Inital Code Upload

2025-09-13 17:00:03 +02:00
commit bcb3539d2c
39 changed files with 1099 additions and 0 deletions
@@ -0,0 +1 @@
+{}
@@ -0,0 +1,168 @@
+using System.Runtime.Intrinsics.Arm;
+using System.Text;
+using System.Text.RegularExpressions;
+using PratParser.Lexer;
+
+namespace Lexer
+{
+
+
+    public static class Tokenizer
+    {
+        private class TokenizeEventArgs(TokenKind kind, string value) : EventArgs
+        {
+            public TokenKind Kind = kind;
+            public string Value = value;
+        }
+
+        private struct RegexPattern
+        {
+            public Regex Regex;
+            public EventHandler<TokenizeEventArgs> Handler;
+            public TokenKind TokenKind;
+
+            public RegexPattern(string Pattern, EventHandler<TokenizeEventArgs> handler, TokenKind tokenKind)
+            {
+                Regex = new Regex(Pattern);
+                Handler = handler;
+                TokenKind = tokenKind;
+            }
+
+            public bool check(string value)
+            {
+                Match match = Regex.Match(value);
+                if (match.Success && match.Index == 0)
+                {
+                    Handler(this, new TokenizeEventArgs(TokenKind, match.Captures[0].Value));
+                    return true;
+                }
+                return false;
+            }
+        }
+
+        static List<Token> Tokens = [];
+        static string Source = "";
+        static int Pos = 0;
+        static int Linecount = 1;
+        private static readonly List<RegexPattern> Patterns = [
+            new RegexPattern(@"[a-zA-Z_][a-zA-Z_]*",symbolHandler,TokenKind.IDENTIFIER),
+            new RegexPattern(@"-?[0-9]+(?:\.[0-9]+)?",defaultHandler,TokenKind.NUMBER),
+            new RegexPattern("\"(?:\\\\.|[^\"\\\\])*\"", stringHandler, TokenKind.STRING_VALUE),
+            new RegexPattern("//[^\n\r]*", skipHandler, TokenKind.COMMENT),
+            new RegexPattern(Regex.Escape(Environment.NewLine),skipHandler,TokenKind.LineBrake),
+            new RegexPattern("\\s+", skipHandler, TokenKind.Whitespace),
+            new RegexPattern("\\[",defaultHandler,TokenKind.OPEN_BRACKET),
+            new RegexPattern("\\]",defaultHandler,TokenKind.CLOSE_BRACKET),
+            new RegexPattern("\\{",defaultHandler,TokenKind.OPEN_CURLY),
+            new RegexPattern("\\}",defaultHandler,TokenKind.CLOSE_CURLY),
+            new RegexPattern("\\(",defaultHandler,TokenKind.OPEN_PAREN),
+            new RegexPattern("\\)",defaultHandler,TokenKind.CLOSE_PAREN),
+            new RegexPattern("==",defaultHandler,TokenKind.EQUALS),
+            new RegexPattern("!=",defaultHandler,TokenKind.NOT_EQUALS),
+            new RegexPattern("=",defaultHandler,TokenKind.ASSIGMENT),
+            new RegexPattern("!",defaultHandler,TokenKind.NOT),
+            new RegexPattern("<=",defaultHandler,TokenKind.LESS_EQUALS),
+            new RegexPattern("<",defaultHandler,TokenKind.LESS),
+            new RegexPattern("=>",defaultHandler,TokenKind.GREATER_EQUALS),
+            new RegexPattern(">",defaultHandler,TokenKind.GREATER),
+            new RegexPattern("\\|\\|",defaultHandler,TokenKind.OR),
+            new RegexPattern("&&",defaultHandler,TokenKind.AND),
+            new RegexPattern("\\.\\.",defaultHandler,TokenKind.DOT_DOT),
+            new RegexPattern("\\.",defaultHandler,TokenKind.DOT),
+            new RegexPattern(":",defaultHandler,TokenKind.COLON),
+            new RegexPattern("\\?",defaultHandler,TokenKind.QUESTION),
+            new RegexPattern(",",defaultHandler,TokenKind.COMMA),
+            new RegexPattern("\\+\\+",defaultHandler,TokenKind.PLUSPLUS),
+            new RegexPattern("\\-\\-",defaultHandler,TokenKind.MINUSMINUS),
+            new RegexPattern("\\+=",defaultHandler,TokenKind.PLUSEQUALS),
+            new RegexPattern("\\-=",defaultHandler,TokenKind.MINUSEQUALS),
+            new RegexPattern("\\+",defaultHandler,TokenKind.PLUS),
+            new RegexPattern("\\-",defaultHandler,TokenKind.MINUS),
+            new RegexPattern("\\*",defaultHandler,TokenKind.MULTIPLY),
+            new RegexPattern("\\/",defaultHandler,TokenKind.DIVISION),
+            new RegexPattern("%",defaultHandler,TokenKind.PRECENT),
+            new RegexPattern(";",defaultHandler,TokenKind.SEMICOLON)
+        ];
+
+        public static void Tokenize(string source)
+        {
+            Tokens.Clear();
+            Pos = 0;
+            Source = source;
+            Linecount = 1;
+            while (!at_eof())
+            {
+                bool matched = false;
+
+                foreach (RegexPattern patern in Patterns)
+                {
+                    if (patern.check(restOfString()))
+                    {
+                        matched = true;
+                        break;
+                    }
+                }
+                if (matched != true)
+                {
+                    throw new Exception($"Unknown Expression at Line: {Linecount}");
+                }
+            }
+
+            Tokens.Add(new Token(TokenKind.EOF, "", Linecount));
+        }
+
+        private static string restOfString()
+        {
+            return Source.Substring(Pos);
+        }
+
+        private static bool at_eof()
+        {
+            return Pos >= Source.Length;
+        }
+
+        private static void defaultHandler(object? e, TokenizeEventArgs args)
+        {
+            Tokens.Add(new Token(args.Kind, args.Value, Linecount));
+            Pos += args.Value.Length;
+        }
+
+         private static void symbolHandler(object? sender, TokenizeEventArgs args)
+        {
+            Tokens.Add(new Token(args.Kind, args.Value, Linecount).mapToKeyword());
+            Pos += args.Value.Length;
+        }
+
+        private static void stringHandler(object? sender, TokenizeEventArgs e)
+        {
+            Tokens.Add(new Token(e.Kind, e.Value.Substring(1, e.Value.Length - 2), Linecount));
+            Pos += e.Value.Length;
+        }
+
+        private static void skipHandler(object? e, TokenizeEventArgs args)
+        {
+            Pos += args.Value.Length;
+            if (args.Kind == TokenKind.LineBrake)
+            {
+                Linecount++;
+            }
+        }
+
+        public static Token[] getTokens()
+        {
+            return Tokens.ToArray();
+        }
+
+        public static string toString()
+        {
+            StringBuilder builder = new StringBuilder();
+            foreach (Token token in Tokens)
+            {
+                builder.Append(token.ToString());
+                builder.Append(Environment.NewLine);
+            }
+            return builder.ToString();
+        }
+    }
+
+}
@@ -0,0 +1,142 @@
+
+namespace PratParser.Lexer
+{
+    public struct Token(TokenKind kind, string value, int codeline)
+    {
+        public TokenKind Kind = kind;
+        public string Value = value;
+        public int Codeline = codeline;
+
+        public override string ToString()
+        {
+            if (isOneOfMany([TokenKind.IDENTIFIER, TokenKind.NUMBER, TokenKind.STRING_VALUE]))
+            {
+                return $"{Kind} : ({Value}) -> In Line: {Codeline}";
+            }
+            else
+            {
+                return $"{Kind} -> In Line: {Codeline}";
+            }
+        }
+
+        public bool isOneOfMany(TokenKind[] expectedTokens)
+        {
+            return expectedTokens.Contains(Kind);
+        }
+
+        public Token mapToKeyword()
+        {
+            if (keywordMap.ContainsKey(Value))
+            {
+                Kind = keywordMap[Value];
+            }
+            return this;
+        }
+
+        private static Dictionary<string, TokenKind> keywordMap = new Dictionary<string, TokenKind>
+        {
+            { "const", TokenKind.CONST },
+            { "public", TokenKind.PUBLIC },
+            { "private", TokenKind.PRIAVTE }, 
+            { "protected", TokenKind.PROTECTED },
+            { "namespace", TokenKind.NAMESPACE },
+            { "class", TokenKind.CLASS },
+            { "new", TokenKind.NEW },
+            { "import", TokenKind.IMPORT },
+            { "from", TokenKind.FROM },
+            { "void", TokenKind.VOID },
+            { "if", TokenKind.IF },
+            { "else", TokenKind.ELSE },
+            { "while", TokenKind.WHILE },
+            { "do", TokenKind.DO },
+            { "for", TokenKind.FOR },
+            { "foreach", TokenKind.FOREACH },
+            { "typeof", TokenKind.TYPEOF },
+            { "in", TokenKind.IN },
+            { "int", TokenKind.INT },
+            { "float", TokenKind.FLOAT },
+            { "double", TokenKind.DOUBLE },
+            { "word", TokenKind.WORD },
+            { "byte", TokenKind.BYTE },
+            { "bool", TokenKind.BOOL },
+            { "lint", TokenKind.LINT },
+            { "sint", TokenKind.SINT },
+            { "string", TokenKind.STRING_TYPE }
+        };
+    }
+
+    public enum TokenKind
+    {
+        EOF,
+        NUMBER,
+        STRING_VALUE,
+        COMMENT,
+        IDENTIFIER,
+        Whitespace,
+        LineBrake,
+
+        OPEN_BRACKET,
+        CLOSE_BRACKET,
+        OPEN_CURLY,
+        CLOSE_CURLY,
+        OPEN_PAREN,
+        CLOSE_PAREN,
+
+        ASSIGMENT,
+        EQUALS,
+        NOT,
+        NOT_EQUALS,
+        LESS,
+        LESS_EQUALS,
+        GREATER,
+        GREATER_EQUALS,
+        AND,
+        OR,
+
+        DOT,
+        DOT_DOT,
+        SEMICOLON,
+        COLON,
+        QUESTION,
+        COMMA,
+
+        PLUS,
+        MINUS,
+        MULTIPLY,
+        DIVISION,
+        PLUSPLUS,
+        MINUSMINUS,
+        PLUSEQUALS,
+        MINUSEQUALS,
+        PRECENT,
+
+        //Known Keywords
+        CONST,
+        PUBLIC,
+        PRIAVTE,
+        PROTECTED,
+        NAMESPACE,
+        CLASS,
+        NEW,
+        IMPORT,
+        FROM,
+        VOID,
+        IF,
+        ELSE,
+        WHILE,
+        DO,
+        FOR,
+        FOREACH,
+        TYPEOF,
+        IN,
+        INT,
+        FLOAT,
+        DOUBLE,
+        WORD,
+        BYTE,
+        BOOL,
+        LINT,
+        SINT,
+        STRING_TYPE
+    }
+}
@@ -0,0 +1,65 @@
+using ast;
+using PratParser.Lexer;
+
+namespace Parsing
+{
+    public class Parser
+    {
+        Token[] Tokens = [];
+        int pos = 0;
+
+        public Token expect(TokenKind kind)
+        {
+            return expectError(kind);
+        }
+
+        private Token expectError(TokenKind expectedKind)
+        {
+            Token token = currentToken();
+            TokenKind kind = token.Kind;
+
+            if (kind != expectedKind)
+            {
+                throw new Exception($"Expected {expectedKind} but recived {kind} instead\n");
+            }
+
+            return advance();
+        }
+
+        public BlockStatement Parse(Token[] tokens)
+        {
+            Tokens = tokens;
+
+            List<Statement> Body = [];
+
+            while (hasTokens())
+            {
+                Body.Add(Statement.Parse(this));
+            }
+
+            return new BlockStatement(Body.ToArray());
+        }
+
+        private Token currentToken()
+        {
+            return Tokens[pos];
+        }
+
+        internal TokenKind currentTokenKind()
+        {
+            return currentToken().Kind;
+        }
+
+        internal Token advance()
+        {
+            Token tk = currentToken();
+            pos++;
+            return tk;
+        }
+
+        private bool hasTokens()
+        {
+            return pos < Tokens.Length && currentTokenKind() != TokenKind.EOF; 
+        }
+    }
+}
@@ -0,0 +1,78 @@
+using ast;
+using PratParser.Lexer;
+
+namespace Parsing
+{
+    internal enum BindingPowers
+    {
+        default_bp = 0,
+        comma,
+        assignment,
+        logical,
+        relational,
+        additive,
+        multiplicative,
+        unary,
+        call,
+        member,
+        primary
+    }
+
+    internal delegate Statement? Statement_Handler(Parser parser);
+    internal delegate Expression? nud_Handler(Parser parser);
+    internal delegate Expression? led_Handler(Parser parser, Expression left, BindingPowers bp);
+
+    internal static class lookups
+    {
+        public static Dictionary<TokenKind, Statement_Handler> Statement_Lookup = [];
+        public static Dictionary<TokenKind, nud_Handler> Nud_Lookup = [];
+        public static Dictionary<TokenKind, led_Handler> Led_Lookup = [];
+        public static Dictionary<TokenKind, BindingPowers> BindingPower_Lookup = [];
+
+        private static void initializeNud(TokenKind kind, BindingPowers bp, nud_Handler handler)
+        {
+            Nud_Lookup.Add(kind, handler);
+            BindingPower_Lookup.Add(kind, bp);
+        }
+
+        private static void initializeLed(TokenKind kind, BindingPowers bp, led_Handler handler)
+        {
+            Led_Lookup.Add(kind, handler);
+            BindingPower_Lookup.Add(kind, bp);
+        }
+
+        private static void initializeStatement(TokenKind kind, Statement_Handler handler)
+        {
+            Statement_Lookup.Add(kind, handler);
+            BindingPower_Lookup.Add(kind, BindingPowers.default_bp);
+        }
+
+        static lookups()
+        {
+            //Logical
+            initializeLed(TokenKind.AND, BindingPowers.logical, Expression.ParseBinayExpression);
+            initializeLed(TokenKind.OR, BindingPowers.logical, Expression.ParseBinayExpression);
+            initializeLed(TokenKind.DOT_DOT, BindingPowers.logical, Expression.ParseBinayExpression);
+
+            //Relational
+            initializeLed(TokenKind.LESS, BindingPowers.relational, Expression.ParseBinayExpression);
+            initializeLed(TokenKind.LESS_EQUALS, BindingPowers.relational, Expression.ParseBinayExpression);
+            initializeLed(TokenKind.GREATER, BindingPowers.relational, Expression.ParseBinayExpression);
+            initializeLed(TokenKind.GREATER_EQUALS, BindingPowers.relational, Expression.ParseBinayExpression);
+            initializeLed(TokenKind.EQUALS, BindingPowers.relational, Expression.ParseBinayExpression);
+            initializeLed(TokenKind.NOT_EQUALS, BindingPowers.relational, Expression.ParseBinayExpression);
+
+            //Additiv Multiplicative
+            initializeLed(TokenKind.PLUS, BindingPowers.additive, Expression.ParseBinayExpression);
+            initializeLed(TokenKind.MINUS, BindingPowers.additive, Expression.ParseBinayExpression);
+            initializeLed(TokenKind.MULTIPLY, BindingPowers.multiplicative, Expression.ParseBinayExpression);
+            initializeLed(TokenKind.DIVISION, BindingPowers.multiplicative, Expression.ParseBinayExpression);
+            initializeLed(TokenKind.PRECENT, BindingPowers.multiplicative, Expression.ParseBinayExpression);
+
+            initializeNud(TokenKind.NUMBER, BindingPowers.primary, Expression.ParsePrimaryExpression);
+            initializeNud(TokenKind.STRING_VALUE, BindingPowers.primary, Expression.ParsePrimaryExpression);
+            initializeNud(TokenKind.IDENTIFIER, BindingPowers.primary, Expression.ParsePrimaryExpression);
+        }
+    }
+
+}
@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="Ressources\**\*">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+</Project>
@@ -0,0 +1,38 @@
+#define DEBUG
+
+
+#if DEBUG
+using System.Linq.Expressions;
+using ast;
+using Lexer;
+using Parsing;
+
+string path = "Ressources/testPrserCode.txt";
+#else
+    Console.WriteLine("Insert the Path to the Parsable File");
+    string? path = Console.ReadLine();
+#endif
+
+if (path == null) return;
+
+FileStream stream = File.OpenRead(path);
+
+StreamReader reader = new StreamReader(stream);
+string? codeline;
+    codeline = reader.ReadToEnd();
+
+    if (codeline != null)
+    {
+        Console.WriteLine(codeline);
+    }
+
+
+Tokenizer.Tokenize(codeline);
+
+Console.Write(Tokenizer.toString());
+
+BlockStatement statement = new Parser().Parse(Tokenizer.getTokens());
+
+Console.Write(statement);
+
+
@@ -0,0 +1 @@
+4.2 + 45 * 5;
@@ -0,0 +1,3 @@
+"Test String = \"Testing\""
+20 + 15 + (2.4 + -2);
+int a = 15 + 20;
@@ -0,0 +1,66 @@
+using System.Text;
+
+namespace ast
+{
+    public class BlockStatement : Statement
+    {
+        Statement[] Body;
+
+        public BlockStatement(Statement[] body)
+        {
+            Body = body;
+        }
+
+        public override void stmt()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override string ToString()
+        {
+            return ToString(0);
+        }
+
+        public override string ToString(int indentLevel)
+        {
+            string indent = new string(' ', indentLevel * 2);
+            StringBuilder builder = new StringBuilder();
+            builder.AppendLine($"{indent}BlockStatement {{");
+
+            foreach (var stmt in Body)
+            {
+                builder.AppendLine(stmt.ToString(indentLevel + 1));
+            }
+
+            builder.Append($"{indent}}}");
+            return builder.ToString();
+        }
+    }
+
+
+    public class ExpressionStatement : Statement
+    {
+        Expression Expression;
+
+        public ExpressionStatement(Expression exp)
+        {
+            Expression = exp;
+        }
+
+        public override void stmt()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override string ToString()
+        {
+            return ToString(0);
+        }
+
+        public override string ToString(int indentLevel)
+        {
+            string indent = new string(' ', indentLevel * 2);
+            return $"{indent}ExpressionStatement:  \n{Expression.ToString(indentLevel+1)}";
+        }
+    }
+}
@@ -0,0 +1,79 @@
+using System.Collections;
+using System.Reflection.Metadata;
+using System.Security.AccessControl;
+using Parsing;
+using PratParser.Lexer;
+
+namespace ast
+{
+    public abstract class Statement
+    {
+        public abstract void stmt();
+
+         public abstract string ToString(int indentLevel);
+
+        public static Statement Parse(Parser parser)
+        {
+            if (lookups.Statement_Lookup.TryGetValue(parser.currentTokenKind(), out Statement_Handler? statement_Handler))
+            {
+                return statement_Handler(parser);
+            }
+
+            Expression? exp = Expression.parse_expression(parser, BindingPowers.default_bp);
+            parser.expect(TokenKind.SEMICOLON);
+
+            return new ExpressionStatement(exp);
+        }
+    }
+
+    public abstract class Expression
+    {
+        public abstract void expr();
+
+         public abstract string ToString(int indentLevel);
+
+        public static Expression ParsePrimaryExpression(Parser p)
+        {
+            switch (p.currentTokenKind())
+            {
+                case TokenKind.NUMBER:
+                    return new NumberExpr(p.advance().Value);
+                case TokenKind.STRING_VALUE:
+                    return new StringExpr(p.advance().Value);
+                case TokenKind.IDENTIFIER:
+                    return new SymbolExpr(p.advance().Value);
+                default:
+                    throw new ArgumentException();
+            }
+        }
+
+        internal static Expression? ParseBinayExpression(Parser parser, Expression left, BindingPowers bp)
+        {
+            Token operatorToken = parser.advance();
+            Expression right = parse_expression(parser, bp);
+
+            return new BinaryExpression(left, operatorToken, right);
+        }
+
+        internal static Expression? parse_expression(Parser parser, BindingPowers bp)
+        {
+            //Firste parse the nud
+
+            TokenKind tokenKind = parser.currentTokenKind();
+            if (!lookups.Nud_Lookup.TryGetValue(tokenKind, out nud_Handler? handler)) throw new Exception("Tokenkind not found");
+
+            Expression? left = handler(parser) ?? throw new Exception("Unparsable Token");
+
+            while (lookups.BindingPower_Lookup.TryGetValue(parser.currentTokenKind(), out BindingPowers binding) && binding > bp)
+            {
+                tokenKind = parser.currentTokenKind();
+                if (!lookups.Led_Lookup.TryGetValue(tokenKind, out led_Handler? ledhandler)) throw new Exception("Tokenkind not found");
+
+                left = ledhandler(parser, left, bp);
+            }
+
+            return left;
+            // While we Have a Lead and the current bp is < then bp of current token Contunie Prsing
+        }
+    }
+}
@@ -0,0 +1,117 @@
+using System.Net;
+using PratParser.Lexer;
+
+namespace ast
+{
+    public class NumberExpr : Expression
+    {
+        public double Value { get; private set; }
+
+        public NumberExpr(string value)
+        {
+            Value = double.Parse(value);
+        }
+
+        public override void expr()
+        {
+            throw new NotImplementedException();
+        }
+        public override string ToString()
+        {
+            return ToString(0);
+        }
+
+        public override string ToString(int indentLevel)
+        {
+            string indent = new string(' ', indentLevel * 2);
+            return $"{indent}NumberExpr({Value})";
+        }
+    }
+
+    public class StringExpr : Expression
+    {
+        public string Value { get; private set; }
+
+        public StringExpr(string value)
+        {
+            Value = value;
+        }
+
+        public override void expr()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override string ToString()
+        {
+            return ToString(0);
+        }
+
+        public override string ToString(int indentLevel)
+        {
+            string indent = new string(' ', indentLevel * 2);
+            return $"{indent}StringExpr(\"{Value}\")";
+        }
+    }
+
+    public class SymbolExpr : Expression
+    {
+        public string Value { get; private set; }
+
+        public SymbolExpr(string value)
+        {
+            Value = value;
+        }
+
+        public override void expr()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override string ToString()
+        {
+            return ToString(0);
+        }
+
+        public override string ToString(int indentLevel)
+        {
+            string indent = new string(' ', indentLevel * 2);
+            return $"{indent}SymbolExpr({Value})";
+        }
+    }
+
+    //Complex Expression
+    public class BinaryExpression : Expression
+    {
+        Expression Left;
+        Token Operator;
+        Expression Right;
+
+        public BinaryExpression(Expression left, Token oper, Expression right)
+        {
+            Left = left;
+            Operator = oper;
+            Right = right;
+        }
+
+        public override void expr()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override string ToString()
+        {
+            return ToString(0);
+        }
+
+        public override string ToString(int indentLevel)
+        {
+            string indent = new string(' ', indentLevel * 2);
+            return $"{indent}BinaryExpr(\n" +
+                   $"{Left.ToString(indentLevel + 1)},\n" +
+                   $"{indent}  {Operator},\n" +
+                   $"{Right.ToString(indentLevel + 1)}\n" +
+                   $"{indent})";
+        }
+    }
+}
@@ -0,0 +1,23 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v9.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v9.0": {
+      "PratParser/1.0.0": {
+        "runtime": {
+          "PratParser.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "PratParser/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}
@@ -0,0 +1,12 @@
+{
+  "runtimeOptions": {
+    "tfm": "net9.0",
+    "framework": {
+      "name": "Microsoft.NETCore.App",
+      "version": "9.0.0"
+    },
+    "configProperties": {
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}
@@ -0,0 +1 @@
+4.2 + 45 * 5;
@@ -0,0 +1,3 @@
+"Test String = \"Testing\""
+20 + 15 + (2.4 + -2);
+int a = 15 + 20;
@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v9.0", FrameworkDisplayName = ".NET 9.0")]
@@ -0,0 +1,22 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: System.Reflection.AssemblyCompanyAttribute("PratParser")]
+[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0")]
+[assembly: System.Reflection.AssemblyProductAttribute("PratParser")]
+[assembly: System.Reflection.AssemblyTitleAttribute("PratParser")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
+
+// Generated by the MSBuild WriteCodeFragment class.
+
@@ -0,0 +1 @@
+85729b138746085f67449f60f64b4e53d4894da2ab994747153023fdbbb60cb6
@@ -0,0 +1,15 @@
+is_global = true
+build_property.TargetFramework = net9.0
+build_property.TargetPlatformMinVersion = 
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.ProjectTypeGuids = 
+build_property.InvariantGlobalization = 
+build_property.PlatformNeutralAssembly = 
+build_property.EnforceExtendedAnalyzerRules = 
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property.RootNamespace = PratParser
+build_property.ProjectDir = C:\Users\wayan\Documents\pratParser\PratParser\
+build_property.EnableComHosting = 
+build_property.EnableGeneratedComInterfaceComImportInterop = 
+build_property.EffectiveAnalysisLevelStyle = 9.0
+build_property.EnableCodeStyleSeverity = 
@@ -0,0 +1,8 @@
+// <auto-generated/>
+global using global::System;
+global using global::System.Collections.Generic;
+global using global::System.IO;
+global using global::System.Linq;
+global using global::System.Net.Http;
+global using global::System.Threading;
+global using global::System.Threading.Tasks;
@@ -0,0 +1 @@
+77aa58cb5516ffdc1572656d3a2eec1900dd2baa3a7c596c8c488fc2d9a728c0
@@ -0,0 +1,16 @@
+C:\Users\wayan\Documents\pratParser\PratParser\bin\Debug\net9.0\PratParser.exe
+C:\Users\wayan\Documents\pratParser\PratParser\bin\Debug\net9.0\PratParser.deps.json
+C:\Users\wayan\Documents\pratParser\PratParser\bin\Debug\net9.0\PratParser.runtimeconfig.json
+C:\Users\wayan\Documents\pratParser\PratParser\bin\Debug\net9.0\PratParser.dll
+C:\Users\wayan\Documents\pratParser\PratParser\bin\Debug\net9.0\PratParser.pdb
+C:\Users\wayan\Documents\pratParser\PratParser\obj\Debug\net9.0\PratParser.GeneratedMSBuildEditorConfig.editorconfig
+C:\Users\wayan\Documents\pratParser\PratParser\obj\Debug\net9.0\PratParser.AssemblyInfoInputs.cache
+C:\Users\wayan\Documents\pratParser\PratParser\obj\Debug\net9.0\PratParser.AssemblyInfo.cs
+C:\Users\wayan\Documents\pratParser\PratParser\obj\Debug\net9.0\PratParser.csproj.CoreCompileInputs.cache
+C:\Users\wayan\Documents\pratParser\PratParser\obj\Debug\net9.0\PratParser.dll
+C:\Users\wayan\Documents\pratParser\PratParser\obj\Debug\net9.0\refint\PratParser.dll
+C:\Users\wayan\Documents\pratParser\PratParser\obj\Debug\net9.0\PratParser.pdb
+C:\Users\wayan\Documents\pratParser\PratParser\obj\Debug\net9.0\PratParser.genruntimeconfig.cache
+C:\Users\wayan\Documents\pratParser\PratParser\obj\Debug\net9.0\ref\PratParser.dll
+C:\Users\wayan\Documents\pratParser\PratParser\bin\Debug\net9.0\Ressources\testcode.txt
+C:\Users\wayan\Documents\pratParser\PratParser\bin\Debug\net9.0\Ressources\testPrserCode.txt
@@ -0,0 +1 @@
+c549846708a50bbf705c9f138631838f500d7cfed9153757e9d5cdffe2ddc47d
@@ -0,0 +1,76 @@
+{
+  "format": 1,
+  "restore": {
+    "C:\\Users\\wayan\\Documents\\pratParser\\PratParser\\PratParser.csproj": {}
+  },
+  "projects": {
+    "C:\\Users\\wayan\\Documents\\pratParser\\PratParser\\PratParser.csproj": {
+      "version": "1.0.0",
+      "restore": {
+        "projectUniqueName": "C:\\Users\\wayan\\Documents\\pratParser\\PratParser\\PratParser.csproj",
+        "projectName": "PratParser",
+        "projectPath": "C:\\Users\\wayan\\Documents\\pratParser\\PratParser\\PratParser.csproj",
+        "packagesPath": "C:\\Users\\wayan\\.nuget\\packages\\",
+        "outputPath": "C:\\Users\\wayan\\Documents\\pratParser\\PratParser\\obj\\",
+        "projectStyle": "PackageReference",
+        "fallbackFolders": [
+          "C:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages"
+        ],
+        "configFilePaths": [
+          "C:\\Users\\wayan\\AppData\\Roaming\\NuGet\\NuGet.Config",
+          "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.FallbackLocation.config",
+          "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
+        ],
+        "originalTargetFrameworks": [
+          "net9.0"
+        ],
+        "sources": {
+          "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
+          "C:\\Program Files\\dotnet\\library-packs": {},
+          "C:\\TwinCAT\\Functions\\TE2000-HMI-Engineering\\Infrastructure\\Packages": {},
+          "C:\\TwinCAT\\Functions\\TE2000-HMI-Engineering\\References": {},
+          "https://api.nuget.org/v3/index.json": {}
+        },
+        "frameworks": {
+          "net9.0": {
+            "targetAlias": "net9.0",
+            "projectReferences": {}
+          }
+        },
+        "warningProperties": {
+          "warnAsError": [
+            "NU1605"
+          ]
+        },
+        "restoreAuditProperties": {
+          "enableAudit": "true",
+          "auditLevel": "low",
+          "auditMode": "direct"
+        },
+        "SdkAnalysisLevel": "9.0.300"
+      },
+      "frameworks": {
+        "net9.0": {
+          "targetAlias": "net9.0",
+          "imports": [
+            "net461",
+            "net462",
+            "net47",
+            "net471",
+            "net472",
+            "net48",
+            "net481"
+          ],
+          "assetTargetFallback": true,
+          "warn": true,
+          "frameworkReferences": {
+            "Microsoft.NETCore.App": {
+              "privateAssets": "all"
+            }
+          },
+          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.304/PortableRuntimeIdentifierGraph.json"
+        }
+      }
+    }
+  }
+}
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <RestoreSuccess Condition=" '$(RestoreSuccess)' == '' ">True</RestoreSuccess>
+    <RestoreTool Condition=" '$(RestoreTool)' == '' ">NuGet</RestoreTool>
+    <ProjectAssetsFile Condition=" '$(ProjectAssetsFile)' == '' ">$(MSBuildThisFileDirectory)project.assets.json</ProjectAssetsFile>
+    <NuGetPackageRoot Condition=" '$(NuGetPackageRoot)' == '' ">$(UserProfile)\.nuget\packages\</NuGetPackageRoot>
+    <NuGetPackageFolders Condition=" '$(NuGetPackageFolders)' == '' ">C:\Users\wayan\.nuget\packages\;C:\Program Files (x86)\Microsoft Visual Studio\Shared\NuGetPackages</NuGetPackageFolders>
+    <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
+    <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">6.14.1</NuGetToolVersion>
+  </PropertyGroup>
+  <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <SourceRoot Include="C:\Users\wayan\.nuget\packages\" />
+    <SourceRoot Include="C:\Program Files (x86)\Microsoft Visual Studio\Shared\NuGetPackages\" />
+  </ItemGroup>
+</Project>
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" />
@@ -0,0 +1,82 @@
+{
+  "version": 3,
+  "targets": {
+    "net9.0": {}
+  },
+  "libraries": {},
+  "projectFileDependencyGroups": {
+    "net9.0": []
+  },
+  "packageFolders": {
+    "C:\\Users\\wayan\\.nuget\\packages\\": {},
+    "C:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages": {}
+  },
+  "project": {
+    "version": "1.0.0",
+    "restore": {
+      "projectUniqueName": "C:\\Users\\wayan\\Documents\\pratParser\\PratParser\\PratParser.csproj",
+      "projectName": "PratParser",
+      "projectPath": "C:\\Users\\wayan\\Documents\\pratParser\\PratParser\\PratParser.csproj",
+      "packagesPath": "C:\\Users\\wayan\\.nuget\\packages\\",
+      "outputPath": "C:\\Users\\wayan\\Documents\\pratParser\\PratParser\\obj\\",
+      "projectStyle": "PackageReference",
+      "fallbackFolders": [
+        "C:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages"
+      ],
+      "configFilePaths": [
+        "C:\\Users\\wayan\\AppData\\Roaming\\NuGet\\NuGet.Config",
+        "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.FallbackLocation.config",
+        "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
+      ],
+      "originalTargetFrameworks": [
+        "net9.0"
+      ],
+      "sources": {
+        "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
+        "C:\\Program Files\\dotnet\\library-packs": {},
+        "C:\\TwinCAT\\Functions\\TE2000-HMI-Engineering\\Infrastructure\\Packages": {},
+        "C:\\TwinCAT\\Functions\\TE2000-HMI-Engineering\\References": {},
+        "https://api.nuget.org/v3/index.json": {}
+      },
+      "frameworks": {
+        "net9.0": {
+          "targetAlias": "net9.0",
+          "projectReferences": {}
+        }
+      },
+      "warningProperties": {
+        "warnAsError": [
+          "NU1605"
+        ]
+      },
+      "restoreAuditProperties": {
+        "enableAudit": "true",
+        "auditLevel": "low",
+        "auditMode": "direct"
+      },
+      "SdkAnalysisLevel": "9.0.300"
+    },
+    "frameworks": {
+      "net9.0": {
+        "targetAlias": "net9.0",
+        "imports": [
+          "net461",
+          "net462",
+          "net47",
+          "net471",
+          "net472",
+          "net48",
+          "net481"
+        ],
+        "assetTargetFallback": true,
+        "warn": true,
+        "frameworkReferences": {
+          "Microsoft.NETCore.App": {
+            "privateAssets": "all"
+          }
+        },
+        "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.304/PortableRuntimeIdentifierGraph.json"
+      }
+    }
+  }
+}
@@ -0,0 +1,8 @@
+{
+  "version": 2,
+  "dgSpecHash": "jYRDsoiv3mc=",
+  "success": true,
+  "projectFilePath": "C:\\Users\\wayan\\Documents\\pratParser\\PratParser\\PratParser.csproj",
+  "expectedPackageFiles": [],
+  "logs": []
+}
@@ -0,0 +1,34 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PratParser", "PratParser\PratParser.csproj", "{7DE15ADD-C045-41C6-BC32-2056F25B6B54}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Debug|x64.Build.0 = Debug|Any CPU
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Debug|x86.Build.0 = Debug|Any CPU
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Release|x64.ActiveCfg = Release|Any CPU
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Release|x64.Build.0 = Release|Any CPU
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Release|x86.ActiveCfg = Release|Any CPU
+		{7DE15ADD-C045-41C6-BC32-2056F25B6B54}.Release|x86.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
				`@@ -0,0 +1 @@`
				`85729b138746085f67449f60f64b4e53d4894da2ab994747153023fdbbb60cb6`
				`@@ -0,0 +1 @@`
				`77aa58cb5516ffdc1572656d3a2eec1900dd2baa3a7c596c8c488fc2d9a728c0`
				`@@ -0,0 +1 @@`
				`c549846708a50bbf705c9f138631838f500d7cfed9153757e9d5cdffe2ddc47d`