CFG-RecursiveDescentParser 1.0.1

Info

C# library that allows grammars to be defined directly in the code on the basis of which the parsing process is performed. It is based on a recursive descent pattern.

Example grammars

        //Defionated symbols
        Symbol minus = new("-");
        Symbol open = new("(");
        Symbol close = new(")");
        Symbol comma = new(",");
        Symbol plus = new("+");
        Symbol mul = new("*");
        Symbol Digits = new(new Regex(@"\d+"), 50);
        Symbol Integer = new();
        Symbol PosInt = new();
        Symbol NegInt = new();
        Symbol Expr = new();
        Symbol Oper = new();
        
        Func<dynamic[], dynamic> fun = s =>
        {
            return new Number(s[0]);
        };
        Expr.AddRule(fun, Integer);
        
        fun = s =>
        {
            string op = s[0];
            Node expr1 = s[2];
            Node expr2 = s[4];
            var root = new Operator(op[0]) { Left = expr1, Right = expr2 };
            return root;
        };
        Expr.AddRule(fun, Oper, open, Expr, comma, Expr, close);

        fun = s => s[0];
        Integer.AddRule(fun, PosInt);

        fun = s => s[0];
        Integer.AddRule(fun, NegInt);

        fun = s =>
        {
            string ds = s[0].Value;
            return Convert.ToInt32(ds);
        };
        PosInt.AddRule(fun, Digits);

        fun = s =>
        {
            int x = s[1];
            return -x;
        };
        NegInt.AddRule(fun, minus, PosInt);

        Oper.AddRule(s => s[0], plus);
        Oper.AddRule(s => s[0], minus);
        Oper.AddRule(s => s[0], mul);

        Grammar g = new(Expr, minus, plus, mul, open, close, comma, 
            Digits, Integer, PosInt, NegInt, Oper);

        g.Parse("1");
        var ob = g.Result;
        Node tree = ob;
        //tree.Value() = 1
        
        g.Parse("+(1,1)");
        ob = g.Result;
        tree = ob;
        //tree.Value() = 2
        
        g.Parse("+(*(5,-(10,5)),*(-6,-4))");
        ob = g.Result;
        tree = ob;
        //tree.Value() = 49

        class Node
        {
            public Node? Left;
            public Node? Right;
        
            public Node(Node? l, Node? r)
            {
                Left = l;
                Right = r;
            }
            
            public virtual int Value()
            {
                return 0;
            }
        }
        
        class Operator : Node
        {
            private char _op;
        
            public Operator(char op) : base(null, null)
            {
                _op = op;
            }
        
            public override int Value()
            {
                switch (_op)
                {
                    case '+': return Left!.Value() + Right!.Value(); 
                    case '-': return Left!.Value() - Right!.Value(); 
                    case '*': return Left!.Value() * Right!.Value();
                    default: throw new NotImplementedException();
                }
            }
        }
        
        class Number : Node
        {
            private int _num;
        
            public Number(int num) : base(null, null)
            {
                _num = num;
            }
        
            public override int Value()
            {
                return _num;
            }
        }

Licence: MIT