refined parse errors

NotImplementedLife · NotImplementedLife · commit 42462b94266b · 2023-04-30T12:58:03.000+03:00
diff --git a/EsotericDevZone.RuleBasedParser.csproj b/EsotericDevZone.RuleBasedParser.csproj
@@ -51,11 +51,13 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ParseError.cs" />
     <Compile Include="Presets\AtomBuilders.cs" />
     <Compile Include="IgnoreMatch.cs" />
     <Compile Include="NoTokensProvidedException.cs" />
     <Compile Include="ParseException.cs" />
     <Compile Include="CommentStyle.cs" />
+    <Compile Include="Presets\AtomBuildException.cs" />
     <Compile Include="Presets\CommentStyles.cs" />
     <Compile Include="Helpers\CommentsStyleHelper.cs" />
     <Compile Include="Helpers\TokenSplitHelper.cs" />
diff --git a/IgnoreMatch.cs b/IgnoreMatch.cs
@@ -6,6 +6,7 @@ internal class IgnoreMatch : IParseRulePatternItemMatch
         public int Position { get; }
 
         public int TokensCount { get; } = 1;
+        public double Similarity { get; set; }
 
         public IgnoreMatch(int position, int tokensCount=1)
         {
diff --git a/ParseError.cs b/ParseError.cs
@@ -0,0 +1,29 @@
+﻿using EsotericDevZone.RuleBasedParser.ParseRulePatterns;
+
+namespace EsotericDevZone.RuleBasedParser
+{
+    internal class ParseError : IParseRulePatternItemMatch
+    {
+        public string Message { get; }
+        public int Position { get; }
+
+        public int TokensCount { get; } = 0;
+
+        public double Similarity { get; set; } = 0;
+
+        public ParseError(ParseError error, double similarity)
+        {
+            Message = error.Message;
+            Position = error.Position;
+            Similarity = similarity;
+        }
+
+        public ParseError(string message, int position)
+        {
+            Message = message;
+            Position = position;
+        }
+
+        public override string ToString() => $"ParseError: \"{Message}\" at token index {Position} [S={Similarity}]";
+    }
+}
diff --git a/ParseRecord.cs b/ParseRecord.cs
@@ -10,12 +10,21 @@ class ParseRecord : IParseRulePatternItemMatch
         public ParseResult Result { get; }
         public int Position { get; }
         public int TokensCount { get; }
+        public double Similarity { get; set; }
+        public ParseError Error { get; }
+
+        public ParseRecord(ParseError error)
+        {
+            Error = error;
+        }
+
         public ParseRecord(string ruleKey, ParseResult value, int position, int tokensCount)
         {
             RuleKey = ruleKey;
             Result = value;
             Position = position;
             TokensCount = tokensCount;
+            Error = null;
         }
 
         public override string ToString() => $"Record(Key='{RuleKey}', Position={Position}, TokensCount={TokensCount})";       
diff --git a/ParseRulePatterns/AtomPatternItem.cs b/ParseRulePatterns/AtomPatternItem.cs
@@ -9,21 +9,17 @@ namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns
     internal class AtomPatternItem : IParseRulePatternItem
     {
         public string Name { get; }        
-        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)
+        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);
-            }
-            catch(ParseException e)
-            {
-                throw new ParseException((ParseException)e);
+                return new ParseRecord(Name, result, position, 1) { Similarity = 1 };
             }
             catch(Exception e)
             {
-                throw new ParseException(tokens[position], e.Message);
+                return new ParseError(e.Message, position);
             }            
         }
 
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);
+        IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack=0);
     }
 }
diff --git a/ParseRulePatterns/IParseRulePatternItemMatch.cs b/ParseRulePatterns/IParseRulePatternItemMatch.cs
@@ -4,5 +4,6 @@ internal interface IParseRulePatternItemMatch
     {
         int Position { get; }
         int TokensCount { get; }
+        double Similarity { get; set; }
     }    
 }
