public Lexer(ICharStream input, TextWriter output, TextWriter errorOutput)
{
this._input = input;
this.Output = output;
this.ErrorOutput = errorOutput;
this._tokenFactorySourcePair = Tuple.Create((ITokenSource)this, input);
}
/// <summary>
/// Constructs a new
/// <see cref="CommonToken"/>
/// with the specified token type and
/// text.
/// </summary>
/// <param name="type">The token type.</param>
/// <param name="text">The text of the token.</param>
public CommonToken(int type, string text)
{
this._type = type;
this._channel = TokenConstants.DefaultChannel;
this._text = text;
this.source = EmptySource;
}
private static void GetElementDependencies(ICustomAttributeProvider annotatedElement, IList <Sharpen.Tuple <RuleDependencyAttribute, ICustomAttributeProvider> > result)
{
foreach (RuleDependencyAttribute dependency in annotatedElement.GetCustomAttributes(typeof(RuleDependencyAttribute), true))
{
result.Add(Tuple.Create(dependency, annotatedElement));
}
}
/// <summary>Set the char stream and reset the lexer</summary>
public virtual void SetInputStream(ICharStream input)
{
this._input = null;
this._tokenFactorySourcePair = Tuple.Create((ITokenSource)this, _input);
Reset();
this._input = input;
this._tokenFactorySourcePair = Tuple.Create((ITokenSource)this, _input);
}
/// <summary>Begin parsing at startRuleIndex</summary>
public virtual ParserRuleContext Parse(int startRuleIndex)
{
RuleStartState startRuleStartState = _atn.ruleToStartState[startRuleIndex];
InterpreterRuleContext rootContext = new InterpreterRuleContext(null, ATNState.InvalidStateNumber, startRuleIndex);
if (startRuleStartState.isPrecedenceRule)
{
EnterRecursionRule(rootContext, startRuleStartState.stateNumber, startRuleIndex, 0);
}
else
{
EnterRule(rootContext, startRuleStartState.stateNumber, startRuleIndex);
}
while (true)
{
ATNState p = AtnState;
switch (p.StateType)
{
case StateType.RuleStop:
{
// pop; return from rule
if (RuleContext.IsEmpty)
{
if (startRuleStartState.isPrecedenceRule)
{
ParserRuleContext result = RuleContext;
Sharpen.Tuple <ParserRuleContext, int> parentContext = _parentContextStack.Pop();
UnrollRecursionContexts(parentContext.Item1);
return(result);
}
else
{
ExitRule();
return(rootContext);
}
}
VisitRuleStopState(p);
break;
}
default:
{
try
{
VisitState(p);
}
catch (RecognitionException e)
{
State = _atn.ruleToStopState[p.ruleIndex].stateNumber;
Context.exception = e;
ErrorHandler.ReportError(this, e);
ErrorHandler.Recover(this, e);
}
break;
}
}
}
}
public CommonToken(Sharpen.Tuple <ITokenSource, ICharStream> source, int type, int channel, int start, int stop)
{
this.source = source;
this._type = type;
this._channel = channel;
this.start = start;
this.stop = stop;
if (source.Item1 != null)
{
this._line = source.Item1.Line;
this.charPositionInLine = source.Item1.Column;
}
}
protected internal virtual void VisitRuleStopState(ATNState p)
{
RuleStartState ruleStartState = _atn.ruleToStartState[p.ruleIndex];
if (ruleStartState.isPrecedenceRule)
{
Sharpen.Tuple <ParserRuleContext, int> parentContext = _parentContextStack.Pop();
UnrollRecursionContexts(parentContext.Item1);
State = parentContext.Item2;
}
else
{
ExitRule();
}
RuleTransition ruleTransition = (RuleTransition)_atn.states[State].Transition(0);
State = ruleTransition.followState.stateNumber;
}
public virtual CommonToken Create(Sharpen.Tuple <ITokenSource, ICharStream> source, int type, string text, int channel, int start, int stop, int line, int charPositionInLine)
{
CommonToken t = new CommonToken(source, type, channel, start, stop);
t.Line = line;
t.Column = charPositionInLine;
if (text != null)
{
t.Text = text;
}
else
{
if (copyText && source.Item2 != null)
{
t.Text = source.Item2.GetText(Interval.Of(start, stop));
}
}
return(t);
}
/// <summary>
/// Constructs a new
/// <see cref="CommonToken"/>
/// as a copy of another
/// <see cref="IToken"/>
/// .
/// <p>
/// If
/// <paramref name="oldToken"/>
/// is also a
/// <see cref="CommonToken"/>
/// instance, the newly
/// constructed token will share a reference to the
/// <see cref="Text()"/>
/// field and
/// the
/// <see cref="Tuple{T1, T2}"/>
/// stored in
/// <see cref="source"/>
/// . Otherwise,
/// <see cref="Text()"/>
/// will
/// be assigned the result of calling
/// <see cref="Text()"/>
/// , and
/// <see cref="source"/>
/// will be constructed from the result of
/// <see cref="IToken.TokenSource()"/>
/// and
/// <see cref="IToken.InputStream()"/>
/// .</p>
/// </summary>
/// <param name="oldToken">The token to copy.</param>
public CommonToken(IToken oldToken)
{
_type = oldToken.Type;
_line = oldToken.Line;
index = oldToken.TokenIndex;
charPositionInLine = oldToken.Column;
_channel = oldToken.Channel;
start = oldToken.StartIndex;
stop = oldToken.StopIndex;
if (oldToken is Antlr4.Runtime.CommonToken)
{
_text = ((Antlr4.Runtime.CommonToken)oldToken)._text;
source = ((Antlr4.Runtime.CommonToken)oldToken).source;
}
else
{
_text = oldToken.Text;
source = Sharpen.Tuple.Create(oldToken.TokenSource, oldToken.InputStream);
}
}
IToken ITokenFactory.Create(Sharpen.Tuple <ITokenSource, ICharStream> source, int type, string text, int channel, int start, int stop, int line, int charPositionInLine)
{
return(Create(source, type, text, channel, start, stop, line, charPositionInLine));
}
public override void EnterRecursionRule(ParserRuleContext localctx, int state, int ruleIndex, int precedence)
{
_parentContextStack.Push(Tuple.Create(RuleContext, localctx.invokingState));
base.EnterRecursionRule(localctx, state, ruleIndex, precedence);
}
/// <summary>
/// Constructs a new
/// <see cref="CommonToken"/>
/// with the specified token type.
/// </summary>
/// <param name="type">The token type.</param>
public CommonToken(int type)
{
// set to invalid position
this._type = type;
this.source = EmptySource;
}
protected internal virtual void ReadStates(ATN atn)
{
//
// STATES
//
IList <Sharpen.Tuple <LoopEndState, int> > loopBackStateNumbers = new List <Sharpen.Tuple <LoopEndState, int> >();
IList <Sharpen.Tuple <BlockStartState, int> > endStateNumbers = new List <Sharpen.Tuple <BlockStartState, int> >();
int nstates = ReadInt();
for (int i_1 = 0; i_1 < nstates; i_1++)
{
StateType stype = (StateType)ReadInt();
// ignore bad type of states
if (stype == StateType.InvalidType)
{
atn.AddState(null);
continue;
}
int ruleIndex = ReadInt();
if (ruleIndex == char.MaxValue)
{
ruleIndex = -1;
}
ATNState s = StateFactory(stype, ruleIndex);
if (stype == StateType.LoopEnd)
{
// special case
int loopBackStateNumber = ReadInt();
loopBackStateNumbers.Add(Tuple.Create((LoopEndState)s, loopBackStateNumber));
}
else
{
if (s is BlockStartState)
{
int endStateNumber = ReadInt();
endStateNumbers.Add(Tuple.Create((BlockStartState)s, endStateNumber));
}
}
atn.AddState(s);
}
// delay the assignment of loop back and end states until we know all the state instances have been initialized
foreach (Sharpen.Tuple <LoopEndState, int> pair in loopBackStateNumbers)
{
pair.Item1.loopBackState = atn.states[pair.Item2];
}
foreach (Sharpen.Tuple <BlockStartState, int> pair_1 in endStateNumbers)
{
pair_1.Item1.endState = (BlockEndState)atn.states[pair_1.Item2];
}
int numNonGreedyStates = ReadInt();
for (int i_2 = 0; i_2 < numNonGreedyStates; i_2++)
{
int stateNumber = ReadInt();
((DecisionState)atn.states[stateNumber]).nonGreedy = true;
}
int numPrecedenceStates = ReadInt();
for (int i_4 = 0; i_4 < numPrecedenceStates; i_4++)
{
int stateNumber = ReadInt();
((RuleStartState)atn.states[stateNumber]).isPrecedenceRule = true;
}
}
public Lexer(ICharStream input)
{
this._input = input;
this._tokenFactorySourcePair = Sharpen.Tuple.Create((ITokenSource)this, input);
}
