fix #596

Author: b3b00

src/samples/ParserExample/GettingStarted.cs

@@ -0,0 +1,44 @@
+using sly.lexer;
+using sly.parser.generator;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ParserExample
+{
+    internal enum GettingStartedLexer
+    {
+        [Lexeme("[0-9]+")]
+        INT = 1,
+
+        [Lexeme("\\+")]
+        PLUS = 2,
+
+        [Lexeme("[ \\t]+", isSkippable: true)] // the lexeme is marked isSkippable : it will not be sent to the parser and simply discarded.
+        WS = 3
+    }
+
+    internal class GettingStartedParser
+    {
+
+        [Production("expression: INT")]
+        public int intExpr(Token<GettingStartedLexer> intToken)
+        {
+            return intToken.IntValue;
+        }
+
+        [Production("expression: term PLUS expression")]
+        public int Expression(int left, Token<GettingStartedLexer> operatorToken, int right)
+        {
+            return left + right;
+        }
+
+        [Production("term: INT")]
+        public int Expression(Token<GettingStartedLexer> intToken)
+        {
+            return intToken.IntValue;
+        }
+    }
+}

src/samples/ParserExample/Program.cs

@@ -1357,7 +1357,8 @@ print a
         }
         private static void Main(string[] args)
         {
-            testIssue516();
+            TestIssue596GettingStartedParser();
+            //testIssue516();
             //TestIssue507();
             //TestFStrings();
             //TestIssue495();
@@ -1848,6 +1849,21 @@ private static void TestFStrings()
               IndentedWhileTests tests = new IndentedWhileTests();
               tests.TestFString();
           }
+
+
+        private static void TestIssue596GettingStartedParser() {             
+            var parserInstance = new GettingStartedParser();
+            var builder = new ParserBuilder<GettingStartedLexer, int>();
+            var buildResult = builder.BuildParser(parserInstance, ParserType.LL_RECURSIVE_DESCENT, "expression");
+            Assert.True(buildResult.IsOk);
+            var parser = buildResult.Result;
+            var result = parser.Parse("1+2+3");
+            Assert.True(result.IsOk);
+            Assert.Equal(6, result.Result);
+
+            result = parser.Parse("");
+            Assert.True(result.IsError);
+        }
     }
 
     public enum TestGrammarToken

src/sly/parser/parser/ParseError.cs

@@ -47,12 +47,15 @@ protected string GetContextualMessage(string fullSource, int line, int column, s
         {
             StringBuilder sb = new StringBuilder();
             sb.AppendLine(ErrorMessage);
-            var theLine = fullSource.GetLines()[line];
-            var tab = " ".Multiply(line.ToString().Length);
-            sb.Append(tab).AppendLine(" |");
-            sb.Append(line).Append(" |").AppendLine(theLine);
-            sb.Append($"{tab} |").Append(" ".Multiply(column)).Append("^^^").AppendLine($" {message}");
-            
+            var allLines = fullSource.GetLines();
+            if (line < allLines.Count)
+            {
+                var theLine = fullSource.GetLines()[line];
+                var tab = " ".Multiply(line.ToString().Length);
+                sb.Append(tab).AppendLine(" |");
+                sb.Append(line).Append(" |").AppendLine(theLine);
+                sb.Append($"{tab} |").Append(" ".Multiply(column)).Append("^^^").AppendLine($" {message}");
+            }
             return sb.ToString();
         }
     }

tests/ParserTests/Issue596/Issue596Parser.cs

@@ -0,0 +1,40 @@
+using sly;
+using sly.lexer;
+using sly.parser.generator;
+
+namespace ParserTests.Issue596
+{
+    internal enum GettingStartedLexer
+    {
+        [Lexeme("[0-9]+")]
+        INT = 1,
+
+        [Lexeme("\\+")]
+        PLUS = 2,
+
+        [Lexeme("[ \\t]+", isSkippable: true)] // the lexeme is marked isSkippable : it will not be sent to the parser and simply discarded.
+        WS = 3
+    }
+
+    internal class GettingStartedParser
+    {
+
+        [Production("expression: INT")]
+        public int intExpr(Token<GettingStartedLexer> intToken)
+        {
+            return intToken.IntValue;
+        }
+
+        [Production("expression: term PLUS expression")]
+        public int Expression(int left, Token<GettingStartedLexer> operatorToken, int right)
+        {
+            return left + right;
+        }
+
+        [Production("term: INT")]
+        public int Expression(Token<GettingStartedLexer> intToken)
+        {
+            return intToken.IntValue;
+        }
+    }
+}

tests/ParserTests/Issue596/TestIssue596.cs

@@ -0,0 +1,39 @@
+using NFluent;
+using sly.parser;
+using sly.parser.generator;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace ParserTests.Issue596
+{
+    public class TestIssue596
+    {
+        [Fact]
+        public void Issue596Test()
+        {
+            var parserInstance = new GettingStartedParser();
+            var builder = new ParserBuilder<GettingStartedLexer, int>();
+            var buildResult = builder.BuildParser(parserInstance, ParserType.LL_RECURSIVE_DESCENT, "expression");
+            Check.That(buildResult).IsOk();
+            Assert.True(buildResult.IsOk);
+            var parser = buildResult.Result;
+            
+            var result = parser.Parse("1+2+3");
+            Check.That(result).IsOkParsing();
+            Check.That(result.Result).IsEqualTo(6);
+            
+
+            result = parser.Parse("");
+            Check.That(result).Not.IsOkParsing();
+            var error = result.Errors.First();
+            Check.That(error.ErrorType).IsEqualTo(ErrorType.UnexpectedEOS);
+            Check.That(error.ErrorMessage).Contains("INT");
+            
+        }
+
+    }
+}