Merge branch 'dev' of github.com:b3b00/csly into dev

* 'dev' of github.com:b3b00/csly:
  entrypoint rule for expression parser
  readme.md : add documentation for expression parser generator
  compilation fix
  expression parser generator
  remov unused project
  UT for expression parser generator
  expression parser WIP
  WIP
  upgrade to net core 2.0
  gestion des regles de parser d'expression dans les parser BNF et EBNF
  passage à .net core 2.0
  pratt parsing WIP
  WIP / does not compiler
  start dev

Author: olduh29

ParserTests/ExpressionGeneratorTests.cs

@@ -0,0 +1,150 @@
+using Xunit;
+using sly.parser;
+using sly.parser.generator;
+using expressionparser;
+using simpleExpressionParser;
+using System.Collections.Generic;
+
+namespace ParserTests
+{
+    
+    public class ExpressionGeneratorTests
+    {
+
+        private Parser<ExpressionToken,int> Parser;
+
+        private string StartingRule = "";
+        public ExpressionGeneratorTests()
+        {
+            
+        }
+
+
+        private void BuildParser()
+        {
+            StartingRule = $"{typeof(SimpleExpressionParser).Name}_expressions";
+            SimpleExpressionParser parserInstance = new SimpleExpressionParser();
+            ParserBuilder<ExpressionToken, int> builder = new ParserBuilder<ExpressionToken, int>();
+            Parser = builder.BuildParser(parserInstance, ParserType.LL_RECURSIVE_DESCENT, StartingRule);            
+        }
+
+        [Fact]
+       public void TestBuild()
+        {
+            BuildParser();            
+            Assert.Equal(5, Parser.Configuration.NonTerminals.Count);
+            var nonterminals = new List<NonTerminal<ExpressionToken>>();
+            foreach(var pair in Parser.Configuration.NonTerminals)
+            {
+                nonterminals.Add(pair.Value);
+            }
+            NonTerminal<ExpressionToken> nt = nonterminals[0];
+            Assert.Equal(1, nt.Rules.Count);
+            Assert.Equal("operand", nt.Name);
+            nt = nonterminals[1];
+            Assert.Equal(3, nt.Rules.Count);
+            Assert.Contains("10", nt.Name);
+            Assert.Contains("PLUS", nt.Name);
+            Assert.Contains("MINUS", nt.Name);
+            nt = nonterminals[2];
+            Assert.Equal(3, nt.Rules.Count);
+            Assert.Contains("50", nt.Name);
+            Assert.Contains("TIMES", nt.Name);
+            Assert.Contains("DIVIDE", nt.Name);
+            nt = nonterminals[3];
+            Assert.Equal(2, nt.Rules.Count);
+            Assert.Contains("100", nt.Name);
+            Assert.Contains("MINUS", nt.Name);
+            nt = nonterminals[4];
+            Assert.Equal(1, nt.Rules.Count);
+            Assert.Equal(StartingRule, nt.Name);
+            Assert.Equal(1, nt.Rules[0].Clauses.Count);
+        }
+
+
+        [Fact]
+        public void TestSingleValue()
+        {
+            BuildParser();
+            ParseResult<ExpressionToken, int> r = Parser.Parse("1",StartingRule);
+            Assert.False(r.IsError);
+            Assert.NotNull(r.Result);
+            Assert.Equal(1, r.Result);
+        }
+
+        [Fact]
+        public void TestSingleNegativeValue()
+        {
+            BuildParser();
+            ParseResult<ExpressionToken, int> r = Parser.Parse("-1", StartingRule);
+            Assert.False(r.IsError);
+            Assert.NotNull(r.Result);
+            Assert.Equal(-1, r.Result);
+        }
+
+        [Fact]
+        public void TestTermPlus()
+        {
+            BuildParser();
+            ParseResult<ExpressionToken, int> r = Parser.Parse("1 + 1", StartingRule);
+            Assert.False(r.IsError);
+            Assert.NotNull(r.Result);
+            Assert.IsAssignableFrom(typeof(int), r.Result);
+            Assert.Equal(2, (int)r.Result);
+        }
+
+        [Fact]
+        public void TestTermMinus()
+        {
+            BuildParser();
+            ParseResult<ExpressionToken, int> r = Parser.Parse("1 - 1", StartingRule);
+            Assert.False(r.IsError);
+            Assert.NotNull(r.Result);
+            Assert.Equal(0, r.Result);
+        }
+
+        [Fact]
+        public void TestFactorTimes()
+        {
+            BuildParser();
+            ParseResult<ExpressionToken, int> r = Parser.Parse("2*2", StartingRule);
+            Assert.False(r.IsError);
+            Assert.NotNull(r.Result);
+            Assert.IsAssignableFrom(typeof(int), r.Result);
+            Assert.Equal(4, r.Result);
+        }
+
+        [Fact]
+        public void TestFactorDivide()
+        {
+            BuildParser();
+            ParseResult<ExpressionToken, int> r = Parser.Parse("42/2", StartingRule);
+            Assert.False(r.IsError);
+            Assert.NotNull(r.Result);
+            Assert.Equal(21, r.Result);
+        }
+
+        [Fact]
+        public void TestUnaryPrecedence()
+        {
+            BuildParser();
+            ParseResult<ExpressionToken, int> r = Parser.Parse("-1 * 2", StartingRule);
+            Assert.False(r.IsError);
+            Assert.NotNull(r.Result);
+            Assert.Equal(-2, r.Result);
+        }
+
+
+        [Fact]
+        public void TestPrecedence()
+        {
+            BuildParser();
+            ParseResult<ExpressionToken, int> r = Parser.Parse("-1 + 2  * 3", StartingRule);
+            Assert.False(r.IsError);
+            Assert.NotNull(r.Result);
+            Assert.Equal(5, r.Result);
+        }
+
+
+    }
+}

