Beispiel #1
0
        private void Matches(RegexGrammar g, string regex, string s)
        {
            var converter = new RegexConverter();
            var c         = converter.Convert(g.ParseExpression(regex));

            var runner = PatternCompiler.Default.Compile(new Pattern()
            {
                Data = c
            });
            var result = runner.Run(s);

            Assert.IsTrue(result.IsSuccessful && result.InputPosition >= s.Length, $"PEG from regex {regex} must match {s}. Matched {result.InputPosition} characters. Success: {result.IsSuccessful}");
        }
Beispiel #2
0
        private static int GetNumCaptures(string regex, string strData)
        {
            var data = strData.ToCharArray();
            var g    = new RegexGrammar(PatternCompiler.Default);

            var converter = new RegexConverter();
            var c         = converter.Convert(g.ParseExpression(regex));

            var matchPattern = new ZeroOrMore(new PrioritizedChoice(new CaptureGroup(0, c), new Any()));

            var p = new Pattern(null)
            {
                Data = matchPattern
            };

            var runner   = PatternCompiler.Default.Compile(p);
            var captures = new List <Capture>();
            var result   = runner.Run(data, 0, data.Length, captures);

            return(result.IsSuccessful ? captures.Count : -1);
        }
Beispiel #3
0
        static void Main(string[] args)
        {
            //{
            //    var jitter = new CustomJitter("Regex.dll");
            //    var rg = new RegexGrammar(new PatternCompiler(new Compiler(), new DefaultOptimizer(), jitter));
            //    jitter.Save();

            //    rg.ParseExpression("abc");
            //}

            var patternCompiler = new PatternCompiler(new Compiler(), null, new ILJitter());
            var regexGrammar    = new Lazy <RegexGrammar>(() => new RegexGrammar(patternCompiler));
            var converter       = new RegexConverter();
            var helper          = new PegHelper(patternCompiler);

            helper.EnsureExpressionBuilt();
            //CompileAndWritePatternToFile("PegExpression", helper.GetExpressionPattern());

            //var input = "AAA AAAas ntAar ".ToCharArray();
            var input = GenerateInputData(1 << 20);

            //var pattern = new PointerImplementation();
            //var patternStr = "([A-Za-z] 'awyer' [ \t] / [A-Za-z] 'inn' [ \t])";
            //var patternStr = "([A-Za-z] 'x')";
            //var patternStr = "([A-Za-z] 'awyer' [ \t] / [A-Za-z] 'inn' [ \t])";
            //var patternStr = "'Tom' / 'Finn' / 'Sawyer' / 'Huckleberry'";
            //var patternStr = "'Tom' / 'Sawyer' / 'Huckleberry' / 'Finn' ";
            //var patternStr = "[ -z][ -z]([ -z][ -z]('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn') / [ -z]('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn') / ('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn'))";
            //var patternStr = "[ -z][ -z]([ -z][ -z]('T' / 'S') / [ -z]('T' / 'Sawye' / 'Huck') / 'Huckleberry')";
            //var patternStr = "[ -z][ -z]([ -z][ -z]('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn') / [ -z]('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn') / ('Tom' / 'Sawyer' / 'Huckleberry' / 'Finn'))";
            //var patternStr = "[ -z][ -z]([ -z][ -z]('T' / 'S' / 'H') / [ -z]('T' / 'S' / 'H') / ('T' / 'S'))";
            //var patternStr = $"[ -{char.MaxValue}][ -z]([ -z][ -z]('T' / 'S') / [ -z]('T'))";
            //var patternStr = ".. ('T' / 'SS' / 'HHH' / 'FFFF')";
            //var patternStr = "('T' / 'SS' / 'HHH' / 'FFFF')";
            //var patternStr = ".. ('TT' / 'FFF')";
            //var patternStr = "'Twain'";
            //var patternStr = "[a-z] 'shing'";
            //var patternStr = "[a-z]+";
            //var patternStr = "('Huck'[a-zA-Z]+) / ('Saw'[a-zA-Z]+)";
            //var m = $"[{char.MinValue}-uz-{char.MaxValue}]";
            //var patternStr = $"[a-q]{m}{m}{m}{m}{m}{m}{m}{m}{m}{m}{m}{m}{m} 'x'";
            //var pattern = CompileAndWritePatternToFile("SimpleMatch", new Pattern("SimpleMatch") { Data = helper.ParseExpression("[a-z]*") });

            //var p = converter.Convert(regexGrammar.Value.ParseExpression("Twain"));
            //var p = converter.Convert(regexGrammar.Value.ParseExpression("river.{20,50}Tom|Tom.{20,50}river"));
            //var p = converter.Convert(regexGrammar.Value.ParseExpression("river.{10,25}Tom|Tom.{10,25}river"));
            //var a = new Pattern("A");
            //a.Data = new PrioritizedChoice(new Sequence(letters, a), new Empty());
            //var p = new Sequence(letters, a);
            //var p = new Sequence(new PrioritizedChoice('T', 'R'), "om");//Operator.EndingWithGreedy(capitalsAndNonCapitals, CharacterClass.String("ing"));
            //var ws = new Pattern { Data = new ZeroOrMore(new CharacterClass(' ')) };
            //var p1 = new Pattern { Data = new Sequence(ws, CharacterClass.String("abc")) };
            //var p2 = new Pattern { Data = new Sequence(ws, CharacterClass.String("xyz")) };
            //var p = new PrioritizedChoice(p1, p2);
            var p = new ZeroOrMore(new PrioritizedChoice(new CaptureGroup(0, converter.Convert(regexGrammar.Value.ParseExpression("([A-Za-z]awyer|[A-Za-z]inn)\\s"))), new Any()));

            var s2 = new Stopwatch();

            s2.Start();

            var peg = new Pattern("SimpleMatch")
            {
                Data = p,
                //Data = new ZeroOrMore(new PrioritizedChoice(new CaptureGroup(0, p), new Any()))
            };
            var pattern = CompileAndWritePatternToFile("SimpleMatch", peg);

            Console.WriteLine($"Saved ({s2.ElapsedMilliseconds}ms)");

            var text      = "Tom..Huckleberry  Finn         Tom  Tom  Huck\nFinn,";
            var capts     = new List <Capture>();
            var runResult = pattern.Run(text, capts);

            if (runResult.IsSuccessful && runResult.InputPosition == text.Length)
            {
                Console.WriteLine($"Successful match on '{text}'");
            }

            //for (var n = 0; n < 10; n++)
            //{
            //    for (var x = 0; x < 25; x++)
            //    {
            //        //var pegGrammar = new PegGrammar(new ILInterpreterFactory());
            //        //pegGrammar.EnsureExpressionBuilt();

            //        //var expression = pegGrammar.ParseExpression("'th' [a-z]+");
            //        //var compiler = (new ILCompilerFactory()).Create(new Pattern
            //        //{
            //        //    Data = new ZeroOrMore(new PrioritizedChoice(new CaptureGroup(0, expression), new Any()))
            //        //});

            //        Stopwatch s = new Stopwatch();
            //        s.Start();
            //        var result = default(RunResult);
            //        var captures = new List<Capture>();

            //        for (var i = 0; i < 1000; i++)
            //        {
            //            captures = new List<Capture>();
            //            result = pattern.Run(input, 0, input.Length, captures);
            //            if (!result.IsSuccessful)
            //            {
            //                Console.WriteLine("Match fail");
            //            }
            //        }
            //        s.Stop();
            //        Console.WriteLine($"That took {s.ElapsedMilliseconds}ms ({captures.Count})");
            //    }
            //}

            Console.ReadKey();
        }