<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Antlr4.Runtime</name>
    </assembly>
    <members>
        <member name="T:Antlr4.Runtime.AntlrFileStream">
            <summary>
            This is an
            <see cref="T:Antlr4.Runtime.AntlrInputStream"/>
            that is loaded from a file all at once
            when you construct the object.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.AntlrFileStream.#ctor(System.String)">
            <exception cref="T:System.IO.IOException"/>
        </member>
        <member name="M:Antlr4.Runtime.AntlrFileStream.#ctor(System.String,System.Text.Encoding)">
            <exception cref="T:System.IO.IOException"/>
        </member>
        <member name="M:Antlr4.Runtime.AntlrFileStream.Load(System.String,System.Text.Encoding)">
            <exception cref="T:System.IO.IOException"/>
        </member>
        <member name="T:Antlr4.Runtime.AntlrInputStream">
            <summary>
            Vacuum all input from a
            <see cref="T:System.IO.TextReader"/>
            /
            <see cref="T:System.IO.Stream"/>
            and then treat it
            like a
            <c>char[]</c>
            buffer. Can also pass in a
            <see cref="T:System.String"/>
            or
            <c>char[]</c>
            to use.
            <p>If you need encoding, pass in stream/reader with correct encoding.</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.AntlrInputStream.data">
            <summary>The data being scanned</summary>
        </member>
        <member name="F:Antlr4.Runtime.AntlrInputStream.n">
            <summary>How many characters are actually in the buffer</summary>
        </member>
        <member name="F:Antlr4.Runtime.AntlrInputStream.p">
            <summary>0..n-1 index into string of next char</summary>
        </member>
        <member name="F:Antlr4.Runtime.AntlrInputStream.name">
            <summary>What is name or source of this char stream?</summary>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.#ctor(System.String)">
            <summary>Copy data in string to a local char array</summary>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.#ctor(System.Char[],System.Int32)">
            <summary>This is the preferred constructor for strings as no data is copied</summary>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.#ctor(System.IO.TextReader)">
            <exception cref="T:System.IO.IOException"/>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.#ctor(System.IO.TextReader,System.Int32)">
            <exception cref="T:System.IO.IOException"/>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.#ctor(System.IO.TextReader,System.Int32,System.Int32)">
            <exception cref="T:System.IO.IOException"/>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.#ctor(System.IO.Stream)">
            <exception cref="T:System.IO.IOException"/>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.#ctor(System.IO.Stream,System.Int32)">
            <exception cref="T:System.IO.IOException"/>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.#ctor(System.IO.Stream,System.Int32,System.Int32)">
            <exception cref="T:System.IO.IOException"/>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.Load(System.IO.TextReader,System.Int32,System.Int32)">
            <exception cref="T:System.IO.IOException"/>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.Reset">
            <summary>
            Reset the stream so that it's in the same state it was
            when the object was created *except* the data array is not
            touched.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.AntlrInputStream.Index">
            <summary>
            Return the current input symbol index 0..n where n indicates the
            last symbol has been read.
            </summary>
            <remarks>
            Return the current input symbol index 0..n where n indicates the
            last symbol has been read.  The index is the index of char to
            be returned from LA(1).
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.Mark">
            <summary>mark/release do nothing; we have entire buffer</summary>
        </member>
        <member name="M:Antlr4.Runtime.AntlrInputStream.Seek(System.Int32)">
            <summary>
            consume() ahead until p==index; can't just set p=index as we must
            update line and charPositionInLine.
            </summary>
            <remarks>
            consume() ahead until p==index; can't just set p=index as we must
            update line and charPositionInLine. If we seek backwards, just set p
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.Atn.AbstractPredicateTransition">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Atn.AmbiguityInfo">
            <summary>This class represents profiling event information for an ambiguity.</summary>
            <remarks>
            This class represents profiling event information for an ambiguity.
            Ambiguities are decisions where a particular input resulted in an SLL
            conflict, followed by LL prediction also reaching a conflict state
            (indicating a true ambiguity in the grammar).
            <p>
            This event may be reported during SLL prediction in cases where the
            conflicting SLL configuration set provides sufficient information to
            determine that the SLL conflict is truly an ambiguity. For example, if none
            of the ATN configurations in the conflicting SLL configuration set have
            traversed a global follow transition (i.e.
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.ReachesIntoOuterContext"/>
            is
            <see langword="false"/>
            for all
            configurations), then the result of SLL prediction for that input is known to
            be equivalent to the result of LL prediction for that input.</p>
            <p>
            In some cases, the minimum represented alternative in the conflicting LL
            configuration set is not equal to the minimum represented alternative in the
            conflicting SLL configuration set. Grammars and inputs which result in this
            scenario are unable to use
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Sll"/>
            , which in turn means
            they cannot use the two-stage parsing strategy to improve parsing performance
            for that input.</p>
            </remarks>
            <seealso cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.ReportAmbiguity(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.Dfa.DFAState,System.Int32,System.Int32,System.Boolean,Antlr4.Runtime.Sharpen.BitSet,Antlr4.Runtime.Atn.ATNConfigSet)"/>
            <seealso cref="M:Antlr4.Runtime.IParserErrorListener.ReportAmbiguity(Antlr4.Runtime.Parser,Antlr4.Runtime.Dfa.DFA,System.Int32,System.Int32,System.Boolean,Antlr4.Runtime.Sharpen.BitSet,Antlr4.Runtime.Atn.ATNConfigSet)"/>
            <since>4.3</since>
        </member>
        <member name="F:Antlr4.Runtime.Atn.AmbiguityInfo.ambigAlts">
            <summary>The set of alternative numbers for this decision event that lead to a valid parse.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.AmbiguityInfo.#ctor(System.Int32,Antlr4.Runtime.Atn.SimulatorState,Antlr4.Runtime.Sharpen.BitSet,Antlr4.Runtime.ITokenStream,System.Int32,System.Int32)">
            <summary>
            Constructs a new instance of the
            <see cref="T:Antlr4.Runtime.Atn.AmbiguityInfo"/>
            class with the
            specified detailed ambiguity information.
            </summary>
            <param name="decision">The decision number</param>
            <param name="state">
            The final simulator state identifying the ambiguous
            alternatives for the current input
            </param>
            <param name="ambigAlts">
            The set of alternatives in the decision that lead to a valid parse.
            The predicted alt is the min(ambigAlts)
            </param>
            <param name="input">The input token stream</param>
            <param name="startIndex">The start index for the current prediction</param>
            <param name="stopIndex">
            The index at which the ambiguity was identified during
            prediction
            </param>
        </member>
        <member name="P:Antlr4.Runtime.Atn.AmbiguityInfo.AmbiguousAlternatives">
            <summary>Gets the set of alternatives in the decision that lead to a valid parse.</summary>
            <since>4.5</since>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATN.decisionToState">
            <summary>
            Each subrule/rule is a decision point and we must track them so we
            can go back later and build DFA predictors for them.
            </summary>
            <remarks>
            Each subrule/rule is a decision point and we must track them so we
            can go back later and build DFA predictors for them.  This includes
            all the rules, subrules, optional blocks, ()+, ()* etc...
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATN.ruleToStartState">
            <summary>Maps from rule index to starting state number.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATN.ruleToStopState">
            <summary>Maps from rule index to stop state number.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATN.grammarType">
            <summary>The type of the ATN.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATN.maxTokenType">
            <summary>The maximum value for any symbol recognized by a transition in the ATN.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATN.ruleToTokenType">
            <summary>For lexer ATNs, this maps the rule index to the resulting token type.</summary>
            <remarks>
            For lexer ATNs, this maps the rule index to the resulting token type.
            For parser ATNs, this maps the rule index to the generated bypass token
            type if the
            <see cref="P:Antlr4.Runtime.Atn.ATNDeserializationOptions.GenerateRuleBypassTransitions"/>
            deserialization option was specified; otherwise, this is
            <see langword="null"/>
            .
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATN.lexerActions">
            <summary>
            For lexer ATNs, this is an array of
            <see cref="T:Antlr4.Runtime.Atn.ILexerAction"/>
            objects which may
            be referenced by action transitions in the ATN.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ATN.#ctor(Antlr4.Runtime.Atn.ATNType,System.Int32)">
            <summary>Used for runtime deserialization of ATNs from strings</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ATN.ClearDFA">
            <summary>
            Clears the DFA cached for this ATN.
            </summary>
            <remarks>
            <para>This method is not safe for concurrent use. Since recognizers by default share an <see cref="T:Antlr4.Runtime.Atn.ATN"/>
            instance, all parsing operations by all recognizers using this instance must be stopped before the DFA can
            be safely cleared.</para>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ATN.NextTokens(Antlr4.Runtime.Atn.ATNState,Antlr4.Runtime.Atn.PredictionContext)">
            <summary>
            Compute the set of valid tokens that can occur starting in state
            <paramref name="s"/>
            .
            If
            <paramref name="ctx"/>
            is
            <see cref="F:Antlr4.Runtime.Atn.PredictionContext.EmptyLocal"/>
            , the set of tokens will not include what can follow
            the rule surrounding
            <paramref name="s"/>
            . In other words, the set will be
            restricted to tokens reachable staying within
            <paramref name="s"/>
            's rule.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ATN.NextTokens(Antlr4.Runtime.Atn.ATNState)">
            <summary>
            Compute the set of valid tokens that can occur starting in
            <paramref name="s"/>
            and
            staying in same rule.
            <see cref="F:Antlr4.Runtime.TokenConstants.Epsilon"/>
            is in set if we reach end of
            rule.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ATN.GetExpectedTokens(System.Int32,Antlr4.Runtime.RuleContext)">
            <summary>
            Computes the set of input symbols which could follow ATN state number
            <paramref name="stateNumber"/>
            in the specified full
            <paramref name="context"/>
            . This method
            considers the complete parser context, but does not evaluate semantic
            predicates (i.e. all predicates encountered during the calculation are
            assumed true). If a path in the ATN exists from the starting state to the
            <see cref="T:Antlr4.Runtime.Atn.RuleStopState"/>
            of the outermost context without matching any
            symbols,
            <see cref="F:Antlr4.Runtime.TokenConstants.Eof"/>
            is added to the returned set.
            <p>If
            <paramref name="context"/>
            is
            <see langword="null"/>
            , it is treated as
            <see cref="P:Antlr4.Runtime.ParserRuleContext.EmptyContext"/>
            .</p>
            <p>Note that this does NOT give you the set of all tokens that could
            appear at a given token position in the input phrase.  In other words, it
            does not answer:</p>
            <quote>"Given a specific partial input phrase, return the set of all
            tokens that can follow the last token in the input phrase."</quote>
            <p>The big difference is that with just the input, the parser could land
            right in the middle of a lookahead decision. Getting all
            <em>possible</em> tokens given a partial input stream is a separate
            computation. See https://github.com/antlr/antlr4/issues/1428</p>
            <p>For this function, we are specifying an ATN state and call stack to
            compute what token(s) can come next and specifically: outside of a
            lookahead decision. That is what you want for error reporting and
            recovery upon parse error.</p>
            </summary>
            <param name="stateNumber">the ATN state number</param>
            <param name="context">the full parse context</param>
            <returns>
            The set of potentially valid input symbols which could follow the
            specified state in the specified context.
            </returns>
            <exception cref="T:System.ArgumentException">
            if the ATN does not contain a state with
            number
            <paramref name="stateNumber"/>
            </exception>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ATNConfig">
            <summary>A tuple: (ATN state, predicted alt, syntactic, semantic context).</summary>
            <remarks>
            A tuple: (ATN state, predicted alt, syntactic, semantic context).
            The syntactic context is a graph-structured stack node whose
            path(s) to the root is the rule invocation(s)
            chain used to arrive at the state.  The semantic context is
            the tree of semantic predicates encountered before reaching
            an ATN state.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNConfig.SuppressPrecedenceFilter">
            <summary>
            This field stores the bit mask for implementing the
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.PrecedenceFilterSuppressed"/>
            property as a bit within the
            existing
            <see cref="F:Antlr4.Runtime.Atn.ATNConfig.altAndOuterContextDepth"/>
            field.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNConfig.state">
            <summary>The ATN state associated with this configuration</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNConfig.altAndOuterContextDepth">
            <summary>This is a bit-field currently containing the following values.</summary>
            <remarks>
            This is a bit-field currently containing the following values.
            <ul>
            <li>0x00FFFFFF: Alternative</li>
            <li>0x7F000000: Outer context depth</li>
            <li>0x80000000: Suppress precedence filter</li>
            </ul>
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNConfig.context">
            <summary>
            The stack of invoking states leading to the rule/states associated
            with this config.
            </summary>
            <remarks>
            The stack of invoking states leading to the rule/states associated
            with this config.  We track only those contexts pushed during
            execution of the ATN simulator.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ATNConfig.State">
            <summary>Gets the ATN state associated with this configuration.</summary>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ATNConfig.Alt">
            <summary>What alt (or lexer rule) is predicted by this configuration.</summary>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ATNConfig.OuterContextDepth">
            <summary>
            We cannot execute predicates dependent upon local context unless
            we know for sure we are in the correct context.
            </summary>
            <remarks>
            We cannot execute predicates dependent upon local context unless
            we know for sure we are in the correct context. Because there is
            no way to do this efficiently, we simply cannot evaluate
            dependent predicates unless we are in the rule that initially
            invokes the ATN simulator.
            <p>
            closure() tracks the depth of how far we dip into the outer context:
            depth &gt; 0.  Note that it may not be totally accurate depth since I
            don't ever decrement. TODO: make it a boolean then</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ATNConfig.Equals(System.Object)">
            <summary>
            An ATN configuration is equal to another if both have
            the same state, they predict the same alternative, and
            syntactic/semantic contexts are the same.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ATNConfigSet">
            <author>Sam Harwell</author>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNConfigSet.mergedConfigs">
            <summary>
            This maps (state, alt) -&gt; merged
            <see cref="T:Antlr4.Runtime.Atn.ATNConfig"/>
            . The key does not account for
            the
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.SemanticContext"/>
            of the value, which is only a problem if a single
            <c>ATNConfigSet</c>
            contains two configs with the same state and alternative
            but different semantic contexts. When this case arises, the first config
            added to this map stays, and the remaining configs are placed in
            <see cref="F:Antlr4.Runtime.Atn.ATNConfigSet.unmerged"/>
            .
            <p/>
            This map is only used for optimizing the process of adding configs to the set,
            and is
            <see langword="null"/>
            for read-only sets stored in the DFA.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNConfigSet.unmerged">
            <summary>
            This is an "overflow" list holding configs which cannot be merged with one
            of the configs in
            <see cref="F:Antlr4.Runtime.Atn.ATNConfigSet.mergedConfigs"/>
            but have a colliding key. This
            occurs when two configs in the set have the same state and alternative but
            different semantic contexts.
            <p/>
            This list is only used for optimizing the process of adding configs to the set,
            and is
            <see langword="null"/>
            for read-only sets stored in the DFA.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNConfigSet.configs">
            <summary>This is a list of all configs in this set.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNConfigSet.outermostConfigSet">
            <summary>
            When
            <see langword="true"/>
            , this config set represents configurations where the entire
            outer context has been consumed by the ATN interpreter. This prevents the
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.Closure(Antlr4.Runtime.Atn.ATNConfigSet,Antlr4.Runtime.Atn.ATNConfigSet,System.Boolean,System.Boolean,Antlr4.Runtime.Atn.PredictionContextCache,System.Boolean)"/>
            from pursuing the global FOLLOW when a
            rule stop state is reached with an empty prediction context.
            <p/>
            Note:
            <c>outermostConfigSet</c>
            and
            <see cref="F:Antlr4.Runtime.Atn.ATNConfigSet.dipsIntoOuterContext"/>
            should never
            be true at the same time.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ATNConfigSet.RepresentedAlternatives">
            <summary>
            Get the set of all alternatives represented by configurations in this
            set.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ATNDeserializationOptions">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ATNDeserializer">
            <author>Sam Harwell</author>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNDeserializer.BaseSerializedUuid">
            <summary>This is the earliest supported serialized UUID.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNDeserializer.AddedLexerActions">
            <summary>
            This UUID indicates an extension of
            <see cref="F:Antlr4.Runtime.Atn.ATNDeserializer.BaseSerializedUuid"/>
            for the addition of lexer actions encoded as a sequence of
            <see cref="T:Antlr4.Runtime.Atn.ILexerAction"/>
            instances.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNDeserializer.SupportedUuids">
            <summary>
            This list contains all of the currently supported UUIDs, ordered by when
            the feature first appeared in this branch.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNDeserializer.SerializedUuid">
            <summary>This is the current serialized UUID.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ATNDeserializer.IsFeatureSupported(System.Guid,System.Guid)">
            <summary>
            Determines if a particular serialized representation of an ATN supports
            a particular feature, identified by the
            <see cref="T:System.Guid"/>
            used for serializing
            the ATN at the time the feature was first introduced.
            </summary>
            <param name="feature">
            The
            <see cref="T:System.Guid"/>
            marking the first time the feature was
            supported in the serialized ATN.
            </param>
            <param name="actualUuid">
            The
            <see cref="T:System.Guid"/>
            of the actual serialized ATN which is
            currently being deserialized.
            </param>
            <returns>
            
            <see langword="true"/>
            if the
            <paramref name="actualUuid"/>
            value represents a
            serialized ATN at or after the feature identified by
            <paramref name="feature"/>
            was
            introduced; otherwise,
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ATNDeserializer.MarkPrecedenceDecisions(Antlr4.Runtime.Atn.ATN)">
            <summary>
            Analyze the
            <see cref="T:Antlr4.Runtime.Atn.StarLoopEntryState"/>
            states in the specified ATN to set
            the
            <see cref="F:Antlr4.Runtime.Atn.StarLoopEntryState.precedenceRuleDecision"/>
            field to the
            correct value.
            </summary>
            <param name="atn">The ATN.</param>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ATNSerializer.Serialize">
            <summary>
            Serialize state descriptors, edge descriptors, and decision→state map
            into list of ints:
            grammar-type, (ANTLRParser.LEXER, ...)
            max token type,
            num states,
            state-0-type ruleIndex, state-1-type ruleIndex, ...
            </summary>
            <remarks>
            Serialize state descriptors, edge descriptors, and decision→state map
            into list of ints:
            grammar-type, (ANTLRParser.LEXER, ...)
            max token type,
            num states,
            state-0-type ruleIndex, state-1-type ruleIndex, ... state-i-type ruleIndex optional-arg ...
            num rules,
            rule-1-start-state rule-1-args, rule-2-start-state  rule-2-args, ...
            (args are token type,actionIndex in lexer else 0,0)
            num modes,
            mode-0-start-state, mode-1-start-state, ... (parser has 0 modes)
            num sets
            set-0-interval-count intervals, set-1-interval-count intervals, ...
            num total edges,
            src, trg, edge-type, edge arg1, optional edge arg2 (present always), ...
            num decisions,
            decision-0-start-state, decision-1-start-state, ...
            Convenient to pack into unsigned shorts to make as Java string.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ATNSerializer.GetSerializedAsString(Antlr4.Runtime.Atn.ATN,System.Collections.Generic.IList{System.String})">
            <summary>Used by Java target to encode short/int array as chars in string.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNSimulator.SerializedUuid">
            <summary>This is the current serialized UUID.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNSimulator.Error">
            <summary>Must distinguish between missing edge and edge we know leads nowhere</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ATNSimulator.ClearDFA">
            <summary>Clear the DFA cache used by the current instance.</summary>
            <remarks>
            Clear the DFA cache used by the current instance. Since the DFA cache may
            be shared by multiple ATN simulators, this method may affect the
            performance (but not accuracy) of other parsers which are being used
            concurrently.
            </remarks>
            <exception cref="T:System.NotSupportedException">
            if the current instance does not
            support clearing the DFA.
            </exception>
            <since>4.3</since>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ATNState">
            <summary>
            The following images show the relation of states and
            <see cref="F:Antlr4.Runtime.Atn.ATNState.transitions"/>
            for various grammar constructs.
            <ul>
            <li>Solid edges marked with an &#0949; indicate a required
            <see cref="T:Antlr4.Runtime.Atn.EpsilonTransition"/>
            .</li>
            <li>Dashed edges indicate locations where any transition derived from
            <see cref="M:Antlr4.Runtime.Atn.ATNState.Transition(System.Int32)"/>
            might appear.</li>
            <li>Dashed nodes are place holders for either a sequence of linked
            <see cref="T:Antlr4.Runtime.Atn.BasicState"/>
            states or the inclusion of a block representing a nested
            construct in one of the forms below.</li>
            <li>Nodes showing multiple outgoing alternatives with a
            <c>...</c>
            support
            any number of alternatives (one or more). Nodes without the
            <c>...</c>
            only
            support the exact number of alternatives shown in the diagram.</li>
            </ul>
            <h2>Basic Blocks</h2>
            <h3>Rule</h3>
            <embed src="images/Rule.svg" type="image/svg+xml"/>
            <h3>Block of 1 or more alternatives</h3>
            <embed src="images/Block.svg" type="image/svg+xml"/>
            <h2>Greedy Loops</h2>
            <h3>Greedy Closure:
            <c>(...)*</c>
            </h3>
            <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
            <h3>Greedy Positive Closure:
            <c>(...)+</c>
            </h3>
            <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
            <h3>Greedy Optional:
            <c>(...)?</c>
            </h3>
            <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
            <h2>Non-Greedy Loops</h2>
            <h3>Non-Greedy Closure:
            <c>(...)*?</c>
            </h3>
            <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
            <h3>Non-Greedy Positive Closure:
            <c>(...)+?</c>
            </h3>
            <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
            <h3>Non-Greedy Optional:
            <c>(...)??</c>
            </h3>
            <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNState.atn">
            <summary>Which ATN are we in?</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNState.transitions">
            <summary>Track the transitions emanating from this ATN state.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ATNState.nextTokenWithinRule">
            <summary>Used to cache lookahead during parsing, not used during construction</summary>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ATNState.StateNumber">
            <summary>Gets the state number.</summary>
            <returns>the state number</returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ATNState.NonStopStateNumber">
            <summary>
            For all states except
            <see cref="T:Antlr4.Runtime.Atn.RuleStopState"/>
            , this returns the state
            number. Returns -1 for stop states.
            </summary>
            <returns>
            -1 for
            <see cref="T:Antlr4.Runtime.Atn.RuleStopState"/>
            , otherwise the state number
            </returns>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ATNType">
            <summary>Represents the type of recognizer an ATN applies to.</summary>
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Atn.AtomTransition">
            <summary>TODO: make all transitions sets? no, should remove set edges</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.AtomTransition.label">
            <summary>The token type or character value; or, signifies special label.</summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.BasicBlockStartState">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Atn.BasicState">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Atn.BlockEndState">
            <summary>
            Terminal node of a simple
            <c>(a|b|c)</c>
            block.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.BlockStartState">
            <summary>
            The start of a regular
            <c>(...)</c>
            block.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ConflictInfo">
            <summary>This class stores information about a configuration conflict.</summary>
            <author>Sam Harwell</author>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ConflictInfo.ConflictedAlts">
            <summary>Gets the set of conflicting alternatives for the configuration set.</summary>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ConflictInfo.IsExact">
            <summary>Gets whether or not the configuration conflict is an exact conflict.</summary>
            <remarks>
            Gets whether or not the configuration conflict is an exact conflict.
            An exact conflict occurs when the prediction algorithm determines that
            the represented alternatives for a particular configuration set cannot be
            further reduced by consuming additional input. After reaching an exact
            conflict during an SLL prediction, only switch to full-context prediction
            could reduce the set of viable alternatives. In LL prediction, an exact
            conflict indicates a true ambiguity in the input.
            <p>
            For the
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
            prediction mode,
            accept states are conflicting but not exact are treated as non-accept
            states.</p>
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ContextSensitivityInfo">
            <summary>This class represents profiling event information for a context sensitivity.</summary>
            <remarks>
            This class represents profiling event information for a context sensitivity.
            Context sensitivities are decisions where a particular input resulted in an
            SLL conflict, but LL prediction produced a single unique alternative.
            <p>
            In some cases, the unique alternative identified by LL prediction is not
            equal to the minimum represented alternative in the conflicting SLL
            configuration set. Grammars and inputs which result in this scenario are
            unable to use
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Sll"/>
            , which in turn means they cannot use
            the two-stage parsing strategy to improve parsing performance for that
            input.</p>
            </remarks>
            <seealso cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.ReportContextSensitivity(Antlr4.Runtime.Dfa.DFA,System.Int32,Antlr4.Runtime.Atn.SimulatorState,System.Int32,System.Int32)"/>
            <seealso cref="M:Antlr4.Runtime.IParserErrorListener.ReportContextSensitivity(Antlr4.Runtime.Parser,Antlr4.Runtime.Dfa.DFA,System.Int32,System.Int32,System.Int32,Antlr4.Runtime.Atn.SimulatorState)"/>
            <since>4.3</since>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ContextSensitivityInfo.#ctor(System.Int32,Antlr4.Runtime.Atn.SimulatorState,Antlr4.Runtime.ITokenStream,System.Int32,System.Int32)">
            <summary>
            Constructs a new instance of the
            <see cref="T:Antlr4.Runtime.Atn.ContextSensitivityInfo"/>
            class
            with the specified detailed context sensitivity information.
            </summary>
            <param name="decision">The decision number</param>
            <param name="state">
            The final simulator state containing the unique
            alternative identified by full-context prediction
            </param>
            <param name="input">The input token stream</param>
            <param name="startIndex">The start index for the current prediction</param>
            <param name="stopIndex">
            The index at which the context sensitivity was
            identified during full-context prediction
            </param>
        </member>
        <member name="T:Antlr4.Runtime.Atn.DecisionEventInfo">
            <summary>
            This is the base class for gathering detailed information about prediction
            events which occur during parsing.
            </summary>
            <remarks>
            This is the base class for gathering detailed information about prediction
            events which occur during parsing.
            Note that we could record the parser call stack at the time this event
            occurred but in the presence of left recursive rules, the stack is kind of
            meaningless. It's better to look at the individual configurations for their
            individual stacks. Of course that is a
            <see cref="T:Antlr4.Runtime.Atn.PredictionContext"/>
            object
            not a parse tree node and so it does not have information about the extent
            (start...stop) of the various subtrees. Examining the stack tops of all
            configurations provide the return states for the rule invocations.
            From there you can get the enclosing rule.
            </remarks>
            <since>4.3</since>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionEventInfo.decision">
            <summary>The invoked decision number which this event is related to.</summary>
            <seealso cref="F:Antlr4.Runtime.Atn.ATN.decisionToState"/>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionEventInfo.state">
            <summary>
            The simulator state containing additional information relevant to the
            prediction state when the current event occurred, or
            <see langword="null"/>
            if no
            additional information is relevant or available.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionEventInfo.input">
            <summary>The input token stream which is being parsed.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionEventInfo.startIndex">
            <summary>
            The token index in the input stream at which the current prediction was
            originally invoked.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionEventInfo.stopIndex">
            <summary>The token index in the input stream at which the current event occurred.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionEventInfo.fullCtx">
            <summary>
            <see langword="true"/>
            if the current event occurred during LL prediction;
            otherwise,
            <see langword="false"/>
            if the input occurred during SLL prediction.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.DecisionInfo">
            <summary>This class contains profiling gathered for a particular decision.</summary>
            <remarks>
            This class contains profiling gathered for a particular decision.
            <p>
            Parsing performance in ANTLR 4 is heavily influenced by both static factors
            (e.g. the form of the rules in the grammar) and dynamic factors (e.g. the
            choice of input and the state of the DFA cache at the time profiling
            operations are started). For best results, gather and use aggregate
            statistics from a large sample of inputs representing the inputs expected in
            production before using the results to make changes in the grammar.</p>
            </remarks>
            <since>4.3</since>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.decision">
            <summary>
            The decision number, which is an index into
            <see cref="F:Antlr4.Runtime.Atn.ATN.decisionToState"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.invocations">
            <summary>
            The total number of times
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream,System.Int32,Antlr4.Runtime.ParserRuleContext)"/>
            was
            invoked for this decision.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.timeInPrediction">
            <summary>
            The total time spent in
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream,System.Int32,Antlr4.Runtime.ParserRuleContext)"/>
            for
            this decision, in nanoseconds.
            <p>
            The value of this field is computed by <see cref="T:System.Diagnostics.Stopwatch"/>,
            and is not adjusted to compensate for JIT
            and/or garbage collection overhead. For best accuracy, perform profiling
            in a separate process which is warmed up by parsing the input prior to
            profiling. If desired, call <see cref="M:Antlr4.Runtime.Atn.ATNSimulator.ClearDFA"/>
            to reset the DFA cache to its initial
            state before starting the profiling measurement pass.</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.SLL_TotalLook">
            <summary>The sum of the lookahead required for SLL prediction for this decision.</summary>
            <remarks>
            The sum of the lookahead required for SLL prediction for this decision.
            Note that SLL prediction is used before LL prediction for performance
            reasons even when
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Ll"/>
            or
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
            is used.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.SLL_MinLook">
            <summary>
            Gets the minimum lookahead required for any single SLL prediction to
            complete for this decision, by reaching a unique prediction, reaching an
            SLL conflict state, or encountering a syntax error.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.SLL_MaxLook">
            <summary>
            Gets the maximum lookahead required for any single SLL prediction to
            complete for this decision, by reaching a unique prediction, reaching an
            SLL conflict state, or encountering a syntax error.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.SLL_MaxLookEvent">
            <summary>
            Gets the
            <see cref="T:Antlr4.Runtime.Atn.LookaheadEventInfo"/>
            associated with the event where the
            <see cref="F:Antlr4.Runtime.Atn.DecisionInfo.SLL_MaxLook"/>
            value was set.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.LL_TotalLook">
            <summary>The sum of the lookahead required for LL prediction for this decision.</summary>
            <remarks>
            The sum of the lookahead required for LL prediction for this decision.
            Note that LL prediction is only used when SLL prediction reaches a
            conflict state.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.LL_MinLook">
            <summary>
            Gets the minimum lookahead required for any single LL prediction to
            complete for this decision.
            </summary>
            <remarks>
            Gets the minimum lookahead required for any single LL prediction to
            complete for this decision. An LL prediction completes when the algorithm
            reaches a unique prediction, a conflict state (for
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Ll"/>
            , an ambiguity state (for
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
            , or a syntax error.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.LL_MaxLook">
            <summary>
            Gets the maximum lookahead required for any single LL prediction to
            complete for this decision.
            </summary>
            <remarks>
            Gets the maximum lookahead required for any single LL prediction to
            complete for this decision. An LL prediction completes when the algorithm
            reaches a unique prediction, a conflict state (for
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Ll"/>
            , an ambiguity state (for
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
            , or a syntax error.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.LL_MaxLookEvent">
            <summary>
            Gets the
            <see cref="T:Antlr4.Runtime.Atn.LookaheadEventInfo"/>
            associated with the event where the
            <see cref="F:Antlr4.Runtime.Atn.DecisionInfo.LL_MaxLook"/>
            value was set.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.contextSensitivities">
            <summary>
            A collection of
            <see cref="T:Antlr4.Runtime.Atn.ContextSensitivityInfo"/>
            instances describing the
            context sensitivities encountered during LL prediction for this decision.
            </summary>
            <seealso cref="T:Antlr4.Runtime.Atn.ContextSensitivityInfo"/>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.errors">
            <summary>
            A collection of
            <see cref="T:Antlr4.Runtime.Atn.ErrorInfo"/>
            instances describing the parse errors
            identified during calls to
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream,System.Int32,Antlr4.Runtime.ParserRuleContext)"/>
            for
            this decision.
            </summary>
            <seealso cref="T:Antlr4.Runtime.Atn.ErrorInfo"/>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.ambiguities">
            <summary>
            A collection of
            <see cref="T:Antlr4.Runtime.Atn.AmbiguityInfo"/>
            instances describing the
            ambiguities encountered during LL prediction for this decision.
            </summary>
            <seealso cref="T:Antlr4.Runtime.Atn.AmbiguityInfo"/>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.predicateEvals">
            <summary>
            A collection of
            <see cref="T:Antlr4.Runtime.Atn.PredicateEvalInfo"/>
            instances describing the
            results of evaluating individual predicates during prediction for this
            decision.
            </summary>
            <seealso cref="T:Antlr4.Runtime.Atn.PredicateEvalInfo"/>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.SLL_ATNTransitions">
            <summary>
            The total number of ATN transitions required during SLL prediction for
            this decision.
            </summary>
            <remarks>
            The total number of ATN transitions required during SLL prediction for
            this decision. An ATN transition is determined by the number of times the
            DFA does not contain an edge that is required for prediction, resulting
            in on-the-fly computation of that edge.
            <p>
            If DFA caching of SLL transitions is employed by the implementation, ATN
            computation may cache the computed edge for efficient lookup during
            future parsing of this decision. Otherwise, the SLL parsing algorithm
            will use ATN transitions exclusively.</p>
            </remarks>
            <seealso cref="F:Antlr4.Runtime.Atn.DecisionInfo.SLL_ATNTransitions"/>
            <seealso cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.ComputeTargetState(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.Dfa.DFAState,Antlr4.Runtime.ParserRuleContext,System.Int32,System.Boolean,Antlr4.Runtime.Atn.PredictionContextCache)"/>
            <seealso cref="M:Antlr4.Runtime.Atn.LexerATNSimulator.ComputeTargetState(Antlr4.Runtime.ICharStream,Antlr4.Runtime.Dfa.DFAState,System.Int32)"/>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.SLL_DFATransitions">
            <summary>
            The total number of DFA transitions required during SLL prediction for
            this decision.
            </summary>
            <remarks>
            The total number of DFA transitions required during SLL prediction for
            this decision.
            <p>If the ATN simulator implementation does not use DFA caching for SLL
            transitions, this value will be 0.</p>
            </remarks>
            <seealso cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState,System.Int32)"/>
            <seealso cref="M:Antlr4.Runtime.Atn.LexerATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState,System.Int32)"/>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.LL_Fallback">
            <summary>
            Gets the total number of times SLL prediction completed in a conflict
            state, resulting in fallback to LL prediction.
            </summary>
            <remarks>
            Gets the total number of times SLL prediction completed in a conflict
            state, resulting in fallback to LL prediction.
            <p>Note that this value is not related to whether or not
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Sll"/>
            may be used successfully with a particular
            grammar. If the ambiguity resolution algorithm applied to the SLL
            conflicts for this decision produce the same result as LL prediction for
            this decision,
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Sll"/>
            would produce the same overall
            parsing result as
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Ll"/>
            .</p>
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.LL_ATNTransitions">
            <summary>
            The total number of ATN transitions required during LL prediction for
            this decision.
            </summary>
            <remarks>
            The total number of ATN transitions required during LL prediction for
            this decision. An ATN transition is determined by the number of times the
            DFA does not contain an edge that is required for prediction, resulting
            in on-the-fly computation of that edge.
            <p>
            If DFA caching of LL transitions is employed by the implementation, ATN
            computation may cache the computed edge for efficient lookup during
            future parsing of this decision. Otherwise, the LL parsing algorithm will
            use ATN transitions exclusively.</p>
            </remarks>
            <seealso cref="F:Antlr4.Runtime.Atn.DecisionInfo.LL_DFATransitions"/>
            <seealso cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.ComputeTargetState(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.Dfa.DFAState,Antlr4.Runtime.ParserRuleContext,System.Int32,System.Boolean,Antlr4.Runtime.Atn.PredictionContextCache)"/>
            <seealso cref="M:Antlr4.Runtime.Atn.LexerATNSimulator.ComputeTargetState(Antlr4.Runtime.ICharStream,Antlr4.Runtime.Dfa.DFAState,System.Int32)"/>
        </member>
        <member name="F:Antlr4.Runtime.Atn.DecisionInfo.LL_DFATransitions">
            <summary>
            The total number of DFA transitions required during LL prediction for
            this decision.
            </summary>
            <remarks>
            The total number of DFA transitions required during LL prediction for
            this decision.
            <p>If the ATN simulator implementation does not use DFA caching for LL
            transitions, this value will be 0.</p>
            </remarks>
            <seealso cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState,System.Int32)"/>
            <seealso cref="M:Antlr4.Runtime.Atn.LexerATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState,System.Int32)"/>
        </member>
        <member name="M:Antlr4.Runtime.Atn.DecisionInfo.#ctor(System.Int32)">
            <summary>
            Constructs a new instance of the
            <see cref="T:Antlr4.Runtime.Atn.DecisionInfo"/>
            class to contain
            statistics for a particular decision.
            </summary>
            <param name="decision">The decision number</param>
        </member>
        <member name="P:Antlr4.Runtime.Atn.EpsilonTransition.OutermostPrecedenceReturn">
            <returns>
            the rule index of a precedence rule for which this transition is
            returning from, where the precedence value is 0; otherwise, -1.
            </returns>
            <seealso cref="P:Antlr4.Runtime.Atn.ATNConfig.PrecedenceFilterSuppressed"/>
            <seealso cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.ApplyPrecedenceFilter(Antlr4.Runtime.Atn.ATNConfigSet,Antlr4.Runtime.ParserRuleContext,Antlr4.Runtime.Atn.PredictionContextCache)"></seealso>
            <since>4.4.1</since>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ErrorInfo">
            <summary>
            This class represents profiling event information for a syntax error
            identified during prediction.
            </summary>
            <remarks>
            This class represents profiling event information for a syntax error
            identified during prediction. Syntax errors occur when the prediction
            algorithm is unable to identify an alternative which would lead to a
            successful parse.
            </remarks>
            <seealso cref="M:Antlr4.Runtime.Parser.NotifyErrorListeners(Antlr4.Runtime.IToken,System.String,Antlr4.Runtime.RecognitionException)"/>
            <seealso cref="M:Antlr4.Runtime.IAntlrErrorListener`1.SyntaxError(Antlr4.Runtime.IRecognizer,`0,System.Int32,System.Int32,System.String,Antlr4.Runtime.RecognitionException)"/>
            <since>4.3</since>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ErrorInfo.#ctor(System.Int32,Antlr4.Runtime.Atn.SimulatorState,Antlr4.Runtime.ITokenStream,System.Int32,System.Int32)">
            <summary>
            Constructs a new instance of the
            <see cref="T:Antlr4.Runtime.Atn.ErrorInfo"/>
            class with the
            specified detailed syntax error information.
            </summary>
            <param name="decision">The decision number</param>
            <param name="state">
            The final simulator state reached during prediction
            prior to reaching the
            <see cref="F:Antlr4.Runtime.Atn.ATNSimulator.Error"/>
            state
            </param>
            <param name="input">The input token stream</param>
            <param name="startIndex">The start index for the current prediction</param>
            <param name="stopIndex">The index at which the syntax error was identified</param>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ILexerAction">
            <summary>
            Represents a single action which can be executed following the successful
            match of a lexer rule.
            </summary>
            <remarks>
            Represents a single action which can be executed following the successful
            match of a lexer rule. Lexer actions are used for both embedded action syntax
            and ANTLR 4's new lexer command syntax.
            </remarks>
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ILexerAction.ActionType">
            <summary>Gets the serialization type of the lexer action.</summary>
            <returns>The serialization type of the lexer action.</returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ILexerAction.IsPositionDependent">
            <summary>Gets whether the lexer action is position-dependent.</summary>
            <remarks>
            Gets whether the lexer action is position-dependent. Position-dependent
            actions may have different semantics depending on the
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            index at the time the action is executed.
            <p>Many lexer commands, including
            <c>type</c>
            ,
            <c>skip</c>
            , and
            <c>more</c>
            , do not check the input index during their execution.
            Actions like this are position-independent, and may be stored more
            efficiently as part of the
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.ActionExecutor"/>
            .</p>
            </remarks>
            <returns>
            
            <see langword="true"/>
            if the lexer action semantics can be affected by the
            position of the input
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            at the time it is executed;
            otherwise,
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ILexerAction.Execute(Antlr4.Runtime.Lexer)">
            <summary>
            Execute the lexer action in the context of the specified
            <see cref="T:Antlr4.Runtime.Lexer"/>
            .
            <p>For position-dependent actions, the input stream must already be
            positioned correctly prior to calling this method.</p>
            </summary>
            <param name="lexer">The lexer instance.</param>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerActionExecutor">
            <summary>
            Represents an executor for a sequence of lexer actions which traversed during
            the matching operation of a lexer rule (token).
            </summary>
            <remarks>
            Represents an executor for a sequence of lexer actions which traversed during
            the matching operation of a lexer rule (token).
            <p>The executor tracks position information for position-dependent lexer actions
            efficiently, ensuring that actions appearing only at the end of the rule do
            not cause bloating of the
            <see cref="T:Antlr4.Runtime.Dfa.DFA"/>
            created for the lexer.</p>
            </remarks>
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="F:Antlr4.Runtime.Atn.LexerActionExecutor.hashCode">
            <summary>
            Caches the result of
            <see cref="F:Antlr4.Runtime.Atn.LexerActionExecutor.hashCode"/>
            since the hash code is an element
            of the performance-critical
            <see cref="M:Antlr4.Runtime.Atn.ATNConfig.GetHashCode"/>
            operation.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerActionExecutor.#ctor(Antlr4.Runtime.Atn.ILexerAction[])">
            <summary>
            Constructs an executor for a sequence of
            <see cref="T:Antlr4.Runtime.Atn.ILexerAction"/>
            actions.
            </summary>
            <param name="lexerActions">The lexer actions to execute.</param>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerActionExecutor.Append(Antlr4.Runtime.Atn.LexerActionExecutor,Antlr4.Runtime.Atn.ILexerAction)">
            <summary>
            Creates a
            <see cref="T:Antlr4.Runtime.Atn.LexerActionExecutor"/>
            which executes the actions for
            the input
            <paramref name="lexerActionExecutor"/>
            followed by a specified
            <paramref name="lexerAction"/>
            .
            </summary>
            <param name="lexerActionExecutor">
            The executor for actions already traversed by
            the lexer while matching a token within a particular
            <see cref="T:Antlr4.Runtime.Atn.ATNConfig"/>
            . If this is
            <see langword="null"/>
            , the method behaves as though
            it were an empty executor.
            </param>
            <param name="lexerAction">
            The lexer action to execute after the actions
            specified in
            <paramref name="lexerActionExecutor"/>
            .
            </param>
            <returns>
            A
            <see cref="T:Antlr4.Runtime.Atn.LexerActionExecutor"/>
            for executing the combine actions
            of
            <paramref name="lexerActionExecutor"/>
            and
            <paramref name="lexerAction"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerActionExecutor.FixOffsetBeforeMatch(System.Int32)">
            <summary>
            Creates a
            <see cref="T:Antlr4.Runtime.Atn.LexerActionExecutor"/>
            which encodes the current offset
            for position-dependent lexer actions.
            <p>Normally, when the executor encounters lexer actions where
            <see cref="P:Antlr4.Runtime.Atn.ILexerAction.IsPositionDependent"/>
            returns
            <see langword="true"/>
            , it calls
            <see cref="M:Antlr4.Runtime.IIntStream.Seek(System.Int32)"/>
            on the input
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            to set the input
            position to the <em>end</em> of the current token. This behavior provides
            for efficient DFA representation of lexer actions which appear at the end
            of a lexer rule, even when the lexer rule matches a variable number of
            characters.</p>
            <p>Prior to traversing a match transition in the ATN, the current offset
            from the token start index is assigned to all position-dependent lexer
            actions which have not already been assigned a fixed offset. By storing
            the offsets relative to the token start index, the DFA representation of
            lexer actions which appear in the middle of tokens remains efficient due
            to sharing among tokens of the same length, regardless of their absolute
            position in the input stream.</p>
            <p>If the current executor already has offsets assigned to all
            position-dependent lexer actions, the method returns
            <c>this</c>
            .</p>
            </summary>
            <param name="offset">
            The current offset to assign to all position-dependent
            lexer actions which do not already have offsets assigned.
            </param>
            <returns>
            A
            <see cref="T:Antlr4.Runtime.Atn.LexerActionExecutor"/>
            which stores input stream offsets
            for all position-dependent lexer actions.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerActionExecutor.LexerActions">
            <summary>Gets the lexer actions to be executed by this executor.</summary>
            <returns>The lexer actions to be executed by this executor.</returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerActionExecutor.Execute(Antlr4.Runtime.Lexer,Antlr4.Runtime.ICharStream,System.Int32)">
            <summary>
            Execute the actions encapsulated by this executor within the context of a
            particular
            <see cref="T:Antlr4.Runtime.Lexer"/>
            .
            <p>This method calls
            <see cref="M:Antlr4.Runtime.IIntStream.Seek(System.Int32)"/>
            to set the position of the
            <paramref name="input"/>
            
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            prior to calling
            <see cref="M:Antlr4.Runtime.Atn.ILexerAction.Execute(Antlr4.Runtime.Lexer)"/>
            on a position-dependent action. Before the
            method returns, the input position will be restored to the same position
            it was in when the method was invoked.</p>
            </summary>
            <param name="lexer">The lexer instance.</param>
            <param name="input">
            The input stream which is the source for the current token.
            When this method is called, the current
            <see cref="P:Antlr4.Runtime.IIntStream.Index"/>
            for
            <paramref name="input"/>
            should be the start of the following token, i.e. 1
            character past the end of the current token.
            </param>
            <param name="startIndex">
            The token start index. This value may be passed to
            <see cref="M:Antlr4.Runtime.IIntStream.Seek(System.Int32)"/>
            to set the
            <paramref name="input"/>
            position to the beginning
            of the token.
            </param>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerActionType">
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerATNSimulator">
            <summary>"dup" of ParserInterpreter</summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerATNSimulator.SimState">
            <summary>
            When we hit an accept state in either the DFA or the ATN, we
            have to notify the character stream to start buffering characters
            via
            <see cref="M:Antlr4.Runtime.IIntStream.Mark"/>
            and record the current state. The current sim state
            includes the current index into the input, the current line,
            and current character position in that line. Note that the Lexer is
            tracking the starting line and characterization of the token. These
            variables track the "state" of the simulator when it hits an accept state.
            <p>We track these variables separately for the DFA and ATN simulation
            because the DFA simulation often has to fail over to the ATN
            simulation. If the ATN simulation fails, we need the DFA to fall
            back to its previously accepted state, if any. If the ATN succeeds,
            then the ATN does the accept and the DFA simulator that invoked it
            can simply return the predicted token type.</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.LexerATNSimulator.startIndex">
            <summary>The current token's starting index into the character stream.</summary>
            <remarks>
            The current token's starting index into the character stream.
            Shared across DFA to ATN simulation in case the ATN fails and the
            DFA did not have a previous accept state. In this case, we use the
            ATN-generated exception object.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.LexerATNSimulator.line">
            <summary>line number 1..n within the input</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.LexerATNSimulator.charPositionInLine">
            <summary>The index of the character relative to the beginning of the line 0..n-1</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.LexerATNSimulator.prevAccept">
            <summary>Used during DFA/ATN exec to record the most recent accept configuration info</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState,System.Int32)">
            <summary>Get an existing target state for an edge in the DFA.</summary>
            <remarks>
            Get an existing target state for an edge in the DFA. If the target state
            for the edge has not yet been computed or is otherwise not available,
            this method returns
            <see langword="null"/>
            .
            </remarks>
            <param name="s">The current DFA state</param>
            <param name="t">The next input symbol</param>
            <returns>
            The existing target DFA state for the given input symbol
            <paramref name="t"/>
            , or
            <see langword="null"/>
            if the target state for this edge is not
            already cached
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerATNSimulator.ComputeTargetState(Antlr4.Runtime.ICharStream,Antlr4.Runtime.Dfa.DFAState,System.Int32)">
            <summary>
            Compute a target state for an edge in the DFA, and attempt to add the
            computed state and corresponding edge to the DFA.
            </summary>
            <param name="input">The input stream</param>
            <param name="s">The current DFA state</param>
            <param name="t">The next input symbol</param>
            <returns>
            The computed target DFA state for the given input symbol
            <paramref name="t"/>
            . If
            <paramref name="t"/>
            does not lead to a valid DFA state, this method
            returns
            <see cref="F:Antlr4.Runtime.Atn.ATNSimulator.Error"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerATNSimulator.GetReachableConfigSet(Antlr4.Runtime.ICharStream,Antlr4.Runtime.Atn.ATNConfigSet,Antlr4.Runtime.Atn.ATNConfigSet,System.Int32)">
            <summary>
            Given a starting configuration set, figure out all ATN configurations
            we can reach upon input
            <paramref name="t"/>
            . Parameter
            <paramref name="reach"/>
            is a return
            parameter.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerATNSimulator.Closure(Antlr4.Runtime.ICharStream,Antlr4.Runtime.Atn.ATNConfig,Antlr4.Runtime.Atn.ATNConfigSet,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Since the alternatives within any lexer decision are ordered by
            preference, this method stops pursuing the closure as soon as an accept
            state is reached.
            </summary>
            <remarks>
            Since the alternatives within any lexer decision are ordered by
            preference, this method stops pursuing the closure as soon as an accept
            state is reached. After the first accept state is reached by depth-first
            search from
            <paramref name="config"/>
            , all other (potentially reachable) states for
            this rule would have a lower priority.
            </remarks>
            <returns>
            
            <see langword="true"/>
            if an accept state is reached, otherwise
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerATNSimulator.EvaluatePredicate(Antlr4.Runtime.ICharStream,System.Int32,System.Int32,System.Boolean)">
            <summary>Evaluate a predicate specified in the lexer.</summary>
            <remarks>
            Evaluate a predicate specified in the lexer.
            <p>If
            <paramref name="speculative"/>
            is
            <see langword="true"/>
            , this method was called before
            <see cref="M:Antlr4.Runtime.Atn.LexerATNSimulator.Consume(Antlr4.Runtime.ICharStream)"/>
            for the matched character. This method should call
            <see cref="M:Antlr4.Runtime.Atn.LexerATNSimulator.Consume(Antlr4.Runtime.ICharStream)"/>
            before evaluating the predicate to ensure position
            sensitive values, including
            <see cref="P:Antlr4.Runtime.Lexer.Text"/>
            ,
            <see cref="P:Antlr4.Runtime.Lexer.Line"/>
            ,
            and
            <see cref="P:Antlr4.Runtime.Lexer.Column"/>
            , properly reflect the current
            lexer state. This method should restore
            <paramref name="input"/>
            and the simulator
            to the original state before returning (i.e. undo the actions made by the
            call to
            <see cref="M:Antlr4.Runtime.Atn.LexerATNSimulator.Consume(Antlr4.Runtime.ICharStream)"/>
            .</p>
            </remarks>
            <param name="input">The input stream.</param>
            <param name="ruleIndex">The rule containing the predicate.</param>
            <param name="predIndex">The index of the predicate within the rule.</param>
            <param name="speculative">
            
            <see langword="true"/>
            if the current index in
            <paramref name="input"/>
            is
            one character before the predicate's location.
            </param>
            <returns>
            
            <see langword="true"/>
            if the specified predicate evaluates to
            <see langword="true"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerATNSimulator.AddDFAState(Antlr4.Runtime.Atn.ATNConfigSet)">
            <summary>
            Add a new DFA state if there isn't one with this set of
            configurations already.
            </summary>
            <remarks>
            Add a new DFA state if there isn't one with this set of
            configurations already. This method also detects the first
            configuration containing an ATN rule stop state. Later, when
            traversing the DFA, we will know which rule to accept.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerATNSimulator.GetText(Antlr4.Runtime.ICharStream)">
            <summary>Get the text matched so far for the current token.</summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerChannelAction">
            <summary>
            Implements the
            <c>channel</c>
            lexer action by calling
            <see cref="P:Antlr4.Runtime.Lexer.Channel"/>
            with the assigned channel.
            </summary>
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerChannelAction.#ctor(System.Int32)">
            <summary>
            Constructs a new
            <paramref name="channel"/>
            action with the specified channel value.
            </summary>
            <param name="channel">
            The channel value to pass to
            <see cref="P:Antlr4.Runtime.Lexer.Channel"/>
            .
            </param>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerChannelAction.Channel">
            <summary>
            Gets the channel to use for the
            <see cref="T:Antlr4.Runtime.IToken"/>
            created by the lexer.
            </summary>
            <returns>
            The channel to use for the
            <see cref="T:Antlr4.Runtime.IToken"/>
            created by the lexer.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerChannelAction.ActionType">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see cref="F:Antlr4.Runtime.Atn.LexerActionType.Channel"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerChannelAction.IsPositionDependent">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerChannelAction.Execute(Antlr4.Runtime.Lexer)">
            <summary>
            <inheritDoc/>
            <p>This action is implemented by calling
            <see cref="P:Antlr4.Runtime.Lexer.Channel"/>
            with the
            value provided by
            <see cref="P:Antlr4.Runtime.Atn.LexerChannelAction.Channel"/>
            .</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerCustomAction">
            <summary>
            Executes a custom lexer action by calling
            <see cref="M:Antlr4.Runtime.Recognizer`2.Action(Antlr4.Runtime.RuleContext,System.Int32,System.Int32)"/>
            with the
            rule and action indexes assigned to the custom action. The implementation of
            a custom action is added to the generated code for the lexer in an override
            of
            <see cref="M:Antlr4.Runtime.Recognizer`2.Action(Antlr4.Runtime.RuleContext,System.Int32,System.Int32)"/>
            when the grammar is compiled.
            <p>This class may represent embedded actions created with the <code>{...}</code>
            syntax in ANTLR 4, as well as actions created for lexer commands where the
            command argument could not be evaluated when the grammar was compiled.</p>
            </summary>
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerCustomAction.#ctor(System.Int32,System.Int32)">
            <summary>
            Constructs a custom lexer action with the specified rule and action
            indexes.
            </summary>
            <param name="ruleIndex">
            The rule index to use for calls to
            <see cref="M:Antlr4.Runtime.Recognizer`2.Action(Antlr4.Runtime.RuleContext,System.Int32,System.Int32)"/>
            .
            </param>
            <param name="actionIndex">
            The action index to use for calls to
            <see cref="M:Antlr4.Runtime.Recognizer`2.Action(Antlr4.Runtime.RuleContext,System.Int32,System.Int32)"/>
            .
            </param>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerCustomAction.RuleIndex">
            <summary>
            Gets the rule index to use for calls to
            <see cref="M:Antlr4.Runtime.Recognizer`2.Action(Antlr4.Runtime.RuleContext,System.Int32,System.Int32)"/>
            .
            </summary>
            <returns>The rule index for the custom action.</returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerCustomAction.ActionIndex">
            <summary>
            Gets the action index to use for calls to
            <see cref="M:Antlr4.Runtime.Recognizer`2.Action(Antlr4.Runtime.RuleContext,System.Int32,System.Int32)"/>
            .
            </summary>
            <returns>The action index for the custom action.</returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerCustomAction.ActionType">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see cref="F:Antlr4.Runtime.Atn.LexerActionType.Custom"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerCustomAction.IsPositionDependent">
            <summary>Gets whether the lexer action is position-dependent.</summary>
            <remarks>
            Gets whether the lexer action is position-dependent. Position-dependent
            actions may have different semantics depending on the
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            index at the time the action is executed.
            <p>Custom actions are position-dependent since they may represent a
            user-defined embedded action which makes calls to methods like
            <see cref="P:Antlr4.Runtime.Lexer.Text"/>
            .</p>
            </remarks>
            <returns>
            This method returns
            <see langword="true"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerCustomAction.Execute(Antlr4.Runtime.Lexer)">
            <summary>
            <inheritDoc/>
            <p>Custom actions are implemented by calling
            <see cref="M:Antlr4.Runtime.Recognizer`2.Action(Antlr4.Runtime.RuleContext,System.Int32,System.Int32)"/>
            with the
            appropriate rule and action indexes.</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerIndexedCustomAction">
            <summary>
            This implementation of
            <see cref="T:Antlr4.Runtime.Atn.ILexerAction"/>
            is used for tracking input offsets
            for position-dependent actions within a
            <see cref="T:Antlr4.Runtime.Atn.LexerActionExecutor"/>
            .
            <p>This action is not serialized as part of the ATN, and is only required for
            position-dependent lexer actions which appear at a location other than the
            end of a rule. For more information about DFA optimizations employed for
            lexer actions, see
            <see cref="M:Antlr4.Runtime.Atn.LexerActionExecutor.Append(Antlr4.Runtime.Atn.LexerActionExecutor,Antlr4.Runtime.Atn.ILexerAction)"/>
            and
            <see cref="M:Antlr4.Runtime.Atn.LexerActionExecutor.FixOffsetBeforeMatch(System.Int32)"/>
            .</p>
            </summary>
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerIndexedCustomAction.#ctor(System.Int32,Antlr4.Runtime.Atn.ILexerAction)">
            <summary>
            Constructs a new indexed custom action by associating a character offset
            with a
            <see cref="T:Antlr4.Runtime.Atn.ILexerAction"/>
            .
            <p>Note: This class is only required for lexer actions for which
            <see cref="P:Antlr4.Runtime.Atn.ILexerAction.IsPositionDependent"/>
            returns
            <see langword="true"/>
            .</p>
            </summary>
            <param name="offset">
            The offset into the input
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            , relative to
            the token start index, at which the specified lexer action should be
            executed.
            </param>
            <param name="action">
            The lexer action to execute at a particular offset in the
            input
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            .
            </param>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerIndexedCustomAction.Offset">
            <summary>
            Gets the location in the input
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            at which the lexer
            action should be executed. The value is interpreted as an offset relative
            to the token start index.
            </summary>
            <returns>
            The location in the input
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            at which the lexer
            action should be executed.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerIndexedCustomAction.Action">
            <summary>Gets the lexer action to execute.</summary>
            <returns>
            A
            <see cref="T:Antlr4.Runtime.Atn.ILexerAction"/>
            object which executes the lexer action.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerIndexedCustomAction.ActionType">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns the result of calling
            <see cref="P:Antlr4.Runtime.Atn.LexerIndexedCustomAction.ActionType"/>
            on the
            <see cref="T:Antlr4.Runtime.Atn.ILexerAction"/>
            returned by
            <see cref="P:Antlr4.Runtime.Atn.LexerIndexedCustomAction.Action"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerIndexedCustomAction.IsPositionDependent">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see langword="true"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerIndexedCustomAction.Execute(Antlr4.Runtime.Lexer)">
            <summary>
            <inheritDoc/>
            <p>This method calls
            <see cref="M:Antlr4.Runtime.Atn.LexerIndexedCustomAction.Execute(Antlr4.Runtime.Lexer)"/>
            on the result of
            <see cref="P:Antlr4.Runtime.Atn.LexerIndexedCustomAction.Action"/>
            using the provided
            <paramref name="lexer"/>
            .</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerModeAction">
            <summary>
            Implements the
            <c>mode</c>
            lexer action by calling
            <see cref="M:Antlr4.Runtime.Lexer.Mode(System.Int32)"/>
            with
            the assigned mode.
            </summary>
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerModeAction.#ctor(System.Int32)">
            <summary>
            Constructs a new
            <paramref name="mode"/>
            action with the specified mode value.
            </summary>
            <param name="mode">
            The mode value to pass to
            <see cref="M:Antlr4.Runtime.Lexer.Mode(System.Int32)"/>
            .
            </param>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerModeAction.Mode">
            <summary>Get the lexer mode this action should transition the lexer to.</summary>
            <returns>
            The lexer mode for this
            <c>mode</c>
            command.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerModeAction.ActionType">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see cref="F:Antlr4.Runtime.Atn.LexerActionType.Mode"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerModeAction.IsPositionDependent">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerModeAction.Execute(Antlr4.Runtime.Lexer)">
            <summary>
            <inheritDoc/>
            <p>This action is implemented by calling
            <see cref="M:Antlr4.Runtime.Lexer.Mode(System.Int32)"/>
            with the
            value provided by
            <see cref="P:Antlr4.Runtime.Atn.LexerModeAction.Mode"/>
            .</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerMoreAction">
            <summary>
            Implements the
            <c>more</c>
            lexer action by calling
            <see cref="M:Antlr4.Runtime.Lexer.More"/>
            .
            <p>The
            <c>more</c>
            command does not have any parameters, so this action is
            implemented as a singleton instance exposed by
            <see cref="F:Antlr4.Runtime.Atn.LexerMoreAction.Instance"/>
            .</p>
            </summary>
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="F:Antlr4.Runtime.Atn.LexerMoreAction.Instance">
            <summary>Provides a singleton instance of this parameterless lexer action.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerMoreAction.#ctor">
            <summary>
            Constructs the singleton instance of the lexer
            <c>more</c>
            command.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerMoreAction.ActionType">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see cref="F:Antlr4.Runtime.Atn.LexerActionType.More"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerMoreAction.IsPositionDependent">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerMoreAction.Execute(Antlr4.Runtime.Lexer)">
            <summary>
            <inheritDoc/>
            <p>This action is implemented by calling
            <see cref="M:Antlr4.Runtime.Lexer.More"/>
            .</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerPopModeAction">
            <summary>
            Implements the
            <c>popMode</c>
            lexer action by calling
            <see cref="M:Antlr4.Runtime.Lexer.PopMode"/>
            .
            <p>The
            <c>popMode</c>
            command does not have any parameters, so this action is
            implemented as a singleton instance exposed by
            <see cref="F:Antlr4.Runtime.Atn.LexerPopModeAction.Instance"/>
            .</p>
            </summary>
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="F:Antlr4.Runtime.Atn.LexerPopModeAction.Instance">
            <summary>Provides a singleton instance of this parameterless lexer action.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerPopModeAction.#ctor">
            <summary>
            Constructs the singleton instance of the lexer
            <c>popMode</c>
            command.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerPopModeAction.ActionType">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see cref="F:Antlr4.Runtime.Atn.LexerActionType.PopMode"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerPopModeAction.IsPositionDependent">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerPopModeAction.Execute(Antlr4.Runtime.Lexer)">
            <summary>
            <inheritDoc/>
            <p>This action is implemented by calling
            <see cref="M:Antlr4.Runtime.Lexer.PopMode"/>
            .</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerPushModeAction">
            <summary>
            Implements the
            <c>pushMode</c>
            lexer action by calling
            <see cref="M:Antlr4.Runtime.Lexer.PushMode(System.Int32)"/>
            with the assigned mode.
            </summary>
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerPushModeAction.#ctor(System.Int32)">
            <summary>
            Constructs a new
            <c>pushMode</c>
            action with the specified mode value.
            </summary>
            <param name="mode">
            The mode value to pass to
            <see cref="M:Antlr4.Runtime.Lexer.PushMode(System.Int32)"/>
            .
            </param>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerPushModeAction.Mode">
            <summary>Get the lexer mode this action should transition the lexer to.</summary>
            <returns>
            The lexer mode for this
            <c>pushMode</c>
            command.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerPushModeAction.ActionType">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see cref="F:Antlr4.Runtime.Atn.LexerActionType.PushMode"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerPushModeAction.IsPositionDependent">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerPushModeAction.Execute(Antlr4.Runtime.Lexer)">
            <summary>
            <inheritDoc/>
            <p>This action is implemented by calling
            <see cref="M:Antlr4.Runtime.Lexer.PushMode(System.Int32)"/>
            with the
            value provided by
            <see cref="P:Antlr4.Runtime.Atn.LexerPushModeAction.Mode"/>
            .</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerSkipAction">
            <summary>
            Implements the
            <c>skip</c>
            lexer action by calling
            <see cref="M:Antlr4.Runtime.Lexer.Skip"/>
            .
            <p>The
            <c>skip</c>
            command does not have any parameters, so this action is
            implemented as a singleton instance exposed by
            <see cref="F:Antlr4.Runtime.Atn.LexerSkipAction.Instance"/>
            .</p>
            </summary>
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="F:Antlr4.Runtime.Atn.LexerSkipAction.Instance">
            <summary>Provides a singleton instance of this parameterless lexer action.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerSkipAction.#ctor">
            <summary>
            Constructs the singleton instance of the lexer
            <c>skip</c>
            command.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerSkipAction.ActionType">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see cref="F:Antlr4.Runtime.Atn.LexerActionType.Skip"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerSkipAction.IsPositionDependent">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerSkipAction.Execute(Antlr4.Runtime.Lexer)">
            <summary>
            <inheritDoc/>
            <p>This action is implemented by calling
            <see cref="M:Antlr4.Runtime.Lexer.Skip"/>
            .</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LexerTypeAction">
            <summary>
            Implements the
            <c>type</c>
            lexer action by calling
            <see cref="P:Antlr4.Runtime.Lexer.Type"/>
            with the assigned type.
            </summary>
            <author>Sam Harwell</author>
            <since>4.2</since>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerTypeAction.#ctor(System.Int32)">
            <summary>
            Constructs a new
            <paramref name="type"/>
            action with the specified token type value.
            </summary>
            <param name="type">
            The type to assign to the token using
            <see cref="P:Antlr4.Runtime.Lexer.Type"/>
            .
            </param>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerTypeAction.Type">
            <summary>Gets the type to assign to a token created by the lexer.</summary>
            <returns>The type to assign to a token created by the lexer.</returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerTypeAction.ActionType">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see cref="F:Antlr4.Runtime.Atn.LexerActionType.Type"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LexerTypeAction.IsPositionDependent">
            <summary><inheritDoc/></summary>
            <returns>
            This method returns
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LexerTypeAction.Execute(Antlr4.Runtime.Lexer)">
            <summary>
            <inheritDoc/>
            <p>This action is implemented by calling
            <see cref="P:Antlr4.Runtime.Lexer.Type"/>
            with the
            value provided by
            <see cref="P:Antlr4.Runtime.Atn.LexerTypeAction.Type"/>
            .</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.LL1Analyzer.HitPred">
            <summary>
            Special value added to the lookahead sets to indicate that we hit
            a predicate during analysis if
            <c>seeThruPreds==false</c>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LL1Analyzer.GetDecisionLookahead(Antlr4.Runtime.Atn.ATNState)">
            <summary>
            Calculates the SLL(1) expected lookahead set for each outgoing transition
            of an
            <see cref="T:Antlr4.Runtime.Atn.ATNState"/>
            . The returned array has one element for each
            outgoing transition in
            <paramref name="s"/>
            . If the closure from transition
            <em>i</em> leads to a semantic predicate before matching a symbol, the
            element at index <em>i</em> of the result will be
            <see langword="null"/>
            .
            </summary>
            <param name="s">the ATN state</param>
            <returns>
            the expected symbols for each outgoing transition of
            <paramref name="s"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LL1Analyzer.Look(Antlr4.Runtime.Atn.ATNState,Antlr4.Runtime.Atn.PredictionContext)">
            <summary>
            Compute set of tokens that can follow
            <paramref name="s"/>
            in the ATN in the
            specified
            <paramref name="ctx"/>
            .
            <p>If
            <paramref name="ctx"/>
            is
            <see langword="null"/>
            and the end of the rule containing
            <paramref name="s"/>
            is reached,
            <see cref="F:Antlr4.Runtime.TokenConstants.Epsilon"/>
            is added to the result set.
            If
            <paramref name="ctx"/>
            is not
            <see langword="null"/>
            and the end of the outermost rule is
            reached,
            <see cref="F:Antlr4.Runtime.TokenConstants.Eof"/>
            is added to the result set.</p>
            </summary>
            <param name="s">the ATN state</param>
            <param name="ctx">
            the complete parser context, or
            <see langword="null"/>
            if the context
            should be ignored
            </param>
            <returns>
            The set of tokens that can follow
            <paramref name="s"/>
            in the ATN in the
            specified
            <paramref name="ctx"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LL1Analyzer.Look(Antlr4.Runtime.Atn.ATNState,Antlr4.Runtime.Atn.ATNState,Antlr4.Runtime.Atn.PredictionContext)">
            <summary>
            Compute set of tokens that can follow
            <paramref name="s"/>
            in the ATN in the
            specified
            <paramref name="ctx"/>
            .
            <p>If
            <paramref name="ctx"/>
            is
            <see langword="null"/>
            and the end of the rule containing
            <paramref name="s"/>
            is reached,
            <see cref="F:Antlr4.Runtime.TokenConstants.Epsilon"/>
            is added to the result set.
            If
            <paramref name="ctx"/>
            is not
            <c>PredictionContext#EMPTY_LOCAL</c>
            and the end of the outermost rule is
            reached,
            <see cref="F:Antlr4.Runtime.TokenConstants.Eof"/>
            is added to the result set.</p>
            </summary>
            <param name="s">the ATN state</param>
            <param name="stopState">
            the ATN state to stop at. This can be a
            <see cref="T:Antlr4.Runtime.Atn.BlockEndState"/>
            to detect epsilon paths through a closure.
            </param>
            <param name="ctx">
            the complete parser context, or
            <see langword="null"/>
            if the context
            should be ignored
            </param>
            <returns>
            The set of tokens that can follow
            <paramref name="s"/>
            in the ATN in the
            specified
            <paramref name="ctx"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LL1Analyzer.Look(Antlr4.Runtime.Atn.ATNState,Antlr4.Runtime.Atn.ATNState,Antlr4.Runtime.Atn.PredictionContext,Antlr4.Runtime.Misc.IntervalSet,System.Collections.Generic.HashSet{Antlr4.Runtime.Atn.ATNConfig},Antlr4.Runtime.Sharpen.BitSet,System.Boolean,System.Boolean)">
            <summary>
            Compute set of tokens that can follow
            <paramref name="s"/>
            in the ATN in the
            specified
            <paramref name="ctx"/>
            .
            <p/>
            If
            <paramref name="ctx"/>
            is
            <see cref="F:Antlr4.Runtime.Atn.PredictionContext.EmptyLocal"/>
            and
            <paramref name="stopState"/>
            or the end of the rule containing
            <paramref name="s"/>
            is reached,
            <see cref="F:Antlr4.Runtime.TokenConstants.Epsilon"/>
            is added to the result set. If
            <paramref name="ctx"/>
            is not
            <see cref="F:Antlr4.Runtime.Atn.PredictionContext.EmptyLocal"/>
            and
            <paramref name="addEOF"/>
            is
            <see langword="true"/>
            and
            <paramref name="stopState"/>
            or the end of the outermost rule is reached,
            <see cref="F:Antlr4.Runtime.TokenConstants.Eof"/>
            is added to the result set.
            </summary>
            <param name="s">the ATN state.</param>
            <param name="stopState">
            the ATN state to stop at. This can be a
            <see cref="T:Antlr4.Runtime.Atn.BlockEndState"/>
            to detect epsilon paths through a closure.
            </param>
            <param name="ctx">
            The outer context, or
            <see cref="F:Antlr4.Runtime.Atn.PredictionContext.EmptyLocal"/>
            if
            the outer context should not be used.
            </param>
            <param name="look">The result lookahead set.</param>
            <param name="lookBusy">
            A set used for preventing epsilon closures in the ATN
            from causing a stack overflow. Outside code should pass
            <c>new HashSet&lt;ATNConfig&gt;</c>
            for this argument.
            </param>
            <param name="calledRuleStack">
            A set used for preventing left recursion in the
            ATN from causing a stack overflow. Outside code should pass
            <c>new BitSet()</c>
            for this argument.
            </param>
            <param name="seeThruPreds">
            
            <see langword="true"/>
            to true semantic predicates as
            implicitly
            <see langword="true"/>
            and "see through them", otherwise
            <see langword="false"/>
            to treat semantic predicates as opaque and add
            <see cref="F:Antlr4.Runtime.Atn.LL1Analyzer.HitPred"/>
            to the
            result if one is encountered.
            </param>
            <param name="addEOF">
            Add
            <see cref="F:Antlr4.Runtime.TokenConstants.Eof"/>
            to the result if the end of the
            outermost context is reached. This parameter has no effect if
            <paramref name="ctx"/>
            is
            <see cref="F:Antlr4.Runtime.Atn.PredictionContext.EmptyLocal"/>
            .
            </param>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LookaheadEventInfo">
            <summary>
            This class represents profiling event information for tracking the lookahead
            depth required in order to make a prediction.
            </summary>
            <since>4.3</since>
        </member>
        <member name="M:Antlr4.Runtime.Atn.LookaheadEventInfo.#ctor(System.Int32,Antlr4.Runtime.Atn.SimulatorState,System.Int32,Antlr4.Runtime.ITokenStream,System.Int32,System.Int32,System.Boolean)">
            <summary>
            Constructs a new instance of the
            <see cref="T:Antlr4.Runtime.Atn.LookaheadEventInfo"/>
            class with
            the specified detailed lookahead information.
            </summary>
            <param name="decision">The decision number</param>
            <param name="state">
            The final simulator state containing the necessary
            information to determine the result of a prediction, or
            <see langword="null"/>
            if
            the final state is not available
            </param>
            <param name="predictedAlt">The alternative chosen by
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream,System.Int32,Antlr4.Runtime.ParserRuleContext)"/>.</param>
            <param name="input">The input token stream</param>
            <param name="startIndex">The start index for the current prediction</param>
            <param name="stopIndex">The index at which the prediction was finally made</param>
            <param name="fullCtx">
            
            <see langword="true"/>
            if the current lookahead is part of an LL
            prediction; otherwise,
            <see langword="false"/>
            if the current lookahead is part of
            an SLL prediction
            </param>
        </member>
        <member name="P:Antlr4.Runtime.Atn.LookaheadEventInfo.PredictedAlternative">
            <summary>
            The alternative chosen by adaptivePredict(), not necessarily
            the outermost alt shown for a rule; left-recursive rules have
            user-level alts that differ from the rewritten rule with a (...) block
            and a (..)* loop.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.LoopEndState">
            <summary>Mark the end of a * or + loop.</summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.OrderedATNConfigSet">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ParseInfo">
            <summary>
            This class provides access to specific and aggregate statistics gathered
            during profiling of a parser.
            </summary>
            <since>4.3</since>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ParseInfo.DecisionInfo">
            <summary>
            Gets an array of
            <see cref="P:Antlr4.Runtime.Atn.ParseInfo.DecisionInfo"/>
            instances containing the profiling
            information gathered for each decision in the ATN.
            </summary>
            <returns>
            An array of
            <see cref="P:Antlr4.Runtime.Atn.ParseInfo.DecisionInfo"/>
            instances, indexed by decision
            number.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParseInfo.GetLLDecisions">
            <summary>
            Gets the decision numbers for decisions that required one or more
            full-context predictions during parsing.
            </summary>
            <remarks>
            Gets the decision numbers for decisions that required one or more
            full-context predictions during parsing. These are decisions for which
            <see cref="F:Antlr4.Runtime.Atn.DecisionInfo.LL_Fallback"/>
            is non-zero.
            </remarks>
            <returns>
            A list of decision numbers which required one or more
            full-context predictions during parsing.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParseInfo.GetTotalTimeInPrediction">
            <summary>
            Gets the total time spent during prediction across all decisions made
            during parsing.
            </summary>
            <remarks>
            Gets the total time spent during prediction across all decisions made
            during parsing. This value is the sum of
            <see cref="F:Antlr4.Runtime.Atn.DecisionInfo.timeInPrediction"/>
            for all decisions.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParseInfo.GetTotalSLLLookaheadOps">
            <summary>
            Gets the total number of SLL lookahead operations across all decisions
            made during parsing.
            </summary>
            <remarks>
            Gets the total number of SLL lookahead operations across all decisions
            made during parsing. This value is the sum of
            <see cref="F:Antlr4.Runtime.Atn.DecisionInfo.SLL_TotalLook"/>
            for all decisions.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParseInfo.GetTotalLLLookaheadOps">
            <summary>
            Gets the total number of LL lookahead operations across all decisions
            made during parsing.
            </summary>
            <remarks>
            Gets the total number of LL lookahead operations across all decisions
            made during parsing. This value is the sum of
            <see cref="F:Antlr4.Runtime.Atn.DecisionInfo.LL_TotalLook"/>
            for all decisions.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParseInfo.GetTotalSLLATNLookaheadOps">
            <summary>
            Gets the total number of ATN lookahead operations for SLL prediction
            across all decisions made during parsing.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParseInfo.GetTotalLLATNLookaheadOps">
            <summary>
            Gets the total number of ATN lookahead operations for LL prediction
            across all decisions made during parsing.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParseInfo.GetTotalATNLookaheadOps">
            <summary>
            Gets the total number of ATN lookahead operations for SLL and LL
            prediction across all decisions made during parsing.
            </summary>
            <remarks>
            Gets the total number of ATN lookahead operations for SLL and LL
            prediction across all decisions made during parsing.
            <p>
            This value is the sum of
            <see cref="M:Antlr4.Runtime.Atn.ParseInfo.GetTotalSLLATNLookaheadOps"/>
            and
            <see cref="M:Antlr4.Runtime.Atn.ParseInfo.GetTotalLLATNLookaheadOps"/>
            .</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParseInfo.GetDFASize">
            <summary>
            Gets the total number of DFA states stored in the DFA cache for all
            decisions in the ATN.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParseInfo.GetDFASize(System.Int32)">
            <summary>
            Gets the total number of DFA states stored in the DFA cache for a
            particular decision.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ParserATNSimulator">
            <summary>The embodiment of the adaptive LL(*), ALL(*), parsing strategy.</summary>
            <remarks>
            The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
            <p>
            The basic complexity of the adaptive strategy makes it harder to understand.
            We begin with ATN simulation to build paths in a DFA. Subsequent prediction
            requests go through the DFA first. If they reach a state without an edge for
            the current symbol, the algorithm fails over to the ATN simulation to
            complete the DFA path for the current input (until it finds a conflict state
            or uniquely predicting state).</p>
            <p>
            All of that is done without using the outer context because we want to create
            a DFA that is not dependent upon the rule invocation stack when we do a
            prediction. One DFA works in all contexts. We avoid using context not
            necessarily because it's slower, although it can be, but because of the DFA
            caching problem. The closure routine only considers the rule invocation stack
            created during prediction beginning in the decision rule. For example, if
            prediction occurs without invoking another rule's ATN, there are no context
            stacks in the configurations. When lack of context leads to a conflict, we
            don't know if it's an ambiguity or a weakness in the strong LL(*) parsing
            strategy (versus full LL(*)).</p>
            <p>
            When SLL yields a configuration set with conflict, we rewind the input and
            retry the ATN simulation, this time using full outer context without adding
            to the DFA. Configuration context stacks will be the full invocation stacks
            from the start rule. If we get a conflict using full context, then we can
            definitively say we have a true ambiguity for that input sequence. If we
            don't get a conflict, it implies that the decision is sensitive to the outer
            context. (It is not context-sensitive in the sense of context-sensitive
            grammars.)</p>
            <p>
            The next time we reach this DFA state with an SLL conflict, through DFA
            simulation, we will again retry the ATN simulation using full context mode.
            This is slow because we can't save the results and have to "interpret" the
            ATN each time we get that input.</p>
            <p>
            <strong>CACHING FULL CONTEXT PREDICTIONS</strong></p>
            <p>
            We could cache results from full context to predicted alternative easily and
            that saves a lot of time but doesn't work in presence of predicates. The set
            of visible predicates from the ATN start state changes depending on the
            context, because closure can fall off the end of a rule. I tried to cache
            tuples (stack context, semantic context, predicted alt) but it was slower
            than interpreting and much more complicated. Also required a huge amount of
            memory. The goal is not to create the world's fastest parser anyway. I'd like
            to keep this algorithm simple. By launching multiple threads, we can improve
            the speed of parsing across a large number of files.</p>
            <p>
            There is no strict ordering between the amount of input used by SLL vs LL,
            which makes it really hard to build a cache for full context. Let's say that
            we have input A B C that leads to an SLL conflict with full context X. That
            implies that using X we might only use A B but we could also use A B C D to
            resolve conflict. Input A B C D could predict alternative 1 in one position
            in the input and A B C E could predict alternative 2 in another position in
            input. The conflicting SLL configurations could still be non-unique in the
            full context prediction, which would lead us to requiring more input than the
            original A B C.	To make a	prediction cache work, we have to track	the exact
            input	used during the previous prediction. That amounts to a cache that maps
            X to a specific DFA for that context.</p>
            <p>
            Something should be done for left-recursive expression predictions. They are
            likely LL(1) + pred eval. Easier to do the whole SLL unless error and retry
            with full LL thing Sam does.</p>
            <p>
            <strong>AVOIDING FULL CONTEXT PREDICTION</strong></p>
            <p>
            We avoid doing full context retry when the outer context is empty, we did not
            dip into the outer context by falling off the end of the decision state rule,
            or when we force SLL mode.</p>
            <p>
            As an example of the not dip into outer context case, consider as super
            constructor calls versus function calls. One grammar might look like
            this:</p>
            <pre>
            ctorBody
            : '{' superCall? stat* '}'
            ;
            </pre>
            <p>
            Or, you might see something like</p>
            <pre>
            stat
            : superCall ';'
            | expression ';'
            | ...
            ;
            </pre>
            <p>
            In both cases I believe that no closure operations will dip into the outer
            context. In the first case ctorBody in the worst case will stop at the '}'.
            In the 2nd case it should stop at the ';'. Both cases should stay within the
            entry rule and not dip into the outer context.</p>
            <p>
            <strong>PREDICATES</strong></p>
            <p>
            Predicates are always evaluated if present in either SLL or LL both. SLL and
            LL simulation deals with predicates differently. SLL collects predicates as
            it performs closure operations like ANTLR v3 did. It delays predicate
            evaluation until it reaches and accept state. This allows us to cache the SLL
            ATN simulation whereas, if we had evaluated predicates on-the-fly during
            closure, the DFA state configuration sets would be different and we couldn't
            build up a suitable DFA.</p>
            <p>
            When building a DFA accept state during ATN simulation, we evaluate any
            predicates and return the sole semantically valid alternative. If there is
            more than 1 alternative, we report an ambiguity. If there are 0 alternatives,
            we throw an exception. Alternatives without predicates act like they have
            true predicates. The simple way to think about it is to strip away all
            alternatives with false predicates and choose the minimum alternative that
            remains.</p>
            <p>
            When we start in the DFA and reach an accept state that's predicated, we test
            those and return the minimum semantically viable alternative. If no
            alternatives are viable, we throw an exception.</p>
            <p>
            During full LL ATN simulation, closure always evaluates predicates and
            on-the-fly. This is crucial to reducing the configuration set size during
            closure. It hits a landmine when parsing with the Java grammar, for example,
            without this on-the-fly evaluation.</p>
            <p>
            <strong>SHARING DFA</strong></p>
            <p>
            All instances of the same parser share the same decision DFAs through a
            static field. Each instance gets its own ATN simulator but they share the
            same
            <see cref="F:Antlr4.Runtime.Atn.ATN.decisionToDFA"/>
            field. They also share a
            <see cref="T:Antlr4.Runtime.Atn.PredictionContextCache"/>
            object that makes sure that all
            <see cref="T:Antlr4.Runtime.Atn.PredictionContext"/>
            objects are shared among the DFA states. This makes
            a big size difference.</p>
            <p>
            <strong>THREAD SAFETY</strong></p>
            <p>
            The
            <see cref="T:Antlr4.Runtime.Atn.ParserATNSimulator"/>
            locks on the
            <see cref="F:Antlr4.Runtime.Atn.ATN.decisionToDFA"/>
            field when
            it adds a new DFA object to that array.
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAEdge(Antlr4.Runtime.Dfa.DFAState,System.Int32,Antlr4.Runtime.Dfa.DFAState)"/>
            locks on the DFA for the current decision when setting the
            <see cref="F:Antlr4.Runtime.Dfa.DFAState.edges"/>
            field.
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAState(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.Atn.ATNConfigSet,Antlr4.Runtime.Atn.PredictionContextCache)"/>
            locks on
            the DFA for the current decision when looking up a DFA state to see if it
            already exists. We must make sure that all requests to add DFA states that
            are equivalent result in the same shared DFA object. This is because lots of
            threads will be trying to update the DFA at once. The
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAState(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.Atn.ATNConfigSet,Antlr4.Runtime.Atn.PredictionContextCache)"/>
            method also locks inside the DFA lock
            but this time on the shared context cache when it rebuilds the
            configurations'
            <see cref="T:Antlr4.Runtime.Atn.PredictionContext"/>
            objects using cached
            subgraphs/nodes. No other locking occurs, even during DFA simulation. This is
            safe as long as we can guarantee that all threads referencing
            <c>s.edge[t]</c>
            get the same physical target
            <see cref="T:Antlr4.Runtime.Dfa.DFAState"/>
            , or
            <see langword="null"/>
            . Once into the DFA, the DFA simulation does not reference the
            <see cref="F:Antlr4.Runtime.Dfa.DFA.states"/>
            map. It follows the
            <see cref="F:Antlr4.Runtime.Dfa.DFAState.edges"/>
            field to new
            targets. The DFA simulator will either find
            <see cref="F:Antlr4.Runtime.Dfa.DFAState.edges"/>
            to be
            <see langword="null"/>
            , to be non-
            <see langword="null"/>
            and
            <c>dfa.edges[t]</c>
            null, or
            <c>dfa.edges[t]</c>
            to be non-null. The
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAEdge(Antlr4.Runtime.Dfa.DFAState,System.Int32,Antlr4.Runtime.Dfa.DFAState)"/>
            method could be racing to set the field
            but in either case the DFA simulator works; if
            <see langword="null"/>
            , and requests ATN
            simulation. It could also race trying to get
            <c>dfa.edges[t]</c>
            , but either
            way it will work because it's not doing a test and set operation.</p>
            <p>
            <strong>Starting with SLL then failing to combined SLL/LL (Two-Stage
            Parsing)</strong></p>
            <p>
            Sam pointed out that if SLL does not give a syntax error, then there is no
            point in doing full LL, which is slower. We only have to try LL if we get a
            syntax error. For maximum speed, Sam starts the parser set to pure SLL
            mode with the
            <see cref="T:Antlr4.Runtime.BailErrorStrategy"/>
            :</p>
            <pre>
            parser.
            <see cref="P:Antlr4.Runtime.Recognizer`2.Interpreter">getInterpreter()</see>
            .
            <see cref="P:Antlr4.Runtime.Atn.ParserATNSimulator.PredictionMode"/>
            <c>(</c>
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Sll"/>
            <c>)</c>
            ;
            parser.
            <see cref="P:Antlr4.Runtime.Parser.ErrorHandler"/>
            (new
            <see cref="T:Antlr4.Runtime.BailErrorStrategy"/>
            ());
            </pre>
            <p>
            If it does not get a syntax error, then we're done. If it does get a syntax
            error, we need to retry with the combined SLL/LL strategy.</p>
            <p>
            The reason this works is as follows. If there are no SLL conflicts, then the
            grammar is SLL (at least for that input set). If there is an SLL conflict,
            the full LL analysis must yield a set of viable alternatives which is a
            subset of the alternatives reported by SLL. If the LL set is a singleton,
            then the grammar is LL but not SLL. If the LL set is the same size as the SLL
            set, the decision is SLL. If the LL set has size &gt; 1, then that decision
            is truly ambiguous on the current input. If the LL set is smaller, then the
            SLL conflict resolution might choose an alternative that the full LL would
            rule out as a possibility based upon better context information. If that's
            the case, then the SLL parse will definitely get an error because the full LL
            analysis says it's not viable. If SLL conflict resolution chooses an
            alternative within the LL set, them both SLL and LL would choose the same
            alternative because they both choose the minimum of multiple conflicting
            alternatives.</p>
            <p>
            Let's say we have a set of SLL conflicting alternatives
            <c/>
            
            1, 2, 3}} and
            a smaller LL set called <em>s</em>. If <em>s</em> is
            <c/>
            
            2, 3}}, then SLL
            parsing will get an error because SLL will pursue alternative 1. If
            <em>s</em> is
            <c/>
            
            1, 2}} or
            <c/>
            
            1, 3}} then both SLL and LL will
            choose the same alternative because alternative one is the minimum of either
            set. If <em>s</em> is
            <c/>
            
            2}} or
            <c/>
            
            3}} then SLL will get a syntax
            error. If <em>s</em> is
            <c/>
            
            1}} then SLL will succeed.</p>
            <p>
            Of course, if the input is invalid, then we will get an error for sure in
            both SLL and LL parsing. Erroneous input will therefore require 2 passes over
            the input.</p>
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ParserATNSimulator.enable_global_context_dfa">
            <summary>Determines whether the DFA is used for full-context predictions.</summary>
            <remarks>
            Determines whether the DFA is used for full-context predictions. When
            <see langword="true"/>
            , the DFA stores transition information for both full-context
            and SLL parsing; otherwise, the DFA only stores SLL transition
            information.
            <p>
            For some grammars, enabling the full-context DFA can result in a
            substantial performance improvement. However, this improvement typically
            comes at the expense of memory used for storing the cached DFA states,
            configuration sets, and prediction contexts.</p>
            <p>
            The default value is
            <see langword="false"/>
            .</p>
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ParserATNSimulator.reportAmbiguities">
            <summary>
            When
            <see langword="true"/>
            , ambiguous alternatives are reported when they are
            encountered within
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.ExecATN(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.ITokenStream,System.Int32,Antlr4.Runtime.Atn.SimulatorState)"/>
            . When
            <see langword="false"/>
            , these messages
            are suppressed. The default is
            <see langword="false"/>
            .
            <p/>
            When messages about ambiguous alternatives are not required, setting this
            to
            <see langword="false"/>
            enables additional internal optimizations which may lose
            this information.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ParserATNSimulator.userWantsCtxSensitive">
            <summary>
            By default we do full context-sensitive LL(*) parsing not
            Strong LL(*) parsing.
            </summary>
            <remarks>
            By default we do full context-sensitive LL(*) parsing not
            Strong LL(*) parsing. If we fail with Strong LL(*) we
            try full LL(*). That means we rewind and use context information
            when closure operations fall off the end of the rule that
            holds the decision were evaluating.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.#ctor(Antlr4.Runtime.Atn.ATN)">
            <summary>Testing only!</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.IsAcceptState(Antlr4.Runtime.Dfa.DFAState,System.Boolean)">
            <summary>
            Determines if a particular DFA state should be treated as an accept state
            for the current prediction mode.
            </summary>
            <remarks>
            Determines if a particular DFA state should be treated as an accept state
            for the current prediction mode. In addition to the
            <paramref name="useContext"/>
            parameter, the
            <see cref="P:Antlr4.Runtime.Atn.ParserATNSimulator.PredictionMode"/>
            method provides the
            prediction mode controlling the prediction algorithm as a whole.
            <p>
            The default implementation simply returns the value of
            <see cref="P:Antlr4.Runtime.Dfa.DFAState.IsAcceptState"/>
            except for conflict states when
            <paramref name="useContext"/>
            is
            <see langword="true"/>
            and
            <see cref="P:Antlr4.Runtime.Atn.ParserATNSimulator.PredictionMode"/>
            is
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
            . In that case, only
            conflict states where
            <see cref="P:Antlr4.Runtime.Atn.ATNConfigSet.IsExactConflict"/>
            is
            <see langword="true"/>
            are considered accept states.
            </p>
            </remarks>
            <param name="state">The DFA state to check.</param>
            <param name="useContext">
            
            <see langword="true"/>
            if the prediction algorithm is currently
            considering the full parser context; otherwise,
            <see langword="false"/>
            if the
            algorithm is currently performing a local context prediction.
            </param>
            <returns>
            
            <see langword="true"/>
            if the specified
            <paramref name="state"/>
            is an accept state;
            otherwise,
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.ExecATN(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.ITokenStream,System.Int32,Antlr4.Runtime.Atn.SimulatorState)">
            <summary>
            Performs ATN simulation to compute a predicted alternative based
            upon the remaining input, but also updates the DFA cache to avoid
            having to traverse the ATN again for the same input sequence.
            </summary>
            <remarks>
            Performs ATN simulation to compute a predicted alternative based
            upon the remaining input, but also updates the DFA cache to avoid
            having to traverse the ATN again for the same input sequence.
            There are some key conditions we're looking for after computing a new
            set of ATN configs (proposed DFA state):
            if the set is empty, there is no viable alternative for current symbol
            does the state uniquely predict an alternative?
            does the state have a conflict that would prevent us from
            putting it on the work list?
            if in non-greedy decision is there a config at a rule stop state?
            We also have some key operations to do:
            add an edge from previous DFA state to potentially new DFA state, D,
            upon current symbol but only if adding to work list, which means in all
            cases except no viable alternative (and possibly non-greedy decisions?)
            collecting predicates and adding semantic context to DFA accept states
            adding rule context to context-sensitive DFA accept states
            consuming an input symbol
            reporting a conflict
            reporting an ambiguity
            reporting a context sensitivity
            reporting insufficient predicates
            We should isolate those operations, which are side-effecting, to the
            main work loop. We can isolate lots of code into other functions, but
            they should be side effect free. They can return package that
            indicates whether we should report something, whether we need to add a
            DFA edge, whether we need to augment accept state with semantic
            context or rule invocation context. Actually, it seems like we always
            add predicates if they exist, so that can simply be done in the main
            loop for any accept state creation or modification request.
            cover these cases:
            dead end
            single alt
            single alt + preds
            conflict
            conflict + preds
            TODO: greedy + those
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.HandleNoViableAlt(Antlr4.Runtime.ITokenStream,System.Int32,Antlr4.Runtime.Atn.SimulatorState)">
            <summary>
            This method is used to improve the localization of error messages by
            choosing an alternative rather than throwing a
            <see cref="T:Antlr4.Runtime.NoViableAltException"/>
            in particular prediction scenarios where the
            <see cref="F:Antlr4.Runtime.Atn.ATNSimulator.Error"/>
            state was reached during ATN simulation.
            <p>
            The default implementation of this method uses the following
            algorithm to identify an ATN configuration which successfully parsed the
            decision entry rule. Choosing such an alternative ensures that the
            <see cref="T:Antlr4.Runtime.ParserRuleContext"/>
            returned by the calling rule will be complete
            and valid, and the syntax error will be reported later at a more
            localized location.</p>
            <ul>
            <li>If no configuration in
            <c>configs</c>
            reached the end of the
            decision rule, return
            <see cref="F:Antlr4.Runtime.Atn.ATN.InvalidAltNumber"/>
            .</li>
            <li>If all configurations in
            <c>configs</c>
            which reached the end of the
            decision rule predict the same alternative, return that alternative.</li>
            <li>If the configurations in
            <c>configs</c>
            which reached the end of the
            decision rule predict multiple alternatives (call this <em>S</em>),
            choose an alternative in the following order.
            <ol>
            <li>Filter the configurations in
            <c>configs</c>
            to only those
            configurations which remain viable after evaluating semantic predicates.
            If the set of these filtered configurations which also reached the end of
            the decision rule is not empty, return the minimum alternative
            represented in this set.</li>
            <li>Otherwise, choose the minimum alternative in <em>S</em>.</li>
            </ol>
            </li>
            </ul>
            <p>
            In some scenarios, the algorithm described above could predict an
            alternative which will result in a
            <see cref="T:Antlr4.Runtime.FailedPredicateException"/>
            in
            parser. Specifically, this could occur if the <em>only</em> configuration
            capable of successfully parsing to the end of the decision rule is
            blocked by a semantic predicate. By choosing this alternative within
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream,System.Int32,Antlr4.Runtime.ParserRuleContext)"/>
            instead of throwing a
            <see cref="T:Antlr4.Runtime.NoViableAltException"/>
            , the resulting
            <see cref="T:Antlr4.Runtime.FailedPredicateException"/>
            in the parser will identify the specific
            predicate which is preventing the parser from successfully parsing the
            decision rule, which helps developers identify and correct logic errors
            in semantic predicates.
            </p>
            </summary>
            <param name="input">
            The input
            <see cref="T:Antlr4.Runtime.ITokenStream"/>
            </param>
            <param name="startIndex">
            The start index for the current prediction, which is
            the input index where any semantic context in
            <c>configs</c>
            should be
            evaluated
            </param>
            <param name="previous">
            The ATN simulation state immediately before the
            <see cref="F:Antlr4.Runtime.Atn.ATNSimulator.Error"/>
            state was reached
            </param>
            <returns>
            The value to return from
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream,System.Int32,Antlr4.Runtime.ParserRuleContext)"/>
            , or
            <see cref="F:Antlr4.Runtime.Atn.ATN.InvalidAltNumber"/>
            if a suitable alternative was not
            identified and
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AdaptivePredict(Antlr4.Runtime.ITokenStream,System.Int32,Antlr4.Runtime.ParserRuleContext)"/>
            should report an error instead.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.GetExistingTargetState(Antlr4.Runtime.Dfa.DFAState,System.Int32)">
            <summary>Get an existing target state for an edge in the DFA.</summary>
            <remarks>
            Get an existing target state for an edge in the DFA. If the target state
            for the edge has not yet been computed or is otherwise not available,
            this method returns
            <see langword="null"/>
            .
            </remarks>
            <param name="s">The current DFA state</param>
            <param name="t">The next input symbol</param>
            <returns>
            The existing target DFA state for the given input symbol
            <paramref name="t"/>
            , or
            <see langword="null"/>
            if the target state for this edge is not
            already cached
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.ComputeTargetState(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.Dfa.DFAState,Antlr4.Runtime.ParserRuleContext,System.Int32,System.Boolean,Antlr4.Runtime.Atn.PredictionContextCache)">
            <summary>
            Compute a target state for an edge in the DFA, and attempt to add the
            computed state and corresponding edge to the DFA.
            </summary>
            <param name="dfa"/>
            <param name="s">The current DFA state</param>
            <param name="remainingGlobalContext"/>
            <param name="t">The next input symbol</param>
            <param name="useContext"/>
            <param name="contextCache"/>
            <returns>
            The computed target DFA state for the given input symbol
            <paramref name="t"/>
            . If
            <paramref name="t"/>
            does not lead to a valid DFA state, this method
            returns
            <see cref="F:Antlr4.Runtime.Atn.ATNSimulator.Error"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.RemoveAllConfigsNotInRuleStopState(Antlr4.Runtime.Atn.ATNConfigSet,Antlr4.Runtime.Atn.PredictionContextCache)">
            <summary>
            Return a configuration set containing only the configurations from
            <paramref name="configs"/>
            which are in a
            <see cref="T:Antlr4.Runtime.Atn.RuleStopState"/>
            . If all
            configurations in
            <paramref name="configs"/>
            are already in a rule stop state, this
            method simply returns
            <paramref name="configs"/>
            .
            </summary>
            <param name="configs">the configuration set to update</param>
            <param name="contextCache">
            the
            <see cref="T:Antlr4.Runtime.Atn.PredictionContext"/>
            cache
            </param>
            <returns>
            
            <paramref name="configs"/>
            if all configurations in
            <paramref name="configs"/>
            are in a
            rule stop state, otherwise return a new configuration set containing only
            the configurations from
            <paramref name="configs"/>
            which are in a rule stop state
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.ApplyPrecedenceFilter(Antlr4.Runtime.Atn.ATNConfigSet,Antlr4.Runtime.ParserRuleContext,Antlr4.Runtime.Atn.PredictionContextCache)">
            <summary>
            This method transforms the start state computed by
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.ComputeStartState(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.ParserRuleContext,System.Boolean)"/>
            to the special start state used by a
            precedence DFA for a particular precedence value. The transformation
            process applies the following changes to the start state's configuration
            set.
            <ol>
            <li>Evaluate the precedence predicates for each configuration using
            <see cref="M:Antlr4.Runtime.Atn.SemanticContext.EvalPrecedence``2(Antlr4.Runtime.Recognizer{``0,``1},Antlr4.Runtime.RuleContext)"/>
            .</li>
            <li>When
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.PrecedenceFilterSuppressed"/>
            is
            <see langword="false"/>
            ,
            remove all configurations which predict an alternative greater than 1,
            for which another configuration that predicts alternative 1 is in the
            same ATN state with the same prediction context. This transformation is
            valid for the following reasons:
            <ul>
            <li>The closure block cannot contain any epsilon transitions which bypass
            the body of the closure, so all states reachable via alternative 1 are
            part of the precedence alternatives of the transformed left-recursive
            rule.</li>
            <li>The "primary" portion of a left recursive rule cannot contain an
            epsilon transition, so the only way an alternative other than 1 can exist
            in a state that is also reachable via alternative 1 is by nesting calls
            to the left-recursive rule, with the outer calls not being at the
            preferred precedence level. The
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.PrecedenceFilterSuppressed"/>
            property marks ATN
            configurations which do not meet this condition, and therefore are not
            eligible for elimination during the filtering process.</li>
            </ul>
            </li>
            </ol>
            <p>
            The prediction context must be considered by this filter to address
            situations like the following.
            </p>
            <code>
            <pre>
            grammar TA;
            prog: statement* EOF;
            statement: letterA | statement letterA 'b' ;
            letterA: 'a';
            </pre>
            </code>
            <p>
            If the above grammar, the ATN state immediately before the token
            reference
            <c>'a'</c>
            in
            <c>letterA</c>
            is reachable from the left edge
            of both the primary and closure blocks of the left-recursive rule
            <c>statement</c>
            . The prediction context associated with each of these
            configurations distinguishes between them, and prevents the alternative
            which stepped out to
            <c>prog</c>
            (and then back in to
            <c>statement</c>
            from being eliminated by the filter.
            </p>
            </summary>
            <param name="configs">
            The configuration set computed by
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.ComputeStartState(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.ParserRuleContext,System.Boolean)"/>
            as the start state for the DFA.
            </param>
            <returns>
            The transformed configuration set representing the start state
            for a precedence DFA at a particular precedence level (determined by
            calling
            <see cref="P:Antlr4.Runtime.Parser.Precedence"/>
            ).
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.PredicateDFAState(Antlr4.Runtime.Dfa.DFAState,Antlr4.Runtime.Atn.ATNConfigSet,System.Int32)">
            <summary>collect and set D's semantic context</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.EvalSemanticContext(Antlr4.Runtime.Dfa.DFAState.PredPrediction[],Antlr4.Runtime.ParserRuleContext,System.Boolean)">
            <summary>
            Look through a list of predicate/alt pairs, returning alts for the
            pairs that win.
            </summary>
            <remarks>
            Look through a list of predicate/alt pairs, returning alts for the
            pairs that win. A
            <see langword="null"/>
            predicate indicates an alt containing an
            unpredicated config which behaves as "always true."
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.EvalSemanticContext(Antlr4.Runtime.Atn.SemanticContext,Antlr4.Runtime.ParserRuleContext,System.Int32)">
            <summary>Evaluate a semantic context within a specific parser context.</summary>
            <remarks>
            Evaluate a semantic context within a specific parser context.
            <p>
            This method might not be called for every semantic context evaluated
            during the prediction process. In particular, we currently do not
            evaluate the following but it may change in the future:</p>
            <ul>
            <li>Precedence predicates (represented by
            <see cref="T:Antlr4.Runtime.Atn.SemanticContext.PrecedencePredicate"/>
            ) are not currently evaluated
            through this method.</li>
            <li>Operator predicates (represented by
            <see cref="T:Antlr4.Runtime.Atn.SemanticContext.AND"/>
            and
            <see cref="T:Antlr4.Runtime.Atn.SemanticContext.OR"/>
            ) are evaluated as a single semantic
            context, rather than evaluating the operands individually.
            Implementations which require evaluation results from individual
            predicates should override this method to explicitly handle evaluation of
            the operands within operator predicates.</li>
            </ul>
            </remarks>
            <param name="pred">The semantic context to evaluate</param>
            <param name="parserCallStack">
            The parser context in which to evaluate the
            semantic context
            </param>
            <param name="alt">
            The alternative which is guarded by
            <paramref name="pred"/>
            </param>
            <since>4.3</since>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAContextState(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.Atn.ATNConfigSet,System.Int32,Antlr4.Runtime.Atn.PredictionContextCache)">
            <summary>See comment on LexerInterpreter.addDFAState.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAState(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.Atn.ATNConfigSet,Antlr4.Runtime.Atn.PredictionContextCache)">
            <summary>See comment on LexerInterpreter.addDFAState.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.ParserATNSimulator.ReportAmbiguity(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.Dfa.DFAState,System.Int32,System.Int32,System.Boolean,Antlr4.Runtime.Sharpen.BitSet,Antlr4.Runtime.Atn.ATNConfigSet)">
            <summary>If context sensitive parsing, we know it's ambiguity not conflict</summary>
        </member>
        <member name="P:Antlr4.Runtime.Atn.ParserATNSimulator.Parser">
            <since>4.3</since>
        </member>
        <member name="T:Antlr4.Runtime.Atn.PlusBlockStartState">
            <summary>
            Start of
            <c>(A|B|...)+</c>
            loop. Technically a decision state, but
            we don't use for code generation; somebody might need it, so I'm defining
            it for completeness. In reality, the
            <see cref="T:Antlr4.Runtime.Atn.PlusLoopbackState"/>
            node is the
            real decision-making note for
            <c>A+</c>
            .
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.PlusLoopbackState">
            <summary>
            Decision state for
            <c>A+</c>
            and
            <c>(A|B)+</c>
            .  It has two transitions:
            one to the loop back to start of the block and one to exit.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.PrecedencePredicateTransition">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Atn.PredicateEvalInfo">
            <summary>
            This class represents profiling event information for semantic predicate
            evaluations which occur during prediction.
            </summary>
            <seealso cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.EvalSemanticContext(Antlr4.Runtime.Dfa.DFAState.PredPrediction[],Antlr4.Runtime.ParserRuleContext,System.Boolean)"/>
            <since>4.3</since>
        </member>
        <member name="F:Antlr4.Runtime.Atn.PredicateEvalInfo.semctx">
            <summary>The semantic context which was evaluated.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.PredicateEvalInfo.predictedAlt">
            <summary>
            The alternative number for the decision which is guarded by the semantic
            context
            <see cref="F:Antlr4.Runtime.Atn.PredicateEvalInfo.semctx"/>
            . Note that other ATN
            configurations may predict the same alternative which are guarded by
            other semantic contexts and/or
            <see cref="F:Antlr4.Runtime.Atn.SemanticContext.None"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.PredicateEvalInfo.evalResult">
            <summary>
            The result of evaluating the semantic context
            <see cref="F:Antlr4.Runtime.Atn.PredicateEvalInfo.semctx"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredicateEvalInfo.#ctor(Antlr4.Runtime.Atn.SimulatorState,System.Int32,Antlr4.Runtime.ITokenStream,System.Int32,System.Int32,Antlr4.Runtime.Atn.SemanticContext,System.Boolean,System.Int32)">
            <summary>
            Constructs a new instance of the
            <see cref="T:Antlr4.Runtime.Atn.PredicateEvalInfo"/>
            class with the
            specified detailed predicate evaluation information.
            </summary>
            <param name="state">The simulator state</param>
            <param name="decision">The decision number</param>
            <param name="input">The input token stream</param>
            <param name="startIndex">The start index for the current prediction</param>
            <param name="stopIndex">
            The index at which the predicate evaluation was
            triggered. Note that the input stream may be reset to other positions for
            the actual evaluation of individual predicates.
            </param>
            <param name="semctx">The semantic context which was evaluated</param>
            <param name="evalResult">The results of evaluating the semantic context</param>
            <param name="predictedAlt">
            The alternative number for the decision which is
            guarded by the semantic context
            <paramref name="semctx"/>
            . See
            <see cref="F:Antlr4.Runtime.Atn.PredicateEvalInfo.predictedAlt"/>
            for more information.
            </param>
            <seealso cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.EvalSemanticContext(Antlr4.Runtime.Atn.SemanticContext,Antlr4.Runtime.ParserRuleContext,System.Int32)"/>
            <seealso cref="M:Antlr4.Runtime.Atn.SemanticContext.Eval``2(Antlr4.Runtime.Recognizer{``0,``1},Antlr4.Runtime.RuleContext)"/>
        </member>
        <member name="T:Antlr4.Runtime.Atn.PredicateTransition">
            <summary>
            TODO: this is old comment:
            A tree of semantic predicates from the grammar AST if label==SEMPRED.
            </summary>
            <remarks>
            TODO: this is old comment:
            A tree of semantic predicates from the grammar AST if label==SEMPRED.
            In the ATN, labels will always be exactly one predicate, but the DFA
            may have to combine a bunch of them as it collects predicates from
            multiple ATN configurations into a single DFA state.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.PredictionContext.cachedHashCode">
            <summary>
            Stores the computed hash code of this
            <see cref="T:Antlr4.Runtime.Atn.PredictionContext"/>
            . The hash
            code is computed in parts to match the following reference algorithm.
            <pre>
            private int referenceHashCode() {
            int hash =
            <see cref="M:Antlr4.Runtime.Misc.MurmurHash.Initialize">MurmurHash.initialize</see>
            (
            <see cref="F:Antlr4.Runtime.Atn.PredictionContext.InitialHash"/>
            );
            for (int i = 0; i &lt;
            <see cref="P:Antlr4.Runtime.Atn.PredictionContext.Size"/>
            ; i++) {
            hash =
            <see cref="M:Antlr4.Runtime.Misc.MurmurHash.Update(System.Int32,System.Int32)">MurmurHash.update</see>
            (hash,
            <see cref="M:Antlr4.Runtime.Atn.PredictionContext.GetParent(System.Int32)">getParent</see>
            (i));
            }
            for (int i = 0; i &lt;
            <see cref="P:Antlr4.Runtime.Atn.PredictionContext.Size"/>
            ; i++) {
            hash =
            <see cref="M:Antlr4.Runtime.Misc.MurmurHash.Update(System.Int32,System.Int32)">MurmurHash.update</see>
            (hash,
            <see cref="M:Antlr4.Runtime.Atn.PredictionContext.GetReturnState(System.Int32)">getReturnState</see>
            (i));
            }
            hash =
            <see cref="M:Antlr4.Runtime.Misc.MurmurHash.Finish(System.Int32,System.Int32)">MurmurHash.finish</see>
            (hash, 2 *
            <see cref="P:Antlr4.Runtime.Atn.PredictionContext.Size"/>
            );
            return hash;
            }
            </pre>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.PredictionContextCache">
            <summary>
            Used to cache
            <see cref="T:Antlr4.Runtime.Atn.PredictionContext"/>
            objects. Its used for the shared
            context cash associated with contexts in DFA states. This cache
            can be used for both lexers and parsers.
            </summary>
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Atn.PredictionMode">
            <summary>
            This enumeration defines the prediction modes available in ANTLR 4 along with
            utility methods for analyzing configuration sets for conflicts and/or
            ambiguities.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.PredictionMode.Sll">
            <summary>The SLL(*) prediction mode.</summary>
            <remarks>
            The SLL(*) prediction mode. This prediction mode ignores the current
            parser context when making predictions. This is the fastest prediction
            mode, and provides correct results for many grammars. This prediction
            mode is more powerful than the prediction mode provided by ANTLR 3, but
            may result in syntax errors for grammar and input combinations which are
            not SLL.
            <p>
            When using this prediction mode, the parser will either return a correct
            parse tree (i.e. the same parse tree that would be returned with the
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Ll"/>
            prediction mode), or it will report a syntax error. If a
            syntax error is encountered when using the
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Sll"/>
            prediction mode,
            it may be due to either an actual syntax error in the input or indicate
            that the particular combination of grammar and input requires the more
            powerful
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Ll"/>
            prediction abilities to complete successfully.</p>
            <p>
            This prediction mode does not provide any guarantees for prediction
            behavior for syntactically-incorrect inputs.</p>
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.PredictionMode.Ll">
            <summary>The LL(*) prediction mode.</summary>
            <remarks>
            The LL(*) prediction mode. This prediction mode allows the current parser
            context to be used for resolving SLL conflicts that occur during
            prediction. This is the fastest prediction mode that guarantees correct
            parse results for all combinations of grammars with syntactically correct
            inputs.
            <p>
            When using this prediction mode, the parser will make correct decisions
            for all syntactically-correct grammar and input combinations. However, in
            cases where the grammar is truly ambiguous this prediction mode might not
            report a precise answer for <em>exactly which</em> alternatives are
            ambiguous.</p>
            <p>
            This prediction mode does not provide any guarantees for prediction
            behavior for syntactically-incorrect inputs.</p>
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection">
            <summary>The LL(*) prediction mode with exact ambiguity detection.</summary>
            <remarks>
            The LL(*) prediction mode with exact ambiguity detection. In addition to
            the correctness guarantees provided by the
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.Ll"/>
            prediction mode,
            this prediction mode instructs the prediction algorithm to determine the
            complete and exact set of ambiguous alternatives for every ambiguous
            decision encountered while parsing.
            <p>
            This prediction mode may be used for diagnosing ambiguities during
            grammar development. Due to the performance overhead of calculating sets
            of ambiguous alternatives, this prediction mode should be avoided when
            the exact results are not necessary.</p>
            <p>
            This prediction mode does not provide any guarantees for prediction
            behavior for syntactically-incorrect inputs.</p>
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.Atn.PredictionMode.AltAndContextMap">
            <summary>A Map that uses just the state and the stack context as the key.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.AltAndContextConfigEqualityComparator.GetHashCode(Antlr4.Runtime.Atn.ATNConfig)">
            <summary>
            The hash code is only a function of the
            <see cref="F:Antlr4.Runtime.Atn.ATNState.stateNumber"/>
            and
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.Context"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.HasSLLConflictTerminatingPrediction(Antlr4.Runtime.Atn.PredictionMode,Antlr4.Runtime.Atn.ATNConfigSet)">
            <summary>Computes the SLL prediction termination condition.</summary>
            <remarks>
            Computes the SLL prediction termination condition.
            <p>
            This method computes the SLL prediction termination condition for both of
            the following cases.</p>
            <ul>
            <li>The usual SLL+LL fallback upon SLL conflict</li>
            <li>Pure SLL without LL fallback</li>
            </ul>
            <p><strong>COMBINED SLL+LL PARSING</strong></p>
            <p>When LL-fallback is enabled upon SLL conflict, correct predictions are
            ensured regardless of how the termination condition is computed by this
            method. Due to the substantially higher cost of LL prediction, the
            prediction should only fall back to LL when the additional lookahead
            cannot lead to a unique SLL prediction.</p>
            <p>Assuming combined SLL+LL parsing, an SLL configuration set with only
            conflicting subsets should fall back to full LL, even if the
            configuration sets don't resolve to the same alternative (e.g.
            <c/>
            
            1,2}} and
            <c/>
            
            3,4}}. If there is at least one non-conflicting
            configuration, SLL could continue with the hopes that more lookahead will
            resolve via one of those non-conflicting configurations.</p>
            <p>Here's the prediction termination rule them: SLL (for SLL+LL parsing)
            stops when it sees only conflicting configuration subsets. In contrast,
            full LL keeps going when there is uncertainty.</p>
            <p><strong>HEURISTIC</strong></p>
            <p>As a heuristic, we stop prediction when we see any conflicting subset
            unless we see a state that only has one alternative associated with it.
            The single-alt-state thing lets prediction continue upon rules like
            (otherwise, it would admit defeat too soon):</p>
            <p>
            <c>[12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;</c>
            </p>
            <p>When the ATN simulation reaches the state before
            <c>';'</c>
            , it has a
            DFA state that looks like:
            <c>[12|1|[], 6|2|[], 12|2|[]]</c>
            . Naturally
            <c>12|1|[]</c>
            and
            <c>12|2|[]</c>
            conflict, but we cannot stop
            processing this node because alternative to has another way to continue,
            via
            <c>[6|2|[]]</c>
            .</p>
            <p>It also let's us continue for this rule:</p>
            <p>
            <c>[1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;</c>
            </p>
            <p>After matching input A, we reach the stop state for rule A, state 1.
            State 8 is the state right before B. Clearly alternatives 1 and 2
            conflict and no amount of further lookahead will separate the two.
            However, alternative 3 will be able to continue and so we do not stop
            working on this state. In the previous example, we're concerned with
            states associated with the conflicting alternatives. Here alt 3 is not
            associated with the conflicting configs, but since we can continue
            looking for input reasonably, don't declare the state done.</p>
            <p><strong>PURE SLL PARSING</strong></p>
            <p>To handle pure SLL parsing, all we have to do is make sure that we
            combine stack contexts for configurations that differ only by semantic
            predicate. From there, we can do the usual SLL termination heuristic.</p>
            <p><strong>PREDICATES IN SLL+LL PARSING</strong></p>
            <p>SLL decisions don't evaluate predicates until after they reach DFA stop
            states because they need to create the DFA cache that works in all
            semantic situations. In contrast, full LL evaluates predicates collected
            during start state computation so it can ignore predicates thereafter.
            This means that SLL termination detection can totally ignore semantic
            predicates.</p>
            <p>Implementation-wise,
            <see cref="T:Antlr4.Runtime.Atn.ATNConfigSet"/>
            combines stack contexts but not
            semantic predicate contexts so we might see two configurations like the
            following.</p>
            <p>
            <c/>
            (s, 1, x,
            ), (s, 1, x', {p})}</p>
            <p>Before testing these configurations against others, we have to merge
            <c>x</c>
            and
            <c>x'</c>
            (without modifying the existing configurations).
            For example, we test
            <c>(x+x')==x''</c>
            when looking for conflicts in
            the following configurations.</p>
            <p>
            <c/>
            (s, 1, x,
            ), (s, 1, x', {p}), (s, 2, x'', {})}</p>
            <p>If the configuration set has predicates (as indicated by
            <see cref="P:Antlr4.Runtime.Atn.ATNConfigSet.HasSemanticContext"/>
            ), this algorithm makes a copy of
            the configurations to strip out all of the predicates so that a standard
            <see cref="T:Antlr4.Runtime.Atn.ATNConfigSet"/>
            will merge everything ignoring predicates.</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.HasConfigInRuleStopState(System.Collections.Generic.IEnumerable{Antlr4.Runtime.Atn.ATNConfig})">
            <summary>
            Checks if any configuration in
            <paramref name="configs"/>
            is in a
            <see cref="T:Antlr4.Runtime.Atn.RuleStopState"/>
            . Configurations meeting this condition have reached
            the end of the decision rule (local context) or end of start rule (full
            context).
            </summary>
            <param name="configs">the configuration set to test</param>
            <returns>
            
            <see langword="true"/>
            if any configuration in
            <paramref name="configs"/>
            is in a
            <see cref="T:Antlr4.Runtime.Atn.RuleStopState"/>
            , otherwise
            <see langword="false"/>
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.AllConfigsInRuleStopStates(System.Collections.Generic.IEnumerable{Antlr4.Runtime.Atn.ATNConfig})">
            <summary>
            Checks if all configurations in
            <paramref name="configs"/>
            are in a
            <see cref="T:Antlr4.Runtime.Atn.RuleStopState"/>
            . Configurations meeting this condition have reached
            the end of the decision rule (local context) or end of start rule (full
            context).
            </summary>
            <param name="configs">the configuration set to test</param>
            <returns>
            
            <see langword="true"/>
            if all configurations in
            <paramref name="configs"/>
            are in a
            <see cref="T:Antlr4.Runtime.Atn.RuleStopState"/>
            , otherwise
            <see langword="false"/>
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.ResolvesToJustOneViableAlt(System.Collections.Generic.IEnumerable{Antlr4.Runtime.Sharpen.BitSet})">
            <summary>Full LL prediction termination.</summary>
            <remarks>
            Full LL prediction termination.
            <p>Can we stop looking ahead during ATN simulation or is there some
            uncertainty as to which alternative we will ultimately pick, after
            consuming more input? Even if there are partial conflicts, we might know
            that everything is going to resolve to the same minimum alternative. That
            means we can stop since no more lookahead will change that fact. On the
            other hand, there might be multiple conflicts that resolve to different
            minimums. That means we need more look ahead to decide which of those
            alternatives we should predict.</p>
            <p>The basic idea is to split the set of configurations
            <c>C</c>
            , into
            conflicting subsets
            <c>(s, _, ctx, _)</c>
            and singleton subsets with
            non-conflicting configurations. Two configurations conflict if they have
            identical
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.State"/>
            and
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.Context"/>
            values
            but different
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.Alt"/>
            value, e.g.
            <c>(s, i, ctx, _)</c>
            and
            <c>(s, j, ctx, _)</c>
            for
            <c>i!=j</c>
            .</p>
            <p/>
            Reduce these configuration subsets to the set of possible alternatives.
            You can compute the alternative subsets in one pass as follows:
            <p/>
            <c/>
            A_s,ctx =
            i | (s, i, ctx, _)}} for each configuration in
            <c>C</c>
            holding
            <c>s</c>
            and
            <c>ctx</c>
            fixed.
            <p/>
            Or in pseudo-code, for each configuration
            <c>c</c>
            in
            <c>C</c>
            :
            <pre>
            map[c] U= c.
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.Alt">getAlt()</see>
            # map hash/equals uses s and x, not
            alt and not pred
            </pre>
            <p>The values in
            <c>map</c>
            are the set of
            <c>A_s,ctx</c>
            sets.</p>
            <p>If
            <c>|A_s,ctx|=1</c>
            then there is no conflict associated with
            <c>s</c>
            and
            <c>ctx</c>
            .</p>
            <p>Reduce the subsets to singletons by choosing a minimum of each subset. If
            the union of these alternative subsets is a singleton, then no amount of
            more lookahead will help us. We will always pick that alternative. If,
            however, there is more than one alternative, then we are uncertain which
            alternative to predict and must continue looking for resolution. We may
            or may not discover an ambiguity in the future, even if there are no
            conflicting subsets this round.</p>
            <p>The biggest sin is to terminate early because it means we've made a
            decision but were uncertain as to the eventual outcome. We haven't used
            enough lookahead. On the other hand, announcing a conflict too late is no
            big deal; you will still have the conflict. It's just inefficient. It
            might even look until the end of file.</p>
            <p>No special consideration for semantic predicates is required because
            predicates are evaluated on-the-fly for full LL prediction, ensuring that
            no configuration contains a semantic context during the termination
            check.</p>
            <p><strong>CONFLICTING CONFIGS</strong></p>
            <p>Two configurations
            <c>(s, i, x)</c>
            and
            <c>(s, j, x')</c>
            , conflict
            when
            <c>i!=j</c>
            but
            <c>x=x'</c>
            . Because we merge all
            <c>(s, i, _)</c>
            configurations together, that means that there are at
            most
            <c>n</c>
            configurations associated with state
            <c>s</c>
            for
            <c>n</c>
            possible alternatives in the decision. The merged stacks
            complicate the comparison of configuration contexts
            <c>x</c>
            and
            <c>x'</c>
            . Sam checks to see if one is a subset of the other by calling
            merge and checking to see if the merged result is either
            <c>x</c>
            or
            <c>x'</c>
            . If the
            <c>x</c>
            associated with lowest alternative
            <c>i</c>
            is the superset, then
            <c>i</c>
            is the only possible prediction since the
            others resolve to
            <c>min(i)</c>
            as well. However, if
            <c>x</c>
            is
            associated with
            <c>j&gt;i</c>
            then at least one stack configuration for
            <c>j</c>
            is not in conflict with alternative
            <c>i</c>
            . The algorithm
            should keep going, looking for more lookahead due to the uncertainty.</p>
            <p>For simplicity, I'm doing a equality check between
            <c>x</c>
            and
            <c>x'</c>
            that lets the algorithm continue to consume lookahead longer
            than necessary. The reason I like the equality is of course the
            simplicity but also because that is the test you need to detect the
            alternatives that are actually in conflict.</p>
            <p><strong>CONTINUE/STOP RULE</strong></p>
            <p>Continue if union of resolved alternative sets from non-conflicting and
            conflicting alternative subsets has more than one alternative. We are
            uncertain about which alternative to predict.</p>
            <p>The complete set of alternatives,
            <c>[i for (_,i,_)]</c>
            , tells us which
            alternatives are still in the running for the amount of input we've
            consumed at this point. The conflicting sets let us to strip away
            configurations that won't lead to more states because we resolve
            conflicts to the configuration with a minimum alternate for the
            conflicting set.</p>
            <p><strong>CASES</strong></p>
            <ul>
            <li>no conflicts and more than 1 alternative in set =&gt; continue</li>
            <li>
            <c>(s, 1, x)</c>
            ,
            <c>(s, 2, x)</c>
            ,
            <c>(s, 3, z)</c>
            ,
            <c>(s', 1, y)</c>
            ,
            <c>(s', 2, y)</c>
            yields non-conflicting set
            <c/>
            
            3}} U conflicting sets
            <c/>
            min(
            1,2})} U
            <c/>
            min(
            1,2})} =
            <c/>
            
            1,3}} =&gt; continue
            </li>
            <li>
            <c>(s, 1, x)</c>
            ,
            <c>(s, 2, x)</c>
            ,
            <c>(s', 1, y)</c>
            ,
            <c>(s', 2, y)</c>
            ,
            <c>(s'', 1, z)</c>
            yields non-conflicting set
            <c/>
            
            1}} U conflicting sets
            <c/>
            min(
            1,2})} U
            <c/>
            min(
            1,2})} =
            <c/>
            
            1}} =&gt; stop and predict 1</li>
            <li>
            <c>(s, 1, x)</c>
            ,
            <c>(s, 2, x)</c>
            ,
            <c>(s', 1, y)</c>
            ,
            <c>(s', 2, y)</c>
            yields conflicting, reduced sets
            <c/>
            
            1}} U
            <c/>
            
            1}} =
            <c/>
            
            1}} =&gt; stop and predict 1, can announce
            ambiguity
            <c/>
            
            1,2}}</li>
            <li>
            <c>(s, 1, x)</c>
            ,
            <c>(s, 2, x)</c>
            ,
            <c>(s', 2, y)</c>
            ,
            <c>(s', 3, y)</c>
            yields conflicting, reduced sets
            <c/>
            
            1}} U
            <c/>
            
            2}} =
            <c/>
            
            1,2}} =&gt; continue</li>
            <li>
            <c>(s, 1, x)</c>
            ,
            <c>(s, 2, x)</c>
            ,
            <c>(s', 3, y)</c>
            ,
            <c>(s', 4, y)</c>
            yields conflicting, reduced sets
            <c/>
            
            1}} U
            <c/>
            
            3}} =
            <c/>
            
            1,3}} =&gt; continue</li>
            </ul>
            <p><strong>EXACT AMBIGUITY DETECTION</strong></p>
            <p>If all states report the same conflicting set of alternatives, then we
            know we have the exact ambiguity set.</p>
            <p><code>|A_<em>i</em>|&gt;1</code> and
            <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.</p>
            <p>In other words, we continue examining lookahead until all
            <c>A_i</c>
            have more than one alternative and all
            <c>A_i</c>
            are the same. If
            <c/>
            A=
            {1,2}, {1,3}}}, then regular LL prediction would terminate
            because the resolved set is
            <c/>
            
            1}}. To determine what the real
            ambiguity is, we have to know whether the ambiguity is between one and
            two or one and three so we keep going. We can only stop prediction when
            we need exact ambiguity detection when the sets look like
            <c/>
            A=
            {1,2}}} or
            <c/>
            
            {1,2},{1,2}}}, etc...</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.AllSubsetsConflict(System.Collections.Generic.IEnumerable{Antlr4.Runtime.Sharpen.BitSet})">
            <summary>
            Determines if every alternative subset in
            <paramref name="altsets"/>
            contains more
            than one alternative.
            </summary>
            <param name="altsets">a collection of alternative subsets</param>
            <returns>
            
            <see langword="true"/>
            if every
            <see cref="T:Antlr4.Runtime.Sharpen.BitSet"/>
            in
            <paramref name="altsets"/>
            has
            <see cref="M:Antlr4.Runtime.Sharpen.BitSet.Cardinality">cardinality</see>
            &gt; 1, otherwise
            <see langword="false"/>
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.HasNonConflictingAltSet(System.Collections.Generic.IEnumerable{Antlr4.Runtime.Sharpen.BitSet})">
            <summary>
            Determines if any single alternative subset in
            <paramref name="altsets"/>
            contains
            exactly one alternative.
            </summary>
            <param name="altsets">a collection of alternative subsets</param>
            <returns>
            
            <see langword="true"/>
            if
            <paramref name="altsets"/>
            contains a
            <see cref="T:Antlr4.Runtime.Sharpen.BitSet"/>
            with
            <see cref="M:Antlr4.Runtime.Sharpen.BitSet.Cardinality">cardinality</see>
            1, otherwise
            <see langword="false"/>
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.HasConflictingAltSet(System.Collections.Generic.IEnumerable{Antlr4.Runtime.Sharpen.BitSet})">
            <summary>
            Determines if any single alternative subset in
            <paramref name="altsets"/>
            contains
            more than one alternative.
            </summary>
            <param name="altsets">a collection of alternative subsets</param>
            <returns>
            
            <see langword="true"/>
            if
            <paramref name="altsets"/>
            contains a
            <see cref="T:Antlr4.Runtime.Sharpen.BitSet"/>
            with
            <see cref="M:Antlr4.Runtime.Sharpen.BitSet.Cardinality">cardinality</see>
            &gt; 1, otherwise
            <see langword="false"/>
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.AllSubsetsEqual(System.Collections.Generic.IEnumerable{Antlr4.Runtime.Sharpen.BitSet})">
            <summary>
            Determines if every alternative subset in
            <paramref name="altsets"/>
            is equivalent.
            </summary>
            <param name="altsets">a collection of alternative subsets</param>
            <returns>
            
            <see langword="true"/>
            if every member of
            <paramref name="altsets"/>
            is equal to the
            others, otherwise
            <see langword="false"/>
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.GetUniqueAlt(System.Collections.Generic.IEnumerable{Antlr4.Runtime.Sharpen.BitSet})">
            <summary>
            Returns the unique alternative predicted by all alternative subsets in
            <paramref name="altsets"/>
            . If no such alternative exists, this method returns
            <see cref="F:Antlr4.Runtime.Atn.ATN.InvalidAltNumber"/>
            .
            </summary>
            <param name="altsets">a collection of alternative subsets</param>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.GetAlts(System.Collections.Generic.IEnumerable{Antlr4.Runtime.Sharpen.BitSet})">
            <summary>
            Gets the complete set of represented alternatives for a collection of
            alternative subsets.
            </summary>
            <remarks>
            Gets the complete set of represented alternatives for a collection of
            alternative subsets. This method returns the union of each
            <see cref="T:Antlr4.Runtime.Sharpen.BitSet"/>
            in
            <paramref name="altsets"/>
            .
            </remarks>
            <param name="altsets">a collection of alternative subsets</param>
            <returns>
            the set of represented alternatives in
            <paramref name="altsets"/>
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.GetAlts(Antlr4.Runtime.Atn.ATNConfigSet)">
            <summary>Get union of all alts from configs.</summary>
            <since>4.5</since>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.GetConflictingAltSubsets(System.Collections.Generic.IEnumerable{Antlr4.Runtime.Atn.ATNConfig})">
            <summary>This function gets the conflicting alt subsets from a configuration set.</summary>
            <remarks>
            This function gets the conflicting alt subsets from a configuration set.
            For each configuration
            <c>c</c>
            in
            <paramref name="configs"/>
            :
            <pre>
            map[c] U= c.
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.Alt">getAlt()</see>
            # map hash/equals uses s and x, not
            alt and not pred
            </pre>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.PredictionMode.GetStateToAltMap(System.Collections.Generic.IEnumerable{Antlr4.Runtime.Atn.ATNConfig})">
            <summary>Get a map from state to alt subset from a configuration set.</summary>
            <remarks>
            Get a map from state to alt subset from a configuration set. For each
            configuration
            <c>c</c>
            in
            <paramref name="configs"/>
            :
            <pre>
            map[c.
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.State"/>
            ] U= c.
            <see cref="P:Antlr4.Runtime.Atn.ATNConfig.Alt"/>
            </pre>
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.Atn.ProfilingATNSimulator">
            <since>4.3</since>
        </member>
        <member name="F:Antlr4.Runtime.Atn.ProfilingATNSimulator.conflictingAltResolvedBySLL">
            <summary>
            At the point of LL failover, we record how SLL would resolve the conflict so that
            we can determine whether or not a decision / input pair is context-sensitive.
            </summary>
            <remarks>
            At the point of LL failover, we record how SLL would resolve the conflict so that
            we can determine whether or not a decision / input pair is context-sensitive.
            If LL gives a different result than SLL's predicted alternative, we have a
            context sensitivity for sure. The converse is not necessarily true, however.
            It's possible that after conflict resolution chooses minimum alternatives,
            SLL could get the same answer as LL. Regardless of whether or not the result indicates
            an ambiguity, it is not treated as a context sensitivity because LL prediction
            was not required in order to produce a correct prediction for this decision and input sequence.
            It may in fact still be a context sensitivity but we don't know by looking at the
            minimum alternatives for the current input.
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.Atn.RuleStopState">
            <summary>The last node in the ATN for a rule, unless that rule is the start symbol.</summary>
            <remarks>
            The last node in the ATN for a rule, unless that rule is the start symbol.
            In that case, there is one transition to EOF. Later, we might encode
            references to all calls to this rule to compute FOLLOW sets for
            error handling.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.RuleTransition.ruleIndex">
            <summary>Ptr to the rule definition object for this rule ref</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.RuleTransition.followState">
            <summary>What node to begin computations following ref to rule</summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.SemanticContext">
            <summary>
            A tree structure used to record the semantic context in which
            an ATN configuration is valid.
            </summary>
            <remarks>
            A tree structure used to record the semantic context in which
            an ATN configuration is valid.  It's either a single predicate,
            a conjunction
            <c>p1&amp;&amp;p2</c>
            , or a sum of products
            <c>p1||p2</c>
            .
            <p>I have scoped the
            <see cref="T:Antlr4.Runtime.Atn.SemanticContext.AND"/>
            ,
            <see cref="T:Antlr4.Runtime.Atn.SemanticContext.OR"/>
            , and
            <see cref="T:Antlr4.Runtime.Atn.SemanticContext.Predicate"/>
            subclasses of
            <see cref="T:Antlr4.Runtime.Atn.SemanticContext"/>
            within the scope of this outer class.</p>
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.SemanticContext.None">
            <summary>
            The default
            <see cref="T:Antlr4.Runtime.Atn.SemanticContext"/>
            , which is semantically equivalent to
            a predicate of the form
            <c/>
            
            true}?}.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.SemanticContext.Eval``2(Antlr4.Runtime.Recognizer{``0,``1},Antlr4.Runtime.RuleContext)">
            <summary>
            For context independent predicates, we evaluate them without a local
            context (i.e., null context).
            </summary>
            <remarks>
            For context independent predicates, we evaluate them without a local
            context (i.e., null context). That way, we can evaluate them without
            having to create proper rule-specific context during prediction (as
            opposed to the parser, which creates them naturally). In a practical
            sense, this avoids a cast exception from RuleContext to myruleContext.
            <p>For context dependent predicates, we must pass in a local context so that
            references such as $arg evaluate properly as _localctx.arg. We only
            capture context dependent predicates in the context in which we begin
            prediction, so we passed in the outer context here in case of context
            dependent predicate evaluation.</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Atn.SemanticContext.EvalPrecedence``2(Antlr4.Runtime.Recognizer{``0,``1},Antlr4.Runtime.RuleContext)">
            <summary>Evaluate the precedence predicates for the context and reduce the result.</summary>
            <param name="parser">The parser instance.</param>
            <param name="parserCallStack"/>
            <returns>
            The simplified semantic context after precedence predicates are
            evaluated, which will be one of the following values.
            <ul>
            <li>
            <see cref="F:Antlr4.Runtime.Atn.SemanticContext.None"/>
            : if the predicate simplifies to
            <see langword="true"/>
            after
            precedence predicates are evaluated.</li>
            <li>
            <see langword="null"/>
            : if the predicate simplifies to
            <see langword="false"/>
            after
            precedence predicates are evaluated.</li>
            <li>
            <c>this</c>
            : if the semantic context is not changed as a result of
            precedence predicate evaluation.</li>
            <li>A non-
            <see langword="null"/>
            
            <see cref="T:Antlr4.Runtime.Atn.SemanticContext"/>
            : the new simplified
            semantic context after precedence predicates are evaluated.</li>
            </ul>
            </returns>
        </member>
        <member name="T:Antlr4.Runtime.Atn.SemanticContext.Operator">
            <summary>
            This is the base class for semantic context "operators", which operate on
            a collection of semantic context "operands".
            </summary>
            <since>4.3</since>
        </member>
        <member name="P:Antlr4.Runtime.Atn.SemanticContext.Operator.Operands">
            <summary>Gets the operands for the semantic context operator.</summary>
            <returns>
            a collection of
            <see cref="T:Antlr4.Runtime.Atn.SemanticContext"/>
            operands for the
            operator.
            </returns>
            <since>4.3</since>
        </member>
        <member name="T:Antlr4.Runtime.Atn.SemanticContext.AND">
            <summary>
            A semantic context which is true whenever none of the contained contexts
            is false.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.SemanticContext.AND.Eval``2(Antlr4.Runtime.Recognizer{``0,``1},Antlr4.Runtime.RuleContext)">
            <summary>
            <inheritDoc/>
            <p>
            The evaluation of predicates by this context is short-circuiting, but
            unordered.</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.SemanticContext.OR">
            <summary>
            A semantic context which is true whenever at least one of the contained
            contexts is true.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.SemanticContext.OR.Eval``2(Antlr4.Runtime.Recognizer{``0,``1},Antlr4.Runtime.RuleContext)">
            <summary>
            <inheritDoc/>
            <p>
            The evaluation of predicates by this context is short-circuiting, but
            unordered.</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Atn.SemanticContext.Or(Antlr4.Runtime.Atn.SemanticContext,Antlr4.Runtime.Atn.SemanticContext)">
            <seealso cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.GetPredsForAmbigAlts(Antlr4.Runtime.Sharpen.BitSet,Antlr4.Runtime.Atn.ATNConfigSet,System.Int32)"/>
        </member>
        <member name="T:Antlr4.Runtime.Atn.SetTransition">
            <summary>A transition containing a set of values.</summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.SimulatorState">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Atn.StarBlockStartState">
            <summary>The block that begins a closure loop.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Atn.StarLoopEntryState.precedenceRuleDecision">
            <summary>
            Indicates whether this state can benefit from a precedence DFA during SLL
            decision making.
            </summary>
            <remarks>
            Indicates whether this state can benefit from a precedence DFA during SLL
            decision making.
            <p>This is a computed property that is calculated during ATN deserialization
            and stored for use in
            <see cref="T:Antlr4.Runtime.Atn.ParserATNSimulator"/>
            and
            <see cref="T:Antlr4.Runtime.ParserInterpreter"/>
            .</p>
            </remarks>
            <seealso cref="P:Antlr4.Runtime.Dfa.DFA.IsPrecedenceDfa"/>
        </member>
        <member name="F:Antlr4.Runtime.Atn.StarLoopEntryState.precedenceLoopbackStates">
            <summary>
            For precedence decisions, this set marks states <em>S</em> which have all
            of the following characteristics:
            <ul>
            <li>One or more invocation sites of the current rule returns to
            <em>S</em>.</li>
            <li>The closure from <em>S</em> includes the current decision without
            passing through any rule invocations or stepping out of the current
            rule.</li>
            </ul>
            <p>This field is
            <see langword="null"/>
            when
            <see cref="F:Antlr4.Runtime.Atn.StarLoopEntryState.precedenceRuleDecision"/>
            is
            <see langword="false"/>
            .</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.TokensStartState">
            <summary>The Tokens rule start state linking to each lexer rule start state</summary>
        </member>
        <member name="T:Antlr4.Runtime.Atn.Transition">
            <summary>An ATN transition between any two ATN states.</summary>
            <remarks>
            An ATN transition between any two ATN states.  Subclasses define
            atom, set, epsilon, action, predicate, rule transitions.
            <p>This is a one way link.  It emanates from a state (usually via a list of
            transitions) and has a target state.</p>
            <p>Since we never have to change the ATN transitions once we construct it,
            we can fix these transitions as specific classes. The DFA transitions
            on the other hand need to update the labels as it adds transitions to
            the states. We'll use the term Edge for the DFA to distinguish them from
            ATN transitions.</p>
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Atn.Transition.target">
            <summary>The target of this transition.</summary>
        </member>
        <member name="P:Antlr4.Runtime.Atn.Transition.IsEpsilon">
            <summary>Determines if the transition is an "epsilon" transition.</summary>
            <remarks>
            Determines if the transition is an "epsilon" transition.
            <p>The default implementation returns
            <see langword="false"/>
            .</p>
            </remarks>
            <returns>
            
            <see langword="true"/>
            if traversing this transition in the ATN does not
            consume an input symbol; otherwise,
            <see langword="false"/>
            if traversing this
            transition consumes (matches) an input symbol.
            </returns>
        </member>
        <member name="T:Antlr4.Runtime.BailErrorStrategy">
            <summary>
            This implementation of
            <see cref="T:Antlr4.Runtime.IAntlrErrorStrategy"/>
            responds to syntax errors
            by immediately canceling the parse operation with a
            <see cref="T:Antlr4.Runtime.Misc.ParseCanceledException"/>
            . The implementation ensures that the
            <see cref="F:Antlr4.Runtime.ParserRuleContext.exception"/>
            field is set for all parse tree nodes
            that were not completed prior to encountering the error.
            <p>
            This error strategy is useful in the following scenarios.</p>
            <ul>
            <li><strong>Two-stage parsing:</strong> This error strategy allows the first
            stage of two-stage parsing to immediately terminate if an error is
            encountered, and immediately fall back to the second stage. In addition to
            avoiding wasted work by attempting to recover from errors here, the empty
            implementation of
            <see cref="M:Antlr4.Runtime.BailErrorStrategy.Sync(Antlr4.Runtime.Parser)"/>
            improves the performance of
            the first stage.</li>
            <li><strong>Silent validation:</strong> When syntax errors are not being
            reported or logged, and the parse result is simply ignored if errors occur,
            the
            <see cref="T:Antlr4.Runtime.BailErrorStrategy"/>
            avoids wasting work on recovering from errors
            when the result will be ignored either way.</li>
            </ul>
            <p>
            <c>myparser.setErrorHandler(new BailErrorStrategy());</c>
            </p>
            </summary>
            <seealso cref="P:Antlr4.Runtime.Parser.ErrorHandler"/>
        </member>
        <member name="M:Antlr4.Runtime.BailErrorStrategy.Recover(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)">
            <summary>
            Instead of recovering from exception
            <paramref name="e"/>
            , re-throw it wrapped
            in a
            <see cref="T:Antlr4.Runtime.Misc.ParseCanceledException"/>
            so it is not caught by the
            rule function catches.  Use
            <see cref="P:System.Exception.InnerException"/>
            to get the
            original
            <see cref="T:Antlr4.Runtime.RecognitionException"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.BailErrorStrategy.RecoverInline(Antlr4.Runtime.Parser)">
            <summary>
            Make sure we don't attempt to recover inline; if the parser
            successfully recovers, it won't throw an exception.
            </summary>
            <exception cref="T:Antlr4.Runtime.RecognitionException"/>
        </member>
        <member name="M:Antlr4.Runtime.BailErrorStrategy.Sync(Antlr4.Runtime.Parser)">
            <summary>Make sure we don't attempt to recover from problems in subrules.</summary>
        </member>
        <member name="T:Antlr4.Runtime.BaseErrorListener">
            <summary>
            Provides an empty default implementation of
            <see cref="T:Antlr4.Runtime.IAntlrErrorListener`1"/>
            . The
            default implementation of each method does nothing, but can be overridden as
            necessary.
            </summary>
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.BufferedTokenStream">
            <summary>
            This implementation of
            <see cref="T:Antlr4.Runtime.ITokenStream"/>
            loads tokens from a
            <see cref="T:Antlr4.Runtime.ITokenSource"/>
            on-demand, and places the tokens in a buffer to provide
            access to any previous token by index.
            <p>
            This token stream ignores the value of
            <see cref="P:Antlr4.Runtime.IToken.Channel"/>
            . If your
            parser requires the token stream filter tokens to only those on a particular
            channel, such as
            <see cref="F:Antlr4.Runtime.TokenConstants.DefaultChannel"/>
            or
            <see cref="F:Antlr4.Runtime.TokenConstants.HiddenChannel"/>
            , use a filtering token stream such a
            <see cref="T:Antlr4.Runtime.CommonTokenStream"/>
            .</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.BufferedTokenStream.tokenSource">
            <summary>
            The
            <see cref="T:Antlr4.Runtime.ITokenSource"/>
            from which tokens for this stream are fetched.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.BufferedTokenStream.tokens">
            <summary>A collection of all tokens fetched from the token source.</summary>
            <remarks>
            A collection of all tokens fetched from the token source. The list is
            considered a complete view of the input once
            <see cref="F:Antlr4.Runtime.BufferedTokenStream.fetchedEOF"/>
            is set
            to
            <see langword="true"/>
            .
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.BufferedTokenStream.p">
            <summary>
            The index into
            <see cref="F:Antlr4.Runtime.BufferedTokenStream.tokens"/>
            of the current token (next token to
            <see cref="M:Antlr4.Runtime.BufferedTokenStream.Consume"/>
            ).
            <see cref="F:Antlr4.Runtime.BufferedTokenStream.tokens"/>
            <c>[</c>
            <see cref="F:Antlr4.Runtime.BufferedTokenStream.p"/>
            <c>]</c>
            should be
            <see cref="M:Antlr4.Runtime.BufferedTokenStream.Lt(System.Int32)">LT(1)</see>
            .
            <p>This field is set to -1 when the stream is first constructed or when
            <see cref="M:Antlr4.Runtime.BufferedTokenStream.SetTokenSource(Antlr4.Runtime.ITokenSource)"/>
            is called, indicating that the first token has
            not yet been fetched from the token source. For additional information,
            see the documentation of
            <see cref="T:Antlr4.Runtime.IIntStream"/>
            for a description of
            Initializing Methods.</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.BufferedTokenStream.fetchedEOF">
            <summary>
            Indicates whether the
            <see cref="F:Antlr4.Runtime.TokenConstants.Eof"/>
            token has been fetched from
            <see cref="F:Antlr4.Runtime.BufferedTokenStream.tokenSource"/>
            and added to
            <see cref="F:Antlr4.Runtime.BufferedTokenStream.tokens"/>
            . This field improves
            performance for the following cases:
            <ul>
            <li>
            <see cref="M:Antlr4.Runtime.BufferedTokenStream.Consume"/>
            : The lookahead check in
            <see cref="M:Antlr4.Runtime.BufferedTokenStream.Consume"/>
            to prevent
            consuming the EOF symbol is optimized by checking the values of
            <see cref="F:Antlr4.Runtime.BufferedTokenStream.fetchedEOF"/>
            and
            <see cref="F:Antlr4.Runtime.BufferedTokenStream.p"/>
            instead of calling
            <see cref="M:Antlr4.Runtime.BufferedTokenStream.La(System.Int32)"/>
            .</li>
            <li>
            <see cref="M:Antlr4.Runtime.BufferedTokenStream.Fetch(System.Int32)"/>
            : The check to prevent adding multiple EOF symbols into
            <see cref="F:Antlr4.Runtime.BufferedTokenStream.tokens"/>
            is trivial with this field.</li>
            </ul>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.Sync(System.Int32)">
            <summary>
            Make sure index
            <paramref name="i"/>
            in tokens has a token.
            </summary>
            <returns>
            
            <see langword="true"/>
            if a token is located at index
            <paramref name="i"/>
            , otherwise
            <see langword="false"/>
            .
            </returns>
            <seealso cref="M:Antlr4.Runtime.BufferedTokenStream.Get(System.Int32)"/>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.Fetch(System.Int32)">
            <summary>
            Add
            <paramref name="n"/>
            elements to buffer.
            </summary>
            <returns>The actual number of elements added to the buffer.</returns>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.Get(System.Int32,System.Int32)">
            <summary>Get all tokens from start..stop inclusively.</summary>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.AdjustSeekIndex(System.Int32)">
            <summary>
            Allowed derived classes to modify the behavior of operations which change
            the current stream position by adjusting the target token index of a seek
            operation.
            </summary>
            <remarks>
            Allowed derived classes to modify the behavior of operations which change
            the current stream position by adjusting the target token index of a seek
            operation. The default implementation simply returns
            <paramref name="i"/>
            . If an
            exception is thrown in this method, the current stream index should not be
            changed.
            <p>For example,
            <see cref="T:Antlr4.Runtime.CommonTokenStream"/>
            overrides this method to ensure that
            the seek target is always an on-channel token.</p>
            </remarks>
            <param name="i">The target token index.</param>
            <returns>The adjusted target token index.</returns>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.SetTokenSource(Antlr4.Runtime.ITokenSource)">
            <summary>Reset this token stream by setting its token source.</summary>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.GetTokens(System.Int32,System.Int32,Antlr4.Runtime.Sharpen.BitSet)">
            <summary>
            Given a start and stop index, return a
            <c>List</c>
            of all tokens in
            the token type
            <c>BitSet</c>
            .  Return
            <see langword="null"/>
            if no tokens were found.  This
            method looks at both on and off channel tokens.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.NextTokenOnChannel(System.Int32,System.Int32)">
            <summary>Given a starting index, return the index of the next token on channel.</summary>
            <remarks>
            Given a starting index, return the index of the next token on channel.
            Return
            <paramref name="i"/>
            if
            <c>tokens[i]</c>
            is on channel. Return the index of
            the EOF token if there are no tokens on channel between
            <paramref name="i"/>
            and
            EOF.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.PreviousTokenOnChannel(System.Int32,System.Int32)">
            <summary>
            Given a starting index, return the index of the previous token on
            channel.
            </summary>
            <remarks>
            Given a starting index, return the index of the previous token on
            channel. Return
            <paramref name="i"/>
            if
            <c>tokens[i]</c>
            is on channel. Return -1
            if there are no tokens on channel between
            <paramref name="i"/>
            and 0.
            <p>
            If
            <paramref name="i"/>
            specifies an index at or after the EOF token, the EOF token
            index is returned. This is due to the fact that the EOF token is treated
            as though it were on every channel.</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.GetHiddenTokensToRight(System.Int32,System.Int32)">
            <summary>
            Collect all tokens on specified channel to the right of
            the current token up until we see a token on
            <see cref="F:Antlr4.Runtime.Lexer.DefaultTokenChannel"/>
            or
            EOF. If
            <paramref name="channel"/>
            is
            <c>-1</c>
            , find any non default channel token.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.GetHiddenTokensToRight(System.Int32)">
            <summary>
            Collect all hidden tokens (any off-default channel) to the right of
            the current token up until we see a token on
            <see cref="F:Antlr4.Runtime.Lexer.DefaultTokenChannel"/>
            or EOF.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.GetHiddenTokensToLeft(System.Int32,System.Int32)">
            <summary>
            Collect all tokens on specified channel to the left of
            the current token up until we see a token on
            <see cref="F:Antlr4.Runtime.Lexer.DefaultTokenChannel"/>
            .
            If
            <paramref name="channel"/>
            is
            <c>-1</c>
            , find any non default channel token.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.GetHiddenTokensToLeft(System.Int32)">
            <summary>
            Collect all hidden tokens (any off-default channel) to the left of
            the current token up until we see a token on
            <see cref="F:Antlr4.Runtime.Lexer.DefaultTokenChannel"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.GetText">
            <summary>Get the text of all tokens in this buffer.</summary>
        </member>
        <member name="M:Antlr4.Runtime.BufferedTokenStream.Fill">
            <summary>Get all tokens from lexer until EOF.</summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonToken.EmptySource">
            <summary>
            An empty
            <see cref="T:System.Tuple`2"/>
            which is used as the default value of
            <see cref="F:Antlr4.Runtime.CommonToken.source"/>
            for tokens that do not have a source.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonToken.type">
            <summary>
            This is the backing field for the <see cref="P:Antlr4.Runtime.CommonToken.Type"/> property.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonToken.line">
            <summary>
            This is the backing field for the <see cref="P:Antlr4.Runtime.CommonToken.Line"/> property.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonToken.charPositionInLine">
            <summary>
            This is the backing field for the <see cref="P:Antlr4.Runtime.CommonToken.Column"/> property.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonToken.channel">
            <summary>
            This is the backing field for the <see cref="P:Antlr4.Runtime.CommonToken.Channel"/> property.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonToken.source">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.CommonToken.TokenSource"/>
            and
            <see cref="P:Antlr4.Runtime.CommonToken.InputStream"/>
            .
            <p>
            These properties share a field to reduce the memory footprint of
            <see cref="T:Antlr4.Runtime.CommonToken"/>
            . Tokens created by a
            <see cref="T:Antlr4.Runtime.CommonTokenFactory"/>
            from
            the same source and input stream share a reference to the same
            <see cref="T:System.Tuple`2"/>
            containing these values.</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonToken.text">
            <summary>
            This is the backing field for the <see cref="P:Antlr4.Runtime.CommonToken.Text"/> property.
            </summary>
            <seealso cref="P:Antlr4.Runtime.CommonToken.Text"/>
        </member>
        <member name="F:Antlr4.Runtime.CommonToken.index">
            <summary>
            This is the backing field for the <see cref="P:Antlr4.Runtime.CommonToken.TokenIndex"/> property.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonToken.start">
            <summary>
            This is the backing field for the <see cref="P:Antlr4.Runtime.CommonToken.StartIndex"/> property.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonToken.stop">
            <summary>
            This is the backing field for the <see cref="P:Antlr4.Runtime.CommonToken.StopIndex"/> property.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.CommonToken.#ctor(System.Int32)">
            <summary>
            Constructs a new
            <see cref="T:Antlr4.Runtime.CommonToken"/>
            with the specified token type.
            </summary>
            <param name="type">The token type.</param>
        </member>
        <member name="M:Antlr4.Runtime.CommonToken.#ctor(System.Int32,System.String)">
            <summary>
            Constructs a new
            <see cref="T:Antlr4.Runtime.CommonToken"/>
            with the specified token type and
            text.
            </summary>
            <param name="type">The token type.</param>
            <param name="text">The text of the token.</param>
        </member>
        <member name="M:Antlr4.Runtime.CommonToken.#ctor(Antlr4.Runtime.IToken)">
            <summary>
            Constructs a new
            <see cref="T:Antlr4.Runtime.CommonToken"/>
            as a copy of another
            <see cref="T:Antlr4.Runtime.IToken"/>
            .
            <p>
            If
            <paramref name="oldToken"/>
            is also a
            <see cref="T:Antlr4.Runtime.CommonToken"/>
            instance, the newly
            constructed token will share a reference to the
            <see cref="F:Antlr4.Runtime.CommonToken.text"/>
            field and
            the
            <see cref="T:System.Tuple`2"/>
            stored in
            <see cref="F:Antlr4.Runtime.CommonToken.source"/>
            . Otherwise,
            <see cref="F:Antlr4.Runtime.CommonToken.text"/>
            will
            be assigned the result of calling
            <see cref="P:Antlr4.Runtime.CommonToken.Text"/>
            , and
            <see cref="F:Antlr4.Runtime.CommonToken.source"/>
            will be constructed from the result of
            <see cref="P:Antlr4.Runtime.IToken.TokenSource"/>
            and
            <see cref="P:Antlr4.Runtime.IToken.InputStream"/>
            .</p>
            </summary>
            <param name="oldToken">The token to copy.</param>
        </member>
        <member name="P:Antlr4.Runtime.CommonToken.Text">
            <summary>Explicitly set the text for this token.</summary>
            <remarks>
            Explicitly set the text for this token. If {code text} is not
            <see langword="null"/>
            , then
            <see cref="P:Antlr4.Runtime.CommonToken.Text"/>
            will return this value rather than
            extracting the text from the input.
            </remarks>
            <value>
            The explicit text of the token, or
            <see langword="null"/>
            if the text
            should be obtained from the input along with the start and stop indexes
            of the token.
            </value>
        </member>
        <member name="T:Antlr4.Runtime.CommonTokenFactory">
            <summary>
            This default implementation of
            <see cref="T:Antlr4.Runtime.ITokenFactory"/>
            creates
            <see cref="T:Antlr4.Runtime.CommonToken"/>
            objects.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonTokenFactory.Default">
            <summary>
            The default
            <see cref="T:Antlr4.Runtime.CommonTokenFactory"/>
            instance.
            <p>
            This token factory does not explicitly copy token text when constructing
            tokens.</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonTokenFactory.copyText">
            <summary>
            Indicates whether
            <see cref="P:Antlr4.Runtime.CommonToken.Text"/>
            should be called after
            constructing tokens to explicitly set the text. This is useful for cases
            where the input stream might not be able to provide arbitrary substrings
            of text from the input after the lexer creates a token (e.g. the
            implementation of
            <see cref="M:Antlr4.Runtime.ICharStream.GetText(Antlr4.Runtime.Misc.Interval)"/>
            in
            <see cref="T:Antlr4.Runtime.UnbufferedCharStream"/>
            throws an
            <see cref="T:System.NotSupportedException"/>
            ). Explicitly setting the token text
            allows
            <see cref="P:Antlr4.Runtime.IToken.Text"/>
            to be called at any time regardless of the
            input stream implementation.
            <p>
            The default value is
            <see langword="false"/>
            to avoid the performance and memory
            overhead of copying text for every token unless explicitly requested.</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.CommonTokenFactory.#ctor(System.Boolean)">
            <summary>
            Constructs a
            <see cref="T:Antlr4.Runtime.CommonTokenFactory"/>
            with the specified value for
            <see cref="F:Antlr4.Runtime.CommonTokenFactory.copyText"/>
            .
            <p>
            When
            <paramref name="copyText"/>
            is
            <see langword="false"/>
            , the
            <see cref="F:Antlr4.Runtime.CommonTokenFactory.Default"/>
            instance
            should be used instead of constructing a new instance.</p>
            </summary>
            <param name="copyText">
            The value for
            <see cref="F:Antlr4.Runtime.CommonTokenFactory.copyText"/>
            .
            </param>
        </member>
        <member name="M:Antlr4.Runtime.CommonTokenFactory.#ctor">
            <summary>
            Constructs a
            <see cref="T:Antlr4.Runtime.CommonTokenFactory"/>
            with
            <see cref="F:Antlr4.Runtime.CommonTokenFactory.copyText"/>
            set to
            <see langword="false"/>
            .
            <p>
            The
            <see cref="F:Antlr4.Runtime.CommonTokenFactory.Default"/>
            instance should be used instead of calling this
            directly.</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.CommonTokenStream">
            <summary>
            This class extends
            <see cref="T:Antlr4.Runtime.BufferedTokenStream"/>
            with functionality to filter
            token streams to tokens on a particular channel (tokens where
            <see cref="P:Antlr4.Runtime.IToken.Channel"/>
            returns a particular value).
            <p>
            This token stream provides access to all tokens by index or when calling
            methods like
            <see cref="M:Antlr4.Runtime.BufferedTokenStream.GetText"/>
            . The channel filtering is only used for code
            accessing tokens via the lookahead methods
            <see cref="M:Antlr4.Runtime.BufferedTokenStream.La(System.Int32)"/>
            ,
            <see cref="M:Antlr4.Runtime.CommonTokenStream.Lt(System.Int32)"/>
            , and
            <see cref="M:Antlr4.Runtime.CommonTokenStream.Lb(System.Int32)"/>
            .</p>
            <p>
            By default, tokens are placed on the default channel
            (
            <see cref="F:Antlr4.Runtime.TokenConstants.DefaultChannel"/>
            ), but may be reassigned by using the
            <c>-&gt;channel(HIDDEN)</c>
            lexer command, or by using an embedded action to
            call
            <see cref="P:Antlr4.Runtime.Lexer.Channel"/>
            .
            </p>
            <p>
            Note: lexer rules which use the
            <c>-&gt;skip</c>
            lexer command or call
            <see cref="M:Antlr4.Runtime.Lexer.Skip"/>
            do not produce tokens at all, so input text matched by
            such a rule will not be available as part of the token stream, regardless of
            channel.</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.CommonTokenStream.channel">
            <summary>Specifies the channel to use for filtering tokens.</summary>
            <remarks>
            Specifies the channel to use for filtering tokens.
            <p>
            The default value is
            <see cref="F:Antlr4.Runtime.TokenConstants.DefaultChannel"/>
            , which matches the
            default channel assigned to tokens created by the lexer.</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.CommonTokenStream.#ctor(Antlr4.Runtime.ITokenSource)">
            <summary>
            Constructs a new
            <see cref="T:Antlr4.Runtime.CommonTokenStream"/>
            using the specified token
            source and the default token channel (
            <see cref="F:Antlr4.Runtime.TokenConstants.DefaultChannel"/>
            ).
            </summary>
            <param name="tokenSource">The token source.</param>
        </member>
        <member name="M:Antlr4.Runtime.CommonTokenStream.#ctor(Antlr4.Runtime.ITokenSource,System.Int32)">
            <summary>
            Constructs a new
            <see cref="T:Antlr4.Runtime.CommonTokenStream"/>
            using the specified token
            source and filtering tokens to the specified channel. Only tokens whose
            <see cref="P:Antlr4.Runtime.IToken.Channel"/>
            matches
            <paramref name="channel"/>
            or have the
            <see cref="P:Antlr4.Runtime.IToken.Type"/>
            equal to
            <see cref="F:Antlr4.Runtime.TokenConstants.Eof"/>
            will be returned by the
            token stream lookahead methods.
            </summary>
            <param name="tokenSource">The token source.</param>
            <param name="channel">The channel to use for filtering tokens.</param>
        </member>
        <member name="M:Antlr4.Runtime.CommonTokenStream.GetNumberOfOnChannelTokens">
            <summary>Count EOF just once.</summary>
        </member>
        <member name="T:Antlr4.Runtime.ConsoleErrorListener`1">
            <author>Sam Harwell</author>
        </member>
        <member name="F:Antlr4.Runtime.ConsoleErrorListener`1.Instance">
            <summary>
            Provides a default instance of
            <see cref="T:Antlr4.Runtime.ConsoleErrorListener`1"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.ConsoleErrorListener`1.SyntaxError(Antlr4.Runtime.IRecognizer,`0,System.Int32,System.Int32,System.String,Antlr4.Runtime.RecognitionException)">
            <summary>
            <inheritDoc/>
            <p>
            This implementation prints messages to
            <see cref="P:System.Console.Error"/>
            containing the
            values of
            <paramref name="line"/>
            ,
            <paramref name="charPositionInLine"/>
            , and
            <paramref name="msg"/>
            using
            the following format.</p>
            <pre>
            line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>
            </pre>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.DefaultErrorStrategy">
            <summary>
            This is the default implementation of
            <see cref="T:Antlr4.Runtime.IAntlrErrorStrategy"/>
            used for
            error reporting and recovery in ANTLR parsers.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.DefaultErrorStrategy.errorRecoveryMode">
            <summary>
            Indicates whether the error strategy is currently "recovering from an
            error".
            </summary>
            <remarks>
            Indicates whether the error strategy is currently "recovering from an
            error". This is used to suppress reporting multiple error messages while
            attempting to recover from a detected syntax error.
            </remarks>
            <seealso cref="M:Antlr4.Runtime.DefaultErrorStrategy.InErrorRecoveryMode(Antlr4.Runtime.Parser)"/>
        </member>
        <member name="F:Antlr4.Runtime.DefaultErrorStrategy.lastErrorIndex">
            <summary>The index into the input stream where the last error occurred.</summary>
            <remarks>
            The index into the input stream where the last error occurred.
            This is used to prevent infinite loops where an error is found
            but no token is consumed during recovery...another error is found,
            ad nauseum.  This is a failsafe mechanism to guarantee that at least
            one token/tree node is consumed for two errors.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.Reset(Antlr4.Runtime.Parser)">
            <summary>
            <inheritDoc/>
            <p>The default implementation simply calls
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.EndErrorCondition(Antlr4.Runtime.Parser)"/>
            to
            ensure that the handler is not in error recovery mode.</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.BeginErrorCondition(Antlr4.Runtime.Parser)">
            <summary>
            This method is called to enter error recovery mode when a recognition
            exception is reported.
            </summary>
            <param name="recognizer">the parser instance</param>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.InErrorRecoveryMode(Antlr4.Runtime.Parser)">
            <summary><inheritDoc/></summary>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.EndErrorCondition(Antlr4.Runtime.Parser)">
            <summary>
            This method is called to leave error recovery mode after recovering from
            a recognition exception.
            </summary>
            <param name="recognizer"/>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.ReportMatch(Antlr4.Runtime.Parser)">
            <summary>
            <inheritDoc/>
            <p>The default implementation simply calls
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.EndErrorCondition(Antlr4.Runtime.Parser)"/>
            .</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.ReportError(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)">
            <summary>
            <inheritDoc/>
            <p>The default implementation returns immediately if the handler is already
            in error recovery mode. Otherwise, it calls
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.BeginErrorCondition(Antlr4.Runtime.Parser)"/>
            and dispatches the reporting task based on the runtime type of
            <paramref name="e"/>
            according to the following table.</p>
            <ul>
            <li>
            <see cref="T:Antlr4.Runtime.NoViableAltException"/>
            : Dispatches the call to
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.ReportNoViableAlternative(Antlr4.Runtime.Parser,Antlr4.Runtime.NoViableAltException)"/>
            </li>
            <li>
            <see cref="T:Antlr4.Runtime.InputMismatchException"/>
            : Dispatches the call to
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.ReportInputMismatch(Antlr4.Runtime.Parser,Antlr4.Runtime.InputMismatchException)"/>
            </li>
            <li>
            <see cref="T:Antlr4.Runtime.FailedPredicateException"/>
            : Dispatches the call to
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.ReportFailedPredicate(Antlr4.Runtime.Parser,Antlr4.Runtime.FailedPredicateException)"/>
            </li>
            <li>All other types: calls
            <see cref="M:Antlr4.Runtime.Parser.NotifyErrorListeners(System.String)"/>
            to report
            the exception</li>
            </ul>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.Recover(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)">
            <summary>
            <inheritDoc/>
            <p>The default implementation resynchronizes the parser by consuming tokens
            until we find one in the resynchronization set--loosely the set of tokens
            that can follow the current rule.</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.Sync(Antlr4.Runtime.Parser)">
            <summary>
            The default implementation of
            <see cref="M:Antlr4.Runtime.IAntlrErrorStrategy.Sync(Antlr4.Runtime.Parser)"/>
            makes sure
            that the current lookahead symbol is consistent with what were expecting
            at this point in the ATN. You can call this anytime but ANTLR only
            generates code to check before subrules/loops and each iteration.
            <p>Implements Jim Idle's magic sync mechanism in closures and optional
            subrules. E.g.,</p>
            <pre>
            a : sync ( stuff sync )* ;
            sync : {consume to what can follow sync} ;
            </pre>
            At the start of a sub rule upon error,
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.Sync(Antlr4.Runtime.Parser)"/>
            performs single
            token deletion, if possible. If it can't do that, it bails on the current
            rule and uses the default error recovery, which consumes until the
            resynchronization set of the current rule.
            <p>If the sub rule is optional (
            <c>(...)?</c>
            ,
            <c>(...)*</c>
            , or block
            with an empty alternative), then the expected set includes what follows
            the subrule.</p>
            <p>During loop iteration, it consumes until it sees a token that can start a
            sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
            stay in the loop as long as possible.</p>
            <p><strong>ORIGINS</strong></p>
            <p>Previous versions of ANTLR did a poor job of their recovery within loops.
            A single mismatch token or missing token would force the parser to bail
            out of the entire rules surrounding the loop. So, for rule</p>
            <pre>
            classDef : 'class' ID '{' member* '}'
            </pre>
            input with an extra token between members would force the parser to
            consume until it found the next class definition rather than the next
            member definition of the current class.
            <p>This functionality cost a little bit of effort because the parser has to
            compare token set at the start of the loop and at each iteration. If for
            some reason speed is suffering for you, you can turn off this
            functionality by simply overriding this method as a blank { }.</p>
            </summary>
            <exception cref="T:Antlr4.Runtime.RecognitionException"/>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.ReportNoViableAlternative(Antlr4.Runtime.Parser,Antlr4.Runtime.NoViableAltException)">
            <summary>
            This is called by
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.ReportError(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)"/>
            when the exception is a
            <see cref="T:Antlr4.Runtime.NoViableAltException"/>
            .
            </summary>
            <seealso cref="M:Antlr4.Runtime.DefaultErrorStrategy.ReportError(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)"/>
            <param name="recognizer">the parser instance</param>
            <param name="e">the recognition exception</param>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.ReportInputMismatch(Antlr4.Runtime.Parser,Antlr4.Runtime.InputMismatchException)">
            <summary>
            This is called by
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.ReportError(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)"/>
            when the exception is an
            <see cref="T:Antlr4.Runtime.InputMismatchException"/>
            .
            </summary>
            <seealso cref="M:Antlr4.Runtime.DefaultErrorStrategy.ReportError(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)"/>
            <param name="recognizer">the parser instance</param>
            <param name="e">the recognition exception</param>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.ReportFailedPredicate(Antlr4.Runtime.Parser,Antlr4.Runtime.FailedPredicateException)">
            <summary>
            This is called by
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.ReportError(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)"/>
            when the exception is a
            <see cref="T:Antlr4.Runtime.FailedPredicateException"/>
            .
            </summary>
            <seealso cref="M:Antlr4.Runtime.DefaultErrorStrategy.ReportError(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)"/>
            <param name="recognizer">the parser instance</param>
            <param name="e">the recognition exception</param>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.ReportUnwantedToken(Antlr4.Runtime.Parser)">
            <summary>
            This method is called to report a syntax error which requires the removal
            of a token from the input stream.
            </summary>
            <remarks>
            This method is called to report a syntax error which requires the removal
            of a token from the input stream. At the time this method is called, the
            erroneous symbol is current
            <c>LT(1)</c>
            symbol and has not yet been
            removed from the input stream. When this method returns,
            <paramref name="recognizer"/>
            is in error recovery mode.
            <p>This method is called when
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.SingleTokenDeletion(Antlr4.Runtime.Parser)"/>
            identifies
            single-token deletion as a viable recovery strategy for a mismatched
            input error.</p>
            <p>The default implementation simply returns if the handler is already in
            error recovery mode. Otherwise, it calls
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.BeginErrorCondition(Antlr4.Runtime.Parser)"/>
            to
            enter error recovery mode, followed by calling
            <see cref="M:Antlr4.Runtime.Parser.NotifyErrorListeners(System.String)"/>
            .</p>
            </remarks>
            <param name="recognizer">the parser instance</param>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.ReportMissingToken(Antlr4.Runtime.Parser)">
            <summary>
            This method is called to report a syntax error which requires the
            insertion of a missing token into the input stream.
            </summary>
            <remarks>
            This method is called to report a syntax error which requires the
            insertion of a missing token into the input stream. At the time this
            method is called, the missing token has not yet been inserted. When this
            method returns,
            <paramref name="recognizer"/>
            is in error recovery mode.
            <p>This method is called when
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.SingleTokenInsertion(Antlr4.Runtime.Parser)"/>
            identifies
            single-token insertion as a viable recovery strategy for a mismatched
            input error.</p>
            <p>The default implementation simply returns if the handler is already in
            error recovery mode. Otherwise, it calls
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.BeginErrorCondition(Antlr4.Runtime.Parser)"/>
            to
            enter error recovery mode, followed by calling
            <see cref="M:Antlr4.Runtime.Parser.NotifyErrorListeners(System.String)"/>
            .</p>
            </remarks>
            <param name="recognizer">the parser instance</param>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.RecoverInline(Antlr4.Runtime.Parser)">
            <summary>
            <inheritDoc/>
            <p>The default implementation attempts to recover from the mismatched input
            by using single token insertion and deletion as described below. If the
            recovery attempt fails, this method throws an
            <see cref="T:Antlr4.Runtime.InputMismatchException"/>
            .</p>
            <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>
            <p>
            <c>LA(1)</c>
            is not what we are looking for. If
            <c>LA(2)</c>
            has the
            right token, however, then assume
            <c>LA(1)</c>
            is some extra spurious
            token and delete it. Then consume and return the next token (which was
            the
            <c>LA(2)</c>
            token) as the successful result of the match operation.</p>
            <p>This recovery strategy is implemented by
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.SingleTokenDeletion(Antlr4.Runtime.Parser)"/>
            .</p>
            <p><strong>MISSING TOKEN</strong> (single token insertion)</p>
            <p>If current token (at
            <c>LA(1)</c>
            ) is consistent with what could come
            after the expected
            <c>LA(1)</c>
            token, then assume the token is missing
            and use the parser's
            <see cref="T:Antlr4.Runtime.ITokenFactory"/>
            to create it on the fly. The
            "insertion" is performed by returning the created token as the successful
            result of the match operation.</p>
            <p>This recovery strategy is implemented by
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.SingleTokenInsertion(Antlr4.Runtime.Parser)"/>
            .</p>
            <p><strong>EXAMPLE</strong></p>
            <p>For example, Input
            <c>i=(3;</c>
            is clearly missing the
            <c>')'</c>
            . When
            the parser returns from the nested call to
            <c>expr</c>
            , it will have
            call chain:</p>
            <pre>
            stat &#x2192; expr &#x2192; atom
            </pre>
            and it will be trying to match the
            <c>')'</c>
            at this point in the
            derivation:
            <pre>
            =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
            ^
            </pre>
            The attempt to match
            <c>')'</c>
            will fail when it sees
            <c>';'</c>
            and
            call
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.RecoverInline(Antlr4.Runtime.Parser)"/>
            . To recover, it sees that
            <c>LA(1)==';'</c>
            is in the set of tokens that can follow the
            <c>')'</c>
            token reference
            in rule
            <c>atom</c>
            . It can assume that you forgot the
            <c>')'</c>
            .
            </summary>
            <exception cref="T:Antlr4.Runtime.RecognitionException"/>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.SingleTokenInsertion(Antlr4.Runtime.Parser)">
            <summary>
            This method implements the single-token insertion inline error recovery
            strategy.
            </summary>
            <remarks>
            This method implements the single-token insertion inline error recovery
            strategy. It is called by
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.RecoverInline(Antlr4.Runtime.Parser)"/>
            if the single-token
            deletion strategy fails to recover from the mismatched input. If this
            method returns
            <see langword="true"/>
            ,
            <paramref name="recognizer"/>
            will be in error recovery
            mode.
            <p>This method determines whether or not single-token insertion is viable by
            checking if the
            <c>LA(1)</c>
            input symbol could be successfully matched
            if it were instead the
            <c>LA(2)</c>
            symbol. If this method returns
            <see langword="true"/>
            , the caller is responsible for creating and inserting a
            token with the correct type to produce this behavior.</p>
            </remarks>
            <param name="recognizer">the parser instance</param>
            <returns>
            
            <see langword="true"/>
            if single-token insertion is a viable recovery
            strategy for the current mismatched input, otherwise
            <see langword="false"/>
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.SingleTokenDeletion(Antlr4.Runtime.Parser)">
            <summary>
            This method implements the single-token deletion inline error recovery
            strategy.
            </summary>
            <remarks>
            This method implements the single-token deletion inline error recovery
            strategy. It is called by
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.RecoverInline(Antlr4.Runtime.Parser)"/>
            to attempt to recover
            from mismatched input. If this method returns null, the parser and error
            handler state will not have changed. If this method returns non-null,
            <paramref name="recognizer"/>
            will <em>not</em> be in error recovery mode since the
            returned token was a successful match.
            <p>If the single-token deletion is successful, this method calls
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.ReportUnwantedToken(Antlr4.Runtime.Parser)"/>
            to report the error, followed by
            <see cref="M:Antlr4.Runtime.Parser.Consume"/>
            to actually "delete" the extraneous token. Then,
            before returning
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.ReportMatch(Antlr4.Runtime.Parser)"/>
            is called to signal a successful
            match.</p>
            </remarks>
            <param name="recognizer">the parser instance</param>
            <returns>
            the successfully matched
            <see cref="T:Antlr4.Runtime.IToken"/>
            instance if single-token
            deletion successfully recovers from the mismatched input, otherwise
            <see langword="null"/>
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.GetMissingSymbol(Antlr4.Runtime.Parser)">
            <summary>Conjure up a missing token during error recovery.</summary>
            <remarks>
            Conjure up a missing token during error recovery.
            The recognizer attempts to recover from single missing
            symbols. But, actions might refer to that missing symbol.
            For example, x=ID {f($x);}. The action clearly assumes
            that there has been an identifier matched previously and that
            $x points at that token. If that token is missing, but
            the next token in the stream is what we want we assume that
            this token is missing and we keep going. Because we
            have to return some token to replace the missing token,
            we have to conjure one up. This method gives the user control
            over the tokens returned for missing tokens. Mostly,
            you will want to create something special for identifier
            tokens. For literals such as '{' and ',', the default
            action in the parser or tree parser works. It simply creates
            a CommonToken of the appropriate type. The text will be the token.
            If you change what tokens must be created by the lexer,
            override this method to create the appropriate tokens.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.GetTokenErrorDisplay(Antlr4.Runtime.IToken)">
            <summary>
            How should a token be displayed in an error message? The default
            is to display just the text, but during development you might
            want to have a lot of information spit out.
            </summary>
            <remarks>
            How should a token be displayed in an error message? The default
            is to display just the text, but during development you might
            want to have a lot of information spit out.  Override in that case
            to use t.toString() (which, for CommonToken, dumps everything about
            the token). This is better than forcing you to override a method in
            your token objects because you don't have to go modify your lexer
            so that it creates a new Java type.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.DefaultErrorStrategy.ConsumeUntil(Antlr4.Runtime.Parser,Antlr4.Runtime.Misc.IntervalSet)">
            <summary>Consume tokens until one matches the given token set.</summary>
        </member>
        <member name="T:Antlr4.Runtime.Dependents">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Dfa.AbstractEdgeMap`1">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Dfa.AcceptStateInfo">
            <summary>
            Stores information about a
            <see cref="T:Antlr4.Runtime.Dfa.DFAState"/>
            which is an accept state under
            some condition. Certain settings, such as
            <see cref="P:Antlr4.Runtime.Atn.ParserATNSimulator.PredictionMode"/>
            , may be used in addition to
            this information to determine whether or not a particular state is an accept
            state.
            </summary>
            <author>Sam Harwell</author>
        </member>
        <member name="P:Antlr4.Runtime.Dfa.AcceptStateInfo.Prediction">
            <summary>Gets the prediction made by this accept state.</summary>
            <remarks>
            Gets the prediction made by this accept state. Note that this value
            assumes the predicates, if any, in the
            <see cref="T:Antlr4.Runtime.Dfa.DFAState"/>
            evaluate to
            <see langword="true"/>
            . If predicate evaluation is enabled, the final prediction of
            the accept state will be determined by the result of predicate
            evaluation.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Dfa.AcceptStateInfo.LexerActionExecutor">
            <summary>
            Gets the
            <see cref="T:Antlr4.Runtime.Atn.LexerActionExecutor"/>
            which can be used to execute actions
            and/or commands after the lexer matches a token.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Dfa.ArrayEdgeMap`1">
            <author>Sam Harwell</author>
        </member>
        <member name="F:Antlr4.Runtime.Dfa.DFA.states">
            <summary>A set of all DFA states.</summary>
            <remarks>
            A set of all DFA states. Use
            <see cref="T:System.Collections.Generic.IDictionary`2"/>
            so we can get old state back
            (
            <see cref="T:System.Collections.Generic.HashSet`1"/>
            only allows you to see if it's there).
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Dfa.DFA.atnStartState">
            <summary>From which ATN state did we create this DFA?</summary>
        </member>
        <member name="F:Antlr4.Runtime.Dfa.DFA.precedenceDfa">
            <summary>
            <see langword="true"/>
            if this DFA is for a precedence decision; otherwise,
            <see langword="false"/>
            . This is the backing field for <see cref="P:Antlr4.Runtime.Dfa.DFA.IsPrecedenceDfa"/>.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Dfa.DFA.IsPrecedenceDfa">
            <summary>Gets whether this DFA is a precedence DFA.</summary>
            <remarks>
            Gets whether this DFA is a precedence DFA. Precedence DFAs use a special
            start state
            <see cref="F:Antlr4.Runtime.Dfa.DFA.s0"/>
            which is not stored in
            <see cref="F:Antlr4.Runtime.Dfa.DFA.states"/>
            . The
            <see cref="F:Antlr4.Runtime.Dfa.DFAState.edges"/>
            array for this start state contains outgoing edges
            supplying individual start states corresponding to specific precedence
            values.
            </remarks>
            <returns>
            
            <see langword="true"/>
            if this is a precedence DFA; otherwise,
            <see langword="false"/>
            .
            </returns>
            <seealso cref="P:Antlr4.Runtime.Parser.Precedence"/>
            <summary>Sets whether this is a precedence DFA.</summary>
            <value>
            
            <see langword="true"/>
            if this is a precedence DFA; otherwise,
            <see langword="false"/>
            </value>
            <exception cref="T:System.NotSupportedException">
            if
            <c>precedenceDfa</c>
            does not
            match the value of
            <see cref="P:Antlr4.Runtime.Dfa.DFA.IsPrecedenceDfa"/>
            for the current DFA.
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.Dfa.DFA.GetPrecedenceStartState(System.Int32,System.Boolean)">
            <summary>Get the start state for a specific precedence value.</summary>
            <param name="precedence">The current precedence.</param>
            <returns>
            The start state corresponding to the specified precedence, or
            <see langword="null"/>
            if no start state exists for the specified precedence.
            </returns>
            <exception cref="T:System.InvalidOperationException">if this is not a precedence DFA.</exception>
            <seealso cref="P:Antlr4.Runtime.Dfa.DFA.IsPrecedenceDfa"/>
        </member>
        <member name="M:Antlr4.Runtime.Dfa.DFA.SetPrecedenceStartState(System.Int32,System.Boolean,Antlr4.Runtime.Dfa.DFAState)">
            <summary>Set the start state for a specific precedence value.</summary>
            <param name="precedence">The current precedence.</param>
            <param name="startState">
            The start state corresponding to the specified
            precedence.
            </param>
            <exception cref="T:System.InvalidOperationException">if this is not a precedence DFA.</exception>
            <seealso cref="P:Antlr4.Runtime.Dfa.DFA.IsPrecedenceDfa"/>
        </member>
        <member name="T:Antlr4.Runtime.Dfa.DFASerializer">
            <summary>A DFA walker that knows how to dump them to serialized strings.</summary>
        </member>
        <member name="T:Antlr4.Runtime.Dfa.DFAState">
            <summary>A DFA state represents a set of possible ATN configurations.</summary>
            <remarks>
            A DFA state represents a set of possible ATN configurations.
            As Aho, Sethi, Ullman p. 117 says "The DFA uses its state
            to keep track of all possible states the ATN can be in after
            reading each input symbol.  That is to say, after reading
            input a1a2..an, the DFA is in a state that represents the
            subset T of the states of the ATN that are reachable from the
            ATN's start state along some path labeled a1a2..an."
            In conventional NFA&#x2192;DFA conversion, therefore, the subset T
            would be a bitset representing the set of states the
            ATN could be in.  We need to track the alt predicted by each
            state as well, however.  More importantly, we need to maintain
            a stack of states, tracking the closure operations as they
            jump from rule to rule, emulating rule invocations (method calls).
            I have to add a stack to simulate the proper lookahead sequences for
            the underlying LL grammar from which the ATN was derived.
            <p>I use a set of ATNConfig objects not simple states.  An ATNConfig
            is both a state (ala normal conversion) and a RuleContext describing
            the chain of rules (if any) followed to arrive at that state.</p>
            <p>A DFA state may have multiple references to a particular state,
            but with different ATN contexts (with same or different alts)
            meaning that state was reached via a different set of rule invocations.</p>
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Dfa.DFAState.edges">
            <summary>
            <c>edges.get(symbol)</c>
            points to target of symbol.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Dfa.DFAState.contextEdges">
            <summary>These keys for these edges are the top level element of the global context.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Dfa.DFAState.contextSymbols">
            <summary>Symbols in this set require a global context transition before matching an input symbol.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Dfa.DFAState.predicates">
            <summary>
            This list is computed by
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.PredicateDFAState(Antlr4.Runtime.Dfa.DFAState,Antlr4.Runtime.Atn.ATNConfigSet,System.Int32)"/>
            .
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Dfa.DFAState.PredPrediction">
            <summary>Map a predicate to a predicted alternative.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Dfa.DFAState.Equals(System.Object)">
            <summary>
            Two
            <see cref="T:Antlr4.Runtime.Dfa.DFAState"/>
            instances are equal if their ATN configuration sets
            are the same. This method is used to see if a state already exists.
            <p>Because the number of alternatives and number of ATN configurations are
            finite, there is a finite number of DFA states that can be processed.
            This is necessary to show that the algorithm terminates.</p>
            <p>Cannot test the DFA state numbers here because in
            <see cref="M:Antlr4.Runtime.Atn.ParserATNSimulator.AddDFAState(Antlr4.Runtime.Dfa.DFA,Antlr4.Runtime.Atn.ATNConfigSet,Antlr4.Runtime.Atn.PredictionContextCache)"/>
            we need to know if any other state
            exists that has this exact set of ATN configurations. The
            <see cref="F:Antlr4.Runtime.Dfa.DFAState.stateNumber"/>
            is irrelevant.</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Dfa.EmptyEdgeMap`1">
            <summary>
            This implementation of
            <see cref="T:Antlr4.Runtime.Dfa.AbstractEdgeMap`1"/>
            represents an empty edge map.
            </summary>
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Dfa.IEdgeMap`1">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Dfa.SingletonEdgeMap`1">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Dfa.SparseEdgeMap`1">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.DiagnosticErrorListener">
            <summary>
            This implementation of
            <see cref="T:Antlr4.Runtime.IAntlrErrorListener`1"/>
            can be used to identify
            certain potential correctness and performance problems in grammars. "Reports"
            are made by calling
            <see cref="M:Antlr4.Runtime.Parser.NotifyErrorListeners(System.String)"/>
            with the appropriate
            message.
            <ul>
            <li><b>Ambiguities</b>: These are cases where more than one path through the
            grammar can match the input.</li>
            <li><b>Weak context sensitivity</b>: These are cases where full-context
            prediction resolved an SLL conflict to a unique alternative which equaled the
            minimum alternative of the SLL conflict.</li>
            <li><b>Strong (forced) context sensitivity</b>: These are cases where the
            full-context prediction resolved an SLL conflict to a unique alternative,
            <em>and</em> the minimum alternative of the SLL conflict was found to not be
            a truly viable alternative. Two-stage parsing cannot be used for inputs where
            this situation occurs.</li>
            </ul>
            </summary>
            <author>Sam Harwell</author>
        </member>
        <member name="F:Antlr4.Runtime.DiagnosticErrorListener.exactOnly">
            <summary>
            When
            <see langword="true"/>
            , only exactly known ambiguities are reported.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.DiagnosticErrorListener.#ctor">
            <summary>
            Initializes a new instance of
            <see cref="T:Antlr4.Runtime.DiagnosticErrorListener"/>
            which only
            reports exact ambiguities.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.DiagnosticErrorListener.#ctor(System.Boolean)">
            <summary>
            Initializes a new instance of
            <see cref="T:Antlr4.Runtime.DiagnosticErrorListener"/>
            , specifying
            whether all ambiguities or only exact ambiguities are reported.
            </summary>
            <param name="exactOnly">
            
            <see langword="true"/>
            to report only exact ambiguities, otherwise
            <see langword="false"/>
            to report all ambiguities.
            </param>
        </member>
        <member name="M:Antlr4.Runtime.DiagnosticErrorListener.GetConflictingAlts(Antlr4.Runtime.Sharpen.BitSet,Antlr4.Runtime.Atn.ATNConfigSet)">
            <summary>
            Computes the set of conflicting or ambiguous alternatives from a
            configuration set, if that information was not already provided by the
            parser.
            </summary>
            <param name="reportedAlts">
            The set of conflicting or ambiguous alternatives, as
            reported by the parser.
            </param>
            <param name="configs">The conflicting or ambiguous configuration set.</param>
            <returns>
            Returns
            <paramref name="reportedAlts"/>
            if it is not
            <see langword="null"/>
            , otherwise
            returns the set of alternatives represented in
            <paramref name="configs"/>
            .
            </returns>
        </member>
        <member name="T:Antlr4.Runtime.FailedPredicateException">
            <summary>A semantic predicate failed during validation.</summary>
            <remarks>
            A semantic predicate failed during validation.  Validation of predicates
            occurs when normally parsing the alternative just like matching a token.
            Disambiguating predicate evaluation occurs when we test a predicate during
            prediction.
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.IAntlrErrorListener`1">
            <summary>How to emit recognition errors.</summary>
        </member>
        <member name="M:Antlr4.Runtime.IAntlrErrorListener`1.SyntaxError(Antlr4.Runtime.IRecognizer,`0,System.Int32,System.Int32,System.String,Antlr4.Runtime.RecognitionException)">
            <summary>Upon syntax error, notify any interested parties.</summary>
            <remarks>
            Upon syntax error, notify any interested parties. This is not how to
            recover from errors or compute error messages.
            <see cref="T:Antlr4.Runtime.IAntlrErrorStrategy"/>
            specifies how to recover from syntax errors and how to compute error
            messages. This listener's job is simply to emit a computed message,
            though it has enough information to create its own message in many cases.
            <p>The
            <see cref="T:Antlr4.Runtime.RecognitionException"/>
            is non-null for all syntax errors except
            when we discover mismatched token errors that we can recover from
            in-line, without returning from the surrounding rule (via the single
            token insertion and deletion mechanism).</p>
            </remarks>
            <param name="recognizer">
            What parser got the error. From this
            object, you can access the context as well
            as the input stream.
            </param>
            <param name="offendingSymbol">
            The offending token in the input token
            stream, unless recognizer is a lexer (then it's null). If
            no viable alternative error,
            <paramref name="e"/>
            has token at which we
            started production for the decision.
            </param>
            <param name="line">The line number in the input where the error occurred.</param>
            <param name="charPositionInLine">The character position within that line where the error occurred.</param>
            <param name="msg">The message to emit.</param>
            <param name="e">
            The exception generated by the parser that led to
            the reporting of an error. It is null in the case where
            the parser was able to recover in line without exiting the
            surrounding rule.
            </param>
        </member>
        <member name="T:Antlr4.Runtime.IAntlrErrorStrategy">
            <summary>
            The interface for defining strategies to deal with syntax errors encountered
            during a parse by ANTLR-generated parsers.
            </summary>
            <remarks>
            The interface for defining strategies to deal with syntax errors encountered
            during a parse by ANTLR-generated parsers. We distinguish between three
            different kinds of errors:
            <ul>
            <li>The parser could not figure out which path to take in the ATN (none of
            the available alternatives could possibly match)</li>
            <li>The current input does not match what we were looking for</li>
            <li>A predicate evaluated to false</li>
            </ul>
            Implementations of this interface report syntax errors by calling
            <see cref="M:Antlr4.Runtime.Parser.NotifyErrorListeners(System.String)"/>
            .
            <p>TODO: what to do about lexers</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.IAntlrErrorStrategy.Reset(Antlr4.Runtime.Parser)">
            <summary>
            Reset the error handler state for the specified
            <paramref name="recognizer"/>
            .
            </summary>
            <param name="recognizer">the parser instance</param>
        </member>
        <member name="M:Antlr4.Runtime.IAntlrErrorStrategy.RecoverInline(Antlr4.Runtime.Parser)">
            <summary>
            This method is called when an unexpected symbol is encountered during an
            inline match operation, such as
            <see cref="M:Antlr4.Runtime.Parser.Match(System.Int32)"/>
            . If the error
            strategy successfully recovers from the match failure, this method
            returns the
            <see cref="T:Antlr4.Runtime.IToken"/>
            instance which should be treated as the
            successful result of the match.
            <p>This method handles the consumption of any tokens - the caller should
            <em>not</em> call
            <see cref="M:Antlr4.Runtime.Parser.Consume"/>
            after a successful recovery.</p>
            <p>Note that the calling code will not report an error if this method
            returns successfully. The error strategy implementation is responsible
            for calling
            <see cref="M:Antlr4.Runtime.Parser.NotifyErrorListeners(System.String)"/>
            as appropriate.</p>
            </summary>
            <param name="recognizer">the parser instance</param>
            <exception cref="T:Antlr4.Runtime.RecognitionException">
            if the error strategy was not able to
            recover from the unexpected input symbol
            </exception>
            <exception cref="T:Antlr4.Runtime.RecognitionException"/>
        </member>
        <member name="M:Antlr4.Runtime.IAntlrErrorStrategy.Recover(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)">
            <summary>
            This method is called to recover from exception
            <paramref name="e"/>
            . This method is
            called after
            <see cref="M:Antlr4.Runtime.IAntlrErrorStrategy.ReportError(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)"/>
            by the default exception handler
            generated for a rule method.
            </summary>
            <seealso cref="M:Antlr4.Runtime.IAntlrErrorStrategy.ReportError(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)"/>
            <param name="recognizer">the parser instance</param>
            <param name="e">the recognition exception to recover from</param>
            <exception cref="T:Antlr4.Runtime.RecognitionException">
            if the error strategy could not recover from
            the recognition exception
            </exception>
            <exception cref="T:Antlr4.Runtime.RecognitionException"/>
        </member>
        <member name="M:Antlr4.Runtime.IAntlrErrorStrategy.Sync(Antlr4.Runtime.Parser)">
            <summary>
            This method provides the error handler with an opportunity to handle
            syntactic or semantic errors in the input stream before they result in a
            <see cref="T:Antlr4.Runtime.RecognitionException"/>
            .
            <p>The generated code currently contains calls to
            <see cref="M:Antlr4.Runtime.IAntlrErrorStrategy.Sync(Antlr4.Runtime.Parser)"/>
            after
            entering the decision state of a closure block (
            <c>(...)*</c>
            or
            <c>(...)+</c>
            ).</p>
            <p>For an implementation based on Jim Idle's "magic sync" mechanism, see
            <see cref="M:Antlr4.Runtime.DefaultErrorStrategy.Sync(Antlr4.Runtime.Parser)"/>
            .</p>
            </summary>
            <seealso cref="M:Antlr4.Runtime.DefaultErrorStrategy.Sync(Antlr4.Runtime.Parser)"/>
            <param name="recognizer">the parser instance</param>
            <exception cref="T:Antlr4.Runtime.RecognitionException">
            if an error is detected by the error
            strategy but cannot be automatically recovered at the current state in
            the parsing process
            </exception>
            <exception cref="T:Antlr4.Runtime.RecognitionException"/>
        </member>
        <member name="M:Antlr4.Runtime.IAntlrErrorStrategy.InErrorRecoveryMode(Antlr4.Runtime.Parser)">
            <summary>
            Tests whether or not
            <paramref name="recognizer"/>
            is in the process of recovering
            from an error. In error recovery mode,
            <see cref="M:Antlr4.Runtime.Parser.Consume"/>
            adds
            symbols to the parse tree by calling
            <see cref="M:Antlr4.Runtime.ParserRuleContext.AddErrorNode(Antlr4.Runtime.IToken)"/>
            instead of
            <see cref="M:Antlr4.Runtime.ParserRuleContext.AddChild(Antlr4.Runtime.IToken)"/>
            .
            </summary>
            <param name="recognizer">the parser instance</param>
            <returns>
            
            <see langword="true"/>
            if the parser is currently recovering from a parse
            error, otherwise
            <see langword="false"/>
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.IAntlrErrorStrategy.ReportMatch(Antlr4.Runtime.Parser)">
            <summary>
            This method is called by when the parser successfully matches an input
            symbol.
            </summary>
            <param name="recognizer">the parser instance</param>
        </member>
        <member name="M:Antlr4.Runtime.IAntlrErrorStrategy.ReportError(Antlr4.Runtime.Parser,Antlr4.Runtime.RecognitionException)">
            <summary>
            Report any kind of
            <see cref="T:Antlr4.Runtime.RecognitionException"/>
            . This method is called by
            the default exception handler generated for a rule method.
            </summary>
            <param name="recognizer">the parser instance</param>
            <param name="e">the recognition exception to report</param>
        </member>
        <member name="T:Antlr4.Runtime.ICharStream">
            <summary>A source of characters for an ANTLR lexer.</summary>
        </member>
        <member name="M:Antlr4.Runtime.ICharStream.GetText(Antlr4.Runtime.Misc.Interval)">
            <summary>
            This method returns the text for a range of characters within this input
            stream.
            </summary>
            <remarks>
            This method returns the text for a range of characters within this input
            stream. This method is guaranteed to not throw an exception if the
            specified
            <paramref name="interval"/>
            lies entirely within a marked range. For more
            information about marked ranges, see
            <see cref="M:Antlr4.Runtime.IIntStream.Mark"/>
            .
            </remarks>
            <param name="interval">an interval within the stream</param>
            <returns>the text of the specified interval</returns>
            <exception cref="T:System.ArgumentNullException">
            if
            <paramref name="interval"/>
            is
            <see langword="null"/>
            </exception>
            <exception cref="T:System.ArgumentException">
            if
            <c>interval.a &lt; 0</c>
            , or if
            <c>interval.b &lt; interval.a - 1</c>
            , or if
            <c>interval.b</c>
            lies at or
            past the end of the stream
            </exception>
            <exception cref="T:System.NotSupportedException">
            if the stream does not support
            getting the text of the specified interval
            </exception>
        </member>
        <member name="T:Antlr4.Runtime.IIntStream">
            <summary>A simple stream of symbols whose values are represented as integers.</summary>
            <remarks>
            A simple stream of symbols whose values are represented as integers. This
            interface provides <em>marked ranges</em> with support for a minimum level
            of buffering necessary to implement arbitrary lookahead during prediction.
            For more information on marked ranges, see
            <see cref="M:Antlr4.Runtime.IIntStream.Mark"/>
            .
            <p><strong>Initializing Methods:</strong> Some methods in this interface have
            unspecified behavior if no call to an initializing method has occurred after
            the stream was constructed. The following is a list of initializing methods:</p>
            <ul>
            <li>
            <see cref="M:Antlr4.Runtime.IIntStream.La(System.Int32)"/>
            </li>
            <li>
            <see cref="M:Antlr4.Runtime.IIntStream.Consume"/>
            </li>
            <li>
            <see cref="P:Antlr4.Runtime.IIntStream.Size"/>
            </li>
            </ul>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.IIntStream.Consume">
            <summary>Consumes the current symbol in the stream.</summary>
            <remarks>
            Consumes the current symbol in the stream. This method has the following
            effects:
            <ul>
            <li><strong>Forward movement:</strong> The value of
            <see cref="P:Antlr4.Runtime.IIntStream.Index">index()</see>
            before calling this method is less than the value of
            <c>index()</c>
            after calling this method.</li>
            <li><strong>Ordered lookahead:</strong> The value of
            <c>LA(1)</c>
            before
            calling this method becomes the value of
            <c>LA(-1)</c>
            after calling
            this method.</li>
            </ul>
            Note that calling this method does not guarantee that
            <c>index()</c>
            is
            incremented by exactly 1, as that would preclude the ability to implement
            filtering streams (e.g.
            <see cref="T:Antlr4.Runtime.CommonTokenStream"/>
            which distinguishes
            between "on-channel" and "off-channel" tokens).
            </remarks>
            <exception cref="T:System.InvalidOperationException">
            if an attempt is made to consume the the
            end of the stream (i.e. if
            <c>LA(1)==</c>
            <see cref="F:Antlr4.Runtime.IntStreamConstants.Eof">EOF</see>
            before calling
            <c>consume</c>
            ).
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.IIntStream.La(System.Int32)">
            <summary>
            Gets the value of the symbol at offset
            <paramref name="i"/>
            from the current
            position. When
            <c>i==1</c>
            , this method returns the value of the current
            symbol in the stream (which is the next symbol to be consumed). When
            <c>i==-1</c>
            , this method returns the value of the previously read
            symbol in the stream. It is not valid to call this method with
            <c>i==0</c>
            , but the specific behavior is unspecified because this
            method is frequently called from performance-critical code.
            <p>This method is guaranteed to succeed if any of the following are true:</p>
            <ul>
            <li>
            <c>i&gt;0</c>
            </li>
            <li>
            <c>i==-1</c>
            and
            <see cref="P:Antlr4.Runtime.IIntStream.Index">index()</see>
            returns a value greater
            than the value of
            <c>index()</c>
            after the stream was constructed
            and
            <c>LA(1)</c>
            was called in that order. Specifying the current
            <c>index()</c>
            relative to the index after the stream was created
            allows for filtering implementations that do not return every symbol
            from the underlying source. Specifying the call to
            <c>LA(1)</c>
            allows for lazily initialized streams.</li>
            <li>
            <c>LA(i)</c>
            refers to a symbol consumed within a marked region
            that has not yet been released.</li>
            </ul>
            <p>If
            <paramref name="i"/>
            represents a position at or beyond the end of the stream,
            this method returns
            <see cref="F:Antlr4.Runtime.IntStreamConstants.Eof"/>
            .</p>
            <p>The return value is unspecified if
            <c>i&lt;0</c>
            and fewer than
            <c>-i</c>
            calls to
            <see cref="M:Antlr4.Runtime.IIntStream.Consume">consume()</see>
            have occurred from the beginning of
            the stream before calling this method.</p>
            </summary>
            <exception cref="T:System.NotSupportedException">
            if the stream does not support
            retrieving the value of the specified symbol
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.IIntStream.Mark">
            <summary>
            A mark provides a guarantee that
            <see cref="M:Antlr4.Runtime.IIntStream.Seek(System.Int32)">seek()</see>
            operations will be
            valid over a "marked range" extending from the index where
            <c>mark()</c>
            was called to the current
            <see cref="P:Antlr4.Runtime.IIntStream.Index">index()</see>
            . This allows the use of
            streaming input sources by specifying the minimum buffering requirements
            to support arbitrary lookahead during prediction.
            <p>The returned mark is an opaque handle (type
            <c>int</c>
            ) which is passed
            to
            <see cref="M:Antlr4.Runtime.IIntStream.Release(System.Int32)">release()</see>
            when the guarantees provided by the marked
            range are no longer necessary. When calls to
            <c>mark()</c>
            /
            <c>release()</c>
            are nested, the marks must be released
            in reverse order of which they were obtained. Since marked regions are
            used during performance-critical sections of prediction, the specific
            behavior of invalid usage is unspecified (i.e. a mark is not released, or
            a mark is released twice, or marks are not released in reverse order from
            which they were created).</p>
            <p>The behavior of this method is unspecified if no call to an
            <see cref="T:Antlr4.Runtime.IIntStream">initializing method</see>
            has occurred after this stream was
            constructed.</p>
            <p>This method does not change the current position in the input stream.</p>
            <p>The following example shows the use of
            <see cref="M:Antlr4.Runtime.IIntStream.Mark">mark()</see>
            ,
            <see cref="M:Antlr4.Runtime.IIntStream.Release(System.Int32)">release(mark)</see>
            ,
            <see cref="P:Antlr4.Runtime.IIntStream.Index">index()</see>
            , and
            <see cref="M:Antlr4.Runtime.IIntStream.Seek(System.Int32)">seek(index)</see>
            as part of an operation to safely work within a
            marked region, then restore the stream position to its original value and
            release the mark.</p>
            <pre>
            IntStream stream = ...;
            int index = -1;
            int mark = stream.mark();
            try {
            index = stream.index();
            // perform work here...
            } finally {
            if (index != -1) {
            stream.seek(index);
            }
            stream.release(mark);
            }
            </pre>
            </summary>
            <returns>
            An opaque marker which should be passed to
            <see cref="M:Antlr4.Runtime.IIntStream.Release(System.Int32)">release()</see>
            when the marked range is no longer required.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.IIntStream.Release(System.Int32)">
            <summary>
            This method releases a marked range created by a call to
            <see cref="M:Antlr4.Runtime.IIntStream.Mark">mark()</see>
            . Calls to
            <c>release()</c>
            must appear in the
            reverse order of the corresponding calls to
            <c>mark()</c>
            . If a mark is
            released twice, or if marks are not released in reverse order of the
            corresponding calls to
            <c>mark()</c>
            , the behavior is unspecified.
            <p>For more information and an example, see
            <see cref="M:Antlr4.Runtime.IIntStream.Mark"/>
            .</p>
            </summary>
            <param name="marker">
            A marker returned by a call to
            <c>mark()</c>
            .
            </param>
            <seealso cref="M:Antlr4.Runtime.IIntStream.Mark"/>
        </member>
        <member name="P:Antlr4.Runtime.IIntStream.Index">
            <summary>
            Return the index into the stream of the input symbol referred to by
            <c>LA(1)</c>
            .
            <p>The behavior of this method is unspecified if no call to an
            <see cref="T:Antlr4.Runtime.IIntStream">initializing method</see>
            has occurred after this stream was
            constructed.</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.IIntStream.Seek(System.Int32)">
            <summary>
            Set the input cursor to the position indicated by
            <paramref name="index"/>
            . If the
            specified index lies past the end of the stream, the operation behaves as
            though
            <paramref name="index"/>
            was the index of the EOF symbol. After this method
            returns without throwing an exception, then at least one of the following
            will be true.
            <ul>
            <li>
            <see cref="P:Antlr4.Runtime.IIntStream.Index">index()</see>
            will return the index of the first symbol
            appearing at or after the specified
            <paramref name="index"/>
            . Specifically,
            implementations which filter their sources should automatically
            adjust
            <paramref name="index"/>
            forward the minimum amount required for the
            operation to target a non-ignored symbol.</li>
            <li>
            <c>LA(1)</c>
            returns
            <see cref="F:Antlr4.Runtime.IntStreamConstants.Eof"/>
            </li>
            </ul>
            This operation is guaranteed to not throw an exception if
            <paramref name="index"/>
            lies within a marked region. For more information on marked regions, see
            <see cref="M:Antlr4.Runtime.IIntStream.Mark"/>
            . The behavior of this method is unspecified if no call to
            an
            <see cref="T:Antlr4.Runtime.IIntStream">initializing method</see>
            has occurred after this stream
            was constructed.
            </summary>
            <param name="index">The absolute index to seek to.</param>
            <exception cref="T:System.ArgumentException">
            if
            <paramref name="index"/>
            is less than 0
            </exception>
            <exception cref="T:System.NotSupportedException">
            if the stream does not support
            seeking to the specified index
            </exception>
        </member>
        <member name="P:Antlr4.Runtime.IIntStream.Size">
            <summary>
            Returns the total number of symbols in the stream, including a single EOF
            symbol.
            </summary>
            <exception cref="T:System.NotSupportedException">
            if the size of the stream is
            unknown.
            </exception>
        </member>
        <member name="P:Antlr4.Runtime.IIntStream.SourceName">
            <summary>Gets the name of the underlying symbol source.</summary>
            <remarks>
            Gets the name of the underlying symbol source. This method returns a
            non-null, non-empty string. If such a name is not known, this method
            returns
            <see cref="F:Antlr4.Runtime.IntStreamConstants.UnknownSourceName"/>
            .
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.IntStreamConstants.Eof">
            <summary>
            The value returned by
            <see cref="M:Antlr4.Runtime.IIntStream.La(System.Int32)">LA()</see>
            when the end of the stream is
            reached.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.IntStreamConstants.UnknownSourceName">
            <summary>
            The value returned by
            <see cref="P:Antlr4.Runtime.IIntStream.SourceName"/>
            when the actual name of the
            underlying source is not known.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.InputMismatchException">
            <summary>
            This signifies any kind of mismatched input exceptions such as
            when the current input does not match the expected token.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.InterpreterRuleContext">
            <summary>
            This class extends
            <see cref="T:Antlr4.Runtime.ParserRuleContext"/>
            by allowing the value of
            <see cref="P:Antlr4.Runtime.InterpreterRuleContext.RuleIndex"/>
            to be explicitly set for the context.
            <p>
            <see cref="T:Antlr4.Runtime.ParserRuleContext"/>
            does not include field storage for the rule index
            since the context classes created by the code generator override the
            <see cref="P:Antlr4.Runtime.InterpreterRuleContext.RuleIndex"/>
            method to return the correct value for that context.
            Since the parser interpreter does not use the context classes generated for a
            parser, this class (with slightly more memory overhead per node) is used to
            provide equivalent functionality.</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.InterpreterRuleContext.ruleIndex">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.InterpreterRuleContext.RuleIndex"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.InterpreterRuleContext.#ctor(Antlr4.Runtime.ParserRuleContext,System.Int32,System.Int32)">
            <summary>
            Constructs a new
            <see cref="T:Antlr4.Runtime.InterpreterRuleContext"/>
            with the specified
            parent, invoking state, and rule index.
            </summary>
            <param name="parent">The parent context.</param>
            <param name="invokingStateNumber">The invoking state number.</param>
            <param name="ruleIndex">The rule index for the current context.</param>
        </member>
        <member name="T:Antlr4.Runtime.IParserErrorListener">
            <summary>How to emit recognition errors for parsers.</summary>
        </member>
        <member name="M:Antlr4.Runtime.IParserErrorListener.ReportAmbiguity(Antlr4.Runtime.Parser,Antlr4.Runtime.Dfa.DFA,System.Int32,System.Int32,System.Boolean,Antlr4.Runtime.Sharpen.BitSet,Antlr4.Runtime.Atn.ATNConfigSet)">
            <summary>
            This method is called by the parser when a full-context prediction
            results in an ambiguity.
            </summary>
            <remarks>
            This method is called by the parser when a full-context prediction
            results in an ambiguity.
            <p>Each full-context prediction which does not result in a syntax error
            will call either
            <see cref="M:Antlr4.Runtime.IParserErrorListener.ReportContextSensitivity(Antlr4.Runtime.Parser,Antlr4.Runtime.Dfa.DFA,System.Int32,System.Int32,System.Int32,Antlr4.Runtime.Atn.SimulatorState)"/>
            or
            <see cref="M:Antlr4.Runtime.IParserErrorListener.ReportAmbiguity(Antlr4.Runtime.Parser,Antlr4.Runtime.Dfa.DFA,System.Int32,System.Int32,System.Boolean,Antlr4.Runtime.Sharpen.BitSet,Antlr4.Runtime.Atn.ATNConfigSet)"/>
            .</p>
            <p>
            When
            <paramref name="ambigAlts"/>
            is not null, it contains the set of potentially
            viable alternatives identified by the prediction algorithm. When
            <paramref name="ambigAlts"/>
            is null, use
            <see cref="P:Antlr4.Runtime.Atn.ATNConfigSet.RepresentedAlternatives"/>
            to obtain the represented
            alternatives from the
            <paramref name="configs"/>
            argument.</p>
            <p>When
            <paramref name="exact"/>
            is
            <see langword="true"/>
            , <em>all</em> of the potentially
            viable alternatives are truly viable, i.e. this is reporting an exact
            ambiguity. When
            <paramref name="exact"/>
            is
            <see langword="false"/>
            , <em>at least two</em> of
            the potentially viable alternatives are viable for the current input, but
            the prediction algorithm terminated as soon as it determined that at
            least the <em>minimum</em> potentially viable alternative is truly
            viable.</p>
            <p>When the
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
            prediction
            mode is used, the parser is required to identify exact ambiguities so
            <paramref name="exact"/>
            will always be
            <see langword="true"/>
            .</p>
            </remarks>
            <param name="recognizer">the parser instance</param>
            <param name="dfa">the DFA for the current decision</param>
            <param name="startIndex">the input index where the decision started</param>
            <param name="stopIndex">the input input where the ambiguity was identified</param>
            <param name="exact">
            
            <see langword="true"/>
            if the ambiguity is exactly known, otherwise
            <see langword="false"/>
            . This is always
            <see langword="true"/>
            when
            <see cref="F:Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
            is used.
            </param>
            <param name="ambigAlts">
            the potentially ambiguous alternatives, or
            <see langword="null"/>
            to indicate that the potentially ambiguous alternatives are the complete
            set of represented alternatives in
            <paramref name="configs"/>
            </param>
            <param name="configs">
            the ATN configuration set where the ambiguity was
            identified
            </param>
        </member>
        <member name="M:Antlr4.Runtime.IParserErrorListener.ReportAttemptingFullContext(Antlr4.Runtime.Parser,Antlr4.Runtime.Dfa.DFA,System.Int32,System.Int32,Antlr4.Runtime.Sharpen.BitSet,Antlr4.Runtime.Atn.SimulatorState)">
            <summary>
            This method is called when an SLL conflict occurs and the parser is about
            to use the full context information to make an LL decision.
            </summary>
            <remarks>
            This method is called when an SLL conflict occurs and the parser is about
            to use the full context information to make an LL decision.
            <p>If one or more configurations in
            <c>configs</c>
            contains a semantic
            predicate, the predicates are evaluated before this method is called. The
            subset of alternatives which are still viable after predicates are
            evaluated is reported in
            <paramref name="conflictingAlts"/>
            .</p>
            </remarks>
            <param name="recognizer">the parser instance</param>
            <param name="dfa">the DFA for the current decision</param>
            <param name="startIndex">the input index where the decision started</param>
            <param name="stopIndex">the input index where the SLL conflict occurred</param>
            <param name="conflictingAlts">
            The specific conflicting alternatives. If this is
            <see langword="null"/>
            , the conflicting alternatives are all alternatives
            represented in
            <c>configs</c>
            .
            </param>
            <param name="conflictState">
            the simulator state when the SLL conflict was
            detected
            </param>
        </member>
        <member name="M:Antlr4.Runtime.IParserErrorListener.ReportContextSensitivity(Antlr4.Runtime.Parser,Antlr4.Runtime.Dfa.DFA,System.Int32,System.Int32,System.Int32,Antlr4.Runtime.Atn.SimulatorState)">
            <summary>
            This method is called by the parser when a full-context prediction has a
            unique result.
            </summary>
            <remarks>
            This method is called by the parser when a full-context prediction has a
            unique result.
            <p>Each full-context prediction which does not result in a syntax error
            will call either
            <see cref="M:Antlr4.Runtime.IParserErrorListener.ReportContextSensitivity(Antlr4.Runtime.Parser,Antlr4.Runtime.Dfa.DFA,System.Int32,System.Int32,System.Int32,Antlr4.Runtime.Atn.SimulatorState)"/>
            or
            <see cref="M:Antlr4.Runtime.IParserErrorListener.ReportAmbiguity(Antlr4.Runtime.Parser,Antlr4.Runtime.Dfa.DFA,System.Int32,System.Int32,System.Boolean,Antlr4.Runtime.Sharpen.BitSet,Antlr4.Runtime.Atn.ATNConfigSet)"/>
            .</p>
            <p>For prediction implementations that only evaluate full-context
            predictions when an SLL conflict is found (including the default
            <see cref="T:Antlr4.Runtime.Atn.ParserATNSimulator"/>
            implementation), this method reports cases
            where SLL conflicts were resolved to unique full-context predictions,
            i.e. the decision was context-sensitive. This report does not necessarily
            indicate a problem, and it may appear even in completely unambiguous
            grammars.</p>
            <p>
            <c>configs</c>
            may have more than one represented alternative if the
            full-context prediction algorithm does not evaluate predicates before
            beginning the full-context prediction. In all cases, the final prediction
            is passed as the
            <paramref name="prediction"/>
            argument.</p>
            <p>Note that the definition of "context sensitivity" in this method
            differs from the concept in
            <see cref="F:Antlr4.Runtime.Atn.DecisionInfo.contextSensitivities"/>
            .
            This method reports all instances where an SLL conflict occurred but LL
            parsing produced a unique result, whether or not that unique result
            matches the minimum alternative in the SLL conflicting set.</p>
            </remarks>
            <param name="recognizer">the parser instance</param>
            <param name="dfa">the DFA for the current decision</param>
            <param name="startIndex">the input index where the decision started</param>
            <param name="stopIndex">
            the input index where the context sensitivity was
            finally determined
            </param>
            <param name="prediction">the unambiguous result of the full-context prediction</param>
            <param name="acceptState">
            the simulator state when the unambiguous prediction
            was determined
            </param>
        </member>
        <member name="T:Antlr4.Runtime.IToken">
            <summary>
            A token has properties: text, type, line, character position in the line
            (so we can ignore tabs), token channel, index, and source from which
            we obtained this token.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.IToken.Text">
            <summary>Get the text of the token.</summary>
        </member>
        <member name="P:Antlr4.Runtime.IToken.Type">
            <summary>Get the token type of the token.</summary>
        </member>
        <member name="P:Antlr4.Runtime.IToken.Line">
            <summary>
            The line number on which the 1st character of this token was matched,
            line=1..n
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.IToken.Column">
            <summary>
            The index of the first character of this token relative to the
            beginning of the line at which it occurs, 0..n-1
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.IToken.Channel">
            <summary>Return the channel this token.</summary>
            <remarks>
            Return the channel this token. Each token can arrive at the parser
            on a different channel, but the parser only "tunes" to a single channel.
            The parser ignores everything not on DEFAULT_CHANNEL.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.IToken.TokenIndex">
            <summary>An index from 0..n-1 of the token object in the input stream.</summary>
            <remarks>
            An index from 0..n-1 of the token object in the input stream.
            This must be valid in order to print token streams and
            use TokenRewriteStream.
            Return -1 to indicate that this token was conjured up since
            it doesn't have a valid index.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.IToken.StartIndex">
            <summary>
            The starting character index of the token
            This method is optional; return -1 if not implemented.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.IToken.StopIndex">
            <summary>The last character index of the token.</summary>
            <remarks>
            The last character index of the token.
            This method is optional; return -1 if not implemented.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.IToken.TokenSource">
            <summary>
            Gets the
            <see cref="T:Antlr4.Runtime.ITokenSource"/>
            which created this token.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.IToken.InputStream">
            <summary>
            Gets the
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            from which this token was derived.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.TokenConstants.Epsilon">
            <summary>
            During lookahead operations, this "token" signifies we hit rule end ATN state
            and did not follow it despite needing to.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.TokenConstants.DefaultChannel">
            <summary>
            All tokens go to the parser (unless skip() is called in that rule)
            on a particular "channel".
            </summary>
            <remarks>
            All tokens go to the parser (unless skip() is called in that rule)
            on a particular "channel".  The parser tunes to a particular channel
            so that whitespace etc... can go to the parser on a "hidden" channel.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.TokenConstants.HiddenChannel">
            <summary>
            Anything on different channel than DEFAULT_CHANNEL is not parsed
            by parser.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.TokenConstants.MinUserChannelValue">
            <summary>
            This is the minimum constant value which can be assigned to a
            user-defined token channel.
            </summary>
            <remarks>
            This is the minimum constant value which can be assigned to a
            user-defined token channel.
            <p>
            The non-negative numbers less than
            <see cref="F:Antlr4.Runtime.TokenConstants.MinUserChannelValue"/>
            are
            assigned to the predefined channels
            <see cref="F:Antlr4.Runtime.TokenConstants.DefaultChannel"/>
            and
            <see cref="F:Antlr4.Runtime.TokenConstants.HiddenChannel"/>
            .</p>
            </remarks>
            <seealso cref="P:Antlr4.Runtime.IToken.Channel"/>
        </member>
        <member name="T:Antlr4.Runtime.ITokenFactory">
            <summary>The default mechanism for creating tokens.</summary>
            <remarks>
            The default mechanism for creating tokens. It's used by default in Lexer and
            the error handling strategy (to create missing tokens).  Notifying the parser
            of a new factory means that it notifies it's token source and error strategy.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.ITokenFactory.Create(System.Tuple{Antlr4.Runtime.ITokenSource,Antlr4.Runtime.ICharStream},System.Int32,System.String,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)">
            <summary>
            This is the method used to create tokens in the lexer and in the
            error handling strategy.
            </summary>
            <remarks>
            This is the method used to create tokens in the lexer and in the
            error handling strategy. If text!=null, than the start and stop positions
            are wiped to -1 in the text override is set in the CommonToken.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.ITokenFactory.Create(System.Int32,System.String)">
            <summary>Generically useful</summary>
        </member>
        <member name="T:Antlr4.Runtime.ITokenSource">
            <summary>
            A source of tokens must provide a sequence of tokens via
            <see cref="M:Antlr4.Runtime.ITokenSource.NextToken"/>
            and also must reveal it's source of characters;
            <see cref="T:Antlr4.Runtime.CommonToken"/>
            's text is
            computed from a
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            ; it only store indices into the char
            stream.
            <p>Errors from the lexer are never passed to the parser. Either you want to keep
            going or you do not upon token recognition error. If you do not want to
            continue lexing then you do not want to continue parsing. Just throw an
            exception not under
            <see cref="T:Antlr4.Runtime.RecognitionException"/>
            and Java will naturally toss
            you all the way out of the recognizers. If you want to continue lexing then
            you should not throw an exception to the parser--it has already requested a
            token. Keep lexing until you get a valid one. Just report errors and keep
            going, looking for a valid token.</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.ITokenSource.NextToken">
            <summary>
            Return a
            <see cref="T:Antlr4.Runtime.IToken"/>
            object from your input stream (usually a
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            ). Do not fail/return upon lexing error; keep chewing
            on the characters until you get a good one; errors are not passed through
            to the parser.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.ITokenSource.Line">
            <summary>Get the line number for the current position in the input stream.</summary>
            <remarks>
            Get the line number for the current position in the input stream. The
            first line in the input is line 1.
            </remarks>
            <returns>
            The line number for the current position in the input stream, or
            0 if the current token source does not track line numbers.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.ITokenSource.Column">
            <summary>
            Get the index into the current line for the current position in the input
            stream.
            </summary>
            <remarks>
            Get the index into the current line for the current position in the input
            stream. The first character on a line has position 0.
            </remarks>
            <returns>
            The line number for the current position in the input stream, or
            -1 if the current token source does not track character positions.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.ITokenSource.InputStream">
            <summary>
            Get the
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            from which this token source is currently
            providing tokens.
            </summary>
            <returns>
            The
            <see cref="T:Antlr4.Runtime.ICharStream"/>
            associated with the current position in
            the input, or
            <see langword="null"/>
            if no input stream is available for the token
            source.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.ITokenSource.SourceName">
            <summary>Gets the name of the underlying input source.</summary>
            <remarks>
            Gets the name of the underlying input source. This method returns a
            non-null, non-empty string. If such a name is not known, this method
            returns
            <see cref="F:Antlr4.Runtime.IntStreamConstants.UnknownSourceName"/>
            .
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.ITokenSource.TokenFactory">
            <summary>
            Set the
            <see cref="T:Antlr4.Runtime.ITokenFactory"/>
            this token source should use for creating
            <see cref="T:Antlr4.Runtime.IToken"/>
            objects from the input.
            </summary>
            <value>
            The
            <see cref="T:Antlr4.Runtime.ITokenFactory"/>
            to use for creating tokens.
            </value>
            <summary>
            Gets the
            <see cref="T:Antlr4.Runtime.ITokenFactory"/>
            this token source is currently using for
            creating
            <see cref="T:Antlr4.Runtime.IToken"/>
            objects from the input.
            </summary>
            <returns>
            The
            <see cref="T:Antlr4.Runtime.ITokenFactory"/>
            currently used by this token source.
            </returns>
        </member>
        <member name="T:Antlr4.Runtime.ITokenStream">
            <summary>
            An
            <see cref="T:Antlr4.Runtime.IIntStream"/>
            whose symbols are
            <see cref="T:Antlr4.Runtime.IToken"/>
            instances.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.ITokenStream.Lt(System.Int32)">
            <summary>
            Get the
            <see cref="T:Antlr4.Runtime.IToken"/>
            instance associated with the value returned by
            <see cref="M:Antlr4.Runtime.IIntStream.La(System.Int32)">LA(k)</see>
            . This method has the same pre- and post-conditions as
            <see cref="M:Antlr4.Runtime.IIntStream.La(System.Int32)"/>
            . In addition, when the preconditions of this method
            are met, the return value is non-null and the value of
            <c>LT(k).getType()==LA(k)</c>
            .
            </summary>
            <seealso cref="M:Antlr4.Runtime.IIntStream.La(System.Int32)"/>
        </member>
        <member name="M:Antlr4.Runtime.ITokenStream.Get(System.Int32)">
            <summary>
            Gets the
            <see cref="T:Antlr4.Runtime.IToken"/>
            at the specified
            <c>index</c>
            in the stream. When
            the preconditions of this method are met, the return value is non-null.
            <p>The preconditions for this method are the same as the preconditions of
            <see cref="M:Antlr4.Runtime.IIntStream.Seek(System.Int32)"/>
            . If the behavior of
            <c>seek(index)</c>
            is
            unspecified for the current state and given
            <c>index</c>
            , then the
            behavior of this method is also unspecified.</p>
            <p>The symbol referred to by
            <c>index</c>
            differs from
            <c>seek()</c>
            only
            in the case of filtering streams where
            <c>index</c>
            lies before the end
            of the stream. Unlike
            <c>seek()</c>
            , this method does not adjust
            <c>index</c>
            to point to a non-ignored symbol.</p>
            </summary>
            <exception cref="T:System.ArgumentException">if {code index} is less than 0</exception>
            <exception cref="T:System.NotSupportedException">
            if the stream does not support
            retrieving the token at the specified index
            </exception>
        </member>
        <member name="P:Antlr4.Runtime.ITokenStream.TokenSource">
            <summary>
            Gets the underlying
            <see cref="T:Antlr4.Runtime.ITokenSource"/>
            which provides tokens for this
            stream.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.ITokenStream.GetText(Antlr4.Runtime.Misc.Interval)">
            <summary>
            Return the text of all tokens within the specified
            <paramref name="interval"/>
            . This
            method behaves like the following code (including potential exceptions
            for violating preconditions of
            <see cref="M:Antlr4.Runtime.ITokenStream.Get(System.Int32)"/>
            , but may be optimized by the
            specific implementation.
            <pre>
            TokenStream stream = ...;
            String text = "";
            for (int i = interval.a; i &lt;= interval.b; i++) {
            text += stream.get(i).getText();
            }
            </pre>
            </summary>
            <param name="interval">
            The interval of tokens within this stream to get text
            for.
            </param>
            <returns>
            The text of all tokens within the specified interval in this
            stream.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            if
            <paramref name="interval"/>
            is
            <see langword="null"/>
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.ITokenStream.GetText">
            <summary>Return the text of all tokens in the stream.</summary>
            <remarks>
            Return the text of all tokens in the stream. This method behaves like the
            following code, including potential exceptions from the calls to
            <see cref="P:Antlr4.Runtime.IIntStream.Size"/>
            and
            <see cref="M:Antlr4.Runtime.ITokenStream.GetText(Antlr4.Runtime.Misc.Interval)"/>
            , but may be
            optimized by the specific implementation.
            <pre>
            TokenStream stream = ...;
            String text = stream.getText(new Interval(0, stream.size()));
            </pre>
            </remarks>
            <returns>The text of all tokens in the stream.</returns>
        </member>
        <member name="M:Antlr4.Runtime.ITokenStream.GetText(Antlr4.Runtime.RuleContext)">
            <summary>
            Return the text of all tokens in the source interval of the specified
            context.
            </summary>
            <remarks>
            Return the text of all tokens in the source interval of the specified
            context. This method behaves like the following code, including potential
            exceptions from the call to
            <see cref="M:Antlr4.Runtime.ITokenStream.GetText(Antlr4.Runtime.Misc.Interval)"/>
            , but may be
            optimized by the specific implementation.
            <p>If
            <c>ctx.getSourceInterval()</c>
            does not return a valid interval of
            tokens provided by this stream, the behavior is unspecified.</p>
            <pre>
            TokenStream stream = ...;
            String text = stream.getText(ctx.getSourceInterval());
            </pre>
            </remarks>
            <param name="ctx">
            The context providing the source interval of tokens to get
            text for.
            </param>
            <returns>
            The text of all tokens within the source interval of
            <paramref name="ctx"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.ITokenStream.GetText(Antlr4.Runtime.IToken,Antlr4.Runtime.IToken)">
            <summary>
            Return the text of all tokens in this stream between
            <paramref name="start"/>
            and
            <paramref name="stop"/>
            (inclusive).
            <p>If the specified
            <paramref name="start"/>
            or
            <paramref name="stop"/>
            token was not provided by
            this stream, or if the
            <paramref name="stop"/>
            occurred before the
            <paramref name="start"/>
            token, the behavior is unspecified.</p>
            <p>For streams which ensure that the
            <see cref="P:Antlr4.Runtime.IToken.TokenIndex"/>
            method is
            accurate for all of its provided tokens, this method behaves like the
            following code. Other streams may implement this method in other ways
            provided the behavior is consistent with this at a high level.</p>
            <pre>
            TokenStream stream = ...;
            String text = "";
            for (int i = start.getTokenIndex(); i &lt;= stop.getTokenIndex(); i++) {
            text += stream.get(i).getText();
            }
            </pre>
            </summary>
            <param name="start">The first token in the interval to get text for.</param>
            <param name="stop">The last token in the interval to get text for (inclusive).</param>
            <returns>
            The text of all tokens lying between the specified
            <paramref name="start"/>
            and
            <paramref name="stop"/>
            tokens.
            </returns>
            <exception cref="T:System.NotSupportedException">
            if this stream does not support
            this method for the specified tokens
            </exception>
        </member>
        <member name="T:Antlr4.Runtime.IVocabulary">
            <summary>
            This interface provides information about the vocabulary used by a
            recognizer.
            </summary>
            <seealso cref="P:Antlr4.Runtime.Recognizer`2.Vocabulary"/>
            <author>Sam Harwell</author>
        </member>
        <member name="P:Antlr4.Runtime.IVocabulary.MaxTokenType">
            <summary>Returns the highest token type value.</summary>
            <remarks>
            Returns the highest token type value. It can be used to iterate from
            zero to that number, inclusively, thus querying all stored entries.
            </remarks>
            <returns>the highest token type value</returns>
        </member>
        <member name="M:Antlr4.Runtime.IVocabulary.GetLiteralName(System.Int32)">
            <summary>Gets the string literal associated with a token type.</summary>
            <remarks>
            Gets the string literal associated with a token type. The string returned
            by this method, when not
            <see langword="null"/>
            , can be used unaltered in a parser
            grammar to represent this token type.
            <p>The following table shows examples of lexer rules and the literal
            names assigned to the corresponding token types.</p>
            <table>
            <tr>
            <th>Rule</th>
            <th>Literal Name</th>
            <th>Java String Literal</th>
            </tr>
            <tr>
            <td>
            <c>THIS : 'this';</c>
            </td>
            <td>
            <c>'this'</c>
            </td>
            <td>
            <c>"'this'"</c>
            </td>
            </tr>
            <tr>
            <td>
            <c>SQUOTE : '\'';</c>
            </td>
            <td>
            <c>'\''</c>
            </td>
            <td>
            <c>"'\\''"</c>
            </td>
            </tr>
            <tr>
            <td>
            <c>ID : [A-Z]+;</c>
            </td>
            <td>n/a</td>
            <td>
            <see langword="null"/>
            </td>
            </tr>
            </table>
            </remarks>
            <param name="tokenType">The token type.</param>
            <returns>
            The string literal associated with the specified token type, or
            <see langword="null"/>
            if no string literal is associated with the type.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.IVocabulary.GetSymbolicName(System.Int32)">
            <summary>Gets the symbolic name associated with a token type.</summary>
            <remarks>
            Gets the symbolic name associated with a token type. The string returned
            by this method, when not
            <see langword="null"/>
            , can be used unaltered in a parser
            grammar to represent this token type.
            <p>This method supports token types defined by any of the following
            methods:</p>
            <ul>
            <li>Tokens created by lexer rules.</li>
            <li>Tokens defined in a <code>tokens{}</code> block in a lexer or parser
            grammar.</li>
            <li>The implicitly defined
            <c>EOF</c>
            token, which has the token type
            <see cref="F:Antlr4.Runtime.TokenConstants.Eof"/>
            .</li>
            </ul>
            <p>The following table shows examples of lexer rules and the literal
            names assigned to the corresponding token types.</p>
            <table>
            <tr>
            <th>Rule</th>
            <th>Symbolic Name</th>
            </tr>
            <tr>
            <td>
            <c>THIS : 'this';</c>
            </td>
            <td>
            <c>THIS</c>
            </td>
            </tr>
            <tr>
            <td>
            <c>SQUOTE : '\'';</c>
            </td>
            <td>
            <c>SQUOTE</c>
            </td>
            </tr>
            <tr>
            <td>
            <c>ID : [A-Z]+;</c>
            </td>
            <td>
            <c>ID</c>
            </td>
            </tr>
            </table>
            </remarks>
            <param name="tokenType">The token type.</param>
            <returns>
            The symbolic name associated with the specified token type, or
            <see langword="null"/>
            if no symbolic name is associated with the type.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.IVocabulary.GetDisplayName(System.Int32)">
            <summary>Gets the display name of a token type.</summary>
            <remarks>
            Gets the display name of a token type.
            <p>ANTLR provides a default implementation of this method, but
            applications are free to override the behavior in any manner which makes
            sense for the application. The default implementation returns the first
            result from the following list which produces a non-
            <see langword="null"/>
            result.</p>
            <ol>
            <li>The result of
            <see cref="M:Antlr4.Runtime.IVocabulary.GetLiteralName(System.Int32)"/>
            </li>
            <li>The result of
            <see cref="M:Antlr4.Runtime.IVocabulary.GetSymbolicName(System.Int32)"/>
            </li>
            <li>The result of
            <see cref="M:System.Int32.ToString"/>
            </li>
            </ol>
            </remarks>
            <param name="tokenType">The token type.</param>
            <returns>
            The display name of the token type, for use in error reporting or
            other user-visible messages which reference specific token types.
            </returns>
        </member>
        <member name="T:Antlr4.Runtime.Lexer">
            <summary>A lexer is recognizer that draws input symbols from a character stream.</summary>
            <remarks>
            A lexer is recognizer that draws input symbols from a character stream.
            lexer grammars result in a subclass of this object. A Lexer object
            uses simplified match() and error recovery mechanisms in the interest
            of speed.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Lexer._factory">
            <summary>How to create token objects</summary>
        </member>
        <member name="F:Antlr4.Runtime.Lexer._token">
            <summary>The goal of all lexer rules/methods is to create a token object.</summary>
            <remarks>
            The goal of all lexer rules/methods is to create a token object.
            This is an instance variable as multiple rules may collaborate to
            create a single token.  nextToken will return this object after
            matching lexer rule(s).  If you subclass to allow multiple token
            emissions, then set this to the last token to be matched or
            something nonnull so that the auto token emit mechanism will not
            emit another token.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Lexer._tokenStartCharIndex">
            <summary>
            What character index in the stream did the current token start at?
            Needed, for example, to get the text for current token.
            </summary>
            <remarks>
            What character index in the stream did the current token start at?
            Needed, for example, to get the text for current token.  Set at
            the start of nextToken.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Lexer._tokenStartLine">
            <summary>The line on which the first character of the token resides</summary>
        </member>
        <member name="F:Antlr4.Runtime.Lexer._tokenStartCharPositionInLine">
            <summary>The character position of first character within the line</summary>
        </member>
        <member name="F:Antlr4.Runtime.Lexer._hitEOF">
            <summary>Once we see EOF on char stream, next token will be EOF.</summary>
            <remarks>
            Once we see EOF on char stream, next token will be EOF.
            If you have DONE : EOF ; then you see DONE EOF.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Lexer._channel">
            <summary>The channel number for the current token</summary>
        </member>
        <member name="F:Antlr4.Runtime.Lexer._type">
            <summary>The token type for the current token</summary>
        </member>
        <member name="F:Antlr4.Runtime.Lexer._text">
            <summary>
            You can set the text for the current token to override what is in
            the input char buffer.
            </summary>
            <remarks>
            You can set the text for the current token to override what is in
            the input char buffer.  Use setText() or can set this instance var.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Lexer.NextToken">
            <summary>
            Return a token from this source; i.e., match a token on the char
            stream.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Lexer.Skip">
            <summary>
            Instruct the lexer to skip creating a token for current lexer rule
            and look for another token.
            </summary>
            <remarks>
            Instruct the lexer to skip creating a token for current lexer rule
            and look for another token.  nextToken() knows to keep looking when
            a lexer rule finishes with token set to SKIP_TOKEN.  Recall that
            if token==null at end of any token rule, it creates one for you
            and emits it.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Lexer.SetInputStream(Antlr4.Runtime.ICharStream)">
            <summary>Set the char stream and reset the lexer</summary>
        </member>
        <member name="M:Antlr4.Runtime.Lexer.Emit(Antlr4.Runtime.IToken)">
            <summary>
            By default does not support multiple emits per nextToken invocation
            for efficiency reasons.
            </summary>
            <remarks>
            By default does not support multiple emits per nextToken invocation
            for efficiency reasons.  Subclass and override this method, nextToken,
            and getToken (to push tokens into a list and pull from that list
            rather than a single variable as this implementation does).
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Lexer.Emit">
            <summary>
            The standard method called to automatically emit a token at the
            outermost lexical rule.
            </summary>
            <remarks>
            The standard method called to automatically emit a token at the
            outermost lexical rule.  The token object should point into the
            char buffer start..stop.  If there is a text override in 'text',
            use that to set the token's text.  Override this method to emit
            custom Token objects or provide a new factory.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Lexer.CharIndex">
            <summary>What is the index of the current character of lookahead?</summary>
        </member>
        <member name="P:Antlr4.Runtime.Lexer.Text">
            <summary>
            Return the text matched so far for the current token or any text
            override.
            </summary>
            <summary>
            Set the complete text of this token; it wipes any previous changes to the
            text.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Lexer.Token">
            <summary>Override if emitting multiple tokens.</summary>
        </member>
        <member name="P:Antlr4.Runtime.Lexer.TokenNames">
            <summary>
            Used to print out token names like ID during debugging and
            error reporting.
            </summary>
            <remarks>
            Used to print out token names like ID during debugging and
            error reporting.  The generated parsers implement a method
            that overrides this to point to their String[] tokenNames.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Lexer.GetAllTokens">
            <summary>Return a list of all Token objects in input char stream.</summary>
            <remarks>
            Return a list of all Token objects in input char stream.
            Forces load of all tokens. Does not include EOF token.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Lexer.Recover(Antlr4.Runtime.RecognitionException)">
            <summary>
            Lexers can normally match any char in it's vocabulary after matching
            a token, so do the easy thing and just kill a character and hope
            it all works out.
            </summary>
            <remarks>
            Lexers can normally match any char in it's vocabulary after matching
            a token, so do the easy thing and just kill a character and hope
            it all works out.  You can instead use the rule invocation stack
            to do sophisticated error recovery if you are in a fragment rule.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.LexerNoViableAltException.startIndex">
            <summary>Matching attempted at what input index?</summary>
        </member>
        <member name="F:Antlr4.Runtime.LexerNoViableAltException.deadEndConfigs">
            <summary>Which configurations did we try at input.index() that couldn't match input.LA(1)?</summary>
        </member>
        <member name="T:Antlr4.Runtime.ListTokenSource">
            <summary>
            Provides an implementation of
            <see cref="T:Antlr4.Runtime.ITokenSource"/>
            as a wrapper around a list
            of
            <see cref="T:Antlr4.Runtime.IToken"/>
            objects.
            <p>If the final token in the list is an
            <see cref="F:Antlr4.Runtime.TokenConstants.Eof"/>
            token, it will be used
            as the EOF token for every call to
            <see cref="M:Antlr4.Runtime.ListTokenSource.NextToken"/>
            after the end of the
            list is reached. Otherwise, an EOF token will be created.</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.ListTokenSource.tokens">
            <summary>
            The wrapped collection of
            <see cref="T:Antlr4.Runtime.IToken"/>
            objects to return.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.ListTokenSource.sourceName">
            <summary>The name of the input source.</summary>
            <remarks>
            The name of the input source. If this value is
            <see langword="null"/>
            , a call to
            <see cref="P:Antlr4.Runtime.ListTokenSource.SourceName"/>
            should return the source name used to create the
            the next token in
            <see cref="F:Antlr4.Runtime.ListTokenSource.tokens"/>
            (or the previous token if the end of
            the input has been reached).
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.ListTokenSource.i">
            <summary>
            The index into
            <see cref="F:Antlr4.Runtime.ListTokenSource.tokens"/>
            of token to return by the next call to
            <see cref="M:Antlr4.Runtime.ListTokenSource.NextToken"/>
            . The end of the input is indicated by this value
            being greater than or equal to the number of items in
            <see cref="F:Antlr4.Runtime.ListTokenSource.tokens"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.ListTokenSource.eofToken">
            <summary>This field caches the EOF token for the token source.</summary>
        </member>
        <member name="F:Antlr4.Runtime.ListTokenSource._factory">
            <summary>
            This is the backing field for the <see cref="P:Antlr4.Runtime.ListTokenSource.TokenFactory"/> property.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.ListTokenSource.#ctor(System.Collections.Generic.IList{Antlr4.Runtime.IToken})">
            <summary>
            Constructs a new
            <see cref="T:Antlr4.Runtime.ListTokenSource"/>
            instance from the specified
            collection of
            <see cref="T:Antlr4.Runtime.IToken"/>
            objects.
            </summary>
            <param name="tokens">
            The collection of
            <see cref="T:Antlr4.Runtime.IToken"/>
            objects to provide as a
            <see cref="T:Antlr4.Runtime.ITokenSource"/>
            .
            </param>
            <exception>
            NullPointerException
            if
            <paramref name="tokens"/>
            is
            <see langword="null"/>
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.ListTokenSource.#ctor(System.Collections.Generic.IList{Antlr4.Runtime.IToken},System.String)">
            <summary>
            Constructs a new
            <see cref="T:Antlr4.Runtime.ListTokenSource"/>
            instance from the specified
            collection of
            <see cref="T:Antlr4.Runtime.IToken"/>
            objects and source name.
            </summary>
            <param name="tokens">
            The collection of
            <see cref="T:Antlr4.Runtime.IToken"/>
            objects to provide as a
            <see cref="T:Antlr4.Runtime.ITokenSource"/>
            .
            </param>
            <param name="sourceName">
            The name of the
            <see cref="T:Antlr4.Runtime.ITokenSource"/>
            . If this value is
            <see langword="null"/>
            ,
            <see cref="P:Antlr4.Runtime.ListTokenSource.SourceName"/>
            will attempt to infer the name from
            the next
            <see cref="T:Antlr4.Runtime.IToken"/>
            (or the previous token if the end of the input has
            been reached).
            </param>
            <exception>
            NullPointerException
            if
            <paramref name="tokens"/>
            is
            <see langword="null"/>
            </exception>
        </member>
        <member name="P:Antlr4.Runtime.ListTokenSource.Column">
            <summary><inheritDoc/></summary>
        </member>
        <member name="M:Antlr4.Runtime.ListTokenSource.NextToken">
            <summary><inheritDoc/></summary>
        </member>
        <member name="P:Antlr4.Runtime.ListTokenSource.Line">
            <summary><inheritDoc/></summary>
        </member>
        <member name="P:Antlr4.Runtime.ListTokenSource.InputStream">
            <summary><inheritDoc/></summary>
        </member>
        <member name="P:Antlr4.Runtime.ListTokenSource.SourceName">
            <summary><inheritDoc/></summary>
        </member>
        <member name="P:Antlr4.Runtime.ListTokenSource.TokenFactory">
            <summary><inheritDoc/></summary>
            <summary><inheritDoc/></summary>
        </member>
        <member name="T:Antlr4.Runtime.Misc.Args">
            <author>Sam Harwell</author>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Args.NotNull(System.String,System.Object)">
            <exception cref="T:System.ArgumentNullException">
            if
            <paramref name="value"/>
            is
            <see langword="null"/>
            .
            </exception>
        </member>
        <member name="T:Antlr4.Runtime.Misc.IIntSet">
            <summary>A generic set of integers.</summary>
            <seealso cref="T:Antlr4.Runtime.Misc.IntervalSet"/>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IIntSet.Add(System.Int32)">
            <summary>Adds the specified value to the current set.</summary>
            <param name="el">the value to add</param>
            <exception>
            IllegalStateException
            if the current set is read-only
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IIntSet.AddAll(Antlr4.Runtime.Misc.IIntSet)">
            <summary>
            Modify the current
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            object to contain all elements that are
            present in itself, the specified
            <paramref name="set"/>
            , or both.
            </summary>
            <param name="set">
            The set to add to the current set. A
            <see langword="null"/>
            argument is
            treated as though it were an empty set.
            </param>
            <returns>
            
            <c>this</c>
            (to support chained calls)
            </returns>
            <exception>
            IllegalStateException
            if the current set is read-only
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IIntSet.And(Antlr4.Runtime.Misc.IIntSet)">
            <summary>
            Return a new
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            object containing all elements that are
            present in both the current set and the specified set
            <paramref name="a"/>
            .
            </summary>
            <param name="a">
            The set to intersect with the current set. A
            <see langword="null"/>
            argument is treated as though it were an empty set.
            </param>
            <returns>
            A new
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            instance containing the intersection of the
            current set and
            <paramref name="a"/>
            . The value
            <see langword="null"/>
            may be returned in
            place of an empty result set.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IIntSet.Complement(Antlr4.Runtime.Misc.IIntSet)">
            <summary>
            Return a new
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            object containing all elements that are
            present in
            <paramref name="elements"/>
            but not present in the current set. The
            following expressions are equivalent for input non-null
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            instances
            <c>x</c>
            and
            <c>y</c>
            .
            <ul>
            <li>
            <c>x.complement(y)</c>
            </li>
            <li>
            <c>y.subtract(x)</c>
            </li>
            </ul>
            </summary>
            <param name="elements">
            The set to compare with the current set. A
            <see langword="null"/>
            argument is treated as though it were an empty set.
            </param>
            <returns>
            A new
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            instance containing the elements present in
            <paramref name="elements"/>
            but not present in the current set. The value
            <see langword="null"/>
            may be returned in place of an empty result set.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IIntSet.Or(Antlr4.Runtime.Misc.IIntSet)">
            <summary>
            Return a new
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            object containing all elements that are
            present in the current set, the specified set
            <paramref name="a"/>
            , or both.
            <p>
            This method is similar to
            <see cref="M:Antlr4.Runtime.Misc.IIntSet.AddAll(Antlr4.Runtime.Misc.IIntSet)"/>
            , but returns a new
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            instance instead of modifying the current set.</p>
            </summary>
            <param name="a">
            The set to union with the current set. A
            <see langword="null"/>
            argument
            is treated as though it were an empty set.
            </param>
            <returns>
            A new
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            instance containing the union of the current
            set and
            <paramref name="a"/>
            . The value
            <see langword="null"/>
            may be returned in place of an
            empty result set.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IIntSet.Subtract(Antlr4.Runtime.Misc.IIntSet)">
            <summary>
            Return a new
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            object containing all elements that are
            present in the current set but not present in the input set
            <paramref name="a"/>
            .
            The following expressions are equivalent for input non-null
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            instances
            <c>x</c>
            and
            <c>y</c>
            .
            <ul>
            <li>
            <c>y.subtract(x)</c>
            </li>
            <li>
            <c>x.complement(y)</c>
            </li>
            </ul>
            </summary>
            <param name="a">
            The set to compare with the current set. A
            <see langword="null"/>
            argument is treated as though it were an empty set.
            </param>
            <returns>
            A new
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            instance containing the elements present in
            <c>elements</c>
            but not present in the current set. The value
            <see langword="null"/>
            may be returned in place of an empty result set.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Misc.IIntSet.Count">
            <summary>Return the total number of elements represented by the current set.</summary>
            <returns>
            the total number of elements represented by the current set,
            regardless of the manner in which the elements are stored.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Misc.IIntSet.IsNil">
            <summary>
            Returns
            <see langword="true"/>
            if this set contains no elements.
            </summary>
            <returns>
            
            <see langword="true"/>
            if the current set contains no elements; otherwise,
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IIntSet.Equals(System.Object)">
            <summary><inheritDoc/></summary>
        </member>
        <member name="P:Antlr4.Runtime.Misc.IIntSet.SingleElement">
            <summary>
            Returns the single value contained in the set, if
            <see cref="P:Antlr4.Runtime.Misc.IIntSet.Count"/>
            is 1;
            otherwise, returns
            <see cref="F:Antlr4.Runtime.TokenConstants.InvalidType"/>
            .
            </summary>
            <returns>
            the single value contained in the set, if
            <see cref="P:Antlr4.Runtime.Misc.IIntSet.Count"/>
            is 1;
            otherwise, returns
            <see cref="F:Antlr4.Runtime.TokenConstants.InvalidType"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IIntSet.Contains(System.Int32)">
            <summary>
            Returns
            <see langword="true"/>
            if the set contains the specified element.
            </summary>
            <param name="el">The element to check for.</param>
            <returns>
            
            <see langword="true"/>
            if the set contains
            <paramref name="el"/>
            ; otherwise
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IIntSet.Remove(System.Int32)">
            <summary>Removes the specified value from the current set.</summary>
            <remarks>
            Removes the specified value from the current set. If the current set does
            not contain the element, no changes are made.
            </remarks>
            <param name="el">the value to remove</param>
            <exception>
            IllegalStateException
            if the current set is read-only
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IIntSet.ToList">
            <summary>Return a list containing the elements represented by the current set.</summary>
            <remarks>
            Return a list containing the elements represented by the current set. The
            list is returned in ascending numerical order.
            </remarks>
            <returns>
            A list containing all element present in the current set, sorted
            in ascending numerical order.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IIntSet.ToString">
            <summary><inheritDoc/></summary>
        </member>
        <member name="T:Antlr4.Runtime.Misc.Interval">
            <summary>An immutable inclusive interval a..b.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Misc.Interval.a">
            <summary>The start of the interval.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Misc.Interval.b">
            <summary>The end of the interval (inclusive).</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Interval.Of(System.Int32,System.Int32)">
            <summary>
            Interval objects are used readonly so share all with the
            same single value a==b up to some max size.
            </summary>
            <remarks>
            Interval objects are used readonly so share all with the
            same single value a==b up to some max size.  Use an array as a perfect hash.
            Return shared object for 0..INTERVAL_POOL_MAX_VALUE or a new
            Interval object with a..a in it.  On Java.g4, 218623 IntervalSets
            have a..a (set with 1 element).
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Misc.Interval.Length">
            <summary>return number of elements between a and b inclusively.</summary>
            <remarks>
            return number of elements between a and b inclusively. x..x is length 1.
            if b &lt; a, then length is 0. 9..10 has length 2.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Interval.StartsBeforeDisjoint(Antlr4.Runtime.Misc.Interval)">
            <summary>Does this start completely before other? Disjoint</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Interval.StartsBeforeNonDisjoint(Antlr4.Runtime.Misc.Interval)">
            <summary>Does this start at or before other? Nondisjoint</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Interval.StartsAfter(Antlr4.Runtime.Misc.Interval)">
            <summary>Does this.a start after other.b? May or may not be disjoint</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Interval.StartsAfterDisjoint(Antlr4.Runtime.Misc.Interval)">
            <summary>Does this start completely after other? Disjoint</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Interval.StartsAfterNonDisjoint(Antlr4.Runtime.Misc.Interval)">
            <summary>Does this start after other? NonDisjoint</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Interval.Disjoint(Antlr4.Runtime.Misc.Interval)">
            <summary>Are both ranges disjoint? I.e., no overlap?</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Interval.Adjacent(Antlr4.Runtime.Misc.Interval)">
            <summary>Are two intervals adjacent such as 0..41 and 42..42?</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Interval.Union(Antlr4.Runtime.Misc.Interval)">
            <summary>Return the interval computed from combining this and other</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Interval.Intersection(Antlr4.Runtime.Misc.Interval)">
            <summary>Return the interval in common between this and o</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Interval.DifferenceNotProperlyContained(Antlr4.Runtime.Misc.Interval)">
            <summary>
            Return the interval with elements from
            <c>this</c>
            not in
            <paramref name="other"/>
            ;
            <paramref name="other"/>
            must not be totally enclosed (properly contained)
            within
            <c>this</c>
            , which would result in two disjoint intervals
            instead of the single one returned by this method.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Misc.IntervalSet">
            <summary>
            This class implements the
            <see cref="T:Antlr4.Runtime.Misc.IIntSet"/>
            backed by a sorted array of
            non-overlapping intervals. It is particularly efficient for representing
            large collections of numbers, where the majority of elements appear as part
            of a sequential range of numbers that are all part of the set. For example,
            the set { 1, 2, 3, 4, 7, 8 } may be represented as { [1, 4], [7, 8] }.
            <p>
            This class is able to represent sets containing any combination of values in
            the range
            <see cref="F:System.Int32.MinValue"/>
            to
            <see cref="F:System.Int32.MaxValue"/>
            (inclusive).</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Misc.IntervalSet.intervals">
            <summary>The list of sorted, disjoint intervals.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IntervalSet.Of(System.Int32)">
            <summary>Create a set with a single element, el.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IntervalSet.Of(System.Int32,System.Int32)">
            <summary>Create a set with all ints within range [a..b] (inclusive)</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IntervalSet.Add(System.Int32)">
            <summary>Add a single element to the set.</summary>
            <remarks>
            Add a single element to the set.  An isolated element is stored
            as a range el..el.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IntervalSet.Add(System.Int32,System.Int32)">
            <summary>Add interval; i.e., add all integers from a to b to set.</summary>
            <remarks>
            Add interval; i.e., add all integers from a to b to set.
            If b&lt;a, do nothing.
            Keep list in sorted order (by left range value).
            If overlap, combine ranges.  For example,
            If this is {1..5, 10..20}, adding 6..7 yields
            {1..5, 6..7, 10..20}.  Adding 4..8 yields {1..8, 10..20}.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IntervalSet.Or(Antlr4.Runtime.Misc.IntervalSet[])">
            <summary>combine all sets in the array returned the or'd value</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IntervalSet.Complement(Antlr4.Runtime.Misc.IIntSet)">
            <summary>
            <inheritDoc/>
            
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IntervalSet.Subtract(Antlr4.Runtime.Misc.IntervalSet,Antlr4.Runtime.Misc.IntervalSet)">
            <summary>Compute the set difference between two interval sets.</summary>
            <remarks>
            Compute the set difference between two interval sets. The specific
            operation is
            <c>left - right</c>
            . If either of the input sets is
            <see langword="null"/>
            , it is treated as though it was an empty set.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IntervalSet.And(Antlr4.Runtime.Misc.IIntSet)">
            <summary>
            <inheritDoc/>
            
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IntervalSet.Contains(System.Int32)">
            <summary>
            <inheritDoc/>
            
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Misc.IntervalSet.IsNil">
            <summary>
            <inheritDoc/>
            
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Misc.IntervalSet.SingleElement">
            <summary>
            <inheritDoc/>
            
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Misc.IntervalSet.MaxElement">
            <summary>Returns the maximum value contained in the set.</summary>
            <returns>
            the maximum value contained in the set. If the set is empty, this
            method returns
            <see cref="F:Antlr4.Runtime.TokenConstants.InvalidType"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Misc.IntervalSet.MinElement">
            <summary>Returns the minimum value contained in the set.</summary>
            <returns>
            the minimum value contained in the set. If the set is empty, this
            method returns
            <see cref="F:Antlr4.Runtime.TokenConstants.InvalidType"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IntervalSet.GetIntervals">
            <summary>Return a list of Interval objects.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Misc.IntervalSet.Equals(System.Object)">
            <summary>
            Are two IntervalSets equal?  Because all intervals are sorted
            and disjoint, equals is a simple linear walk over both lists
            to make sure they are the same.
            </summary>
            <remarks>
            Are two IntervalSets equal?  Because all intervals are sorted
            and disjoint, equals is a simple linear walk over both lists
            to make sure they are the same.  Interval.equals() is used
            by the List.equals() method to check the ranges.
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.Misc.MurmurHash">
            <author>Sam Harwell</author>
        </member>
        <member name="M:Antlr4.Runtime.Misc.MurmurHash.Initialize">
            <summary>Initialize the hash using the default seed value.</summary>
            <returns>the intermediate hash value</returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.MurmurHash.Initialize(System.Int32)">
            <summary>
            Initialize the hash using the specified
            <paramref name="seed"/>
            .
            </summary>
            <param name="seed">the seed</param>
            <returns>the intermediate hash value</returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.MurmurHash.Update(System.Int32,System.Int32)">
            <summary>
            Update the intermediate hash value for the next input
            <paramref name="value"/>
            .
            </summary>
            <param name="hash">the intermediate hash value</param>
            <param name="value">the value to add to the current hash</param>
            <returns>the updated intermediate hash value</returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.MurmurHash.Update(System.Int32,System.Object)">
            <summary>
            Update the intermediate hash value for the next input
            <paramref name="value"/>
            .
            </summary>
            <param name="hash">the intermediate hash value</param>
            <param name="value">the value to add to the current hash</param>
            <returns>the updated intermediate hash value</returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.MurmurHash.Finish(System.Int32,System.Int32)">
            <summary>
            Apply the final computation steps to the intermediate value
            <paramref name="hash"/>
            to form the final result of the MurmurHash 3 hash function.
            </summary>
            <param name="hash">the intermediate hash value</param>
            <param name="numberOfWords">the number of integer values added to the hash</param>
            <returns>the final hash result</returns>
        </member>
        <member name="M:Antlr4.Runtime.Misc.MurmurHash.HashCode``1(``0[],System.Int32)">
            <summary>
            Utility function to compute the hash code of an array using the
            MurmurHash algorithm.
            </summary>
            <param name="data">the array data</param>
            <param name="seed">the seed for the MurmurHash algorithm</param>
            <returns>the hash code of the data</returns>
        </member>
        <member name="T:Antlr4.Runtime.Misc.ParseCanceledException">
            <summary>This exception is thrown to cancel a parsing operation.</summary>
            <remarks>
            This exception is thrown to cancel a parsing operation. This exception does
            not extend
            <see cref="T:Antlr4.Runtime.RecognitionException"/>
            , allowing it to bypass the standard
            error recovery mechanisms.
            <see cref="T:Antlr4.Runtime.BailErrorStrategy"/>
            throws this exception in
            response to a parse error.
            </remarks>
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.Misc.RuleDependencyChecker">
            <author>Sam Harwell</author>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Utils.ToMap(System.String[])">
            <summary>Convert array of strings to string&#x2192;index map.</summary>
            <remarks>
            Convert array of strings to string&#x2192;index map. Useful for
            converting rulenames to name&#x2192;ruleindex map.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Misc.Utils.ToSet(Antlr4.Runtime.Sharpen.BitSet)">
            <since>4.5</since>
        </member>
        <member name="T:Antlr4.Runtime.NoViableAltException">
            <summary>
            Indicates that the parser could not decide which of two or more paths
            to take based upon the remaining input.
            </summary>
            <remarks>
            Indicates that the parser could not decide which of two or more paths
            to take based upon the remaining input. It tracks the starting token
            of the offending input and also knows where the parser was
            in the various paths when the error. Reported by reportNoViableAlternative()
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.NoViableAltException.deadEndConfigs">
            <summary>Which configurations did we try at input.index() that couldn't match input.LT(1)?</summary>
        </member>
        <member name="F:Antlr4.Runtime.NoViableAltException.startToken">
            <summary>
            The token object at the start index; the input stream might
            not be buffering tokens so get a reference to it.
            </summary>
            <remarks>
            The token object at the start index; the input stream might
            not be buffering tokens so get a reference to it. (At the
            time the error occurred, of course the stream needs to keep a
            buffer all of the tokens but later we might not have access to those.)
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.Parser">
            <summary>This is all the parsing support code essentially; most of it is error recovery stuff.</summary>
        </member>
        <member name="F:Antlr4.Runtime.Parser.bypassAltsAtnCache">
            <summary>
            This field maps from the serialized ATN string to the deserialized
            <see cref="T:Antlr4.Runtime.Atn.ATN"/>
            with
            bypass alternatives.
            </summary>
            <seealso cref="P:Antlr4.Runtime.Atn.ATNDeserializationOptions.GenerateRuleBypassTransitions"/>
        </member>
        <member name="F:Antlr4.Runtime.Parser._errHandler">
            <summary>The error handling strategy for the parser.</summary>
            <remarks>
            The error handling strategy for the parser. The default value is a new
            instance of
            <see cref="T:Antlr4.Runtime.DefaultErrorStrategy"/>
            .
            </remarks>
            <seealso cref="P:Antlr4.Runtime.Parser.ErrorHandler"/>
        </member>
        <member name="F:Antlr4.Runtime.Parser._input">
            <summary>The input stream.</summary>
            <seealso cref="P:Antlr4.Runtime.Parser.InputStream"/>
            <seealso cref="M:Antlr4.Runtime.Parser.SetInputStream(Antlr4.Runtime.ITokenStream)"/>
        </member>
        <member name="F:Antlr4.Runtime.Parser._ctx">
            <summary>
            The
            <see cref="T:Antlr4.Runtime.ParserRuleContext"/>
            object for the currently executing rule.
            This is always non-null during the parsing process.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Parser._buildParseTrees">
            <summary>
            Specifies whether or not the parser should construct a parse tree during
            the parsing process.
            </summary>
            <remarks>
            Specifies whether or not the parser should construct a parse tree during
            the parsing process. The default value is
            <see langword="true"/>
            .
            </remarks>
            <seealso cref="P:Antlr4.Runtime.Parser.BuildParseTree"/>
        </member>
        <member name="F:Antlr4.Runtime.Parser._tracer">
            <summary>
            When
            <see cref="P:Antlr4.Runtime.Parser.Trace"/>
            <c>(true)</c>
            is called, a reference to the
            <see cref="T:Antlr4.Runtime.Parser.TraceListener"/>
            is stored here so it can be easily removed in a
            later call to
            <see cref="P:Antlr4.Runtime.Parser.Trace"/>
            <c>(false)</c>
            . The listener itself is
            implemented as a parser listener so this field is not directly used by
            other parser methods.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Parser._parseListeners">
            <summary>
            The list of
            <see cref="T:Antlr4.Runtime.Tree.IParseTreeListener"/>
            listeners registered to receive
            events during the parse.
            </summary>
            <seealso cref="M:Antlr4.Runtime.Parser.AddParseListener(Antlr4.Runtime.Tree.IParseTreeListener)"/>
        </member>
        <member name="F:Antlr4.Runtime.Parser._syntaxErrors">
            <summary>The number of syntax errors reported during parsing.</summary>
            <remarks>
            The number of syntax errors reported during parsing. This value is
            incremented each time
            <see cref="M:Antlr4.Runtime.Parser.NotifyErrorListeners(System.String)"/>
            is called.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Parser.matchedEOF">
            <summary>Indicates parser has match()ed EOF token.</summary>
            <remarks>
            Indicates parser has match()ed EOF token. See
            <see cref="M:Antlr4.Runtime.Parser.ExitRule"/>
            .
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Parser.Reset">
            <summary>reset the parser's state</summary>
        </member>
        <member name="M:Antlr4.Runtime.Parser.Match(System.Int32)">
            <summary>
            Match current input symbol against
            <paramref name="ttype"/>
            . If the symbol type
            matches,
            <see cref="M:Antlr4.Runtime.IAntlrErrorStrategy.ReportMatch(Antlr4.Runtime.Parser)"/>
            and
            <see cref="M:Antlr4.Runtime.Parser.Consume"/>
            are
            called to complete the match process.
            <p>If the symbol type does not match,
            <see cref="M:Antlr4.Runtime.IAntlrErrorStrategy.RecoverInline(Antlr4.Runtime.Parser)"/>
            is called on the current error
            strategy to attempt recovery. If
            <see cref="P:Antlr4.Runtime.Parser.BuildParseTree"/>
            is
            <see langword="true"/>
            and the token index of the symbol returned by
            <see cref="M:Antlr4.Runtime.IAntlrErrorStrategy.RecoverInline(Antlr4.Runtime.Parser)"/>
            is -1, the symbol is added to
            the parse tree by calling
            <see cref="M:Antlr4.Runtime.ParserRuleContext.AddErrorNode(Antlr4.Runtime.IToken)"/>
            .</p>
            </summary>
            <param name="ttype">the token type to match</param>
            <returns>the matched symbol</returns>
            <exception cref="T:Antlr4.Runtime.RecognitionException">
            if the current input symbol did not match
            <paramref name="ttype"/>
            and the error strategy could not recover from the
            mismatched symbol
            </exception>
            <exception cref="T:Antlr4.Runtime.RecognitionException"/>
        </member>
        <member name="M:Antlr4.Runtime.Parser.MatchWildcard">
            <summary>Match current input symbol as a wildcard.</summary>
            <remarks>
            Match current input symbol as a wildcard. If the symbol type matches
            (i.e. has a value greater than 0),
            <see cref="M:Antlr4.Runtime.IAntlrErrorStrategy.ReportMatch(Antlr4.Runtime.Parser)"/>
            and
            <see cref="M:Antlr4.Runtime.Parser.Consume"/>
            are called to complete the match process.
            <p>If the symbol type does not match,
            <see cref="M:Antlr4.Runtime.IAntlrErrorStrategy.RecoverInline(Antlr4.Runtime.Parser)"/>
            is called on the current error
            strategy to attempt recovery. If
            <see cref="P:Antlr4.Runtime.Parser.BuildParseTree"/>
            is
            <see langword="true"/>
            and the token index of the symbol returned by
            <see cref="M:Antlr4.Runtime.IAntlrErrorStrategy.RecoverInline(Antlr4.Runtime.Parser)"/>
            is -1, the symbol is added to
            the parse tree by calling
            <see cref="M:Antlr4.Runtime.ParserRuleContext.AddErrorNode(Antlr4.Runtime.IToken)"/>
            .</p>
            </remarks>
            <returns>the matched symbol</returns>
            <exception cref="T:Antlr4.Runtime.RecognitionException">
            if the current input symbol did not match
            a wildcard and the error strategy could not recover from the mismatched
            symbol
            </exception>
            <exception cref="T:Antlr4.Runtime.RecognitionException"/>
        </member>
        <member name="P:Antlr4.Runtime.Parser.BuildParseTree">
            <summary>
            Track the
            <see cref="T:Antlr4.Runtime.ParserRuleContext"/>
            objects during the parse and hook
            them up using the
            <see cref="F:Antlr4.Runtime.ParserRuleContext.children"/>
            list so that it
            forms a parse tree. The
            <see cref="T:Antlr4.Runtime.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>
            <p>When we build parse trees, we are adding all of these contexts to
            <see cref="F:Antlr4.Runtime.ParserRuleContext.children"/>
            list. Contexts are then not candidates
            for garbage collection.</p>
            </summary>
            <summary>
            Gets whether or not a complete parse tree will be constructed while
            parsing.
            </summary>
            <remarks>
            Gets whether or not a complete parse tree will be constructed while
            parsing. This property is
            <see langword="true"/>
            for a newly constructed parser.
            </remarks>
            <returns>
            
            <see langword="true"/>
            if a complete parse tree will be constructed while
            parsing, otherwise
            <see langword="false"/>
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Parser.TrimParseTree">
            <summary>Trim the internal lists of the parse tree during parsing to conserve memory.</summary>
            <remarks>
            Trim the internal lists of the parse tree during parsing to conserve memory.
            This property is set to
            <see langword="false"/>
            by default for a newly constructed parser.
            </remarks>
            <value>
            
            <see langword="true"/>
            to trim the capacity of the
            <see cref="F:Antlr4.Runtime.ParserRuleContext.children"/>
            list to its size after a rule is parsed.
            </value>
            <returns>
            
            <see langword="true"/>
            if the
            <see cref="F:Antlr4.Runtime.ParserRuleContext.children"/>
            list is trimmed
            using the default
            <see cref="T:Antlr4.Runtime.Parser.TrimToSizeListener"/>
            during the parse process.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Parser.AddParseListener(Antlr4.Runtime.Tree.IParseTreeListener)">
            <summary>
            Registers
            <paramref name="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
            <see cref="F:Antlr4.Runtime.Tree.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>
            <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.</p>
            <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="T:System.ArgumentNullException">
            if
            <c/>
            listener is
            <see langword="null"/>
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.Parser.RemoveParseListener(Antlr4.Runtime.Tree.IParseTreeListener)">
            <summary>
            Remove
            <paramref name="listener"/>
            from the list of parse listeners.
            <p>If
            <paramref name="listener"/>
            is
            <see langword="null"/>
            or has not been added as a parse
            listener, this method does nothing.</p>
            </summary>
            <seealso cref="M:Antlr4.Runtime.Parser.AddParseListener(Antlr4.Runtime.Tree.IParseTreeListener)"/>
            <param name="listener">the listener to remove</param>
        </member>
        <member name="M:Antlr4.Runtime.Parser.RemoveParseListeners">
            <summary>Remove all parse listeners.</summary>
            <seealso cref="M:Antlr4.Runtime.Parser.AddParseListener(Antlr4.Runtime.Tree.IParseTreeListener)"/>
        </member>
        <member name="M:Antlr4.Runtime.Parser.TriggerEnterRuleEvent">
            <summary>Notify any parse listeners of an enter rule event.</summary>
            <seealso cref="M:Antlr4.Runtime.Parser.AddParseListener(Antlr4.Runtime.Tree.IParseTreeListener)"/>
        </member>
        <member name="M:Antlr4.Runtime.Parser.TriggerExitRuleEvent">
            <summary>Notify any parse listeners of an exit rule event.</summary>
            <seealso cref="M:Antlr4.Runtime.Parser.AddParseListener(Antlr4.Runtime.Tree.IParseTreeListener)"/>
        </member>
        <member name="P:Antlr4.Runtime.Parser.NumberOfSyntaxErrors">
            <summary>Gets the number of syntax errors reported during parsing.</summary>
            <remarks>
            Gets the number of syntax errors reported during parsing. This value is
            incremented each time
            <see cref="M:Antlr4.Runtime.Parser.NotifyErrorListeners(System.String)"/>
            is called.
            </remarks>
            <seealso cref="M:Antlr4.Runtime.Parser.NotifyErrorListeners(System.String)"/>
        </member>
        <member name="M:Antlr4.Runtime.Parser.GetATNWithBypassAlts">
            <summary>
            The ATN with bypass alternatives is expensive to create so we create it
            lazily.
            </summary>
            <exception cref="T:System.NotSupportedException">
            if the current parser does not
            implement the
            <see cref="P:Antlr4.Runtime.Recognizer`2.SerializedAtn"/>
            method.
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.Parser.CompileParseTreePattern(System.String,System.Int32)">
            <summary>The preferred method of getting a tree pattern.</summary>
            <remarks>
            The preferred method of getting a tree pattern. For example, here's a
            sample use:
            <pre>
            ParseTree t = parser.expr();
            ParseTreePattern p = parser.compileParseTreePattern("&lt;ID&gt;+0", MyParser.RULE_expr);
            ParseTreeMatch m = p.match(t);
            String id = m.get("ID");
            </pre>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Parser.CompileParseTreePattern(System.String,System.Int32,Antlr4.Runtime.Lexer)">
            <summary>
            The same as
            <see cref="M:Antlr4.Runtime.Parser.CompileParseTreePattern(System.String,System.Int32)"/>
            but specify a
            <see cref="T:Antlr4.Runtime.Lexer"/>
            rather than trying to deduce it from this parser.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Parser.SetInputStream(Antlr4.Runtime.ITokenStream)">
            <summary>Set the token stream and reset the parser.</summary>
        </member>
        <member name="P:Antlr4.Runtime.Parser.CurrentToken">
            <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>
        </member>
        <member name="M:Antlr4.Runtime.Parser.Consume">
            <summary>
            Consume and return the
            <linkplain>
            #getCurrentToken
            current symbol
            </linkplain>
            .
            <p>E.g., given the following input with
            <c>A</c>
            being the current
            lookahead symbol, this function moves the cursor to
            <c>B</c>
            and returns
            <c>A</c>
            .</p>
            <pre>
            A B
            ^
            </pre>
            If the parser is not in error recovery mode, the consumed symbol is added
            to the parse tree using
            <see cref="M:Antlr4.Runtime.ParserRuleContext.AddChild(Antlr4.Runtime.IToken)"/>
            , and
            <see cref="M:Antlr4.Runtime.Tree.IParseTreeListener.VisitTerminal(Antlr4.Runtime.Tree.ITerminalNode)"/>
            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
            <see cref="M:Antlr4.Runtime.ParserRuleContext.AddErrorNode(Antlr4.Runtime.IToken)"/>
            , and
            <see cref="M:Antlr4.Runtime.Tree.IParseTreeListener.VisitErrorNode(Antlr4.Runtime.Tree.IErrorNode)"/>
            is called on any parse
            listeners.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Parser.EnterRule(Antlr4.Runtime.ParserRuleContext,System.Int32,System.Int32)">
            <summary>Always called by generated parsers upon entry to a rule.</summary>
            <remarks>
            Always called by generated parsers upon entry to a rule. Access field
            <see cref="F:Antlr4.Runtime.Parser._ctx"/>
            get the current context.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Parser.Precedence">
            <summary>Get the precedence level for the top-most precedence rule.</summary>
            <returns>
            The precedence level for the top-most precedence rule, or -1 if
            the parser context is not nested within a precedence rule.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Parser.PushNewRecursionContext(Antlr4.Runtime.ParserRuleContext,System.Int32,System.Int32)">
            <summary>
            Like
            <see cref="M:Antlr4.Runtime.Parser.EnterRule(Antlr4.Runtime.ParserRuleContext,System.Int32,System.Int32)"/>
            but for recursive rules.
            Make the current context the child of the incoming localctx.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Parser.IsExpectedToken(System.Int32)">
            <summary>
            Checks whether or not
            <paramref name="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>
            
            <see langword="true"/>
            if
            <paramref name="symbol"/>
            can follow the current state in
            the ATN, otherwise
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Parser.GetExpectedTokens">
            <summary>
            Computes the set of input symbols which could follow the current parser
            state and context, as given by
            <see cref="P:Antlr4.Runtime.Recognizer`2.State"/>
            and
            <see cref="P:Antlr4.Runtime.Parser.Context"/>
            ,
            respectively.
            </summary>
            <seealso cref="M:Antlr4.Runtime.Atn.ATN.GetExpectedTokens(System.Int32,Antlr4.Runtime.RuleContext)"/>
        </member>
        <member name="M:Antlr4.Runtime.Parser.GetRuleIndex(System.String)">
            <summary>
            Get a rule's index (i.e.,
            <c>RULE_ruleName</c>
            field) or -1 if not found.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Parser.GetRuleInvocationStack">
            <summary>
            Return List&lt;String&gt; of the rule names in your parser instance
            leading up to a call to the current rule.
            </summary>
            <remarks>
            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.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Parser.GetDFAStrings">
            <summary>For debugging and other purposes.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Parser.DumpDFA">
            <summary>For debugging and other purposes.</summary>
        </member>
        <member name="P:Antlr4.Runtime.Parser.Profile">
            <since>4.3</since>
        </member>
        <member name="P:Antlr4.Runtime.Parser.Trace">
            <summary>
            During a parse is sometimes useful to listen in on the rule entry and exit
            events as well as token matches.
            </summary>
            <remarks>
            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.
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.ParserInterpreter">
            <summary>
            A parser simulator that mimics what ANTLR's generated
            parser code does.
            </summary>
            <remarks>
            A parser simulator that mimics what ANTLR's generated
            parser code does. A ParserATNSimulator is used to make
            predictions via adaptivePredict but this class moves a pointer through the
            ATN to simulate parsing. ParserATNSimulator just
            makes us efficient rather than having to backtrack, for example.
            This properly creates parse trees even for left recursive rules.
            We rely on the left recursive rule invocation and special predicate
            transitions to make left recursive rules work.
            See TestParserInterpreter for examples.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.ParserInterpreter.pushRecursionContextStates">
            <summary>
            This identifies StarLoopEntryState's that begin the (...)
            precedence loops of left recursive rules.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.ParserInterpreter._parentContextStack">
            <summary>
            This stack corresponds to the _parentctx, _parentState pair of locals
            that would exist on call stack frames with a recursive descent parser;
            in the generated function for a left-recursive rule you'd see:
            private EContext e(int _p) throws RecognitionException {
            ParserRuleContext _parentctx = _ctx;    // Pair.a
            int _parentState = getState();          // Pair.b
            ...
            </summary>
            <remarks>
            This stack corresponds to the _parentctx, _parentState pair of locals
            that would exist on call stack frames with a recursive descent parser;
            in the generated function for a left-recursive rule you'd see:
            private EContext e(int _p) throws RecognitionException {
            ParserRuleContext _parentctx = _ctx;    // Pair.a
            int _parentState = getState();          // Pair.b
            ...
            }
            Those values are used to create new recursive rule invocation contexts
            associated with left operand of an alt like "expr '*' expr".
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.ParserInterpreter.overrideDecision">
            <summary>
            We need a map from (decision,inputIndex)-&gt;forced alt for computing ambiguous
            parse trees.
            </summary>
            <remarks>
            We need a map from (decision,inputIndex)-&gt;forced alt for computing ambiguous
            parse trees. For now, we allow exactly one override.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.ParserInterpreter.overrideDecisionRoot">
            <summary>
            What is the current context when we override a decisions?  This tells
            us what the root of the parse tree is when using override
            for an ambiguity/lookahead check.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.ParserInterpreter.#ctor(Antlr4.Runtime.ParserInterpreter)">
            <summary>
            A copy constructor that creates a new parser interpreter by reusing
            the fields of a previous interpreter.
            </summary>
            <param name="old">The interpreter to copy</param>
            <since>4.5</since>
        </member>
        <member name="M:Antlr4.Runtime.ParserInterpreter.Parse(System.Int32)">
            <summary>Begin parsing at startRuleIndex</summary>
        </member>
        <member name="M:Antlr4.Runtime.ParserInterpreter.VisitDecisionState(Antlr4.Runtime.Atn.DecisionState)">
            <summary>
            Method visitDecisionState() is called when the interpreter reaches
            a decision state (instance of DecisionState).
            </summary>
            <remarks>
            Method visitDecisionState() is called when the interpreter reaches
            a decision state (instance of DecisionState). It gives an opportunity
            for subclasses to track interesting things.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.ParserInterpreter.CreateInterpreterRuleContext(Antlr4.Runtime.ParserRuleContext,System.Int32,System.Int32)">
            <summary>Provide simple "factory" for InterpreterRuleContext's.</summary>
            <since>4.5.1</since>
        </member>
        <member name="M:Antlr4.Runtime.ParserInterpreter.AddDecisionOverride(System.Int32,System.Int32,System.Int32)">
            <summary>
            Override this parser interpreters normal decision-making process
            at a particular decision and input token index.
            </summary>
            <remarks>
            Override this parser interpreters normal decision-making process
            at a particular decision and input token index. Instead of
            allowing the adaptive prediction mechanism to choose the
            first alternative within a block that leads to a successful parse,
            force it to take the alternative, 1..n for n alternatives.
            As an implementation limitation right now, you can only specify one
            override. This is sufficient to allow construction of different
            parse trees for ambiguous input. It means re-parsing the entire input
            in general because you're never sure where an ambiguous sequence would
            live in the various parse trees. For example, in one interpretation,
            an ambiguous input sequence would be matched completely in expression
            but in another it could match all the way back to the root.
            s : e '!'? ;
            e : ID
            | ID '!'
            ;
            Here, x! can be matched as (s (e ID) !) or (s (e ID !)). In the first
            case, the ambiguous sequence is fully contained only by the root.
            In the second case, the ambiguous sequences fully contained within just
            e, as in: (e ID !).
            Rather than trying to optimize this and make
            some intelligent decisions for optimization purposes, I settled on
            just re-parsing the whole input and then using
            {link Trees#getRootOfSubtreeEnclosingRegion} to find the minimal
            subtree that contains the ambiguous sequence. I originally tried to
            record the call stack at the point the parser detected and ambiguity but
            left recursive rules create a parse tree stack that does not reflect
            the actual call stack. That impedance mismatch was enough to make
            it it challenging to restart the parser at a deeply nested rule
            invocation.
            Only parser interpreters can override decisions so as to avoid inserting
            override checking code in the critical ALL(*) prediction execution path.
            </remarks>
            <since>4.5</since>
        </member>
        <member name="M:Antlr4.Runtime.ParserInterpreter.Recover(Antlr4.Runtime.RecognitionException)">
            <summary>
            Rely on the error handler for this parser but, if no tokens are consumed
            to recover, add an error node.
            </summary>
            <remarks>
            Rely on the error handler for this parser but, if no tokens are consumed
            to recover, add an error node. Otherwise, nothing is seen in the parse
            tree.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.ParserInterpreter.RootContext">
            <summary>
            Return the root of the parse, which can be useful if the parser
            bails out.
            </summary>
            <remarks>
            Return the root of the parse, which can be useful if the parser
            bails out. You still can access the top node. Note that,
            because of the way left recursive rules add children, it's possible
            that the root will not have any children if the start rule immediately
            called and left recursive rule that fails.
            </remarks>
            <since>4.5.1</since>
        </member>
        <member name="T:Antlr4.Runtime.ParserRuleContext">
            <summary>A rule invocation record for parsing.</summary>
            <remarks>
            A rule invocation record for parsing.
            Contains all of the information about the current rule not stored in the
            RuleContext. It handles parse tree children list, Any ATN state
            tracing, and the default values available for rule invocations:
            start, stop, rule index, current alt number.
            Subclasses made for each rule and grammar track the parameters,
            return values, locals, and labels specific to that rule. These
            are the objects that are returned from rules.
            Note text is not an actual field of a rule return value; it is computed
            from start and stop using the input stream's toString() method.  I
            could add a ctor to this so that we can pass in and store the input
            stream, but I'm not sure we want to do that.  It would seem to be undefined
            to get the .text property anyway if the rule matches tokens from multiple
            input streams.
            I do not use getters for fields of objects that are used simply to
            group values such as this aggregate.  The getters/setters are there to
            satisfy the superclass interface.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.ParserRuleContext.children">
            <summary>
            If we are debugging or building a parse tree for a visitor,
            we need to track all of the tokens and rule invocations associated
            with this rule's context.
            </summary>
            <remarks>
            If we are debugging or building a parse tree for a visitor,
            we need to track all of the tokens and rule invocations associated
            with this rule's context. This is empty for parsing w/o tree constr.
            operation because we don't the need to track the details about
            how we parse this rule.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.ParserRuleContext.start">
            <summary>
            For debugging/tracing purposes, we want to track all of the nodes in
            the ATN traversed by the parser for a particular rule.
            </summary>
            <remarks>
            For debugging/tracing purposes, we want to track all of the nodes in
            the ATN traversed by the parser for a particular rule.
            This list indicates the sequence of ATN nodes used to match
            the elements of the children list. This list does not include
            ATN nodes and other rules used to match rule invocations. It
            traces the rule invocation node itself but nothing inside that
            other rule's ATN submachine.
            There is NOT a one-to-one correspondence between the children and
            states list. There are typically many nodes in the ATN traversed
            for each element in the children list. For example, for a rule
            invocation there is the invoking state and the following state.
            The parser setState() method updates field s and adds it to this list
            if we are debugging/tracing.
            This does not trace states visited during prediction.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.ParserRuleContext.stop">
            <summary>
            For debugging/tracing purposes, we want to track all of the nodes in
            the ATN traversed by the parser for a particular rule.
            </summary>
            <remarks>
            For debugging/tracing purposes, we want to track all of the nodes in
            the ATN traversed by the parser for a particular rule.
            This list indicates the sequence of ATN nodes used to match
            the elements of the children list. This list does not include
            ATN nodes and other rules used to match rule invocations. It
            traces the rule invocation node itself but nothing inside that
            other rule's ATN submachine.
            There is NOT a one-to-one correspondence between the children and
            states list. There are typically many nodes in the ATN traversed
            for each element in the children list. For example, for a rule
            invocation there is the invoking state and the following state.
            The parser setState() method updates field s and adds it to this list
            if we are debugging/tracing.
            This does not trace states visited during prediction.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.ParserRuleContext.exception">
            <summary>The exception that forced this rule to return.</summary>
            <remarks>
            The exception that forced this rule to return. If the rule successfully
            completed, this is
            <see langword="null"/>
            .
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.ParserRuleContext.CopyFrom(Antlr4.Runtime.ParserRuleContext)">
            <summary>
            COPY a ctx (I'm deliberately not using copy constructor) to avoid
            confusion with creating node with parent.
            </summary>
            <remarks>
            COPY a ctx (I'm deliberately not using copy constructor) to avoid
            confusion with creating node with parent. Does not copy children.
            <p>This is used in the generated parser code to flip a generic XContext
            node for rule X to a YContext for alt label Y. In that sense, it is not
            really a generic copy function.</p>
            <p>If we do an error sync() at start of a rule, we might add error nodes
            to the generic XContext so this function must copy those nodes to the
            YContext as well else they are lost!</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.ParserRuleContext.AddChild(Antlr4.Runtime.Tree.ITerminalNode)">
            <summary>Does not set parent link; other add methods do that</summary>
        </member>
        <member name="M:Antlr4.Runtime.ParserRuleContext.RemoveLastChild">
            <summary>
            Used by enterOuterAlt to toss out a RuleContext previously added as
            we entered a rule.
            </summary>
            <remarks>
            Used by enterOuterAlt to toss out a RuleContext previously added as
            we entered a rule. If we have # label, we will need to remove
            generic ruleContext object.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.ParserRuleContext.Start">
            <summary>Get the initial token in this context.</summary>
            <remarks>
            Get the initial token in this context.
            Note that the range from start to stop is inclusive, so for rules that do not consume anything
            (for example, zero length or error productions) this token may exceed stop.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.ParserRuleContext.Stop">
            <summary>Get the final token in this context.</summary>
            <remarks>
            Get the final token in this context.
            Note that the range from start to stop is inclusive, so for rules that do not consume anything
            (for example, zero length or error productions) this token may precede start.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.ParserRuleContext.ToInfoString(Antlr4.Runtime.Parser)">
            <summary>Used for rule context info debugging during parse-time, not so much for ATN debugging</summary>
        </member>
        <member name="T:Antlr4.Runtime.ProxyErrorListener`1">
            <summary>
            This implementation of
            <see cref="T:Antlr4.Runtime.IAntlrErrorListener`1"/>
            dispatches all calls to a
            collection of delegate listeners. This reduces the effort required to support multiple
            listeners.
            </summary>
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.ProxyParserErrorListener">
            <author>Sam Harwell</author>
        </member>
        <member name="T:Antlr4.Runtime.RecognitionException">
            <summary>The root of the ANTLR exception hierarchy.</summary>
            <remarks>
            The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
            3 kinds of errors: prediction errors, failed predicate errors, and
            mismatched input errors. In each case, the parser knows where it is
            in the input, where it is in the ATN, the rule invocation stack,
            and what kind of problem occurred.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.RecognitionException.recognizer">
            <summary>
            The
            <see cref="T:Antlr4.Runtime.IRecognizer"/>
            where this exception originated.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.RecognitionException.offendingToken">
            <summary>
            The current
            <see cref="T:Antlr4.Runtime.IToken"/>
            when an error occurred. Since not all streams
            support accessing symbols by index, we have to track the
            <see cref="T:Antlr4.Runtime.IToken"/>
            instance itself.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.RecognitionException.OffendingState">
            <summary>
            Get the ATN state number the parser was in at the time the error
            occurred.
            </summary>
            <remarks>
            Get the ATN state number the parser was in at the time the error
            occurred. For
            <see cref="T:Antlr4.Runtime.NoViableAltException"/>
            and
            <see cref="T:Antlr4.Runtime.LexerNoViableAltException"/>
            exceptions, this is the
            <see cref="T:Antlr4.Runtime.Atn.DecisionState"/>
            number. For others, it is the state whose outgoing
            edge we couldn't match.
            <p>If the state number is not known, this method returns -1.</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.RecognitionException.GetExpectedTokens">
            <summary>
            Gets the set of input symbols which could potentially follow the
            previously matched symbol at the time this exception was thrown.
            </summary>
            <remarks>
            Gets the set of input symbols which could potentially follow the
            previously matched symbol at the time this exception was thrown.
            <p>If the set of expected tokens is not known and could not be computed,
            this method returns
            <see langword="null"/>
            .</p>
            </remarks>
            <returns>
            The set of token types that could potentially follow the current
            state in the ATN, or
            <see langword="null"/>
            if the information is not available.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.RecognitionException.Context">
            <summary>
            Gets the
            <see cref="T:Antlr4.Runtime.RuleContext"/>
            at the time this exception was thrown.
            <p>If the context is not available, this method returns
            <see langword="null"/>
            .</p>
            </summary>
            <returns>
            The
            <see cref="T:Antlr4.Runtime.RuleContext"/>
            at the time this exception was thrown.
            If the context is not available, this method returns
            <see langword="null"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.RecognitionException.InputStream">
            <summary>
            Gets the input stream which is the symbol source for the recognizer where
            this exception was thrown.
            </summary>
            <remarks>
            Gets the input stream which is the symbol source for the recognizer where
            this exception was thrown.
            <p>If the input stream is not available, this method returns
            <see langword="null"/>
            .</p>
            </remarks>
            <returns>
            The input stream which is the symbol source for the recognizer
            where this exception was thrown, or
            <see langword="null"/>
            if the stream is not
            available.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.RecognitionException.Recognizer">
            <summary>
            Gets the
            <see cref="T:Antlr4.Runtime.IRecognizer"/>
            where this exception occurred.
            <p>If the recognizer is not available, this method returns
            <see langword="null"/>
            .</p>
            </summary>
            <returns>
            The recognizer where this exception occurred, or
            <see langword="null"/>
            if
            the recognizer is not available.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Recognizer`2.TokenNames">
            <summary>
            Used to print out token names like ID during debugging and
            error reporting.
            </summary>
            <remarks>
            Used to print out token names like ID during debugging and
            error reporting.  The generated parsers implement a method
            that overrides this to point to their String[] tokenNames.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Recognizer`2.Vocabulary">
            <summary>Get the vocabulary used by the recognizer.</summary>
            <returns>
            A
            <see cref="T:Antlr4.Runtime.IVocabulary"/>
            instance providing information about the
            vocabulary used by the grammar.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Recognizer`2.TokenTypeMap">
            <summary>Get a map from token names to token types.</summary>
            <remarks>
            Get a map from token names to token types.
            <p>Used for XPath and tree pattern compilation.</p>
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Recognizer`2.RuleIndexMap">
            <summary>Get a map from rule names to rule indexes.</summary>
            <remarks>
            Get a map from rule names to rule indexes.
            <p>Used for XPath and tree pattern compilation.</p>
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Recognizer`2.SerializedAtn">
            <summary>
            If this recognizer was generated, it will have a serialized ATN
            representation of the grammar.
            </summary>
            <remarks>
            If this recognizer was generated, it will have a serialized ATN
            representation of the grammar.
            <p>For interpreters, we don't know their serialized ATN despite having
            created the interpreter from it.</p>
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Recognizer`2.GrammarFileName">
            <summary>For debugging and other purposes, might want the grammar name.</summary>
            <remarks>
            For debugging and other purposes, might want the grammar name.
            Have ANTLR generate an implementation for this method.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Recognizer`2.Atn">
            <summary>
            Get the
            <see cref="T:Antlr4.Runtime.Atn.ATN"/>
            used by the recognizer for prediction.
            </summary>
            <returns>
            The
            <see cref="T:Antlr4.Runtime.Atn.ATN"/>
            used by the recognizer for prediction.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Recognizer`2.Interpreter">
            <summary>Get the ATN interpreter used by the recognizer for prediction.</summary>
            <returns>The ATN interpreter used by the recognizer for prediction.</returns>
            <summary>Set the ATN interpreter used by the recognizer for prediction.</summary>
            <value>
            The ATN interpreter used by the recognizer for
            prediction.
            </value>
        </member>
        <member name="P:Antlr4.Runtime.Recognizer`2.ParseInfo">
            <summary>
            If profiling during the parse/lex, this will return DecisionInfo records
            for each decision in recognizer in a ParseInfo object.
            </summary>
            <since>4.3</since>
        </member>
        <member name="M:Antlr4.Runtime.Recognizer`2.GetErrorHeader(Antlr4.Runtime.RecognitionException)">
            <summary>What is the error header, normally line/character position information?</summary>
        </member>
        <member name="M:Antlr4.Runtime.Recognizer`2.GetTokenErrorDisplay(Antlr4.Runtime.IToken)">
            <summary>
            How should a token be displayed in an error message? The default
            is to display just the text, but during development you might
            want to have a lot of information spit out.
            </summary>
            <remarks>
            How should a token be displayed in an error message? The default
            is to display just the text, but during development you might
            want to have a lot of information spit out.  Override in that case
            to use t.toString() (which, for CommonToken, dumps everything about
            the token). This is better than forcing you to override a method in
            your token objects because you don't have to go modify your lexer
            so that it creates a new Java type.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Recognizer`2.AddErrorListener(Antlr4.Runtime.IAntlrErrorListener{`0})">
            <exception>
            NullPointerException
            if
            <paramref name="listener"/>
            is
            <see langword="null"/>
            .
            </exception>
        </member>
        <member name="P:Antlr4.Runtime.Recognizer`2.ErrorListeners">
            <summary>
            Gets a copy of the error listeners registered with this recognizer instance. Since this list is a copy of
            the original, any changes made to it will have no impact on the recognizer.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Recognizer`2.State">
            <summary>
            Indicate that the recognizer has changed internal state that is
            consistent with the ATN state passed in.
            </summary>
            <remarks>
            Indicate that the recognizer has changed internal state that is
            consistent with the ATN state passed in.  This way we always know
            where we are in the ATN as the parser goes along. The rule
            context objects form a stack that lets us see the stack of
            invoking rules. Combine this and we have complete ATN
            configuration information.
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.RuleContext">
            <summary>A rule context is a record of a single rule invocation.</summary>
            <remarks>
            A rule context is a record of a single rule invocation.
            We form a stack of these context objects using the parent
            pointer. A parent pointer of null indicates that the current
            context is the bottom of the stack. The ParserRuleContext subclass
            as a children list so that we can turn this data structure into a
            tree.
            The root node always has a null pointer and invokingState of -1.
            Upon entry to parsing, the first invoked rule function creates a
            context object (a subclass specialized for that rule such as
            SContext) and makes it the root of a parse tree, recorded by field
            Parser._ctx.
            public final SContext s() throws RecognitionException {
            SContext _localctx = new SContext(_ctx, getState()); &lt;-- create new node
            enterRule(_localctx, 0, RULE_s);                     &lt;-- push it
            ...
            exitRule();                                          &lt;-- pop back to _localctx
            return _localctx;
            }
            A subsequent rule invocation of r from the start rule s pushes a
            new context object for r whose parent points at s and use invoking
            state is the state with r emanating as edge label.
            The invokingState fields from a context object to the root
            together form a stack of rule indication states where the root
            (bottom of the stack) has a -1 sentinel value. If we invoke start
            symbol s then call r1, which calls r2, the  would look like
            this:
            SContext[-1]   &lt;- root node (bottom of the stack)
            R1Context[p]   &lt;- p in rule s called r1
            R2Context[q]   &lt;- q in rule r1 called r2
            So the top of the stack, _ctx, represents a call to the current
            rule and it holds the return address from another rule that invoke
            to this rule. To invoke a rule, we must always have a current context.
            The parent contexts are useful for computing lookahead sets and
            getting error information.
            These objects are used during parsing and prediction.
            For the special case of parsers, we use the subclass
            ParserRuleContext.
            </remarks>
            <seealso cref="T:Antlr4.Runtime.ParserRuleContext"/>
        </member>
        <member name="F:Antlr4.Runtime.RuleContext.parent">
            <summary>What context invoked this rule?</summary>
        </member>
        <member name="F:Antlr4.Runtime.RuleContext.invokingState">
            <summary>
            What state invoked the rule associated with this context?
            The "return address" is the followState of invokingState
            If parent is null, this should be -1 this context object represents
            the start rule.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.RuleContext.IsEmpty">
            <summary>
            A context is empty if there is no invoking state; meaning nobody called
            current context.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.RuleContext.GetText">
            <summary>Return the combined text of all child nodes.</summary>
            <remarks>
            Return the combined text of all child nodes. This method only considers
            tokens which have been added to the parse tree.
            <p/>
            Since tokens on hidden channels (e.g. whitespace or comments) are not
            added to the parse trees, they will not appear in the output of this
            method.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.RuleContext.OuterAlternative">
            <summary>
            For rule associated with this parse tree internal node, return
            the outer alternative number used to match the input.
            </summary>
            <remarks>
            For rule associated with this parse tree internal node, return
            the outer alternative number used to match the input. Default
            implementation does not compute nor store this alt num. Create
            a subclass of ParserRuleContext with backing field and set
            option contextSuperClass.
            to set it.
            </remarks>
            <since>4.5.3</since>
            <summary>Set the outer alternative number for this context node.</summary>
            <remarks>
            Set the outer alternative number for this context node. Default
            implementation does nothing to avoid backing field overhead for
            trees that don't need it.  Create
            a subclass of ParserRuleContext with backing field and set
            option contextSuperClass.
            </remarks>
            <since>4.5.3</since>
        </member>
        <member name="M:Antlr4.Runtime.RuleContext.ToStringTree(Antlr4.Runtime.Parser)">
            <summary>
            Print out a whole tree, not just a node, in LISP format
            (root child1 ..
            </summary>
            <remarks>
            Print out a whole tree, not just a node, in LISP format
            (root child1 .. childN). Print just a node if this is a leaf.
            We have to know the recognizer so we can get rule names.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.RuleContext.ToStringTree(System.Collections.Generic.IList{System.String})">
            <summary>
            Print out a whole tree, not just a node, in LISP format
            (root child1 ..
            </summary>
            <remarks>
            Print out a whole tree, not just a node, in LISP format
            (root child1 .. childN). Print just a node if this is a leaf.
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.RuleContextWithAltNum">
            <summary>
            A handy class for use with
            options {contextSuperClass=org.antlr.v4.runtime.RuleContextWithAltNum;}
            that provides a property for the outer alternative number
            matched for an internal parse tree node.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.TokenStreamRewriter">
            <summary>
            Useful for rewriting out a buffered input token stream after doing some
            augmentation or other manipulations on it.
            </summary>
            <remarks>
            Useful for rewriting out a buffered input token stream after doing some
            augmentation or other manipulations on it.
            <p>
            You can insert stuff, replace, and delete chunks. Note that the operations
            are done lazily--only if you convert the buffer to a
            <see cref="T:System.String"/>
            with
            <see cref="M:Antlr4.Runtime.ITokenStream.GetText"/>
            . This is very efficient because you are not
            moving data around all the time. As the buffer of tokens is converted to
            strings, the
            <see cref="M:Antlr4.Runtime.TokenStreamRewriter.GetText"/>
            method(s) scan the input token stream and
            check to see if there is an operation at the current index. If so, the
            operation is done and then normal
            <see cref="T:System.String"/>
            rendering continues on the
            buffer. This is like having multiple Turing machine instruction streams
            (programs) operating on a single input tape. :)</p>
            <p>
            This rewriter makes no modifications to the token stream. It does not ask the
            stream to fill itself up nor does it advance the input cursor. The token
            stream
            <see cref="P:Antlr4.Runtime.IIntStream.Index"/>
            will return the same value before and
            after any
            <see cref="M:Antlr4.Runtime.TokenStreamRewriter.GetText"/>
            call.</p>
            <p>
            The rewriter only works on tokens that you have in the buffer and ignores the
            current input cursor. If you are buffering tokens on-demand, calling
            <see cref="M:Antlr4.Runtime.TokenStreamRewriter.GetText"/>
            halfway through the input will only do rewrites for those
            tokens in the first half of the file.</p>
            <p>
            Since the operations are done lazily at
            <see cref="M:Antlr4.Runtime.TokenStreamRewriter.GetText"/>
            -time, operations do
            not screw up the token index values. That is, an insert operation at token
            index
            <c>i</c>
            does not change the index values for tokens
            <c>i</c>
            +1..n-1.</p>
            <p>
            Because operations never actually alter the buffer, you may always get the
            original token stream back without undoing anything. Since the instructions
            are queued up, you can easily simulate transactions and roll back any changes
            if there is an error just by removing instructions. For example,</p>
            <pre>
            CharStream input = new ANTLRFileStream("input");
            TLexer lex = new TLexer(input);
            CommonTokenStream tokens = new CommonTokenStream(lex);
            T parser = new T(tokens);
            TokenStreamRewriter rewriter = new TokenStreamRewriter(tokens);
            parser.startRule();
            </pre>
            <p>
            Then in the rules, you can execute (assuming rewriter is visible):</p>
            <pre>
            Token t,u;
            ...
            rewriter.insertAfter(t, "text to put after t");}
            rewriter.insertAfter(u, "text after u");}
            System.out.println(rewriter.getText());
            </pre>
            <p>
            You can also have multiple "instruction streams" and get multiple rewrites
            from a single pass over the input. Just name the instruction streams and use
            that name again when printing the buffer. This could be useful for generating
            a C file and also its header file--all from the same buffer:</p>
            <pre>
            rewriter.insertAfter("pass1", t, "text to put after t");}
            rewriter.insertAfter("pass2", u, "text after u");}
            System.out.println(rewriter.getText("pass1"));
            System.out.println(rewriter.getText("pass2"));
            </pre>
            <p>
            If you don't use named rewrite streams, a "default" stream is used as the
            first example shows.</p>
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.TokenStreamRewriter.RewriteOperation.instructionIndex">
            <summary>What index into rewrites List are we?</summary>
        </member>
        <member name="F:Antlr4.Runtime.TokenStreamRewriter.RewriteOperation.index">
            <summary>Token buffer index.</summary>
        </member>
        <member name="M:Antlr4.Runtime.TokenStreamRewriter.RewriteOperation.Execute(System.Text.StringBuilder)">
            <summary>Execute the rewrite operation by possibly adding to the buffer.</summary>
            <remarks>
            Execute the rewrite operation by possibly adding to the buffer.
            Return the index of the next token to operate on.
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.TokenStreamRewriter.InsertAfterOp">
            <summary>
            Distinguish between insert after/before to do the "insert afters"
            first and then the "insert befores" at same index.
            </summary>
            <remarks>
            Distinguish between insert after/before to do the "insert afters"
            first and then the "insert befores" at same index. Implementation
            of "insert after" is "insert before index+1".
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.TokenStreamRewriter.ReplaceOp">
            <summary>
            I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
            instructions.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.TokenStreamRewriter.tokens">
            <summary>Our source stream</summary>
        </member>
        <member name="F:Antlr4.Runtime.TokenStreamRewriter.programs">
            <summary>You may have multiple, named streams of rewrite operations.</summary>
            <remarks>
            You may have multiple, named streams of rewrite operations.
            I'm calling these things "programs."
            Maps String (name) &#x2192; rewrite (List)
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.TokenStreamRewriter.lastRewriteTokenIndexes">
            <summary>Map String (program name) &#x2192; Integer index</summary>
        </member>
        <member name="M:Antlr4.Runtime.TokenStreamRewriter.Rollback(System.String,System.Int32)">
            <summary>
            Rollback the instruction stream for a program so that
            the indicated instruction (via instructionIndex) is no
            longer in the stream.
            </summary>
            <remarks>
            Rollback the instruction stream for a program so that
            the indicated instruction (via instructionIndex) is no
            longer in the stream. UNTESTED!
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.TokenStreamRewriter.DeleteProgram(System.String)">
            <summary>Reset the program so that no instructions exist</summary>
        </member>
        <member name="M:Antlr4.Runtime.TokenStreamRewriter.GetText">
            <summary>
            Return the text from the original tokens altered per the
            instructions given to this rewriter.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.TokenStreamRewriter.GetText(System.String)">
            <summary>
            Return the text from the original tokens altered per the
            instructions given to this rewriter in programName.
            </summary>
            <since>4.5</since>
        </member>
        <member name="M:Antlr4.Runtime.TokenStreamRewriter.GetText(Antlr4.Runtime.Misc.Interval)">
            <summary>
            Return the text associated with the tokens in the interval from the
            original token stream but with the alterations given to this rewriter.
            </summary>
            <remarks>
            Return the text associated with the tokens in the interval from the
            original token stream but with the alterations given to this rewriter.
            The interval refers to the indexes in the original token stream.
            We do not alter the token stream in any way, so the indexes
            and intervals are still consistent. Includes any operations done
            to the first and last token in the interval. So, if you did an
            insertBefore on the first token, you would get that insertion.
            The same is true if you do an insertAfter the stop token.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.TokenStreamRewriter.ReduceToSingleOperationPerIndex(System.Collections.Generic.IList{Antlr4.Runtime.TokenStreamRewriter.RewriteOperation})">
            <summary>
            We need to combine operations and report invalid operations (like
            overlapping replaces that are not completed nested).
            </summary>
            <remarks>
            We need to combine operations and report invalid operations (like
            overlapping replaces that are not completed nested). Inserts to
            same index need to be combined etc...  Here are the cases:
            I.i.u I.j.v								leave alone, nonoverlapping
            I.i.u I.i.v								combine: Iivu
            R.i-j.u R.x-y.v	| i-j in x-y			delete first R
            R.i-j.u R.i-j.v							delete first R
            R.i-j.u R.x-y.v	| x-y in i-j			ERROR
            R.i-j.u R.x-y.v	| boundaries overlap	ERROR
            Delete special case of replace (text==null):
            D.i-j.u D.x-y.v	| boundaries overlap	combine to max(min)..max(right)
            I.i.u R.x-y.v | i in (x+1)-y			delete I (since insert before
            we're not deleting i)
            I.i.u R.x-y.v | i not in (x+1)-y		leave alone, nonoverlapping
            R.x-y.v I.i.u | i in x-y				ERROR
            R.x-y.v I.x.u 							R.x-y.uv (combine, delete I)
            R.x-y.v I.i.u | i not in x-y			leave alone, nonoverlapping
            I.i.u = insert u before op @ index i
            R.x-y.u = replace x-y indexed tokens with u
            First we need to examine replaces. For any replace op:
            1. wipe out any insertions before op within that range.
            2. Drop any replace op before that is contained completely within
            that range.
            3. Throw exception upon boundary overlap with any previous replace.
            Then we can deal with inserts:
            1. for any inserts to same index, combine even if not adjacent.
            2. for any prior replace with same left boundary, combine this
            insert with replace and delete this replace.
            3. throw exception if index in same range as previous replace
            Don't actually delete; make op null in list. Easier to walk list.
            Later we can throw as we add to index &#x2192; op map.
            Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
            inserted stuff would be before the replace range. But, if you
            add tokens in front of a method body '{' and then delete the method
            body, I think the stuff before the '{' you added should disappear too.
            Return a map from token index to operation.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.TokenStreamRewriter.GetKindOfOps``1(System.Collections.Generic.IList{Antlr4.Runtime.TokenStreamRewriter.RewriteOperation},System.Int32)">
            <summary>Get all operations before an index of a particular kind</summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.Visit(Antlr4.Runtime.Tree.IParseTree)">
            <summary>
            <inheritDoc/>
            <p>The default implementation calls
            <see cref="M:Antlr4.Runtime.Tree.IParseTree.Accept``1(Antlr4.Runtime.Tree.IParseTreeVisitor{``0})"/>
            on the
            specified tree.</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)">
            <summary>
            <inheritDoc/>
            <p>The default implementation initializes the aggregate result to
            <see cref="P:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.DefaultResult">defaultResult()</see>
            . Before visiting each child, it
            calls
            <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.ShouldVisitNextChild(Antlr4.Runtime.Tree.IRuleNode,`0)">shouldVisitNextChild</see>
            ; if the result
            is
            <see langword="false"/>
            no more children are visited and the current aggregate
            result is returned. After visiting a child, the aggregate result is
            updated by calling
            <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.AggregateResult(`0,`0)">aggregateResult</see>
            with the
            previous aggregate result and the result of visiting the child.</p>
            <p>The default implementation is not safe for use in visitors that modify
            the tree structure. Visitors that modify the tree should override this
            method to behave properly in respect to the specific algorithm in use.</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitTerminal(Antlr4.Runtime.Tree.ITerminalNode)">
            <summary>
            <inheritDoc/>
            <p>The default implementation returns the result of
            <see cref="P:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.DefaultResult">defaultResult</see>
            .</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitErrorNode(Antlr4.Runtime.Tree.IErrorNode)">
            <summary>
            <inheritDoc/>
            <p>The default implementation returns the result of
            <see cref="P:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.DefaultResult">defaultResult</see>
            .</p>
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.DefaultResult">
            <summary>Gets the default value returned by visitor methods.</summary>
            <remarks>
            Gets the default value returned by visitor methods. This value is
            returned by the default implementations of
            <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitTerminal(Antlr4.Runtime.Tree.ITerminalNode)">visitTerminal</see>
            ,
            <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitErrorNode(Antlr4.Runtime.Tree.IErrorNode)">visitErrorNode</see>
            .
            The default implementation of
            <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)">visitChildren</see>
            initializes its aggregate result to this value.
            <p>The base implementation returns
            <see langword="null"/>
            .</p>
            </remarks>
            <returns>The default value returned by visitor methods.</returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.AggregateResult(`0,`0)">
            <summary>Aggregates the results of visiting multiple children of a node.</summary>
            <remarks>
            Aggregates the results of visiting multiple children of a node. After
            either all children are visited or
            <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.ShouldVisitNextChild(Antlr4.Runtime.Tree.IRuleNode,`0)"/>
            returns
            <see langword="false"/>
            , the aggregate value is returned as the result of
            <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
            .
            <p>The default implementation returns
            <paramref name="nextResult"/>
            , meaning
            <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
            will return the result of the last child visited
            (or return the initial value if the node has no children).</p>
            </remarks>
            <param name="aggregate">
            The previous aggregate value. In the default
            implementation, the aggregate value is initialized to
            <see cref="P:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.DefaultResult"/>
            , which is passed as the
            <paramref name="aggregate"/>
            argument
            to this method after the first child node is visited.
            </param>
            <param name="nextResult">
            The result of the immediately preceeding call to visit
            a child node.
            </param>
            <returns>The updated aggregate result.</returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.ShouldVisitNextChild(Antlr4.Runtime.Tree.IRuleNode,`0)">
            <summary>
            This method is called after visiting each child in
            <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
            . This method is first called before the first
            child is visited; at that point
            <paramref name="currentResult"/>
            will be the initial
            value (in the default implementation, the initial value is returned by a
            call to
            <see cref="P:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.DefaultResult"/>
            . This method is not called after the last
            child is visited.
            <p>The default implementation always returns
            <see langword="true"/>
            , indicating that
            <c>visitChildren</c>
            should only return after all children are visited.
            One reason to override this method is to provide a "short circuit"
            evaluation option for situations where the result of visiting a single
            child has the potential to determine the result of the visit operation as
            a whole.</p>
            </summary>
            <param name="node">
            The
            <see cref="T:Antlr4.Runtime.Tree.IRuleNode"/>
            whose children are currently being
            visited.
            </param>
            <param name="currentResult">
            The current aggregate result of the children visited
            to the current point.
            </param>
            <returns>
            
            <see langword="true"/>
            to continue visiting children. Otherwise return
            <see langword="false"/>
            to stop visiting children and immediately return the
            current aggregate result from
            <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
            .
            </returns>
        </member>
        <member name="T:Antlr4.Runtime.Tree.ErrorNodeImpl">
            <summary>
            Represents a token that was consumed during resynchronization
            rather than during a valid match operation.
            </summary>
            <remarks>
            Represents a token that was consumed during resynchronization
            rather than during a valid match operation. For example,
            we will create this kind of a node during single token insertion
            and deletion as well as during "consume until error recovery set"
            upon no viable alternative exceptions.
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.Tree.IParseTree">
            <summary>
            An interface to access the tree of
            <see cref="T:Antlr4.Runtime.RuleContext"/>
            objects created
            during a parse that makes the data structure look like a simple parse tree.
            This node represents both internal nodes, rule invocations,
            and leaf nodes, token matches.
            <p>The payload is either a
            <see cref="T:Antlr4.Runtime.IToken"/>
            or a
            <see cref="T:Antlr4.Runtime.RuleContext"/>
            object.</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.IParseTree.Accept``1(Antlr4.Runtime.Tree.IParseTreeVisitor{``0})">
            <summary>
            The
            <see cref="T:Antlr4.Runtime.Tree.IParseTreeVisitor`1"/>
            needs a double dispatch method.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.IParseTree.GetText">
            <summary>Return the combined text of all leaf nodes.</summary>
            <remarks>
            Return the combined text of all leaf nodes. Does not get any
            off-channel tokens (if any) so won't return whitespace and
            comments if they are sent to parser on hidden channel.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Tree.IParseTree.ToStringTree(Antlr4.Runtime.Parser)">
            <summary>
            Specialize toStringTree so that it can print out more information
            based upon the parser.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Tree.IParseTreeListener">
            <summary>
            This interface describes the minimal core of methods triggered
            by
            <see cref="T:Antlr4.Runtime.Tree.ParseTreeWalker"/>
            . E.g.,
            ParseTreeWalker walker = new ParseTreeWalker();
            walker.walk(myParseTreeListener, myParseTree); &lt;-- triggers events in your listener
            If you want to trigger events in multiple listeners during a single
            tree walk, you can use the ParseTreeDispatcher object available at
            https://github.com/antlr/antlr4/issues/841
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Tree.IParseTreeVisitor`1">
            <summary>This interface defines the basic notion of a parse tree visitor.</summary>
            <remarks>
            This interface defines the basic notion of a parse tree visitor. Generated
            visitors implement this interface and the
            <c>XVisitor</c>
            interface for
            grammar
            <c>X</c>
            .
            </remarks>
            <author>Sam Harwell</author>
        </member>
        <member name="M:Antlr4.Runtime.Tree.IParseTreeVisitor`1.Visit(Antlr4.Runtime.Tree.IParseTree)">
            <summary>Visit a parse tree, and return a user-defined result of the operation.</summary>
            <param name="tree">
            The
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            to visit.
            </param>
            <returns>The result of visiting the parse tree.</returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.IParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)">
            <summary>
            Visit the children of a node, and return a user-defined result
            of the operation.
            </summary>
            <param name="node">
            The
            <see cref="T:Antlr4.Runtime.Tree.IRuleNode"/>
            whose children should be visited.
            </param>
            <returns>The result of visiting the children of the node.</returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.IParseTreeVisitor`1.VisitTerminal(Antlr4.Runtime.Tree.ITerminalNode)">
            <summary>Visit a terminal node, and return a user-defined result of the operation.</summary>
            <param name="node">
            The
            <see cref="T:Antlr4.Runtime.Tree.ITerminalNode"/>
            to visit.
            </param>
            <returns>The result of visiting the node.</returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.IParseTreeVisitor`1.VisitErrorNode(Antlr4.Runtime.Tree.IErrorNode)">
            <summary>Visit an error node, and return a user-defined result of the operation.</summary>
            <param name="node">
            The
            <see cref="T:Antlr4.Runtime.Tree.IErrorNode"/>
            to visit.
            </param>
            <returns>The result of visiting the node.</returns>
        </member>
        <member name="T:Antlr4.Runtime.Tree.ISyntaxTree">
            <summary>
            A tree that knows about an interval in a token stream
            is some kind of syntax tree.
            </summary>
            <remarks>
            A tree that knows about an interval in a token stream
            is some kind of syntax tree. Subinterfaces distinguish
            between parse trees and other kinds of syntax trees we might want to create.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Tree.ISyntaxTree.SourceInterval">
            <summary>
            Return an
            <see cref="T:Antlr4.Runtime.Misc.Interval"/>
            indicating the index in the
            <see cref="T:Antlr4.Runtime.ITokenStream"/>
            of the first and last token associated with this
            subtree. If this node is a leaf, then the interval represents a single
            token and has interval i..i for token index i.
            <p>An interval of i..i-1 indicates an empty interval at position
            i in the input stream, where 0 &lt;= i &lt;= the size of the input
            token stream.  Currently, the code base can only have i=0..n-1 but
            in concept one could have an empty interval after EOF. </p>
            <p>If source interval is unknown, this returns
            <see cref="F:Antlr4.Runtime.Misc.Interval.Invalid"/>
            .</p>
            <p>As a weird special case, the source interval for rules matched after
            EOF is unspecified.</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Tree.ITree">
            <summary>The basic notion of a tree has a parent, a payload, and a list of children.</summary>
            <remarks>
            The basic notion of a tree has a parent, a payload, and a list of children.
            It is the most abstract interface for all the trees used by ANTLR.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Tree.ITree.Parent">
            <summary>The parent of this node.</summary>
            <remarks>
            The parent of this node. If the return value is null, then this
            node is the root of the tree.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Tree.ITree.Payload">
            <summary>This method returns whatever object represents the data at this note.</summary>
            <remarks>
            This method returns whatever object represents the data at this note. For
            example, for parse trees, the payload can be a
            <see cref="T:Antlr4.Runtime.IToken"/>
            representing
            a leaf node or a
            <see cref="T:Antlr4.Runtime.RuleContext"/>
            object representing a rule
            invocation. For abstract syntax trees (ASTs), this is a
            <see cref="T:Antlr4.Runtime.IToken"/>
            object.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Tree.ITree.GetChild(System.Int32)">
            <summary>
            If there are children, get the
            <paramref name="i"/>
            th value indexed from 0.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.ITree.ChildCount">
            <summary>
            How many children are there? If there is none, then this
            node represents a leaf node.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.ITree.ToStringTree">
            <summary>
            Print out a whole tree, not just a node, in LISP format
            <c>(root child1 .. childN)</c>
            . Print just a node if this is a leaf.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Tree.ParseTreeProperty`1">
            <summary>Associate a property with a parse tree node.</summary>
            <remarks>
            Associate a property with a parse tree node. Useful with parse tree listeners
            that need to associate values with particular tree nodes, kind of like
            specifying a return value for the listener event method that visited a
            particular node. Example:
            <pre>
            ParseTreeProperty&lt;Integer&gt; values = new ParseTreeProperty&lt;Integer&gt;();
            values.put(tree, 36);
            int x = values.get(tree);
            values.removeFrom(tree);
            </pre>
            You would make one decl (values here) in the listener and use lots of times
            in your event methods.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Tree.ParseTreeWalker.EnterRule(Antlr4.Runtime.Tree.IParseTreeListener,Antlr4.Runtime.Tree.IRuleNode)">
            <summary>
            The discovery of a rule node, involves sending two events: the generic
            <see cref="M:Antlr4.Runtime.Tree.IParseTreeListener.EnterEveryRule(Antlr4.Runtime.ParserRuleContext)"/>
            and a
            <see cref="T:Antlr4.Runtime.RuleContext"/>
            -specific event. First we trigger the generic and then
            the rule specific. We to them in reverse order upon finishing the node.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Tree.Pattern.Chunk">
            <summary>
            A chunk is either a token tag, a rule tag, or a span of literal text within a
            tree pattern.
            </summary>
            <remarks>
            A chunk is either a token tag, a rule tag, or a span of literal text within a
            tree pattern.
            <p>The method
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Split(System.String)"/>
            returns a list of
            chunks in preparation for creating a token stream by
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Tokenize(System.String)"/>
            . From there, we get a parse
            tree from with
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Compile(System.String,System.Int32)"/>
            . These
            chunks are converted to
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            ,
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TokenTagToken"/>
            , or the
            regular tokens of the text surrounding the tags.</p>
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch">
            <summary>
            Represents the result of matching a
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            against a tree pattern.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.tree">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.Tree"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.pattern">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.Pattern"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.labels">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.Labels"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.mismatchedNode">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.MismatchedNode"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.#ctor(Antlr4.Runtime.Tree.IParseTree,Antlr4.Runtime.Tree.Pattern.ParseTreePattern,Antlr4.Runtime.Misc.MultiMap{System.String,Antlr4.Runtime.Tree.IParseTree},Antlr4.Runtime.Tree.IParseTree)">
            <summary>
            Constructs a new instance of
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch"/>
            from the specified
            parse tree and pattern.
            </summary>
            <param name="tree">The parse tree to match against the pattern.</param>
            <param name="pattern">The parse tree pattern.</param>
            <param name="labels">
            A mapping from label names to collections of
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            objects located by the tree pattern matching process.
            </param>
            <param name="mismatchedNode">
            The first node which failed to match the tree
            pattern during the matching process.
            </param>
            <exception>
            IllegalArgumentException
            if
            <paramref name="tree"/>
            is
            <see langword="null"/>
            </exception>
            <exception>
            IllegalArgumentException
            if
            <paramref name="pattern"/>
            is
            <see langword="null"/>
            </exception>
            <exception>
            IllegalArgumentException
            if
            <paramref name="labels"/>
            is
            <see langword="null"/>
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.Get(System.String)">
            <summary>
            Get the last node associated with a specific
            <paramref name="label"/>
            .
            <p>For example, for pattern
            <c>&lt;id:ID&gt;</c>
            ,
            <c>get("id")</c>
            returns the
            node matched for that
            <c>ID</c>
            . If more than one node
            matched the specified label, only the last is returned. If there is
            no node associated with the label, this returns
            <see langword="null"/>
            .</p>
            <p>Pattern tags like
            <c>&lt;ID&gt;</c>
            and
            <c>&lt;expr&gt;</c>
            without labels are
            considered to be labeled with
            <c>ID</c>
            and
            <c>expr</c>
            , respectively.</p>
            </summary>
            <param name="label">The label to check.</param>
            <returns>
            The last
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            to match a tag with the specified
            label, or
            <see langword="null"/>
            if no parse tree matched a tag with the label.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.GetAll(System.String)">
            <summary>Return all nodes matching a rule or token tag with the specified label.</summary>
            <remarks>
            Return all nodes matching a rule or token tag with the specified label.
            <p>If the
            <paramref name="label"/>
            is the name of a parser rule or token in the
            grammar, the resulting list will contain both the parse trees matching
            rule or tags explicitly labeled with the label and the complete set of
            parse trees matching the labeled and unlabeled tags in the pattern for
            the parser rule or token. For example, if
            <paramref name="label"/>
            is
            <c>"foo"</c>
            ,
            the result will contain <em>all</em> of the following.</p>
            <ul>
            <li>Parse tree nodes matching tags of the form
            <c>&lt;foo:anyRuleName&gt;</c>
            and
            <c>&lt;foo:AnyTokenName&gt;</c>
            .</li>
            <li>Parse tree nodes matching tags of the form
            <c>&lt;anyLabel:foo&gt;</c>
            .</li>
            <li>Parse tree nodes matching tags of the form
            <c>&lt;foo&gt;</c>
            .</li>
            </ul>
            </remarks>
            <param name="label">The label.</param>
            <returns>
            A collection of all
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            nodes matching tags with
            the specified
            <paramref name="label"/>
            . If no nodes matched the label, an empty list
            is returned.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.Labels">
            <summary>Return a mapping from label &#x2192; [list of nodes].</summary>
            <remarks>
            Return a mapping from label &#x2192; [list of nodes].
            <p>The map includes special entries corresponding to the names of rules and
            tokens referenced in tags in the original pattern. For additional
            information, see the description of
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.GetAll(System.String)"/>
            .</p>
            </remarks>
            <returns>
            A mapping from labels to parse tree nodes. If the parse tree
            pattern did not contain any rule or token tags, this map will be empty.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.MismatchedNode">
            <summary>Get the node at which we first detected a mismatch.</summary>
            <returns>
            the node at which we first detected a mismatch, or
            <see langword="null"/>
            if the match was successful.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.Succeeded">
            <summary>Gets a value indicating whether the match operation succeeded.</summary>
            <returns>
            
            <see langword="true"/>
            if the match operation succeeded; otherwise,
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.Pattern">
            <summary>Get the tree pattern we are matching against.</summary>
            <returns>The tree pattern we are matching against.</returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.Tree">
            <summary>Get the parse tree we are trying to match to a pattern.</summary>
            <returns>
            The
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            we are trying to match to a pattern.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.ToString">
            <summary><inheritDoc/></summary>
        </member>
        <member name="T:Antlr4.Runtime.Tree.Pattern.ParseTreePattern">
            <summary>
            A pattern like
            <c>&lt;ID&gt; = &lt;expr&gt;;</c>
            converted to a
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            by
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Compile(System.String,System.Int32)"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.patternRuleIndex">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.PatternRuleIndex"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.pattern">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.Pattern"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.patternTree">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.PatternTree"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.matcher">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.Matcher"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.#ctor(Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher,System.String,System.Int32,Antlr4.Runtime.Tree.IParseTree)">
            <summary>
            Construct a new instance of the
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreePattern"/>
            class.
            </summary>
            <param name="matcher">
            The
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher"/>
            which created this
            tree pattern.
            </param>
            <param name="pattern">The tree pattern in concrete syntax form.</param>
            <param name="patternRuleIndex">
            The parser rule which serves as the root of the
            tree pattern.
            </param>
            <param name="patternTree">
            The tree pattern in
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            form.
            </param>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.Match(Antlr4.Runtime.Tree.IParseTree)">
            <summary>Match a specific parse tree against this tree pattern.</summary>
            <param name="tree">The parse tree to match against this tree pattern.</param>
            <returns>
            A
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch"/>
            object describing the result of the
            match operation. The
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.Succeeded"/>
            method can be
            used to determine whether or not the match was successful.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.Matches(Antlr4.Runtime.Tree.IParseTree)">
            <summary>Determine whether or not a parse tree matches this tree pattern.</summary>
            <param name="tree">The parse tree to match against this tree pattern.</param>
            <returns>
            
            <see langword="true"/>
            if
            <paramref name="tree"/>
            is a match for the current tree
            pattern; otherwise,
            <see langword="false"/>
            .
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.FindAll(Antlr4.Runtime.Tree.IParseTree,System.String)">
            <summary>
            Find all nodes using XPath and then try to match those subtrees against
            this tree pattern.
            </summary>
            <param name="tree">
            The
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            to match against this pattern.
            </param>
            <param name="xpath">An expression matching the nodes</param>
            <returns>
            A collection of
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch"/>
            objects describing the
            successful matches. Unsuccessful matches are omitted from the result,
            regardless of the reason for the failure.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.Matcher">
            <summary>
            Get the
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher"/>
            which created this tree pattern.
            </summary>
            <returns>
            The
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher"/>
            which created this tree
            pattern.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.Pattern">
            <summary>Get the tree pattern in concrete syntax form.</summary>
            <returns>The tree pattern in concrete syntax form.</returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.PatternRuleIndex">
            <summary>
            Get the parser rule which serves as the outermost rule for the tree
            pattern.
            </summary>
            <returns>
            The parser rule which serves as the outermost rule for the tree
            pattern.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.PatternTree">
            <summary>
            Get the tree pattern as a
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            . The rule and token tags from
            the pattern are present in the parse tree as terminal nodes with a symbol
            of type
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            or
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TokenTagToken"/>
            .
            </summary>
            <returns>
            The tree pattern as a
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            .
            </returns>
        </member>
        <member name="T:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher">
            <summary>
            A tree pattern matching mechanism for ANTLR
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            s.
            <p>Patterns are strings of source input text with special tags representing
            token or rule references such as:</p>
            <p>
            <c>&lt;ID&gt; = &lt;expr&gt;;</c>
            </p>
            <p>Given a pattern start rule such as
            <c>statement</c>
            , this object constructs
            a
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            with placeholders for the
            <c>ID</c>
            and
            <c>expr</c>
            subtree. Then the
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Match(Antlr4.Runtime.Tree.IParseTree,Antlr4.Runtime.Tree.Pattern.ParseTreePattern)"/>
            routines can compare an actual
            <see cref="T:Antlr4.Runtime.Tree.IParseTree"/>
            from a parse with this pattern. Tag
            <c>&lt;ID&gt;</c>
            matches
            any
            <c>ID</c>
            token and tag
            <c>&lt;expr&gt;</c>
            references the result of the
            <c>expr</c>
            rule (generally an instance of
            <c>ExprContext</c>
            .</p>
            <p>Pattern
            <c>x = 0;</c>
            is a similar pattern that matches the same pattern
            except that it requires the identifier to be
            <c>x</c>
            and the expression to
            be
            <c>0</c>
            .</p>
            <p>The
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Matches(Antlr4.Runtime.Tree.IParseTree,Antlr4.Runtime.Tree.Pattern.ParseTreePattern)"/>
            routines return
            <see langword="true"/>
            or
            <see langword="false"/>
            based
            upon a match for the tree rooted at the parameter sent in. The
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Match(Antlr4.Runtime.Tree.IParseTree,Antlr4.Runtime.Tree.Pattern.ParseTreePattern)"/>
            routines return a
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch"/>
            object that
            contains the parse tree, the parse tree pattern, and a map from tag name to
            matched nodes (more below). A subtree that fails to match, returns with
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.MismatchedNode"/>
            set to the first tree node that did not
            match.</p>
            <p>For efficiency, you can compile a tree pattern in string form to a
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreePattern"/>
            object.</p>
            <p>See
            <c>TestParseTreeMatcher</c>
            for lots of examples.
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreePattern"/>
            has two static helper methods:
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.FindAll(Antlr4.Runtime.Tree.IParseTree,System.String)"/>
            and
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreePattern.Match(Antlr4.Runtime.Tree.IParseTree)"/>
            that
            are easy to use but not super efficient because they create new
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher"/>
            objects each time and have to compile the
            pattern in string form before using it.</p>
            <p>The lexer and parser that you pass into the
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher"/>
            constructor are used to parse the pattern in string form. The lexer converts
            the
            <c>&lt;ID&gt; = &lt;expr&gt;;</c>
            into a sequence of four tokens (assuming lexer
            throws out whitespace or puts it on a hidden channel). Be aware that the
            input stream is reset for the lexer (but not the parser; a
            <see cref="T:Antlr4.Runtime.ParserInterpreter"/>
            is created to parse the input.). Any user-defined
            fields you have put into the lexer might get changed when this mechanism asks
            it to scan the pattern string.</p>
            <p>Normally a parser does not accept token
            <c>&lt;expr&gt;</c>
            as a valid
            <c>expr</c>
            but, from the parser passed in, we create a special version of
            the underlying grammar representation (an
            <see cref="T:Antlr4.Runtime.Atn.ATN"/>
            ) that allows imaginary
            tokens representing rules (
            <c>&lt;expr&gt;</c>
            ) to match entire rules. We call
            these <em>bypass alternatives</em>.</p>
            <p>Delimiters are
            <c>&lt;</c>
            and
            <c>&gt;</c>
            , with
            <c>\</c>
            as the escape string
            by default, but you can set them to whatever you want using
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.SetDelimiters(System.String,System.String,System.String)"/>
            . You must escape both start and stop strings
            <c>\&lt;</c>
            and
            <c>\&gt;</c>
            .</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.lexer">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Lexer"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.parser">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Parser"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.#ctor(Antlr4.Runtime.Lexer,Antlr4.Runtime.Parser)">
            <summary>
            Constructs a
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher"/>
            or from a
            <see cref="T:Antlr4.Runtime.Lexer"/>
            and
            <see cref="T:Antlr4.Runtime.Parser"/>
            object. The lexer input stream is altered for tokenizing
            the tree patterns. The parser is used as a convenient mechanism to get
            the grammar name, plus token, rule names.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.SetDelimiters(System.String,System.String,System.String)">
            <summary>
            Set the delimiters used for marking rule and token tags within concrete
            syntax used by the tree pattern parser.
            </summary>
            <param name="start">The start delimiter.</param>
            <param name="stop">The stop delimiter.</param>
            <param name="escapeLeft">The escape sequence to use for escaping a start or stop delimiter.</param>
            <exception>
            IllegalArgumentException
            if
            <paramref name="start"/>
            is
            <see langword="null"/>
            or empty.
            </exception>
            <exception>
            IllegalArgumentException
            if
            <paramref name="stop"/>
            is
            <see langword="null"/>
            or empty.
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Matches(Antlr4.Runtime.Tree.IParseTree,System.String,System.Int32)">
            <summary>
            Does
            <paramref name="pattern"/>
            matched as rule
            <paramref name="patternRuleIndex"/>
            match
            <paramref name="tree"/>
            ?
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Matches(Antlr4.Runtime.Tree.IParseTree,Antlr4.Runtime.Tree.Pattern.ParseTreePattern)">
            <summary>
            Does
            <paramref name="pattern"/>
            matched as rule patternRuleIndex match tree? Pass in a
            compiled pattern instead of a string representation of a tree pattern.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Match(Antlr4.Runtime.Tree.IParseTree,System.String,System.Int32)">
            <summary>
            Compare
            <paramref name="pattern"/>
            matched as rule
            <paramref name="patternRuleIndex"/>
            against
            <paramref name="tree"/>
            and return a
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch"/>
            object that contains the
            matched elements, or the node at which the match failed.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Match(Antlr4.Runtime.Tree.IParseTree,Antlr4.Runtime.Tree.Pattern.ParseTreePattern)">
            <summary>
            Compare
            <paramref name="pattern"/>
            matched against
            <paramref name="tree"/>
            and return a
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch"/>
            object that contains the matched elements, or the
            node at which the match failed. Pass in a compiled pattern instead of a
            string representation of a tree pattern.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Compile(System.String,System.Int32)">
            <summary>
            For repeated use of a tree pattern, compile it to a
            <see cref="T:Antlr4.Runtime.Tree.Pattern.ParseTreePattern"/>
            using this method.
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Lexer">
            <summary>Used to convert the tree pattern string into a series of tokens.</summary>
            <remarks>
            Used to convert the tree pattern string into a series of tokens. The
            input stream is reset.
            </remarks>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Parser">
            <summary>
            Used to collect to the grammar file name, token names, rule names for
            used to parse the pattern into a parse tree.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.MatchImpl(Antlr4.Runtime.Tree.IParseTree,Antlr4.Runtime.Tree.IParseTree,Antlr4.Runtime.Misc.MultiMap{System.String,Antlr4.Runtime.Tree.IParseTree})">
            <summary>
            Recursively walk
            <paramref name="tree"/>
            against
            <paramref name="patternTree"/>
            , filling
            <c>match.</c>
            <see cref="P:Antlr4.Runtime.Tree.Pattern.ParseTreeMatch.Labels"/>
            .
            </summary>
            <returns>
            the first node encountered in
            <paramref name="tree"/>
            which does not match
            a corresponding node in
            <paramref name="patternTree"/>
            , or
            <see langword="null"/>
            if the match
            was successful. The specific node returned depends on the matching
            algorithm used by the implementation, and may be overridden.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.GetRuleTagToken(Antlr4.Runtime.Tree.IParseTree)">
            <summary>
            Is
            <paramref name="t"/>
            
            <c>(expr &lt;expr&gt;)</c>
            subtree?
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Split(System.String)">
            <summary>
            Split
            <c>&lt;ID&gt; = &lt;e:expr&gt; ;</c>
            into 4 chunks for tokenizing by
            <see cref="M:Antlr4.Runtime.Tree.Pattern.ParseTreePatternMatcher.Tokenize(System.String)"/>
            .
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken">
            <summary>
            A
            <see cref="T:Antlr4.Runtime.IToken"/>
            object representing an entire subtree matched by a parser
            rule; e.g.,
            <c>&lt;expr&gt;</c>
            . These tokens are created for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TagChunk"/>
            chunks where the tag corresponds to a parser rule.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.RuleTagToken.ruleName">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.RuleName"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.RuleTagToken.bypassTokenType">
            <summary>The token type for the current token.</summary>
            <remarks>
            The token type for the current token. This is the token type assigned to
            the bypass alternative for the rule during ATN deserialization.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.RuleTagToken.label">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.Label"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.RuleTagToken.#ctor(System.String,System.Int32)">
            <summary>
            Constructs a new instance of
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            with the specified rule
            name and bypass token type and no label.
            </summary>
            <param name="ruleName">The name of the parser rule this rule tag matches.</param>
            <param name="bypassTokenType">The bypass token type assigned to the parser rule.</param>
            <exception>
            IllegalArgumentException
            if
            <paramref name="ruleName"/>
            is
            <see langword="null"/>
            or empty.
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.RuleTagToken.#ctor(System.String,System.Int32,System.String)">
            <summary>
            Constructs a new instance of
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            with the specified rule
            name, bypass token type, and label.
            </summary>
            <param name="ruleName">The name of the parser rule this rule tag matches.</param>
            <param name="bypassTokenType">The bypass token type assigned to the parser rule.</param>
            <param name="label">
            The label associated with the rule tag, or
            <see langword="null"/>
            if
            the rule tag is unlabeled.
            </param>
            <exception>
            IllegalArgumentException
            if
            <paramref name="ruleName"/>
            is
            <see langword="null"/>
            or empty.
            </exception>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.RuleName">
            <summary>Gets the name of the rule associated with this rule tag.</summary>
            <returns>The name of the parser rule associated with this rule tag.</returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.Label">
            <summary>Gets the label associated with the rule tag.</summary>
            <returns>
            The name of the label associated with the rule tag, or
            <see langword="null"/>
            if this is an unlabeled rule tag.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.Channel">
            <summary>
            <inheritDoc/>
            <p>Rule tag tokens are always placed on the
            <see cref="F:Antlr4.Runtime.TokenConstants.DefaultChannel"/>
            .</p>
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.Text">
            <summary>
            <inheritDoc/>
            <p>This method returns the rule tag formatted with
            <c>&lt;</c>
            and
            <c>&gt;</c>
            delimiters.</p>
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.Type">
            <summary>
            <inheritDoc/>
            <p>Rule tag tokens have types assigned according to the rule bypass
            transitions created during ATN deserialization.</p>
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.Line">
            <summary>
            <inheritDoc/>
            <p>The implementation for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            always returns 0.</p>
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.Column">
            <summary>
            <inheritDoc/>
            <p>The implementation for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            always returns -1.</p>
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.TokenIndex">
            <summary>
            <inheritDoc/>
            <p>The implementation for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            always returns -1.</p>
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.StartIndex">
            <summary>
            <inheritDoc/>
            <p>The implementation for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            always returns -1.</p>
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.StopIndex">
            <summary>
            <inheritDoc/>
            <p>The implementation for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            always returns -1.</p>
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.TokenSource">
            <summary>
            <inheritDoc/>
            <p>The implementation for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            always returns
            <see langword="null"/>
            .</p>
            </summary>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.RuleTagToken.InputStream">
            <summary>
            <inheritDoc/>
            <p>The implementation for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            always returns
            <see langword="null"/>
            .</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.RuleTagToken.ToString">
            <summary>
            <inheritDoc/>
            <p>The implementation for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.RuleTagToken"/>
            returns a string of the form
            <c>ruleName:bypassTokenType</c>
            .</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Tree.Pattern.TagChunk">
            <summary>Represents a placeholder tag in a tree pattern.</summary>
            <remarks>
            Represents a placeholder tag in a tree pattern. A tag can have any of the
            following forms.
            <ul>
            <li>
            <c>expr</c>
            : An unlabeled placeholder for a parser rule
            <c>expr</c>
            .</li>
            <li>
            <c>ID</c>
            : An unlabeled placeholder for a token of type
            <c>ID</c>
            .</li>
            <li>
            <c>e:expr</c>
            : A labeled placeholder for a parser rule
            <c>expr</c>
            .</li>
            <li>
            <c>id:ID</c>
            : A labeled placeholder for a token of type
            <c>ID</c>
            .</li>
            </ul>
            This class does not perform any validation on the tag or label names aside
            from ensuring that the tag is a non-null, non-empty string.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.TagChunk.tag">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.TagChunk.Tag"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.TagChunk.label">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.TagChunk.Label"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.TagChunk.#ctor(System.String)">
            <summary>
            Construct a new instance of
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TagChunk"/>
            using the specified tag and
            no label.
            </summary>
            <param name="tag">
            The tag, which should be the name of a parser rule or token
            type.
            </param>
            <exception>
            IllegalArgumentException
            if
            <paramref name="tag"/>
            is
            <see langword="null"/>
            or
            empty.
            </exception>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.TagChunk.#ctor(System.String,System.String)">
            <summary>
            Construct a new instance of
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TagChunk"/>
            using the specified label
            and tag.
            </summary>
            <param name="label">
            The label for the tag. If this is
            <see langword="null"/>
            , the
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TagChunk"/>
            represents an unlabeled tag.
            </param>
            <param name="tag">
            The tag, which should be the name of a parser rule or token
            type.
            </param>
            <exception>
            IllegalArgumentException
            if
            <paramref name="tag"/>
            is
            <see langword="null"/>
            or
            empty.
            </exception>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.TagChunk.Tag">
            <summary>Get the tag for this chunk.</summary>
            <returns>The tag for the chunk.</returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.TagChunk.Label">
            <summary>Get the label, if any, assigned to this chunk.</summary>
            <returns>
            The label assigned to this chunk, or
            <see langword="null"/>
            if no label is
            assigned to the chunk.
            </returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.TagChunk.ToString">
            <summary>This method returns a text representation of the tag chunk.</summary>
            <remarks>
            This method returns a text representation of the tag chunk. Labeled tags
            are returned in the form
            <c>label:tag</c>
            , and unlabeled tags are
            returned as just the tag name.
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.Tree.Pattern.TextChunk">
            <summary>
            Represents a span of raw text (concrete syntax) between tags in a tree
            pattern string.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.TextChunk.text">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.TextChunk.Text"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.TextChunk.#ctor(System.String)">
            <summary>
            Constructs a new instance of
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TextChunk"/>
            with the specified text.
            </summary>
            <param name="text">The text of this chunk.</param>
            <exception>
            IllegalArgumentException
            if
            <paramref name="text"/>
            is
            <see langword="null"/>
            .
            </exception>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.TextChunk.Text">
            <summary>Gets the raw text of this chunk.</summary>
            <returns>The text of the chunk.</returns>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.TextChunk.ToString">
            <summary>
            <inheritDoc/>
            <p>The implementation for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TextChunk"/>
            returns the result of
            <see cref="P:Antlr4.Runtime.Tree.Pattern.TextChunk.Text"/>
            in single quotes.</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Tree.Pattern.TokenTagToken">
            <summary>
            A
            <see cref="T:Antlr4.Runtime.IToken"/>
            object representing a token of a particular type; e.g.,
            <c>&lt;ID&gt;</c>
            . These tokens are created for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TagChunk"/>
            chunks where the
            tag corresponds to a lexer rule or token type.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.TokenTagToken.tokenName">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.TokenTagToken.TokenName"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.Tree.Pattern.TokenTagToken.label">
            <summary>
            This is the backing field for
            <see cref="P:Antlr4.Runtime.Tree.Pattern.TokenTagToken.Label"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.TokenTagToken.#ctor(System.String,System.Int32)">
            <summary>
            Constructs a new instance of
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TokenTagToken"/>
            for an unlabeled tag
            with the specified token name and type.
            </summary>
            <param name="tokenName">The token name.</param>
            <param name="type">The token type.</param>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.TokenTagToken.#ctor(System.String,System.Int32,System.String)">
            <summary>
            Constructs a new instance of
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TokenTagToken"/>
            with the specified
            token name, type, and label.
            </summary>
            <param name="tokenName">The token name.</param>
            <param name="type">The token type.</param>
            <param name="label">
            The label associated with the token tag, or
            <see langword="null"/>
            if
            the token tag is unlabeled.
            </param>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.TokenTagToken.TokenName">
            <summary>Gets the token name.</summary>
            <returns>The token name.</returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.TokenTagToken.Label">
            <summary>Gets the label associated with the rule tag.</summary>
            <returns>
            The name of the label associated with the rule tag, or
            <see langword="null"/>
            if this is an unlabeled rule tag.
            </returns>
        </member>
        <member name="P:Antlr4.Runtime.Tree.Pattern.TokenTagToken.Text">
            <summary>
            <inheritDoc/>
            <p>The implementation for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TokenTagToken"/>
            returns the token tag
            formatted with
            <c>&lt;</c>
            and
            <c>&gt;</c>
            delimiters.</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Pattern.TokenTagToken.ToString">
            <summary>
            <inheritDoc/>
            <p>The implementation for
            <see cref="T:Antlr4.Runtime.Tree.Pattern.TokenTagToken"/>
            returns a string of the form
            <c>tokenName:type</c>
            .</p>
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Tree.Trees">
            <summary>A set of utility routines useful for all kinds of ANTLR trees.</summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Trees.ToStringTree(Antlr4.Runtime.Tree.ITree)">
            <summary>Print out a whole tree in LISP form.</summary>
            <remarks>
            Print out a whole tree in LISP form.
            <see cref="M:Antlr4.Runtime.Tree.Trees.GetNodeText(Antlr4.Runtime.Tree.ITree,Antlr4.Runtime.Parser)"/>
            is used on the
            node payloads to get the text for the nodes.  Detect
            parse trees and extract data appropriately.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Trees.ToStringTree(Antlr4.Runtime.Tree.ITree,Antlr4.Runtime.Parser)">
            <summary>Print out a whole tree in LISP form.</summary>
            <remarks>
            Print out a whole tree in LISP form.
            <see cref="M:Antlr4.Runtime.Tree.Trees.GetNodeText(Antlr4.Runtime.Tree.ITree,Antlr4.Runtime.Parser)"/>
            is used on the
            node payloads to get the text for the nodes.  Detect
            parse trees and extract data appropriately.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Trees.ToStringTree(Antlr4.Runtime.Tree.ITree,System.Collections.Generic.IList{System.String})">
            <summary>Print out a whole tree in LISP form.</summary>
            <remarks>
            Print out a whole tree in LISP form.
            <see cref="M:Antlr4.Runtime.Tree.Trees.GetNodeText(Antlr4.Runtime.Tree.ITree,Antlr4.Runtime.Parser)"/>
            is used on the
            node payloads to get the text for the nodes.
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Trees.GetChildren(Antlr4.Runtime.Tree.ITree)">
            <summary>Return ordered list of all children of this node</summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Trees.GetAncestors(Antlr4.Runtime.Tree.ITree)">
            <summary>Return a list of all ancestors of this node.</summary>
            <remarks>
            Return a list of all ancestors of this node.  The first node of
            list is the root and the last is the parent of this node.
            </remarks>
            <since>4.5.1</since>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Trees.IsAncestorOf(Antlr4.Runtime.Tree.ITree,Antlr4.Runtime.Tree.ITree)">
            <summary>Return true if t is u's parent or a node on path to root from u.</summary>
            <remarks>
            Return true if t is u's parent or a node on path to root from u.
            Use == not equals().
            </remarks>
            <since>4.5.1</since>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Trees.GetDescendants(Antlr4.Runtime.Tree.IParseTree)">
            <summary>Get all descendents; includes t itself.</summary>
            <since>4.5.1</since>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Trees.GetRootOfSubtreeEnclosingRegion(Antlr4.Runtime.Tree.IParseTree,System.Int32,System.Int32)">
            <summary>
            Find smallest subtree of t enclosing range startTokenIndex..stopTokenIndex
            inclusively using postorder traversal.
            </summary>
            <remarks>
            Find smallest subtree of t enclosing range startTokenIndex..stopTokenIndex
            inclusively using postorder traversal.  Recursive depth-first-search.
            </remarks>
            <since>4.5</since>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Trees.StripChildrenOutOfRange(Antlr4.Runtime.ParserRuleContext,Antlr4.Runtime.ParserRuleContext,System.Int32,System.Int32)">
            <summary>
            Replace any subtree siblings of root that are completely to left
            or right of lookahead range with a CommonToken(Token.INVALID_TYPE,"...")
            node.
            </summary>
            <remarks>
            Replace any subtree siblings of root that are completely to left
            or right of lookahead range with a CommonToken(Token.INVALID_TYPE,"...")
            node. The source interval for t is not altered to suit smaller range!
            WARNING: destructive to t.
            </remarks>
            <since>4.5.1</since>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Trees.FindNodeSuchThat(Antlr4.Runtime.Tree.ITree,System.Predicate{Antlr4.Runtime.Tree.ITree})">
            <summary>Return first node satisfying the pred</summary>
            <since>4.5.1</since>
        </member>
        <member name="T:Antlr4.Runtime.Tree.Xpath.XPath">
            <summary>
            Represent a subset of XPath XML path syntax for use in identifying nodes in
            parse trees.
            </summary>
            <remarks>
            Represent a subset of XPath XML path syntax for use in identifying nodes in
            parse trees.
            <p>
            Split path into words and separators
            <c>/</c>
            and
            <c>//</c>
            via ANTLR
            itself then walk path elements from left to right. At each separator-word
            pair, find set of nodes. Next stage uses those as work list.</p>
            <p>
            The basic interface is
            <see cref="M:Antlr4.Runtime.Tree.Xpath.XPath.FindAll(Antlr4.Runtime.Tree.IParseTree,System.String,Antlr4.Runtime.Parser)">ParseTree.findAll</see>
            <c>(tree, pathString, parser)</c>
            .
            But that is just shorthand for:</p>
            <pre>
            <see cref="T:Antlr4.Runtime.Tree.Xpath.XPath"/>
            p = new
            <see cref="M:Antlr4.Runtime.Tree.Xpath.XPath.#ctor(Antlr4.Runtime.Parser,System.String)">XPath</see>
            (parser, pathString);
            return p.
            <see cref="M:Antlr4.Runtime.Tree.Xpath.XPath.Evaluate(Antlr4.Runtime.Tree.IParseTree)">evaluate</see>
            (tree);
            </pre>
            <p>
            See
            <c>org.antlr.v4.test.TestXPath</c>
            for descriptions. In short, this
            allows operators:</p>
            <dl>
            <dt>/</dt> <dd>root</dd>
            <dt>//</dt> <dd>anywhere</dd>
            <dt>!</dt> <dd>invert; this must appear directly after root or anywhere
            operator</dd>
            </dl>
            <p>
            and path elements:</p>
            <dl>
            <dt>ID</dt> <dd>token name</dd>
            <dt>'string'</dt> <dd>any string literal token from the grammar</dd>
            <dt>expr</dt> <dd>rule name</dd>
            <dt>*</dt> <dd>wildcard matching any node</dd>
            </dl>
            <p>
            Whitespace is not allowed.</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Xpath.XPath.GetXPathElement(Antlr4.Runtime.IToken,System.Boolean)">
            <summary>
            Convert word like
            <c>*</c>
            or
            <c>ID</c>
            or
            <c>expr</c>
            to a path
            element.
            <paramref name="anywhere"/>
            is
            <see langword="true"/>
            if
            <c>//</c>
            precedes the
            word.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Xpath.XPath.Evaluate(Antlr4.Runtime.Tree.IParseTree)">
            <summary>
            Return a list of all nodes starting at
            <paramref name="t"/>
            as root that satisfy the
            path. The root
            <c>/</c>
            is relative to the node passed to
            <see cref="M:Antlr4.Runtime.Tree.Xpath.XPath.Evaluate(Antlr4.Runtime.Tree.IParseTree)"/>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Xpath.XPathElement.#ctor(System.String)">
            <summary>
            Construct element like
            <c>/ID</c>
            or
            <c>ID</c>
            or
            <c>/*</c>
            etc...
            op is null if just node
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Tree.Xpath.XPathElement.Evaluate(Antlr4.Runtime.Tree.IParseTree)">
            <summary>
            Given tree rooted at
            <paramref name="t"/>
            return all nodes matched by this path
            element.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.Tree.Xpath.XPathRuleAnywhereElement">
            <summary>
            Either
            <c>ID</c>
            at start of path or
            <c>...//ID</c>
            in middle of path.
            </summary>
        </member>
        <member name="T:Antlr4.Runtime.UnbufferedCharStream">
            <summary>Do not buffer up the entire char stream.</summary>
            <remarks>
            Do not buffer up the entire char stream. It does keep a small buffer
            for efficiency and also buffers while a mark exists (set by the
            lookahead prediction in parser). "Unbuffered" here refers to fact
            that it doesn't buffer all data, not that's it's on demand loading of char.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedCharStream.data">
            <summary>A moving window buffer of the data being scanned.</summary>
            <remarks>
            A moving window buffer of the data being scanned. While there's a marker,
            we keep adding to buffer. Otherwise,
            <see cref="M:Antlr4.Runtime.UnbufferedCharStream.Consume">consume()</see>
            resets so
            we start filling at index 0 again.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedCharStream.n">
            <summary>
            The number of characters currently in
            <see cref="F:Antlr4.Runtime.UnbufferedCharStream.data">data</see>
            .
            <p>This is not the buffer capacity, that's
            <c>data.length</c>
            .</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedCharStream.p">
            <summary>
            0..n-1 index into
            <see cref="F:Antlr4.Runtime.UnbufferedCharStream.data">data</see>
            of next character.
            <p>The
            <c>LA(1)</c>
            character is
            <c>data[p]</c>
            . If
            <c>p == n</c>
            , we are
            out of buffered characters.</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedCharStream.numMarkers">
            <summary>
            Count up with
            <see cref="M:Antlr4.Runtime.UnbufferedCharStream.Mark">mark()</see>
            and down with
            <see cref="M:Antlr4.Runtime.UnbufferedCharStream.Release(System.Int32)">release()</see>
            . When we
            <c>release()</c>
            the last mark,
            <c>numMarkers</c>
            reaches 0 and we reset the buffer. Copy
            <c>data[p]..data[n-1]</c>
            to
            <c>data[0]..data[(n-1)-p]</c>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedCharStream.lastChar">
            <summary>
            This is the
            <c>LA(-1)</c>
            character for the current position.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedCharStream.lastCharBufferStart">
            <summary>
            When
            <c>numMarkers &gt; 0</c>
            , this is the
            <c>LA(-1)</c>
            character for the
            first character in
            <see cref="F:Antlr4.Runtime.UnbufferedCharStream.data">data</see>
            . Otherwise, this is unspecified.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedCharStream.currentCharIndex">
            <summary>Absolute character index.</summary>
            <remarks>
            Absolute character index. It's the index of the character about to be
            read via
            <c>LA(1)</c>
            . Goes from 0 to the number of characters in the
            entire stream, although the stream size is unknown before the end is
            reached.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedCharStream.name">
            <summary>The name or source of this char stream.</summary>
        </member>
        <member name="M:Antlr4.Runtime.UnbufferedCharStream.#ctor">
            <summary>Useful for subclasses that pull char from other than this.input.</summary>
        </member>
        <member name="M:Antlr4.Runtime.UnbufferedCharStream.#ctor(System.Int32)">
            <summary>Useful for subclasses that pull char from other than this.input.</summary>
        </member>
        <member name="M:Antlr4.Runtime.UnbufferedCharStream.Sync(System.Int32)">
            <summary>
            Make sure we have 'need' elements from current position
            <see cref="F:Antlr4.Runtime.UnbufferedCharStream.p">p</see>
            .
            Last valid
            <c>p</c>
            index is
            <c>data.length-1</c>
            .
            <c>p+need-1</c>
            is
            the char index 'need' elements ahead. If we need 1 element,
            <c>(p+1-1)==p</c>
            must be less than
            <c>data.length</c>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.UnbufferedCharStream.Fill(System.Int32)">
            <summary>
            Add
            <paramref name="n"/>
            characters to the buffer. Returns the number of characters
            actually added to the buffer. If the return value is less than
            <paramref name="n"/>
            ,
            then EOF was reached before
            <paramref name="n"/>
            characters could be added.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.UnbufferedCharStream.NextChar">
            <summary>
            Override to provide different source of characters than
            <see cref="F:Antlr4.Runtime.UnbufferedCharStream.input">input</see>
            .
            </summary>
            <exception cref="T:System.IO.IOException"/>
        </member>
        <member name="M:Antlr4.Runtime.UnbufferedCharStream.Mark">
            <summary>Return a marker that we can release later.</summary>
            <remarks>
            Return a marker that we can release later.
            <p>The specific marker value used for this class allows for some level of
            protection against misuse where
            <c>seek()</c>
            is called on a mark or
            <c>release()</c>
            is called in the wrong order.</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.UnbufferedCharStream.Release(System.Int32)">
            <summary>Decrement number of markers, resetting buffer if we hit 0.</summary>
            <param name="marker"/>
        </member>
        <member name="M:Antlr4.Runtime.UnbufferedCharStream.Seek(System.Int32)">
            <summary>
            Seek to absolute character index, which might not be in the current
            sliding window.
            </summary>
            <remarks>
            Seek to absolute character index, which might not be in the current
            sliding window.  Move
            <c>p</c>
            to
            <c>index-bufferStartIndex</c>
            .
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedTokenStream.tokens">
            <summary>A moving window buffer of the data being scanned.</summary>
            <remarks>
            A moving window buffer of the data being scanned. While there's a marker,
            we keep adding to buffer. Otherwise,
            <see cref="M:Antlr4.Runtime.UnbufferedTokenStream.Consume">consume()</see>
            resets so
            we start filling at index 0 again.
            </remarks>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedTokenStream.n">
            <summary>
            The number of tokens currently in
            <see cref="F:Antlr4.Runtime.UnbufferedTokenStream.tokens">tokens</see>
            .
            <p>This is not the buffer capacity, that's
            <c>tokens.length</c>
            .</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedTokenStream.p">
            <summary>
            0..n-1 index into
            <see cref="F:Antlr4.Runtime.UnbufferedTokenStream.tokens">tokens</see>
            of next token.
            <p>The
            <c>LT(1)</c>
            token is
            <c>tokens[p]</c>
            . If
            <c>p == n</c>
            , we are
            out of buffered tokens.</p>
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedTokenStream.numMarkers">
            <summary>
            Count up with
            <see cref="M:Antlr4.Runtime.UnbufferedTokenStream.Mark">mark()</see>
            and down with
            <see cref="M:Antlr4.Runtime.UnbufferedTokenStream.Release(System.Int32)">release()</see>
            . When we
            <c>release()</c>
            the last mark,
            <c>numMarkers</c>
            reaches 0 and we reset the buffer. Copy
            <c>tokens[p]..tokens[n-1]</c>
            to
            <c>tokens[0]..tokens[(n-1)-p]</c>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedTokenStream.lastToken">
            <summary>
            This is the
            <c>LT(-1)</c>
            token for the current position.
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedTokenStream.lastTokenBufferStart">
            <summary>
            When
            <c>numMarkers &gt; 0</c>
            , this is the
            <c>LT(-1)</c>
            token for the
            first token in
            <see cref="F:Antlr4.Runtime.UnbufferedTokenStream.tokens"/>
            . Otherwise, this is
            <see langword="null"/>
            .
            </summary>
        </member>
        <member name="F:Antlr4.Runtime.UnbufferedTokenStream.currentTokenIndex">
            <summary>Absolute token index.</summary>
            <remarks>
            Absolute token index. It's the index of the token about to be read via
            <c>LT(1)</c>
            . Goes from 0 to the number of tokens in the entire stream,
            although the stream size is unknown before the end is reached.
            <p>This value is used to set the token indexes if the stream provides tokens
            that implement
            <see cref="T:Antlr4.Runtime.IWritableToken"/>
            .</p>
            </remarks>
        </member>
        <member name="M:Antlr4.Runtime.UnbufferedTokenStream.Sync(System.Int32)">
            <summary>
            Make sure we have 'need' elements from current position
            <see cref="F:Antlr4.Runtime.UnbufferedTokenStream.p">p</see>
            . Last valid
            <c>p</c>
            index is
            <c>tokens.length-1</c>
            .
            <c>p+need-1</c>
            is the tokens index 'need' elements
            ahead.  If we need 1 element,
            <c>(p+1-1)==p</c>
            must be less than
            <c>tokens.length</c>
            .
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.UnbufferedTokenStream.Fill(System.Int32)">
            <summary>
            Add
            <paramref name="n"/>
            elements to the buffer. Returns the number of tokens
            actually added to the buffer. If the return value is less than
            <paramref name="n"/>
            ,
            then EOF was reached before
            <paramref name="n"/>
            tokens could be added.
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.UnbufferedTokenStream.Mark">
            <summary>Return a marker that we can release later.</summary>
            <remarks>
            Return a marker that we can release later.
            <p>The specific marker value used for this class allows for some level of
            protection against misuse where
            <c>seek()</c>
            is called on a mark or
            <c>release()</c>
            is called in the wrong order.</p>
            </remarks>
        </member>
        <member name="T:Antlr4.Runtime.Vocabulary">
            <summary>
            This class provides a default implementation of the
            <see cref="T:Antlr4.Runtime.IVocabulary"/>
            interface.
            </summary>
            <author>Sam Harwell</author>
        </member>
        <member name="F:Antlr4.Runtime.Vocabulary.EmptyVocabulary">
            <summary>
            Gets an empty
            <see cref="T:Antlr4.Runtime.IVocabulary"/>
            instance.
            <p>
            No literal or symbol names are assigned to token types, so
            <see cref="M:Antlr4.Runtime.Vocabulary.GetDisplayName(System.Int32)"/>
            returns the numeric value for all tokens
            except
            <see cref="F:Antlr4.Runtime.TokenConstants.Eof"/>
            .</p>
            </summary>
        </member>
        <member name="M:Antlr4.Runtime.Vocabulary.#ctor(System.String[],System.String[])">
            <summary>
            Constructs a new instance of
            <see cref="T:Antlr4.Runtime.Vocabulary"/>
            from the specified
            literal and symbolic token names.
            </summary>
            <param name="literalNames">
            The literal names assigned to tokens, or
            <see langword="null"/>
            if no literal names are assigned.
            </param>
            <param name="symbolicNames">
            The symbolic names assigned to tokens, or
            <see langword="null"/>
            if no symbolic names are assigned.
            </param>
            <seealso cref="M:Antlr4.Runtime.Vocabulary.GetLiteralName(System.Int32)"/>
            <seealso cref="M:Antlr4.Runtime.Vocabulary.GetSymbolicName(System.Int32)"/>
        </member>
        <member name="M:Antlr4.Runtime.Vocabulary.#ctor(System.String[],System.String[],System.String[])">
            <summary>
            Constructs a new instance of
            <see cref="T:Antlr4.Runtime.Vocabulary"/>
            from the specified
            literal, symbolic, and display token names.
            </summary>
            <param name="literalNames">
            The literal names assigned to tokens, or
            <see langword="null"/>
            if no literal names are assigned.
            </param>
            <param name="symbolicNames">
            The symbolic names assigned to tokens, or
            <see langword="null"/>
            if no symbolic names are assigned.
            </param>
            <param name="displayNames">
            The display names assigned to tokens, or
            <see langword="null"/>
            to use the values in
            <paramref name="literalNames"/>
            and
            <paramref name="symbolicNames"/>
            as
            the source of display names, as described in
            <see cref="M:Antlr4.Runtime.Vocabulary.GetDisplayName(System.Int32)"/>
            .
            </param>
            <seealso cref="M:Antlr4.Runtime.Vocabulary.GetLiteralName(System.Int32)"/>
            <seealso cref="M:Antlr4.Runtime.Vocabulary.GetSymbolicName(System.Int32)"/>
            <seealso cref="M:Antlr4.Runtime.Vocabulary.GetDisplayName(System.Int32)"/>
        </member>
        <member name="M:Antlr4.Runtime.Vocabulary.FromTokenNames(System.String[])">
            <summary>
            Returns a
            <see cref="T:Antlr4.Runtime.Vocabulary"/>
            instance from the specified set of token
            names. This method acts as a compatibility layer for the single
            <paramref name="tokenNames"/>
            array generated by previous releases of ANTLR.
            <p>The resulting vocabulary instance returns
            <see langword="null"/>
            for
            <see cref="M:Antlr4.Runtime.Vocabulary.GetLiteralName(System.Int32)"/>
            and
            <see cref="M:Antlr4.Runtime.Vocabulary.GetSymbolicName(System.Int32)"/>
            , and the
            value from
            <paramref name="tokenNames"/>
            for the display names.</p>
            </summary>
            <param name="tokenNames">
            The token names, or
            <see langword="null"/>
            if no token names are
            available.
            </param>
            <returns>
            A
            <see cref="T:Antlr4.Runtime.IVocabulary"/>
            instance which uses
            <paramref name="tokenNames"/>
            for
            the display names of tokens.
            </returns>
        </member>
    </members>
</doc>
