Typedbuffer and low level parsers

src/Parlot/BufferSpan.cs

@@ -0,0 +1,138 @@
+using System;
+
+namespace Parlot
+{
+    public readonly struct BufferSpan<T> : IEquatable<T[]>, IEquatable<BufferSpan<T>>
+    where T : IEquatable<T>
+    {
+        public BufferSpan(T[] buffer, int offset, int count)
+        {
+            Buffer = buffer;
+            Offset = offset;
+            Length = count;
+        }
+
+#if SUPPORTS_READONLYSPAN
+        public BufferSpan(Span<T> buffer, int offset, int count)
+        {
+            Buffer = buffer.ToArray();
+            Offset = offset;
+            Length = count;
+        }
+#endif
+        public BufferSpan(T[] buffer)
+        : this(buffer, 0, buffer?.Length ?? 0)
+        {
+        }
+
+        public T this[int i]
+        {
+            get { return Buffer[Offset + i]; }
+        }
+
+        public BufferSpan<T> SubBuffer(int start, int length)
+        {
+            return new(Buffer, start + Offset, length);
+        }
+
+        public readonly int Length;
+        public readonly int Offset;
+        public readonly T[] Buffer;
+
+#if SUPPORTS_READONLYSPAN
+        public ReadOnlySpan<T> Span => Buffer == null ? ReadOnlySpan<T>.Empty : Buffer.AsSpan(Offset, Length);
+#endif
+
+        public override string ToString()
+        {
+            if (typeof(T) == typeof(char))
+            {
+                if (Buffer == null)
+                    return null;
+                return new string((char[])(object)Buffer, Offset, Length);
+            }
+            return base.ToString();
+        }
+
+        public bool Equals(T[] other)
+        {
+            if (other == null)
+            {
+                return Buffer == null;
+            }
+
+#if NETSTANDARD2_0
+            if (Length != other.Length)
+            {
+                return false;
+            }
+
+            for (var i = 0; i < Length; i++)
+            {
+                if (!Buffer[Offset + i].Equals(other[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+#else
+            return Span.SequenceEqual(other);
+#endif
+        }
+
+        public bool Equals(BufferSpan<T> other)
+        {
+#if NETSTANDARD2_0
+            if (Length != other.Length)
+            {
+                return false;
+            }
+
+            for (var i = 0; i < Length; i++)
+            {
+                if (!Buffer[Offset + i].Equals(other.Buffer[other.Offset + i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+#else
+            return Span.SequenceEqual(other.Span);
+#endif
+        }
+
+#if !NETSTANDARD2_0
+        public static implicit operator BufferSpan<T>(Span<T> s)
+        {
+            return new BufferSpan<T>(s, 0, s.Length);
+        }
+        public static implicit operator ReadOnlySpan<T>(BufferSpan<T> s)
+        {
+            return s.Span;
+        }
+#endif
+        public static implicit operator BufferSpan<T>(T[] s)
+        {
+            return new BufferSpan<T>(s, 0, s.Length);
+        }
+
+        public int IndexOf(T startChar, int startOffset = 0, int end = -1)
+        {
+            // #if NETSTANDARD2_0
+            if (end == -1 || end > Length)
+                end = Length;
+            for (var i = startOffset; i < end; i++)
+            {
+                if (Buffer[Offset + i].Equals(startChar))
+                    return i;
+            }
+
+            return -1;
+            // #else
+            //             return Span.IndexOf(startChar, startOffset, end);
+            // #endif
+        }
+    }
+}

src/Parlot/Character.cs

@@ -45,7 +45,7 @@ public static bool IsWhiteSpaceOrNewLine(char ch)
         public static bool IsNewLine(char ch)
             => (ch == '\n') || (ch == '\r') || (ch == '\v');
 
-        public static char ScanHexEscape(string text, int index, out int length)
+        public static char ScanHexEscape(char[] text, int index, out int length)
         {
             var lastIndex = Math.Min(4 + index, text.Length - 1);
             var code = 0;
@@ -68,75 +68,69 @@ public static char ScanHexEscape(string text, int index, out int length)
             return (char)code;
         }
 
-        public static TextSpan DecodeString(string s) => DecodeString(new TextSpan(s));
+        public static BufferSpan<char> DecodeString(string s) => DecodeString(s.ToCharArray());
 
-        public static TextSpan DecodeString(TextSpan span)
+        public static BufferSpan<char> DecodeString(BufferSpan<char> span)
         {
             // Nothing to do if the string doesn't have any escape char
-            if (span.Buffer.IndexOf('\\', span.Offset, span.Length) == -1)
+            if (span.IndexOf('\\') == -1)
             {
                 return span;
             }
 
-#if NETSTANDARD2_0
-            var result = CreateString(span.Length, span, static (chars, source) =>
-#else
-            var result = String.Create(span.Length, span, static (chars, source) =>
-#endif
-            {
-                // The asumption is that the new string will be shorter since escapes results are smaller than their source
+            var result = new char[span.Length];
+            // The asumption is that the new string will be shorter since escapes results are smaller than their source
+
+            var dataIndex = 0;
+            var buffer = span.Buffer;
+            var start = span.Offset;
+            var end = span.Offset + span.Length;
 
-                var dataIndex = 0;
-                var buffer = source.Buffer;
-                var start = source.Offset;
-                var end = source.Offset + source.Length;
+            for (var i = start; i < end; i++)
+            {
+                var c = buffer[i];
 
-                for (var i = start; i < end; i++)
+                if (c == '\\')
                 {
-                    var c = buffer[i];
+                    i++;
+                    c = buffer[i];
 
-                    if (c == '\\')
+                    switch (c)
                     {
-                        i++;
-                        c = buffer[i];
-
-                        switch (c)
-                        {
-                            case '\'': c = '\''; break;
-                            case '"': c = '\"'; break;
-                            case '\\': c = '\\'; break;
-                            case 'b': c = '\b'; break;
-                            case 'f': c = '\f'; break;
-                            case 'n': c = '\n'; break;
-                            case 'r': c = '\r'; break;
-                            case 't': c = '\t'; break;
-                            case 'v': c = '\v'; break;
-                            case 'u':
-                                c = Character.ScanHexEscape(buffer, i, out var length);
-                                i += length;
-                                break;
-                            case 'x':
-                                c = Character.ScanHexEscape(buffer, i, out length);
-                                i += length;
-                                break;
-                        }
+                        case '\'': c = '\''; break;
+                        case '"': c = '\"'; break;
+                        case '\\': c = '\\'; break;
+                        case 'b': c = '\b'; break;
+                        case 'f': c = '\f'; break;
+                        case 'n': c = '\n'; break;
+                        case 'r': c = '\r'; break;
+                        case 't': c = '\t'; break;
+                        case 'v': c = '\v'; break;
+                        case 'u':
+                            c = Character.ScanHexEscape(buffer, i, out var length);
+                            i += length;
+                            break;
+                        case 'x':
+                            c = Character.ScanHexEscape(buffer, i, out length);
+                            i += length;
+                            break;
                     }
-
-                    chars[dataIndex++] = c;
                 }
 
-                chars[dataIndex++] = '\0';
-            });
+                result[dataIndex++] = c;
+            }
+
+            result[dataIndex++] = '\0';
 
             for (var i = result.Length - 1; i >= 0; i--)
             {
                 if (result[i] != '\0')
                 {
-                    return new TextSpan(result, 0, i + 1);
+                    return new BufferSpan<char>(result, 0, i + 1);
                 }
             }
 
-            return new TextSpan(result);
+            return result;
         }
 
         private static int HexValue(char ch)

src/Parlot/Compilation/CompilationContext.cs

@@ -1,13 +1,16 @@
 using Parlot.Fluent;
+using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
 
 namespace Parlot.Compilation
 {
+
     /// <summary>
     /// Reprensents the context of a compilation phase, coordinating all the parsers involved.
     /// </summary>
-    public class CompilationContext
+    public class CompilationContext<TParseContext>
+    where TParseContext : ParseContext
     {
         private int _number = 0;
 
@@ -18,7 +21,7 @@ public CompilationContext()
         /// <summary>
         /// Gets the expression containing the the <see cref="ParseContext"/> instance for the parser.
         /// </summary>
-        public ParameterExpression ParseContext { get; } = Expression.Parameter(typeof(ParseContext));
+        public ParameterExpression ParseContext { get; } = Expression.Parameter(typeof(TParseContext));
 
         /// <summary>
         /// Gets or sets a counter used to generate unique variable names.
@@ -34,7 +37,7 @@ public CompilationContext()
         /// Gets the list of global expressions to add the the final list of statements.
         /// </summary>
         public List<Expression> GlobalExpressions { get; } = new();
-        
+
         /// <summary>
         /// Gets the list of shared lambda expressions representing intermediate parsers.
         /// </summary>
@@ -51,5 +54,20 @@ public CompilationContext()
         /// This is done to optimize compiled parser that are usually used for pattern matching only.
         /// </remarks>
         public bool DiscardResult { get; set; } = false;
+
+
+        public ParameterExpression DeclareValueVariable<T>(CompilationResult result)
+        {
+            return this.DeclareValueVariable<T, TParseContext>(result);
+        }
+    }
+
+    /// <summary>
+    /// Reprensents the context of a compilation phase, coordinating all the parsers involved.
+    /// </summary>
+    public class CompilationContext<TParseContext, TChar> : CompilationContext<TParseContext>
+    where TParseContext : ParseContextWithScanner<TChar>
+    where TChar : IEquatable<TChar>, IConvertible
+    {
     }
 }

src/Parlot/Compilation/CompiledParser.cs

@@ -16,18 +16,20 @@ public interface ICompiledParser
     /// in order to expose is as as standard parser contract.
     /// </summary>
     /// <remarks>
-    /// This class is used in <see cref="Parser{T}.Compile"/>.
+    /// This class is used in <see cref="Parsers.Compile{T, TParseContext,TChar}"/>.
     /// </remarks>
-    public class CompiledParser<T> : Parser<T>, ICompiledParser
+    public class CompiledParser<T, TParseContext, TChar> : Parser<T, TParseContext, TChar>, ICompiledParser
+    where TParseContext : ParseContextWithScanner<TChar>
+    where TChar : IEquatable<TChar>, IConvertible
     {
-        private readonly Func<ParseContext, ValueTuple<bool, T>> _parse;
+        private readonly Func<TParseContext, ValueTuple<bool, T>> _parse;
 
-        public CompiledParser(Func<ParseContext, ValueTuple<bool, T>> parse)
+        public CompiledParser(Func<TParseContext, ValueTuple<bool, T>> parse)
         {
             _parse = parse ?? throw new ArgumentNullException(nameof(parse));
         }
 
-        public override bool Parse(ParseContext context, ref ParseResult<T> result)
+        public override bool Parse(TParseContext context, ref ParseResult<T> result)
         {
             var start = context.Scanner.Cursor.Offset;
             var parsed = _parse(context);