with source match

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Sandbox/Constant.cs

@@ -0,0 +1,100 @@
+using System.Linq;
+
+namespace SimpleStateMachine.StructuralSearch.Sandbox
+{
+    public static class Constant
+    {
+        /// <summary>
+        /// Parenthesis char: '('
+        /// </summary>
+        public static readonly char LeftParenthesis = '(';
+        
+        /// <summary>
+        /// Parenthesis char: ')'
+        /// </summary>
+        public static readonly char RightParenthesis = ')';
+        
+        /// <summary>
+        /// Parenthesis char: '['
+        /// </summary>
+        public static readonly char LeftSquareParenthesis = '[';
+        
+        /// <summary>
+        /// Parenthesis char: ']'
+        /// </summary>
+        public static readonly char RightSquareParenthesis = ']';
+        
+        /// <summary>
+        /// Parenthesis char: '{'
+        /// </summary>
+        public static readonly char LeftCurlyParenthesis = '{';
+        
+        /// <summary>
+        /// Parenthesis char: '}'
+        /// </summary>
+        public static readonly char RightCurlyParenthesis = '}';
+        
+        /// <summary>
+        /// Char: '$'
+        /// </summary>
+        public static readonly char PlaceholderSeparator = '$';
+        
+        /// <summary>
+        /// Char: '\r'
+        /// </summary>
+        public static readonly char CarriageReturn = '\r';
+        
+        /// <summary>
+        /// Char: '\n'
+        /// </summary>
+        public static readonly char LineFeed = '\n';
+        
+        /// <summary>
+        /// Char: ' '
+        /// </summary>
+        public static readonly char Space = ' ';
+        
+        /// <summary>
+        /// Parenthesis chars: '(' and ')'
+        /// </summary>
+        public static readonly (char, char) Parenthesis = (LeftParenthesis, RightParenthesis);
+        
+        /// <summary>
+        /// Parenthesis chars: '[' and ']'
+        /// </summary>
+        public static readonly (char, char) SquareParenthesis = (LeftSquareParenthesis, RightSquareParenthesis);
+        
+        /// <summary>
+        /// Parenthesis chars: '{ and '}'
+        /// </summary>
+        public static readonly (char, char) CurlyParenthesis = (LeftCurlyParenthesis, RightCurlyParenthesis);
+        
+        /// <summary>
+        /// Parenthesis chars: '(' and ')', '{ and '}', '{ and '}'
+        /// </summary>
+        public static readonly (char, char)[] AllParenthesised = { Parenthesis, SquareParenthesis, CurlyParenthesis };
+        
+        public static char[] All()
+        {
+            var all = new char[]{
+                LeftParenthesis,
+                RightParenthesis,
+                LeftSquareParenthesis,
+                RightSquareParenthesis,
+                LeftCurlyParenthesis,
+                RightCurlyParenthesis,
+                PlaceholderSeparator,
+                CarriageReturn,
+                LineFeed,
+                Space
+            };
+
+            return all;
+        }
+        
+        public static char[] AllExclude(params char[] excluded)
+        {
+            return All().Where(x => !excluded.Contains(x)).ToArray();
+        }
+    }
+}

…hine.StructuralSearch.Sandbox/Parsers.cs …ructuralSearch.Sandbox/Custom/Parsers.cssrc/SimpleStateMachine.StructuralSearch.Sandbox/Parsers.cs renamed to src/SimpleStateMachine.StructuralSearch.Sandbox/Custom/Parsers.cs src/SimpleStateMachine.StructuralSearch.Sandbox/Parsers.cs renamed to src/SimpleStateMachine.StructuralSearch.Sandbox/Custom/Parsers.cs

@@ -52,6 +52,5 @@ public static Parser<TToken, R> Series<TToken, T, R>(IEnumerable<Parser<TToken,
 
             return new SeriesParser<TToken, T, R>(parsers, func);
         }
-
     }
 }

src/SimpleStateMachine.StructuralSearch.Sandbox/Custom/PlaceholderParser.cs

@@ -0,0 +1,21 @@
+using Pidgin;
+
+namespace SimpleStateMachine.StructuralSearch.Sandbox.Custom
+{
+    public class PlaceholderParser: Parser<char, SourceMatch>
+    {
+        private Parser<char, SourceMatch> _parser;
+        private string _name;
+        public PlaceholderParser(string name, Parser<char, SourceMatch> parser)
+        {
+            _name = name;
+            _parser = parser;
+        }
+        public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expecteds, out SourceMatch result)
+        { 
+            var isCorrect = _parser.TryParse(ref state, ref expecteds, out result);
+            
+            return isCorrect;
+        }
+    }
+}

…alSearch.Sandbox/Custom/MapManyParser.cs …ralSearch.Sandbox/Custom/SeriesParser.cssrc/SimpleStateMachine.StructuralSearch.Sandbox/Custom/MapManyParser.cs renamed to src/SimpleStateMachine.StructuralSearch.Sandbox/Custom/SeriesParser.cs src/SimpleStateMachine.StructuralSearch.Sandbox/Custom/MapManyParser.cs renamed to src/SimpleStateMachine.StructuralSearch.Sandbox/Custom/SeriesParser.cs

