Added ForNode implementation

Author: snakex64

src/NodeDev.Blazor/Components/SourceViewer.razor

@@ -93,6 +93,10 @@ else
 
             Code += $"{System.Environment.NewLine}*/";
         }
+        catch(Exception ex)
+        {
+            Code = $"/* Error during code generation: {System.Environment.NewLine}{ex}{System.Environment.NewLine}*/";
+        }
     }
 
     private void OnGraphChanged(Graph graph)

src/NodeDev.Core/Class/NodeClassTypeCreator.cs

@@ -3,6 +3,7 @@
 using NodeDev.Core.Types;
 using FastExpressionCompiler;
 using NodeDev.Core.Nodes;
+using System.Linq.Expressions;
 
 namespace NodeDev.Core.Class;
 

src/NodeDev.Core/Graph.cs

@@ -256,7 +256,7 @@ public LambdaExpression BuildExpression(BuildExpressionOptions options)
             info.MethodParametersExpression[parameter.Name] = variable;
         }
 
-        // Create a variable for each node input and output
+        // Create a variable for each node's output
         foreach (var node in Nodes.Values)
         {
             if (node.CanBeInlined)

src/NodeDev.Core/Nodes/Flow/ForNode.cs

@@ -1,48 +1,68 @@
-using NodeDev.Core.Connections;
+using FastExpressionCompiler;
+using NodeDev.Core.Connections;
 using NodeDev.Core.Types;
 using System.Linq.Expressions;
 
 namespace NodeDev.Core.Nodes.Flow;
 
 public class ForNode : FlowNode
 {
-	public override bool IsFlowNode => true;
+    public override bool IsFlowNode => true;
 
-	public override bool FetchState => true;
+    public override bool FetchState => true;
 
-	public override bool ReOrderExecInputsAndOutputs => false;
+    public override bool ReOrderExecInputsAndOutputs => false;
 
-	public override bool AllowRemergingExecConnections => false;
+    public override bool AllowRemergingExecConnections => false;
 
-	public ForNode(Graph graph, string? id = null) : base(graph, id)
-	{
-		Name = "For";
+    public ForNode(Graph graph, string? id = null) : base(graph, id)
+    {
+        Name = "For";
 
-		Inputs.Add(new("Exec", this, TypeFactory.ExecType));
-		Inputs.Add(new("Start", this, TypeFactory.Get<int>()));
-		Inputs.Add(new("End (Exclude)", this, TypeFactory.Get<int>()));
+        Inputs.Add(new("Exec", this, TypeFactory.ExecType));
+        Inputs.Add(new("Start", this, TypeFactory.Get<int>()));
+        Inputs.Add(new("End (Exclude)", this, TypeFactory.Get<int>()));
 
-		Outputs.Add(new("ExecLoop", this, TypeFactory.ExecType));
-		Outputs.Add(new("Index", this, TypeFactory.Get<int>(), linkedExec: Outputs[0]));
-		Outputs.Add(new("ExecOut", this, TypeFactory.ExecType));
-	}
+        Outputs.Add(new("ExecLoop", this, TypeFactory.ExecType));
+        Outputs.Add(new("Index", this, TypeFactory.Get<int>(), linkedExec: Outputs[0]));
+        Outputs.Add(new("ExecOut", this, TypeFactory.ExecType));
+    }
 
-	public override string GetExecOutputPathId(string pathId, Connection execOutput)
-	{
-		if (execOutput == Outputs[0])
-			return pathId + "-" + execOutput.Id;
-		else if (execOutput == Outputs[2])
-			return pathId;
-		else
-			throw new Exception("Invalid exec output");
-	}
+    public override string GetExecOutputPathId(string pathId, Connection execOutput)
+    {
+        if (execOutput == Outputs[0])
+            return pathId + "-" + execOutput.Id;
+        else if (execOutput == Outputs[2])
+            return pathId;
+        else
+            throw new Exception("Invalid exec output");
+    }
 
-	public override bool DoesOutputPathAllowDeadEnd(Connection execOutput) => execOutput == Outputs[0]; // The loop exec path must be a dead end (or a breaking node, such as return, continue, break)
+    public override bool DoesOutputPathAllowDeadEnd(Connection execOutput) => execOutput == Outputs[0]; // The loop exec path must be a dead end (or a breaking node, such as return, continue, break)
 
-        public override bool DoesOutputPathAllowMerge(Connection execOutput) => execOutput == Outputs[2]; // the ExecOut path allows merging, but not the loop. The loop is always a dead end.
+    public override bool DoesOutputPathAllowMerge(Connection execOutput) => execOutput == Outputs[2]; // the ExecOut path allows merging, but not the loop. The loop is always a dead end.
 
-	internal override Expression BuildExpression(Dictionary<Connection, Graph.NodePathChunks>? subChunks, BuildExpressionInfo info)
-	{
-		throw new NotImplementedException();
-	}
+    internal override Expression BuildExpression(Dictionary<Connection, Graph.NodePathChunks>? subChunks, BuildExpressionInfo info)
+    {
+        ArgumentNullException.ThrowIfNull(subChunks);
+
+        var count = info.LocalVariables[Outputs[1]];
+        var assignCount = Expression.Assign(count, info.LocalVariables[Inputs[1]]); // assign the start value to the count variable
+        var incrementCount = Expression.PreIncrementAssign(count); // increment the count variable
+
+        var loopBody = Expression.Block(Graph.BuildExpression(subChunks[Outputs[0]], info).Append(incrementCount)); // Build the loop body and the counter increment
+        var afterLoop = Expression.Block(Graph.BuildExpression(subChunks[Outputs[2]], info)); // Build the after loop body
+
+        var breakLabel = Expression.Label();
+        var loop = Expression.Loop(
+            Expression.IfThenElse(
+                Expression.LessThan(count, info.LocalVariables[Inputs[2]]), // i < end
+                loopBody, // does the assign for enumerator.Current, as well as the loop body
+                Expression.Break(breakLabel) // break the loop
+            ),
+            breakLabel
+        );
+
+        return Expression.Block(assignCount, loop, afterLoop);
+    }
 }

src/NodeDev.Core/Nodes/Node.cs

@@ -100,7 +100,11 @@ public virtual void SelectOverload(AlternateOverload overload, out List<Connecti
 				if (output.Type.IsExec)
 					continue;
 
-				var variable = Expression.Variable(output.Type.MakeRealType(), $"{Name}_{output.Name}".Replace(" ", string.Empty).Replace(".", string.Empty));
+				var variable = Expression.Variable(output.Type.MakeRealType(), $"{Name}_{output.Name}"
+					.Replace(" ", string.Empty)
+					.Replace(".", string.Empty)
+					.Replace("<", string.Empty)
+					.Replace(">", string.Empty));
 				yield return (output, variable);
 			}
 		}