improved performance

NotImplementedLife · NotImplementedLife · commit 5c30a7ec1388 · 2023-04-30T18:16:19.000+03:00
diff --git a/AtomResult.cs b/AtomResult.cs
@@ -0,0 +1,35 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EsotericDevZone.RuleBasedParser
+{
+    public class AtomResult
+    {
+        public object Value { get; }
+        public string ErrorMessage { get; }
+
+        public bool Failed => ErrorMessage != null;
+
+        private AtomResult(object value, string errorMessage)
+        {
+            Value = value;
+            ErrorMessage = errorMessage;
+        }        
+
+        public static AtomResult Atom(object value)
+        {            
+            return new AtomResult(value, null);
+        }
+        public static AtomResult Error(string message)
+        {            
+            return new AtomResult(null, message);
+        }
+
+        public override string ToString() => Failed ? $"AtomResult Error={ErrorMessage}"
+            : $"AtomResult Value={Value}";
+
+    }
+}
diff --git a/EsotericDevZone.RuleBasedParser.csproj b/EsotericDevZone.RuleBasedParser.csproj
@@ -51,6 +51,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AtomResult.cs" />
     <Compile Include="ParseError.cs" />
     <Compile Include="Presets\AtomBuilders.cs" />
     <Compile Include="IgnoreMatch.cs" />
diff --git a/IgnoreMatch.cs b/IgnoreMatch.cs
@@ -5,8 +5,7 @@ internal class IgnoreMatch : IParseRulePatternItemMatch
     {
         public int Position { get; }
 
-        public int TokensCount { get; } = 1;
-        public double Similarity { get; set; }
+        public int TokensCount { get; } = 1;        
 
         public IgnoreMatch(int position, int tokensCount=1)
         {
diff --git a/ParseError.cs b/ParseError.cs
@@ -9,13 +9,13 @@ internal class ParseError : IParseRulePatternItemMatch
 
         public int TokensCount { get; } = 0;
 
-        public double Similarity { get; set; } = 0;
+        public double Relevance { get; set; } = 0;
 
         public ParseError(ParseError error, double similarity)
         {
             Message = error.Message;
             Position = error.Position;
-            Similarity = similarity;
+            Relevance = similarity;
         }
 
         public ParseError(string message, int position)
@@ -24,6 +24,6 @@ public ParseError(string message, int position)
             Position = position;
         }
 
-        public override string ToString() => $"ParseError: \"{Message}\" at token index {Position} [S={Similarity}]";
+        public override string ToString() => $"ParseError: \"{Message}\" at token index {Position} [S={Relevance}]";
     }
 }
diff --git a/ParseException.cs b/ParseException.cs
@@ -8,20 +8,25 @@ namespace EsotericDevZone.RuleBasedParser
 {
     public class ParseException : Exception
     {
-        public Token ReferencedToken { get;  } = null;
+        public Token ReferencedToken { get; } = null;
 
         public ParseException() : base() { }
         public ParseException(string message) : base(message) { }
         public ParseException(Token token, string message) : base(message) { ReferencedToken = token; }
         public ParseException(Exception exception) : base(exception.Message, exception) { }
         public ParseException(ParseException exception) : this(exception.ReferencedToken, exception.Message) { }
 
-        public override string ToString()
+        public override string Message 
         {
-            if (ReferencedToken == null) 
-                return $"Parse error: {Message}";
-            else
-                return $"{ReferencedToken.Line}:{ReferencedToken.Column} Parse error: {Message}";
-        } 
+            get
+            {
+                if (ReferencedToken == null)
+                    return $"Parse error: {base.Message}";
+                else
+                    return $"{ReferencedToken.Line}:{ReferencedToken.Column} Parse error: {base.Message}";
+            }
+        }
+
+        public override string ToString() => Message;        
     }
 }
diff --git a/ParseRecord.cs b/ParseRecord.cs
@@ -9,8 +9,7 @@ class ParseRecord : IParseRulePatternItemMatch
         public string RuleKey { get; }
         public ParseResult Result { get; }
         public int Position { get; }