@@ -15,6 +15,25 @@ public SeriesParser(IEnumerable<Parser<TToken, T>> parsers, Func<IEnumerable<T>,
             this.parsers = parsers;
         }
 
+        // public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expected<TToken>> expecteds, out R result)
+        // {
+        //     var results = new List<T>();
+        //     foreach (var parser in parsers)
+        //     {
+        //         if (!parser.TryParse(ref state, ref expecteds, out var _result))
+        //         {
+        //             result = default (R);
+        //             return false;
+        //         }
+        //         Console.WriteLine($"R: {_result}");
+        //         results.Add(_result);
+        //     }
+        //     
+        //     result = _func(results);
+        //     return true;
+        // }
+        
+        
         public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expected<TToken>> expecteds, out R result)
         {
             var results = new List<T>();

src/SimpleStateMachine.StructuralSearch.Sandbox/Extensions/EnumerableStringExtensions.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SimpleStateMachine.StructuralSearch.Sandbox.Extensions
+{
+    public static class EnumerableStringExtensions
+    {
+        public static string JoinToString(this IEnumerable<string> enumerable, string separator = null)
+        {
+            return string.Join(separator, enumerable);
+        }
+    }
+}

src/SimpleStateMachine.StructuralSearch.Sandbox/Extensions/IEnumerableSourceMatchExtensions.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace SimpleStateMachine.StructuralSearch.Sandbox.Extensions
+{
+    public static class IEnumerableSourceMatchExtensions
+    {
+        public static SourceMatch Concatenate(this IEnumerable<SourceMatch> matches)
+        {
+            int start = matches.First().Start;
+            int end = matches.Last().End;
+            var value = string.Join(string.Empty, matches.Select(x => x.Value));
+            return new SourceMatch(value, start, end);
+        }
+    }
+}

src/SimpleStateMachine.StructuralSearch.Sandbox/Extensions/ParserExtensions.cs

@@ -65,6 +65,7 @@ public static Parser<TToken, T> WithDebug<TToken, T>(this Parser<TToken, T> pars
                 return u;
             }, parser, Parser<TToken>.CurrentPos, Parser<TToken>.CurrentSourcePosDelta);
         }
+        
         public static Parser<TToken, T> BetweenAsThen<TToken, T, U, V>(this Parser<TToken, T> parser,
             Parser<TToken, U> parser1,
             Parser<TToken, V> parser2, Func<U, T, V, T> func)

src/SimpleStateMachine.StructuralSearch.Sandbox/Extensions/StringParserExtensions.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using Pidgin;
+using static Pidgin.Parser<char>;
+using static Pidgin.Parser;
 
 namespace SimpleStateMachine.StructuralSearch.Sandbox.Extensions
 {
@@ -38,9 +40,16 @@ public static Parser<TToken, IEnumerable<string>> ToMany<TToken>(this Parser<TTo
         {
             return parser.Select(x => new List<string>() { x }).ToIEnumerable();
         }
-        // public static Parser<TToken, List<string>> ToMany<TToken>(this Parser<TToken, string> parser)
-        // {
-        //     return parser.Select(x => new List<string>{ x });
-        // }
+        
+        public static Parser<TToken, string> JoinToString<TToken>(this Parser<TToken, IEnumerable<string>> parser, string separator = null)
+        {
+            separator ??= string.Empty;
+            return parser.Select(x => string.Join(separator, x));
+        }
+        
+        public static Parser<TToken, SourceMatch> AsMatch<TToken>(this Parser<TToken, string> parser)
+        {
+            return parser.Then(Parser<TToken>.CurrentOffset, (s, offset) => new SourceMatch(s, offset - s.Length, offset));
+        }
     }
 }

src/SimpleStateMachine.StructuralSearch.Sandbox/ParserToParser.cs

@@ -1,4 +1,5 @@
 using Pidgin;
+using SimpleStateMachine.StructuralSearch.Sandbox.Extensions;
 
 namespace SimpleStateMachine.StructuralSearch.Sandbox
 {
@@ -14,5 +15,11 @@ public static Parser<char, Parser<char, string>> Stringc(char token)
             var _token = token.ToString();
             return Parser.String(_token).Select(x => Parser.String(_token));
         }
+        
+        public static Parser<char, Parser<char, SourceMatch>> StringcMatch(char token)
+        {
+            var _token = token.ToString();
+            return Parser.String(_token).Select(x => Parser.String(_token).AsMatch());
+        }
     }
 }

src/SimpleStateMachine.StructuralSearch.Sandbox/Placeholder.cs

@@ -0,0 +1,17 @@
+namespace SimpleStateMachine.StructuralSearch.Sandbox
+{
+    public class Placeholder
+    {
+        public static Placeholder Not => null;
+        private PlaceholdersMaster _master;
+        public Placeholder(PlaceholdersMaster master, string name, SourceMatch match)
+        {
+            _master = master;
+            Name = name;
+            Match = match;
+        }
+        
+        public string Name { get; }
+        public SourceMatch Match { get; }
+    }
+}