[DO NOT MERGE YET] Added generic parser extensions

.gitignore

@@ -9,5 +9,5 @@ TestResults
 *.dotCover
 *.nupkg
 build
-
-.vs
+util/
+.vs/

Demo/Debug/CoreCompileInputs.cache

@@ -0,0 +1 @@
+14c86c5107a4d04c0343e28e8f15d438958d165b

Demo/Demo.cs

@@ -1,19 +1,132 @@
-using System;
-using Piglet.Demo.Lexer;
-using Piglet.Demo.Parser;
-
-namespace Piglet.Demo
-{
-    public class Demo
-    {
-        public static void Main(string[] args)
-        {
-            // Simple demo runner
-            WordsAndNumbers.Run();
-            Movement.Run();
-            JsonParser.Run();
-            BlogFormatParser.RunFluent();
-            //Console.ReadKey();
-        }
-    }
-}
+using System;
+using Piglet.Parser.Configuration.Generic;
+using Piglet.Parser.Configuration;
+using Piglet.Parser.Construction;
+using Piglet.Demo.Parser;
+using Piglet.Demo.Lexer;
+using System.Linq;
+using Piglet.Parser;
+
+namespace Piglet.Demo
+{
+    using f = Func<int, int>;
+
+    public class Demo
+    {
+        public static void Main(string[] args)
+        {
+            static int Exp(int a, int x) => Enumerable.Range(0, x).Aggregate(1, (acc, i) => acc * a);
+            var configurator = ParserFactory.Configure<int>();
+
+            INonTerminal<int> expr = configurator.CreateNonTerminal();
+            INonTerminal<int> term = configurator.CreateNonTerminal();
+            INonTerminal<int> factor = configurator.CreateNonTerminal();
+            INonTerminal<int> expexpr = configurator.CreateNonTerminal();
+            ITerminal<int> number = configurator.CreateTerminal("\\d+", t => int.Parse(t, System.Globalization.CultureInfo.InvariantCulture));
+            ITerminal<int> add = configurator.CreateTerminal("\\+");
+            ITerminal<int> sub = configurator.CreateTerminal("-");
+            ITerminal<int> mul = configurator.CreateTerminal("\\*");
+            ITerminal<int> div = configurator.CreateTerminal("/");
+            ITerminal<int> pow = configurator.CreateTerminal("[\\^]");
+
+            expr.AddProduction(expr, add, term).SetReduceFunction(s => s[0] + s[2]);
+            expr.AddProduction(expr, sub, term).SetReduceFunction(s => s[0] - s[2]);
+            expr.AddProduction(term).SetReduceFunction(s => s[0]);
+
+            term.AddProduction(term, mul, expexpr).SetReduceFunction(s => s[0] * s[2]);
+            term.AddProduction(term, div, expexpr).SetReduceFunction(s => s[0] / s[2]);
+            term.AddProduction(expexpr).SetReduceFunction(s => s[0]);
+
+            expexpr.AddProduction(expexpr, pow, factor).SetReduceFunction(s => Exp(s[0], s[2]));
+            expexpr.AddProduction(factor).SetReduceFunction(s => s[0]);
+
+            factor.AddProduction(number).SetReduceFunction(s => s[0]);
+            factor.AddProduction("(", expr, ")").SetReduceFunction(s => s[1]);
+
+            var parser = configurator.CreateParser();
+            var value = parser.Parse("3^4 + 1");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+            var s = @"x + -5 - 3 * -x * x";
+            var par = new test_lexer().CreateParser();
+            var f = par.Parse(s);
+
+            Console.WriteLine(s);
+            Console.WriteLine(f);
+
+            return;
+
+            // Simple demo runner
+            WordsAndNumbers.Run();
+            Movement.Run();
+            JsonParser.Run();
+            BlogFormatParser.RunFluent();
+            //Console.ReadKey();
+        }
+
+
+        private class test_lexer
+            : ParserConstructor<(string, f)>
+        {
+            /**/
+            protected override void Construct(NonTerminalWrapper<(string, f)> nt_func)
+            {
+                var nt_expr = CreateNonTerminal<(string s, f f)>();
+                var nt_unop = CreateNonTerminal<Func<(string s, f f), (string s, f f)>>();
+                var nt_binop = CreateNonTerminal<Func<(string s, f f), (string s, f f), (string s, f f)>>();
+
+                var t_lit = CreateTerminal(@"\d+", x => (i: int.Parse(x), x));
+                var t_var = CreateTerminal(@"x", x => x);
+                var t_add = CreateTerminal(@"\+", x => x);
+                var t_mul = CreateTerminal(@"\*", x => x);
+                var t_sub = CreateTerminal(@"-", x => x);
+                var t_div = CreateTerminal(@"/", x => x);
+                var t_mod = CreateTerminal(@"%", x => x);
+                var t_oparen = CreateTerminal(@"\(");
+                var t_cparen = CreateTerminal(@"\)");
+
+                SetPrecedenceList(
+                    (AssociativityDirection.Left, new[] { t_add, t_sub }),
+                    (AssociativityDirection.Left, new[] { t_mul, t_div, t_mod })
+                 // (AssociativityDirection.Right, new[] { t_pow })
+                );
+
+                var prec_b = SetAssociativity(AssociativityDirection.Left);
+                var prec_u = SetAssociativity(AssociativityDirection.Right);
+
+                CreateProduction(nt_func, nt_expr);
+                CreateProduction(nt_unop, t_add, _ => f1 => ($"(+{f1.s})", f1.f));
+                CreateProduction(nt_unop, t_sub, _ => f1 => ($"(-{f1.s})", x => f1.f(x)));
+                CreateProduction(nt_binop, t_mod, _ => (f1, f2) => ($"({f1.s} % {f2.s})", x => f1.f(x) % f2.f(x)));
+                CreateProduction(nt_binop, t_div, _ => (f1, f2) => ($"({f1.s} / {f2.s})", x => f1.f(x) / f2.f(x)));
+                CreateProduction(nt_binop, t_mul, _ => (f1, f2) => ($"({f1.s} * {f2.s})", x => f1.f(x) * f2.f(x)));
+                CreateProduction(nt_binop, t_sub, _ => (f1, f2) => ($"({f1.s} - {f2.s})", x => f1.f(x) - f2.f(x)));
+                CreateProduction(nt_binop, t_add, _ => (f1, f2) => ($"({f1.s} + {f2.s})", x => f1.f(x) + f2.f(x)));
+                CreateProduction(nt_expr, t_var, l => ("X", x => x));
+                CreateProduction(nt_expr, t_lit, l => (l.x, _ => l.i));
+                CreateProduction(nt_expr, t_oparen, nt_expr, t_cparen, (x, y, z) => ($"({y.s})", u => y.f(u)));
+                CreateProduction(nt_expr, nt_unop, nt_expr, (x, y) => x(y)).SetPrecedence(prec_u);
+                CreateProduction(nt_expr, nt_expr, nt_binop, nt_expr, (x, y, z) => y(x, z)).SetPrecedence(prec_b);
+
+                Configurator.LexerSettings.Ignore = new[]
+                {
+                    @"\s+",
+                    @"/\*[^(\*/)]*\*/",
+                    @"//[^\n]*\n"
+                };
+            }
+        }
+    }
+}

