private void Write(PythonNode stmt, bool notlambda = true)
{
if (stmt is PythonAstNode)
{
Write(stmt as PythonAstNode);
}
else if (stmt is SuiteStatementNode)
{
Write(stmt as SuiteStatementNode);
}
else if (stmt is ExpressionStatementNode)
{
Write(stmt as ExpressionStatementNode, notlambda);
}
else if (stmt is NameExpressionNode)
{
Write(stmt as NameExpressionNode);
}
else if (stmt is OrExpressionNode)
{
Write((OrExpressionNode)stmt);
}
else
{
throw new NotImplementedException(stmt.GetType().ToString());
}
}
public static NodeInfo CreateInfo(PythonNode node)
{
var type = node.GetType().Name;
dynamic nodeValue;
switch (type)
{
case "FunctionDefinitionNode":
nodeValue = ((FunctionDefinition)node.InnerNode).Name;
break;
case "ConstantExpressionNode":
nodeValue = ((ConstantExpression)node.InnerNode).Value;
break;
case "AugmentedAssignStatementNode":
nodeValue = ((AugmentedAssignStatement)node.InnerNode).Operator;
break;
case "BinaryExpressionNode":
nodeValue = ((BinaryExpression)node.InnerNode).Operator;
break;
case "NameExpressionNode":
nodeValue = ((NameExpression)node.InnerNode).Name;
break;
case "TupleExpressionNode":
nodeValue = ((TupleExpression)node.InnerNode).IsExpandable;
break;
case "ParameterNode":
nodeValue = ((Parameter)node.InnerNode).Name;
break;
case "ArgNode":
case "CallExpressionNode":
case "LambdaExpressionNode":
case "SuiteStatementNode":
case "IfStatementNode":
case "IfStatementTestNode":
case "AssignmentStatementNode":
case "ReturnStatementNode":
case "ExpressionStatementNode":
case "WhileStatementNode":
case "ParenthesisExpressionNode":
case "ForStatementNode":
case "ConditionalExpressionNode":
nodeValue = null;
break;
default:
throw new NotImplementedException();
}
return(nodeValue == null ? new NodeInfo(type) : new NodeInfo(type, nodeValue));
}
public PythonNode GetCorrespondingNodeByBinding(PythonNode node)
{
if (Id == node.Id && Equals(Value, node.Value) && GetType() == node.GetType())
{
return(this);
}
foreach (var child in Children)
{
var childResult = child.GetCorrespondingNodeByBinding(node);
if (childResult != null)
{
return(childResult);
}
}
return(null);
}
public bool ContainsByBinding(PythonNode node)
{
if (Id == node.Id && Equals(Value, node.Value) && GetType() == node.GetType())
{
return(true);
}
foreach (var child in Children)
{
var contains = child.ContainsByBinding(node);
if (contains)
{
return(true);
}
}
return(false);
}
public bool MatchTemplate(PythonNode node)
{
if (node.GetType() != GetType())
{
return(false);
}
if (Children.Count != node.Children.Count)
{
return(false);
}
for (var i = 0; i < Children.Count; i++)
{
if (!Children[i].MatchTemplate(node.Children[i]))
{
return(false);
}
}
return(true);
}
private void Write(PythonNode stmt, bool notlambda = true)
{
if (stmt is PythonAstNode)
{
Write(stmt as PythonAstNode);
}
else if (stmt is SuiteStatementNode)
{
Write(stmt as SuiteStatementNode);
}
else if (stmt is FunctionDefinitionNode)
{
Write(stmt as FunctionDefinitionNode);
}
else if (stmt is ReturnStatementNode)
{
Write(stmt as ReturnStatementNode, notlambda);
}
else if (stmt is IfStatementNode)
{
Write(stmt as IfStatementNode);
}
else if (stmt is AssignmentStatementNode)
{
Write(stmt as AssignmentStatementNode);
}
else if (stmt is AugmentedAssignStatementNode)
{
Write(stmt as AugmentedAssignStatementNode);
}
else if (stmt is ForStatementNode)
{
Write(stmt as ForStatementNode);
}
else if (stmt is WhileStatementNode)
{
Write(stmt as WhileStatementNode);
}
else if (stmt is ExpressionStatementNode)
{
Write(stmt as ExpressionStatementNode, notlambda);
}
else if (stmt is ImportStatementNode)
{
Write(stmt as ImportStatementNode);
}
else if (stmt is NameExpressionNode)
{
Write(stmt as NameExpressionNode);
}
else if (stmt is BinaryExpressionNode)
{
Write(stmt as BinaryExpressionNode);
}
else if (stmt is ConstantExpressionNode)
{
Write(stmt as ConstantExpressionNode);
}
else if (stmt is CallExpressionNode)
{
Write(stmt as CallExpressionNode);
}
else if (stmt is ArgNode)
{
Write((ArgNode)stmt);
}
else if (stmt is TupleExpressionNode)
{
Write(stmt as TupleExpressionNode);
}
else if (stmt is ParenthesisExpressionNode)
{
Write((ParenthesisExpressionNode)stmt);
}
else if (stmt is MemberExpressionNode)
{
Write((MemberExpressionNode)stmt);
}
else if (stmt is LambdaExpressionNode)
{
Write((LambdaExpressionNode)stmt);
}
else if (stmt is IndexExpressionNode)
{
Write((IndexExpressionNode)stmt);
}
else if (stmt is ListExpressionNode)
{
Write((ListExpressionNode)stmt);
}
else if (stmt is OrExpressionNode)
{
Write((OrExpressionNode)stmt);
}
else if (stmt is UnaryExpressionNode)
{
Write((UnaryExpressionNode)stmt);
}
else if (stmt is ParameterNode)
{
Write((ParameterNode)stmt);
}
else if (stmt is PrintStatementNode)
{
Write((PrintStatementNode)stmt);
}
else if (stmt is FromImportStatementNode)
{
Write((FromImportStatementNode)stmt);
}
else
{
throw new NotImplementedException(stmt.GetType().ToString());
}
}
