forgetest1
/
antlr
forked from jasder/antlr
1
0
Fork 0
Code Issues Pull Requests 1 Releases Wiki Activity

Merge branch 'sharpen'

This commit is contained in:
Sam Harwell 2014-07-31 16:45:03 -05:00
parent 30b8b1452d c78833e705
commit 20b89b15e8
75 changed files with 810 additions and 810 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
reference/sharpen

@ -1 +1 @@
Subproject commit a0560d197e8a96bfea52f9bf663cf8bc58127047 Subproject commit ee445cbaf89cd22aa1b39d686a8b68ec1b55f4d6

4
runtime/CSharp/Antlr4.Runtime/AntlrInputStream.cs
View File

@ -42,11 +42,11 @@ namespace Antlr4.Runtime
/// <see cref="System.IO.Stream"/> /// <see cref="System.IO.Stream"/>
/// and then treat it /// and then treat it
/// like a /// like a
/// <code>char[]</code> /// <c>char[]</c>
/// buffer. Can also pass in a /// buffer. Can also pass in a
/// <see cref="string"/> /// <see cref="string"/>
/// or /// or
/// <code>char[]</code> /// <c>char[]</c>
/// to use. /// to use.
/// <p>If you need encoding, pass in stream/reader with correct encoding.</p> /// <p>If you need encoding, pass in stream/reader with correct encoding.</p>
/// </summary> /// </summary>

22
runtime/CSharp/Antlr4.Runtime/Atn/ATN.cs
View File

@ -83,7 +83,7 @@ namespace Antlr4.Runtime.Atn
/// type if the /// type if the
/// <see cref="ATNDeserializationOptions.GenerateRuleBypassTransitions()"/> /// <see cref="ATNDeserializationOptions.GenerateRuleBypassTransitions()"/>
/// deserialization option was specified; otherwise, this is /// deserialization option was specified; otherwise, this is
/// <code>null</code> /// <see langword="null"/>
/// . /// .
/// </remarks> /// </remarks>
public int[] ruleToTokenType; public int[] ruleToTokenType;
@ -156,18 +156,18 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Compute the set of valid tokens that can occur starting in state /// Compute the set of valid tokens that can occur starting in state
/// <code>s</code> /// <paramref name="s"/>
/// . /// .
/// If /// If
/// <code>ctx</code> /// <paramref name="ctx"/>
/// is /// is
/// <see cref="PredictionContext.EmptyLocal"/> /// <see cref="PredictionContext.EmptyLocal"/>
/// , the set of tokens will not include what can follow /// , the set of tokens will not include what can follow
/// the rule surrounding /// the rule surrounding
/// <code>s</code> /// <paramref name="s"/>
/// . In other words, the set will be /// . In other words, the set will be
/// restricted to tokens reachable staying within /// restricted to tokens reachable staying within
/// <code>s</code> /// <paramref name="s"/>
/// 's rule. /// 's rule.
/// </summary> /// </summary>
[return: NotNull] [return: NotNull]
@ -181,7 +181,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Compute the set of valid tokens that can occur starting in /// Compute the set of valid tokens that can occur starting in
/// <code>s</code> /// <paramref name="s"/>
/// and /// and
/// staying in same rule. /// staying in same rule.
/// <see cref="TokenConstants.Epsilon"/> /// <see cref="TokenConstants.Epsilon"/>
@ -253,9 +253,9 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Computes the set of input symbols which could follow ATN state number /// Computes the set of input symbols which could follow ATN state number
/// <code>stateNumber</code> /// <paramref name="stateNumber"/>
/// in the specified full /// in the specified full
/// <code>context</code> /// <paramref name="context"/>
/// . This method /// . This method
/// considers the complete parser context, but does not evaluate semantic /// considers the complete parser context, but does not evaluate semantic
/// predicates (i.e. all predicates encountered during the calculation are /// predicates (i.e. all predicates encountered during the calculation are
@ -266,9 +266,9 @@ namespace Antlr4.Runtime.Atn
/// <see cref="TokenConstants.Eof"/> /// <see cref="TokenConstants.Eof"/>
/// is added to the returned set. /// is added to the returned set.
/// <p>If /// <p>If
/// <code>context</code> /// <paramref name="context"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// , it is treated as /// , it is treated as
/// <see cref="ParserRuleContext.EmptyContext"/> /// <see cref="ParserRuleContext.EmptyContext"/>
/// .</p> /// .</p>
@ -282,7 +282,7 @@ namespace Antlr4.Runtime.Atn
/// <exception cref="System.ArgumentException"> /// <exception cref="System.ArgumentException">
/// if the ATN does not contain a state with /// if the ATN does not contain a state with
/// number /// number
/// <code>stateNumber</code> /// <paramref name="stateNumber"/>
/// </exception> /// </exception>
[return: NotNull] [return: NotNull]
public virtual IntervalSet GetExpectedTokens(int stateNumber, RuleContext context) public virtual IntervalSet GetExpectedTokens(int stateNumber, RuleContext context)

10
runtime/CSharp/Antlr4.Runtime/Atn/ATNConfigSet.cs
View File

@ -49,7 +49,7 @@ namespace Antlr4.Runtime.Atn
/// the /// the
/// <see cref="ATNConfig.SemanticContext()"/> /// <see cref="ATNConfig.SemanticContext()"/>
/// of the value, which is only a problem if a single /// of the value, which is only a problem if a single
/// <code>ATNConfigSet</code> /// <c>ATNConfigSet</c>
/// contains two configs with the same state and alternative /// contains two configs with the same state and alternative
/// but different semantic contexts. When this case arises, the first config /// but different semantic contexts. When this case arises, the first config
/// added to this map stays, and the remaining configs are placed in /// added to this map stays, and the remaining configs are placed in
@ -58,7 +58,7 @@ namespace Antlr4.Runtime.Atn
/// <p/> /// <p/>
/// This map is only used for optimizing the process of adding configs to the set, /// This map is only used for optimizing the process of adding configs to the set,
/// and is /// and is
/// <code>null</code> /// <see langword="null"/>
/// for read-only sets stored in the DFA. /// for read-only sets stored in the DFA.
/// </summary> /// </summary>
private readonly Dictionary<long, ATNConfig> mergedConfigs; private readonly Dictionary<long, ATNConfig> mergedConfigs;
@ -73,7 +73,7 @@ namespace Antlr4.Runtime.Atn
/// <p/> /// <p/>
/// This list is only used for optimizing the process of adding configs to the set, /// This list is only used for optimizing the process of adding configs to the set,
/// and is /// and is
/// <code>null</code> /// <see langword="null"/>
/// for read-only sets stored in the DFA. /// for read-only sets stored in the DFA.
/// </summary> /// </summary>
private readonly List<ATNConfig> unmerged; private readonly List<ATNConfig> unmerged;
@ -92,7 +92,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// When /// When
/// <code>true</code> /// <see langword="true"/>
/// , this config set represents configurations where the entire /// , this config set represents configurations where the entire
/// outer context has been consumed by the ATN interpreter. This prevents the /// outer context has been consumed by the ATN interpreter. This prevents the
/// <see cref="ParserATNSimulator.Closure(ATNConfigSet, ATNConfigSet, bool, bool, PredictionContextCache, bool)"/> /// <see cref="ParserATNSimulator.Closure(ATNConfigSet, ATNConfigSet, bool, bool, PredictionContextCache, bool)"/>
@ -100,7 +100,7 @@ namespace Antlr4.Runtime.Atn
/// rule stop state is reached with an empty prediction context. /// rule stop state is reached with an empty prediction context.
/// <p/> /// <p/>
/// Note: /// Note:
/// <code>outermostConfigSet</code> /// <c>outermostConfigSet</c>
/// and /// and
/// <see cref="dipsIntoOuterContext"/> /// <see cref="dipsIntoOuterContext"/>
/// should never /// should never

8
runtime/CSharp/Antlr4.Runtime/Atn/ATNDeserializer.cs
View File

@ -118,15 +118,15 @@ namespace Antlr4.Runtime.Atn
/// </param> /// </param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if the /// if the
/// <code>actualUuid</code> /// <paramref name="actualUuid"/>
/// value represents a /// value represents a
/// serialized ATN at or after the feature identified by /// serialized ATN at or after the feature identified by
/// <code>feature</code> /// <paramref name="feature"/>
/// was /// was
/// introduced; otherwise, /// introduced; otherwise,
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
protected internal virtual bool IsFeatureSupported(Guid feature, Guid actualUuid) protected internal virtual bool IsFeatureSupported(Guid feature, Guid actualUuid)

16
runtime/CSharp/Antlr4.Runtime/Atn/ATNState.cs
View File

@ -53,10 +53,10 @@ namespace Antlr4.Runtime.Atn
/// states or the inclusion of a block representing a nested /// states or the inclusion of a block representing a nested
/// construct in one of the forms below.</li> /// construct in one of the forms below.</li>
/// <li>Nodes showing multiple outgoing alternatives with a /// <li>Nodes showing multiple outgoing alternatives with a
/// <code>...</code> /// <c>...</c>
/// support /// support
/// any number of alternatives (one or more). Nodes without the /// any number of alternatives (one or more). Nodes without the
/// <code>...</code> /// <c>...</c>
/// only /// only
/// support the exact number of alternatives shown in the diagram.</li> /// support the exact number of alternatives shown in the diagram.</li>
/// </ul> /// </ul>
@ -67,28 +67,28 @@ namespace Antlr4.Runtime.Atn
/// <embed src="images/Block.svg" type="image/svg+xml"/> /// <embed src="images/Block.svg" type="image/svg+xml"/>
/// <h2>Greedy Loops</h2> /// <h2>Greedy Loops</h2>
/// <h3>Greedy Closure: /// <h3>Greedy Closure:
/// <code>(...)*</code> /// <c>(...)*</c>
/// </h3> /// </h3>
/// <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/> /// <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
/// <h3>Greedy Positive Closure: /// <h3>Greedy Positive Closure:
/// <code>(...)+</code> /// <c>(...)+</c>
/// </h3> /// </h3>
/// <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/> /// <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
/// <h3>Greedy Optional: /// <h3>Greedy Optional:
/// <code>(...)?</code> /// <c>(...)?</c>
/// </h3> /// </h3>
/// <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/> /// <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
/// <h2>Non-Greedy Loops</h2> /// <h2>Non-Greedy Loops</h2>
/// <h3>Non-Greedy Closure: /// <h3>Non-Greedy Closure:
/// <code>(...)*?</code> /// <c>(...)*?</c>
/// </h3> /// </h3>
/// <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/> /// <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
/// <h3>Non-Greedy Positive Closure: /// <h3>Non-Greedy Positive Closure:
/// <code>(...)+?</code> /// <c>(...)+?</c>
/// </h3> /// </h3>
/// <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/> /// <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
/// <h3>Non-Greedy Optional: /// <h3>Non-Greedy Optional:
/// <code>(...)??</code> /// <c>(...)??</c>
/// </h3> /// </h3>
/// <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/> /// <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
/// </summary> /// </summary>

2
runtime/CSharp/Antlr4.Runtime/Atn/AmbiguityInfo.cs
View File

@ -47,7 +47,7 @@ namespace Antlr4.Runtime.Atn
/// traversed a global follow transition (i.e. /// traversed a global follow transition (i.e.
/// <see cref="ATNConfig.ReachesIntoOuterContext()"/> /// <see cref="ATNConfig.ReachesIntoOuterContext()"/>
/// is /// is
/// <code>false</code> /// <see langword="false"/>
/// for all /// for all
/// configurations), then the result of SLL prediction for that input is known to /// 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> /// be equivalent to the result of LL prediction for that input.</p>

2
runtime/CSharp/Antlr4.Runtime/Atn/BlockEndState.cs
View File

