Added v2 C# project

tomc128 · tomc128 · commit a9bc80afee48 · 2022-10-11T21:49:21.000+01:00
So far, token reading and polish notation conversion has been implemented
diff --git a/.gitignore b/.gitignore
diff --git a/v1/.vscode/settings.json b/v1/.vscode/settings.json
diff --git a/v1/boolean_expression_parser.py b/v1/boolean_expression_parser.py
@@ -102,7 +102,7 @@ def prepare_table(expr: Expression):
 
 
 
-def simulate(expr: Expression, table: Table):
+def simulate_full(expr: Expression, table: Table):
 
     tokens = expr[0]
     variables = expr[1]
@@ -136,8 +136,6 @@ def simulate(expr: Expression, table: Table):
     
 
 
-
-
 def main():
     '''Main program loop.'''
 
@@ -155,7 +153,7 @@ def main():
         debug_print(f'Variables: {",".join(expr1[1])}')
 
         table1 = prepare_table(expr1)
-        table1 = simulate(expr1, table1)
+        table1 = simulate_full(expr1, table1)
 
         print_table(expr1, table1)
 
diff --git a/v1/errors.py b/v1/errors.py
diff --git a/v2/BooleanExpressionParser/.vscode/launch.json b/v2/BooleanExpressionParser/.vscode/launch.json
@@ -0,0 +1,26 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            // Use IntelliSense to find out which attributes exist for C# debugging
+            // Use hover for the description of the existing attributes
+            // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+            "name": ".NET Core Launch (console)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/bin/Debug/net6.0/BooleanExpressionParser.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}",
+            // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+            "console": "internalConsole",
+            "stopAtEntry": false
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach"
+        }
+    ]
+}
diff --git a/v2/BooleanExpressionParser/.vscode/tasks.json b/v2/BooleanExpressionParser/.vscode/tasks.json
@@ -0,0 +1,41 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/BooleanExpressionParser.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/BooleanExpressionParser.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "--project",
+                "${workspaceFolder}/BooleanExpressionParser.csproj"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}
diff --git a/v2/BooleanExpressionParser/BooleanExpressionParser.csproj b/v2/BooleanExpressionParser/BooleanExpressionParser.csproj
@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>
diff --git a/v2/BooleanExpressionParser/Nodes/AndOperatorNode.cs b/v2/BooleanExpressionParser/Nodes/AndOperatorNode.cs
@@ -0,0 +1,9 @@
+public class AndOperatorNode : OperatorNode
+{
+    public AndOperatorNode(Node left, Node right) : base(left, right) { }
+
+    public override bool Evaluate()
+    {
+        return Left.Evaluate() && Right.Evaluate();
+    }
+}
diff --git a/v2/BooleanExpressionParser/Nodes/Node.cs b/v2/BooleanExpressionParser/Nodes/Node.cs
@@ -0,0 +1,7 @@
+public abstract class Node
+{
+
+    public abstract bool Evaluate();
+    
+
+}
diff --git a/v2/BooleanExpressionParser/Nodes/NotOperatorNode.cs b/v2/BooleanExpressionParser/Nodes/NotOperatorNode.cs
@@ -0,0 +1,9 @@
+public class NotOperatorNode : OperatorNode
+{
+    public NotOperatorNode(Node left, Node right) : base(left, right) { }
+
+    public override bool Evaluate()
+    {
+        return !Left.Evaluate();
+    }
+}
diff --git a/v2/BooleanExpressionParser/Nodes/OperatorNode.cs b/v2/BooleanExpressionParser/Nodes/OperatorNode.cs
@@ -0,0 +1,12 @@
+public abstract class OperatorNode : Node
+{
+
+    public OperatorNode(Node left, Node right)
+    {
+        Left = left;
+        Right = right;
+    }
+
+    public Node Left { get; private set; }
+    public Node Right { get; private set; }
+}
diff --git a/v2/BooleanExpressionParser/Nodes/OrOperatorNode.cs b/v2/BooleanExpressionParser/Nodes/OrOperatorNode.cs
@@ -0,0 +1,9 @@
+public class OrOperatorNode : OperatorNode
+{
+    public OrOperatorNode(Node left, Node right) : base(left, right) { }
+
+    public override bool Evaluate()
+    {
+        return Left.Evaluate() || Right.Evaluate();
+    }
+}
diff --git a/v2/BooleanExpressionParser/Program.cs b/v2/BooleanExpressionParser/Program.cs
@@ -0,0 +1,74 @@
+﻿internal class Program
+{
+    static void Main(string[] args)
+    {
+        string expression = @"(!(A & B) | C) & D";
+
+        expression = expression.Replace(" ", "");
+
+        var tokens = new List<Token>();
+        var reader = new StringReader(expression);
+
+        Token token;
+        do
+        {
+            token = new Token(reader);
+            tokens.Add(token);
+        } while (token.Type != Token.TokenType.EXPR_END);
+
+        var polishTokens = ToPolish(tokens);
+
+        foreach (var t in polishTokens)
+        {
+            Console.WriteLine(t);
+        }
+    }
+
+    static List<Token> ToPolish(List<Token> normalTokens)
+    {
+        var output = new Queue<Token>();
+        var stack = new Stack<Token>();
+
+        foreach (var token in normalTokens)
+        {
+            switch (token.Type)
+            {
+                case Token.TokenType.IDENTIFIER:
+                    output.Enqueue(token);
+                    break;
+                case Token.TokenType.BINARY_OPERATOR:
+                case Token.TokenType.UNARY_OPERATOR:
+                    while (stack.Count > 0 && stack.Peek().Type != Token.TokenType.OPEN_PAREN)
+                    {
+                        output.Enqueue(stack.Pop());
+                    }
+                    stack.Push(token);
+                    break;
+                case Token.TokenType.OPEN_PAREN:
+                    stack.Push(token);
+                    break;
+                case Token.TokenType.CLOSE_PAREN:
+                    while (stack.Count > 0 && stack.Peek().Type != Token.TokenType.OPEN_PAREN)
+                    {
+                        output.Enqueue(stack.Pop());
+                    }
+                    if (stack.Peek().Type == Token.TokenType.OPEN_PAREN)
+                    {
+                        stack.Pop();
+                        if (stack.Count > 0 && (stack.Peek().Type == Token.TokenType.UNARY_OPERATOR || stack.Peek().Type == Token.TokenType.BINARY_OPERATOR))
+                        {
+                            output.Enqueue(stack.Pop());
+                        }
+                    }
+                    break;
+            }
+        }
+
+        while (stack.Count > 0)
+        {
+            output.Enqueue(stack.Pop());
+        }
+
+        return output.ToList();
+    }
+}
diff --git a/v2/BooleanExpressionParser/Token.cs b/v2/BooleanExpressionParser/Token.cs
@@ -0,0 +1,63 @@
+public class Token
+{
+
+    static Dictionary<char, (TokenType, string)> tokenDict = new()
+    {
+        { '(', (TokenType.OPEN_PAREN, "(") },
+        { ')', (TokenType.CLOSE_PAREN, ")") },
+        { '&', (TokenType.BINARY_OPERATOR, "AND") },
+        { '.', (TokenType.BINARY_OPERATOR, "AND") },
+        { '|', (TokenType.BINARY_OPERATOR, "OR") },
+        { '+', (TokenType.BINARY_OPERATOR, "OR") },
+        { '!', (TokenType.UNARY_OPERATOR, "NOT") },
+        { '¬', (TokenType.UNARY_OPERATOR, "NOT") },
+    };
+
+
+    public enum TokenType
+    {
+        OPEN_PAREN,
+        CLOSE_PAREN,
+        UNARY_OPERATOR,
+        BINARY_OPERATOR,
+        IDENTIFIER,
+        EXPR_END,
+    }
+
+    public TokenType Type { get; set; }
+    public string Value { get; set; }
+
+    public Token(StringReader reader)
+    {
+        var c = reader.Read();
+        if (c == -1)
+        {
+            Type = TokenType.EXPR_END;
+            Value = "";
+            return;
+        }
+
+        var ch = (char)c;
+        if (tokenDict.ContainsKey(ch))
+        {
+            var (type, value) = tokenDict[ch];
+            Type = type;
+            Value = value;
+        }
+        else
+        {
+            string word = $"{ch}";
+            while (reader.Peek() != -1 && !tokenDict.ContainsKey((char)reader.Peek()))
+            {
+                word += (char)reader.Read();
+            }
+            Type = TokenType.IDENTIFIER;
+            Value = word;
+        }
+    }
+
+    public override string ToString()
+    {
+        return $"{Type}: {Value}";
+    }
+}

-Original file line number
+Diff line change
@@ @@ -0,0 +1,7 @@ @@
 +public abstract class Node
 +{
++
 +    public abstract bool Evaluate();
++
++
 +}