protected internal virtual void ReadEdges(ATN atn, IList <IntervalSet> sets)
{
//
// EDGES
//
int nedges = ReadInt();
for (int i_9 = 0; i_9 < nedges; i_9++)
{
int src = ReadInt();
int trg = ReadInt();
TransitionType ttype = (TransitionType)ReadInt();
int arg1 = ReadInt();
int arg2 = ReadInt();
int arg3 = ReadInt();
Transition trans = EdgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets);
ATNState srcState = atn.states[src];
srcState.AddTransition(trans);
}
// edges for rule stop states can be derived, so they aren't serialized
foreach (ATNState state_1 in atn.states)
{
for (int i_10 = 0; i_10 < state_1.NumberOfTransitions; i_10++)
{
Transition t = state_1.Transition(i_10);
if (!(t is RuleTransition))
{
continue;
}
RuleTransition ruleTransition = (RuleTransition)t;
int outermostPrecedenceReturn = -1;
if (atn.ruleToStartState[ruleTransition.target.ruleIndex].isPrecedenceRule)
{
if (ruleTransition.precedence == 0)
{
outermostPrecedenceReturn = ruleTransition.target.ruleIndex;
}
}
EpsilonTransition returnTransition = new EpsilonTransition(ruleTransition.followState, outermostPrecedenceReturn);
atn.ruleToStopState[ruleTransition.target.ruleIndex].AddTransition(returnTransition);
}
}
foreach (ATNState state_2 in atn.states)
{
if (state_2 is BlockStartState)
{
// we need to know the end state to set its start state
if (((BlockStartState)state_2).endState == null)
{
throw new InvalidOperationException();
}
// block end states can only be associated to a single block start state
if (((BlockStartState)state_2).endState.startState != null)
{
throw new InvalidOperationException();
}
((BlockStartState)state_2).endState.startState = (BlockStartState)state_2;
}
else if (state_2 is PlusLoopbackState)
{
PlusLoopbackState loopbackState = (PlusLoopbackState)state_2;
for (int i_10 = 0; i_10 < loopbackState.NumberOfTransitions; i_10++)
{
ATNState target = loopbackState.Transition(i_10).target;
if (target is PlusBlockStartState)
{
((PlusBlockStartState)target).loopBackState = loopbackState;
}
}
}
else if (state_2 is StarLoopbackState)
{
StarLoopbackState loopbackState = (StarLoopbackState)state_2;
for (int i_10 = 0; i_10 < loopbackState.NumberOfTransitions; i_10++)
{
ATNState target = loopbackState.Transition(i_10).target;
if (target is StarLoopEntryState)
{
((StarLoopEntryState)target).loopBackState = loopbackState;
}
}
}
}
}
protected internal virtual ATNState StateFactory(StateType type, int ruleIndex)
{
ATNState s;
switch (type)
{
case StateType.InvalidType:
{
return(null);
}
case StateType.Basic:
{
s = new BasicState();
break;
}
case StateType.RuleStart:
{
s = new RuleStartState();
break;
}
case StateType.BlockStart:
{
s = new BasicBlockStartState();
break;
}
case StateType.PlusBlockStart:
{
s = new PlusBlockStartState();
break;
}
case StateType.StarBlockStart:
{
s = new StarBlockStartState();
break;
}
case StateType.TokenStart:
{
s = new TokensStartState();
break;
}
case StateType.RuleStop:
{
s = new RuleStopState();
break;
}
case StateType.BlockEnd:
{
s = new BlockEndState();
break;
}
case StateType.StarLoopBack:
{
s = new StarLoopbackState();
break;
}
case StateType.StarLoopEntry:
{
s = new StarLoopEntryState();
break;
}
case StateType.PlusLoopBack:
{
s = new PlusLoopbackState();
break;
}
case StateType.LoopEnd:
{
s = new LoopEndState();
break;
}
default:
{
string message = string.Format(CultureInfo.CurrentCulture, "The specified state type {0} is not valid.", type);
throw new ArgumentException(message);
}
}
s.ruleIndex = ruleIndex;
return(s);
}