-        public int TokensCount { get; }
-        public double Similarity { get; set; }
+        public int TokensCount { get; }        
         public ParseError Error { get; }
 
         public ParseRecord(ParseError error)
diff --git a/ParseRulePatterns/AtomPatternItem.cs b/ParseRulePatterns/AtomPatternItem.cs
@@ -1,26 +1,19 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+﻿using System.Collections.Generic;
 
 namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns
 {
     internal class AtomPatternItem : IParseRulePatternItem
     {
         public string Name { get; }        
-        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)
-        {
-            try
-            {
-                var resObj = parser.GetAtomBuilder(Name)(tokens[position].Value);
-                var result = new ParseResult(tokens[position], resObj);
-                return new ParseRecord(Name, result, position, 1) { Similarity = 1 };
-            }
-            catch(Exception e)
+        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)
+        {            
+            var atom = parser.GetAtomBuilder(Name)(tokens[position].Value);            
+            if (atom.Failed) 
             {
-                return new ParseError(e.Message, position);
+                return new ParseError(atom.ErrorMessage, position);
             }            
+            var result = new ParseResult(tokens[position], atom.Value);
+            return new ParseRecord(Name, result, position, 1);      
         }
 
         public AtomPatternItem(string name)
diff --git a/ParseRulePatterns/IParseRulePatternItem.cs b/ParseRulePatterns/IParseRulePatternItem.cs
@@ -4,6 +4,6 @@ namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns
 {
     internal interface IParseRulePatternItem
     {        
-        IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack=0);
+        IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position);
     }
 }
diff --git a/ParseRulePatterns/IParseRulePatternItemMatch.cs b/ParseRulePatterns/IParseRulePatternItemMatch.cs
@@ -3,7 +3,6 @@
     internal interface IParseRulePatternItemMatch 
     {
         int Position { get; }
-        int TokensCount { get; }
-        double Similarity { get; set; }
+        int TokensCount { get; }        
     }    
 }
diff --git a/ParseRulePatterns/LiteralPatternItem.cs b/ParseRulePatterns/LiteralPatternItem.cs
@@ -9,13 +9,13 @@ namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns
     internal class LiteralPatternItem : IParseRulePatternItem
     {
         public string Name { get; }
-        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)
+        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)
         {
             if (tokens[position].Value != Name)
             {
                 return new ParseError($"Expected '{Name}', got '{tokens[position].Value}'", position);
             }                
-            return new IgnoreMatch(position) { Similarity = 1 };
+            return new IgnoreMatch(position);
         }
 
         public LiteralPatternItem(string name)
diff --git a/ParseRulePatterns/RepeatableTailItem.cs b/ParseRulePatterns/RepeatableTailItem.cs
@@ -4,9 +4,9 @@ namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns
 {
     internal class RepeatableTailItem : IParseRulePatternItem
     {
-        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)
+        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)
         {
-            return new IgnoreMatch(position, 0) { Similarity = 1 };
+            return new IgnoreMatch(position, 0);
         }
 
         public override string ToString() => "??";
diff --git a/ParseRulePatterns/RuleKeyPatternItem.cs b/ParseRulePatterns/RuleKeyPatternItem.cs
@@ -6,12 +6,12 @@ internal class RuleKeyPatternItem : IParseRulePatternItem
     {
         public string RuleKey { get; }
 
-        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)
+        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)
         {
-            var rec = parser.LookFor(RuleKey, tokens, position, stack + 1);
+            var rec = parser.LookFor(RuleKey, tokens, position);
             if (rec.Error != null)
             {
-                return new ParseError(rec.Error, rec.Error.Similarity);
+                return new ParseError(rec.Error, rec.Error.Relevance);
             }
             return rec;
         }
