Fix/ebnf

.github/workflows/dotnetcore.yml

@@ -13,6 +13,7 @@ on:
       - dev
 permissions:
   pull-requests: write
+  checks: write
 jobs:  
   build:
     env:
@@ -23,7 +24,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
         matrix:
-          os: [ubuntu-latest, windows-latest]
+          os: [ubuntu-latest]
     steps:
     - uses: actions/checkout@v2
     - name: Setup .NET Core
@@ -35,7 +36,7 @@ jobs:
     - name: Build with dotnet
       run: dotnet build --configuration Release
     - name: Test with dotnet
-      uses: b3b00/coverlet-action@1.3.5-alpha1
+      uses: b3b00/coverlet-action@d4de331462c1706fd9f07b4b2a565f256fd95a23
       id: 'coverlet'
       if: env.RUN_TESTS
       with:
@@ -44,17 +45,22 @@ jobs:
         threshold: 80
         outputFormat: 'lcov'
         excludes: '[program]*,[expressionParser]*,[jsonparser]*,[while]*,[indentedWhile]*,[SimpleExpressionParser]*,[GenericLexerWithCallbacks]*,[indented]*,[postProcessedLexerParser]*,[XML]*,[SimpleTemplate]*,[SlowEOS]*'
-
+    - name: Publish Test Results
+      uses: EnricoMi/publish-unit-test-result-action@3a74b2957438d0b6e2e61d67b05318aa25c9e6c6
+      if: always()
+      with:
+        files: |
+          **/*.trx
     - name: coveralls
       uses: coverallsapp/github-action@v1.1.1
-      if: matrix.os == 'windows-latest' && env.RUN_TESTS
+      if: matrix.os == 'ubuntu-latest' && env.RUN_TESTS
       with:
         fail-on-error: false
         github-token: ${{secrets.GITHUB_TOKEN }}
         path-to-lcov: ${{steps.coverlet.outputs.coverageFile}}
         #base-path: ${{github.workspace}}
     - name: publish nuget
-      if:  ${{success() && matrix.os == 'windows-latest' && env.PUBLISH_NUGET}}
+      if:  ${{success() && matrix.os == 'ubuntu-latest' && env.PUBLISH_NUGET}}
       id: publish_nuget
       uses: alirezanet/publish-nuget@v3.0.0
       with:
@@ -64,7 +70,7 @@ jobs:
           VERSION_FILE_PATH: ${{env.MAIN_CSPROJ}}
           INCLUDE_SYMBOLS: true
     - name: Create Release
-      if: ${{ success() && matrix.os == 'windows-latest' && steps.publish_nuget.outputs.VERSION != ''  && steps.publish_nuget.outputs.VERSION != null }}
+      if: ${{ success() && matrix.os == 'ubuntu-latest' && steps.publish_nuget.outputs.VERSION != ''  && steps.publish_nuget.outputs.VERSION != null }}
       id: create_release
       uses: b3b00/create-release@1.0.7
       env:
@@ -76,7 +82,7 @@ jobs:
         prerelease: false
         failsOnCreationError: false   
     - name: Upload Release nuget Asset
-      if: ${{ success() && matrix.os == 'windows-latest' && steps.create_release.outputs.upload_url != ''  && steps.create_release.outputs.upload_url != null }}
+      if: ${{ success() && matrix.os == 'ubuntu-latest' && steps.create_release.outputs.upload_url != ''  && steps.create_release.outputs.upload_url != null }}
       id: upload-release-nuget-asset 
       uses: actions/upload-release-asset@v1
       env:
@@ -87,7 +93,7 @@ jobs:
         asset_name: ${{ steps.publish_nuget.outputs.PACKAGE_NAME }}
         asset_content_type: application/zip
     - name: Upload Release symbols nuget Asset
-      if: ${{ success() && matrix.os == 'windows-latest' && steps.create_release.outputs.upload_url != ''  && steps.create_release.outputs.upload_url != null }}
+      if: ${{ success() && matrix.os == 'ubuntu-latest' && steps.create_release.outputs.upload_url != ''  && steps.create_release.outputs.upload_url != null }}
       id: upload-release-nuget-symbols-asset 
       uses: actions/upload-release-asset@v1
       env:

.gitignore

@@ -49,3 +49,4 @@ BenchmarkDotNet.Artifacts
 AotTester/*
 *.dtp
 *.dtp.state
+src/samples/HandMadeExpres*

src/benchCurrent/Program.cs

@@ -1,5 +1,6 @@
 using System;
 using BenchmarkDotNet.Running;
+using sly.parser.generator;
 
 namespace benchCurrent
 {
@@ -15,7 +16,15 @@ private static void Bench() {
             // var summary3 = BenchmarkRunner.Run<WhileBench>();
 
             //var summary4 = BenchmarkRunner.Run<SimpleExpressionBench>();
-            var summary5 = BenchmarkRunner.Run<JsonStringEscapingBench>();
+
+            // StackExpressionBench bench = new StackExpressionBench();
+            // bench.parserType = ParserType.LL_RECURSIVE_DESCENT;
+            // bench.Setup();
+            // bench.BenchLargeExpression();
+
+            //var summary5 = BenchmarkRunner.Run<StackExpressionBench>();
+
+            var summary6 = BenchmarkRunner.Run<StackEbnfExpressionBench>();
 
         }
         static void Main(string[] args)

src/benchCurrent/StackEbnfExpressionBench.cs

@@ -0,0 +1,91 @@
+using System;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Columns;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Toolchains.CsProj;
+using simpleExpressionParser;
+using sly.parser.generator;
+
+
+namespace benchCurrent
+{
+
+    [MemoryDiagnoser]
+
+    [Config(typeof(Config))]
+    //[Config(typeof(ConfigWithPercentage))]
+    public class StackEbnfExpressionBench
+    {
+
+
+        private class Config : ManualConfig
+        {
+            public Config()
+            {
+                SummaryStyle = BenchmarkDotNet.Reports.SummaryStyle.Default.WithRatioStyle(RatioStyle.Trend);
+                var baseJob = Job.MediumRun.With(CsProjCoreToolchain.NetCoreApp80);
+            }
+        }
+
+        private string expression = "";
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            expression = GetExpression(1000);
+        }
+
+        //[Params(ParserType.LL_RECURSIVE_DESCENT,ParserType.LL_STACK )]
+        //public ParserType parserType { get; set; }
+
+        public string GetExpression(int max)
+        {
+            var rnd = new Random();
+            //int width = rnd.Next(100, max);
+            char[] ops = new[] { '+', '-', '*' };
+            var getOp = () => ops[rnd.Next(0, ops.Length)];
+            var expr = rnd.Next(0, 100).ToString();
+            for (int i = 0; i < max; i++)
+            {
+                var op = getOp();
+                var right = rnd.Next(0, 100);
+                expr += $"{op} {right}";
+
+            }
+Console.WriteLine(expr);
+            return expr;
+        }
+
+
+        [Benchmark(Baseline = true)]
+        public void recursive() => BenchLargeExpression(ParserType.EBNF_LL_RECURSIVE_DESCENT);
+
+        [Benchmark]
+        public void stacked() => BenchLargeExpression(ParserType.EBNF_LL_STACK);
+
+        public void BenchLargeExpression(ParserType type)
+        {
+            var instance = new SimpleExpressionParser();
+            ParserBuilder<ExpressionToken, double> builder =
+                new ParserBuilder<ExpressionToken, double>();
+            var parser = builder.BuildParser(instance, type, "root");
+            if (!parser.IsOk)
+            {
+                foreach (var error in parser.Errors)
+                {
+                    Console.WriteLine(error.Message);
+                }
+                Environment.Exit(1);
+            }
+            var r = parser.Result.Parse(expression);
+            ;
+        }
+
+
+
+
+
+    }
+
+}

src/benchCurrent/StackExpressionBench.cs

@@ -0,0 +1,93 @@
+using System;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Columns;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Toolchains.CsProj;
+using expressionparser;
+using simpleExpressionParser;
+using sly.parser;
+using sly.parser.generator;
+using ExpressionToken = simpleExpressionParser.ExpressionToken;
+
+namespace benchCurrent
+{
+
+    [MemoryDiagnoser]
+
+    [Config(typeof(Config))]
+    //[Config(typeof(ConfigWithPercentage))]
+    public class StackExpressionBench
+    {
+
+
+        private class Config : ManualConfig
+        {
+            public Config()
+            {
+                SummaryStyle = BenchmarkDotNet.Reports.SummaryStyle.Default.WithRatioStyle(RatioStyle.Trend);
+                var baseJob = Job.MediumRun.With(CsProjCoreToolchain.NetCoreApp80);
+            }
+        }
+
+        private string expression = "";
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            expression = GetExpression(1000);
+        }
+
+        //[Params(ParserType.LL_RECURSIVE_DESCENT,ParserType.LL_STACK )]
+        //public ParserType parserType { get; set; }
+
+        public string GetExpression(int max)
+        {
+            var rnd = new Random();
+            //int width = rnd.Next(100, max);
+            char[] ops = new[] { '+', '-', '*' };
+            var getOp = () => ops[rnd.Next(0, ops.Length)];
+            var expr = rnd.Next(0, 100).ToString();
+            for (int i = 0; i < max; i++)
+            {
+                var op = getOp();
+                var right = rnd.Next(0, 100);
+                expr += $"{op} {right}";
+
+            }
+Console.WriteLine(expr);
+            return expr;
+        }
+
+
+        [Benchmark(Baseline = true)]
+        public void recursive() => BenchLargeExpression(ParserType.LL_RECURSIVE_DESCENT);
+
+        [Benchmark]
+        public void stacked() => BenchLargeExpression(ParserType.LL_STACK);
+
+        public void BenchLargeExpression(ParserType type)
+        {
+            var instance = new ExpressionParser();
+            ParserBuilder<expressionparser.ExpressionToken, int> builder =
+                new ParserBuilder<expressionparser.ExpressionToken, int>();
+            var parser = builder.BuildParser(instance, type, "expression");
+            if (!parser.IsOk)
+            {
+                foreach (var error in parser.Errors)
+                {
+                    Console.WriteLine(error.Message);
+                }
+                Environment.Exit(1);
+            }
+            var r = parser.Result.Parse(expression);
+            ;
+        }
+
+
+
+
+
+    }
+
+}