public override List <GraphNode <SStatement> > BuildGraphNodes(Graph <SStatement> graph,
List <GraphNode <SStatement> > previousNodes)
{
var currentNode = graph.AddNode(new GraphNode <SStatement>(this));
foreach (var node in previousNodes)
{
graph.AddDirectedEdge(node, currentNode, 1);
}
previousNodes = new List <GraphNode <SStatement> > {
currentNode
};
if (_statementList.Length > 0 && _statementList[0] != null)
{
previousNodes = _statementList[0].BuildGraphNodes(graph, previousNodes);
}
if (NextStatement != null)
{
previousNodes = NextStatement.BuildGraphNodes(graph, previousNodes);
}
return(previousNodes);
}
public override List <GraphNode <SStatement> > BuildGraphNodes(Graph <SStatement> graph,
List <GraphNode <SStatement> > previousNodes)
{
var currentNode = graph.AddNode(new GraphNode <SStatement>(this));
foreach (var node in previousNodes)
{
graph.AddDirectedEdge(node, currentNode, 1);
}
var currentNodes = new List <GraphNode <SStatement> > {
currentNode
};
var ntrue = IfTrueStatement.BuildGraphNodes(graph, currentNodes);
if (ElseStatement != null)
{
var nfalse = ElseStatement.BuildGraphNodes(graph, currentNodes);
ntrue.AddRange(nfalse);
}
else
{
ntrue.Add(currentNode);
}
previousNodes = NextStatement != null?NextStatement.BuildGraphNodes(graph, ntrue) : ntrue;
return(previousNodes);
}
public virtual object Walk(NextStatement node)
{
if (Enter(node))
{
// Insert code here
}
Exit(node);
return(null);
}
public override string VisitNextStatement(BasicParser.NextStatementContext context)
{
var variableName = context.VARNAME().ToString();
var nextStatement = new NextStatement(variableName);
Statements[_currentLineNumber] = nextStatement;
return(base.VisitNextStatement(context));
}
public NextStatement ParseNextStatement()
{
var nextStatement = new NextStatement {
Token = Next()
};
Match(TokenType.Next);
Match(TokenType.SemiColon);
return(nextStatement);
}
public override List <GraphNode <SStatement> > BuildGraphNodes(Graph <SStatement> graph,
List <GraphNode <SStatement> > previousNodes)
{
var currentNodes = new List <GraphNode <SStatement> >();
var currentNode = graph.AddNode(new GraphNode <SStatement>(this));
graph.AddDirectedEdges(previousNodes, currentNode, 1);
var currentNodeList = new List <GraphNode <SStatement> > {
currentNode
};
var nextNode = new List <GraphNode <SStatement> >();
if (SwitchStatement != null)
{
nextNode.AddRange(SwitchStatement.BuildGraphNodes(graph, currentNodeList));
}
foreach (var jumpTarget in jumpTargets)
{
var a = FindNodes(graph, jumpTarget.NextStatement);
if (a != null)
{
foreach (var graphNode in a)
{
graphNode.Neighbors.Clear();
graphNode.Costs.Clear();
}
}
AddDirectedEdgeToElements(graph, currentNode.Value, jumpTarget.LabeledStatement);
currentNodes.AddRange(FindNodes(graph, jumpTarget.NextStatement));
}
currentNodes.AddRange(nextNode);
//todo: change default on enum
if (jumpTargets.Count(q => q.CodeString == "default") == 0)
{
currentNodes.Add(currentNode);
}
if (NextStatement != null)
{
currentNodes = new List <GraphNode <SStatement> >(NextStatement.BuildGraphNodes(graph, currentNodes));
}
return(currentNodes);
}
public override List <GraphNode <SStatement> > BuildGraphNodes(Graph <SStatement> graph,
List <GraphNode <SStatement> > previousNodes)
{
TargetStatement?.AddJumpOrigin(this);
var currentNode = graph.AddNode(new GraphNode <SStatement>(this));
foreach (var node in previousNodes)
{
graph.AddDirectedEdge(node, currentNode, 1);
}
previousNodes = new List <GraphNode <SStatement> > {
currentNode
};
var findedNode = (GraphNode <SStatement>)graph.Nodes.FindByValue(TargetStatement);
graph.AddDirectedEdge(currentNode, findedNode, 1);
return(NextStatement != null
? NextStatement.BuildGraphNodes(graph, previousNodes)
: new List <GraphNode <SStatement> >());
}
public virtual void Exit(NextStatement node)
{
}
//factory method that takes a line of input and creates a statement
//object
public static Statement CreateStatement(Scanner s)
{
//Remember what line we started on in case the
//statement spans lines.
int line = s.LineNumber;
bool please = false;
bool enabled = true;
int percent = 100;
Statement retval = null;
string Label = null;
try
{
//First we look to see if there is a label...
if (s.Current.Groups["label"].Success)
{
Label = Statement.ReadGroupValue(s, "label");
s.MoveNext();
}
bool validPrefix = false;
//Next we expect either DO, PLEASE, or PLEASE DO
if (s.Current.Value == "PLEASE")
{
validPrefix = true;
please = true;
s.MoveNext();
}
//If they've said PLEASE then they don't *have* to
//use DO. Unless they plan on doing a DON'T or DO NOT
if (s.Current.Value == "DO")
{
validPrefix = true;
s.MoveNext();
if (s.Current.Value == "NOT" ||
s.Current.Value == "N'T")
{
enabled = false;
s.MoveNext();
}
}
//Finally the user might put a %50 here. Note that
//even if the statement is disabled we need to remember
//the % on the off chance that the statement gets enabled
//later.
if (s.Current.Value == "%")
{
s.MoveNext();
string p = Statement.ReadGroupValue(s, "digits");
percent = Int32.Parse(p);
s.MoveNext();
}
//Here we parse out the statement prefix. Easier to
//do it here than break out a separate function.
while (s.Current.Groups["prefix"].Success)
{
switch (s.Current.Value)
{
case "DO":
validPrefix = true;
break;
case "PLEASE":
validPrefix = true;
please = true;
break;
case "NOT":
case "N'T":
enabled = false;
break;
case "%":
s.MoveNext();
string p = Statement.ReadGroupValue(s, "digits");
percent = Int32.Parse(p);
break;
}
s.MoveNext();
}
if (!validPrefix)
{
throw new ParseException(String.Format(Messages.E017, s.LineNumber + 1));
}
if (s.Current.Groups["statement"].Success)
{
//We are looking at the beginning of a statement
switch (s.Current.Value)
{
case "ABSTAIN FROM": retval = new AbstainStatement(s); break;
case "READ OUT": retval = new ReadOutStatement(s); break;
case "WRITE IN": retval = new WriteInStatement(s); break;
case "COME FROM": retval = new ComeFromStatement(s); break;
case "REINSTATE": retval = new ReinstateStatement(s); break;
case "STASH": retval = new StashStatement(s); break;
case "RESUME": retval = new ResumeStatement(s); break;
case "FORGET": retval = new ForgetStatement(s); break;
case "IGNORE": retval = new IgnoreStatement(s); break;
case "REMEMBER": retval = new RememberStatement(s); break;
case "RETRIEVE": retval = new RetrieveStatement(s); break;
case "GIVE UP": retval = new GiveUpStatement(s); break;
}
}
else if (s.Current.Groups["label"].Success)
{
retval = new NextStatement(s);
}
else if (s.Current.Groups["var"].Success)
{
retval = new CalculateStatement(s);
}
else
{
throw new ParseException(String.Format(Messages.E017, s.LineNumber + 1));
}
//Move on to what should be the beginning of the next statement
s.MoveNext();
}
catch (ParseException)
{
//Console.WriteLine(p.Message);
if (retval != null)
{
retval.Splatted = true;
}
else
{
retval = new NonsenseStatement(s);
}
s.Panic();
}
//Note that even badly formed statements get their labels set. This way
//you can still jump to them (though that will cause an exception).
if (Label != null)
{
retval.Label = Label;
}
retval.LineNumber = line;
retval.bEnabled = enabled;
retval.bPlease = please;
retval.Percent = percent;
return(retval);
}
public virtual bool Enter(NextStatement node)
{
return(true);
}
public NextStatement ParseNextStatement()
{
var nextStatement = new NextStatement { Token = Next() };
Match(TokenType.Next);
Match(TokenType.SemiColon);
return nextStatement;
}
public override object Walk(NextStatement node)
{
throw new Next();
}
public override void Exit(NextStatement node)
{
level--;
}
public virtual object Walk(NextStatement node)
{
if (Enter(node))
{
// Insert code here
}
Exit(node);
return null;
}
public override bool Enter(NextStatement node)
{
Print("NextStatement");
level++;
return true;
}
public virtual bool Enter(NextStatement node)
{
return true;
}
protected override void visitNextStatement(NextStatement statement)
{
appendExitOrNextStatement(statement, KeywordEnum.NEXT, statement.Loop, statement.Condition);
}
public virtual void Exit(NextStatement node)
{
}
public override object Walk(NextStatement node)
{
throw new Next();
}
public override void Exit(NextStatement node)
{
level--;
}
public override bool Enter(NextStatement node)
{
Print("NextStatement");
level++;
return(true);
}