@ -34,7 +34,7 @@ namespace Antlr4.Runtime.Atn
{ {
/// <summary> /// <summary>
/// Terminal node of a simple /// Terminal node of a simple
/// <code>(a|b|c)</code> /// <c>(a|b|c)</c>
/// block. /// block.
/// </summary> /// </summary>
public sealed class BlockEndState : ATNState public sealed class BlockEndState : ATNState

2
runtime/CSharp/Antlr4.Runtime/Atn/BlockStartState.cs
View File

@ -34,7 +34,7 @@ namespace Antlr4.Runtime.Atn
{ {
/// <summary> /// <summary>
/// The start of a regular /// The start of a regular
/// <code>(...)</code> /// <c>(...)</c>
/// block. /// block.
/// </summary> /// </summary>
public abstract class BlockStartState : DecisionState public abstract class BlockStartState : DecisionState

6
runtime/CSharp/Antlr4.Runtime/Atn/DecisionEventInfo.cs
View File

@ -53,7 +53,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// The simulator state containing additional information relevant to the /// The simulator state containing additional information relevant to the
/// prediction state when the current event occurred, or /// prediction state when the current event occurred, or
/// <code>null</code> /// <see langword="null"/>
/// if no /// if no
/// additional information is relevant or available. /// additional information is relevant or available.
/// </summary> /// </summary>
@ -80,10 +80,10 @@ namespace Antlr4.Runtime.Atn
public readonly int stopIndex; public readonly int stopIndex;
/// <summary> /// <summary>
/// <code>true</code> /// <see langword="true"/>
/// if the current event occurred during LL prediction; /// if the current event occurred during LL prediction;
/// otherwise, /// otherwise,
/// <code>false</code> /// <see langword="false"/>
/// if the input occurred during SLL prediction. /// if the input occurred during SLL prediction.
/// </summary> /// </summary>
public readonly bool fullCtx; public readonly bool fullCtx;

10
runtime/CSharp/Antlr4.Runtime/Atn/ILexerAction.cs
View File

@ -63,11 +63,11 @@ namespace Antlr4.Runtime.Atn
/// <see cref="Antlr4.Runtime.ICharStream"/> /// <see cref="Antlr4.Runtime.ICharStream"/>
/// index at the time the action is executed. /// index at the time the action is executed.
/// <p>Many lexer commands, including /// <p>Many lexer commands, including
/// <code>type</code> /// <c>type</c>
/// , /// ,
/// <code>skip</code> /// <c>skip</c>
/// , and /// , and
/// <code>more</code> /// <c>more</c>
/// , do not check the input index during their execution. /// , do not check the input index during their execution.
/// Actions like this are position-independent, and may be stored more /// Actions like this are position-independent, and may be stored more
/// efficiently as part of the /// efficiently as part of the
@ -76,13 +76,13 @@ namespace Antlr4.Runtime.Atn
/// </remarks> /// </remarks>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if the lexer action semantics can be affected by the /// if the lexer action semantics can be affected by the
/// position of the input /// position of the input
/// <see cref="Antlr4.Runtime.ICharStream"/> /// <see cref="Antlr4.Runtime.ICharStream"/>
/// at the time it is executed; /// at the time it is executed;
/// otherwise, /// otherwise,
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
bool IsPositionDependent bool IsPositionDependent

78
runtime/CSharp/Antlr4.Runtime/Atn/LL1Analyzer.cs
View File

@ -39,7 +39,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Special value added to the lookahead sets to indicate that we hit /// Special value added to the lookahead sets to indicate that we hit
/// a predicate during analysis if /// a predicate during analysis if
/// <code>seeThruPreds==false</code> /// <c>seeThruPreds==false</c>
/// . /// .
/// </summary> /// </summary>
public const int HitPred = TokenConstants.InvalidType; public const int HitPred = TokenConstants.InvalidType;
@ -58,17 +58,17 @@ namespace Antlr4.Runtime.Atn
/// <see cref="ATNState"/> /// <see cref="ATNState"/>
/// . The returned array has one element for each /// . The returned array has one element for each
/// outgoing transition in /// outgoing transition in
/// <code>s</code> /// <paramref name="s"/>
/// . If the closure from transition /// . If the closure from transition
/// <em>i</em> leads to a semantic predicate before matching a symbol, the /// <em>i</em> leads to a semantic predicate before matching a symbol, the
/// element at index <em>i</em> of the result will be /// element at index <em>i</em> of the result will be
/// <code>null</code> /// <see langword="null"/>
/// . /// .
/// </summary> /// </summary>
/// <param name="s">the ATN state</param> /// <param name="s">the ATN state</param>
/// <returns> /// <returns>
/// the expected symbols for each outgoing transition of /// the expected symbols for each outgoing transition of
/// <code>s</code> /// <paramref name="s"/>
/// . /// .
/// </returns> /// </returns>
[return: Nullable] [return: Nullable]
@ -99,24 +99,24 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Compute set of tokens that can follow /// Compute set of tokens that can follow
/// <code>s</code> /// <paramref name="s"/>
/// in the ATN in the /// in the ATN in the
/// specified /// specified
/// <code>ctx</code> /// <paramref name="ctx"/>
/// . /// .
/// <p>If /// <p>If
/// <code>ctx</code> /// <paramref name="ctx"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// and the end of the rule containing /// and the end of the rule containing
/// <code>s</code> /// <paramref name="s"/>
/// is reached, /// is reached,
/// <see cref="TokenConstants.Epsilon"/> /// <see cref="TokenConstants.Epsilon"/>
/// is added to the result set. /// is added to the result set.
/// If /// If
/// <code>ctx</code> /// <paramref name="ctx"/>
/// is not /// is not
/// <code>null</code> /// <see langword="null"/>
/// and the end of the outermost rule is /// and the end of the outermost rule is
/// reached, /// reached,
/// <see cref="TokenConstants.Eof"/> /// <see cref="TokenConstants.Eof"/>
@ -125,16 +125,16 @@ namespace Antlr4.Runtime.Atn
/// <param name="s">the ATN state</param> /// <param name="s">the ATN state</param>
/// <param name="ctx"> /// <param name="ctx">
/// the complete parser context, or /// the complete parser context, or
/// <code>null</code> /// <see langword="null"/>
/// if the context /// if the context
/// should be ignored /// should be ignored
/// </param> /// </param>
/// <returns> /// <returns>
/// The set of tokens that can follow /// The set of tokens that can follow
/// <code>s</code> /// <paramref name="s"/>
/// in the ATN in the /// in the ATN in the
/// specified /// specified
/// <code>ctx</code> /// <paramref name="ctx"/>
/// . /// .
/// </returns> /// </returns>
[return: NotNull] [return: NotNull]
@ -145,24 +145,24 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Compute set of tokens that can follow /// Compute set of tokens that can follow
/// <code>s</code> /// <paramref name="s"/>
/// in the ATN in the /// in the ATN in the
/// specified /// specified
/// <code>ctx</code> /// <paramref name="ctx"/>
/// . /// .
/// <p>If /// <p>If
/// <code>ctx</code> /// <paramref name="ctx"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// and the end of the rule containing /// and the end of the rule containing
/// <code>s</code> /// <paramref name="s"/>
/// is reached, /// is reached,
/// <see cref="TokenConstants.Epsilon"/> /// <see cref="TokenConstants.Epsilon"/>
/// is added to the result set. /// is added to the result set.
/// If /// If
/// <see cref="IntStreamConstants.Eof"/> /// <paramref name="ctx"/>
/// is not /// is not
/// <code>PredictionContext#EMPTY_LOCAL</code> /// <c>PredictionContext#EMPTY_LOCAL</c>
/// and the end of the outermost rule is /// and the end of the outermost rule is
/// reached, /// reached,
/// <see cref="TokenConstants.Eof"/> /// <see cref="TokenConstants.Eof"/>
@ -176,16 +176,16 @@ namespace Antlr4.Runtime.Atn
/// </param> /// </param>
/// <param name="ctx"> /// <param name="ctx">
/// the complete parser context, or /// the complete parser context, or
/// <code>null</code> /// <see langword="null"/>
/// if the context /// if the context
/// should be ignored /// should be ignored
/// </param> /// </param>
/// <returns> /// <returns>
/// The set of tokens that can follow /// The set of tokens that can follow
/// <code>s</code> /// <paramref name="s"/>
/// in the ATN in the /// in the ATN in the
/// specified /// specified
/// <code>ctx</code> /// <paramref name="ctx"/>
/// . /// .
/// </returns> /// </returns>
[return: NotNull] [return: NotNull]
@ -201,32 +201,32 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Compute set of tokens that can follow /// Compute set of tokens that can follow
/// <code>s</code> /// <paramref name="s"/>
/// in the ATN in the /// in the ATN in the
/// specified /// specified
/// <code>ctx</code> /// <paramref name="ctx"/>
/// . /// .
/// <p/> /// <p/>
/// If /// If
/// <code>ctx</code> /// <paramref name="ctx"/>
/// is /// is
/// <see cref="PredictionContext.EmptyLocal"/> /// <see cref="PredictionContext.EmptyLocal"/>
/// and /// and
/// <code>stopState</code> /// <paramref name="stopState"/>
/// or the end of the rule containing /// or the end of the rule containing
/// <code>s</code> /// <paramref name="s"/>
/// is reached, /// is reached,
/// <see cref="TokenConstants.Epsilon"/> /// <see cref="TokenConstants.Epsilon"/>
/// is added to the result set. If /// is added to the result set. If
/// <code>ctx</code> /// <paramref name="ctx"/>
/// is not /// is not
/// <see cref="PredictionContext.EmptyLocal"/> /// <see cref="PredictionContext.EmptyLocal"/>
/// and /// and
/// <code>addEOF</code> /// <paramref name="addEOF"/>
/// is /// is
/// <code>true</code> /// <see langword="true"/>
/// and /// and
/// <code>stopState</code> /// <paramref name="stopState"/>
/// or the end of the outermost rule is reached, /// or the end of the outermost rule is reached,
/// <see cref="TokenConstants.Eof"/> /// <see cref="TokenConstants.Eof"/>
/// is added to the result set. /// is added to the result set.
@ -247,23 +247,23 @@ namespace Antlr4.Runtime.Atn
/// <param name="lookBusy"> /// <param name="lookBusy">
/// A set used for preventing epsilon closures in the ATN /// A set used for preventing epsilon closures in the ATN
/// from causing a stack overflow. Outside code should pass /// from causing a stack overflow. Outside code should pass
/// <code>new HashSet&lt;ATNConfig&gt;</code> /// <c>new HashSet&lt;ATNConfig&gt;</c>
/// for this argument. /// for this argument.
/// </param> /// </param>
/// <param name="calledRuleStack"> /// <param name="calledRuleStack">
/// A set used for preventing left recursion in the /// A set used for preventing left recursion in the
/// ATN from causing a stack overflow. Outside code should pass /// ATN from causing a stack overflow. Outside code should pass
/// <code>new BitSet()</code> /// <c>new BitSet()</c>
/// for this argument. /// for this argument.
/// </param> /// </param>
/// <param name="seeThruPreds"> /// <param name="seeThruPreds">
/// ///
/// <code>true</code> /// <see langword="true"/>
/// to true semantic predicates as /// to true semantic predicates as
/// implicitly /// implicitly
/// <code>true</code> /// <see langword="true"/>
/// and "see through them", otherwise /// and "see through them", otherwise
/// <code>false</code> /// <see langword="false"/>
/// to treat semantic predicates as opaque and add /// to treat semantic predicates as opaque and add
/// <see cref="HitPred"/> /// <see cref="HitPred"/>
/// to the /// to the
@ -274,7 +274,7 @@ namespace Antlr4.Runtime.Atn
/// <see cref="TokenConstants.Eof"/> /// <see cref="TokenConstants.Eof"/>
/// to the result if the end of the /// to the result if the end of the
/// outermost context is reached. This parameter has no effect if /// outermost context is reached. This parameter has no effect if
/// <code>ctx</code> /// <paramref name="ctx"/>
/// is /// is
/// <see cref="PredictionContext.EmptyLocal"/> /// <see cref="PredictionContext.EmptyLocal"/>
/// . /// .

34
runtime/CSharp/Antlr4.Runtime/Atn/LexerATNSimulator.cs
View File

@ -248,16 +248,16 @@ namespace Antlr4.Runtime.Atn
/// Get an existing target state for an edge in the DFA. If the target state /// 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, /// for the edge has not yet been computed or is otherwise not available,
/// this method returns /// this method returns
/// <code>null</code> /// <see langword="null"/>
/// . /// .
/// </remarks> /// </remarks>
/// <param name="s">The current DFA state</param> /// <param name="s">The current DFA state</param>
/// <param name="t">The next input symbol</param> /// <param name="t">The next input symbol</param>
/// <returns> /// <returns>
/// The existing target DFA state for the given input symbol /// The existing target DFA state for the given input symbol
/// <code>t</code> /// <paramref name="t"/>
/// , or /// , or
/// <code>null</code> /// <see langword="null"/>
/// if the target state for this edge is not /// if the target state for this edge is not
/// already cached /// already cached
/// </returns> /// </returns>
@ -287,9 +287,9 @@ namespace Antlr4.Runtime.Atn
/// <param name="t">The next input symbol</param> /// <param name="t">The next input symbol</param>
/// <returns> /// <returns>
/// The computed target DFA state for the given input symbol /// The computed target DFA state for the given input symbol
/// <code>t</code> /// <paramref name="t"/>
/// . If /// . If
/// <code>t</code> /// <paramref name="t"/>
/// does not lead to a valid DFA state, this method /// does not lead to a valid DFA state, this method
/// returns /// returns
/// <see cref="ATNSimulator.Error"/> /// <see cref="ATNSimulator.Error"/>
@ -340,9 +340,9 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Given a starting configuration set, figure out all ATN configurations /// Given a starting configuration set, figure out all ATN configurations
/// we can reach upon input /// we can reach upon input
/// <code>t</code> /// <paramref name="t"/>
/// . Parameter /// . Parameter
/// <code>reach</code> /// <paramref name="reach"/>
/// is a return /// is a return
/// parameter. /// parameter.
/// </summary> /// </summary>
@ -434,15 +434,15 @@ namespace Antlr4.Runtime.Atn
/// preference, this method stops pursuing the closure as soon as an accept /// 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 /// state is reached. After the first accept state is reached by depth-first
/// search from /// search from
/// <code>config</code> /// <paramref name="config"/>
/// , all other (potentially reachable) states for /// , all other (potentially reachable) states for
/// this rule would have a lower priority. /// this rule would have a lower priority.
/// </remarks> /// </remarks>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if an accept state is reached, otherwise /// if an accept state is reached, otherwise
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
protected internal virtual bool Closure(ICharStream input, ATNConfig config, ATNConfigSet configs, bool currentAltReachedAcceptState, bool speculative, bool treatEofAsEpsilon) protected internal virtual bool Closure(ICharStream input, ATNConfig config, ATNConfigSet configs, bool currentAltReachedAcceptState, bool speculative, bool treatEofAsEpsilon)
@ -604,9 +604,9 @@ namespace Antlr4.Runtime.Atn
/// <remarks> /// <remarks>
/// Evaluate a predicate specified in the lexer. /// Evaluate a predicate specified in the lexer.
/// <p>If /// <p>If
/// <code>speculative</code> /// <paramref name="speculative"/>
/// is /// is
/// <code>true</code> /// <see langword="true"/>
/// , this method was called before /// , this method was called before
/// <see cref="Consume(Antlr4.Runtime.ICharStream)"/> /// <see cref="Consume(Antlr4.Runtime.ICharStream)"/>
/// for the matched character. This method should call /// for the matched character. This method should call
@ -621,7 +621,7 @@ namespace Antlr4.Runtime.Atn
/// <see cref="Antlr4.Runtime.Lexer.Column()"/> /// <see cref="Antlr4.Runtime.Lexer.Column()"/>
/// , properly reflect the current /// , properly reflect the current
/// lexer state. This method should restore /// lexer state. This method should restore
/// <code>input</code> /// <paramref name="input"/>
/// and the simulator /// and the simulator
/// to the original state before returning (i.e. undo the actions made by the /// to the original state before returning (i.e. undo the actions made by the
/// call to /// call to
@ -633,17 +633,17 @@ namespace Antlr4.Runtime.Atn
/// <param name="predIndex">The index of the predicate within the rule.</param> /// <param name="predIndex">The index of the predicate within the rule.</param>
/// <param name="speculative"> /// <param name="speculative">
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if the current index in /// if the current index in
/// <code>input</code> /// <paramref name="input"/>
/// is /// is
/// one character before the predicate's location. /// one character before the predicate's location.
/// </param> /// </param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if the specified predicate evaluates to /// if the specified predicate evaluates to
/// <code>true</code> /// <see langword="true"/>
/// . /// .
/// </returns> /// </returns>
protected internal virtual bool EvaluatePredicate(ICharStream input, int ruleIndex, int predIndex, bool speculative) protected internal virtual bool EvaluatePredicate(ICharStream input, int ruleIndex, int predIndex, bool speculative)

22
runtime/CSharp/Antlr4.Runtime/Atn/LexerActionExecutor.cs
View File

@ -86,9 +86,9 @@ namespace Antlr4.Runtime.Atn
/// <see cref="LexerActionExecutor"/> /// <see cref="LexerActionExecutor"/>
/// which executes the actions for /// which executes the actions for
/// the input /// the input
/// <code>lexerActionExecutor</code> /// <paramref name="lexerActionExecutor"/>
/// followed by a specified /// followed by a specified
/// <code>lexerAction</code> /// <paramref name="lexerAction"/>
/// . /// .
/// </summary> /// </summary>
/// <param name="lexerActionExecutor"> /// <param name="lexerActionExecutor">
@ -96,14 +96,14 @@ namespace Antlr4.Runtime.Atn
/// the lexer while matching a token within a particular /// the lexer while matching a token within a particular
/// <see cref="ATNConfig"/> /// <see cref="ATNConfig"/>
/// . If this is /// . If this is
/// <code>null</code> /// <see langword="null"/>
/// , the method behaves as though /// , the method behaves as though
/// it were an empty executor. /// it were an empty executor.
/// </param> /// </param>
/// <param name="lexerAction"> /// <param name="lexerAction">
/// The lexer action to execute after the actions /// The lexer action to execute after the actions
/// specified in /// specified in
/// <code>lexerActionExecutor</code> /// <paramref name="lexerActionExecutor"/>
/// . /// .
/// </param> /// </param>
/// <returns> /// <returns>
@ -111,9 +111,9 @@ namespace Antlr4.Runtime.Atn
/// <see cref="LexerActionExecutor"/> /// <see cref="LexerActionExecutor"/>
/// for executing the combine actions /// for executing the combine actions
/// of /// of
/// <code>lexerActionExecutor</code> /// <paramref name="lexerActionExecutor"/>
/// and /// and
/// <code>lexerAction</code> /// <paramref name="lexerAction"/>
/// . /// .
/// </returns> /// </returns>
[return: NotNull] [return: NotNull]
@ -136,7 +136,7 @@ namespace Antlr4.Runtime.Atn
/// <p>Normally, when the executor encounters lexer actions where /// <p>Normally, when the executor encounters lexer actions where
/// <see cref="ILexerAction.IsPositionDependent()"/> /// <see cref="ILexerAction.IsPositionDependent()"/>
/// returns /// returns
/// <code>true</code> /// <see langword="true"/>
/// , it calls /// , it calls
/// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/> /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
/// on the input /// on the input
@ -155,7 +155,7 @@ namespace Antlr4.Runtime.Atn
/// position in the input stream.</p> /// position in the input stream.</p>
/// <p>If the current executor already has offsets assigned to all /// <p>If the current executor already has offsets assigned to all
/// position-dependent lexer actions, the method returns /// position-dependent lexer actions, the method returns
/// <code>this</code> /// <c>this</c>
/// .</p> /// .</p>
/// </summary> /// </summary>
/// <param name="offset"> /// <param name="offset">
@ -209,7 +209,7 @@ namespace Antlr4.Runtime.Atn
/// <p>This method calls /// <p>This method calls
/// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/> /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
/// to set the position of the /// to set the position of the
/// <code>input</code> /// <paramref name="input"/>
/// ///
/// <see cref="Antlr4.Runtime.ICharStream"/> /// <see cref="Antlr4.Runtime.ICharStream"/>
/// prior to calling /// prior to calling
@ -224,7 +224,7 @@ namespace Antlr4.Runtime.Atn
/// When this method is called, the current /// When this method is called, the current
/// <see cref="Antlr4.Runtime.IIntStream.Index()"/> /// <see cref="Antlr4.Runtime.IIntStream.Index()"/>
/// for /// for
/// <code>input</code> /// <paramref name="input"/>
/// should be the start of the following token, i.e. 1 /// should be the start of the following token, i.e. 1
/// character past the end of the current token. /// character past the end of the current token.
/// </param> /// </param>
@ -232,7 +232,7 @@ namespace Antlr4.Runtime.Atn
/// The token start index. This value may be passed to /// The token start index. This value may be passed to
/// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/> /// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
/// to set the /// to set the
/// <code>input</code> /// <paramref name="input"/>
/// position to the beginning /// position to the beginning
/// of the token. /// of the token.
/// </param> /// </param>

6
runtime/CSharp/Antlr4.Runtime/Atn/LexerChannelAction.cs
View File

@ -36,7 +36,7 @@ namespace Antlr4.Runtime.Atn
{ {
/// <summary> /// <summary>
/// Implements the /// Implements the
/// <code>channel</code> /// <c>channel</c>
/// lexer action by calling /// lexer action by calling
/// <see cref="Lexer.Channel"/> /// <see cref="Lexer.Channel"/>
/// with the assigned channel. /// with the assigned channel.
@ -49,7 +49,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Constructs a new /// Constructs a new
/// <code>channel</code> /// <paramref name="channel"/>
/// action with the specified channel value. /// action with the specified channel value.
/// </summary> /// </summary>
/// <param name="channel"> /// <param name="channel">
@ -97,7 +97,7 @@ namespace Antlr4.Runtime.Atn
/// <summary><inheritDoc/></summary> /// <summary><inheritDoc/></summary>
/// <returns> /// <returns>
/// This method returns /// This method returns
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
public bool IsPositionDependent public bool IsPositionDependent

2
runtime/CSharp/Antlr4.Runtime/Atn/LexerCustomAction.cs
View File

@ -134,7 +134,7 @@ namespace Antlr4.Runtime.Atn
/// </remarks> /// </remarks>
/// <returns> /// <returns>
/// This method returns /// This method returns
/// <code>true</code> /// <see langword="true"/>
/// . /// .
/// </returns> /// </returns>
public bool IsPositionDependent public bool IsPositionDependent

6
runtime/CSharp/Antlr4.Runtime/Atn/LexerIndexedCustomAction.cs
View File

@ -66,7 +66,7 @@ namespace Antlr4.Runtime.Atn
/// <p>Note: This class is only required for lexer actions for which /// <p>Note: This class is only required for lexer actions for which
/// <see cref="ILexerAction.IsPositionDependent()"/> /// <see cref="ILexerAction.IsPositionDependent()"/>
/// returns /// returns
/// <code>true</code> /// <see langword="true"/>
/// .</p> /// .</p>
/// </summary> /// </summary>
/// <param name="offset"> /// <param name="offset">
@ -146,7 +146,7 @@ namespace Antlr4.Runtime.Atn
/// <summary><inheritDoc/></summary> /// <summary><inheritDoc/></summary>
/// <returns> /// <returns>
/// This method returns /// This method returns
/// <code>true</code> /// <see langword="true"/>
/// . /// .
/// </returns> /// </returns>
public bool IsPositionDependent public bool IsPositionDependent
@ -164,7 +164,7 @@ namespace Antlr4.Runtime.Atn
/// on the result of /// on the result of
/// <see cref="Action()"/> /// <see cref="Action()"/>
/// using the provided /// using the provided
/// <code>lexer</code> /// <paramref name="lexer"/>
/// .</p> /// .</p>
/// </summary> /// </summary>
public void Execute(Lexer lexer) public void Execute(Lexer lexer)

8
runtime/CSharp/Antlr4.Runtime/Atn/LexerModeAction.cs
View File

@ -36,7 +36,7 @@ namespace Antlr4.Runtime.Atn
{ {
/// <summary> /// <summary>
/// Implements the /// Implements the
/// <code>mode</code> /// <c>mode</c>
/// lexer action by calling /// lexer action by calling
/// <see cref="Antlr4.Runtime.Lexer.Mode(int)"/> /// <see cref="Antlr4.Runtime.Lexer.Mode(int)"/>
/// with /// with
@ -50,7 +50,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Constructs a new /// Constructs a new
/// <code>mode</code> /// <paramref name="mode"/>
/// action with the specified mode value. /// action with the specified mode value.
/// </summary> /// </summary>
/// <param name="mode"> /// <param name="mode">
@ -67,7 +67,7 @@ namespace Antlr4.Runtime.Atn
/// <remarks>Get the lexer mode this action should transition the lexer to.</remarks> /// <remarks>Get the lexer mode this action should transition the lexer to.</remarks>
/// <returns> /// <returns>
/// The lexer mode for this /// The lexer mode for this
/// <code>mode</code> /// <c>mode</c>
/// command. /// command.
/// </returns> /// </returns>
public int Mode public int Mode
@ -95,7 +95,7 @@ namespace Antlr4.Runtime.Atn
/// <summary><inheritDoc/></summary> /// <summary><inheritDoc/></summary>
/// <returns> /// <returns>
/// This method returns /// This method returns
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
public bool IsPositionDependent public bool IsPositionDependent

8
runtime/CSharp/Antlr4.Runtime/Atn/LexerMoreAction.cs
View File

@ -36,12 +36,12 @@ namespace Antlr4.Runtime.Atn
{ {
/// <summary> /// <summary>
/// Implements the /// Implements the
/// <code>more</code> /// <c>more</c>
/// lexer action by calling /// lexer action by calling
/// <see cref="Antlr4.Runtime.Lexer.More()"/> /// <see cref="Antlr4.Runtime.Lexer.More()"/>
/// . /// .
/// <p>The /// <p>The
/// <code>more</code> /// <c>more</c>
/// command does not have any parameters, so this action is /// command does not have any parameters, so this action is
/// implemented as a singleton instance exposed by /// implemented as a singleton instance exposed by
/// <see cref="Instance"/> /// <see cref="Instance"/>
@ -57,7 +57,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Constructs the singleton instance of the lexer /// Constructs the singleton instance of the lexer
/// <code>more</code> /// <c>more</c>
/// command. /// command.
/// </summary> /// </summary>
private LexerMoreAction() private LexerMoreAction()
@ -81,7 +81,7 @@ namespace Antlr4.Runtime.Atn
/// <summary><inheritDoc/></summary> /// <summary><inheritDoc/></summary>
/// <returns> /// <returns>
/// This method returns /// This method returns
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
public bool IsPositionDependent public bool IsPositionDependent

8
runtime/CSharp/Antlr4.Runtime/Atn/LexerPopModeAction.cs
View File

@ -36,12 +36,12 @@ namespace Antlr4.Runtime.Atn
{ {
/// <summary> /// <summary>
/// Implements the /// Implements the
/// <code>popMode</code> /// <c>popMode</c>
/// lexer action by calling /// lexer action by calling
/// <see cref="Antlr4.Runtime.Lexer.PopMode()"/> /// <see cref="Antlr4.Runtime.Lexer.PopMode()"/>
/// . /// .
/// <p>The /// <p>The
/// <code>popMode</code> /// <c>popMode</c>
/// command does not have any parameters, so this action is /// command does not have any parameters, so this action is
/// implemented as a singleton instance exposed by /// implemented as a singleton instance exposed by
/// <see cref="Instance"/> /// <see cref="Instance"/>
@ -57,7 +57,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Constructs the singleton instance of the lexer /// Constructs the singleton instance of the lexer
/// <code>popMode</code> /// <c>popMode</c>
/// command. /// command.
/// </summary> /// </summary>
private LexerPopModeAction() private LexerPopModeAction()
@ -81,7 +81,7 @@ namespace Antlr4.Runtime.Atn
/// <summary><inheritDoc/></summary> /// <summary><inheritDoc/></summary>
/// <returns> /// <returns>
/// This method returns /// This method returns
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
public bool IsPositionDependent public bool IsPositionDependent

8
runtime/CSharp/Antlr4.Runtime/Atn/LexerPushModeAction.cs
View File

@ -36,7 +36,7 @@ namespace Antlr4.Runtime.Atn
{ {
/// <summary> /// <summary>
/// Implements the /// Implements the
/// <code>pushMode</code> /// <c>pushMode</c>
/// lexer action by calling /// lexer action by calling
/// <see cref="Antlr4.Runtime.Lexer.PushMode(int)"/> /// <see cref="Antlr4.Runtime.Lexer.PushMode(int)"/>
/// with the assigned mode. /// with the assigned mode.
@ -49,7 +49,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Constructs a new /// Constructs a new
/// <code>pushMode</code> /// <c>pushMode</c>
/// action with the specified mode value. /// action with the specified mode value.
/// </summary> /// </summary>
/// <param name="mode"> /// <param name="mode">
@ -66,7 +66,7 @@ namespace Antlr4.Runtime.Atn
/// <remarks>Get the lexer mode this action should transition the lexer to.</remarks> /// <remarks>Get the lexer mode this action should transition the lexer to.</remarks>
/// <returns> /// <returns>
/// The lexer mode for this /// The lexer mode for this
/// <code>pushMode</code> /// <c>pushMode</c>
/// command. /// command.
/// </returns> /// </returns>
public int Mode public int Mode
@ -94,7 +94,7 @@ namespace Antlr4.Runtime.Atn
/// <summary><inheritDoc/></summary> /// <summary><inheritDoc/></summary>
/// <returns> /// <returns>
/// This method returns /// This method returns
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
public bool IsPositionDependent public bool IsPositionDependent

8
runtime/CSharp/Antlr4.Runtime/Atn/LexerSkipAction.cs
View File

@ -36,12 +36,12 @@ namespace Antlr4.Runtime.Atn
{ {
/// <summary> /// <summary>
/// Implements the /// Implements the
/// <code>skip</code> /// <c>skip</c>
/// lexer action by calling /// lexer action by calling
/// <see cref="Antlr4.Runtime.Lexer.Skip()"/> /// <see cref="Antlr4.Runtime.Lexer.Skip()"/>
/// . /// .
/// <p>The /// <p>The
/// <code>skip</code> /// <c>skip</c>
/// command does not have any parameters, so this action is /// command does not have any parameters, so this action is
/// implemented as a singleton instance exposed by /// implemented as a singleton instance exposed by
/// <see cref="Instance"/> /// <see cref="Instance"/>
@ -57,7 +57,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Constructs the singleton instance of the lexer /// Constructs the singleton instance of the lexer
/// <code>skip</code> /// <c>skip</c>
/// command. /// command.
/// </summary> /// </summary>
private LexerSkipAction() private LexerSkipAction()
@ -81,7 +81,7 @@ namespace Antlr4.Runtime.Atn
/// <summary><inheritDoc/></summary> /// <summary><inheritDoc/></summary>
/// <returns> /// <returns>
/// This method returns /// This method returns
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
public bool IsPositionDependent public bool IsPositionDependent

6
runtime/CSharp/Antlr4.Runtime/Atn/LexerTypeAction.cs
View File

@ -36,7 +36,7 @@ namespace Antlr4.Runtime.Atn
{ {
/// <summary> /// <summary>
/// Implements the /// Implements the
/// <code>type</code> /// <c>type</c>
/// lexer action by calling /// lexer action by calling
/// <see cref="Lexer.Type"/> /// <see cref="Lexer.Type"/>
/// with the assigned type. /// with the assigned type.
@ -49,7 +49,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Constructs a new /// Constructs a new
/// <code>type</code> /// <paramref name="type"/>
/// action with the specified token type value. /// action with the specified token type value.
/// </summary> /// </summary>
/// <param name="type"> /// <param name="type">
@ -90,7 +90,7 @@ namespace Antlr4.Runtime.Atn
/// <summary><inheritDoc/></summary> /// <summary><inheritDoc/></summary>
/// <returns> /// <returns>
/// This method returns /// This method returns
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
public virtual bool IsPositionDependent public virtual bool IsPositionDependent

6
runtime/CSharp/Antlr4.Runtime/Atn/LookaheadEventInfo.cs
View File

@ -54,7 +54,7 @@ namespace Antlr4.Runtime.Atn
/// <param name="state"> /// <param name="state">
/// The final simulator state containing the necessary /// The final simulator state containing the necessary
/// information to determine the result of a prediction, or /// information to determine the result of a prediction, or
/// <code>null</code> /// <see langword="null"/>
/// if /// if
/// the final state is not available /// the final state is not available
/// </param> /// </param>
@ -63,10 +63,10 @@ namespace Antlr4.Runtime.Atn
/// <param name="stopIndex">The index at which the prediction was finally made</param> /// <param name="stopIndex">The index at which the prediction was finally made</param>
/// <param name="fullCtx"> /// <param name="fullCtx">
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if the current lookahead is part of an LL /// if the current lookahead is part of an LL
/// prediction; otherwise, /// prediction; otherwise,
/// <code>false</code> /// <see langword="false"/>
/// if the current lookahead is part of /// if the current lookahead is part of
/// an SLL prediction /// an SLL prediction
/// </param> /// </param>

92
runtime/CSharp/Antlr4.Runtime/Atn/ParserATNSimulator.cs
View File

@ -196,11 +196,11 @@ namespace Antlr4.Runtime.Atn
/// objects using cached /// objects using cached
/// subgraphs/nodes. No other locking occurs, even during DFA simulation. This is /// subgraphs/nodes. No other locking occurs, even during DFA simulation. This is
/// safe as long as we can guarantee that all threads referencing /// safe as long as we can guarantee that all threads referencing
/// <code>s.edge[t]</code> /// <c>s.edge[t]</c>
/// get the same physical target /// get the same physical target
/// <see cref="Antlr4.Runtime.Dfa.DFAState"/> /// <see cref="Antlr4.Runtime.Dfa.DFAState"/>
/// , or /// , or
/// <code>null</code> /// <see langword="null"/>
/// . Once into the DFA, the DFA simulation does not reference the /// . Once into the DFA, the DFA simulation does not reference the
/// <see cref="Antlr4.Runtime.Dfa.DFA.states"/> /// <see cref="Antlr4.Runtime.Dfa.DFA.states"/>
/// map. It follows the /// map. It follows the
@ -209,21 +209,21 @@ namespace Antlr4.Runtime.Atn
/// targets. The DFA simulator will either find /// targets. The DFA simulator will either find
/// <see cref="DFAState.edges"/> /// <see cref="DFAState.edges"/>
/// to be /// to be
/// <code>null</code> /// <see langword="null"/>
/// , to be non- /// , to be non-
/// <code>null</code> /// <see langword="null"/>
/// and /// and
/// <code>dfa.edges[t]</code> /// <c>dfa.edges[t]</c>
/// null, or /// null, or
/// <code>dfa.edges[t]</code> /// <c>dfa.edges[t]</c>
/// to be non-null. The /// to be non-null. The
/// <see cref="AddDFAEdge(Antlr4.Runtime.Dfa.DFAState, int, Antlr4.Runtime.Dfa.DFAState)"/> /// <see cref="AddDFAEdge(Antlr4.Runtime.Dfa.DFAState, int, Antlr4.Runtime.Dfa.DFAState)"/>
/// method could be racing to set the field /// method could be racing to set the field
/// but in either case the DFA simulator works; if /// but in either case the DFA simulator works; if
/// <code>null</code> /// <see langword="null"/>
/// , and requests ATN /// , and requests ATN
/// simulation. It could also race trying to get /// simulation. It could also race trying to get
/// <code>dfa.edges[t]</code> /// <c>dfa.edges[t]</c>
/// , but either /// , but either
/// way it will work because it's not doing a test and set operation.</p> /// way it will work because it's not doing a test and set operation.</p>
/// <p> /// <p>
@ -241,9 +241,9 @@ namespace Antlr4.Runtime.Atn
/// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Interpreter()">getInterpreter()</see> /// <see cref="Antlr4.Runtime.Recognizer{Symbol, ATNInterpreter}.Interpreter()">getInterpreter()</see>
/// . /// .
/// <see cref="PredictionMode"/> /// <see cref="PredictionMode"/>
/// <code>(</code> /// <c>(</c>
/// <see cref="Atn.PredictionMode.Sll"/> /// <see cref="Atn.PredictionMode.Sll"/>
/// <code>)</code> /// <c>)</c>
/// ; /// ;
/// parser. /// parser.
/// <see cref="Parser.ErrorHandler"/> /// <see cref="Parser.ErrorHandler"/>
@ -271,31 +271,31 @@ namespace Antlr4.Runtime.Atn
/// alternatives.</p> /// alternatives.</p>
/// <p> /// <p>
/// Let's say we have a set of SLL conflicting alternatives /// Let's say we have a set of SLL conflicting alternatives
/// <code/> /// <c/>
/// ///
/// 1, 2, 3}} and /// 1, 2, 3}} and
/// a smaller LL set called <em>s</em>. If <em>s</em> is /// a smaller LL set called <em>s</em>. If <em>s</em> is
/// <code/> /// <c/>
/// ///
/// 2, 3}}, then SLL /// 2, 3}}, then SLL
/// parsing will get an error because SLL will pursue alternative 1. If /// parsing will get an error because SLL will pursue alternative 1. If
/// <em>s</em> is /// <em>s</em> is
/// <code/> /// <c/>
/// ///
/// 1, 2}} or /// 1, 2}} or
/// <code/> /// <c/>
/// ///
/// 1, 3}} then both SLL and LL will /// 1, 3}} then both SLL and LL will
/// choose the same alternative because alternative one is the minimum of either /// choose the same alternative because alternative one is the minimum of either
/// set. If <em>s</em> is /// set. If <em>s</em> is
/// <code/> /// <c/>
/// ///
/// 2}} or /// 2}} or
/// <code/> /// <c/>
/// ///
/// 3}} then SLL will get a syntax /// 3}} then SLL will get a syntax
/// error. If <em>s</em> is /// error. If <em>s</em> is
/// <code/> /// <c/>
/// ///
/// 1}} then SLL will succeed.</p> /// 1}} then SLL will succeed.</p>
/// <p> /// <p>
@ -324,7 +324,7 @@ namespace Antlr4.Runtime.Atn
/// <summary>Determines whether the DFA is used for full-context predictions.</summary> /// <summary>Determines whether the DFA is used for full-context predictions.</summary>
/// <remarks> /// <remarks>
/// Determines whether the DFA is used for full-context predictions. When /// Determines whether the DFA is used for full-context predictions. When
/// <code>true</code> /// <see langword="true"/>
/// , the DFA stores transition information for both full-context /// , the DFA stores transition information for both full-context
/// and SLL parsing; otherwise, the DFA only stores SLL transition /// and SLL parsing; otherwise, the DFA only stores SLL transition
/// information. /// information.
@ -335,7 +335,7 @@ namespace Antlr4.Runtime.Atn
/// configuration sets, and prediction contexts.</p> /// configuration sets, and prediction contexts.</p>
/// <p> /// <p>
/// The default value is /// The default value is
/// <code>false</code> /// <see langword="false"/>
/// .</p> /// .</p>
/// </remarks> /// </remarks>
public bool enable_global_context_dfa = false; public bool enable_global_context_dfa = false;
@ -357,20 +357,20 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// When /// When
/// <code>true</code> /// <see langword="true"/>
/// , ambiguous alternatives are reported when they are /// , ambiguous alternatives are reported when they are
/// encountered within /// encountered within
/// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)"/> /// <see cref="ExecATN(Antlr4.Runtime.Dfa.DFA, Antlr4.Runtime.ITokenStream, int, SimulatorState)"/>
/// . When /// . When
/// <code>false</code> /// <see langword="false"/>
/// , these messages /// , these messages
/// are suppressed. The default is /// are suppressed. The default is
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// <p/> /// <p/>
/// When messages about ambiguous alternatives are not required, setting this /// When messages about ambiguous alternatives are not required, setting this
/// to /// to
/// <code>false</code> /// <see langword="false"/>
/// enables additional internal optimizations which may lose /// enables additional internal optimizations which may lose
/// this information. /// this information.
/// </summary> /// </summary>
@ -894,23 +894,23 @@ namespace Antlr4.Runtime.Atn
/// localized location.</p> /// localized location.</p>
/// <ul> /// <ul>
/// <li>If no configuration in /// <li>If no configuration in
/// <code>configs</code> /// <c>configs</c>
/// reached the end of the /// reached the end of the
/// decision rule, return /// decision rule, return
/// <see cref="ATN.InvalidAltNumber"/> /// <see cref="ATN.InvalidAltNumber"/>
/// .</li> /// .</li>
/// <li>If all configurations in /// <li>If all configurations in
/// <code>configs</code> /// <c>configs</c>
/// which reached the end of the /// which reached the end of the
/// decision rule predict the same alternative, return that alternative.</li> /// decision rule predict the same alternative, return that alternative.</li>
/// <li>If the configurations in /// <li>If the configurations in
/// <code>configs</code> /// <c>configs</c>
/// which reached the end of the /// which reached the end of the
/// decision rule predict multiple alternatives (call this <em>S</em>), /// decision rule predict multiple alternatives (call this <em>S</em>),
/// choose an alternative in the following order. /// choose an alternative in the following order.
/// <ol> /// <ol>
/// <li>Filter the configurations in /// <li>Filter the configurations in
/// <code>configs</code> /// <c>configs</c>
/// to only those /// to only those
/// configurations which remain viable after evaluating semantic predicates. /// configurations which remain viable after evaluating semantic predicates.
/// If the set of these filtered configurations which also reached the end of /// If the set of these filtered configurations which also reached the end of
@ -946,7 +946,7 @@ namespace Antlr4.Runtime.Atn
/// <param name="startIndex"> /// <param name="startIndex">
/// The start index for the current prediction, which is /// The start index for the current prediction, which is
/// the input index where any semantic context in /// the input index where any semantic context in
/// <code>configs</code> /// <c>configs</c>
/// should be /// should be
/// evaluated /// evaluated
/// </param> /// </param>
@ -1086,16 +1086,16 @@ namespace Antlr4.Runtime.Atn
/// Get an existing target state for an edge in the DFA. If the target state /// 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, /// for the edge has not yet been computed or is otherwise not available,
/// this method returns /// this method returns
/// <code>null</code> /// <see langword="null"/>
/// . /// .
/// </remarks> /// </remarks>
/// <param name="s">The current DFA state</param> /// <param name="s">The current DFA state</param>
/// <param name="t">The next input symbol</param> /// <param name="t">The next input symbol</param>
/// <returns> /// <returns>
/// The existing target DFA state for the given input symbol /// The existing target DFA state for the given input symbol
/// <code>t</code> /// <paramref name="t"/>
/// , or /// , or
/// <code>null</code> /// <see langword="null"/>
/// if the target state for this edge is not /// if the target state for this edge is not
/// already cached /// already cached
/// </returns> /// </returns>
@ -1121,9 +1121,9 @@ namespace Antlr4.Runtime.Atn
/// <param name="contextCache"/> /// <param name="contextCache"/>
/// <returns> /// <returns>
/// The computed target DFA state for the given input symbol /// The computed target DFA state for the given input symbol
/// <code>t</code> /// <paramref name="t"/>
/// . If /// . If
/// <code>t</code> /// <paramref name="t"/>
/// does not lead to a valid DFA state, this method /// does not lead to a valid DFA state, this method
/// returns /// returns
/// <see cref="ATNSimulator.Error"/> /// <see cref="ATNSimulator.Error"/>
@ -1233,15 +1233,15 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Return a configuration set containing only the configurations from /// Return a configuration set containing only the configurations from
/// <code>configs</code> /// <paramref name="configs"/>
/// which are in a /// which are in a
/// <see cref="RuleStopState"/> /// <see cref="RuleStopState"/>
/// . If all /// . If all
/// configurations in /// configurations in
/// <code>configs</code> /// <paramref name="configs"/>
/// are already in a rule stop state, this /// are already in a rule stop state, this
/// method simply returns /// method simply returns
/// <code>configs</code> /// <paramref name="configs"/>
/// . /// .
/// </summary> /// </summary>
/// <param name="configs">the configuration set to update</param> /// <param name="configs">the configuration set to update</param>
@ -1252,13 +1252,13 @@ namespace Antlr4.Runtime.Atn
/// </param> /// </param>
/// <returns> /// <returns>
/// ///
/// <code>configs</code> /// <paramref name="configs"/>
/// if all configurations in /// if all configurations in
/// <code>configs</code> /// <paramref name="configs"/>
/// are in a /// are in a
/// rule stop state, otherwise return a new configuration set containing only /// rule stop state, otherwise return a new configuration set containing only
/// the configurations from /// the configurations from
/// <code>configs</code> /// <paramref name="configs"/>
/// which are in a rule stop state /// which are in a rule stop state
/// </returns> /// </returns>
[return: NotNull] [return: NotNull]
@ -1478,18 +1478,18 @@ namespace Antlr4.Runtime.Atn
/// <p> /// <p>
/// If the above grammar, the ATN state immediately before the token /// If the above grammar, the ATN state immediately before the token
/// reference /// reference
/// <code>'a'</code> /// <c>'a'</c>
/// in /// in
/// <code>letterA</code> /// <c>letterA</c>
/// is reachable from the left edge /// is reachable from the left edge
/// of both the primary and closure blocks of the left-recursive rule /// of both the primary and closure blocks of the left-recursive rule
/// <code>statement</code> /// <c>statement</c>
/// . The prediction context associated with each of these /// . The prediction context associated with each of these
/// configurations distinguishes between them, and prevents the alternative /// configurations distinguishes between them, and prevents the alternative
/// which stepped out to /// which stepped out to
/// <code>prog</code> /// <c>prog</c>
/// (and then back in to /// (and then back in to
/// <code>statement</code> /// <c>statement</c>
/// from being eliminated by the filter. /// from being eliminated by the filter.
/// </p> /// </p>
/// </summary> /// </summary>
@ -1657,7 +1657,7 @@ namespace Antlr4.Runtime.Atn
/// <remarks> /// <remarks>
/// Look through a list of predicate/alt pairs, returning alts for the /// Look through a list of predicate/alt pairs, returning alts for the
/// pairs that win. A /// pairs that win. A
/// <code>null</code> /// <see langword="null"/>
/// predicate indicates an alt containing an /// predicate indicates an alt containing an
/// unpredicated config which behaves as "always true." /// unpredicated config which behaves as "always true."
/// </remarks> /// </remarks>
@ -1730,7 +1730,7 @@ namespace Antlr4.Runtime.Atn
/// </param> /// </param>
/// <param name="alt"> /// <param name="alt">
/// The alternative which is guarded by /// The alternative which is guarded by
/// <code>pred</code> /// <paramref name="pred"/>
/// </param> /// </param>
/// <since>4.3</since> /// <since>4.3</since>
protected internal virtual bool EvalSemanticContext(SemanticContext pred, ParserRuleContext parserCallStack, int alt) protected internal virtual bool EvalSemanticContext(SemanticContext pred, ParserRuleContext parserCallStack, int alt)

4
runtime/CSharp/Antlr4.Runtime/Atn/PlusBlockStartState.cs
View File

@ -34,14 +34,14 @@ namespace Antlr4.Runtime.Atn
{ {
/// <summary> /// <summary>
/// Start of /// Start of
/// <code>(A|B|...)+</code> /// <c>(A|B|...)+</c>
/// loop. Technically a decision state, but /// loop. Technically a decision state, but
/// we don't use for code generation; somebody might need it, so I'm defining /// we don't use for code generation; somebody might need it, so I'm defining
/// it for completeness. In reality, the /// it for completeness. In reality, the
/// <see cref="PlusLoopbackState"/> /// <see cref="PlusLoopbackState"/>
/// node is the /// node is the
/// real decision-making note for /// real decision-making note for
/// <code>A+</code> /// <c>A+</c>
/// . /// .
/// </summary> /// </summary>
public sealed class PlusBlockStartState : BlockStartState public sealed class PlusBlockStartState : BlockStartState

4
runtime/CSharp/Antlr4.Runtime/Atn/PlusLoopbackState.cs
View File

@ -34,9 +34,9 @@ namespace Antlr4.Runtime.Atn
{ {
/// <summary> /// <summary>
/// Decision state for /// Decision state for
/// <code>A+</code> /// <c>A+</c>
/// and /// and
/// <code>(A|B)+</code> /// <c>(A|B)+</c>
/// . It has two transitions: /// . It has two transitions:
/// one to the loop back to start of the block and one to exit. /// one to the loop back to start of the block and one to exit.
/// </summary> /// </summary>

2
runtime/CSharp/Antlr4.Runtime/Atn/PredicateEvalInfo.cs
View File

@ -88,7 +88,7 @@ namespace Antlr4.Runtime.Atn
/// <param name="predictedAlt"> /// <param name="predictedAlt">
/// The alternative number for the decision which is /// The alternative number for the decision which is
/// guarded by the semantic context /// guarded by the semantic context
/// <code>semctx</code> /// <paramref name="semctx"/>
/// . See /// . See
/// <see cref="predictedAlt"/> /// <see cref="predictedAlt"/>
/// for more information. /// for more information.

260
runtime/CSharp/Antlr4.Runtime/Atn/PredictionMode.cs
View File

@ -180,10 +180,10 @@ namespace Antlr4.Runtime.Atn
/// <p>Assuming combined SLL+LL parsing, an SLL configuration set with only /// <p>Assuming combined SLL+LL parsing, an SLL configuration set with only
/// conflicting subsets should fall back to full LL, even if the /// conflicting subsets should fall back to full LL, even if the
/// configuration sets don't resolve to the same alternative (e.g. /// configuration sets don't resolve to the same alternative (e.g.
/// <code/> /// <c/>
/// ///
/// 1,2}} and /// 1,2}} and
/// <code/> /// <c/>
/// ///
/// 3,4}}. If there is at least one non-conflicting /// 3,4}}. If there is at least one non-conflicting
/// configuration, SLL could continue with the hopes that more lookahead will /// configuration, SLL could continue with the hopes that more lookahead will
@ -197,25 +197,25 @@ namespace Antlr4.Runtime.Atn
/// The single-alt-state thing lets prediction continue upon rules like /// The single-alt-state thing lets prediction continue upon rules like
/// (otherwise, it would admit defeat too soon):</p> /// (otherwise, it would admit defeat too soon):</p>
/// <p> /// <p>
/// <code>[12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;</code> /// <c>[12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;</c>
/// </p> /// </p>
/// <p>When the ATN simulation reaches the state before /// <p>When the ATN simulation reaches the state before
/// <code>';'</code> /// <c>';'</c>
/// , it has a /// , it has a
/// DFA state that looks like: /// DFA state that looks like:
/// <code>[12|1|[], 6|2|[], 12|2|[]]</code> /// <c>[12|1|[], 6|2|[], 12|2|[]]</c>
/// . Naturally /// . Naturally
/// <code>12|1|[]</code> /// <c>12|1|[]</c>
/// and /// and
/// <code>12|2|[]</code> /// <c>12|2|[]</c>
/// conflict, but we cannot stop /// conflict, but we cannot stop
/// processing this node because alternative to has another way to continue, /// processing this node because alternative to has another way to continue,
/// via /// via
/// <code>[6|2|[]]</code> /// <c>[6|2|[]]</c>
/// .</p> /// .</p>
/// <p>It also let's us continue for this rule:</p> /// <p>It also let's us continue for this rule:</p>
/// <p> /// <p>
/// <code>[1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;</code> /// <c>[1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;</c>
/// </p> /// </p>
/// <p>After matching input A, we reach the stop state for rule A, state 1. /// <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 /// State 8 is the state right before B. Clearly alternatives 1 and 2
@ -242,20 +242,20 @@ namespace Antlr4.Runtime.Atn
/// semantic predicate contexts so we might see two configurations like the /// semantic predicate contexts so we might see two configurations like the
/// following.</p> /// following.</p>
/// <p> /// <p>
/// <code/> /// <c/>
/// (s, 1, x, /// (s, 1, x,
/// ), (s, 1, x', {p})}</p> /// ), (s, 1, x', {p})}</p>
/// <p>Before testing these configurations against others, we have to merge /// <p>Before testing these configurations against others, we have to merge
/// <code>x</code> /// <c>x</c>
/// and /// and
/// <code>x'</code> /// <c>x'</c>
/// (without modifying the existing configurations). /// (without modifying the existing configurations).
/// For example, we test /// For example, we test
/// <code>(x+x')==x''</code> /// <c>(x+x')==x''</c>
/// when looking for conflicts in /// when looking for conflicts in
/// the following configurations.</p> /// the following configurations.</p>
/// <p> /// <p>
/// <code/> /// <c/>
/// (s, 1, x, /// (s, 1, x,
/// ), (s, 1, x', {p}), (s, 2, x'', {})}</p> /// ), (s, 1, x', {p}), (s, 2, x'', {})}</p>
/// <p>If the configuration set has predicates (as indicated by /// <p>If the configuration set has predicates (as indicated by
@ -298,7 +298,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Checks if any configuration in /// Checks if any configuration in
/// <code>configs</code> /// <paramref name="configs"/>
/// is in a /// is in a
/// <see cref="RuleStopState"/> /// <see cref="RuleStopState"/>
/// . Configurations meeting this condition have reached /// . Configurations meeting this condition have reached
@ -308,13 +308,13 @@ namespace Antlr4.Runtime.Atn
/// <param name="configs">the configuration set to test</param> /// <param name="configs">the configuration set to test</param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if any configuration in /// if any configuration in
/// <code>configs</code> /// <paramref name="configs"/>
/// is in a /// is in a
/// <see cref="RuleStopState"/> /// <see cref="RuleStopState"/>
/// , otherwise /// , otherwise
/// <code>false</code> /// <see langword="false"/>
/// </returns> /// </returns>
public static bool HasConfigInRuleStopState(IEnumerable<ATNConfig> configs) public static bool HasConfigInRuleStopState(IEnumerable<ATNConfig> configs)
{ {
@ -330,7 +330,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Checks if all configurations in /// Checks if all configurations in
/// <code>configs</code> /// <paramref name="configs"/>
/// are in a /// are in a
/// <see cref="RuleStopState"/> /// <see cref="RuleStopState"/>
/// . Configurations meeting this condition have reached /// . Configurations meeting this condition have reached
@ -340,13 +340,13 @@ namespace Antlr4.Runtime.Atn
/// <param name="configs">the configuration set to test</param> /// <param name="configs">the configuration set to test</param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if all configurations in /// if all configurations in
/// <code>configs</code> /// <paramref name="configs"/>
/// are in a /// are in a
/// <see cref="RuleStopState"/> /// <see cref="RuleStopState"/>
/// , otherwise /// , otherwise
/// <code>false</code> /// <see langword="false"/>
/// </returns> /// </returns>
public static bool AllConfigsInRuleStopStates(IEnumerable<ATNConfig> configs) public static bool AllConfigsInRuleStopStates(IEnumerable<ATNConfig> configs)
{ {
@ -372,10 +372,10 @@ namespace Antlr4.Runtime.Atn
/// minimums. That means we need more look ahead to decide which of those /// minimums. That means we need more look ahead to decide which of those
/// alternatives we should predict.</p> /// alternatives we should predict.</p>
/// <p>The basic idea is to split the set of configurations /// <p>The basic idea is to split the set of configurations
/// <code>C</code> /// <c>C</c>
/// , into /// , into
/// conflicting subsets /// conflicting subsets
/// <code>(s, _, ctx, _)</code> /// <c>(s, _, ctx, _)</c>
/// and singleton subsets with /// and singleton subsets with
/// non-conflicting configurations. Two configurations conflict if they have /// non-conflicting configurations. Two configurations conflict if they have
/// identical /// identical
@ -386,30 +386,30 @@ namespace Antlr4.Runtime.Atn
/// but different /// but different
/// <see cref="ATNConfig.Alt"/> /// <see cref="ATNConfig.Alt"/>
/// value, e.g. /// value, e.g.
/// <code>(s, i, ctx, _)</code> /// <c>(s, i, ctx, _)</c>
/// and /// and
/// <code>(s, j, ctx, _)</code> /// <c>(s, j, ctx, _)</c>
/// for /// for
/// <code>i!=j</code> /// <c>i!=j</c>
/// .</p> /// .</p>
/// <p/> /// <p/>
/// Reduce these configuration subsets to the set of possible alternatives. /// Reduce these configuration subsets to the set of possible alternatives.
/// You can compute the alternative subsets in one pass as follows: /// You can compute the alternative subsets in one pass as follows:
/// <p/> /// <p/>
/// <code/> /// <c/>
/// A_s,ctx = /// A_s,ctx =
/// i | (s, i, ctx, _)}} for each configuration in /// i | (s, i, ctx, _)}} for each configuration in
/// <code>C</code> /// <c>C</c>
/// holding /// holding
/// <code>s</code> /// <c>s</c>
/// and /// and
/// <code>ctx</code> /// <c>ctx</c>
/// fixed. /// fixed.
/// <p/> /// <p/>
/// Or in pseudo-code, for each configuration /// Or in pseudo-code, for each configuration
/// <code>c</code> /// <c>c</c>
/// in /// in
/// <code>C</code> /// <c>C</c>
/// : /// :
/// <pre> /// <pre>
/// map[c] U= c. /// map[c] U= c.
@ -418,16 +418,16 @@ namespace Antlr4.Runtime.Atn
/// alt and not pred /// alt and not pred
/// </pre> /// </pre>
/// <p>The values in /// <p>The values in
/// <code>map</code> /// <c>map</c>
/// are the set of /// are the set of
/// <code>A_s,ctx</code> /// <c>A_s,ctx</c>
/// sets.</p> /// sets.</p>
/// <p>If /// <p>If
/// <code>|A_s,ctx|=1</code> /// <c>|A_s,ctx|=1</c>
/// then there is no conflict associated with /// then there is no conflict associated with
/// <code>s</code> /// <c>s</c>
/// and /// and
/// <code>ctx</code> /// <c>ctx</c>
/// .</p> /// .</p>
/// <p>Reduce the subsets to singletons by choosing a minimum of each subset. If /// <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 /// the union of these alternative subsets is a singleton, then no amount of
@ -447,57 +447,57 @@ namespace Antlr4.Runtime.Atn
/// check.</p> /// check.</p>
/// <p><strong>CONFLICTING CONFIGS</strong></p> /// <p><strong>CONFLICTING CONFIGS</strong></p>
/// <p>Two configurations /// <p>Two configurations
/// <code>(s, i, x)</code> /// <c>(s, i, x)</c>
/// and /// and
/// <code>(s, j, x')</code> /// <c>(s, j, x')</c>
/// , conflict /// , conflict
/// when /// when
/// <code>i!=j</code> /// <c>i!=j</c>
/// but /// but
/// <code>x=x'</code> /// <c>x=x'</c>
/// . Because we merge all /// . Because we merge all
/// <code>(s, i, _)</code> /// <c>(s, i, _)</c>
/// configurations together, that means that there are at /// configurations together, that means that there are at
/// most /// most
/// <code>n</code> /// <c>n</c>
/// configurations associated with state /// configurations associated with state
/// <code>s</code> /// <c>s</c>
/// for /// for
/// <code>n</code> /// <c>n</c>
/// possible alternatives in the decision. The merged stacks /// possible alternatives in the decision. The merged stacks
/// complicate the comparison of configuration contexts /// complicate the comparison of configuration contexts
/// <code>x</code> /// <c>x</c>
/// and /// and
/// <code>x'</code> /// <c>x'</c>
/// . Sam checks to see if one is a subset of the other by calling /// . 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 /// merge and checking to see if the merged result is either
/// <code>x</code> /// <c>x</c>
/// or /// or
/// <code>x'</code> /// <c>x'</c>
/// . If the /// . If the
/// <code>x</code> /// <c>x</c>
/// associated with lowest alternative /// associated with lowest alternative
/// <code>i</code> /// <c>i</c>
/// is the superset, then /// is the superset, then
/// <code>i</code> /// <c>i</c>
/// is the only possible prediction since the /// is the only possible prediction since the
/// others resolve to /// others resolve to
/// <code>min(i)</code> /// <c>min(i)</c>
/// as well. However, if /// as well. However, if
/// <code>x</code> /// <c>x</c>
/// is /// is
/// associated with /// associated with
/// <code>j&gt;i</code> /// <c>j&gt;i</c>
/// then at least one stack configuration for /// then at least one stack configuration for
/// <code>j</code> /// <c>j</c>
/// is not in conflict with alternative /// is not in conflict with alternative
/// <code>i</code> /// <c>i</c>
/// . The algorithm /// . The algorithm
/// should keep going, looking for more lookahead due to the uncertainty.</p> /// should keep going, looking for more lookahead due to the uncertainty.</p>
/// <p>For simplicity, I'm doing a equality check between /// <p>For simplicity, I'm doing a equality check between
/// <code>x</code> /// <c>x</c>
/// and /// and
/// <code>x'</code> /// <c>x'</c>
/// that lets the algorithm continue to consume lookahead longer /// that lets the algorithm continue to consume lookahead longer
/// than necessary. The reason I like the equality is of course the /// 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 /// simplicity but also because that is the test you need to detect the
@ -507,7 +507,7 @@ namespace Antlr4.Runtime.Atn
/// conflicting alternative subsets has more than one alternative. We are /// conflicting alternative subsets has more than one alternative. We are
/// uncertain about which alternative to predict.</p> /// uncertain about which alternative to predict.</p>
/// <p>The complete set of alternatives, /// <p>The complete set of alternatives,
/// <code>[i for (_,i,_)]</code> /// <c>[i for (_,i,_)]</c>
/// , tells us which /// , tells us which
/// alternatives are still in the running for the amount of input we've /// 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 /// consumed at this point. The conflicting sets let us to strip away
@ -518,108 +518,108 @@ namespace Antlr4.Runtime.Atn
/// <ul> /// <ul>
/// <li>no conflicts and more than 1 alternative in set =&gt; continue</li> /// <li>no conflicts and more than 1 alternative in set =&gt; continue</li>
/// <li> /// <li>
/// <code>(s, 1, x)</code> /// <c>(s, 1, x)</c>
/// , /// ,
/// <code>(s, 2, x)</code> /// <c>(s, 2, x)</c>
/// , /// ,
/// <code>(s, 3, z)</code> /// <c>(s, 3, z)</c>
/// , /// ,
/// <code>(s', 1, y)</code> /// <c>(s', 1, y)</c>
/// , /// ,
/// <code>(s', 2, y)</code> /// <c>(s', 2, y)</c>
/// yields non-conflicting set /// yields non-conflicting set
/// <code/> /// <c/>
/// ///
/// 3}} U conflicting sets /// 3}} U conflicting sets
/// <code/> /// <c/>
/// min( /// min(
/// 1,2})} U /// 1,2})} U
/// <code/> /// <c/>
/// min( /// min(
/// 1,2})} = /// 1,2})} =
/// <code/> /// <c/>
/// ///
/// 1,3}} =&gt; continue /// 1,3}} =&gt; continue
/// </li> /// </li>
/// <li> /// <li>
/// <code>(s, 1, x)</code> /// <c>(s, 1, x)</c>
/// , /// ,
/// <code>(s, 2, x)</code> /// <c>(s, 2, x)</c>
/// , /// ,
/// <code>(s', 1, y)</code> /// <c>(s', 1, y)</c>
/// , /// ,
/// <code>(s', 2, y)</code> /// <c>(s', 2, y)</c>
/// , /// ,
/// <code>(s'', 1, z)</code> /// <c>(s'', 1, z)</c>
/// yields non-conflicting set /// yields non-conflicting set
/// <code/> /// <c/>
/// ///
/// 1}} U conflicting sets /// 1}} U conflicting sets
/// <code/> /// <c/>
/// min( /// min(
/// 1,2})} U /// 1,2})} U
/// <code/> /// <c/>
/// min( /// min(
/// 1,2})} = /// 1,2})} =
/// <code/> /// <c/>
/// ///
/// 1}} =&gt; stop and predict 1</li> /// 1}} =&gt; stop and predict 1</li>
/// <li> /// <li>
/// <code>(s, 1, x)</code> /// <c>(s, 1, x)</c>
/// , /// ,
/// <code>(s, 2, x)</code> /// <c>(s, 2, x)</c>
/// , /// ,
/// <code>(s', 1, y)</code> /// <c>(s', 1, y)</c>
/// , /// ,
/// <code>(s', 2, y)</code> /// <c>(s', 2, y)</c>
/// yields conflicting, reduced sets /// yields conflicting, reduced sets
/// <code/> /// <c/>
/// ///
/// 1}} U /// 1}} U
/// <code/> /// <c/>
/// ///
/// 1}} = /// 1}} =
/// <code/> /// <c/>
/// ///
/// 1}} =&gt; stop and predict 1, can announce /// 1}} =&gt; stop and predict 1, can announce
/// ambiguity /// ambiguity
/// <code/> /// <c/>
/// ///
/// 1,2}}</li> /// 1,2}}</li>
/// <li> /// <li>
/// <code>(s, 1, x)</code> /// <c>(s, 1, x)</c>
/// , /// ,
/// <code>(s, 2, x)</code> /// <c>(s, 2, x)</c>
/// , /// ,
/// <code>(s', 2, y)</code> /// <c>(s', 2, y)</c>
/// , /// ,
/// <code>(s', 3, y)</code> /// <c>(s', 3, y)</c>
/// yields conflicting, reduced sets /// yields conflicting, reduced sets
/// <code/> /// <c/>
/// ///
/// 1}} U /// 1}} U
/// <code/> /// <c/>
/// ///
/// 2}} = /// 2}} =
/// <code/> /// <c/>
/// ///
/// 1,2}} =&gt; continue</li> /// 1,2}} =&gt; continue</li>
/// <li> /// <li>
/// <code>(s, 1, x)</code> /// <c>(s, 1, x)</c>
/// , /// ,
/// <code>(s, 2, x)</code> /// <c>(s, 2, x)</c>
/// , /// ,
/// <code>(s', 3, y)</code> /// <c>(s', 3, y)</c>
/// , /// ,
/// <code>(s', 4, y)</code> /// <c>(s', 4, y)</c>
/// yields conflicting, reduced sets /// yields conflicting, reduced sets
/// <code/> /// <c/>
/// ///
/// 1}} U /// 1}} U
/// <code/> /// <c/>
/// ///
/// 3}} = /// 3}} =
/// <code/> /// <c/>
/// ///
/// 1,3}} =&gt; continue</li> /// 1,3}} =&gt; continue</li>
/// </ul> /// </ul>
@ -629,24 +629,24 @@ namespace Antlr4.Runtime.Atn
/// <p><code>|A_<em>i</em>|&gt;1</code> and /// <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> /// <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 /// <p>In other words, we continue examining lookahead until all
/// <code>A_i</code> /// <c>A_i</c>
/// have more than one alternative and all /// have more than one alternative and all
/// <code>A_i</code> /// <c>A_i</c>
/// are the same. If /// are the same. If
/// <code/> /// <c/>
/// A= /// A=
/// {1,2}, {1,3}}}, then regular LL prediction would terminate /// {1,2}, {1,3}}}, then regular LL prediction would terminate
/// because the resolved set is /// because the resolved set is
/// <code/> /// <c/>
/// ///
/// 1}}. To determine what the real /// 1}}. To determine what the real
/// ambiguity is, we have to know whether the ambiguity is between one and /// 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 /// 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 /// we need exact ambiguity detection when the sets look like
/// <code/> /// <c/>
/// A= /// A=
/// {1,2}}} or /// {1,2}}} or
/// <code/> /// <c/>
/// ///
/// {1,2},{1,2}}}, etc...</p> /// {1,2},{1,2}}}, etc...</p>
/// </remarks> /// </remarks>
@ -657,22 +657,22 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Determines if every alternative subset in /// Determines if every alternative subset in
/// <code>altsets</code> /// <paramref name="altsets"/>
/// contains more /// contains more
/// than one alternative. /// than one alternative.
/// </summary> /// </summary>
/// <param name="altsets">a collection of alternative subsets</param> /// <param name="altsets">a collection of alternative subsets</param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if every /// if every
/// <see cref="Antlr4.Runtime.Sharpen.BitSet"/> /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
/// in /// in
/// <code>altsets</code> /// <paramref name="altsets"/>
/// has /// has
/// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see> /// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see>
/// &gt; 1, otherwise /// &gt; 1, otherwise
/// <code>false</code> /// <see langword="false"/>
/// </returns> /// </returns>
public static bool AllSubsetsConflict(IEnumerable<BitSet> altsets) public static bool AllSubsetsConflict(IEnumerable<BitSet> altsets)
{ {
@ -681,22 +681,22 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Determines if any single alternative subset in /// Determines if any single alternative subset in
/// <code>altsets</code> /// <paramref name="altsets"/>
/// contains /// contains
/// exactly one alternative. /// exactly one alternative.
/// </summary> /// </summary>
/// <param name="altsets">a collection of alternative subsets</param> /// <param name="altsets">a collection of alternative subsets</param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if /// if
/// <code>altsets</code> /// <paramref name="altsets"/>
/// contains a /// contains a
/// <see cref="Antlr4.Runtime.Sharpen.BitSet"/> /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
/// with /// with
/// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see> /// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see>
/// 1, otherwise /// 1, otherwise
/// <code>false</code> /// <see langword="false"/>
/// </returns> /// </returns>
public static bool HasNonConflictingAltSet(IEnumerable<BitSet> altsets) public static bool HasNonConflictingAltSet(IEnumerable<BitSet> altsets)
{ {
@ -712,22 +712,22 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Determines if any single alternative subset in /// Determines if any single alternative subset in
/// <code>altsets</code> /// <paramref name="altsets"/>
/// contains /// contains
/// more than one alternative. /// more than one alternative.
/// </summary> /// </summary>
/// <param name="altsets">a collection of alternative subsets</param> /// <param name="altsets">a collection of alternative subsets</param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if /// if
/// <code>altsets</code> /// <paramref name="altsets"/>
/// contains a /// contains a
/// <see cref="Antlr4.Runtime.Sharpen.BitSet"/> /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
/// with /// with
/// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see> /// <see cref="Antlr4.Runtime.Sharpen.BitSet.Cardinality()">cardinality</see>
/// &gt; 1, otherwise /// &gt; 1, otherwise
/// <code>false</code> /// <see langword="false"/>
/// </returns> /// </returns>
public static bool HasConflictingAltSet(IEnumerable<BitSet> altsets) public static bool HasConflictingAltSet(IEnumerable<BitSet> altsets)
{ {
@ -743,18 +743,18 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Determines if every alternative subset in /// Determines if every alternative subset in
/// <code>altsets</code> /// <paramref name="altsets"/>
/// is equivalent. /// is equivalent.
/// </summary> /// </summary>
/// <param name="altsets">a collection of alternative subsets</param> /// <param name="altsets">a collection of alternative subsets</param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if every member of /// if every member of
/// <code>altsets</code> /// <paramref name="altsets"/>
/// is equal to the /// is equal to the
/// others, otherwise /// others, otherwise
/// <code>false</code> /// <see langword="false"/>
/// </returns> /// </returns>
public static bool AllSubsetsEqual(IEnumerable<BitSet> altsets) public static bool AllSubsetsEqual(IEnumerable<BitSet> altsets)
{ {
@ -774,7 +774,7 @@ namespace Antlr4.Runtime.Atn
/// <summary> /// <summary>
/// Returns the unique alternative predicted by all alternative subsets in /// Returns the unique alternative predicted by all alternative subsets in
/// <code>altsets</code> /// <paramref name="altsets"/>
/// . If no such alternative exists, this method returns /// . If no such alternative exists, this method returns
/// <see cref="ATN.InvalidAltNumber"/> /// <see cref="ATN.InvalidAltNumber"/>
/// . /// .
@ -799,13 +799,13 @@ namespace Antlr4.Runtime.Atn
/// alternative subsets. This method returns the union of each /// alternative subsets. This method returns the union of each
/// <see cref="Antlr4.Runtime.Sharpen.BitSet"/> /// <see cref="Antlr4.Runtime.Sharpen.BitSet"/>
/// in /// in
/// <code>altsets</code> /// <paramref name="altsets"/>
/// . /// .
/// </remarks> /// </remarks>
/// <param name="altsets">a collection of alternative subsets</param> /// <param name="altsets">a collection of alternative subsets</param>
/// <returns> /// <returns>
/// the set of represented alternatives in /// the set of represented alternatives in
/// <code>altsets</code> /// <paramref name="altsets"/>
/// </returns> /// </returns>
public static BitSet GetAlts(IEnumerable<BitSet> altsets) public static BitSet GetAlts(IEnumerable<BitSet> altsets)
{ {
@ -821,9 +821,9 @@ namespace Antlr4.Runtime.Atn
/// <remarks> /// <remarks>
/// This function gets the conflicting alt subsets from a configuration set. /// This function gets the conflicting alt subsets from a configuration set.
/// For each configuration /// For each configuration
/// <code>c</code> /// <c>c</c>
/// in /// in
/// <code>configs</code> /// <paramref name="configs"/>
/// : /// :
/// <pre> /// <pre>
/// map[c] U= c. /// map[c] U= c.
@ -853,9 +853,9 @@ namespace Antlr4.Runtime.Atn
/// <remarks> /// <remarks>
/// Get a map from state to alt subset from a configuration set. For each /// Get a map from state to alt subset from a configuration set. For each
/// configuration /// configuration
/// <code>c</code> /// <c>c</c>
/// in /// in
/// <code>configs</code> /// <paramref name="configs"/>
/// : /// :
/// <pre> /// <pre>
/// map[c. /// map[c.

16
runtime/CSharp/Antlr4.Runtime/Atn/SemanticContext.cs
View File

@ -45,9 +45,9 @@ namespace Antlr4.Runtime.Atn
/// A tree structure used to record the semantic context in which /// A tree structure used to record the semantic context in which
/// an ATN configuration is valid. It's either a single predicate, /// an ATN configuration is valid. It's either a single predicate,
/// a conjunction /// a conjunction
/// <code>p1&amp;&amp;p2</code> /// <c>p1&amp;&amp;p2</c>
/// , or a sum of products /// , or a sum of products
/// <code>p1||p2</code> /// <c>p1||p2</c>
/// . /// .
/// <p>I have scoped the /// <p>I have scoped the
/// <see cref="AND"/> /// <see cref="AND"/>
@ -66,7 +66,7 @@ namespace Antlr4.Runtime.Atn
/// <see cref="SemanticContext"/> /// <see cref="SemanticContext"/>
/// , which is semantically equivalent to /// , which is semantically equivalent to
/// a predicate of the form /// a predicate of the form
/// <code/> /// <c/>
/// ///
/// true}?}. /// true}?}.
/// </summary> /// </summary>
@ -101,21 +101,21 @@ namespace Antlr4.Runtime.Atn
/// <li> /// <li>
/// <see cref="None"/> /// <see cref="None"/>
/// : if the predicate simplifies to /// : if the predicate simplifies to
/// <code>true</code> /// <see langword="true"/>
/// after /// after
/// precedence predicates are evaluated.</li> /// precedence predicates are evaluated.</li>
/// <li> /// <li>
/// <code>null</code> /// <see langword="null"/>
/// : if the predicate simplifies to /// : if the predicate simplifies to
/// <code>false</code> /// <see langword="false"/>
/// after /// after
/// precedence predicates are evaluated.</li> /// precedence predicates are evaluated.</li>
/// <li> /// <li>
/// <code>this</code> /// <c>this</c>
/// : if the semantic context is not changed as a result of /// : if the semantic context is not changed as a result of
/// precedence predicate evaluation.</li> /// precedence predicate evaluation.</li>
/// <li>A non- /// <li>A non-
/// <code>null</code> /// <see langword="null"/>
/// ///
/// <see cref="SemanticContext"/> /// <see cref="SemanticContext"/>
/// : the new simplified /// : the new simplified

6
runtime/CSharp/Antlr4.Runtime/Atn/Transition.cs
View File

@ -75,15 +75,15 @@ namespace Antlr4.Runtime.Atn
/// <remarks> /// <remarks>
/// Determines if the transition is an "epsilon" transition. /// Determines if the transition is an "epsilon" transition.
/// <p>The default implementation returns /// <p>The default implementation returns
/// <code>false</code> /// <see langword="false"/>
/// .</p> /// .</p>
/// </remarks> /// </remarks>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if traversing this transition in the ATN does not /// if traversing this transition in the ATN does not
/// consume an input symbol; otherwise, /// consume an input symbol; otherwise,
/// <code>false</code> /// <see langword="false"/>
/// if traversing this /// if traversing this
/// transition consumes (matches) an input symbol. /// transition consumes (matches) an input symbol.
/// </returns> /// </returns>

4
runtime/CSharp/Antlr4.Runtime/BailErrorStrategy.cs
View File

@ -62,7 +62,7 @@ namespace Antlr4.Runtime
/// when the result will be ignored either way.</li> /// when the result will be ignored either way.</li>
/// </ul> /// </ul>
/// <p> /// <p>
/// <code>myparser.setErrorHandler(new BailErrorStrategy());</code> /// <c>myparser.setErrorHandler(new BailErrorStrategy());</c>
/// </p> /// </p>
/// </summary> /// </summary>
/// <seealso cref="Parser.ErrorHandler"/> /// <seealso cref="Parser.ErrorHandler"/>
@ -70,7 +70,7 @@ namespace Antlr4.Runtime
{ {
/// <summary> /// <summary>
/// Instead of recovering from exception /// Instead of recovering from exception
/// <code>e</code> /// <paramref name="e"/>
/// , re-throw it wrapped /// , re-throw it wrapped
/// in a /// in a
/// <see cref="ParseCanceledException"/> /// <see cref="ParseCanceledException"/>

46
runtime/CSharp/Antlr4.Runtime/BufferedTokenStream.cs
View File

@ -73,7 +73,7 @@ namespace Antlr4.Runtime
/// <see cref="fetchedEOF"/> /// <see cref="fetchedEOF"/>
/// is set /// is set
/// to /// to
/// <code>true</code> /// <see langword="true"/>
/// . /// .
/// </remarks> /// </remarks>
protected internal IList<IToken> tokens = new List<IToken>(100); protected internal IList<IToken> tokens = new List<IToken>(100);
@ -85,9 +85,9 @@ namespace Antlr4.Runtime
/// <see cref="Consume()"/> /// <see cref="Consume()"/>
/// ). /// ).
/// <see cref="tokens"/> /// <see cref="tokens"/>
/// <code>[</code> /// <c>[</c>
/// <see cref="p"/> /// <see cref="p"/>
/// <code>]</code> /// <c>]</c>
/// should be /// should be
/// <see cref="Lt(int)">LT(1)</see> /// <see cref="Lt(int)">LT(1)</see>
/// . /// .
@ -221,16 +221,16 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Make sure index /// Make sure index
/// <code>i</code> /// <paramref name="i"/>
/// in tokens has a token. /// in tokens has a token.
/// </summary> /// </summary>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if a token is located at index /// if a token is located at index
/// <code>i</code> /// <paramref name="i"/>
/// , otherwise /// , otherwise
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
/// <seealso cref="Get(int)"/> /// <seealso cref="Get(int)"/>
@ -250,7 +250,7 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Add /// Add
/// <code>n</code> /// <paramref name="n"/>
/// elements to buffer. /// elements to buffer.
/// </summary> /// </summary>
/// <returns>The actual number of elements added to the buffer.</returns> /// <returns>The actual number of elements added to the buffer.</returns>
@ -359,7 +359,7 @@ namespace Antlr4.Runtime
/// Allowed derived classes to modify the behavior of operations which change /// Allowed derived classes to modify the behavior of operations which change
/// the current stream position by adjusting the target token index of a seek /// the current stream position by adjusting the target token index of a seek
/// operation. The default implementation simply returns /// operation. The default implementation simply returns
/// <code>i</code> /// <paramref name="i"/>
/// . If an /// . If an
/// exception is thrown in this method, the current stream index should not be /// exception is thrown in this method, the current stream index should not be
/// changed. /// changed.
@ -410,12 +410,12 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Given a start and stop index, return a /// Given a start and stop index, return a
/// <code>List</code> /// <c>List</c>
/// of all tokens in /// of all tokens in
/// the token type /// the token type
/// <code>BitSet</code> /// <c>BitSet</c>
/// . Return /// . Return
/// <code>null</code> /// <see langword="null"/>
/// if no tokens were found. This /// if no tokens were found. This
/// method looks at both on and off channel tokens. /// method looks at both on and off channel tokens.
/// </summary> /// </summary>
@ -458,12 +458,12 @@ namespace Antlr4.Runtime
/// <remarks> /// <remarks>
/// Given a starting index, return the index of the next token on channel. /// Given a starting index, return the index of the next token on channel.
/// Return /// Return
/// <code>i</code> /// <paramref name="i"/>
/// if /// if
/// <code>tokens[i]</code> /// <c>tokens[i]</c>
/// is on channel. Return the index of /// is on channel. Return the index of
/// the EOF token if there are no tokens on channel between /// the EOF token if there are no tokens on channel between
/// <code>i</code> /// <paramref name="i"/>
/// and /// and
/// EOF. /// EOF.
/// </remarks> /// </remarks>
@ -495,16 +495,16 @@ namespace Antlr4.Runtime
/// <remarks> /// <remarks>
/// Given a starting index, return the index of the previous token on /// Given a starting index, return the index of the previous token on
/// channel. Return /// channel. Return
/// <code>i</code> /// <paramref name="i"/>
/// if /// if
/// <code>tokens[i]</code> /// <c>tokens[i]</c>
/// is on channel. Return -1 /// is on channel. Return -1
/// if there are no tokens on channel between /// if there are no tokens on channel between
/// <code>i</code> /// <paramref name="i"/>
/// and 0. /// and 0.
/// <p> /// <p>
/// If /// If
/// <code>i</code> /// <paramref name="i"/>
/// specifies an index at or after the EOF token, the EOF token /// 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 /// index is returned. This is due to the fact that the EOF token is treated
/// as though it were on every channel.</p> /// as though it were on every channel.</p>
@ -535,9 +535,9 @@ namespace Antlr4.Runtime
/// <see cref="Lexer.DefaultTokenChannel"/> /// <see cref="Lexer.DefaultTokenChannel"/>
/// or /// or
/// EOF. If /// EOF. If
/// <code>channel</code> /// <paramref name="channel"/>
/// is /// is
/// <code>-1</code> /// <c>-1</c>
/// , find any non default channel token. /// , find any non default channel token.
/// </summary> /// </summary>
public virtual IList<IToken> GetHiddenTokensToRight(int tokenIndex, int channel) public virtual IList<IToken> GetHiddenTokensToRight(int tokenIndex, int channel)
@ -579,9 +579,9 @@ namespace Antlr4.Runtime
/// <see cref="Lexer.DefaultTokenChannel"/> /// <see cref="Lexer.DefaultTokenChannel"/>
/// . /// .
/// If /// If
/// <code>channel</code> /// <paramref name="channel"/>
/// is /// is
/// <code>-1</code> /// <c>-1</c>
/// , find any non default channel token. /// , find any non default channel token.
/// </summary> /// </summary>
public virtual IList<IToken> GetHiddenTokensToLeft(int tokenIndex, int channel) public virtual IList<IToken> GetHiddenTokensToLeft(int tokenIndex, int channel)

6
runtime/CSharp/Antlr4.Runtime/CommonToken.cs
View File

@ -159,7 +159,7 @@ namespace Antlr4.Runtime
/// . /// .
/// <p> /// <p>
/// If /// If
/// <code>oldToken</code> /// <paramref name="oldToken"/>
/// is also a /// is also a
/// <see cref="CommonToken"/> /// <see cref="CommonToken"/>
/// instance, the newly /// instance, the newly
@ -234,7 +234,7 @@ namespace Antlr4.Runtime
/// <summary>Explicitly set the text for this token.</summary> /// <summary>Explicitly set the text for this token.</summary>
/// <remarks> /// <remarks>
/// Explicitly set the text for this token. If {code text} is not /// Explicitly set the text for this token. If {code text} is not
/// <code>null</code> /// <see langword="null"/>
/// , then /// , then
/// <see cref="Text()"/> /// <see cref="Text()"/>
/// will return this value rather than /// will return this value rather than
@ -242,7 +242,7 @@ namespace Antlr4.Runtime
/// </remarks> /// </remarks>
/// <value> /// <value>
/// The explicit text of the token, or /// The explicit text of the token, or
/// <code>null</code> /// <see langword="null"/>
/// if the text /// if the text
/// should be obtained from the input along with the start and stop indexes /// should be obtained from the input along with the start and stop indexes
/// of the token. /// of the token.

8
runtime/CSharp/Antlr4.Runtime/CommonTokenFactory.cs
View File

@ -73,7 +73,7 @@ namespace Antlr4.Runtime
/// input stream implementation. /// input stream implementation.
/// <p> /// <p>
/// The default value is /// The default value is
/// <code>false</code> /// <see langword="false"/>
/// to avoid the performance and memory /// to avoid the performance and memory
/// overhead of copying text for every token unless explicitly requested.</p> /// overhead of copying text for every token unless explicitly requested.</p>
/// </summary> /// </summary>
@ -87,9 +87,9 @@ namespace Antlr4.Runtime
/// . /// .
/// <p> /// <p>
/// When /// When
/// <code>copyText</code> /// <paramref name="copyText"/>
/// is /// is
/// <code>false</code> /// <see langword="false"/>
/// , the /// , the
/// <see cref="Default"/> /// <see cref="Default"/>
/// instance /// instance
@ -111,7 +111,7 @@ namespace Antlr4.Runtime
/// with /// with
/// <see cref="copyText"/> /// <see cref="copyText"/>
/// set to /// set to
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// <p> /// <p>
/// The /// The

6
runtime/CSharp/Antlr4.Runtime/CommonTokenStream.cs
View File

@ -56,7 +56,7 @@ namespace Antlr4.Runtime
/// ( /// (
/// <see cref="TokenConstants.DefaultChannel"/> /// <see cref="TokenConstants.DefaultChannel"/>
/// ), but may be reassigned by using the /// ), but may be reassigned by using the
/// <code>-&gt;channel(HIDDEN)</code> /// <c>-&gt;channel(HIDDEN)</c>
/// lexer command, or by using an embedded action to /// lexer command, or by using an embedded action to
/// call /// call
/// <see cref="Lexer.Channel"/> /// <see cref="Lexer.Channel"/>
@ -64,7 +64,7 @@ namespace Antlr4.Runtime
/// </p> /// </p>
/// <p> /// <p>
/// Note: lexer rules which use the /// Note: lexer rules which use the
/// <code>-&gt;skip</code> /// <c>-&gt;skip</c>
/// lexer command or call /// lexer command or call
/// <see cref="Lexer.Skip()"/> /// <see cref="Lexer.Skip()"/>
/// do not produce tokens at all, so input text matched by /// do not produce tokens at all, so input text matched by
@ -105,7 +105,7 @@ namespace Antlr4.Runtime
/// source and filtering tokens to the specified channel. Only tokens whose /// source and filtering tokens to the specified channel. Only tokens whose
/// <see cref="IToken.Channel()"/> /// <see cref="IToken.Channel()"/>
/// matches /// matches
/// <code>channel</code> /// <paramref name="channel"/>
/// or have the /// or have the
/// <see cref="IToken.Type()"/> /// <see cref="IToken.Type()"/>
/// equal to /// equal to

6
runtime/CSharp/Antlr4.Runtime/ConsoleErrorListener.cs
View File

@ -52,11 +52,11 @@ namespace Antlr4.Runtime
/// <see cref="System.Console.Error"/> /// <see cref="System.Console.Error"/>
/// containing the /// containing the
/// values of /// values of
/// <code>line</code> /// <paramref name="line"/>
/// , /// ,
/// <code>charPositionInLine</code> /// <paramref name="charPositionInLine"/>
/// , and /// , and
/// <code>msg</code> /// <paramref name="msg"/>
/// using /// using
/// the following format.</p> /// the following format.</p>
/// <pre> /// <pre>

62
runtime/CSharp/Antlr4.Runtime/DefaultErrorStrategy.cs
View File

@ -132,7 +132,7 @@ namespace Antlr4.Runtime
/// in error recovery mode. Otherwise, it calls /// in error recovery mode. Otherwise, it calls
/// <see cref="BeginErrorCondition(Parser)"/> /// <see cref="BeginErrorCondition(Parser)"/>
/// and dispatches the reporting task based on the runtime type of /// and dispatches the reporting task based on the runtime type of
/// <code>e</code> /// <paramref name="e"/>
/// according to the following table.</p> /// according to the following table.</p>
/// <ul> /// <ul>
/// <li> /// <li>
@ -253,9 +253,9 @@ namespace Antlr4.Runtime
/// rule and uses the default error recovery, which consumes until the /// rule and uses the default error recovery, which consumes until the
/// resynchronization set of the current rule. /// resynchronization set of the current rule.
/// <p>If the sub rule is optional ( /// <p>If the sub rule is optional (
/// <code>(...)?</code> /// <c>(...)?</c>
/// , /// ,
/// <code>(...)*</code> /// <c>(...)*</c>
/// , or block /// , or block
/// with an empty alternative), then the expected set includes what follows /// with an empty alternative), then the expected set includes what follows
/// the subrule.</p> /// the subrule.</p>
@ -407,10 +407,10 @@ namespace Antlr4.Runtime
/// This method is called to report a syntax error which requires the removal /// 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 /// of a token from the input stream. At the time this method is called, the
/// erroneous symbol is current /// erroneous symbol is current
/// <code>LT(1)</code> /// <c>LT(1)</c>
/// symbol and has not yet been /// symbol and has not yet been
/// removed from the input stream. When this method returns, /// removed from the input stream. When this method returns,
/// <code>recognizer</code> /// <paramref name="recognizer"/>
/// is in error recovery mode. /// is in error recovery mode.
/// <p>This method is called when /// <p>This method is called when
/// <see cref="SingleTokenDeletion(Parser)"/> /// <see cref="SingleTokenDeletion(Parser)"/>
@ -449,7 +449,7 @@ namespace Antlr4.Runtime
/// insertion of a missing token into the input stream. At the time this /// 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 is called, the missing token has not yet been inserted. When this
/// method returns, /// method returns,
/// <code>recognizer</code> /// <paramref name="recognizer"/>
/// is in error recovery mode. /// is in error recovery mode.
/// <p>This method is called when /// <p>This method is called when
/// <see cref="SingleTokenInsertion(Parser)"/> /// <see cref="SingleTokenInsertion(Parser)"/>
@ -487,26 +487,26 @@ namespace Antlr4.Runtime
/// .</p> /// .</p>
/// <p><strong>EXTRA TOKEN</strong> (single token deletion)</p> /// <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>
/// <p> /// <p>
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// is not what we are looking for. If /// is not what we are looking for. If
/// <code>LA(2)</code> /// <c>LA(2)</c>
/// has the /// has the
/// right token, however, then assume /// right token, however, then assume
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// is some extra spurious /// is some extra spurious
/// token and delete it. Then consume and return the next token (which was /// token and delete it. Then consume and return the next token (which was
/// the /// the
/// <code>LA(2)</code> /// <c>LA(2)</c>
/// token) as the successful result of the match operation.</p> /// token) as the successful result of the match operation.</p>
/// <p>This recovery strategy is implemented by /// <p>This recovery strategy is implemented by
/// <see cref="SingleTokenDeletion(Parser)"/> /// <see cref="SingleTokenDeletion(Parser)"/>
/// .</p> /// .</p>
/// <p><strong>MISSING TOKEN</strong> (single token insertion)</p> /// <p><strong>MISSING TOKEN</strong> (single token insertion)</p>
/// <p>If current token (at /// <p>If current token (at
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// ) is consistent with what could come /// ) is consistent with what could come
/// after the expected /// after the expected
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// token, then assume the token is missing /// token, then assume the token is missing
/// and use the parser's /// and use the parser's
/// <see cref="ITokenFactory"/> /// <see cref="ITokenFactory"/>
@ -518,19 +518,19 @@ namespace Antlr4.Runtime
/// .</p> /// .</p>
/// <p><strong>EXAMPLE</strong></p> /// <p><strong>EXAMPLE</strong></p>
/// <p>For example, Input /// <p>For example, Input
/// <code>i=(3;</code> /// <c>i=(3;</c>
/// is clearly missing the /// is clearly missing the
/// <code>')'</code> /// <c>')'</c>
/// . When /// . When
/// the parser returns from the nested call to /// the parser returns from the nested call to
/// <code>expr</code> /// <c>expr</c>
/// , it will have /// , it will have
/// call chain:</p> /// call chain:</p>
/// <pre> /// <pre>
/// stat &#x2192; expr &#x2192; atom /// stat &#x2192; expr &#x2192; atom
/// </pre> /// </pre>
/// and it will be trying to match the /// and it will be trying to match the
/// <code>')'</code> /// <c>')'</c>
/// at this point in the /// at this point in the
/// derivation: /// derivation:
/// <pre> /// <pre>
@ -538,21 +538,21 @@ namespace Antlr4.Runtime
/// ^ /// ^
/// </pre> /// </pre>
/// The attempt to match /// The attempt to match
/// <code>')'</code> /// <c>')'</c>
/// will fail when it sees /// will fail when it sees
/// <code>';'</code> /// <c>';'</c>
/// and /// and
/// call /// call
/// <see cref="RecoverInline(Parser)"/> /// <see cref="RecoverInline(Parser)"/>
/// . To recover, it sees that /// . To recover, it sees that
/// <code>LA(1)==';'</code> /// <c>LA(1)==';'</c>
/// is in the set of tokens that can follow the /// is in the set of tokens that can follow the
/// <code>')'</code> /// <c>')'</c>
/// token reference /// token reference
/// in rule /// in rule
/// <code>atom</code> /// <c>atom</c>
/// . It can assume that you forgot the /// . It can assume that you forgot the
/// <code>')'</code> /// <c>')'</c>
/// . /// .
/// </summary> /// </summary>
/// <exception cref="Antlr4.Runtime.RecognitionException"/> /// <exception cref="Antlr4.Runtime.RecognitionException"/>
@ -587,29 +587,29 @@ namespace Antlr4.Runtime
/// if the single-token /// if the single-token
/// deletion strategy fails to recover from the mismatched input. If this /// deletion strategy fails to recover from the mismatched input. If this
/// method returns /// method returns
/// <code>true</code> /// <see langword="true"/>
/// , /// ,
/// <code>recognizer</code> /// <paramref name="recognizer"/>
/// will be in error recovery /// will be in error recovery
/// mode. /// mode.
/// <p>This method determines whether or not single-token insertion is viable by /// <p>This method determines whether or not single-token insertion is viable by
/// checking if the /// checking if the
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// input symbol could be successfully matched /// input symbol could be successfully matched
/// if it were instead the /// if it were instead the
/// <code>LA(2)</code> /// <c>LA(2)</c>
/// symbol. If this method returns /// symbol. If this method returns
/// <code>true</code> /// <see langword="true"/>
/// , the caller is responsible for creating and inserting a /// , the caller is responsible for creating and inserting a
/// token with the correct type to produce this behavior.</p> /// token with the correct type to produce this behavior.</p>
/// </remarks> /// </remarks>
/// <param name="recognizer">the parser instance</param> /// <param name="recognizer">the parser instance</param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if single-token insertion is a viable recovery /// if single-token insertion is a viable recovery
/// strategy for the current mismatched input, otherwise /// strategy for the current mismatched input, otherwise
/// <code>false</code> /// <see langword="false"/>
/// </returns> /// </returns>
protected internal virtual bool SingleTokenInsertion(Parser recognizer) protected internal virtual bool SingleTokenInsertion(Parser recognizer)
{ {
@ -641,7 +641,7 @@ namespace Antlr4.Runtime
/// to attempt to recover /// to attempt to recover
/// from mismatched input. If this method returns null, the parser and error /// from mismatched input. If this method returns null, the parser and error
/// handler state will not have changed. If this method returns non-null, /// handler state will not have changed. If this method returns non-null,
/// <code>recognizer</code> /// <paramref name="recognizer"/>
/// will <em>not</em> be in error recovery mode since the /// will <em>not</em> be in error recovery mode since the
/// returned token was a successful match. /// returned token was a successful match.
/// <p>If the single-token deletion is successful, this method calls /// <p>If the single-token deletion is successful, this method calls
@ -660,7 +660,7 @@ namespace Antlr4.Runtime
/// <see cref="IToken"/> /// <see cref="IToken"/>
/// instance if single-token /// instance if single-token
/// deletion successfully recovers from the mismatched input, otherwise /// deletion successfully recovers from the mismatched input, otherwise
/// <code>null</code> /// <see langword="null"/>
/// </returns> /// </returns>
[return: Nullable] [return: Nullable]
protected internal virtual IToken SingleTokenDeletion(Parser recognizer) protected internal virtual IToken SingleTokenDeletion(Parser recognizer)

20
runtime/CSharp/Antlr4.Runtime/Dfa/DFA.cs
View File

@ -67,9 +67,9 @@ namespace Antlr4.Runtime.Dfa
private int nextStateNumber; private int nextStateNumber;
/// <summary> /// <summary>
/// <code>true</code> /// <see langword="true"/>
/// if this DFA is for a precedence decision; otherwise, /// if this DFA is for a precedence decision; otherwise,
/// <code>false</code> /// <see langword="false"/>
/// . This is the backing field for <see cref="IsPrecedenceDfa"/>. /// . This is the backing field for <see cref="IsPrecedenceDfa"/>.
/// </summary> /// </summary>
private volatile bool precedenceDfa; private volatile bool precedenceDfa;
@ -100,9 +100,9 @@ namespace Antlr4.Runtime.Dfa
/// </remarks> /// </remarks>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if this is a precedence DFA; otherwise, /// if this is a precedence DFA; otherwise,
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
/// <seealso cref="Antlr4.Runtime.Parser.Precedence()"/> /// <seealso cref="Antlr4.Runtime.Parser.Precedence()"/>
@ -116,13 +116,13 @@ namespace Antlr4.Runtime.Dfa
/// <see cref="states"/> /// <see cref="states"/>
/// map is cleared</li> /// map is cleared</li>
/// <li>If /// <li>If
/// <code>precedenceDfa</code> /// <c>precedenceDfa</c>
/// is /// is
/// <code>false</code> /// <see langword="false"/>
/// , the initial state /// , the initial state
/// <see cref="s0"/> /// <see cref="s0"/>
/// is set to /// is set to
/// <code>null</code> /// <see langword="null"/>
/// ; otherwise, it is initialized to a new /// ; otherwise, it is initialized to a new
/// <see cref="DFAState"/> /// <see cref="DFAState"/>
/// with an empty outgoing /// with an empty outgoing
@ -136,9 +136,9 @@ namespace Antlr4.Runtime.Dfa
/// </remarks> /// </remarks>
/// <value> /// <value>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if this is a precedence DFA; otherwise, /// if this is a precedence DFA; otherwise,
/// <code>false</code> /// <see langword="false"/>
/// </value> /// </value>
public bool IsPrecedenceDfa public bool IsPrecedenceDfa
{ {
@ -182,7 +182,7 @@ namespace Antlr4.Runtime.Dfa
/// <param name="precedence">The current precedence.</param> /// <param name="precedence">The current precedence.</param>
/// <returns> /// <returns>
/// The start state corresponding to the specified precedence, or /// The start state corresponding to the specified precedence, or
/// <code>null</code> /// <see langword="null"/>
/// if no start state exists for the specified precedence. /// if no start state exists for the specified precedence.
/// </returns> /// </returns>
/// <exception cref="System.InvalidOperationException">if this is not a precedence DFA.</exception> /// <exception cref="System.InvalidOperationException">if this is not a precedence DFA.</exception>

4
runtime/CSharp/Antlr4.Runtime/Dfa/DFAState.cs
View File

@ -71,7 +71,7 @@ namespace Antlr4.Runtime.Dfa
public readonly ATNConfigSet configs; public readonly ATNConfigSet configs;
/// <summary> /// <summary>
/// <code>edges.get(symbol)</code> /// <c>edges.get(symbol)</c>
/// points to target of symbol. /// points to target of symbol.
/// </summary> /// </summary>
[Nullable] [Nullable]
@ -89,7 +89,7 @@ namespace Antlr4.Runtime.Dfa
/// <see cref="Antlr4.Runtime.Atn.ATN.InvalidAltNumber"/> /// <see cref="Antlr4.Runtime.Atn.ATN.InvalidAltNumber"/>
/// when /// when
/// <see cref="predicates"/> /// <see cref="predicates"/>
/// <code>!=null</code> /// <c>!=null</c>
/// . /// .
/// </summary> /// </summary>
public int prediction; public int prediction;

12
runtime/CSharp/Antlr4.Runtime/DiagnosticErrorListener.cs
View File

@ -62,7 +62,7 @@ namespace Antlr4.Runtime
{ {
/// <summary> /// <summary>
/// When /// When
/// <code>true</code> /// <see langword="true"/>
/// , only exactly known ambiguities are reported. /// , only exactly known ambiguities are reported.
/// </summary> /// </summary>
protected internal readonly bool exactOnly; protected internal readonly bool exactOnly;
@ -86,9 +86,9 @@ namespace Antlr4.Runtime
/// </summary> /// </summary>
/// <param name="exactOnly"> /// <param name="exactOnly">
/// ///
/// <code>true</code> /// <see langword="true"/>
/// to report only exact ambiguities, otherwise /// to report only exact ambiguities, otherwise
/// <code>false</code> /// <see langword="false"/>
/// to report all ambiguities. /// to report all ambiguities.
/// </param> /// </param>
public DiagnosticErrorListener(bool exactOnly) public DiagnosticErrorListener(bool exactOnly)
@ -162,12 +162,12 @@ namespace Antlr4.Runtime
/// <param name="configs">The conflicting or ambiguous configuration set.</param> /// <param name="configs">The conflicting or ambiguous configuration set.</param>
/// <returns> /// <returns>
/// Returns /// Returns
/// <code>reportedAlts</code> /// <paramref name="reportedAlts"/>
/// if it is not /// if it is not
/// <code>null</code> /// <see langword="null"/>
/// , otherwise /// , otherwise
/// returns the set of alternatives represented in /// returns the set of alternatives represented in
/// <code>configs</code> /// <paramref name="configs"/>
/// . /// .
/// </returns> /// </returns>
[return: NotNull] [return: NotNull]

2
runtime/CSharp/Antlr4.Runtime/IAntlrErrorListener`1.cs
View File

@ -64,7 +64,7 @@ namespace Antlr4.Runtime
/// The offending token in the input token /// The offending token in the input token
/// stream, unless recognizer is a lexer (then it's null). If /// stream, unless recognizer is a lexer (then it's null). If
/// no viable alternative error, /// no viable alternative error,
/// <code>e</code> /// <paramref name="e"/>
/// has token at which we /// has token at which we
/// started production for the decision. /// started production for the decision.
/// </param> /// </param>

14
runtime/CSharp/Antlr4.Runtime/IAntlrErrorStrategy.cs
View File

@ -56,7 +56,7 @@ namespace Antlr4.Runtime
{ {
/// <summary> /// <summary>
/// Reset the error handler state for the specified /// Reset the error handler state for the specified
/// <code>recognizer</code> /// <paramref name="recognizer"/>
/// . /// .
/// </summary> /// </summary>
/// <param name="recognizer">the parser instance</param> /// <param name="recognizer">the parser instance</param>
@ -89,7 +89,7 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// This method is called to recover from exception /// This method is called to recover from exception
/// <code>e</code> /// <paramref name="e"/>
/// . This method is /// . This method is
/// called after /// called after
/// <see cref="ReportError(Parser, RecognitionException)"/> /// <see cref="ReportError(Parser, RecognitionException)"/>
@ -115,9 +115,9 @@ namespace Antlr4.Runtime
/// <see cref="Sync(Parser)"/> /// <see cref="Sync(Parser)"/>
/// after /// after
/// entering the decision state of a closure block ( /// entering the decision state of a closure block (
/// <code>(...)*</code> /// <c>(...)*</c>
/// or /// or
/// <code>(...)+</code> /// <c>(...)+</c>
/// ).</p> /// ).</p>
/// <p>For an implementation based on Jim Idle's "magic sync" mechanism, see /// <p>For an implementation based on Jim Idle's "magic sync" mechanism, see
/// <see cref="DefaultErrorStrategy.Sync(Parser)"/> /// <see cref="DefaultErrorStrategy.Sync(Parser)"/>
@ -135,7 +135,7 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Tests whether or not /// Tests whether or not
/// <code>recognizer</code> /// <paramref name="recognizer"/>
/// is in the process of recovering /// is in the process of recovering
/// from an error. In error recovery mode, /// from an error. In error recovery mode,
/// <see cref="Parser.Consume()"/> /// <see cref="Parser.Consume()"/>
@ -149,10 +149,10 @@ namespace Antlr4.Runtime
/// <param name="recognizer">the parser instance</param> /// <param name="recognizer">the parser instance</param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if the parser is currently recovering from a parse /// if the parser is currently recovering from a parse
/// error, otherwise /// error, otherwise
/// <code>false</code> /// <see langword="false"/>
/// </returns> /// </returns>
bool InErrorRecoveryMode(Parser recognizer); bool InErrorRecoveryMode(Parser recognizer);

12
runtime/CSharp/Antlr4.Runtime/ICharStream.cs
View File

@ -45,7 +45,7 @@ namespace Antlr4.Runtime
/// This method returns the text for a range of characters within this input /// 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 /// stream. This method is guaranteed to not throw an exception if the
/// specified /// specified
/// <code>interval</code> /// <paramref name="interval"/>
/// lies entirely within a marked range. For more /// lies entirely within a marked range. For more
/// information about marked ranges, see /// information about marked ranges, see
/// <see cref="IIntStream.Mark()"/> /// <see cref="IIntStream.Mark()"/>
@ -55,17 +55,17 @@ namespace Antlr4.Runtime
/// <returns>the text of the specified interval</returns> /// <returns>the text of the specified interval</returns>
/// <exception cref="System.ArgumentNullException"> /// <exception cref="System.ArgumentNullException">
/// if /// if
/// <code>interval</code> /// <paramref name="interval"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// </exception> /// </exception>
/// <exception cref="System.ArgumentException"> /// <exception cref="System.ArgumentException">
/// if /// if
/// <code>interval.a &lt; 0</code> /// <c>interval.a &lt; 0</c>
/// , or if /// , or if
/// <code>interval.b &lt; interval.a - 1</code> /// <c>interval.b &lt; interval.a - 1</c>
/// , or if /// , or if
/// <code>interval.b</code> /// <c>interval.b</c>
/// lies at or /// lies at or
/// past the end of the stream /// past the end of the stream
/// </exception> /// </exception>

72
runtime/CSharp/Antlr4.Runtime/IIntStream.cs
View File

@ -65,18 +65,18 @@ namespace Antlr4.Runtime
/// <li><strong>Forward movement:</strong> The value of /// <li><strong>Forward movement:</strong> The value of
/// <see cref="Index()">index()</see> /// <see cref="Index()">index()</see>
/// before calling this method is less than the value of /// before calling this method is less than the value of
/// <code>index()</code> /// <c>index()</c>
/// after calling this method.</li> /// after calling this method.</li>
/// <li><strong>Ordered lookahead:</strong> The value of /// <li><strong>Ordered lookahead:</strong> The value of
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// before /// before
/// calling this method becomes the value of /// calling this method becomes the value of
/// <code>LA(-1)</code> /// <c>LA(-1)</c>
/// after calling /// after calling
/// this method.</li> /// this method.</li>
/// </ul> /// </ul>
/// Note that calling this method does not guarantee that /// Note that calling this method does not guarantee that
/// <code>index()</code> /// <c>index()</c>
/// is /// is
/// incremented by exactly 1, as that would preclude the ability to implement /// incremented by exactly 1, as that would preclude the ability to implement
/// filtering streams (e.g. /// filtering streams (e.g.
@ -87,65 +87,65 @@ namespace Antlr4.Runtime
/// <exception cref="System.InvalidOperationException"> /// <exception cref="System.InvalidOperationException">
/// if an attempt is made to consume the the /// if an attempt is made to consume the the
/// end of the stream (i.e. if /// end of the stream (i.e. if
/// <code>LA(1)==</code> /// <c>LA(1)==</c>
/// <see cref="IntStreamConstants.Eof">EOF</see> /// <see cref="IntStreamConstants.Eof">EOF</see>
/// before calling /// before calling
/// <code>consume</code> /// <c>consume</c>
/// ). /// ).
/// </exception> /// </exception>
void Consume(); void Consume();
/// <summary> /// <summary>
/// Gets the value of the symbol at offset /// Gets the value of the symbol at offset
/// <code>i</code> /// <paramref name="i"/>
/// from the current /// from the current
/// position. When /// position. When
/// <code>i==1</code> /// <c>i==1</c>
/// , this method returns the value of the current /// , this method returns the value of the current
/// symbol in the stream (which is the next symbol to be consumed). When /// symbol in the stream (which is the next symbol to be consumed). When
/// <code>i==-1</code> /// <c>i==-1</c>
/// , this method returns the value of the previously read /// , this method returns the value of the previously read
/// symbol in the stream. It is not valid to call this method with /// symbol in the stream. It is not valid to call this method with
/// <code>i==0</code> /// <c>i==0</c>
/// , but the specific behavior is unspecified because this /// , but the specific behavior is unspecified because this
/// method is frequently called from performance-critical code. /// method is frequently called from performance-critical code.
/// <p>This method is guaranteed to succeed if any of the following are true:</p> /// <p>This method is guaranteed to succeed if any of the following are true:</p>
/// <ul> /// <ul>
/// <li> /// <li>
/// <code>i&gt;0</code> /// <c>i&gt;0</c>
/// </li> /// </li>
/// <li> /// <li>
/// <code>i==-1</code> /// <c>i==-1</c>
/// and /// and
/// <see cref="Index()">index()</see> /// <see cref="Index()">index()</see>
/// returns a value greater /// returns a value greater
/// than the value of /// than the value of
/// <code>index()</code> /// <c>index()</c>
/// after the stream was constructed /// after the stream was constructed
/// and /// and
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// was called in that order. Specifying the current /// was called in that order. Specifying the current
/// <code>index()</code> /// <c>index()</c>
/// relative to the index after the stream was created /// relative to the index after the stream was created
/// allows for filtering implementations that do not return every symbol /// allows for filtering implementations that do not return every symbol
/// from the underlying source. Specifying the call to /// from the underlying source. Specifying the call to
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// allows for lazily initialized streams.</li> /// allows for lazily initialized streams.</li>
/// <li> /// <li>
/// <code>LA(i)</code> /// <c>LA(i)</c>
/// refers to a symbol consumed within a marked region /// refers to a symbol consumed within a marked region
/// that has not yet been released.</li> /// that has not yet been released.</li>
/// </ul> /// </ul>
/// <p>If /// <p>If
/// <code>i</code> /// <paramref name="i"/>
/// represents a position at or beyond the end of the stream, /// represents a position at or beyond the end of the stream,
/// this method returns /// this method returns
/// <see cref="IntStreamConstants.Eof"/> /// <see cref="IntStreamConstants.Eof"/>
/// .</p> /// .</p>
/// <p>The return value is unspecified if /// <p>The return value is unspecified if
/// <code>i&lt;0</code> /// <c>i&lt;0</c>
/// and fewer than /// and fewer than
/// <code>-i</code> /// <c>-i</c>
/// calls to /// calls to
/// <see cref="Consume()">consume()</see> /// <see cref="Consume()">consume()</see>
/// have occurred from the beginning of /// have occurred from the beginning of
@ -162,22 +162,22 @@ namespace Antlr4.Runtime
/// <see cref="Seek(int)">seek()</see> /// <see cref="Seek(int)">seek()</see>
/// operations will be /// operations will be
/// valid over a "marked range" extending from the index where /// valid over a "marked range" extending from the index where
/// <code>mark()</code> /// <c>mark()</c>
/// was called to the current /// was called to the current
/// <see cref="Index()">index()</see> /// <see cref="Index()">index()</see>
/// . This allows the use of /// . This allows the use of
/// streaming input sources by specifying the minimum buffering requirements /// streaming input sources by specifying the minimum buffering requirements
/// to support arbitrary lookahead during prediction. /// to support arbitrary lookahead during prediction.
/// <p>The returned mark is an opaque handle (type /// <p>The returned mark is an opaque handle (type
/// <code>int</code> /// <c>int</c>
/// ) which is passed /// ) which is passed
/// to /// to
/// <see cref="Release(int)">release()</see> /// <see cref="Release(int)">release()</see>
/// when the guarantees provided by the marked /// when the guarantees provided by the marked
/// range are no longer necessary. When calls to /// range are no longer necessary. When calls to
/// <code>mark()</code> /// <c>mark()</c>
/// / /// /
/// <code>release()</code> /// <c>release()</c>
/// are nested, the marks must be released /// are nested, the marks must be released
/// in reverse order of which they were obtained. Since marked regions are /// in reverse order of which they were obtained. Since marked regions are
/// used during performance-critical sections of prediction, the specific /// used during performance-critical sections of prediction, the specific
@ -226,14 +226,14 @@ namespace Antlr4.Runtime
/// This method releases a marked range created by a call to /// This method releases a marked range created by a call to
/// <see cref="Mark()">mark()</see> /// <see cref="Mark()">mark()</see>
/// . Calls to /// . Calls to
/// <code>release()</code> /// <c>release()</c>
/// must appear in the /// must appear in the
/// reverse order of the corresponding calls to /// reverse order of the corresponding calls to
/// <code>mark()</code> /// <c>mark()</c>
/// . If a mark is /// . If a mark is
/// released twice, or if marks are not released in reverse order of the /// released twice, or if marks are not released in reverse order of the
/// corresponding calls to /// corresponding calls to
/// <code>mark()</code> /// <c>mark()</c>
/// , the behavior is unspecified. /// , the behavior is unspecified.
/// <p>For more information and an example, see /// <p>For more information and an example, see
/// <see cref="Mark()"/> /// <see cref="Mark()"/>
@ -241,7 +241,7 @@ namespace Antlr4.Runtime
/// </summary> /// </summary>
/// <param name="marker"> /// <param name="marker">
/// A marker returned by a call to /// A marker returned by a call to
/// <code>mark()</code> /// <c>mark()</c>
/// . /// .
/// </param> /// </param>
/// <seealso cref="Mark()"/> /// <seealso cref="Mark()"/>
@ -249,7 +249,7 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Return the index into the stream of the input symbol referred to by /// Return the index into the stream of the input symbol referred to by
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// . /// .
/// <p>The behavior of this method is unspecified if no call to an /// <p>The behavior of this method is unspecified if no call to an
/// <see cref="IIntStream">initializing method</see> /// <see cref="IIntStream">initializing method</see>
@ -263,11 +263,11 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Set the input cursor to the position indicated by /// Set the input cursor to the position indicated by
/// <code>index</code> /// <paramref name="index"/>
/// . If the /// . If the
/// specified index lies past the end of the stream, the operation behaves as /// specified index lies past the end of the stream, the operation behaves as
/// though /// though
/// <code>index</code> /// <paramref name="index"/>
/// was the index of the EOF symbol. After this method /// was the index of the EOF symbol. After this method
/// returns without throwing an exception, the at least one of the following /// returns without throwing an exception, the at least one of the following
/// will be true. /// will be true.
@ -276,21 +276,21 @@ namespace Antlr4.Runtime
/// <see cref="Index()">index()</see> /// <see cref="Index()">index()</see>
/// will return the index of the first symbol /// will return the index of the first symbol
/// appearing at or after the specified /// appearing at or after the specified
/// <code>index</code> /// <paramref name="index"/>
/// . Specifically, /// . Specifically,
/// implementations which filter their sources should automatically /// implementations which filter their sources should automatically
/// adjust /// adjust
/// <code>index</code> /// <paramref name="index"/>
/// forward the minimum amount required for the /// forward the minimum amount required for the
/// operation to target a non-ignored symbol.</li> /// operation to target a non-ignored symbol.</li>
/// <li> /// <li>
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// returns /// returns
/// <see cref="IntStreamConstants.Eof"/> /// <see cref="IntStreamConstants.Eof"/>
/// </li> /// </li>
/// </ul> /// </ul>
/// This operation is guaranteed to not throw an exception if /// This operation is guaranteed to not throw an exception if
/// <code>index</code> /// <paramref name="index"/>
/// lies within a marked region. For more information on marked regions, see /// lies within a marked region. For more information on marked regions, see
/// <see cref="Mark()"/> /// <see cref="Mark()"/>
/// . The behavior of this method is unspecified if no call to /// . The behavior of this method is unspecified if no call to
@ -302,7 +302,7 @@ namespace Antlr4.Runtime
/// <param name="index">The absolute index to seek to.</param> /// <param name="index">The absolute index to seek to.</param>
/// <exception cref="System.ArgumentException"> /// <exception cref="System.ArgumentException">
/// if /// if
/// <code>index</code> /// <paramref name="index"/>
/// is less than 0 /// is less than 0
/// </exception> /// </exception>
/// <exception cref="System.NotSupportedException"> /// <exception cref="System.NotSupportedException">

40
runtime/CSharp/Antlr4.Runtime/IParserErrorListener.cs
View File

@ -53,26 +53,26 @@ namespace Antlr4.Runtime
/// .</p> /// .</p>
/// <p> /// <p>
/// When /// When
/// <code>ambigAlts</code> /// <paramref name="ambigAlts"/>
/// is not null, it contains the set of potentially /// is not null, it contains the set of potentially
/// viable alternatives identified by the prediction algorithm. When /// viable alternatives identified by the prediction algorithm. When
/// <code>ambigAlts</code> /// <paramref name="ambigAlts"/>
/// is null, use /// is null, use
/// <see cref="Antlr4.Runtime.Atn.ATNConfigSet.RepresentedAlternatives()"/> /// <see cref="Antlr4.Runtime.Atn.ATNConfigSet.RepresentedAlternatives()"/>
/// to obtain the represented /// to obtain the represented
/// alternatives from the /// alternatives from the
/// <code>configs</code> /// <paramref name="configs"/>
/// argument.</p> /// argument.</p>
/// <p>When /// <p>When
/// <code>exact</code> /// <paramref name="exact"/>
/// is /// is
/// <code>true</code> /// <see langword="true"/>
/// , <em>all</em> of the potentially /// , <em>all</em> of the potentially
/// viable alternatives are truly viable, i.e. this is reporting an exact /// viable alternatives are truly viable, i.e. this is reporting an exact
/// ambiguity. When /// ambiguity. When
/// <code>exact</code> /// <paramref name="exact"/>
/// is /// is
/// <code>false</code> /// <see langword="false"/>
/// , <em>at least two</em> of /// , <em>at least two</em> of
/// the potentially viable alternatives are viable for the current input, but /// the potentially viable alternatives are viable for the current input, but
/// the prediction algorithm terminated as soon as it determined that at /// the prediction algorithm terminated as soon as it determined that at
@ -82,9 +82,9 @@ namespace Antlr4.Runtime
/// <see cref="Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/> /// <see cref="Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
/// prediction /// prediction
/// mode is used, the parser is required to identify exact ambiguities so /// mode is used, the parser is required to identify exact ambiguities so
/// <code>exact</code> /// <paramref name="exact"/>
/// will always be /// will always be
/// <code>true</code> /// <see langword="true"/>
/// .</p> /// .</p>
/// </remarks> /// </remarks>
/// <param name="recognizer">the parser instance</param> /// <param name="recognizer">the parser instance</param>
@ -93,21 +93,21 @@ namespace Antlr4.Runtime
/// <param name="stopIndex">the input input where the ambiguity was identified</param> /// <param name="stopIndex">the input input where the ambiguity was identified</param>
/// <param name="exact"> /// <param name="exact">
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if the ambiguity is exactly known, otherwise /// if the ambiguity is exactly known, otherwise
/// <code>false</code> /// <see langword="false"/>
/// . This is always /// . This is always
/// <code>true</code> /// <see langword="true"/>
/// when /// when
/// <see cref="Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/> /// <see cref="Antlr4.Runtime.Atn.PredictionMode.LlExactAmbigDetection"/>
/// is used. /// is used.
/// </param> /// </param>
/// <param name="ambigAlts"> /// <param name="ambigAlts">
/// the potentially ambiguous alternatives, or /// the potentially ambiguous alternatives, or
/// <code>null</code> /// <see langword="null"/>
/// to indicate that the potentially ambiguous alternatives are the complete /// to indicate that the potentially ambiguous alternatives are the complete
/// set of represented alternatives in /// set of represented alternatives in
/// <code>configs</code> /// <paramref name="configs"/>
/// </param> /// </param>
/// <param name="configs"> /// <param name="configs">
/// the ATN configuration set where the ambiguity was /// the ATN configuration set where the ambiguity was
@ -123,12 +123,12 @@ namespace Antlr4.Runtime
/// This method is called when an SLL conflict occurs and the parser is about /// 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. /// to use the full context information to make an LL decision.
/// <p>If one or more configurations in /// <p>If one or more configurations in
/// <code>configs</code> /// <c>configs</c>
/// contains a semantic /// contains a semantic
/// predicate, the predicates are evaluated before this method is called. The /// predicate, the predicates are evaluated before this method is called. The
/// subset of alternatives which are still viable after predicates are /// subset of alternatives which are still viable after predicates are
/// evaluated is reported in /// evaluated is reported in
/// <code>conflictingAlts</code> /// <paramref name="conflictingAlts"/>
/// .</p> /// .</p>
/// </remarks> /// </remarks>
/// <param name="recognizer">the parser instance</param> /// <param name="recognizer">the parser instance</param>
@ -137,10 +137,10 @@ namespace Antlr4.Runtime
/// <param name="stopIndex">the input index where the SLL conflict occurred</param> /// <param name="stopIndex">the input index where the SLL conflict occurred</param>
/// <param name="conflictingAlts"> /// <param name="conflictingAlts">
/// The specific conflicting alternatives. If this is /// The specific conflicting alternatives. If this is
/// <code>null</code> /// <see langword="null"/>
/// , the conflicting alternatives are all alternatives /// , the conflicting alternatives are all alternatives
/// represented in /// represented in
/// <code>configs</code> /// <c>configs</c>
/// . /// .
/// </param> /// </param>
/// <param name="conflictState"> /// <param name="conflictState">
@ -171,12 +171,12 @@ namespace Antlr4.Runtime
/// indicate a problem, and it may appear even in completely unambiguous /// indicate a problem, and it may appear even in completely unambiguous
/// grammars.</p> /// grammars.</p>
/// <p> /// <p>
/// <code>configs</code> /// <c>configs</c>
/// may have more than one represented alternative if the /// may have more than one represented alternative if the
/// full-context prediction algorithm does not evaluate predicates before /// full-context prediction algorithm does not evaluate predicates before
/// beginning the full-context prediction. In all cases, the final prediction /// beginning the full-context prediction. In all cases, the final prediction
/// is passed as the /// is passed as the
/// <code>prediction</code> /// <paramref name="prediction"/>
/// argument.</p> /// argument.</p>
/// <p>Note that the definition of "context sensitivity" in this method /// <p>Note that the definition of "context sensitivity" in this method
/// differs from the concept in /// differs from the concept in

2
runtime/CSharp/Antlr4.Runtime/ITokenSource.cs
View File

@ -110,7 +110,7 @@ namespace Antlr4.Runtime
/// <see cref="ICharStream"/> /// <see cref="ICharStream"/>
/// associated with the current position in /// associated with the current position in
/// the input, or /// the input, or
/// <code>null</code> /// <see langword="null"/>
/// if no input stream is available for the token /// if no input stream is available for the token
/// source. /// source.
/// </returns> /// </returns>

44
runtime/CSharp/Antlr4.Runtime/ITokenStream.cs
View File

@ -51,7 +51,7 @@ namespace Antlr4.Runtime
/// <see cref="IIntStream.La(int)"/> /// <see cref="IIntStream.La(int)"/>
/// . In addition, when the preconditions of this method /// . In addition, when the preconditions of this method
/// are met, the return value is non-null and the value of /// are met, the return value is non-null and the value of
/// <code>LT(k).getType()==LA(k)</code> /// <c>LT(k).getType()==LA(k)</c>
/// . /// .
/// </summary> /// </summary>
/// <seealso cref="IIntStream.La(int)"/> /// <seealso cref="IIntStream.La(int)"/>
@ -62,30 +62,30 @@ namespace Antlr4.Runtime
/// Gets the /// Gets the
/// <see cref="IToken"/> /// <see cref="IToken"/>
/// at the specified /// at the specified
/// <code>index</code> /// <c>index</c>
/// in the stream. When /// in the stream. When
/// the preconditions of this method are met, the return value is non-null. /// 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 /// <p>The preconditions for this method are the same as the preconditions of
/// <see cref="IIntStream.Seek(int)"/> /// <see cref="IIntStream.Seek(int)"/>
/// . If the behavior of /// . If the behavior of
/// <code>seek(index)</code> /// <c>seek(index)</c>
/// is /// is
/// unspecified for the current state and given /// unspecified for the current state and given
/// <code>index</code> /// <c>index</c>
/// , then the /// , then the
/// behavior of this method is also unspecified.</p> /// behavior of this method is also unspecified.</p>
/// <p>The symbol referred to by /// <p>The symbol referred to by
/// <code>index</code> /// <c>index</c>
/// differs from /// differs from
/// <code>seek()</code> /// <c>seek()</c>
/// only /// only
/// in the case of filtering streams where /// in the case of filtering streams where
/// <code>index</code> /// <c>index</c>
/// lies before the end /// lies before the end
/// of the stream. Unlike /// of the stream. Unlike
/// <code>seek()</code> /// <c>seek()</c>
/// , this method does not adjust /// , this method does not adjust
/// <code>index</code> /// <c>index</c>
/// to point to a non-ignored symbol.</p> /// to point to a non-ignored symbol.</p>
/// </summary> /// </summary>
/// <exception cref="System.ArgumentException">if {code index} is less than 0</exception> /// <exception cref="System.ArgumentException">if {code index} is less than 0</exception>
@ -109,7 +109,7 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Return the text of all tokens within the specified /// Return the text of all tokens within the specified
/// <code>interval</code> /// <paramref name="interval"/>
/// . This /// . This
/// method behaves like the following code (including potential exceptions /// method behaves like the following code (including potential exceptions
/// for violating preconditions of /// for violating preconditions of
@ -134,9 +134,9 @@ namespace Antlr4.Runtime
/// </returns> /// </returns>
/// <exception cref="System.ArgumentNullException"> /// <exception cref="System.ArgumentNullException">
/// if /// if
/// <code>interval</code> /// <paramref name="interval"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// </exception> /// </exception>
[return: NotNull] [return: NotNull]
string GetText(Interval interval); string GetText(Interval interval);
@ -171,7 +171,7 @@ namespace Antlr4.Runtime
/// , but may be /// , but may be
/// optimized by the specific implementation. /// optimized by the specific implementation.
/// <p>If /// <p>If
/// <code>ctx.getSourceInterval()</code> /// <c>ctx.getSourceInterval()</c>
/// does not return a valid interval of /// does not return a valid interval of
/// tokens provided by this stream, the behavior is unspecified.</p> /// tokens provided by this stream, the behavior is unspecified.</p>
/// <pre> /// <pre>
@ -185,7 +185,7 @@ namespace Antlr4.Runtime
/// </param> /// </param>
/// <returns> /// <returns>
/// The text of all tokens within the source interval of /// The text of all tokens within the source interval of
/// <code>ctx</code> /// <paramref name="ctx"/>
/// . /// .
/// </returns> /// </returns>
[return: NotNull] [return: NotNull]
@ -193,19 +193,19 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Return the text of all tokens in this stream between /// Return the text of all tokens in this stream between
/// <code>start</code> /// <paramref name="start"/>
/// and /// and
/// <code>stop</code> /// <paramref name="stop"/>
/// (inclusive). /// (inclusive).
/// <p>If the specified /// <p>If the specified
/// <code>start</code> /// <paramref name="start"/>
/// or /// or
/// <code>stop</code> /// <paramref name="stop"/>
/// token was not provided by /// token was not provided by
/// this stream, or if the /// this stream, or if the
/// <code>stop</code> /// <paramref name="stop"/>
/// occurred before the /// occurred before the
/// <code>start</code> /// <paramref name="start"/>
/// token, the behavior is unspecified.</p> /// token, the behavior is unspecified.</p>
/// <p>For streams which ensure that the /// <p>For streams which ensure that the
/// <see cref="IToken.TokenIndex()"/> /// <see cref="IToken.TokenIndex()"/>
@ -225,9 +225,9 @@ namespace Antlr4.Runtime
/// <param name="stop">The last token in the interval to get text for (inclusive).</param> /// <param name="stop">The last token in the interval to get text for (inclusive).</param>
/// <returns> /// <returns>
/// The text of all tokens lying between the specified /// The text of all tokens lying between the specified
/// <code>start</code> /// <paramref name="start"/>
/// and /// and
/// <code>stop</code> /// <paramref name="stop"/>
/// tokens. /// tokens.
/// </returns> /// </returns>
/// <exception cref="System.NotSupportedException"> /// <exception cref="System.NotSupportedException">

12
runtime/CSharp/Antlr4.Runtime/ListTokenSource.cs
View File

@ -61,7 +61,7 @@ namespace Antlr4.Runtime
/// <summary>The name of the input source.</summary> /// <summary>The name of the input source.</summary>
/// <remarks> /// <remarks>
/// The name of the input source. If this value is /// The name of the input source. If this value is
/// <code>null</code> /// <see langword="null"/>
/// , a call to /// , a call to
/// <see cref="SourceName()"/> /// <see cref="SourceName()"/>
/// should return the source name used to create the /// should return the source name used to create the
@ -111,9 +111,9 @@ namespace Antlr4.Runtime
/// <exception> /// <exception>
/// NullPointerException /// NullPointerException
/// if /// if
/// <code>tokens</code> /// <paramref name="tokens"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// </exception> /// </exception>
public ListTokenSource(IList<IToken> tokens) public ListTokenSource(IList<IToken> tokens)
: this(tokens, null) : this(tokens, null)
@ -139,7 +139,7 @@ namespace Antlr4.Runtime
/// The name of the /// The name of the
/// <see cref="ITokenSource"/> /// <see cref="ITokenSource"/>
/// . If this value is /// . If this value is
/// <code>null</code> /// <see langword="null"/>
/// , /// ,
/// <see cref="SourceName()"/> /// <see cref="SourceName()"/>
/// will attempt to infer the name from /// will attempt to infer the name from
@ -151,9 +151,9 @@ namespace Antlr4.Runtime
/// <exception> /// <exception>
/// NullPointerException /// NullPointerException
/// if /// if
/// <code>tokens</code> /// <paramref name="tokens"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// </exception> /// </exception>
public ListTokenSource(IList<IToken> tokens, string sourceName) public ListTokenSource(IList<IToken> tokens, string sourceName)
{ {

4
runtime/CSharp/Antlr4.Runtime/Misc/Args.cs
View File

@ -37,9 +37,9 @@ namespace Antlr4.Runtime.Misc
{ {
/// <exception cref="System.ArgumentNullException"> /// <exception cref="System.ArgumentNullException">
/// if /// if
/// <code>value</code> /// <paramref name="value"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// . /// .
/// </exception> /// </exception>
public static void NotNull(string parameterName, object value) public static void NotNull(string parameterName, object value)

26
runtime/CSharp/Antlr4.Runtime/Misc/Array2DHashSet`1.cs
View File

@ -87,7 +87,7 @@ namespace Antlr4.Runtime.Misc
/// <summary> /// <summary>
/// Add /// Add
/// <code>o</code> /// <paramref name="o"/>
/// to set if not there; return existing value if already /// to set if not there; return existing value if already
/// there. This method performs the same operation as /// there. This method performs the same operation as
/// <see cref="Array2DHashSet{T}.Add(object)"/> /// <see cref="Array2DHashSet{T}.Add(object)"/>
@ -580,16 +580,16 @@ namespace Antlr4.Runtime.Misc
/// <summary> /// <summary>
/// Return /// Return
/// <code>o</code> /// <paramref name="o"/>
/// as an instance of the element type /// as an instance of the element type
/// <code>T</code> /// <c>T</c>
/// . If /// . If
/// <code>o</code> /// <paramref name="o"/>
/// is non-null but known to not be an instance of /// is non-null but known to not be an instance of
/// <code>T</code> /// <c>T</c>
/// , this /// , this
/// method returns /// method returns
/// <code>null</code> /// <see langword="null"/>
/// . The base implementation does not perform any /// . The base implementation does not perform any
/// type checks; override this method to provide strong type checks for the /// type checks; override this method to provide strong type checks for the
/// <see cref="Array2DHashSet{T}.Contains(object)"/> /// <see cref="Array2DHashSet{T}.Contains(object)"/>
@ -604,11 +604,11 @@ namespace Antlr4.Runtime.Misc
/// <param name="o">the object to try and cast to the element type of the set</param> /// <param name="o">the object to try and cast to the element type of the set</param>
/// <returns> /// <returns>
/// ///
/// <code>o</code> /// <paramref name="o"/>
/// if it could be an instance of /// if it could be an instance of
/// <code>T</code> /// <c>T</c>
/// , otherwise /// , otherwise
/// <code>null</code> /// <see langword="null"/>
/// . /// .
/// </returns> /// </returns>
protected internal virtual T AsElementType(object o) protected internal virtual T AsElementType(object o)
@ -618,9 +618,9 @@ namespace Antlr4.Runtime.Misc
/// <summary> /// <summary>
/// Return an array of /// Return an array of
/// <code>T[]</code> /// <c>T[]</c>
/// with length /// with length
/// <code>capacity</code> /// <paramref name="capacity"/>
/// . /// .
/// </summary> /// </summary>
/// <param name="capacity">the length of the array to return</param> /// <param name="capacity">the length of the array to return</param>
@ -632,9 +632,9 @@ namespace Antlr4.Runtime.Misc
/// <summary> /// <summary>
/// Return an array of /// Return an array of
/// <code>T</code> /// <c>T</c>
/// with length /// with length
/// <code>capacity</code> /// <paramref name="capacity"/>
/// . /// .
/// </summary> /// </summary>
/// <param name="capacity">the length of the array to return</param> /// <param name="capacity">the length of the array to return</param>

68
runtime/CSharp/Antlr4.Runtime/Misc/IIntSet.cs
View File

@ -52,18 +52,18 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/> /// <see cref="IIntSet"/>
/// object to contain all elements that are /// object to contain all elements that are
/// present in itself, the specified /// present in itself, the specified
/// <code>set</code> /// <paramref name="set"/>
/// , or both. /// , or both.
/// </summary> /// </summary>
/// <param name="set"> /// <param name="set">
/// The set to add to the current set. A /// The set to add to the current set. A
/// <code>null</code> /// <see langword="null"/>
/// argument is /// argument is
/// treated as though it were an empty set. /// treated as though it were an empty set.
/// </param> /// </param>
/// <returns> /// <returns>
/// ///
/// <code>this</code> /// <c>this</c>
/// (to support chained calls) /// (to support chained calls)
/// </returns> /// </returns>
/// <exception> /// <exception>
@ -78,12 +78,12 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/> /// <see cref="IIntSet"/>
/// object containing all elements that are /// object containing all elements that are
/// present in both the current set and the specified set /// present in both the current set and the specified set
/// <code>a</code> /// <paramref name="a"/>
/// . /// .
/// </summary> /// </summary>
/// <param name="a"> /// <param name="a">
/// The set to intersect with the current set. A /// The set to intersect with the current set. A
/// <code>null</code> /// <see langword="null"/>
/// argument is treated as though it were an empty set. /// argument is treated as though it were an empty set.
/// </param> /// </param>
/// <returns> /// <returns>
@ -91,9 +91,9 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/> /// <see cref="IIntSet"/>
/// instance containing the intersection of the /// instance containing the intersection of the
/// current set and /// current set and
/// <code>a</code> /// <paramref name="a"/>
/// . The value /// . The value
/// <code>null</code> /// <see langword="null"/>
/// may be returned in /// may be returned in
/// place of an empty result set. /// place of an empty result set.
/// </returns> /// </returns>
@ -105,36 +105,36 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/> /// <see cref="IIntSet"/>
/// object containing all elements that are /// object containing all elements that are
/// present in /// present in
/// <code>elements</code> /// <paramref name="elements"/>
/// but not present in the current set. The /// but not present in the current set. The
/// following expressions are equivalent for input non-null /// following expressions are equivalent for input non-null
/// <see cref="IIntSet"/> /// <see cref="IIntSet"/>
/// instances /// instances
/// <code>x</code> /// <c>x</c>
/// and /// and
/// <code>y</code> /// <c>y</c>
/// . /// .
/// <ul> /// <ul>
/// <li> /// <li>
/// <code>x.complement(y)</code> /// <c>x.complement(y)</c>
/// </li> /// </li>
/// <li> /// <li>
/// <code>y.subtract(x)</code> /// <c>y.subtract(x)</c>
/// </li> /// </li>
/// </ul> /// </ul>
/// </summary> /// </summary>
/// <param name="elements"> /// <param name="elements">
/// The set to compare with the current set. A /// The set to compare with the current set. A
/// <code>null</code> /// <see langword="null"/>
/// argument is treated as though it were an empty set. /// argument is treated as though it were an empty set.
/// </param> /// </param>
/// <returns> /// <returns>
/// A new /// A new
/// <see cref="IIntSet"/> /// <see cref="IIntSet"/>
/// instance containing the elements present in /// instance containing the elements present in
/// <code>elements</code> /// <paramref name="elements"/>
/// but not present in the current set. The value /// but not present in the current set. The value
/// <code>null</code> /// <see langword="null"/>
/// may be returned in place of an empty result set. /// may be returned in place of an empty result set.
/// </returns> /// </returns>
[return: Nullable] [return: Nullable]
@ -145,7 +145,7 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/> /// <see cref="IIntSet"/>
/// object containing all elements that are /// object containing all elements that are
/// present in the current set, the specified set /// present in the current set, the specified set
/// <code>a</code> /// <paramref name="a"/>
/// , or both. /// , or both.
/// <p> /// <p>
/// This method is similar to /// This method is similar to
@ -156,7 +156,7 @@ namespace Antlr4.Runtime.Misc
/// </summary> /// </summary>
/// <param name="a"> /// <param name="a">
/// The set to union with the current set. A /// The set to union with the current set. A
/// <code>null</code> /// <see langword="null"/>
/// argument /// argument
/// is treated as though it were an empty set. /// is treated as though it were an empty set.
/// </param> /// </param>
@ -165,9 +165,9 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/> /// <see cref="IIntSet"/>
/// instance containing the union of the current /// instance containing the union of the current
/// set and /// set and
/// <code>a</code> /// <paramref name="a"/>
/// . The value /// . The value
/// <code>null</code> /// <see langword="null"/>
/// may be returned in place of an /// may be returned in place of an
/// empty result set. /// empty result set.
/// </returns> /// </returns>
@ -179,36 +179,36 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/> /// <see cref="IIntSet"/>
/// object containing all elements that are /// object containing all elements that are
/// present in the current set but not present in the input set /// present in the current set but not present in the input set
/// <code>a</code> /// <paramref name="a"/>
/// . /// .
/// The following expressions are equivalent for input non-null /// The following expressions are equivalent for input non-null
/// <see cref="IIntSet"/> /// <see cref="IIntSet"/>
/// instances /// instances
/// <code>x</code> /// <c>x</c>
/// and /// and
/// <code>y</code> /// <c>y</c>
/// . /// .
/// <ul> /// <ul>
/// <li> /// <li>
/// <code>y.subtract(x)</code> /// <c>y.subtract(x)</c>
/// </li> /// </li>
/// <li> /// <li>
/// <code>x.complement(y)</code> /// <c>x.complement(y)</c>
/// </li> /// </li>
/// </ul> /// </ul>
/// </summary> /// </summary>
/// <param name="a"> /// <param name="a">
/// The set to compare with the current set. A /// The set to compare with the current set. A
/// <code>null</code> /// <see langword="null"/>
/// argument is treated as though it were an empty set. /// argument is treated as though it were an empty set.
/// </param> /// </param>
/// <returns> /// <returns>
/// A new /// A new
/// <see cref="IIntSet"/> /// <see cref="IIntSet"/>
/// instance containing the elements present in /// instance containing the elements present in
/// <code>elements</code> /// <c>elements</c>
/// but not present in the current set. The value /// but not present in the current set. The value
/// <code>null</code> /// <see langword="null"/>
/// may be returned in place of an empty result set. /// may be returned in place of an empty result set.
/// </returns> /// </returns>
[return: Nullable] [return: Nullable]
@ -227,14 +227,14 @@ namespace Antlr4.Runtime.Misc
/// <summary> /// <summary>
/// Returns /// Returns
/// <code>true</code> /// <see langword="true"/>
/// if this set contains no elements. /// if this set contains no elements.
/// </summary> /// </summary>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if the current set contains no elements; otherwise, /// if the current set contains no elements; otherwise,
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
bool IsNil bool IsNil
@ -268,17 +268,17 @@ namespace Antlr4.Runtime.Misc
/// <summary> /// <summary>
/// Returns /// Returns
/// <code>true</code> /// <see langword="true"/>
/// if the set contains the specified element. /// if the set contains the specified element.
/// </summary> /// </summary>
/// <param name="el">The element to check for.</param> /// <param name="el">The element to check for.</param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if the set contains /// if the set contains
/// <code>el</code> /// <paramref name="el"/>
/// ; otherwise /// ; otherwise
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
bool Contains(int el); bool Contains(int el);

8
runtime/CSharp/Antlr4.Runtime/Misc/Interval.cs
View File

@ -166,14 +166,14 @@ namespace Antlr4.Runtime.Misc
/// <summary> /// <summary>
/// Return the interval with elements from /// Return the interval with elements from
/// <code>this</code> /// <c>this</c>
/// not in /// not in
/// <code>other</code> /// <paramref name="other"/>
/// ; /// ;
/// <code>other</code> /// <paramref name="other"/>
/// must not be totally enclosed (properly contained) /// must not be totally enclosed (properly contained)
/// within /// within
/// <code>this</code> /// <c>this</c>
/// , which would result in two disjoint intervals /// , which would result in two disjoint intervals
/// instead of the single one returned by this method. /// instead of the single one returned by this method.
/// </summary> /// </summary>

4
runtime/CSharp/Antlr4.Runtime/Misc/IntervalSet.cs
View File

@ -300,9 +300,9 @@ namespace Antlr4.Runtime.Misc
/// <remarks> /// <remarks>
/// Compute the set difference between two interval sets. The specific /// Compute the set difference between two interval sets. The specific
/// operation is /// operation is
/// <code>left - right</code> /// <c>left - right</c>
/// . If either of the input sets is /// . If either of the input sets is
/// <code>null</code> /// <see langword="null"/>
/// , it is treated as though it was an empty set. /// , it is treated as though it was an empty set.
/// </remarks> /// </remarks>
[return: NotNull] [return: NotNull]

8
runtime/CSharp/Antlr4.Runtime/Misc/MurmurHash.cs
View File

@ -46,7 +46,7 @@ namespace Antlr4.Runtime.Misc
/// <summary> /// <summary>
/// Initialize the hash using the specified /// Initialize the hash using the specified
/// <code>seed</code> /// <paramref name="seed"/>
/// . /// .
/// </summary> /// </summary>
/// <param name="seed">the seed</param> /// <param name="seed">the seed</param>
@ -58,7 +58,7 @@ namespace Antlr4.Runtime.Misc
/// <summary> /// <summary>
/// Update the intermediate hash value for the next input /// Update the intermediate hash value for the next input
/// <code>value</code> /// <paramref name="value"/>
/// . /// .
/// </summary> /// </summary>
/// <param name="hash">the intermediate hash value</param> /// <param name="hash">the intermediate hash value</param>
@ -84,7 +84,7 @@ namespace Antlr4.Runtime.Misc
/// <summary> /// <summary>
/// Update the intermediate hash value for the next input /// Update the intermediate hash value for the next input
/// <code>value</code> /// <paramref name="value"/>
/// . /// .
/// </summary> /// </summary>
/// <param name="hash">the intermediate hash value</param> /// <param name="hash">the intermediate hash value</param>
@ -97,7 +97,7 @@ namespace Antlr4.Runtime.Misc
/// <summary> /// <summary>
/// Apply the final computation steps to the intermediate value /// Apply the final computation steps to the intermediate value
/// <code>hash</code> /// <paramref name="hash"/>
/// to form the final result of the MurmurHash 3 hash function. /// to form the final result of the MurmurHash 3 hash function.
/// </summary> /// </summary>
/// <param name="hash">the intermediate hash value</param> /// <param name="hash">the intermediate hash value</param>

54
runtime/CSharp/Antlr4.Runtime/Parser.cs
View File

@ -145,7 +145,7 @@ namespace Antlr4.Runtime
/// <remarks> /// <remarks>
/// Specifies whether or not the parser should construct a parse tree during /// Specifies whether or not the parser should construct a parse tree during
/// the parsing process. The default value is /// the parsing process. The default value is
/// <code>true</code> /// <see langword="true"/>
/// . /// .
/// </remarks> /// </remarks>
/// <seealso cref="BuildParseTree"/> /// <seealso cref="BuildParseTree"/>
@ -155,13 +155,13 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// When /// When
/// <see cref="Trace"/> /// <see cref="Trace"/>
/// <code>(true)</code> /// <c>(true)</c>
/// is called, a reference to the /// is called, a reference to the
/// <see cref="TraceListener"/> /// <see cref="TraceListener"/>
/// is stored here so it can be easily removed in a /// is stored here so it can be easily removed in a
/// later call to /// later call to
/// <see cref="Trace"/> /// <see cref="Trace"/>
/// <code>(false)</code> /// <c>(false)</c>
/// . The listener itself is /// . The listener itself is
/// implemented as a parser listener so this field is not directly used by /// implemented as a parser listener so this field is not directly used by
/// other parser methods. /// other parser methods.
@ -217,7 +217,7 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Match current input symbol against /// Match current input symbol against
/// <code>ttype</code> /// <paramref name="ttype"/>
/// . If the symbol type /// . If the symbol type
/// matches, /// matches,
/// <see cref="IAntlrErrorStrategy.ReportMatch(Parser)"/> /// <see cref="IAntlrErrorStrategy.ReportMatch(Parser)"/>
@ -231,7 +231,7 @@ namespace Antlr4.Runtime
/// strategy to attempt recovery. If /// strategy to attempt recovery. If
/// <see cref="BuildParseTree()"/> /// <see cref="BuildParseTree()"/>
/// is /// is
/// <code>true</code> /// <see langword="true"/>
/// and the token index of the symbol returned by /// and the token index of the symbol returned by
/// <see cref="IAntlrErrorStrategy.RecoverInline(Parser)"/> /// <see cref="IAntlrErrorStrategy.RecoverInline(Parser)"/>
/// is -1, the symbol is added to /// is -1, the symbol is added to
@ -243,7 +243,7 @@ namespace Antlr4.Runtime
/// <returns>the matched symbol</returns> /// <returns>the matched symbol</returns>
/// <exception cref="RecognitionException"> /// <exception cref="RecognitionException">
/// if the current input symbol did not match /// if the current input symbol did not match
/// <code>ttype</code> /// <paramref name="ttype"/>
/// and the error strategy could not recover from the /// and the error strategy could not recover from the
/// mismatched symbol /// mismatched symbol
/// </exception> /// </exception>
@ -284,7 +284,7 @@ namespace Antlr4.Runtime
/// strategy to attempt recovery. If /// strategy to attempt recovery. If
/// <see cref="BuildParseTree()"/> /// <see cref="BuildParseTree()"/>
/// is /// is
/// <code>true</code> /// <see langword="true"/>
/// and the token index of the symbol returned by /// and the token index of the symbol returned by
/// <see cref="IAntlrErrorStrategy.RecoverInline(Parser)"/> /// <see cref="IAntlrErrorStrategy.RecoverInline(Parser)"/>
/// is -1, the symbol is added to /// is -1, the symbol is added to
@ -348,15 +348,15 @@ namespace Antlr4.Runtime
/// <remarks> /// <remarks>
/// Gets whether or not a complete parse tree will be constructed while /// Gets whether or not a complete parse tree will be constructed while
/// parsing. This property is /// parsing. This property is
/// <code>true</code> /// <see langword="true"/>
/// for a newly constructed parser. /// for a newly constructed parser.
/// </remarks> /// </remarks>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if a complete parse tree will be constructed while /// if a complete parse tree will be constructed while
/// parsing, otherwise /// parsing, otherwise
/// <code>false</code> /// <see langword="false"/>
/// </returns> /// </returns>
public virtual bool BuildParseTree public virtual bool BuildParseTree
{ {
@ -375,19 +375,19 @@ namespace Antlr4.Runtime
/// <remarks> /// <remarks>
/// Trim the internal lists of the parse tree during parsing to conserve memory. /// Trim the internal lists of the parse tree during parsing to conserve memory.
/// This property is set to /// This property is set to
/// <code>false</code> /// <see langword="false"/>
/// by default for a newly constructed parser. /// by default for a newly constructed parser.
/// </remarks> /// </remarks>
/// <value> /// <value>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// to trim the capacity of the /// to trim the capacity of the
/// <see cref="ParserRuleContext.children"/> /// <see cref="ParserRuleContext.children"/>
/// list to its size after a rule is parsed. /// list to its size after a rule is parsed.
/// </value> /// </value>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if the /// if the
/// <see cref="ParserRuleContext.children"/> /// <see cref="ParserRuleContext.children"/>
/// list is trimmed /// list is trimmed
@ -434,7 +434,7 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Registers /// Registers
/// <code>listener</code> /// <paramref name="listener"/>
/// to receive events during the parsing process. /// to receive events during the parsing process.
/// <p>To support output-preserving grammar transformations (including but not /// <p>To support output-preserving grammar transformations (including but not
/// limited to left-recursion removal, automated left-factoring, and /// limited to left-recursion removal, automated left-factoring, and
@ -460,9 +460,9 @@ namespace Antlr4.Runtime
/// <param name="listener">the listener to add</param> /// <param name="listener">the listener to add</param>
/// <exception cref="System.ArgumentNullException"> /// <exception cref="System.ArgumentNullException">
/// if /// if
/// <code/> /// <c/>
/// listener is /// listener is
/// <code>null</code> /// <see langword="null"/>
/// </exception> /// </exception>
public virtual void AddParseListener(IParseTreeListener listener) public virtual void AddParseListener(IParseTreeListener listener)
{ {
@ -479,12 +479,12 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Remove /// Remove
/// <code>listener</code> /// <paramref name="listener"/>
/// from the list of parse listeners. /// from the list of parse listeners.
/// <p>If /// <p>If
/// <code>listener</code> /// <paramref name="listener"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// or has not been added as a parse /// or has not been added as a parse
/// listener, this method does nothing.</p> /// listener, this method does nothing.</p>
/// </summary> /// </summary>
@ -709,12 +709,12 @@ namespace Antlr4.Runtime
/// </linkplain> /// </linkplain>
/// . /// .
/// <p>E.g., given the following input with /// <p>E.g., given the following input with
/// <code>A</code> /// <c>A</c>
/// being the current /// being the current
/// lookahead symbol, this function moves the cursor to /// lookahead symbol, this function moves the cursor to
/// <code>B</code> /// <c>B</c>
/// and returns /// and returns
/// <code>A</code> /// <c>A</c>
/// .</p> /// .</p>
/// <pre> /// <pre>
/// A B /// A B
@ -988,7 +988,7 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Checks whether or not /// Checks whether or not
/// <code>symbol</code> /// <paramref name="symbol"/>
/// can follow the current state in the /// can follow the current state in the
/// ATN. The behavior of this method is equivalent to the following, but is /// ATN. The behavior of this method is equivalent to the following, but is
/// implemented such that the complete context-sensitive follow set does not /// implemented such that the complete context-sensitive follow set does not
@ -1000,12 +1000,12 @@ namespace Antlr4.Runtime
/// <param name="symbol">the symbol type to check</param> /// <param name="symbol">the symbol type to check</param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if /// if
/// <code>symbol</code> /// <paramref name="symbol"/>
/// can follow the current state in /// can follow the current state in
/// the ATN, otherwise /// the ATN, otherwise
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
public virtual bool IsExpectedToken(int symbol) public virtual bool IsExpectedToken(int symbol)
@ -1068,7 +1068,7 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Get a rule's index (i.e., /// Get a rule's index (i.e.,
/// <code>RULE_ruleName</code> /// <c>RULE_ruleName</c>
/// field) or -1 if not found. /// field) or -1 if not found.
/// </summary> /// </summary>
public virtual int GetRuleIndex(string ruleName) public virtual int GetRuleIndex(string ruleName)

2
runtime/CSharp/Antlr4.Runtime/ParserRuleContext.cs
View File

@ -123,7 +123,7 @@ namespace Antlr4.Runtime
/// <remarks> /// <remarks>
/// The exception that forced this rule to return. If the rule successfully /// The exception that forced this rule to return. If the rule successfully
/// completed, this is /// completed, this is
/// <code>null</code> /// <see langword="null"/>
/// . /// .
/// </remarks> /// </remarks>
public RecognitionException exception; public RecognitionException exception;

16
runtime/CSharp/Antlr4.Runtime/RecognitionException.cs
View File

@ -142,13 +142,13 @@ namespace Antlr4.Runtime
/// previously matched symbol at the time this exception was thrown. /// 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, /// <p>If the set of expected tokens is not known and could not be computed,
/// this method returns /// this method returns
/// <code>null</code> /// <see langword="null"/>
/// .</p> /// .</p>
/// </remarks> /// </remarks>
/// <returns> /// <returns>
/// The set of token types that could potentially follow the current /// The set of token types that could potentially follow the current
/// state in the ATN, or /// state in the ATN, or
/// <code>null</code> /// <see langword="null"/>
/// if the information is not available. /// if the information is not available.
/// </returns> /// </returns>
[return: Nullable] [return: Nullable]
@ -166,7 +166,7 @@ namespace Antlr4.Runtime
/// <see cref="RuleContext"/> /// <see cref="RuleContext"/>
/// at the time this exception was thrown. /// at the time this exception was thrown.
/// <p>If the context is not available, this method returns /// <p>If the context is not available, this method returns
/// <code>null</code> /// <see langword="null"/>
/// .</p> /// .</p>
/// </summary> /// </summary>
/// <returns> /// <returns>
@ -174,7 +174,7 @@ namespace Antlr4.Runtime
/// <see cref="RuleContext"/> /// <see cref="RuleContext"/>
/// at the time this exception was thrown. /// at the time this exception was thrown.
/// If the context is not available, this method returns /// If the context is not available, this method returns
/// <code>null</code> /// <see langword="null"/>
/// . /// .
/// </returns> /// </returns>
public virtual RuleContext Context public virtual RuleContext Context
@ -193,13 +193,13 @@ namespace Antlr4.Runtime
/// Gets the input stream which is the symbol source for the recognizer where /// Gets the input stream which is the symbol source for the recognizer where
/// this exception was thrown. /// this exception was thrown.
/// <p>If the input stream is not available, this method returns /// <p>If the input stream is not available, this method returns
/// <code>null</code> /// <see langword="null"/>
/// .</p> /// .</p>
/// </remarks> /// </remarks>
/// <returns> /// <returns>
/// The input stream which is the symbol source for the recognizer /// The input stream which is the symbol source for the recognizer
/// where this exception was thrown, or /// where this exception was thrown, or
/// <code>null</code> /// <see langword="null"/>
/// if the stream is not /// if the stream is not
/// available. /// available.
/// </returns> /// </returns>
@ -229,12 +229,12 @@ namespace Antlr4.Runtime
/// <see cref="IRecognizer"/> /// <see cref="IRecognizer"/>
/// where this exception occurred. /// where this exception occurred.
/// <p>If the recognizer is not available, this method returns /// <p>If the recognizer is not available, this method returns
/// <code>null</code> /// <see langword="null"/>
/// .</p> /// .</p>
/// </summary> /// </summary>
/// <returns> /// <returns>
/// The recognizer where this exception occurred, or /// The recognizer where this exception occurred, or
/// <code>null</code> /// <see langword="null"/>
/// if /// if
/// the recognizer is not available. /// the recognizer is not available.
/// </returns> /// </returns>

4
runtime/CSharp/Antlr4.Runtime/Recognizer`2.cs
View File

@ -280,9 +280,9 @@ namespace Antlr4.Runtime
/// <exception> /// <exception>
/// NullPointerException /// NullPointerException
/// if /// if
/// <code>listener</code> /// <paramref name="listener"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// . /// .
/// </exception> /// </exception>
public virtual void AddErrorListener(IAntlrErrorListener<Symbol> listener) public virtual void AddErrorListener(IAntlrErrorListener<Symbol> listener)

4
runtime/CSharp/Antlr4.Runtime/TokenStreamRewriter.cs
View File

@ -82,9 +82,9 @@ namespace Antlr4.Runtime
/// -time, operations do /// -time, operations do
/// not screw up the token index values. That is, an insert operation at token /// not screw up the token index values. That is, an insert operation at token
/// index /// index
/// <code>i</code> /// <c>i</c>
/// does not change the index values for tokens /// does not change the index values for tokens
/// <code>i</code> /// <c>i</c>
/// +1..n-1.</p> /// +1..n-1.</p>
/// <p> /// <p>
/// Because operations never actually alter the buffer, you may always get the /// Because operations never actually alter the buffer, you may always get the

20
runtime/CSharp/Antlr4.Runtime/Tree/AbstractParseTreeVisitor`1.cs
View File

@ -55,7 +55,7 @@ namespace Antlr4.Runtime.Tree
/// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(IRuleNode, Result)">shouldVisitNextChild</see> /// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(IRuleNode, Result)">shouldVisitNextChild</see>
/// ; if the result /// ; if the result
/// is /// is
/// <code>false</code> /// <see langword="false"/>
/// no more children are visited and the current aggregate /// no more children are visited and the current aggregate
/// result is returned. After visiting a child, the aggregate result is /// result is returned. After visiting a child, the aggregate result is
/// updated by calling /// updated by calling
@ -117,7 +117,7 @@ namespace Antlr4.Runtime.Tree
/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">visitChildren</see> /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">visitChildren</see>
/// initializes its aggregate result to this value. /// initializes its aggregate result to this value.
/// <p>The base implementation returns /// <p>The base implementation returns
/// <code>null</code> /// <see langword="null"/>
/// .</p> /// .</p>
/// </remarks> /// </remarks>
/// <returns>The default value returned by visitor methods.</returns> /// <returns>The default value returned by visitor methods.</returns>
@ -135,12 +135,12 @@ namespace Antlr4.Runtime.Tree
/// either all children are visited or /// either all children are visited or
/// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(IRuleNode, Result)"/> /// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(IRuleNode, Result)"/>
/// returns /// returns
/// <code>false</code> /// <see langword="false"/>
/// , the aggregate value is returned as the result of /// , the aggregate value is returned as the result of
/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/> /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
/// . /// .
/// <p>The default implementation returns /// <p>The default implementation returns
/// <code>nextResult</code> /// <paramref name="nextResult"/>
/// , meaning /// , meaning
/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/> /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
/// will return the result of the last child visited /// will return the result of the last child visited
@ -151,7 +151,7 @@ namespace Antlr4.Runtime.Tree
/// implementation, the aggregate value is initialized to /// implementation, the aggregate value is initialized to
/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()"/> /// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()"/>
/// , which is passed as the /// , which is passed as the
/// <code>aggregate</code> /// <paramref name="aggregate"/>
/// argument /// argument
/// to this method after the first child node is visited. /// to this method after the first child node is visited.
/// </param> /// </param>
@ -170,7 +170,7 @@ namespace Antlr4.Runtime.Tree
/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/> /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
/// . This method is first called before the first /// . This method is first called before the first
/// child is visited; at that point /// child is visited; at that point
/// <code>currentResult</code> /// <paramref name="currentResult"/>
/// will be the initial /// will be the initial
/// value (in the default implementation, the initial value is returned by a /// value (in the default implementation, the initial value is returned by a
/// call to /// call to
@ -178,9 +178,9 @@ namespace Antlr4.Runtime.Tree
/// . This method is not called after the last /// . This method is not called after the last
/// child is visited. /// child is visited.
/// <p>The default implementation always returns /// <p>The default implementation always returns
/// <code>true</code> /// <see langword="true"/>
/// , indicating that /// , indicating that
/// <code>visitChildren</code> /// <c>visitChildren</c>
/// should only return after all children are visited. /// should only return after all children are visited.
/// One reason to override this method is to provide a "short circuit" /// One reason to override this method is to provide a "short circuit"
/// evaluation option for situations where the result of visiting a single /// evaluation option for situations where the result of visiting a single
@ -199,9 +199,9 @@ namespace Antlr4.Runtime.Tree
/// </param> /// </param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// to continue visiting children. Otherwise return /// to continue visiting children. Otherwise return
/// <code>false</code> /// <see langword="false"/>
/// to stop visiting children and immediately return the /// to stop visiting children and immediately return the
/// current aggregate result from /// current aggregate result from
/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/> /// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>

4
runtime/CSharp/Antlr4.Runtime/Tree/IParseTreeVisitor`1.cs
View File

@ -36,10 +36,10 @@ namespace Antlr4.Runtime.Tree
/// <remarks> /// <remarks>
/// This interface defines the basic notion of a parse tree visitor. Generated /// This interface defines the basic notion of a parse tree visitor. Generated
/// visitors implement this interface and the /// visitors implement this interface and the
/// <code>XVisitor</code> /// <c>XVisitor</c>
/// interface for /// interface for
/// grammar /// grammar
/// <code>X</code> /// <c>X</c>
/// . /// .
/// </remarks> /// </remarks>
/// <author>Sam Harwell</author> /// <author>Sam Harwell</author>

4
runtime/CSharp/Antlr4.Runtime/Tree/ITree.cs
View File

@ -69,7 +69,7 @@ namespace Antlr4.Runtime.Tree
/// <summary> /// <summary>
/// If there are children, get the /// If there are children, get the
/// <code>i</code> /// <paramref name="i"/>
/// th value indexed from 0. /// th value indexed from 0.
/// </summary> /// </summary>
ITree GetChild(int i); ITree GetChild(int i);
@ -89,7 +89,7 @@ namespace Antlr4.Runtime.Tree
/// <summary> /// <summary>
/// Print out a whole tree, not just a node, in LISP format /// Print out a whole tree, not just a node, in LISP format
/// <code>(root child1 .. childN)</code> /// <c>(root child1 .. childN)</c>
/// . Print just a node if this is a leaf. /// . Print just a node if this is a leaf.
/// </summary> /// </summary>
string ToStringTree(); string ToStringTree();

54
runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreeMatch.cs
View File

@ -91,23 +91,23 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <exception> /// <exception>
/// IllegalArgumentException /// IllegalArgumentException
/// if /// if
/// <code>tree</code> /// <paramref name="tree"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// </exception> /// </exception>
/// <exception> /// <exception>
/// IllegalArgumentException /// IllegalArgumentException
/// if /// if
/// <code>pattern</code> /// <paramref name="pattern"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// </exception> /// </exception>
/// <exception> /// <exception>
/// IllegalArgumentException /// IllegalArgumentException
/// if /// if
/// <code>labels</code> /// <paramref name="labels"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// </exception> /// </exception>
public ParseTreeMatch(IParseTree tree, ParseTreePattern pattern, MultiMap<string, IParseTree> labels, IParseTree mismatchedNode) public ParseTreeMatch(IParseTree tree, ParseTreePattern pattern, MultiMap<string, IParseTree> labels, IParseTree mismatchedNode)
{ {
@ -131,29 +131,29 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary> /// <summary>
/// Get the last node associated with a specific /// Get the last node associated with a specific
/// <code>label</code> /// <paramref name="label"/>
/// . /// .
/// <p>For example, for pattern /// <p>For example, for pattern
/// <code>&lt;id:ID&gt;</code> /// <c>&lt;id:ID&gt;</c>
/// , /// ,
/// <code>get("id")</code> /// <c>get("id")</c>
/// returns the /// returns the
/// node matched for that /// node matched for that
/// <code>ID</code> /// <c>ID</c>
/// . If more than one node /// . If more than one node
/// matched the specified label, only the last is returned. If there is /// matched the specified label, only the last is returned. If there is
/// no node associated with the label, this returns /// no node associated with the label, this returns
/// <code>null</code> /// <see langword="null"/>
/// .</p> /// .</p>
/// <p>Pattern tags like /// <p>Pattern tags like
/// <code>&lt;ID&gt;</code> /// <c>&lt;ID&gt;</c>
/// and /// and
/// <code>&lt;expr&gt;</code> /// <c>&lt;expr&gt;</c>
/// without labels are /// without labels are
/// considered to be labeled with /// considered to be labeled with
/// <code>ID</code> /// <c>ID</c>
/// and /// and
/// <code>expr</code> /// <c>expr</c>
/// , respectively.</p> /// , respectively.</p>
/// </summary> /// </summary>
/// <param name="label">The label to check.</param> /// <param name="label">The label to check.</param>
@ -162,7 +162,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <see cref="Antlr4.Runtime.Tree.IParseTree"/> /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
/// to match a tag with the specified /// to match a tag with the specified
/// label, or /// label, or
/// <code>null</code> /// <see langword="null"/>
/// if no parse tree matched a tag with the label. /// if no parse tree matched a tag with the label.
/// </returns> /// </returns>
[return: Nullable] [return: Nullable]
@ -181,28 +181,28 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <remarks> /// <remarks>
/// Return all nodes matching a rule or token tag with the specified label. /// Return all nodes matching a rule or token tag with the specified label.
/// <p>If the /// <p>If the
/// <code>label</code> /// <paramref name="label"/>
/// is the name of a parser rule or token in the /// is the name of a parser rule or token in the
/// grammar, the resulting list will contain both the parse trees matching /// grammar, the resulting list will contain both the parse trees matching
/// rule or tags explicitly labeled with the label and the complete set of /// 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 /// parse trees matching the labeled and unlabeled tags in the pattern for
/// the parser rule or token. For example, if /// the parser rule or token. For example, if
/// <code>label</code> /// <paramref name="label"/>
/// is /// is
/// <code>"foo"</code> /// <c>"foo"</c>
/// , /// ,
/// the result will contain <em>all</em> of the following.</p> /// the result will contain <em>all</em> of the following.</p>
/// <ul> /// <ul>
/// <li>Parse tree nodes matching tags of the form /// <li>Parse tree nodes matching tags of the form
/// <code>&lt;foo:anyRuleName&gt;</code> /// <c>&lt;foo:anyRuleName&gt;</c>
/// and /// and
/// <code>&lt;foo:AnyTokenName&gt;</code> /// <c>&lt;foo:AnyTokenName&gt;</c>
/// .</li> /// .</li>
/// <li>Parse tree nodes matching tags of the form /// <li>Parse tree nodes matching tags of the form
/// <code>&lt;anyLabel:foo&gt;</code> /// <c>&lt;anyLabel:foo&gt;</c>
/// .</li> /// .</li>
/// <li>Parse tree nodes matching tags of the form /// <li>Parse tree nodes matching tags of the form
/// <code>&lt;foo&gt;</code> /// <c>&lt;foo&gt;</c>
/// .</li> /// .</li>
/// </ul> /// </ul>
/// </remarks> /// </remarks>
@ -212,7 +212,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <see cref="Antlr4.Runtime.Tree.IParseTree"/> /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
/// nodes matching tags with /// nodes matching tags with
/// the specified /// the specified
/// <code>label</code> /// <paramref name="label"/>
/// . If no nodes matched the label, an empty list /// . If no nodes matched the label, an empty list
/// is returned. /// is returned.
/// </returns> /// </returns>
@ -253,7 +253,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <remarks>Get the node at which we first detected a mismatch.</remarks> /// <remarks>Get the node at which we first detected a mismatch.</remarks>
/// <returns> /// <returns>
/// the node at which we first detected a mismatch, or /// the node at which we first detected a mismatch, or
/// <code>null</code> /// <see langword="null"/>
/// if the match was successful. /// if the match was successful.
/// </returns> /// </returns>
[Nullable] [Nullable]
@ -269,9 +269,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <remarks>Gets a value indicating whether the match operation succeeded.</remarks> /// <remarks>Gets a value indicating whether the match operation succeeded.</remarks>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if the match operation succeeded; otherwise, /// if the match operation succeeded; otherwise,
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
public virtual bool Succeeded public virtual bool Succeeded

8
runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreePattern.cs
View File

@ -38,7 +38,7 @@ namespace Antlr4.Runtime.Tree.Pattern
{ {
/// <summary> /// <summary>
/// A pattern like /// A pattern like
/// <code>&lt;ID&gt; = &lt;expr&gt;;</code> /// <c>&lt;ID&gt; = &lt;expr&gt;;</c>
/// converted to a /// converted to a
/// <see cref="Antlr4.Runtime.Tree.IParseTree"/> /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
/// by /// by
@ -130,12 +130,12 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <param name="tree">The parse tree to match against this tree pattern.</param> /// <param name="tree">The parse tree to match against this tree pattern.</param>
/// <returns> /// <returns>
/// ///
/// <code>true</code> /// <see langword="true"/>
/// if /// if
/// <code>tree</code> /// <paramref name="tree"/>
/// is a match for the current tree /// is a match for the current tree
/// pattern; otherwise, /// pattern; otherwise,
/// <code>false</code> /// <see langword="false"/>
/// . /// .
/// </returns> /// </returns>
public virtual bool Matches(IParseTree tree) public virtual bool Matches(IParseTree tree)

92
runtime/CSharp/Antlr4.Runtime/Tree/Pattern/ParseTreePatternMatcher.cs
View File

@ -45,48 +45,48 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <p>Patterns are strings of source input text with special tags representing /// <p>Patterns are strings of source input text with special tags representing
/// token or rule references such as:</p> /// token or rule references such as:</p>
/// <p> /// <p>
/// <code>&lt;ID&gt; = &lt;expr&gt;;</code> /// <c>&lt;ID&gt; = &lt;expr&gt;;</c>
/// </p> /// </p>
/// <p>Given a pattern start rule such as /// <p>Given a pattern start rule such as
/// <code>statement</code> /// <c>statement</c>
/// , this object constructs /// , this object constructs
/// a /// a
/// <see cref="Antlr4.Runtime.Tree.IParseTree"/> /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
/// with placeholders for the /// with placeholders for the
/// <code>ID</code> /// <c>ID</c>
/// and /// and
/// <code>expr</code> /// <c>expr</c>
/// subtree. Then the /// subtree. Then the
/// <see cref="Match(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/> /// <see cref="Match(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/>
/// routines can compare an actual /// routines can compare an actual
/// <see cref="Antlr4.Runtime.Tree.IParseTree"/> /// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
/// from a parse with this pattern. Tag /// from a parse with this pattern. Tag
/// <code>&lt;ID&gt;</code> /// <c>&lt;ID&gt;</c>
/// matches /// matches
/// any /// any
/// <code>ID</code> /// <c>ID</c>
/// token and tag /// token and tag
/// <code>&lt;expr&gt;</code> /// <c>&lt;expr&gt;</c>
/// references the result of the /// references the result of the
/// <code>expr</code> /// <c>expr</c>
/// rule (generally an instance of /// rule (generally an instance of
/// <code>ExprContext</code> /// <c>ExprContext</c>
/// .</p> /// .</p>
/// <p>Pattern /// <p>Pattern
/// <code>x = 0;</code> /// <c>x = 0;</c>
/// is a similar pattern that matches the same pattern /// is a similar pattern that matches the same pattern
/// except that it requires the identifier to be /// except that it requires the identifier to be
/// <code>x</code> /// <c>x</c>
/// and the expression to /// and the expression to
/// be /// be
/// <code>0</code> /// <c>0</c>
/// .</p> /// .</p>
/// <p>The /// <p>The
/// <see cref="Matches(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/> /// <see cref="Matches(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/>
/// routines return /// routines return
/// <code>true</code> /// <see langword="true"/>
/// or /// or
/// <code>false</code> /// <see langword="false"/>
/// based /// based
/// upon a match for the tree rooted at the parameter sent in. The /// upon a match for the tree rooted at the parameter sent in. The
/// <see cref="Match(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/> /// <see cref="Match(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/>
@ -102,7 +102,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <see cref="ParseTreePattern"/> /// <see cref="ParseTreePattern"/>
/// object.</p> /// object.</p>
/// <p>See /// <p>See
/// <code>TestParseTreeMatcher</code> /// <c>TestParseTreeMatcher</c>
/// for lots of examples. /// for lots of examples.
/// <see cref="ParseTreePattern"/> /// <see cref="ParseTreePattern"/>
/// has two static helper methods: /// has two static helper methods:
@ -118,7 +118,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <see cref="ParseTreePatternMatcher"/> /// <see cref="ParseTreePatternMatcher"/>
/// constructor are used to parse the pattern in string form. The lexer converts /// constructor are used to parse the pattern in string form. The lexer converts
/// the /// the
/// <code>&lt;ID&gt; = &lt;expr&gt;;</code> /// <c>&lt;ID&gt; = &lt;expr&gt;;</c>
/// into a sequence of four tokens (assuming lexer /// into a sequence of four tokens (assuming lexer
/// throws out whitespace or puts it on a hidden channel). Be aware that the /// 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 /// input stream is reset for the lexer (but not the parser; a
@ -127,30 +127,30 @@ namespace Antlr4.Runtime.Tree.Pattern
/// fields you have put into the lexer might get changed when this mechanism asks /// fields you have put into the lexer might get changed when this mechanism asks
/// it to scan the pattern string.</p> /// it to scan the pattern string.</p>
/// <p>Normally a parser does not accept token /// <p>Normally a parser does not accept token
/// <code>&lt;expr&gt;</code> /// <c>&lt;expr&gt;</c>
/// as a valid /// as a valid
/// <code>expr</code> /// <c>expr</c>
/// but, from the parser passed in, we create a special version of /// but, from the parser passed in, we create a special version of
/// the underlying grammar representation (an /// the underlying grammar representation (an
/// <see cref="Antlr4.Runtime.Atn.ATN"/> /// <see cref="Antlr4.Runtime.Atn.ATN"/>
/// ) that allows imaginary /// ) that allows imaginary
/// tokens representing rules ( /// tokens representing rules (
/// <code>&lt;expr&gt;</code> /// <c>&lt;expr&gt;</c>
/// ) to match entire rules. We call /// ) to match entire rules. We call
/// these <em>bypass alternatives</em>.</p> /// these <em>bypass alternatives</em>.</p>
/// <p>Delimiters are /// <p>Delimiters are
/// <code>&lt;</code> /// <c>&lt;</c>
/// and /// and
/// <code>&gt;</code> /// <c>&gt;</c>
/// , with /// , with
/// <code>\</code> /// <c>\</c>
/// as the escape string /// as the escape string
/// by default, but you can set them to whatever you want using /// by default, but you can set them to whatever you want using
/// <see cref="SetDelimiters(string, string, string)"/> /// <see cref="SetDelimiters(string, string, string)"/>
/// . You must escape both start and stop strings /// . You must escape both start and stop strings
/// <code>\&lt;</code> /// <c>\&lt;</c>
/// and /// and
/// <code>\&gt;</code> /// <c>\&gt;</c>
/// .</p> /// .</p>
/// </summary> /// </summary>
public class ParseTreePatternMatcher public class ParseTreePatternMatcher
@ -223,17 +223,17 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <exception> /// <exception>
/// IllegalArgumentException /// IllegalArgumentException
/// if /// if
/// <code>start</code> /// <paramref name="start"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// or empty. /// or empty.
/// </exception> /// </exception>
/// <exception> /// <exception>
/// IllegalArgumentException /// IllegalArgumentException
/// if /// if
/// <code>stop</code> /// <paramref name="stop"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// or empty. /// or empty.
/// </exception> /// </exception>
public virtual void SetDelimiters(string start, string stop, string escapeLeft) public virtual void SetDelimiters(string start, string stop, string escapeLeft)
@ -253,11 +253,11 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary> /// <summary>
/// Does /// Does
/// <code>pattern</code> /// <paramref name="pattern"/>
/// matched as rule /// matched as rule
/// <code>patternRuleIndex</code> /// <paramref name="patternRuleIndex"/>
/// match /// match
/// <code>tree</code> /// <paramref name="tree"/>
/// ? /// ?
/// </summary> /// </summary>
public virtual bool Matches(IParseTree tree, string pattern, int patternRuleIndex) public virtual bool Matches(IParseTree tree, string pattern, int patternRuleIndex)
@ -268,7 +268,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary> /// <summary>
/// Does /// Does
/// <code>pattern</code> /// <paramref name="pattern"/>
/// matched as rule patternRuleIndex match tree? Pass in a /// matched as rule patternRuleIndex match tree? Pass in a
/// compiled pattern instead of a string representation of a tree pattern. /// compiled pattern instead of a string representation of a tree pattern.
/// </summary> /// </summary>
@ -281,11 +281,11 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary> /// <summary>
/// Compare /// Compare
/// <code>pattern</code> /// <paramref name="pattern"/>
/// matched as rule /// matched as rule
/// <code>patternRuleIndex</code> /// <paramref name="patternRuleIndex"/>
/// against /// against
/// <code>tree</code> /// <paramref name="tree"/>
/// and return a /// and return a
/// <see cref="ParseTreeMatch"/> /// <see cref="ParseTreeMatch"/>
/// object that contains the /// object that contains the
@ -299,9 +299,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary> /// <summary>
/// Compare /// Compare
/// <code>pattern</code> /// <paramref name="pattern"/>
/// matched against /// matched against
/// <code>tree</code> /// <paramref name="tree"/>
/// and return a /// and return a
/// <see cref="ParseTreeMatch"/> /// <see cref="ParseTreeMatch"/>
/// object that contains the matched elements, or the /// object that contains the matched elements, or the
@ -388,22 +388,22 @@ namespace Antlr4.Runtime.Tree.Pattern
// ---- SUPPORT CODE ---- // ---- SUPPORT CODE ----
/// <summary> /// <summary>
/// Recursively walk /// Recursively walk
/// <code>tree</code> /// <paramref name="tree"/>
/// against /// against
/// <code>patternTree</code> /// <paramref name="patternTree"/>
/// , filling /// , filling
/// <code>match.</code> /// <c>match.</c>
/// <see cref="ParseTreeMatch.Labels"/> /// <see cref="ParseTreeMatch.Labels"/>
/// . /// .
/// </summary> /// </summary>
/// <returns> /// <returns>
/// the first node encountered in /// the first node encountered in
/// <code>tree</code> /// <paramref name="tree"/>
/// which does not match /// which does not match
/// a corresponding node in /// a corresponding node in
/// <code>patternTree</code> /// <paramref name="patternTree"/>
/// , or /// , or
/// <code>null</code> /// <see langword="null"/>
/// if the match /// if the match
/// was successful. The specific node returned depends on the matching /// was successful. The specific node returned depends on the matching
/// algorithm used by the implementation, and may be overridden. /// algorithm used by the implementation, and may be overridden.
@ -518,9 +518,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary> /// <summary>
/// Is /// Is
/// <code>t</code> /// <paramref name="t"/>
/// ///
/// <code>(expr &lt;expr&gt;)</code> /// <c>(expr &lt;expr&gt;)</c>
/// subtree? /// subtree?
/// </summary> /// </summary>
protected internal virtual RuleTagToken GetRuleTagToken(IParseTree t) protected internal virtual RuleTagToken GetRuleTagToken(IParseTree t)
@ -600,7 +600,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary> /// <summary>
/// Split /// Split
/// <code>&lt;ID&gt; = &lt;e:expr&gt; ;</code> /// <c>&lt;ID&gt; = &lt;e:expr&gt; ;</c>
/// into 4 chunks for tokenizing by /// into 4 chunks for tokenizing by
/// <see cref="Tokenize(string)"/> /// <see cref="Tokenize(string)"/>
/// . /// .

24
runtime/CSharp/Antlr4.Runtime/Tree/Pattern/RuleTagToken.cs
View File

@ -39,7 +39,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <see cref="Antlr4.Runtime.IToken"/> /// <see cref="Antlr4.Runtime.IToken"/>
/// object representing an entire subtree matched by a parser /// object representing an entire subtree matched by a parser
/// rule; e.g., /// rule; e.g.,
/// <code>&lt;expr&gt;</code> /// <c>&lt;expr&gt;</c>
/// . These tokens are created for /// . These tokens are created for
/// <see cref="TagChunk"/> /// <see cref="TagChunk"/>
/// chunks where the tag corresponds to a parser rule. /// chunks where the tag corresponds to a parser rule.
@ -78,9 +78,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <exception> /// <exception>
/// IllegalArgumentException /// IllegalArgumentException
/// if /// if
/// <code>ruleName</code> /// <paramref name="ruleName"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// or empty. /// or empty.
/// </exception> /// </exception>
public RuleTagToken(string ruleName, int bypassTokenType) public RuleTagToken(string ruleName, int bypassTokenType)
@ -98,16 +98,16 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <param name="bypassTokenType">The bypass token type assigned to the parser rule.</param> /// <param name="bypassTokenType">The bypass token type assigned to the parser rule.</param>
/// <param name="label"> /// <param name="label">
/// The label associated with the rule tag, or /// The label associated with the rule tag, or
/// <code>null</code> /// <see langword="null"/>
/// if /// if
/// the rule tag is unlabeled. /// the rule tag is unlabeled.
/// </param> /// </param>
/// <exception> /// <exception>
/// IllegalArgumentException /// IllegalArgumentException
/// if /// if
/// <code>ruleName</code> /// <paramref name="ruleName"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// or empty. /// or empty.
/// </exception> /// </exception>
public RuleTagToken(string ruleName, int bypassTokenType, string label) public RuleTagToken(string ruleName, int bypassTokenType, string label)
@ -137,7 +137,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <remarks>Gets the label associated with the rule tag.</remarks> /// <remarks>Gets the label associated with the rule tag.</remarks>
/// <returns> /// <returns>
/// The name of the label associated with the rule tag, or /// The name of the label associated with the rule tag, or
/// <code>null</code> /// <see langword="null"/>
/// if this is an unlabeled rule tag. /// if this is an unlabeled rule tag.
/// </returns> /// </returns>
[Nullable] [Nullable]
@ -166,9 +166,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary> /// <summary>
/// <inheritDoc/> /// <inheritDoc/>
/// <p>This method returns the rule tag formatted with /// <p>This method returns the rule tag formatted with
/// <code>&lt;</code> /// <c>&lt;</c>
/// and /// and
/// <code>&gt;</code> /// <c>&gt;</c>
/// delimiters.</p> /// delimiters.</p>
/// </summary> /// </summary>
public virtual string Text public virtual string Text
@ -271,7 +271,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <p>The implementation for /// <p>The implementation for
/// <see cref="RuleTagToken"/> /// <see cref="RuleTagToken"/>
/// always returns /// always returns
/// <code>null</code> /// <see langword="null"/>
/// .</p> /// .</p>
/// </summary> /// </summary>
public virtual ITokenSource TokenSource public virtual ITokenSource TokenSource
@ -287,7 +287,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <p>The implementation for /// <p>The implementation for
/// <see cref="RuleTagToken"/> /// <see cref="RuleTagToken"/>
/// always returns /// always returns
/// <code>null</code> /// <see langword="null"/>
/// .</p> /// .</p>
/// </summary> /// </summary>
public virtual ICharStream InputStream public virtual ICharStream InputStream
@ -303,7 +303,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <p>The implementation for /// <p>The implementation for
/// <see cref="RuleTagToken"/> /// <see cref="RuleTagToken"/>
/// returns a string of the form /// returns a string of the form
/// <code>ruleName:bypassTokenType</code> /// <c>ruleName:bypassTokenType</c>
/// .</p> /// .</p>
/// </summary> /// </summary>
public override string ToString() public override string ToString()

30
runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TagChunk.cs
View File

@ -40,24 +40,24 @@ namespace Antlr4.Runtime.Tree.Pattern
/// following forms. /// following forms.
/// <ul> /// <ul>
/// <li> /// <li>
/// <code>expr</code> /// <c>expr</c>
/// : An unlabeled placeholder for a parser rule /// : An unlabeled placeholder for a parser rule
/// <code>expr</code> /// <c>expr</c>
/// .</li> /// .</li>
/// <li> /// <li>
/// <code>ID</code> /// <c>ID</c>
/// : An unlabeled placeholder for a token of type /// : An unlabeled placeholder for a token of type
/// <code>ID</code> /// <c>ID</c>
/// .</li> /// .</li>
/// <li> /// <li>
/// <code>e:expr</code> /// <c>e:expr</c>
/// : A labeled placeholder for a parser rule /// : A labeled placeholder for a parser rule
/// <code>expr</code> /// <c>expr</c>
/// .</li> /// .</li>
/// <li> /// <li>
/// <code>id:ID</code> /// <c>id:ID</c>
/// : A labeled placeholder for a token of type /// : A labeled placeholder for a token of type
/// <code>ID</code> /// <c>ID</c>
/// .</li> /// .</li>
/// </ul> /// </ul>
/// This class does not perform any validation on the tag or label names aside /// This class does not perform any validation on the tag or label names aside
@ -92,9 +92,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <exception> /// <exception>
/// IllegalArgumentException /// IllegalArgumentException
/// if /// if
/// <code>tag</code> /// <paramref name="tag"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// or /// or
/// empty. /// empty.
/// </exception> /// </exception>
@ -111,7 +111,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// </summary> /// </summary>
/// <param name="label"> /// <param name="label">
/// The label for the tag. If this is /// The label for the tag. If this is
/// <code>null</code> /// <see langword="null"/>
/// , the /// , the
/// <see cref="TagChunk"/> /// <see cref="TagChunk"/>
/// represents an unlabeled tag. /// represents an unlabeled tag.
@ -123,9 +123,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <exception> /// <exception>
/// IllegalArgumentException /// IllegalArgumentException
/// if /// if
/// <code>tag</code> /// <paramref name="tag"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// or /// or
/// empty. /// empty.
/// </exception> /// </exception>
@ -155,7 +155,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <remarks>Get the label, if any, assigned to this chunk.</remarks> /// <remarks>Get the label, if any, assigned to this chunk.</remarks>
/// <returns> /// <returns>
/// The label assigned to this chunk, or /// The label assigned to this chunk, or
/// <code>null</code> /// <see langword="null"/>
/// if no label is /// if no label is
/// assigned to the chunk. /// assigned to the chunk.
/// </returns> /// </returns>
@ -172,7 +172,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <remarks> /// <remarks>
/// This method returns a text representation of the tag chunk. Labeled tags /// This method returns a text representation of the tag chunk. Labeled tags
/// are returned in the form /// are returned in the form
/// <code>label:tag</code> /// <c>label:tag</c>
/// , and unlabeled tags are /// , and unlabeled tags are
/// returned as just the tag name. /// returned as just the tag name.
/// </remarks> /// </remarks>

4
runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TextChunk.cs
View File

@ -61,9 +61,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <exception> /// <exception>
/// IllegalArgumentException /// IllegalArgumentException
/// if /// if
/// <code>text</code> /// <paramref name="text"/>
/// is /// is
/// <code>null</code> /// <see langword="null"/>
/// . /// .
/// </exception> /// </exception>
public TextChunk(string text) public TextChunk(string text)

12
runtime/CSharp/Antlr4.Runtime/Tree/Pattern/TokenTagToken.cs
View File

@ -37,7 +37,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// A /// A
/// <see cref="Antlr4.Runtime.IToken"/> /// <see cref="Antlr4.Runtime.IToken"/>
/// object representing a token of a particular type; e.g., /// object representing a token of a particular type; e.g.,
/// <code>&lt;ID&gt;</code> /// <c>&lt;ID&gt;</c>
/// . These tokens are created for /// . These tokens are created for
/// <see cref="TagChunk"/> /// <see cref="TagChunk"/>
/// chunks where the /// chunks where the
@ -85,7 +85,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <param name="type">The token type.</param> /// <param name="type">The token type.</param>
/// <param name="label"> /// <param name="label">
/// The label associated with the token tag, or /// The label associated with the token tag, or
/// <code>null</code> /// <see langword="null"/>
/// if /// if
/// the token tag is unlabeled. /// the token tag is unlabeled.
/// </param> /// </param>
@ -112,7 +112,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <remarks>Gets the label associated with the rule tag.</remarks> /// <remarks>Gets the label associated with the rule tag.</remarks>
/// <returns> /// <returns>
/// The name of the label associated with the rule tag, or /// The name of the label associated with the rule tag, or
/// <code>null</code> /// <see langword="null"/>
/// if this is an unlabeled rule tag. /// if this is an unlabeled rule tag.
/// </returns> /// </returns>
[Nullable] [Nullable]
@ -130,9 +130,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <see cref="TokenTagToken"/> /// <see cref="TokenTagToken"/>
/// returns the token tag /// returns the token tag
/// formatted with /// formatted with
/// <code>&lt;</code> /// <c>&lt;</c>
/// and /// and
/// <code>&gt;</code> /// <c>&gt;</c>
/// delimiters.</p> /// delimiters.</p>
/// </summary> /// </summary>
public override string Text public override string Text
@ -152,7 +152,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <p>The implementation for /// <p>The implementation for
/// <see cref="TokenTagToken"/> /// <see cref="TokenTagToken"/>
/// returns a string of the form /// returns a string of the form
/// <code>tokenName:type</code> /// <c>tokenName:type</c>
/// .</p> /// .</p>
/// </summary> /// </summary>
public override string ToString() public override string ToString()

24
runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPath.cs
View File

@ -47,16 +47,16 @@ namespace Antlr4.Runtime.Tree.Xpath
/// parse trees. /// parse trees.
/// <p> /// <p>
/// Split path into words and separators /// Split path into words and separators
/// <code>/</code> /// <c>/</c>
/// and /// and
/// <code>//</code> /// <c>//</c>
/// via ANTLR /// via ANTLR
/// itself then walk path elements from left to right. At each separator-word /// 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> /// pair, find set of nodes. Next stage uses those as work list.</p>
/// <p> /// <p>
/// The basic interface is /// The basic interface is
/// <see cref="FindAll(Antlr4.Runtime.Tree.IParseTree, string, Antlr4.Runtime.Parser)">ParseTree.findAll</see> /// <see cref="FindAll(Antlr4.Runtime.Tree.IParseTree, string, Antlr4.Runtime.Parser)">ParseTree.findAll</see>
/// <code>(tree, pathString, parser)</code> /// <c>(tree, pathString, parser)</c>
/// . /// .
/// But that is just shorthand for:</p> /// But that is just shorthand for:</p>
/// <pre> /// <pre>
@ -70,7 +70,7 @@ namespace Antlr4.Runtime.Tree.Xpath
/// </pre> /// </pre>
/// <p> /// <p>
/// See /// See
/// <code>org.antlr.v4.test.TestXPath</code> /// <c>org.antlr.v4.test.TestXPath</c>
/// for descriptions. In short, this /// for descriptions. In short, this
/// allows operators:</p> /// allows operators:</p>
/// <dl> /// <dl>
@ -207,18 +207,18 @@ loop_break: ;
/// <summary> /// <summary>
/// Convert word like /// Convert word like
/// <code>*</code> /// <c>*</c>
/// or /// or
/// <code>ID</code> /// <c>ID</c>
/// or /// or
/// <code>expr</code> /// <c>expr</c>
/// to a path /// to a path
/// element. /// element.
/// <code>anywhere</code> /// <paramref name="anywhere"/>
/// is /// is
/// <code>true</code> /// <see langword="true"/>
/// if /// if
/// <code>//</code> /// <c>//</c>
/// precedes the /// precedes the
/// word. /// word.
/// </summary> /// </summary>
@ -267,10 +267,10 @@ loop_break: ;
/// <summary> /// <summary>
/// Return a list of all nodes starting at /// Return a list of all nodes starting at
/// <code>t</code> /// <paramref name="t"/>
/// as root that satisfy the /// as root that satisfy the
/// path. The root /// path. The root
/// <code>/</code> /// <c>/</c>
/// is relative to the node passed to /// is relative to the node passed to
/// <see cref="Evaluate(Antlr4.Runtime.Tree.IParseTree)"/> /// <see cref="Evaluate(Antlr4.Runtime.Tree.IParseTree)"/>
/// . /// .

8
runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathElement.cs
View File

@ -41,11 +41,11 @@ namespace Antlr4.Runtime.Tree.Xpath
/// <summary> /// <summary>
/// Construct element like /// Construct element like
/// <code>/ID</code> /// <c>/ID</c>
/// or /// or
/// <code>ID</code> /// <c>ID</c>
/// or /// or
/// <code>/*</code> /// <c>/*</c>
/// etc... /// etc...
/// op is null if just node /// op is null if just node
/// </summary> /// </summary>
@ -56,7 +56,7 @@ namespace Antlr4.Runtime.Tree.Xpath
/// <summary> /// <summary>
/// Given tree rooted at /// Given tree rooted at
/// <code>t</code> /// <paramref name="t"/>
/// return all nodes matched by this path /// return all nodes matched by this path
/// element. /// element.
/// </summary> /// </summary>

4
runtime/CSharp/Antlr4.Runtime/Tree/Xpath/XPathRuleAnywhereElement.cs
View File

@ -36,9 +36,9 @@ namespace Antlr4.Runtime.Tree.Xpath
{ {
/// <summary> /// <summary>
/// Either /// Either
/// <code>ID</code> /// <c>ID</c>
/// at start of path or /// at start of path or
/// <code>...//ID</code> /// <c>...//ID</c>
/// in middle of path. /// in middle of path.
/// </summary> /// </summary>
public class XPathRuleAnywhereElement : XPathElement public class XPathRuleAnywhereElement : XPathElement

48
runtime/CSharp/Antlr4.Runtime/UnbufferedCharStream.cs
View File

@ -59,7 +59,7 @@ namespace Antlr4.Runtime
/// <see cref="data">data</see> /// <see cref="data">data</see>
/// . /// .
/// <p>This is not the buffer capacity, that's /// <p>This is not the buffer capacity, that's
/// <code>data.length</code> /// <c>data.length</c>
/// .</p> /// .</p>
/// </summary> /// </summary>
protected internal int n; protected internal int n;
@ -69,11 +69,11 @@ namespace Antlr4.Runtime
/// <see cref="data">data</see> /// <see cref="data">data</see>
/// of next character. /// of next character.
/// <p>The /// <p>The
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// character is /// character is
/// <code>data[p]</code> /// <c>data[p]</c>
/// . If /// . If
/// <code>p == n</code> /// <c>p == n</c>
/// , we are /// , we are
/// out of buffered characters.</p> /// out of buffered characters.</p>
/// </summary> /// </summary>
@ -85,29 +85,29 @@ namespace Antlr4.Runtime
/// and down with /// and down with
/// <see cref="Release(int)">release()</see> /// <see cref="Release(int)">release()</see>
/// . When we /// . When we
/// <code>release()</code> /// <c>release()</c>
/// the last mark, /// the last mark,
/// <code>numMarkers</code> /// <c>numMarkers</c>
/// reaches 0 and we reset the buffer. Copy /// reaches 0 and we reset the buffer. Copy
/// <code>data[p]..data[n-1]</code> /// <c>data[p]..data[n-1]</c>
/// to /// to
/// <code>data[0]..data[(n-1)-p]</code> /// <c>data[0]..data[(n-1)-p]</c>
/// . /// .
/// </summary> /// </summary>
protected internal int numMarkers = 0; protected internal int numMarkers = 0;
/// <summary> /// <summary>
/// This is the /// This is the
/// <code>LA(-1)</code> /// <c>LA(-1)</c>
/// character for the current position. /// character for the current position.
/// </summary> /// </summary>
protected internal int lastChar = -1; protected internal int lastChar = -1;
/// <summary> /// <summary>
/// When /// When
/// <code>numMarkers &gt; 0</code> /// <c>numMarkers &gt; 0</c>
/// , this is the /// , this is the
/// <code>LA(-1)</code> /// <c>LA(-1)</c>
/// character for the /// character for the
/// first character in /// first character in
/// <see cref="data">data</see> /// <see cref="data">data</see>
@ -119,7 +119,7 @@ namespace Antlr4.Runtime
/// <remarks> /// <remarks>
/// Absolute character index. It's the index of the character about to be /// Absolute character index. It's the index of the character about to be
/// read via /// read via
/// <code>LA(1)</code> /// <c>LA(1)</c>
/// . Goes from 0 to the number of characters in the /// . Goes from 0 to the number of characters in the
/// entire stream, although the stream size is unknown before the end is /// entire stream, although the stream size is unknown before the end is
/// reached. /// reached.
@ -199,16 +199,16 @@ namespace Antlr4.Runtime
/// <see cref="p">p</see> /// <see cref="p">p</see>
/// . /// .
/// Last valid /// Last valid
/// <code>p</code> /// <c>p</c>
/// index is /// index is
/// <code>data.length-1</code> /// <c>data.length-1</c>
/// . /// .
/// <code>p+need-1</code> /// <c>p+need-1</c>
/// is /// is
/// the char index 'need' elements ahead. If we need 1 element, /// the char index 'need' elements ahead. If we need 1 element,
/// <code>(p+1-1)==p</code> /// <c>(p+1-1)==p</c>
/// must be less than /// must be less than
/// <code>data.length</code> /// <c>data.length</c>
/// . /// .
/// </summary> /// </summary>
protected internal virtual void Sync(int want) protected internal virtual void Sync(int want)
@ -223,13 +223,13 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Add /// Add
/// <code>n</code> /// <paramref name="n"/>
/// characters to the buffer. Returns the number of characters /// characters to the buffer. Returns the number of characters
/// actually added to the buffer. If the return value is less than /// actually added to the buffer. If the return value is less than
/// <code>n</code> /// <paramref name="n"/>
/// , /// ,
/// then EOF was reached before /// then EOF was reached before
/// <code>n</code> /// <paramref name="n"/>
/// characters could be added. /// characters could be added.
/// </summary> /// </summary>
protected internal virtual int Fill(int n) protected internal virtual int Fill(int n)
@ -297,9 +297,9 @@ namespace Antlr4.Runtime
/// Return a marker that we can release later. /// Return a marker that we can release later.
/// <p>The specific marker value used for this class allows for some level of /// <p>The specific marker value used for this class allows for some level of
/// protection against misuse where /// protection against misuse where
/// <code>seek()</code> /// <c>seek()</c>
/// is called on a mark or /// is called on a mark or
/// <code>release()</code> /// <c>release()</c>
/// is called in the wrong order.</p> /// is called in the wrong order.</p>
/// </remarks> /// </remarks>
public virtual int Mark() public virtual int Mark()
@ -352,9 +352,9 @@ namespace Antlr4.Runtime
/// <remarks> /// <remarks>
/// Seek to absolute character index, which might not be in the current /// Seek to absolute character index, which might not be in the current
/// sliding window. Move /// sliding window. Move
/// <code>p</code> /// <c>p</c>
/// to /// to
/// <code>index-bufferStartIndex</code> /// <c>index-bufferStartIndex</c>
/// . /// .
/// </remarks> /// </remarks>
public virtual void Seek(int index) public virtual void Seek(int index)

46
runtime/CSharp/Antlr4.Runtime/UnbufferedTokenStream.cs
View File

@ -54,7 +54,7 @@ namespace Antlr4.Runtime
/// <see cref="tokens">tokens</see> /// <see cref="tokens">tokens</see>
/// . /// .
/// <p>This is not the buffer capacity, that's /// <p>This is not the buffer capacity, that's
/// <code>tokens.length</code> /// <c>tokens.length</c>
/// .</p> /// .</p>
/// </summary> /// </summary>
protected internal int n; protected internal int n;
@ -64,11 +64,11 @@ namespace Antlr4.Runtime
/// <see cref="tokens">tokens</see> /// <see cref="tokens">tokens</see>
/// of next token. /// of next token.
/// <p>The /// <p>The
/// <code>LT(1)</code> /// <c>LT(1)</c>
/// token is /// token is
/// <code>tokens[p]</code> /// <c>tokens[p]</c>
/// . If /// . If
/// <code>p == n</code> /// <c>p == n</c>
/// , we are /// , we are
/// out of buffered tokens.</p> /// out of buffered tokens.</p>
/// </summary> /// </summary>
@ -80,34 +80,34 @@ namespace Antlr4.Runtime
/// and down with /// and down with
/// <see cref="Release(int)">release()</see> /// <see cref="Release(int)">release()</see>
/// . When we /// . When we
/// <code>release()</code> /// <c>release()</c>
/// the last mark, /// the last mark,
/// <code>numMarkers</code> /// <c>numMarkers</c>
/// reaches 0 and we reset the buffer. Copy /// reaches 0 and we reset the buffer. Copy
/// <code>tokens[p]..tokens[n-1]</code> /// <c>tokens[p]..tokens[n-1]</c>
/// to /// to
/// <code>tokens[0]..tokens[(n-1)-p]</code> /// <c>tokens[0]..tokens[(n-1)-p]</c>
/// . /// .
/// </summary> /// </summary>
protected internal int numMarkers = 0; protected internal int numMarkers = 0;
/// <summary> /// <summary>
/// This is the /// This is the
/// <code>LT(-1)</code> /// <c>LT(-1)</c>
/// token for the current position. /// token for the current position.
/// </summary> /// </summary>
protected internal IToken lastToken; protected internal IToken lastToken;
/// <summary> /// <summary>
/// When /// When
/// <code>numMarkers &gt; 0</code> /// <c>numMarkers &gt; 0</c>
/// , this is the /// , this is the
/// <code>LT(-1)</code> /// <c>LT(-1)</c>
/// token for the /// token for the
/// first token in /// first token in
/// <see cref="tokens"/> /// <see cref="tokens"/>
/// . Otherwise, this is /// . Otherwise, this is
/// <code>null</code> /// <see langword="null"/>
/// . /// .
/// </summary> /// </summary>
protected internal IToken lastTokenBufferStart; protected internal IToken lastTokenBufferStart;
@ -115,7 +115,7 @@ namespace Antlr4.Runtime
/// <summary>Absolute token index.</summary> /// <summary>Absolute token index.</summary>
/// <remarks> /// <remarks>
/// Absolute token index. It's the index of the token about to be read via /// Absolute token index. It's the index of the token about to be read via
/// <code>LT(1)</code> /// <c>LT(1)</c>
/// . Goes from 0 to the number of tokens in the entire stream, /// . Goes from 0 to the number of tokens in the entire stream,
/// although the stream size is unknown before the end is reached. /// 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 /// <p>This value is used to set the token indexes if the stream provides tokens
@ -230,16 +230,16 @@ namespace Antlr4.Runtime
/// Make sure we have 'need' elements from current position /// Make sure we have 'need' elements from current position
/// <see cref="p">p</see> /// <see cref="p">p</see>
/// . Last valid /// . Last valid
/// <code>p</code> /// <c>p</c>
/// index is /// index is
/// <code>tokens.length-1</code> /// <c>tokens.length-1</c>
/// . /// .
/// <code>p+need-1</code> /// <c>p+need-1</c>
/// is the tokens index 'need' elements /// is the tokens index 'need' elements
/// ahead. If we need 1 element, /// ahead. If we need 1 element,
/// <code>(p+1-1)==p</code> /// <c>(p+1-1)==p</c>
/// must be less than /// must be less than
/// <code>tokens.length</code> /// <c>tokens.length</c>
/// . /// .
/// </summary> /// </summary>
protected internal virtual void Sync(int want) protected internal virtual void Sync(int want)
@ -254,13 +254,13 @@ namespace Antlr4.Runtime
/// <summary> /// <summary>
/// Add /// Add
/// <code>n</code> /// <paramref name="n"/>
/// elements to the buffer. Returns the number of tokens /// elements to the buffer. Returns the number of tokens
/// actually added to the buffer. If the return value is less than /// actually added to the buffer. If the return value is less than
/// <code>n</code> /// <paramref name="n"/>
/// , /// ,
/// then EOF was reached before /// then EOF was reached before
/// <code>n</code> /// <paramref name="n"/>
/// tokens could be added. /// tokens could be added.
/// </summary> /// </summary>
protected internal virtual int Fill(int n) protected internal virtual int Fill(int n)
@ -295,9 +295,9 @@ namespace Antlr4.Runtime
/// Return a marker that we can release later. /// Return a marker that we can release later.
/// <p>The specific marker value used for this class allows for some level of /// <p>The specific marker value used for this class allows for some level of
/// protection against misuse where /// protection against misuse where
/// <code>seek()</code> /// <c>seek()</c>
/// is called on a mark or /// is called on a mark or
/// <code>release()</code> /// <c>release()</c>
/// is called in the wrong order.</p> /// is called in the wrong order.</p>
/// </remarks> /// </remarks>
public virtual int Mark() public virtual int Mark()