diff --git a/ParseRulePatterns/WildcardPatternItem.cs b/ParseRulePatterns/WildcardPatternItem.cs
@@ -8,12 +8,12 @@ namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns
 {
     internal class WildcardPatternItem : IParseRulePatternItem
     {
-        private string[] Values;        
-        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)
+        private readonly string[] Values;        
+        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)
         {
             if (Values.Contains(tokens[position].Value))
-                return new WildcardMatch(tokens[position], position) { Similarity = 1 };
-            return new ParseError($"Unexpected token : {tokens[position]}", position);
+                return new WildcardMatch(tokens[position], position);
+            return new ParseError($"Unexpected token : {tokens[position].Value}", position);
         }
 
         public WildcardPatternItem(string[] values)
diff --git a/Parser.cs b/Parser.cs
diff --git a/Presets/AtomBuilders.cs b/Presets/AtomBuilders.cs
diff --git a/Presets/Parsers/ArithmeticsParser.cs b/Presets/Parsers/ArithmeticsParser.cs
diff --git a/WildcardMatch.cs b/WildcardMatch.cs

Original file line number	Diff line number	Diff line change
`@@ -5,8 +5,7 @@ internal class IgnoreMatch : IParseRulePatternItemMatch`
`5`	`5`	`{`
`6`	`6`	`public int Position { get; }`
`7`	`7`
`8`		`- public int TokensCount { get; } = 1;`
`9`		`- public double Similarity { get; set; }`
	`8`	`+ public int TokensCount { get; } = 1;`
`10`	`9`
`11`	`10`	`public IgnoreMatch(int position, int tokensCount=1)`
`12`	`11`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,13 +9,13 @@ internal class ParseError : IParseRulePatternItemMatch`
`9`	`9`
`10`	`10`	`public int TokensCount { get; } = 0;`
`11`	`11`
`12`		`- public double Similarity { get; set; } = 0;`
	`12`	`+ public double Relevance { get; set; } = 0;`
`13`	`13`
`14`	`14`	`public ParseError(ParseError error, double similarity)`
`15`	`15`	`{`
`16`	`16`	`Message = error.Message;`
`17`	`17`	`Position = error.Position;`
`18`		`- Similarity = similarity;`
	`18`	`+ Relevance = similarity;`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`public ParseError(string message, int position)`
`@@ -24,6 +24,6 @@ public ParseError(string message, int position)`
`24`	`24`	`Position = position;`
`25`	`25`	`}`
`26`	`26`
`27`		`- public override string ToString() => $"ParseError: \"{Message}\" at token index {Position} [S={Similarity}]";`
	`27`	`+ public override string ToString() => $"ParseError: \"{Message}\" at token index {Position} [S={Relevance}]";`
`28`	`28`	`}`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,6 @@ namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns`
`4`	`4`	`{`
`5`	`5`	`internal interface IParseRulePatternItem`
`6`	`6`	`{`
`7`		`- IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack=0);`
	`7`	`+ IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position);`
`8`	`8`	`}`
`9`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`	`internal interface IParseRulePatternItemMatch`
`4`	`4`	`{`
`5`	`5`	`int Position { get; }`
`6`		`- int TokensCount { get; }`
`7`		`- double Similarity { get; set; }`
	`6`	`+ int TokensCount { get; }`
`8`	`7`	`}`
`9`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,13 +9,13 @@ namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns`
`9`	`9`	`internal class LiteralPatternItem : IParseRulePatternItem`
`10`	`10`	`{`
`11`	`11`	`public string Name { get; }`
`12`		`- public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)`
	`12`	`+ public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)`
`13`	`13`	`{`
`14`	`14`	`if (tokens[position].Value != Name)`
`15`	`15`	`{`
`16`	`16`	`return new ParseError($"Expected '{Name}', got '{tokens[position].Value}'", position);`
`17`	`17`	`}`
`18`		`- return new IgnoreMatch(position) { Similarity = 1 };`
	`18`	`+ return new IgnoreMatch(position);`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`public LiteralPatternItem(string name)`