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();
}
}
