Implemented AST generation and stringifier

Author: Tom

v2/BooleanExpressionParser/Nodes/Node.cs

@@ -3,5 +3,4 @@ public abstract class Node
 
     public abstract bool Evaluate();
 
-
 }

v2/BooleanExpressionParser/Nodes/NotOperatorNode.cs

@@ -1,6 +1,6 @@
 public class NotOperatorNode : OperatorNode
 {
-    public NotOperatorNode(Node left, Node right) : base(left, right) { }
+    public NotOperatorNode(Node left) : base(left, null) { }
 
     public override bool Evaluate()
     {

v2/BooleanExpressionParser/Nodes/OperatorNode.cs

@@ -1,12 +1,12 @@
 public abstract class OperatorNode : Node
 {
 
-    public OperatorNode(Node left, Node right)
+    public OperatorNode(Node left, Node? right)
     {
         Left = left;
         Right = right;
     }
 
     public Node Left { get; private set; }
-    public Node Right { get; private set; }
+    public Node? Right { get; private set; }
 }

v2/BooleanExpressionParser/Nodes/VariableNode.cs

@@ -0,0 +1,14 @@
+public class VariableNode : Node
+{
+    public VariableNode(String name)
+    {
+        Name = name;
+    }
+
+    public String Name {get;set;}
+
+    public override bool Evaluate()
+    {
+        throw new NotImplementedException();
+    }
+}

v2/BooleanExpressionParser/Program.cs

@@ -1,4 +1,6 @@
-internal class Program
+using System.Text;
+
+internal class Program
 {
     static void Main(string[] args)
     {
@@ -18,10 +20,18 @@ static void Main(string[] args)
 
         var polishTokens = ToPolish(tokens);
 
-        foreach (var t in polishTokens)
-        {
-            Console.WriteLine(t);
-        }
+        polishTokens.ForEach(x => System.Console.WriteLine($"{x.Type} : {x.Value}"));
+
+        var root = BuildAST(polishTokens);
+
+        var text = StringifyAST(root);
+
+
+        System.Console.WriteLine("======");
+
+        System.Console.WriteLine($"Input expression: {expression}");
+
+        System.Console.WriteLine($"Output expression: {text}");
     }
 
     static List<Token> ToPolish(List<Token> normalTokens)
@@ -38,7 +48,8 @@ static List<Token> ToPolish(List<Token> normalTokens)
                     break;
                 case Token.TokenType.BINARY_OPERATOR:
                 case Token.TokenType.UNARY_OPERATOR:
-                    while (stack.Count > 0 && stack.Peek().Type != Token.TokenType.OPEN_PAREN)
+                    while ((stack.Count > 0 && stack.Peek().Type != Token.TokenType.OPEN_PAREN)
+                            /* && CHECK PRECEDENCE HERE */)
                     {
                         output.Enqueue(stack.Pop());
                     }
@@ -66,9 +77,94 @@ static List<Token> ToPolish(List<Token> normalTokens)
 
         while (stack.Count > 0)
         {
+            if (stack.Peek().Type == Token.TokenType.OPEN_PAREN)
+            {
+                throw new Exception("OPEN_PAREN on operator stack.");
+            }
             output.Enqueue(stack.Pop());
         }
 
         return output.ToList();
     }
+
+    static Node BuildAST(List<Token> tokens)
+    {
+        var stack = new Stack<Node>();
+
+        foreach (var token in tokens)
+        {
+            switch (token.Type)
+            {
+                case Token.TokenType.IDENTIFIER:
+                    stack.Push(new VariableNode(token.Value));
+                    break;
+
+                case Token.TokenType.BINARY_OPERATOR:
+                    if (stack.Count < 2) throw new Exception($"2 parameters needed for operator ${token.Type}");
+
+                    if (token.Value == "AND")
+                        stack.Push(new AndOperatorNode(stack.Pop(), stack.Pop()));
+                    else
+                        stack.Push(new OrOperatorNode(stack.Pop(), stack.Pop()));
+                    break;
+
+                case Token.TokenType.UNARY_OPERATOR:
+                    if (stack.Count < 1) throw new Exception($"1 parameter needed for operator ${token.Type}");
+
+                    if (token.Value == "NOT")
+                        stack.Push(new NotOperatorNode(stack.Pop()));
+                    break;
+            }
+        }
+
+        System.Console.WriteLine($"{stack.Count} tokens remaining in stack!");
+
+        return stack.Pop();
+    }
+
+    static String StringifyAST(Node root)
+    {
+        var builder = new StringBuilder();
+
+        Visit(root);
+
+        void Visit(Node node)
+        {
+            switch (node)
+            {
+                case AndOperatorNode op:
+                    VisitAndWrap(op.Left);
+                    builder.Append(" AND ");
+                    VisitAndWrap(op.Right!);
+                    break;
+
+                case OrOperatorNode op:
+                    VisitAndWrap(op.Left);
+                    builder.Append(" OR ");
+                    VisitAndWrap(op.Right!);
+                    break;
+
+                case NotOperatorNode op:
+                    builder.Append($"(NOT ");
+                    Visit(op.Left);
+                    builder.Append(")");
+                    break;
+
+                case VariableNode var:
+                    builder.Append(var.Name);
+                    break;
+
+            }
+        }
+
+        void VisitAndWrap(Node node)
+        {
+            if (node is AndOperatorNode || node is OrOperatorNode) builder.Append("(");
+            Visit(node);
+            if (node is AndOperatorNode || node is OrOperatorNode) builder.Append(")");
+        }
+
+        return builder.ToString();
+    }
+
 }

v2/BooleanExpressionParser/Token.cs

@@ -1,6 +1,5 @@
 public class Token
 {
-
     static Dictionary<char, (TokenType, string)> tokenDict = new()
     {
         { '(', (TokenType.OPEN_PAREN, "(") },