diff --git a/ParseRulePatterns/LiteralPatternItem.cs b/ParseRulePatterns/LiteralPatternItem.cs
@@ -9,11 +9,13 @@ namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns
     internal class LiteralPatternItem : IParseRulePatternItem
     {
         public string Name { get; }
-        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)
+        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)
         {
             if (tokens[position].Value != Name)
-                throw new ParseException(tokens[position], $"Expected '{Name}', got '{tokens[position].Value}'");
-            return new IgnoreMatch(position);
+            {
+                return new ParseError($"Expected '{Name}', got '{tokens[position].Value}'", position);
+            }                
+            return new IgnoreMatch(position) { Similarity = 1 };
         }
 
         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)
+        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)
         {
-            return new IgnoreMatch(position, 0);
+            return new IgnoreMatch(position, 0) { Similarity = 1 };
         }
 
         public override string ToString() => "??";
diff --git a/ParseRulePatterns/RuleKeyPatternItem.cs b/ParseRulePatterns/RuleKeyPatternItem.cs
@@ -1,30 +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 RuleKeyPatternItem : IParseRulePatternItem
     {
         public string RuleKey { get; }
 
-        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)
+        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)
         {
-            try
+            var rec = parser.LookFor(RuleKey, tokens, position, stack + 1);
+            if (rec.Error != null)
             {
-                var rec = parser.LookFor(RuleKey, tokens, position);
-                return rec;
-            }
-            catch(ParseException e)
-            {
-                throw new ParseException((ParseException)e);
-            }
-            catch (Exception e)
-            {
-                throw new ParseException(tokens[position], e.Message);
+                return new ParseError(rec.Error, rec.Error.Similarity);
             }
+            return rec;
         }
 
         public RuleKeyPatternItem(string ruleKey)
diff --git a/ParseRulePatterns/WildcardPatternItem.cs b/ParseRulePatterns/WildcardPatternItem.cs
@@ -9,11 +9,11 @@ namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns
     internal class WildcardPatternItem : IParseRulePatternItem
     {
         private string[] Values;        
-        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)
+        public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)
         {
             if (Values.Contains(tokens[position].Value))
-                return new WildcardMatch(tokens[position], position);
-            throw new ParseException(tokens[position], "Unexpected token");
+                return new WildcardMatch(tokens[position], position) { Similarity = 1 };
+            return new ParseError($"Unexpected token : {tokens[position]}", position);
         }
 
         public WildcardPatternItem(string[] values)
diff --git a/Parser.cs b/Parser.cs
diff --git a/Presets/AtomBuildException.cs b/Presets/AtomBuildException.cs
diff --git a/Presets/AtomBuilders.cs b/Presets/AtomBuilders.cs
diff --git a/WildcardMatch.cs b/WildcardMatch.cs

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ internal class IgnoreMatch : IParseRulePatternItemMatch`
`6`	`6`	`public int Position { get; }`
`7`	`7`
`8`	`8`	`public int TokensCount { get; } = 1;`
	`9`	`+ public double Similarity { get; set; }`
`9`	`10`
`10`	`11`	`public IgnoreMatch(int position, int tokensCount=1)`
`11`	`12`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,21 +9,17 @@ namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns`
`9`	`9`	`internal class AtomPatternItem : IParseRulePatternItem`
`10`	`10`	`{`
`11`	`11`	`public string Name { get; }`
`12`		`- public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)`
	`12`	`+ public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)`
`13`	`13`	`{`
`14`	`14`	`try`
`15`	`15`	`{`
`16`	`16`	`var resObj = parser.GetAtomBuilder(Name)(tokens[position].Value);`
`17`	`17`	`var result = new ParseResult(tokens[position], resObj);`
`18`		`- return new ParseRecord(Name, result, position, 1);`
`19`		`- }`
`20`		`- catch(ParseException e)`
`21`		`- {`
`22`		`- throw new ParseException((ParseException)e);`
	`18`	`+ return new ParseRecord(Name, result, position, 1) { Similarity = 1 };`
