Templating engine

src/WattleScript.Interpreter/Execution/VM/FunctionBuilder.cs

@@ -638,4 +638,4 @@ public int Emit_JLclInit(SymbolRef sym, int target)
 			return AppendInstruction(new Instruction(OpCode.JLclInit, target, sym.Index));
 		}
 	}
-}
+}

src/WattleScript.Interpreter/Extensions.cs

@@ -31,4 +31,4 @@ public static string GetSourceFragment(this SourceRef[] refs, string fullSourceC
             return fullSourceCode.Substring(firstNotNull?.FromCharIndex ?? 0, lastNotNull?.ToCharIndex - firstNotNull?.FromCharIndex ?? 0);
         }
     }
-}
+}

src/WattleScript.Templating/Extensions.cs

@@ -0,0 +1,70 @@
+using System.ComponentModel;
+using System;
+
+namespace WattleScript.Templating;
+
+internal static class Extensions
+{
+    public static string ToDescriptionString(this Enum val)
+    {
+        DescriptionAttribute[] attributes = (DescriptionAttribute[])val.GetType().GetField(val.ToString())?.GetCustomAttributes(typeof(DescriptionAttribute), false)!;
+        return attributes.Length > 0 ? attributes[0].Description : "";
+    }
+
+    public static T? Peek<T>(this List<T?> list)
+    {
+        return list.Count > 0 ? list[^1] : default;
+    }
+
+    public static T? Pop<T>(this List<T?> list)
+    {
+        if (list.Count > 0)
+        {
+            T? itm = list[^1];
+            list.RemoveAt(list.Count - 1);
+            return itm;
+        }
+
+        return default;
+    }
+
+    public static void Push<T>(this List<T?> list, T? itm)
+    {
+        list.Add(itm);
+    }
+
+    public static string ReplaceFirst(this string text, string search, string replace)
+    {
+        int pos = text.IndexOf(search, StringComparison.Ordinal);
+        return pos < 0 ? text : string.Concat(text[..pos], replace, text.AsSpan(pos + search.Length));
+    }
+
+    public static Tuple<string, bool> Snippet(this string str, int pivot, int n)
+    {
+        bool clamped = false;
+
+        int expectedStart = pivot - n;
+        int realStart = Math.Max(0, str.Length > expectedStart ? expectedStart : str.Length);
+        int expectedLen = 2 * n;
+        int realLen = Math.Max(str.Length - realStart > expectedLen ? expectedLen : str.Length - realStart, 0);
+
+        if (str.Length - realStart < expectedLen)
+        {
+            clamped = true;
+        }
+
+        string snippet = str.Substring(realStart, realLen);
+
+        /*if (realStart > 0) // text continues before snippet
+        {
+            snippet = $"««{snippet}";
+        }
+
+        if (str.Length > realStart + realLen) // text continues after snippet
+        {
+            snippet = $"{snippet}»»";
+        }*/
+
+        return new Tuple<string, bool>(snippet, clamped);
+    }
+} 

src/WattleScript.Templating/Parser/Node.cs

@@ -0,0 +1,97 @@
+namespace WattleScript.Templating;
+
+internal class Document
+{
+    public List<NodeBase> Nodes { get; set; }
+    public INodeWithChildren CurrentNode { get; set; }
+    DocumentNode DocNode = new DocumentNode();
+
+    public Document()
+    {
+        Nodes = new List<NodeBase>();
+        Nodes.Add(DocNode);
+        CurrentNode = DocNode;
+    }
+
+    public void AddChild(NodeBase node)
+    {
+        DocNode.AddChild(node);
+    }
+}
+
+internal interface INodeWithChildren
+{
+    public List<NodeBase> Children { get; set; }
+    public void AddChild(NodeBase child);
+}
+
+internal class NodeBase
+{
+    public int CharFrom { get; set; }
+    public bool Recovery { get; set; }
+    public int Line { get; set; }
+    public int Col { get; set; }
+    public int ContentFrom { get; set; }
+    public int ContentTo { get; set; }
+}
+
+internal class ServerNode : NodeBase
+{
+
+}
+
+internal class TextNode : NodeBase
+{
+    public string Text { get; set; }
+
+    public TextNode(string text)
+    {
+        Text = text;
+    }
+}
+
+internal class DocumentNode : NodeBase, INodeWithChildren
+{
+    public List<NodeBase> Children { get; set; } = new List<NodeBase>();
+    public void AddChild(NodeBase child)
+    {
+        Children.Add(child);
+    }
+}
+
+internal class HtmlElement : NodeBase, INodeWithChildren
+{
+    internal enum ClosingType
+    {
+        Unknown,
+        SelfClosing,
+        ImplicitSelfClosing,
+        EndTag
+    }
+
+    public HtmlElement Parent { get; set; }
+    public List<HtmlAttribute> Attributes { get; set; } = new List<HtmlAttribute>();
+    public string Name { get; set; }
+    public ClosingType Closing { get; set; }
+    public bool ForceNativeTag { get; set; }
+    public List<NodeBase> Children { get; set; } = new List<NodeBase>();
+
+    public void AddChild(NodeBase child)
+    {
+        Children.Add(child);
+    }
+}
+
+internal class HtmlAttribute
+{
+    public string Name { get; set; }
+    public string Value { get; set; }
+    public Parser.HtmlAttrEnclosingModes QuoteType { get; set; }
+
+    internal HtmlAttribute(string name, string value, Parser.HtmlAttrEnclosingModes quoteType)
+    {
+        Name = name;
+        Value = value;
+        QuoteType = quoteType;
+    }
+}