public WhileStatementAstNode(
ExpressionAstNode expression,
StatementAstNode statement,
int line, int column)
: base(line, column)
{
Expression = expression;
Statement = statement;
}
public LabeledStatementAstNode(
LabelAstNode label,
StatementAstNode statement,
int line, int column)
: base(line, column)
{
Label = label;
Statement = statement;
}
public override InoTypeEnum Visit(StatementAstNode node)
{
foreach (ASTNode child in node.Children)
{
_ = Visit(child);
}
return(InoTypeEnum.undefined);
}
public DoStatementAstNode(
StatementAstNode statement,
ExpressionAstNode expression,
int line, int column)
: base(line, column)
{
Statement = statement;
Expression = expression;
}
public IfStatementAstNode(
ExpressionAstNode expression,
StatementAstNode statement,
StatementAstNode?elseStatement,
int line, int column)
: base(line, column)
{
Expression = expression;
Statement = statement;
ElseStatement = elseStatement;
}
public ForStatementAstNode(
ExpressionAstNode?initializationExpression,
ExpressionAstNode?conditionExpression,
ExpressionAstNode?afterthoughtExpression,
StatementAstNode statement,
int line, int column)
: base(line, column)
{
InitializationExpression = initializationExpression;
ConditionExpression = conditionExpression;
AfterthoughtExpression = afterthoughtExpression;
Statement = statement;
}
public void VisitStatement(StatementAstNode n)
{
switch (n)
{
case CompoundStatementAstNode node:
VisitCompoundStatement(node);
break;
case DeclarationStatementAstNode node:
VisitDeclarationStatement(node);
break;
case DoStatementAstNode node:
VisitDoStatement(node);
break;
case ExpressionStatementAstNode node:
VisitExpressionStatement(node);
break;
case ForStatementAstNode node:
VisitForStatement(node);
break;
case IfStatementAstNode node:
VisitIfStatement(node);
break;
case JumpStatementAstNode node:
VisitJumpStatement(node);
break;
case LabeledStatementAstNode node:
VisitLabeledStatement(node);
break;
case SwitchStatementAstNode node:
VisitSwitchStatement(node);
break;
case WhileStatementAstNode node:
VisitWhileStatement(node);
break;
default:
throw new NotImplementedException(n.GetType().Name);
}
}
public override ASTNode VisitS([NotNull] p4Parser.SContext context)
{
StatementAstNode Root = null;
if (context.importStmt() != null)
{
foreach (IParseTree importstmt in context.importStmt())
{
if (Root == null)
{
Root = new StatementAstNode(Visit(importstmt), null);
}
else
{
Root.Push(new StatementAstNode(Visit(importstmt), null));
}
}
}
if (context.global() != null)
{
foreach (IParseTree globalDcl in context.global())
{
if (Root == null)
{
Root = new StatementAstNode(Visit(globalDcl), null);
}
else
{
Root.Push(new StatementAstNode(Visit(globalDcl), null));
}
}
}
if (context.main() != null)
{
if (Root == null)
{
Root = new StatementAstNode(Visit(context.main()), null);
}
else
{
Root.Push(new StatementAstNode(Visit(context.main()), null));
}
}
return(Root);
}
public override ASTNode VisitBlock([NotNull] p4Parser.BlockContext context)
{
StatementAstNode Root = null;
foreach (IParseTree stmt in context.stmt())
{
if (Root == null)
{
Root = new StatementAstNode(Visit(stmt), null);
}
else
{
Root.Push(new StatementAstNode(Visit(stmt), null));
}
}
return(Root);
}
public override string Visit(StatementAstNode node)
{
string Code = "";
string CurrentCode = "";
for (int i = 0; i < IndentationDepth; i++)
{
Code += Spaces;
}
foreach (ASTNode child in node.Children)
{
CurrentCode = Visit(child);
if (CurrentCode != "")
{
Code += CurrentCode + "\n";
}
}
return(Code);
}
/// <summary>
/// Create Statement node from AST to the model
/// </summary>
/// <param name="astStatement">The statement node in AST</param>
/// <returns>Statement node from the meta model</returns>
private Statement ConvertStatementAst(StatementAstNode astStatement)
{
if (astStatement == null)
return null;
if (astStatement is StatementListNode)
{
var statmentListNode = astStatement as StatementListNode;
return new CompositeStatement(
statmentListNode.StatementList.Select(s => ConvertStatementAst(s)).ToList()
);
}
else if (astStatement is ForAllStatementAstNode)
{
var forAllAstNode = astStatement as ForAllStatementAstNode;
return new ForAllStatement(
CreateVariable(forAllAstNode.Iterator.Name),
ConvertExpressionAst(forAllAstNode.Set),
ConvertStatementAst(forAllAstNode.StatementList));
}
else if (astStatement is IfStatementAstNode)
{
var ifAstNode = astStatement as IfStatementAstNode;
return new IfStatement(
ConvertExpressionAst(ifAstNode.Condition),
ConvertStatementAst(ifAstNode.IfTrueStatments),
ConvertStatementAst(ifAstNode.IfFalseStatements));
}
else if (astStatement is OpenPositionAstNode)
{
var openOpAst = astStatement as OpenPositionAstNode;
return new OpenPosition(
CreateVariable(openOpAst.PositionSetAstNode.PositionSetName),
ConvertExpressionAst(openOpAst.ExpressionAstNode));
}
else if (astStatement is ClosePositionAstNode)
{
var closeOpAst = astStatement as ClosePositionAstNode;
return new ClosePosition(
ConvertExpressionAst(closeOpAst.Variable)
);
}
else if (astStatement is AssignmentExprAstNode)
{
var assignmentAst = astStatement as AssignmentExprAstNode;
return new Assignment(
CreateVariable(assignmentAst.Variable.Name),
ConvertExpressionAst(assignmentAst.Expression));
}
else if (astStatement is DeclarationAstNode)
{
var declarationAst = astStatement as DeclarationAstNode;
return new Assignment(
CreateVariable(declarationAst.Variable.Name, declarationAst.Type),
ConvertExpressionAst(declarationAst.Initialization));
}
else
{
throw new Exception("The derived type of TradingRuleAstNode is not handled. Type name: " + astStatement.GetType().ToString());
}
}
