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

Update to latest build of Sharpen

This commit is contained in:
Sam Harwell 2014-07-31 16:37:24 -05:00
parent bd8d057d02
commit c78833e705
77 changed files with 810 additions and 824 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"/>
/// and then treat it
/// like a
/// <code>char[]</code>
/// <c>char[]</c>
/// buffer. Can also pass in a
/// <see cref="string"/>
/// or
/// <code>char[]</code>
/// <c>char[]</c>
/// to use.
/// <p>If you need encoding, pass in stream/reader with correct encoding.</p>
/// </summary>

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

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

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

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

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

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

11
runtime/CSharp/Antlr4.Runtime/Atn/ATNSimulator.cs
View File

@ -39,7 +39,6 @@ namespace Antlr4.Runtime.Atn
public abstract class ATNSimulator
{
[System.ObsoleteAttribute(@"Use ATNDeserializer.SerializedVersion instead.")]
[Obsolete]
public static readonly int SerializedVersion;
static ATNSimulator()
@ -50,7 +49,6 @@ namespace Antlr4.Runtime.Atn
/// <summary>This is the current serialized UUID.</summary>
/// <remarks>This is the current serialized UUID.</remarks>
[System.ObsoleteAttribute(@"Use ATNDeserializer.CheckCondition(bool) instead.")]
[Obsolete]
public static readonly Guid SerializedUuid;
static ATNSimulator()
@ -101,56 +99,48 @@ namespace Antlr4.Runtime.Atn
atn.ClearDFA();
}
[Obsolete]
[System.ObsoleteAttribute(@"Use ATNDeserializer.Deserialize(char[]) instead.")]
public static ATN Deserialize(char[] data)
{
return new ATNDeserializer().Deserialize(data);
}
[Obsolete]
[System.ObsoleteAttribute(@"Use ATNDeserializer.CheckCondition(bool) instead.")]
public static void CheckCondition(bool condition)
{
new ATNDeserializer().CheckCondition(condition);
}
[Obsolete]
[System.ObsoleteAttribute(@"Use ATNDeserializer.CheckCondition(bool, string) instead.")]
public static void CheckCondition(bool condition, string message)
{
new ATNDeserializer().CheckCondition(condition, message);
}
[Obsolete]
[System.ObsoleteAttribute(@"Use ATNDeserializer.ToInt(char) instead.")]
public static int ToInt(char c)
{
return ATNDeserializer.ToInt(c);
}
[Obsolete]
[System.ObsoleteAttribute(@"Use ATNDeserializer.ToInt32(char[], int) instead.")]
public static int ToInt32(char[] data, int offset)
{
return ATNDeserializer.ToInt32(data, offset);
}
[Obsolete]
[System.ObsoleteAttribute(@"Use ATNDeserializer.ToLong(char[], int) instead.")]
public static long ToLong(char[] data, int offset)
{
return ATNDeserializer.ToLong(data, offset);
}
[Obsolete]
[System.ObsoleteAttribute(@"Use ATNDeserializer.ToUUID(char[], int) instead.")]
public static Guid ToUUID(char[] data, int offset)
{
return ATNDeserializer.ToUUID(data, offset);
}
[Obsolete]
[NotNull]
[System.ObsoleteAttribute(@"Use ATNDeserializer.EdgeFactory(ATN, TransitionType, int, int, int, int, int, System.Collections.Generic.IList{E}) instead.")]
public static Transition EdgeFactory(ATN atn, TransitionType type, int src, int trg, int arg1, int arg2, int arg3, IList<IntervalSet> sets)
@ -158,7 +148,6 @@ namespace Antlr4.Runtime.Atn
return new ATNDeserializer().EdgeFactory(atn, type, src, trg, arg1, arg2, arg3, sets);
}
[Obsolete]
[System.ObsoleteAttribute(@"Use ATNDeserializer.StateFactory(StateType, int) instead.")]
public static ATNState StateFactory(StateType type, int ruleIndex)
{

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

@ -52,10 +52,10 @@ namespace Antlr4.Runtime.Atn
/// states or the inclusion of a block representing a nested
/// construct in one of the forms below.</li>
/// <li>Nodes showing multiple outgoing alternatives with a
/// <code>...</code>
/// <c>...</c>
/// support
/// any number of alternatives (one or more). Nodes without the
/// <code>...</code>
/// <c>...</c>
/// only
/// support the exact number of alternatives shown in the diagram.</li>
/// </ul>
@ -66,28 +66,28 @@ namespace Antlr4.Runtime.Atn
/// <embed src="images/Block.svg" type="image/svg+xml"/>
/// <h2>Greedy Loops</h2>
/// <h3>Greedy Closure:
/// <code>(...)*</code>
/// <c>(...)*</c>
/// </h3>
/// <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
/// <h3>Greedy Positive Closure:
/// <code>(...)+</code>
/// <c>(...)+</c>
/// </h3>
/// <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
/// <h3>Greedy Optional:
/// <code>(...)?</code>
/// <c>(...)?</c>
/// </h3>
/// <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
/// <h2>Non-Greedy Loops</h2>
/// <h3>Non-Greedy Closure:
/// <code>(...)*?</code>
/// <c>(...)*?</c>
/// </h3>
/// <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
/// <h3>Non-Greedy Positive Closure:
/// <code>(...)+?</code>
/// <c>(...)+?</c>
/// </h3>
/// <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
/// <h3>Non-Greedy Optional:
/// <code>(...)??</code>
/// <c>(...)??</c>
/// </h3>
/// <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
/// </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.
/// <see cref="ATNConfig.ReachesIntoOuterContext()"/>
/// is
/// <code>false</code>
/// <see langword="false"/>
/// for all
/// configurations), then the result of SLL prediction for that input is known to
/// be equivalent to the result of LL prediction for that input.</p>

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

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

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

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

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

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

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

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

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

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

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

@ -246,16 +246,16 @@ namespace Antlr4.Runtime.Atn
/// Get an existing target state for an edge in the DFA. If the target state
/// for the edge has not yet been computed or is otherwise not available,
/// this method returns
/// <code>null</code>
/// <see langword="null"/>
/// .
/// </remarks>
/// <param name="s">The current DFA state</param>
/// <param name="t">The next input symbol</param>
/// <returns>
/// The existing target DFA state for the given input symbol
/// <code>t</code>
/// <paramref name="t"/>
/// , or
/// <code>null</code>
/// <see langword="null"/>
/// if the target state for this edge is not
/// already cached
/// </returns>
@ -283,9 +283,9 @@ namespace Antlr4.Runtime.Atn
/// <param name="t">The next input symbol</param>
/// <returns>
/// The computed target DFA state for the given input symbol
/// <code>t</code>
/// <paramref name="t"/>
/// . If
/// <code>t</code>
/// <paramref name="t"/>
/// does not lead to a valid DFA state, this method
/// returns
/// <see cref="ATNSimulator.Error"/>
@ -336,9 +336,9 @@ namespace Antlr4.Runtime.Atn
/// <summary>
/// Given a starting configuration set, figure out all ATN configurations
/// we can reach upon input
/// <code>t</code>
/// <paramref name="t"/>
/// . Parameter
/// <code>reach</code>
/// <paramref name="reach"/>
/// is a return
/// parameter.
/// </summary>
@ -430,15 +430,15 @@ namespace Antlr4.Runtime.Atn
/// preference, this method stops pursuing the closure as soon as an accept
/// state is reached. After the first accept state is reached by depth-first
/// search from
/// <code>config</code>
/// <paramref name="config"/>
/// , all other (potentially reachable) states for
/// this rule would have a lower priority.
/// </remarks>
/// <returns>
///
/// <code>true</code>
/// <see langword="true"/>
/// if an accept state is reached, otherwise
/// <code>false</code>
/// <see langword="false"/>
/// .
/// </returns>
protected internal virtual bool Closure(ICharStream input, ATNConfig config, ATNConfigSet configs, bool currentAltReachedAcceptState, bool speculative, bool treatEofAsEpsilon)
@ -601,9 +601,9 @@ namespace Antlr4.Runtime.Atn
/// <remarks>
/// Evaluate a predicate specified in the lexer.
/// <p>If
/// <code>speculative</code>
/// <paramref name="speculative"/>
/// is
/// <code>true</code>
/// <see langword="true"/>
/// , this method was called before
/// <see cref="Consume(Antlr4.Runtime.ICharStream)"/>
/// for the matched character. This method should call
@ -618,7 +618,7 @@ namespace Antlr4.Runtime.Atn
/// <see cref="Antlr4.Runtime.Lexer.Column()"/>
/// , properly reflect the current
/// lexer state. This method should restore
/// <code>input</code>
/// <paramref name="input"/>
/// and the simulator
/// to the original state before returning (i.e. undo the actions made by the
/// call to
@ -630,17 +630,17 @@ namespace Antlr4.Runtime.Atn
/// <param name="predIndex">The index of the predicate within the rule.</param>
/// <param name="speculative">
///
/// <code>true</code>
/// <see langword="true"/>
/// if the current index in
/// <code>input</code>
/// <paramref name="input"/>
/// is
/// one character before the predicate's location.
/// </param>
/// <returns>
///
/// <code>true</code>
/// <see langword="true"/>
/// if the specified predicate evaluates to
/// <code>true</code>
/// <see langword="true"/>
/// .
/// </returns>
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"/>
/// which executes the actions for
/// the input
/// <code>lexerActionExecutor</code>
/// <paramref name="lexerActionExecutor"/>
/// followed by a specified
/// <code>lexerAction</code>
/// <paramref name="lexerAction"/>
/// .
/// </summary>
/// <param name="lexerActionExecutor">
@ -96,14 +96,14 @@ namespace Antlr4.Runtime.Atn
/// the lexer while matching a token within a particular
/// <see cref="ATNConfig"/>
/// . If this is
/// <code>null</code>
/// <see langword="null"/>
/// , the method behaves as though
/// it were an empty executor.
/// </param>
/// <param name="lexerAction">
/// The lexer action to execute after the actions
/// specified in
/// <code>lexerActionExecutor</code>
/// <paramref name="lexerActionExecutor"/>
/// .
/// </param>
/// <returns>
@ -111,9 +111,9 @@ namespace Antlr4.Runtime.Atn
/// <see cref="LexerActionExecutor"/>
/// for executing the combine actions
/// of
/// <code>lexerActionExecutor</code>
/// <paramref name="lexerActionExecutor"/>
/// and
/// <code>lexerAction</code>
/// <paramref name="lexerAction"/>
/// .
/// </returns>
[NotNull]
@ -136,7 +136,7 @@ namespace Antlr4.Runtime.Atn
/// <p>Normally, when the executor encounters lexer actions where
/// <see cref="ILexerAction.IsPositionDependent()"/>
/// returns
/// <code>true</code>
/// <see langword="true"/>
/// , it calls
/// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
/// on the input
@ -155,7 +155,7 @@ namespace Antlr4.Runtime.Atn
/// position in the input stream.</p>
/// <p>If the current executor already has offsets assigned to all
/// position-dependent lexer actions, the method returns
/// <code>this</code>
/// <c>this</c>
/// .</p>
/// </summary>
/// <param name="offset">
@ -208,7 +208,7 @@ namespace Antlr4.Runtime.Atn
/// <p>This method calls
/// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
/// to set the position of the
/// <code>input</code>
/// <paramref name="input"/>
///
/// <see cref="Antlr4.Runtime.ICharStream"/>
/// prior to calling
@ -223,7 +223,7 @@ namespace Antlr4.Runtime.Atn
/// When this method is called, the current
/// <see cref="Antlr4.Runtime.IIntStream.Index()"/>
/// for
/// <code>input</code>
/// <paramref name="input"/>
/// should be the start of the following token, i.e. 1
/// character past the end of the current token.
/// </param>
@ -231,7 +231,7 @@ namespace Antlr4.Runtime.Atn
/// The token start index. This value may be passed to
/// <see cref="Antlr4.Runtime.IIntStream.Seek(int)"/>
/// to set the
/// <code>input</code>
/// <paramref name="input"/>
/// position to the beginning
/// of the token.
/// </param>

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

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

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

@ -134,7 +134,7 @@ namespace Antlr4.Runtime.Atn
/// </remarks>
/// <returns>
/// This method returns
/// <code>true</code>
/// <see langword="true"/>
/// .
/// </returns>
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
/// <see cref="ILexerAction.IsPositionDependent()"/>
/// returns
/// <code>true</code>
/// <see langword="true"/>
/// .</p>
/// </summary>
/// <param name="offset">
@ -145,7 +145,7 @@ namespace Antlr4.Runtime.Atn
/// <summary><inheritDoc/></summary>
/// <returns>
/// This method returns
/// <code>true</code>
/// <see langword="true"/>
/// .
/// </returns>
public bool IsPositionDependent
@ -163,7 +163,7 @@ namespace Antlr4.Runtime.Atn
/// on the result of
/// <see cref="Action()"/>
/// using the provided
/// <code>lexer</code>
/// <paramref name="lexer"/>
/// .</p>
/// </summary>
public void Execute(Lexer lexer)

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

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

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

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

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

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

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

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

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

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

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

@ -36,7 +36,7 @@ namespace Antlr4.Runtime.Atn
{
/// <summary>
/// Implements the
/// <code>type</code>
/// <c>type</c>
/// lexer action by calling
/// <see cref="Antlr4.Runtime.Lexer.Type(int)"/>
/// with the assigned type.
@ -49,7 +49,7 @@ namespace Antlr4.Runtime.Atn
/// <summary>
/// Constructs a new
/// <code>type</code>
/// <paramref name="type"/>
/// action with the specified token type value.
/// </summary>
/// <param name="type">
@ -90,7 +90,7 @@ namespace Antlr4.Runtime.Atn
/// <summary><inheritDoc/></summary>
/// <returns>
/// This method returns
/// <code>false</code>
/// <see langword="false"/>
/// .
/// </returns>
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">
/// The final simulator state containing the necessary
/// information to determine the result of a prediction, or
/// <code>null</code>
/// <see langword="null"/>
/// if
/// the final state is not available
/// </param>
@ -63,10 +63,10 @@ namespace Antlr4.Runtime.Atn
/// <param name="stopIndex">The index at which the prediction was finally made</param>
/// <param name="fullCtx">
///
/// <code>true</code>
/// <see langword="true"/>
/// if the current lookahead is part of an LL
/// prediction; otherwise,
/// <code>false</code>
/// <see langword="false"/>
/// if the current lookahead is part of
/// an SLL prediction
/// </param>

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

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

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

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

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

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

1
runtime/CSharp/Antlr4.Runtime/Atn/RuleTransition.cs
View File

@ -49,7 +49,6 @@ namespace Antlr4.Runtime.Atn
public bool optimizedTailCall;
[Obsolete]
[System.ObsoleteAttribute(@"UseRuleTransition(RuleStartState, int, int, ATNState) instead.")]
public RuleTransition(RuleStartState ruleStart, int ruleIndex, ATNState followState)
: this(ruleStart, ruleIndex, 0, followState)

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -56,7 +56,7 @@ namespace Antlr4.Runtime
/// (
/// <see cref="IToken.DefaultChannel"/>
/// ), 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
/// call
/// <see cref="Lexer.Channel(int)"/>
@ -64,7 +64,7 @@ namespace Antlr4.Runtime
/// </p>
/// <p>
/// Note: lexer rules which use the
/// <code>-&gt;skip</code>
/// <c>-&gt;skip</c>
/// lexer command or call
/// <see cref="Lexer.Skip()"/>
/// 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
/// <see cref="IToken.Channel()"/>
/// matches
/// <code>channel</code>
/// <paramref name="channel"/>
/// or have the
/// <see cref="IToken.Type()"/>
/// equal to

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -56,7 +56,7 @@ namespace Antlr4.Runtime
{
/// <summary>
/// Reset the error handler state for the specified
/// <code>recognizer</code>
/// <paramref name="recognizer"/>
/// .
/// </summary>
/// <param name="recognizer">the parser instance</param>
@ -89,7 +89,7 @@ namespace Antlr4.Runtime
/// <summary>
/// This method is called to recover from exception
/// <code>e</code>
/// <paramref name="e"/>
/// . This method is
/// called after
/// <see cref="ReportError(Parser, RecognitionException)"/>
@ -115,9 +115,9 @@ namespace Antlr4.Runtime
/// <see cref="Sync(Parser)"/>
/// after
/// entering the decision state of a closure block (
/// <code>(...)*</code>
/// <c>(...)*</c>
/// or
/// <code>(...)+</code>
/// <c>(...)+</c>
/// ).</p>
/// <p>For an implementation based on Jim Idle's "magic sync" mechanism, see
/// <see cref="DefaultErrorStrategy.Sync(Parser)"/>
@ -135,7 +135,7 @@ namespace Antlr4.Runtime
/// <summary>
/// Tests whether or not
/// <code>recognizer</code>
/// <paramref name="recognizer"/>
/// is in the process of recovering
/// from an error. In error recovery mode,
/// <see cref="Parser.Consume()"/>
@ -149,10 +149,10 @@ namespace Antlr4.Runtime
/// <param name="recognizer">the parser instance</param>
/// <returns>
///
/// <code>true</code>
/// <see langword="true"/>
/// if the parser is currently recovering from a parse
/// error, otherwise
/// <code>false</code>
/// <see langword="false"/>
/// </returns>
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
/// stream. This method is guaranteed to not throw an exception if the
/// specified
/// <code>interval</code>
/// <paramref name="interval"/>
/// lies entirely within a marked range. For more
/// information about marked ranges, see
/// <see cref="IIntStream.Mark()"/>
@ -55,17 +55,17 @@ namespace Antlr4.Runtime
/// <returns>the text of the specified interval</returns>
/// <exception cref="System.ArgumentNullException">
/// if
/// <code>interval</code>
/// <paramref name="interval"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// </exception>
/// <exception cref="System.ArgumentException">
/// if
/// <code>interval.a &lt; 0</code>
/// <c>interval.a &lt; 0</c>
/// , or if
/// <code>interval.b &lt; interval.a - 1</code>
/// <c>interval.b &lt; interval.a - 1</c>
/// , or if
/// <code>interval.b</code>
/// <c>interval.b</c>
/// lies at or
/// past the end of the stream
/// </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
/// <see cref="Index()">index()</see>
/// before calling this method is less than the value of
/// <code>index()</code>
/// <c>index()</c>
/// after calling this method.</li>
/// <li><strong>Ordered lookahead:</strong> The value of
/// <code>LA(1)</code>
/// <c>LA(1)</c>
/// before
/// calling this method becomes the value of
/// <code>LA(-1)</code>
/// <c>LA(-1)</c>
/// after calling
/// this method.</li>
/// </ul>
/// Note that calling this method does not guarantee that
/// <code>index()</code>
/// <c>index()</c>
/// is
/// incremented by exactly 1, as that would preclude the ability to implement
/// filtering streams (e.g.
@ -87,65 +87,65 @@ namespace Antlr4.Runtime
/// <exception cref="System.InvalidOperationException">
/// if an attempt is made to consume the the
/// end of the stream (i.e. if
/// <code>LA(1)==</code>
/// <c>LA(1)==</c>
/// <see cref="Eof">EOF</see>
/// before calling
/// <code>consume</code>
/// <c>consume</c>
/// ).
/// </exception>
void Consume();
/// <summary>
/// Gets the value of the symbol at offset
/// <code>i</code>
/// <paramref name="i"/>
/// from the current
/// position. When
/// <code>i==1</code>
/// <c>i==1</c>
/// , this method returns the value of the current
/// symbol in the stream (which is the next symbol to be consumed). When
/// <code>i==-1</code>
/// <c>i==-1</c>
/// , this method returns the value of the previously read
/// symbol in the stream. It is not valid to call this method with
/// <code>i==0</code>
/// <c>i==0</c>
/// , but the specific behavior is unspecified because this
/// method is frequently called from performance-critical code.
/// <p>This method is guaranteed to succeed if any of the following are true:</p>
/// <ul>
/// <li>
/// <code>i&gt;0</code>
/// <c>i&gt;0</c>
/// </li>
/// <li>
/// <code>i==-1</code>
/// <c>i==-1</c>
/// and
/// <see cref="Index()">index()</see>
/// returns a value greater
/// than the value of
/// <code>index()</code>
/// <c>index()</c>
/// after the stream was constructed
/// and
/// <code>LA(1)</code>
/// <c>LA(1)</c>
/// was called in that order. Specifying the current
/// <code>index()</code>
/// <c>index()</c>
/// relative to the index after the stream was created
/// allows for filtering implementations that do not return every symbol
/// from the underlying source. Specifying the call to
/// <code>LA(1)</code>
/// <c>LA(1)</c>
/// allows for lazily initialized streams.</li>
/// <li>
/// <code>LA(i)</code>
/// <c>LA(i)</c>
/// refers to a symbol consumed within a marked region
/// that has not yet been released.</li>
/// </ul>
/// <p>If
/// <code>i</code>
/// <paramref name="i"/>
/// represents a position at or beyond the end of the stream,
/// this method returns
/// <see cref="Eof"/>
/// .</p>
/// <p>The return value is unspecified if
/// <code>i&lt;0</code>
/// <c>i&lt;0</c>
/// and fewer than
/// <code>-i</code>
/// <c>-i</c>
/// calls to
/// <see cref="Consume()">consume()</see>
/// have occurred from the beginning of
@ -162,22 +162,22 @@ namespace Antlr4.Runtime
/// <see cref="Seek(int)">seek()</see>
/// operations will be
/// valid over a "marked range" extending from the index where
/// <code>mark()</code>
/// <c>mark()</c>
/// was called to the current
/// <see cref="Index()">index()</see>
/// . This allows the use of
/// streaming input sources by specifying the minimum buffering requirements
/// to support arbitrary lookahead during prediction.
/// <p>The returned mark is an opaque handle (type
/// <code>int</code>
/// <c>int</c>
/// ) which is passed
/// to
/// <see cref="Release(int)">release()</see>
/// when the guarantees provided by the marked
/// 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
/// in reverse order of which they were obtained. Since marked regions are
/// 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
/// <see cref="Mark()">mark()</see>
/// . Calls to
/// <code>release()</code>
/// <c>release()</c>
/// must appear in the
/// reverse order of the corresponding calls to
/// <code>mark()</code>
/// <c>mark()</c>
/// . If a mark is
/// released twice, or if marks are not released in reverse order of the
/// corresponding calls to
/// <code>mark()</code>
/// <c>mark()</c>
/// , the behavior is unspecified.
/// <p>For more information and an example, see
/// <see cref="Mark()"/>
@ -241,7 +241,7 @@ namespace Antlr4.Runtime
/// </summary>
/// <param name="marker">
/// A marker returned by a call to
/// <code>mark()</code>
/// <c>mark()</c>
/// .
/// </param>
/// <seealso cref="Mark()"/>
@ -249,7 +249,7 @@ namespace Antlr4.Runtime
/// <summary>
/// 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
/// <see cref="IIntStream">initializing method</see>
@ -263,11 +263,11 @@ namespace Antlr4.Runtime
/// <summary>
/// Set the input cursor to the position indicated by
/// <code>index</code>
/// <paramref name="index"/>
/// . If the
/// specified index lies past the end of the stream, the operation behaves as
/// though
/// <code>index</code>
/// <paramref name="index"/>
/// was the index of the EOF symbol. After this method
/// returns without throwing an exception, the at least one of the following
/// will be true.
@ -276,21 +276,21 @@ namespace Antlr4.Runtime
/// <see cref="Index()">index()</see>
/// will return the index of the first symbol
/// appearing at or after the specified
/// <code>index</code>
/// <paramref name="index"/>
/// . Specifically,
/// implementations which filter their sources should automatically
/// adjust
/// <code>index</code>
/// <paramref name="index"/>
/// forward the minimum amount required for the
/// operation to target a non-ignored symbol.</li>
/// <li>
/// <code>LA(1)</code>
/// <c>LA(1)</c>
/// returns
/// <see cref="Eof"/>
/// </li>
/// </ul>
/// 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
/// <see cref="Mark()"/>
/// . 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>
/// <exception cref="System.ArgumentException">
/// if
/// <code>index</code>
/// <paramref name="index"/>
/// is less than 0
/// </exception>
/// <exception cref="System.NotSupportedException">

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

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

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

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

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

@ -51,7 +51,7 @@ namespace Antlr4.Runtime
/// <see cref="IIntStream.La(int)"/>
/// . In addition, when the preconditions of this method
/// 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>
/// <seealso cref="IIntStream.La(int)"/>
@ -62,30 +62,30 @@ namespace Antlr4.Runtime
/// Gets the
/// <see cref="IToken"/>
/// at the specified
/// <code>index</code>
/// <c>index</c>
/// in the stream. When
/// the preconditions of this method are met, the return value is non-null.
/// <p>The preconditions for this method are the same as the preconditions of
/// <see cref="IIntStream.Seek(int)"/>
/// . If the behavior of
/// <code>seek(index)</code>
/// <c>seek(index)</c>
/// is
/// unspecified for the current state and given
/// <code>index</code>
/// <c>index</c>
/// , then the
/// behavior of this method is also unspecified.</p>
/// <p>The symbol referred to by
/// <code>index</code>
/// <c>index</c>
/// differs from
/// <code>seek()</code>
/// <c>seek()</c>
/// only
/// in the case of filtering streams where
/// <code>index</code>
/// <c>index</c>
/// lies before the end
/// of the stream. Unlike
/// <code>seek()</code>
/// <c>seek()</c>
/// , this method does not adjust
/// <code>index</code>
/// <c>index</c>
/// to point to a non-ignored symbol.</p>
/// </summary>
/// <exception cref="System.ArgumentException">if {code index} is less than 0</exception>
@ -109,7 +109,7 @@ namespace Antlr4.Runtime
/// <summary>
/// Return the text of all tokens within the specified
/// <code>interval</code>
/// <paramref name="interval"/>
/// . This
/// method behaves like the following code (including potential exceptions
/// for violating preconditions of
@ -134,9 +134,9 @@ namespace Antlr4.Runtime
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// if
/// <code>interval</code>
/// <paramref name="interval"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// </exception>
[NotNull]
string GetText(Interval interval);
@ -171,7 +171,7 @@ namespace Antlr4.Runtime
/// , but may be
/// optimized by the specific implementation.
/// <p>If
/// <code>ctx.getSourceInterval()</code>
/// <c>ctx.getSourceInterval()</c>
/// does not return a valid interval of
/// tokens provided by this stream, the behavior is unspecified.</p>
/// <pre>
@ -185,7 +185,7 @@ namespace Antlr4.Runtime
/// </param>
/// <returns>
/// The text of all tokens within the source interval of
/// <code>ctx</code>
/// <paramref name="ctx"/>
/// .
/// </returns>
[NotNull]
@ -193,19 +193,19 @@ namespace Antlr4.Runtime
/// <summary>
/// Return the text of all tokens in this stream between
/// <code>start</code>
/// <paramref name="start"/>
/// and
/// <code>stop</code>
/// <paramref name="stop"/>
/// (inclusive).
/// <p>If the specified
/// <code>start</code>
/// <paramref name="start"/>
/// or
/// <code>stop</code>
/// <paramref name="stop"/>
/// token was not provided by
/// this stream, or if the
/// <code>stop</code>
/// <paramref name="stop"/>
/// occurred before the
/// <code>start</code>
/// <paramref name="start"/>
/// token, the behavior is unspecified.</p>
/// <p>For streams which ensure that the
/// <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>
/// <returns>
/// The text of all tokens lying between the specified
/// <code>start</code>
/// <paramref name="start"/>
/// and
/// <code>stop</code>
/// <paramref name="stop"/>
/// tokens.
/// </returns>
/// <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>
/// <remarks>
/// The name of the input source. If this value is
/// <code>null</code>
/// <see langword="null"/>
/// , a call to
/// <see cref="SourceName()"/>
/// should return the source name used to create the
@ -115,9 +115,9 @@ namespace Antlr4.Runtime
/// <exception>
/// NullPointerException
/// if
/// <code>tokens</code>
/// <paramref name="tokens"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// </exception>
public ListTokenSource(IList<IToken> tokens)
: this(tokens, null)
@ -143,7 +143,7 @@ namespace Antlr4.Runtime
/// The name of the
/// <see cref="ITokenSource"/>
/// . If this value is
/// <code>null</code>
/// <see langword="null"/>
/// ,
/// <see cref="SourceName()"/>
/// will attempt to infer the name from
@ -155,9 +155,9 @@ namespace Antlr4.Runtime
/// <exception>
/// NullPointerException
/// if
/// <code>tokens</code>
/// <paramref name="tokens"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// </exception>
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">
/// if
/// <code>value</code>
/// <paramref name="value"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// .
/// </exception>
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>
/// Add
/// <code>o</code>
/// <paramref name="o"/>
/// to set if not there; return existing value if already
/// there. This method performs the same operation as
/// <see cref="Array2DHashSet{T}.Add(object)"/>
@ -580,16 +580,16 @@ namespace Antlr4.Runtime.Misc
/// <summary>
/// Return
/// <code>o</code>
/// <paramref name="o"/>
/// as an instance of the element type
/// <code>T</code>
/// <c>T</c>
/// . If
/// <code>o</code>
/// <paramref name="o"/>
/// is non-null but known to not be an instance of
/// <code>T</code>
/// <c>T</c>
/// , this
/// method returns
/// <code>null</code>
/// <see langword="null"/>
/// . The base implementation does not perform any
/// type checks; override this method to provide strong type checks for the
/// <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>
/// <returns>
///
/// <code>o</code>
/// <paramref name="o"/>
/// if it could be an instance of
/// <code>T</code>
/// <c>T</c>
/// , otherwise
/// <code>null</code>
/// <see langword="null"/>
/// .
/// </returns>
protected internal virtual T AsElementType(object o)
@ -618,9 +618,9 @@ namespace Antlr4.Runtime.Misc
/// <summary>
/// Return an array of
/// <code>T[]</code>
/// <c>T[]</c>
/// with length
/// <code>capacity</code>
/// <paramref name="capacity"/>
/// .
/// </summary>
/// <param name="capacity">the length of the array to return</param>
@ -632,9 +632,9 @@ namespace Antlr4.Runtime.Misc
/// <summary>
/// Return an array of
/// <code>T</code>
/// <c>T</c>
/// with length
/// <code>capacity</code>
/// <paramref name="capacity"/>
/// .
/// </summary>
/// <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"/>
/// object to contain all elements that are
/// present in itself, the specified
/// <code>set</code>
/// <paramref name="set"/>
/// , or both.
/// </summary>
/// <param name="set">
/// The set to add to the current set. A
/// <code>null</code>
/// <see langword="null"/>
/// argument is
/// treated as though it were an empty set.
/// </param>
/// <returns>
///
/// <code>this</code>
/// <c>this</c>
/// (to support chained calls)
/// </returns>
/// <exception>
@ -78,12 +78,12 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/>
/// object containing all elements that are
/// present in both the current set and the specified set
/// <code>a</code>
/// <paramref name="a"/>
/// .
/// </summary>
/// <param name="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.
/// </param>
/// <returns>
@ -91,9 +91,9 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/>
/// instance containing the intersection of the
/// current set and
/// <code>a</code>
/// <paramref name="a"/>
/// . The value
/// <code>null</code>
/// <see langword="null"/>
/// may be returned in
/// place of an empty result set.
/// </returns>
@ -105,36 +105,36 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/>
/// object containing all elements that are
/// present in
/// <code>elements</code>
/// <paramref name="elements"/>
/// but not present in the current set. The
/// following expressions are equivalent for input non-null
/// <see cref="IIntSet"/>
/// instances
/// <code>x</code>
/// <c>x</c>
/// and
/// <code>y</code>
/// <c>y</c>
/// .
/// <ul>
/// <li>
/// <code>x.complement(y)</code>
/// <c>x.complement(y)</c>
/// </li>
/// <li>
/// <code>y.subtract(x)</code>
/// <c>y.subtract(x)</c>
/// </li>
/// </ul>
/// </summary>
/// <param name="elements">
/// 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.
/// </param>
/// <returns>
/// A new
/// <see cref="IIntSet"/>
/// instance containing the elements present in
/// <code>elements</code>
/// <paramref name="elements"/>
/// 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.
/// </returns>
[Nullable]
@ -145,7 +145,7 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/>
/// object containing all elements that are
/// present in the current set, the specified set
/// <code>a</code>
/// <paramref name="a"/>
/// , or both.
/// <p>
/// This method is similar to
@ -156,7 +156,7 @@ namespace Antlr4.Runtime.Misc
/// </summary>
/// <param name="a">
/// The set to union with the current set. A
/// <code>null</code>
/// <see langword="null"/>
/// argument
/// is treated as though it were an empty set.
/// </param>
@ -165,9 +165,9 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/>
/// instance containing the union of the current
/// set and
/// <code>a</code>
/// <paramref name="a"/>
/// . The value
/// <code>null</code>
/// <see langword="null"/>
/// may be returned in place of an
/// empty result set.
/// </returns>
@ -179,36 +179,36 @@ namespace Antlr4.Runtime.Misc
/// <see cref="IIntSet"/>
/// object containing all elements that are
/// 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
/// <see cref="IIntSet"/>
/// instances
/// <code>x</code>
/// <c>x</c>
/// and
/// <code>y</code>
/// <c>y</c>
/// .
/// <ul>
/// <li>
/// <code>y.subtract(x)</code>
/// <c>y.subtract(x)</c>
/// </li>
/// <li>
/// <code>x.complement(y)</code>
/// <c>x.complement(y)</c>
/// </li>
/// </ul>
/// </summary>
/// <param name="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.
/// </param>
/// <returns>
/// A new
/// <see cref="IIntSet"/>
/// instance containing the elements present in
/// <code>elements</code>
/// <c>elements</c>
/// 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.
/// </returns>
[Nullable]
@ -227,14 +227,14 @@ namespace Antlr4.Runtime.Misc
/// <summary>
/// Returns
/// <code>true</code>
/// <see langword="true"/>
/// if this set contains no elements.
/// </summary>
/// <returns>
///
/// <code>true</code>
/// <see langword="true"/>
/// if the current set contains no elements; otherwise,
/// <code>false</code>
/// <see langword="false"/>
/// .
/// </returns>
bool IsNil
@ -268,17 +268,17 @@ namespace Antlr4.Runtime.Misc
/// <summary>
/// Returns
/// <code>true</code>
/// <see langword="true"/>
/// if the set contains the specified element.
/// </summary>
/// <param name="el">The element to check for.</param>
/// <returns>
///
/// <code>true</code>
/// <see langword="true"/>
/// if the set contains
/// <code>el</code>
/// <paramref name="el"/>
/// ; otherwise
/// <code>false</code>
/// <see langword="false"/>
/// .
/// </returns>
bool Contains(int el);

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

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

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

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

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

@ -46,7 +46,7 @@ namespace Antlr4.Runtime.Misc
/// <summary>
/// Initialize the hash using the specified
/// <code>seed</code>
/// <paramref name="seed"/>
/// .
/// </summary>
/// <param name="seed">the seed</param>
@ -58,7 +58,7 @@ namespace Antlr4.Runtime.Misc
/// <summary>
/// Update the intermediate hash value for the next input
/// <code>value</code>
/// <paramref name="value"/>
/// .
/// </summary>
/// <param name="hash">the intermediate hash value</param>
@ -84,7 +84,7 @@ namespace Antlr4.Runtime.Misc
/// <summary>
/// Update the intermediate hash value for the next input
/// <code>value</code>
/// <paramref name="value"/>
/// .
/// </summary>
/// <param name="hash">the intermediate hash value</param>
@ -97,7 +97,7 @@ namespace Antlr4.Runtime.Misc
/// <summary>
/// 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.
/// </summary>
/// <param name="hash">the intermediate hash value</param>

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

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

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

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

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

@ -140,13 +140,13 @@ namespace Antlr4.Runtime
/// previously matched symbol at the time this exception was thrown.
/// <p>If the set of expected tokens is not known and could not be computed,
/// this method returns
/// <code>null</code>
/// <see langword="null"/>
/// .</p>
/// </remarks>
/// <returns>
/// The set of token types that could potentially follow the current
/// state in the ATN, or
/// <code>null</code>
/// <see langword="null"/>
/// if the information is not available.
/// </returns>
[Nullable]
@ -164,7 +164,7 @@ namespace Antlr4.Runtime
/// <see cref="RuleContext"/>
/// at the time this exception was thrown.
/// <p>If the context is not available, this method returns
/// <code>null</code>
/// <see langword="null"/>
/// .</p>
/// </summary>
/// <returns>
@ -172,7 +172,7 @@ namespace Antlr4.Runtime
/// <see cref="RuleContext"/>
/// at the time this exception was thrown.
/// If the context is not available, this method returns
/// <code>null</code>
/// <see langword="null"/>
/// .
/// </returns>
public virtual RuleContext Context
@ -191,13 +191,13 @@ namespace Antlr4.Runtime
/// Gets the input stream which is the symbol source for the recognizer where
/// this exception was thrown.
/// <p>If the input stream is not available, this method returns
/// <code>null</code>
/// <see langword="null"/>
/// .</p>
/// </remarks>
/// <returns>
/// The input stream which is the symbol source for the recognizer
/// where this exception was thrown, or
/// <code>null</code>
/// <see langword="null"/>
/// if the stream is not
/// available.
/// </returns>
@ -227,12 +227,12 @@ namespace Antlr4.Runtime
/// <see cref="Recognizer{Symbol, ATNInterpreter}"/>
/// where this exception occurred.
/// <p>If the recognizer is not available, this method returns
/// <code>null</code>
/// <see langword="null"/>
/// .</p>
/// </summary>
/// <returns>
/// The recognizer where this exception occurred, or
/// <code>null</code>
/// <see langword="null"/>
/// if
/// the recognizer is not available.
/// </returns>

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

@ -255,7 +255,6 @@ namespace Antlr4.Runtime
/// your token objects because you don't have to go modify your lexer
/// so that it creates a new Java type.
/// </remarks>
[Obsolete]
[System.ObsoleteAttribute(@"This method is not called by the ANTLR 4 Runtime. Specific implementations of IAntlrErrorStrategy may provide a similar feature when necessary. For example, seeDefaultErrorStrategy.GetTokenErrorDisplay(IToken) .")]
public virtual string GetTokenErrorDisplay(IToken t)
{
@ -284,9 +283,9 @@ namespace Antlr4.Runtime
/// <exception>
/// NullPointerException
/// if
/// <code>listener</code>
/// <paramref name="listener"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// .
/// </exception>
public virtual void AddErrorListener<_T0>(IAntlrErrorListener<_T0> listener)

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

@ -81,9 +81,9 @@ namespace Antlr4.Runtime
/// -time, operations do
/// not screw up the token index values. That is, an insert operation at token
/// index
/// <code>i</code>
/// <c>i</c>
/// does not change the index values for tokens
/// <code>i</code>
/// <c>i</c>
/// +1..n-1.</p>
/// <p>
/// 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, object)">shouldVisitNextChild</see>
/// ; if the result
/// is
/// <code>false</code>
/// <see langword="false"/>
/// no more children are visited and the current aggregate
/// result is returned. After visiting a child, the aggregate result is
/// updated by calling
@ -117,7 +117,7 @@ namespace Antlr4.Runtime.Tree
/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)">visitChildren</see>
/// initializes its aggregate result to this value.
/// <p>The base implementation returns
/// <code>null</code>
/// <see langword="null"/>
/// .</p>
/// </remarks>
/// <returns>The default value returned by visitor methods.</returns>
@ -135,12 +135,12 @@ namespace Antlr4.Runtime.Tree
/// either all children are visited or
/// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(IRuleNode, object)"/>
/// returns
/// <code>false</code>
/// <see langword="false"/>
/// , the aggregate value is returned as the result of
/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
/// .
/// <p>The default implementation returns
/// <code>nextResult</code>
/// <paramref name="nextResult"/>
/// , meaning
/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
/// will return the result of the last child visited
@ -151,7 +151,7 @@ namespace Antlr4.Runtime.Tree
/// implementation, the aggregate value is initialized to
/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()"/>
/// , which is passed as the
/// <code>aggregate</code>
/// <paramref name="aggregate"/>
/// argument
/// to this method after the first child node is visited.
/// </param>
@ -170,7 +170,7 @@ namespace Antlr4.Runtime.Tree
/// <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
/// . This method is first called before the first
/// child is visited; at that point
/// <code>currentResult</code>
/// <paramref name="currentResult"/>
/// will be the initial
/// value (in the default implementation, the initial value is returned by a
/// call to
@ -178,9 +178,9 @@ namespace Antlr4.Runtime.Tree
/// . This method is not called after the last
/// child is visited.
/// <p>The default implementation always returns
/// <code>true</code>
/// <see langword="true"/>
/// , indicating that
/// <code>visitChildren</code>
/// <c>visitChildren</c>
/// should only return after all children are visited.
/// One reason to override this method is to provide a "short circuit"
/// evaluation option for situations where the result of visiting a single
@ -199,9 +199,9 @@ namespace Antlr4.Runtime.Tree
/// </param>
/// <returns>
///
/// <code>true</code>
/// <see langword="true"/>
/// to continue visiting children. Otherwise return
/// <code>false</code>
/// <see langword="false"/>
/// to stop visiting children and immediately return the
/// current aggregate result from
/// <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>
/// This interface defines the basic notion of a parse tree visitor. Generated
/// visitors implement this interface and the
/// <code>XVisitor</code>
/// <c>XVisitor</c>
/// interface for
/// grammar
/// <code>X</code>
/// <c>X</c>
/// .
/// </remarks>
/// <author>Sam Harwell</author>

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

@ -69,7 +69,7 @@ namespace Antlr4.Runtime.Tree
/// <summary>
/// If there are children, get the
/// <code>i</code>
/// <paramref name="i"/>
/// th value indexed from 0.
/// </summary>
ITree GetChild(int i);
@ -89,7 +89,7 @@ namespace Antlr4.Runtime.Tree
/// <summary>
/// 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.
/// </summary>
string ToStringTree();

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

@ -91,23 +91,23 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <exception>
/// IllegalArgumentException
/// if
/// <code>tree</code>
/// <paramref name="tree"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// </exception>
/// <exception>
/// IllegalArgumentException
/// if
/// <code>pattern</code>
/// <paramref name="pattern"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// </exception>
/// <exception>
/// IllegalArgumentException
/// if
/// <code>labels</code>
/// <paramref name="labels"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// </exception>
public ParseTreeMatch(IParseTree tree, ParseTreePattern pattern, MultiMap<string, IParseTree> labels, IParseTree mismatchedNode)
{
@ -131,29 +131,29 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary>
/// Get the last node associated with a specific
/// <code>label</code>
/// <paramref name="label"/>
/// .
/// <p>For example, for pattern
/// <code><id:ID></code>
/// <c>&lt;id:ID&gt;</c>
/// ,
/// <code>get("id")</code>
/// <c>get("id")</c>
/// returns the
/// node matched for that
/// <code>ID</code>
/// <c>ID</c>
/// . If more than one node
/// matched the specified label, only the last is returned. If there is
/// no node associated with the label, this returns
/// <code>null</code>
/// <see langword="null"/>
/// .</p>
/// <p>Pattern tags like
/// <code><ID></code>
/// <c>&lt;ID&gt;</c>
/// and
/// <code><expr></code>
/// <c>&lt;expr&gt;</c>
/// without labels are
/// considered to be labeled with
/// <code>ID</code>
/// <c>ID</c>
/// and
/// <code>expr</code>
/// <c>expr</c>
/// , respectively.</p>
/// </summary>
/// <param name="label">The label to check.</param>
@ -162,7 +162,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
/// to match a tag with the specified
/// label, or
/// <code>null</code>
/// <see langword="null"/>
/// if no parse tree matched a tag with the label.
/// </returns>
[Nullable]
@ -181,28 +181,28 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <remarks>
/// Return all nodes matching a rule or token tag with the specified label.
/// <p>If the
/// <code>label</code>
/// <paramref name="label"/>
/// is the name of a parser rule or token in the
/// grammar, the resulting list will contain both the parse trees matching
/// rule or tags explicitly labeled with the label and the complete set of
/// parse trees matching the labeled and unlabeled tags in the pattern for
/// the parser rule or token. For example, if
/// <code>label</code>
/// <paramref name="label"/>
/// is
/// <code>"foo"</code>
/// <c>"foo"</c>
/// ,
/// the result will contain <em>all</em> of the following.</p>
/// <ul>
/// <li>Parse tree nodes matching tags of the form
/// <code><foo:anyRuleName></code>
/// <c>&lt;foo:anyRuleName&gt;</c>
/// and
/// <code><foo:AnyTokenName></code>
/// <c>&lt;foo:AnyTokenName&gt;</c>
/// .</li>
/// <li>Parse tree nodes matching tags of the form
/// <code><anyLabel:foo></code>
/// <c>&lt;anyLabel:foo&gt;</c>
/// .</li>
/// <li>Parse tree nodes matching tags of the form
/// <code><foo></code>
/// <c>&lt;foo&gt;</c>
/// .</li>
/// </ul>
/// </remarks>
@ -212,7 +212,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
/// nodes matching tags with
/// the specified
/// <code>label</code>
/// <paramref name="label"/>
/// . If no nodes matched the label, an empty list
/// is returned.
/// </returns>
@ -252,7 +252,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <remarks>Get the node at which we first detected a mismatch.</remarks>
/// <returns>
/// the node at which we first detected a mismatch, or
/// <code>null</code>
/// <see langword="null"/>
/// if the match was successful.
/// </returns>
public virtual IParseTree MismatchedNode
@ -267,9 +267,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <remarks>Gets a value indicating whether the match operation succeeded.</remarks>
/// <returns>
///
/// <code>true</code>
/// <see langword="true"/>
/// if the match operation succeeded; otherwise,
/// <code>false</code>
/// <see langword="false"/>
/// .
/// </returns>
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>
/// A pattern like
/// <code><ID> = <expr>;</code>
/// <c>&lt;ID&gt; = &lt;expr&gt;;</c>
/// converted to a
/// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
/// by
@ -130,12 +130,12 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <param name="tree">The parse tree to match against this tree pattern.</param>
/// <returns>
///
/// <code>true</code>
/// <see langword="true"/>
/// if
/// <code>tree</code>
/// <paramref name="tree"/>
/// is a match for the current tree
/// pattern; otherwise,
/// <code>false</code>
/// <see langword="false"/>
/// .
/// </returns>
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
/// token or rule references such as:</p>
/// <p>
/// <code><ID> = <expr>;</code>
/// <c>&lt;ID&gt; = &lt;expr&gt;;</c>
/// </p>
/// <p>Given a pattern start rule such as
/// <code>statement</code>
/// <c>statement</c>
/// , this object constructs
/// a
/// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
/// with placeholders for the
/// <code>ID</code>
/// <c>ID</c>
/// and
/// <code>expr</code>
/// <c>expr</c>
/// subtree. Then the
/// <see cref="Match(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/>
/// routines can compare an actual
/// <see cref="Antlr4.Runtime.Tree.IParseTree"/>
/// from a parse with this pattern. Tag
/// <code><ID></code>
/// <c>&lt;ID&gt;</c>
/// matches
/// any
/// <code>ID</code>
/// <c>ID</c>
/// token and tag
/// <code><expr></code>
/// <c>&lt;expr&gt;</c>
/// references the result of the
/// <code>expr</code>
/// <c>expr</c>
/// rule (generally an instance of
/// <code>ExprContext</code>
/// <c>ExprContext</c>
/// .</p>
/// <p>Pattern
/// <code>x = 0;</code>
/// <c>x = 0;</c>
/// is a similar pattern that matches the same pattern
/// except that it requires the identifier to be
/// <code>x</code>
/// <c>x</c>
/// and the expression to
/// be
/// <code>0</code>
/// <c>0</c>
/// .</p>
/// <p>The
/// <see cref="Matches(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/>
/// routines return
/// <code>true</code>
/// <see langword="true"/>
/// or
/// <code>false</code>
/// <see langword="false"/>
/// based
/// upon a match for the tree rooted at the parameter sent in. The
/// <see cref="Match(Antlr4.Runtime.Tree.IParseTree, ParseTreePattern)"/>
@ -102,7 +102,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <see cref="ParseTreePattern"/>
/// object.</p>
/// <p>See
/// <code>TestParseTreeMatcher</code>
/// <c>TestParseTreeMatcher</c>
/// for lots of examples.
/// <see cref="ParseTreePattern"/>
/// has two static helper methods:
@ -118,7 +118,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <see cref="ParseTreePatternMatcher"/>
/// constructor are used to parse the pattern in string form. The lexer converts
/// the
/// <code><ID> = <expr>;</code>
/// <c>&lt;ID&gt; = &lt;expr&gt;;</c>
/// into a sequence of four tokens (assuming lexer
/// throws out whitespace or puts it on a hidden channel). Be aware that the
/// input stream is reset for the lexer (but not the parser; a
@ -127,30 +127,30 @@ namespace Antlr4.Runtime.Tree.Pattern
/// fields you have put into the lexer might get changed when this mechanism asks
/// it to scan the pattern string.</p>
/// <p>Normally a parser does not accept token
/// <code><expr></code>
/// <c>&lt;expr&gt;</c>
/// as a valid
/// <code>expr</code>
/// <c>expr</c>
/// but, from the parser passed in, we create a special version of
/// the underlying grammar representation (an
/// <see cref="Antlr4.Runtime.Atn.ATN"/>
/// ) that allows imaginary
/// tokens representing rules (
/// <code><expr></code>
/// <c>&lt;expr&gt;</c>
/// ) to match entire rules. We call
/// these <em>bypass alternatives</em>.</p>
/// <p>Delimiters are
/// <code>&lt;</code>
/// <c>&lt;</c>
/// and
/// <code>&gt;</code>
/// <c>&gt;</c>
/// , with
/// <code>\</code>
/// <c>\</c>
/// as the escape string
/// by default, but you can set them to whatever you want using
/// <see cref="SetDelimiters(string, string, string)"/>
/// . You must escape both start and stop strings
/// <code>\&lt;</code>
/// <c>\&lt;</c>
/// and
/// <code>\&gt;</code>
/// <c>\&gt;</c>
/// .</p>
/// </summary>
public class ParseTreePatternMatcher
@ -223,17 +223,17 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <exception>
/// IllegalArgumentException
/// if
/// <code>start</code>
/// <paramref name="start"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// or empty.
/// </exception>
/// <exception>
/// IllegalArgumentException
/// if
/// <code>stop</code>
/// <paramref name="stop"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// or empty.
/// </exception>
public virtual void SetDelimiters(string start, string stop, string escapeLeft)
@ -253,11 +253,11 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary>
/// Does
/// <code>pattern</code>
/// <paramref name="pattern"/>
/// matched as rule
/// <code>patternRuleIndex</code>
/// <paramref name="patternRuleIndex"/>
/// match
/// <code>tree</code>
/// <paramref name="tree"/>
/// ?
/// </summary>
public virtual bool Matches(IParseTree tree, string pattern, int patternRuleIndex)
@ -268,7 +268,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary>
/// Does
/// <code>pattern</code>
/// <paramref name="pattern"/>
/// matched as rule patternRuleIndex match tree? Pass in a
/// compiled pattern instead of a string representation of a tree pattern.
/// </summary>
@ -281,11 +281,11 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary>
/// Compare
/// <code>pattern</code>
/// <paramref name="pattern"/>
/// matched as rule
/// <code>patternRuleIndex</code>
/// <paramref name="patternRuleIndex"/>
/// against
/// <code>tree</code>
/// <paramref name="tree"/>
/// and return a
/// <see cref="ParseTreeMatch"/>
/// object that contains the
@ -299,9 +299,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary>
/// Compare
/// <code>pattern</code>
/// <paramref name="pattern"/>
/// matched against
/// <code>tree</code>
/// <paramref name="tree"/>
/// and return a
/// <see cref="ParseTreeMatch"/>
/// object that contains the matched elements, or the
@ -386,22 +386,22 @@ namespace Antlr4.Runtime.Tree.Pattern
// ---- SUPPORT CODE ----
/// <summary>
/// Recursively walk
/// <code>tree</code>
/// <paramref name="tree"/>
/// against
/// <code>patternTree</code>
/// <paramref name="patternTree"/>
/// , filling
/// <code>match.</code>
/// <c>match.</c>
/// <see cref="ParseTreeMatch#labels">labels</see>
/// .
/// </summary>
/// <returns>
/// the first node encountered in
/// <code>tree</code>
/// <paramref name="tree"/>
/// which does not match
/// a corresponding node in
/// <code>patternTree</code>
/// <paramref name="patternTree"/>
/// , or
/// <code>null</code>
/// <see langword="null"/>
/// if the match
/// was successful. The specific node returned depends on the matching
/// algorithm used by the implementation, and may be overridden.
@ -516,9 +516,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary>
/// Is
/// <code>t</code>
/// <paramref name="t"/>
///
/// <code>(expr <expr>)</code>
/// <c>(expr &lt;expr&gt;)</c>
/// subtree?
/// </summary>
protected internal virtual RuleTagToken GetRuleTagToken(IParseTree t)
@ -598,7 +598,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <summary>
/// Split
/// <code><ID> = <e:expr> ;</code>
/// <c>&lt;ID&gt; = &lt;e:expr&gt; ;</c>
/// into 4 chunks for tokenizing by
/// <see cref="Tokenize(string)"/>
/// .

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

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

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

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

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

@ -61,9 +61,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <exception>
/// IllegalArgumentException
/// if
/// <code>text</code>
/// <paramref name="text"/>
/// is
/// <code>null</code>
/// <see langword="null"/>
/// .
/// </exception>
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
/// <see cref="Antlr4.Runtime.IToken"/>
/// object representing a token of a particular type; e.g.,
/// <code><ID></code>
/// <c>&lt;ID&gt;</c>
/// . These tokens are created for
/// <see cref="TagChunk"/>
/// chunks where the
@ -85,7 +85,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <param name="type">The token type.</param>
/// <param name="label">
/// The label associated with the token tag, or
/// <code>null</code>
/// <see langword="null"/>
/// if
/// the token tag is unlabeled.
/// </param>
@ -111,7 +111,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <remarks>Gets the label associated with the rule tag.</remarks>
/// <returns>
/// The name of the label associated with the rule tag, or
/// <code>null</code>
/// <see langword="null"/>
/// if this is an unlabeled rule tag.
/// </returns>
public string Label
@ -128,9 +128,9 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <see cref="TokenTagToken"/>
/// returns the token tag
/// formatted with
/// <code>&lt;</code>
/// <c>&lt;</c>
/// and
/// <code>&gt;</code>
/// <c>&gt;</c>
/// delimiters.</p>
/// </summary>
public override string Text
@ -150,7 +150,7 @@ namespace Antlr4.Runtime.Tree.Pattern
/// <p>The implementation for
/// <see cref="TokenTagToken"/>
/// returns a string of the form
/// <code>tokenName:type</code>
/// <c>tokenName:type</c>
/// .</p>
/// </summary>
public override string ToString()

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

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

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

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