`23`	`19`	`}`
`24`	`20`	`catch(Exception e)`
`25`	`21`	`{`
`26`		`- throw new ParseException(tokens[position], e.Message);`
	`22`	`+ return new ParseError(e.Message, position);`
`27`	`23`	`}`
`28`	`24`	`}`
`29`	`25`
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);`
	`7`	`+ IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack=0);`
`8`	`8`	`}`
`9`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,5 +4,6 @@ internal interface IParseRulePatternItemMatch`
`4`	`4`	`{`
`5`	`5`	`int Position { get; }`
`6`	`6`	`int TokensCount { get; }`
	`7`	`+ double Similarity { get; set; }`
`7`	`8`	`}`
`8`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,11 +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)`
	`12`	`+ public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)`
`13`	`13`	`{`
`14`	`14`	`if (tokens[position].Value != Name)`
`15`		`- throw new ParseException(tokens[position], $"Expected '{Name}', got '{tokens[position].Value}'");`
`16`		`- return new IgnoreMatch(position);`
	`15`	`+ {`
	`16`	`+ return new ParseError($"Expected '{Name}', got '{tokens[position].Value}'", position);`
	`17`	`+ }`
	`18`	`+ return new IgnoreMatch(position) { Similarity = 1 };`
`17`	`19`	`}`
`18`	`20`
`19`	`21`	`public LiteralPatternItem(string name)`
Original file line number	Diff line number	Diff line change
`@@ -4,9 +4,9 @@ namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns`
`4`	`4`	`{`
`5`	`5`	`internal class RepeatableTailItem : IParseRulePatternItem`
`6`	`6`	`{`
`7`		`- public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)`
	`7`	`+ public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)`
`8`	`8`	`{`
`9`		`- return new IgnoreMatch(position, 0);`
	`9`	`+ return new IgnoreMatch(position, 0) { Similarity = 1 };`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`public override string ToString() => "??";`
Original file line number	Diff line number	Diff line change
`@@ -1,30 +1,19 @@`
`1`		`-using System;`
`2`		`-using System.Collections.Generic;`
`3`		`-using System.Linq;`
`4`		`-using System.Text;`
`5`		`-using System.Threading.Tasks;`
	`1`	`+using System.Collections.Generic;`
`6`	`2`
`7`	`3`	`namespace EsotericDevZone.RuleBasedParser.ParseRulePatterns`
`8`	`4`	`{`
`9`	`5`	`internal class RuleKeyPatternItem : IParseRulePatternItem`
`10`	`6`	`{`
`11`	`7`	`public string RuleKey { get; }`
`12`	`8`
`13`		`- public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position)`
	`9`	`+ public IParseRulePatternItemMatch Match(Parser parser, List<Token> tokens, int position, int stack = 0)`
`14`	`10`	`{`
`15`		`- try`
	`11`	`+ var rec = parser.LookFor(RuleKey, tokens, position, stack + 1);`
	`12`	`+ if (rec.Error != null)`
`16`	`13`	`{`
`17`		`- var rec = parser.LookFor(RuleKey, tokens, position);`
`18`		`- return rec;`
`19`		`- }`
`20`		`- catch(ParseException e)`
`21`		`- {`
`22`		`- throw new ParseException((ParseException)e);`
`23`		`- }`
`24`		`- catch (Exception e)`
`25`		`- {`
`26`		`- throw new ParseException(tokens[position], e.Message);`
	`14`	`+ return new ParseError(rec.Error, rec.Error.Similarity);`
`27`	`15`	`}`
	`16`	`+ return rec;`
`28`	`17`	`}`
`29`	`18`
`30`	`19`	`public RuleKeyPatternItem(string ruleKey)`