Demo/Lexer/Movement.cs

@@ -1,5 +1,6 @@
 using System;
 using Piglet.Lexer;
+using Piglet.Lexer.Runtime;
 
 namespace Piglet.Demo.Lexer
 {
@@ -37,9 +38,9 @@ public static void Run()
                 configurator.Ignore(@"\s+");
             });
 
-            foreach (var token in lexer.Tokenize("up down left right right north west left north up"))
+            foreach ((int number, LexedToken<string> token) in lexer.Tokenize("up down left right right north west left north up"))
             {
-                Console.WriteLine("{0} Current position is {1},{2}", token.Item2, positionX, positionY);
+                Console.WriteLine("{0} Current position is {1},{2}", token.SymbolValue, positionX, positionY);
             }
 
             Console.WriteLine(System.DateTime.Now.Ticks - ticks);

Demo/Lexer/WordsAndNumbers.cs

@@ -1,5 +1,6 @@
 using System;
 using Piglet.Lexer;
+using Piglet.Lexer.Runtime;
 
 namespace Piglet.Demo.Lexer
 {
@@ -22,17 +23,9 @@ public static void Run()
 
             // Run the lexer
             string input = "10 piglets 5 boars 1 big sow";
-            foreach (var token in lexer.Tokenize(input))
-            {
-                if (token.Item2 is int)
-                {
-                    Console.WriteLine("Lexer found an integer {0}", token.Item2);
-                }
-                else
-                {
-                    Console.WriteLine("Lexer found a string {0}", token.Item2);
-                }
-            }
+
+            foreach ((int number, LexedToken<object> token) in lexer.Tokenize(input))
+                Console.WriteLine($"Lexer found {(token.SymbolValue is int ? "an integer" : "a string")} {token.SymbolValue}");
         }
     }
 }

Demo/Piglet.Demo.csproj

@@ -1,67 +1,16 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>8.0.30703</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{B23B66AD-EA0F-4254-BDE6-C4EF883BD5B0}</ProjectGuid>
-    <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Piglet.Demo</RootNamespace>
-    <AssemblyName>Piglet.Demo</AssemblyName>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup>
-    <StartupObject>Piglet.Demo.Demo</StartupObject>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Demo.cs" />
-    <Compile Include="Lexer\Movement.cs" />
-    <Compile Include="Lexer\WordsAndNumbers.cs" />
-    <Compile Include="Parser\BlogFormatParser.cs" />
-    <Compile Include="Parser\JsonParser.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\Piglet\Piglet.csproj">
-      <Project>{1E23F251-94E1-4504-81E8-2618F5C9FEA3}</Project>
-      <Name>Piglet</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>netcoreapp3.1</TargetFramework>
+        <ProductVersion>8.0.30703</ProductVersion>
+        <SchemaVersion>2.0</SchemaVersion>
+        <OutputType>Exe</OutputType>
+        <RootNamespace>Piglet.Demo</RootNamespace>
+        <AssemblyName>Piglet.Demo</AssemblyName>
+        <OutputPath>bin\Debug\</OutputPath>
+        <Prefer32Bit>false</Prefer32Bit>
+    </PropertyGroup>
+    <ItemGroup>
+        <ProjectReference Include="..\Piglet\Piglet.csproj"/>
+    </ItemGroup>
 </Project>

Demo/app.config

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7"/></startup></configuration>