Ejemplo n.º 1
0
        public void EmptyGrammarTest()
        {
            var start      = new CharSymbol('S');
            var prodChar   = RegExParser.Parse("$");
            var prodSymbol = new StringProduction(start.C, prodChar);

            var grammar = new Grammar <CharSymbol>(start, new Dictionary <CharSymbol, IProduction <CharSymbol>[]> {
                { start, new [] { prodSymbol } }
            });

            var parser     = new LlParser <CharSymbol>(grammar);
            var emptyInput = new List <ParseLeaf <CharSymbol> >();

            var res = parser.Parse(emptyInput);

            Assert.IsTrue(res);

            var resAsBranch = ((OK <CharSymbol>)res).Tree as ParseBranch <CharSymbol>;

            Assert.IsNotNull(resAsBranch);
            Assert.AreEqual(resAsBranch.Children.Count(), 1);
            Assert.AreEqual(resAsBranch.Symbol, start);

            var resLeaf = resAsBranch.Children.ElementAt(0) as ParseLeaf <CharSymbol>;

            Assert.IsNotNull(resLeaf);
            Assert.AreEqual(resLeaf.Symbol, new CharSymbol('$'));
        }
Ejemplo n.º 2
0
        public void test1()
        {
            var productions = new Dictionary <CharSymbol, IProduction <CharSymbol>[]>();

            /*
             * productions[new CharSymbol('A')] = new StringProduction[]{
             *      new StringProduction('A', "BC"),
             *      new StringProduction('A', "BD")
             * }; */
            productions[new CharSymbol('E')] = new StringProduction[] {
                new StringProduction('E', "A")
            };
            grammar = new Grammar <CharSymbol>(new CharSymbol('E'), productions);
            // TODO: this test fails, because grammar construction fails.
        }
Ejemplo n.º 3
0
        public void LookaheadDfaVerySimpleTest()
        {
            var productions = new Dictionary <CharSymbol, IProduction <CharSymbol>[]>();

            productions[new CharSymbol('E')] = new StringProduction[] {
                new StringProduction('E', "a")
            };             // production: E -> a
            DfaState <CharSymbol> s1     = new DfaState <CharSymbol>("1");
            DfaState <CharSymbol> s2     = new DfaState <CharSymbol>("2");
            DfaState <CharSymbol> sError = new DfaState <CharSymbol>("X");
            var t1 = new List <KeyValuePair <CharSymbol, DfaState <CharSymbol> > > {
                new KeyValuePair <CharSymbol, DfaState <CharSymbol> >(CharSymbol.MinValue, sError),
                new KeyValuePair <CharSymbol, DfaState <CharSymbol> >(new CharSymbol('a'), s2),
                new KeyValuePair <CharSymbol, DfaState <CharSymbol> >(new CharSymbol('b'), sError)
            };
            var t2 = new List <KeyValuePair <CharSymbol, DfaState <CharSymbol> > > {
                new KeyValuePair <CharSymbol, DfaState <CharSymbol> >(CharSymbol.MinValue, sError)
            };
            var tError = new List <KeyValuePair <CharSymbol, DfaState <CharSymbol> > > {
                new KeyValuePair <CharSymbol, DfaState <CharSymbol> >(CharSymbol.MinValue, sError)
            };

            s1.Initialize(0, t1);
            s2.Initialize(1, t2);
            sError.Initialize(0, tError);
            var automatons = new Dictionary <CharSymbol, Dfa <CharSymbol> >();

            //automatons[new CharSymbol(Char.MinValue)] =
            automatons[new CharSymbol('E')] = new Dfa <CharSymbol>(s1);
            foreach (var i in automatons)
            {
                Console.WriteLine("dfa {0}: {1}", i.Key, i.Value.ToString());
            }
            var grammar = new Grammar <CharSymbol>(new CharSymbol('E'), productions);

            grammar.InjectAutomatons(automatons);
            var ldfa = builder.Build(grammar, new CharSymbol('E'), s1);

            Console.WriteLine("Ldfa {0}", ldfa);
        }