ParserTests/ParserTests.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp1.0;net45</TargetFrameworks>
+    <TargetFrameworks>netcoreapp2.0;net45</TargetFrameworks>
     <Authors>b3b00</Authors>
   </PropertyGroup>
   <ItemGroup>
@@ -13,6 +13,7 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\samples\expressionParser\expressionParser.csproj" />
+    <ProjectReference Include="..\samples\SimpleExpressionParser\SimpleExpressionParser.csproj" />
     <ProjectReference Include="..\samples\while\while.csproj" />
     <ProjectReference Include="..\sly\sly.csproj" />
     <ProjectReference Include="..\samples\expressionParser\expressionParser.csproj" />

Pratt/ParseException.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace sly.pratt
+{
+
+    public class PrattParseException : Exception
+    {
+        public PrattParseException(String message) : base(message)
+        {
+        }
+    }
+
+}

Pratt/Parser.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using sly.pratt.parselets;
+using sly.lexer;
+
+
+
+namespace sly.pratt
+{
+
+
+    public static class DictionaryExtensions
+    {
+
+        public static V Get<K, V>(this Dictionary<K, V> dict, K key)
+        {
+            if (dict.ContainsKey(key))
+            {
+                return dict[key];
+            }
+            return default(V);
+        }
+
+    }
+
+    public class Parser<IN, OUT> where IN : struct
+    {
+
+        private int Position;
+
+        private List<Token<IN>> Tokens;
+        //private List<Token<IN>> ReadTokens = new List<Token<IN>>();
+        private Dictionary<IN, PrefixParselet<IN, OUT>> PrefixParselets =
+            new Dictionary<IN, PrefixParselet<IN, OUT>>();
+        private Dictionary<IN, InfixParselet<IN, OUT>> InfixParselets =
+            new Dictionary<IN, InfixParselet<IN, OUT>>();
+
+        public Parser(List<Token<IN>> tokens, int startPosition)
+        {
+            Position = startPosition;
+            Tokens = tokens;
+        }
+
+        
+
+
+        public void infix(IN token, int precedence, BinaryExpressionBuilder<IN,OUT> builder, Associativity assoc = Associativity.Right) 
+        {
+            InfixParselet<IN, OUT> infixparse = new InfixParselet<IN, OUT>(token, precedence, assoc, builder);
+            InfixParselets[token] = infixparse;
+        }
+
+        public void prefix(IN token, int precedence, UnaryExpressionBuilder<IN, OUT> builder)
+        {
+            PrefixParselet<IN, OUT> prefixparse = new PrefixParselet<IN, OUT>(token, precedence, builder);
+            PrefixParselets[token] = prefixparse;
+        }
+
+        public void register(IN token, PrefixParselet<IN, OUT> parselet)
+        {
+            PrefixParselets[token] = parselet;
+        }
+
+        public void register(IN token, InfixParselet<IN, OUT> parselet)
+        {
+            InfixParselets[token] = parselet;
+        }
+
+        public OUT parseExpression(int precedence)
+        {
+            Token<IN> token = lookAhead(0);
+            PrefixParselet<IN, OUT> prefix = PrefixParselets.Get(token.TokenID);
+
+            OUT left = default(OUT);
+
+            if (prefix != null)
+            {
+                left = prefix.Parse(this, token);
+            }
+            
+            //OUT left = prefix.Parse(this, token);
+
+            while (precedence < getPrecedence())
+            {
+                token = consume();
+
+                InfixParselet<IN, OUT> infix = InfixParselets.Get(token.TokenID);
+                left = infix.Parse(this, left, token);
+            }
+
+            return left;
+        }
+
+        public OUT parseExpression()
+        {
+            return parseExpression(0);
+        }
+
+        public bool match(IN expected)
+        {
+            Token<IN> token = lookAhead(0);
+            if (!token.TokenID.Equals(expected))
+            {
+                return false;
+            }
+            
+            return true;
+        }
+
+        public Token<IN> consume(IN expected)
+        {
+
+            Token<IN> token = Tokens[Position];
+            if (!token.TokenID.Equals(expected))
+            {
+                throw new Exception("Expected token " + expected +
+                    " and found " + token.TokenID);
+            }
+            Position++;
+
+            return token;
+        }
+
+        public Token<IN> consume()
+        {
+            // Make sure we've read the token.
+            lookAhead(0);
+            Token<IN> t = Tokens[Position];
+            Position++;
+            return t;
+        }
+
+        private Token<IN> lookAhead(int distance)
+        {
+            // Read in as many as needed.
+            //while (distance >= ReadTokens.Count)
+            //{
+            //    ReadTokens.Add(Tokens[distance]);
+            //}
+
+            // Get the queued token.
+            return Tokens[Position+distance];
+
+        }
+
+        private int getPrecedence()
+        {
+            Token<IN> next = lookAhead(0);
+            IN toktyp = next.TokenID;
+            InfixParselet<IN,OUT> parser = InfixParselets.ContainsKey(toktyp) ? InfixParselets[toktyp] : null;
+            if (parser != null) return parser.Precedence;
+
+            return 0;
+        }
+
+
+    }
+
+}

Pratt/Pratt.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <RootNamespace>sly.pratt</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\samples\expressionParser\expressionParser.csproj" />
+    <ProjectReference Include="..\sly\sly.csproj" />
+  </ItemGroup>
+
+</Project>

Pratt/Precedence.cs

@@ -0,0 +1,20 @@
+namespace sly.pratt.bantam {
+
+    /**
+     * Defines the different precendence levels used by the infix parsers. These
+     * determine how a series of infix expressions will be grouped. For example,
+     * "a + b * c - d" will be parsed as "(a + (b * c)) - d" because "*" has higher
+     * precedence than "+" and "-". Here, bigger numbers mean higher precedence.
+     */
+    public class Precedence {
+        // Ordered in increasing precedence.
+        public static int ASSIGNMENT = 1;
+        public static int CONDITIONAL = 2;
+        public static int SUM = 3;
+        public static int PRODUCT = 4;
+        public static int EXPONENT = 5;
+        public static int PREFIX = 6;
+        public static int POSTFIX = 7;
+        public static int CALL = 8;
+    }
+}