private static PythonNode Wrap(ConstantExpression exp, PythonNode parent) { return(new ConstantExpressionNode(exp) { Parent = parent, Value = exp.Value }); }
public bool Similar(PythonNode node1) { var node = InnerNode.NodeName + ": " + Value; var compared = node1.InnerNode.NodeName + ": " + node1.Value; return(node.Equals(compared)); }
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()); } }
private static PythonNode Wrap(NameExpression exp, PythonNode parent) { return(new NameExpressionNode(exp) { Parent = parent, Value = exp.Name }); }
private static PythonNode Wrap(Statement stmt, PythonNode parent) { if (stmt is SuiteStatement) { return(Wrap(stmt as SuiteStatement, parent)); } if (stmt is ExpressionStatement) { return(Wrap(stmt as ExpressionStatement, parent)); } /* * if (stmt is FunctionDefinition) return Wrap(stmt as FunctionDefinition, parent); * if (stmt is FromImportStatement) return Wrap(stmt as FromImportStatement, parent); * if (stmt is ReturnStatement) return Wrap(stmt as ReturnStatement, parent); * if (stmt is IfStatement) return Wrap(stmt as IfStatement, parent); * if (stmt is AssignmentStatement) return Wrap(stmt as AssignmentStatement, parent); * if (stmt is AugmentedAssignStatement) return Wrap(stmt as AugmentedAssignStatement, parent); * if (stmt is ForStatement) return Wrap(stmt as ForStatement, parent); * if (stmt is WhileStatement) return Wrap(stmt as WhileStatement, parent); * if (stmt is ImportStatement) return Wrap(stmt as ImportStatement, parent); * if (stmt is PrintStatement) return Wrap(stmt as PrintStatement, parent); */ throw new NotImplementedException(stmt.NodeName); }
private static PythonNode Wrap(Expression exp, PythonNode parent) { if (exp is NameExpression) { return(Wrap(exp as NameExpression, parent)); } if (exp is BinaryExpression) { return(Wrap(exp as BinaryExpression, parent)); } if (exp is ConstantExpression) { return(Wrap(exp as ConstantExpression, parent)); } if (exp is CallExpression) { return(Wrap(exp as CallExpression, parent)); } if (exp is TupleExpression) { return(Wrap(exp as TupleExpression, parent)); } if (exp is ParenthesisExpression) { return(Wrap((ParenthesisExpression)exp, parent)); } if (exp is MemberExpression) { return(Wrap((MemberExpression)exp, parent)); } if (exp is IndexExpression) { return(Wrap((IndexExpression)exp, parent)); } if (exp is LambdaExpression) { return(Wrap((LambdaExpression)exp, parent)); } if (exp is OrExpression) { return(Wrap((OrExpression)exp, parent)); } if (exp is UnaryExpression) { return(Wrap((UnaryExpression)exp, parent)); } if (exp is ListExpression) { return(Wrap((ListExpression)exp, parent)); } if (exp is ListComprehension) { return(Wrap((ListComprehension)exp, parent)); } if (exp is ConditionalExpression) { return(Wrap((ConditionalExpression)exp, parent)); } throw new NotImplementedException("Wrapper not implemened : " + exp.Type); }
private static PythonNode Wrap(FunctionDefinition stmt, PythonNode parent) { var result = new FunctionDefinitionNode(stmt) { Parent = parent }; if (!stmt.Name.IsNullOrEmpty()) { result.Value = stmt.Name; } if (stmt.Decorators != null) { foreach (var exp in stmt.Decorators) { result.AddChild(Wrap(exp, result)); } } foreach (var param in stmt.Parameters) { result.AddChild(Wrap(param, result)); } result.AddChild(Wrap(stmt.Body, result)); return(result); }
public virtual void Insert(PythonNode inserted, int index) { if (InsertStrategy == null) { throw new TransformationNotApplicableExpection(); } Children = InsertStrategy.Insert(this, inserted, index); }
public override PythonNode Apply(PythonNode node) { var newList = new List <PythonNode>(); newList.AddRange(node.Children); node.Children = newList.Where(e => e.Id != ModifiedNode.Id).ToList(); return(node); }
public bool Visit(PythonNode pythonNode) { if (pythonNode is FunctionDefinitionNode && pythonNode.Value != null && Equals(pythonNode.Value, _name)) { Function = pythonNode; } return(Function == null); }
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)); }
private static PythonNode Wrap(ParenthesisExpression exp, PythonNode parent) { var result = new ParenthesisExpressionNode(exp) { Parent = parent }; result.AddChild(Wrap(exp.Expression, result)); return(result); }
private static PythonNode Wrap(ImportStatement stmt, PythonNode parent) { var result = new ImportStatementNode(stmt) { Parent = parent }; result.Names = stmt.AsNames; return(result); }
private static PythonNode Wrap(Arg arg, PythonNode parent) { var result = new ArgNode(arg) { Parent = parent, Value = arg.Name }; result.AddChild(Wrap(arg.Expression, result)); return(result); }
private static PythonNode Wrap(LambdaExpression exp, PythonNode parent) { var result = new LambdaExpressionNode(exp) { Parent = parent }; result.AddChild(Wrap(exp.Function, result)); return(result); }
private static PythonNode Wrap(ListExpression exp, PythonNode parent) { var result = new ListExpressionNode(exp) { Parent = parent }; exp.Items.ForEach(e => result.AddChild(Wrap(e, result))); return(result); }
private static PythonNode Wrap(MemberExpression exp, PythonNode parent) { var result = new MemberExpressionNode(exp) { Parent = parent }; result.AddChild(Wrap(exp.Target, result)); result.Value = exp.Name; return(result); }
private static PythonNode Wrap(IfStatementTest test, PythonNode parent) { var result = new IfStatementTestNode(test) { Parent = parent }; result.AddChild(Wrap(test.Test, result)); result.AddChild(Wrap(test.Body, result)); return(result); }
private static PythonNode Wrap(UnaryExpression exp, PythonNode parent) { var result = new UnaryExpressionNode(exp) { Parent = parent }; result.AddChild(Wrap(exp.Expression, result)); result.Value = exp.Op; return(result); }
private static PythonNode Wrap(BinaryExpression exp, PythonNode parent) { var result = new BinaryExpressionNode(exp) { Parent = parent, Value = exp.Operator }; result.AddChild(Wrap(exp.Left, result)); result.AddChild(Wrap(exp.Right, result)); return(result); }
private static PythonNode Wrap(OrExpression exp, PythonNode parent) { var result = new OrExpressionNode(exp) { Parent = parent }; result.AddChild(Wrap(exp.Left, result)); result.AddChild(Wrap(exp.Right, result)); return(result); }
private bool CheckTemplate(PythonNode node) { var result = _template.Match(node); if (result.Item1) { HasMatch = true; MatchResult = result.Item2; return(false); } return(!_exact); }
private static PythonNode Wrap(AugmentedAssignStatement stmt, PythonNode parent) { var result = new AugmentedAssignStatementNode(stmt) { Parent = parent, Value = stmt.Operator.ToString() }; result.AddChild(Wrap(stmt.Left, result)); result.AddChild(Wrap(stmt.Right, result)); result.Value = stmt.Operator; return(result); }
public bool Visit(PythonNode pythonNode) { foreach (var operation in _operations) { if (pythonNode.Equals(operation.ModifiedNode)) { SubOperations.Add(operation); return(true); } } return(false); }
protected override void GenerateNodes(PythonNode t1, PythonNode t2) { var visitor = new SortedTreeVisitor(); t1.PostWalk(visitor); A = visitor.Nodes; T1 = Enumerable.Range(1, A.Count).ToArray(); visitor = new SortedTreeVisitor(); t2.PostWalk(visitor); B = visitor.Nodes; T2 = Enumerable.Range(1, B.Count).ToArray(); }
private static PythonNode Wrap(SuiteStatement stmt, PythonNode parent) { var result = new SuiteStatementNode(stmt) { Parent = parent }; foreach (var statement in stmt.Statements) { result.AddChild(Wrap(statement, result)); } return(result); }
public bool CheckStaticTests(PythonNode changedProgram, Tuple <string, List <string> > staticTests) { var findFunctionVisitor = new FindFunctionVisitor(staticTests.Item1); changedProgram.Walk(findFunctionVisitor); if (findFunctionVisitor.Function != null) { var visitor = new StaticAnalysisTester(staticTests); findFunctionVisitor.Function.Walk(visitor); return(visitor.Passed); } return(false); }
private static PythonNode Wrap(ReturnStatement stmt, PythonNode parent) { var result = new ReturnStatementNode(stmt) { Parent = parent }; if (stmt.Expression != null) { result.AddChild(Wrap(stmt.Expression, result)); } return(result); }
private static PythonNode Wrap(Parameter parameter, PythonNode parent) { var result = new ParameterNode(parameter) { Parent = parent, Value = parameter.Name }; if (parameter.DefaultValue != null) { result.AddChild(Wrap(parameter.DefaultValue, result)); } result.Value = parameter.Name; return(result); }
private static PythonNode Wrap(TupleExpression exp, PythonNode parent) { var result = new TupleExpressionNode(exp) { Parent = parent }; result.Value = exp.IsExpandable; foreach (var item in exp.Items) { result.AddChild(Wrap(item, result)); } return(result); }