internal override IEnumerable<AssociativeNode> BuildAst(List<AssociativeNode> inputAstNodes, AstBuilder.CompilationContext context) { var rhs = AstFactory.BuildStringNode(Value); var assignment = AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), rhs); return new[] { assignment }; }
private List<AssociativeNode> GetAstsForBranch(int branch, List<AssociativeNode> inputAstNodes, bool verboseLogging, AstBuilder builder) { // Get all upstream nodes and then remove nodes that are not var nodes = GetInScopeNodesForInport(branch, false).Where(n => !(n is Symbol)); nodes = ScopedNodeModel.GetNodesInTopScope(nodes); // The second parameter, isDeltaExecution, is set to false so that // all AST nodes will be added to this IF graph node instead of // adding to the corresponding graph node. var allAstNodes = builder.CompileToAstNodes(nodes, Dynamo.Engine.AstBuilder.CompilationContext.None, verboseLogging); var astNodes = allAstNodes.SelectMany(t => t.Item2).ToList(); astNodes.Add(AstFactory.BuildReturnStatement(inputAstNodes[branch])); return astNodes; }
internal override IEnumerable<AssociativeNode> BuildAst(List<AssociativeNode> inputAstNodes, AstBuilder.CompilationContext context) { //Do not build if the node is in error. if (State == ElementState.Error) { return Enumerable.Empty<AssociativeNode>(); } var resultNodes = new List<AssociativeNode>(); // Define unbound variables if necessary if (inputIdentifiers != null && inputAstNodes != null && inputIdentifiers.Count == inputAstNodes.Count) { var initStatments = inputIdentifiers.Zip(inputAstNodes, (ident, rhs) => { var identNode = AstFactory.BuildIdentifier(ident); if (context != AstBuilder.CompilationContext.NodeToCode) MapIdentifiers(identNode); return AstFactory.BuildAssignment(identNode, rhs); }); resultNodes.AddRange(initStatments); } foreach (var astNode in codeStatements.Select(stmnt => NodeUtils.Clone(stmnt.AstNode))) { if (context != AstBuilder.CompilationContext.NodeToCode) MapIdentifiers(astNode); resultNodes.Add(astNode as AssociativeNode); } return resultNodes; }
/// <summary> /// Similar to NodeModel.BuildAst(). When compiled to AST, for /// ScopedNodeModel this method will be called when all requirements /// are satisfied. /// </summary> /// <param name="inputAstNodes"></param> /// <param name="verboseLogging"></param> /// <param name="builder"></param> /// <returns></returns> internal virtual IEnumerable<AssociativeNode> BuildAstInScope(List<AssociativeNode> inputAstNodes, bool verboseLogging, AstBuilder builder) { OnBuilt(); var result = BuildOutputAstInScope(inputAstNodes, verboseLogging, builder); return result; }
/// <summary> /// Similar to NodeModel.BuildOutputAst(). When compiled to AST, for /// ScopedNodeModel this method will be called when all requirements are /// satisfied. The derived class needs to implement this method to /// compile its children into some scopes. /// </summary> /// <param name="inputAstNodes"></param> /// <param name="verboseLogging"></param> /// <param name="builder"></param> /// <returns></returns> public virtual IEnumerable<AssociativeNode> BuildOutputAstInScope(List<AssociativeNode> inputAstNodes, bool verboseLogging, AstBuilder builder) { throw new NotImplementedException("BuildOutputAstInScope"); }
internal override IEnumerable<AssociativeNode> BuildAst(List<AssociativeNode> inputAstNodes, AstBuilder.CompilationContext context) { var paramDict = InPortData.Select(x => x.NickName) .Zip<string, AssociativeNode, Tuple<string, AssociativeNode>>(inputAstNodes, Tuple.Create) .ToDictionary(x => x.Item1, x => x.Item2); AssociativeNode rhs; if (null == _parsed) { rhs = AstFactory.BuildNullNode(); } else { List<AssociativeNode> newInputs = _parsed.Count == 1 ? new List<AssociativeNode> { _parsed[0].GetAstNode(paramDict) } : _parsed.Select(x => x.GetAstNode(paramDict)).ToList(); rhs = newInputs.Count == 1 ? newInputs[0] : AstFactory.BuildExprList(newInputs); } var assignment = AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), rhs); return new[] { assignment }; }
public override IEnumerable<AssociativeNode> BuildOutputAstInScope(List<AssociativeNode> inputAstNodes, bool verboseLogging, AstBuilder builder) { // This function will compile IF node to the following format: // // cond = ...; // v = [Imperative] // { // if (cond) { // return = [Associative] { // ... // } // } // else { // return = [Associative] { // ... // } // } // } // var astsInTrueBranch = GetAstsForBranch(1, inputAstNodes, verboseLogging, builder); var astsInFalseBranch = GetAstsForBranch(2, inputAstNodes, verboseLogging, builder); // if (cond) { // return = [Associative] {...} // } var ifBlock = new LanguageBlockNode { codeblock = new LanguageCodeBlock(Language.kAssociative), CodeBlockNode = new CodeBlockNode { Body = astsInTrueBranch } }; var ifBranch = AstFactory.BuildReturnStatement(ifBlock).ToImperativeAST(); // else { // return = [Associative] { ... } // } var elseBlock = new LanguageBlockNode { codeblock = new LanguageCodeBlock(Language.kAssociative), CodeBlockNode = new CodeBlockNode { Body = astsInFalseBranch } }; var elseBranch = AstFactory.BuildReturnStatement(elseBlock).ToImperativeAST(); var ifelseStatement = new ProtoCore.AST.ImperativeAST.IfStmtNode() { IfExprNode = inputAstNodes[0].ToImperativeAST(), IfBody = new List<ProtoCore.AST.ImperativeAST.ImperativeNode> { ifBranch }, ElseBody = new List<ProtoCore.AST.ImperativeAST.ImperativeNode> { elseBranch } }; // thisVariable = [Imperative] // { // ... // } var outerBlock = new LanguageBlockNode { codeblock = new LanguageCodeBlock(Language.kImperative), CodeBlockNode = new ProtoCore.AST.ImperativeAST.CodeBlockNode { Body = new List<ProtoCore.AST.ImperativeAST.ImperativeNode> { ifelseStatement } } }; var thisVariable = GetAstIdentifierForOutputIndex(0); var assignment = AstFactory.BuildAssignment(thisVariable, outerBlock); return new AssociativeNode[] { assignment }; }
/// <summary> /// Handler for the EngineController's AstBuilt event. /// Formats a string of AST for preview on the node. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> void EngineController_AstBuilt(object sender, AstBuilder.ASTBuiltEventArgs e) { if (e.Node == nodeLogic.GUID) { var sb = new StringBuilder(); sb.AppendLine(string.Format("{0} AST:", e.Node)); foreach (var assocNode in e.AstNodes) { var pretty = assocNode.ToString(); //shorten the guids var strRegex = @"([0-9a-f-]{32}).*?"; var myRegex = new Regex(strRegex, RegexOptions.None); string strTargetString = assocNode.ToString(); foreach (Match myMatch in myRegex.Matches(strTargetString)) { if (myMatch.Success) { pretty = pretty.Replace(myMatch.Value, "..." + myMatch.Value.Substring(myMatch.Value.Length - 7)); } } sb.AppendLine(pretty); } ASTText = sb.ToString(); } }