Beispiel #1
0
        private static void TraversePlay()
        {
            var g = new Grammar(new List <Production> {
                CFGParser.Production("<A> → <B>"),
                CFGParser.Production("<B> → <A>"),
                CFGParser.Production("<B> → 'x'"),
            }, Nonterminal.Of("A"));

            g = IdentityActions.Annotate(g);

            var earley2  = new EarleyParser2(g);
            var sentence = Sentence.FromWords("x");
            var sppf2    = earley2.ParseGetForest(sentence);

            DotRunner.Run(DotBuilder.GetRawDot(sppf2), "infinite");

            var t2 = new Traversal(sppf2, g);
            var r2 = t2.Traverse();
            //foreach (var option in r2) {
            //	var s2 = (Sentence)option.Payload;
            //	if (!sentence.SequenceEqual(s2)) {
            //		throw new Exception();
            //	}
            //}
        }
Beispiel #2
0
        internal bool PredictedAlreadyAndSet(Nonterminal nonterminal)
        {
            var predicted = _nonterminalsPredicted.Contains(nonterminal);

            _nonterminalsPredicted.Add(nonterminal);
            return(predicted);
        }
Beispiel #3
0
        static SimpleMaths()
        {
            var number = Terminals.Double("Number");

            var expression = Nonterminal.Create <double>("Expression");

            expression.SetProductions(
                number.AsIs(),
                expression.Extended().Append("+").Extend(expression).Finish((x1, x2) => x1 + x2),
                expression.Extended().Append("-").Extend(expression).Finish((x1, x2) => x1 - x2),
                expression.Extended().Append("*").Extend(expression).Finish((x1, x2) => x1 * x2),
                expression.Extended().Append("/").Extend(expression).Finish((x1, x2) => x1 / x2),
                "-".Appended().Extend(expression).WithPrecedence(out var NEG).Finish(x => - x),
                expression.Extended().Append("^").Extend(expression).Finish(Math.Pow),
                "(".Appended().Extend(expression).Append(")").AsIs());

            var opScope = new OperatorScope(
                new LeftAssociative("+", "-"),
                new LeftAssociative("*", "/"),
                new PrecedenceOnly(NEG),
                new RightAssociative("^"));

            Designtime = expression.WithOperatorScope(opScope);
            Runtime    = Designtime.Build();
        }
Beispiel #4
0
        /// <summary>
        /// The point of this is to evaluate all of the expressions and assign them to the rule (NonTerminal).  The
        /// "activeMethod" business is to escape recursion if a rule calls itself.
        /// </summary>
        private void InvocationHandler(Invocation invocation)
        {
            Nonterminal result;

            if (rules.TryGetValue(invocation.Method.Name, out result) && result.Expression != null)
            {
                invocation.ReturnValue = result;
            }
            else
            {
                if (activeMethod != null)
                {
                    Nonterminal rule = rules[invocation.Method.Name];
                    invocation.ReturnValue = rule;
                }
                else
                {
                    activeMethod = invocation.Method;
                    invocation.Proceed();
                    Nonterminal rule = rules[invocation.Method.Name];
                    if (rule.Expression == null)
                    {
                        rule.Expression = (Expression)invocation.ReturnValue;
                    }
                    invocation.ReturnValue = rule;

                    // Now check for captured nonterminals (i.e. .Capture("foo"))
                    var walker = new CaptureWalker();
                    rule.Expression.Accept(walker, this);

                    activeMethod = null;
                }
            }
        }
Beispiel #5
0
        /// <summary>
        /// Productions MUST BE:
        /// - left factored
        /// - without left recursions
        /// </summary>
        /// <param name="productions">Processed productions</param>
        public void FillByProcessedProductions(IEnumerable <Production> productions, Nonterminal axiom)
        {
            // A -> alpha
            foreach (var production in productions)
            {
                var useProductionAction = AutomateAction.FromProduction(production);

                // FIRST(alpha)
                var first = Helper.First(productions, production.RightPart);
                foreach (var terminal in first)
                {
                    this[production.LeftPart, terminal] = useProductionAction;
                }

                if (first.Contains(GeneralizedTerminal.Epsilon))
                {
                    // FOLLOW(A)
                    var follow = Helper.Follow(productions, production.LeftPart, axiom);
                    foreach (var terminal in follow)
                    {
                        this[production.LeftPart, terminal] = useProductionAction;
                    }
                }
            }
        }
Beispiel #6
0
        public AutomateAction this[Nonterminal nt, Terminal t]
        {
            get
            {
                if (_table.ContainsKey(nt))
                {
                    foreach (var item in _table[nt])
                    {
                        if (item.Key.IsAppropriateTerminal(t))
                        {
                            return(item.Value);
                        }
                    }
                }

                return(null);
            }

            set
            {
                if (!_table.ContainsKey(nt))
                {
                    _table.Add(nt, new Dictionary <Terminal, AutomateAction>());
                }

                _table[nt][t] = value;
            }
        }
Beispiel #7
0
 public void TestEarleys01()
 {
     ExecuteTest(new Grammar(new List <Production> {
         CFGParser.Production("<X_0> → <X_5> 'x5' [66.743324284322242]"),
         CFGParser.Production("<X_5> → 'x6' 'x6' [18.445467280897063]")
     }, Nonterminal.Of("X_0")), "x6");
 }
        private static Production generateRandomProduction(Nonterminal lhs, List <Nonterminal> nts, double epsylonProb = 0.2, double nontermProb = 0.4, double lengthIncreaseProb = 0.5)
        {
            List <GrammarSymbol> rhs = new List <GrammarSymbol>();

            //epsylon
            if (rnd.NextDouble() < epsylonProb)
            {
                return(new Production(lhs, rhs.ToArray()));
            }

            do
            {
                if (rnd.NextDouble() < nontermProb)
                {
                    rhs.Add(nts[rnd.Next(nts.Count)]);                                 // --> nonterminal
                }
                else
                { // --> terminal
                    char term = (char)('a' + rnd.Next(10));
                    rhs.Add(new Exprinal <String>("" + term, "" + term));
                }
            } while (rnd.NextDouble() < lengthIncreaseProb); //length of right hand side

            return(new Production(lhs, rhs.ToArray()));
        }
        public static ContextFreeGrammar GenerateRandom()
        {
            Nonterminal        startS = new Nonterminal("S");
            List <Nonterminal> nts    = new List <Nonterminal>();

            nts.Add(startS);

            //nonterminals
            int ntcount = rnd.Next(2, 6);

            while (nts.Count < ntcount)
            {
                var newNt = new Nonterminal("" + (char)('A' + rnd.Next(26))); //random NT name
                if (!nts.Contains(newNt))
                {
                    nts.Add(newNt);
                }
            }

            //productions
            List <Production> prods = new List <Production>();

            prods.Add(generateRandomProduction(startS, nts, 0, 1, 0.45)); //add a production for Start with only NTs
            foreach (Nonterminal nt in nts)
            {
                prods.Add(generateRandomProduction(nt, nts)); //at least 1 prod per NT
                while (rnd.NextDouble() < 0.5)
                {
                    prods.Add(generateRandomProduction(nt, nts));                            //generate more prods
                }
            }

            return(new ContextFreeGrammar(startS, prods));
        }
Beispiel #10
0
        /// <summary>
        /// Returns a Nonterminal that references the current expression.  Nonterminals are
        /// the only structure that retains structural meaning after parsing (i.e. it
        /// has representation in the output stream / CST.)  Thus, if you ever need to do
        /// something to your parse result by referring to elements in your pattern,
        /// this is how you can solidify them.
        /// </summary>
        public static Nonterminal Capture(this Expression expression)
        {
            Nonterminal result = new Nonterminal();

            result.Expression = expression;
            return(result);
        }
Beispiel #11
0
        public void TestAccepts03()
        {
            var productions = new HashSet <Production> {
                CFGParser.Production("<S> -> <S> <S> <S>"),
                CFGParser.Production("<S> -> ε"),
                CFGParser.Production("<S> -> 'x2' 'x0'"),
                CFGParser.Production("<S> -> 'x0' <S>"),
                CFGParser.Production("<S> -> 'x4'"),
                CFGParser.Production("<S> -> <S> 'x0' 'x4'"),
                CFGParser.Production("<S> -> 'x3' <S> 'x3' <S> 'x0'"),
                CFGParser.Production("<S> -> 'x2' <S> <S> <S> <S>"),
                CFGParser.Production("<S> -> <S> <S> <S> <S> <S>"),
                CFGParser.Production("<S> -> 'x0' <S> <S>"),
                CFGParser.Production("<S> -> <S>"),
                CFGParser.Production("<S> -> 'x0' <S> <S> 'x1'"),
                CFGParser.Production("<S> -> 'x3' 'x2' 'x1'"),
                CFGParser.Production("<S> -> 'x0' 'x0' 'x2'"),
            };
            Grammar    g = new Grammar(productions, Nonterminal.Of("S"));
            CNFGrammar h = g.ToCNF();

            Assert.IsTrue(h.Accepts(Sentence.FromLetters("")));
            Assert.IsTrue(h.Accepts(Sentence.FromWords("x4")));
            Assert.IsTrue(h.Accepts(Sentence.FromWords("x4 x0 x4")));
        }
Beispiel #12
0
        private void BubblingProcessNode(SyntaxTreeNode node)
        {
            if (node.Value is Nonterminal)
            {
                Nonterminal nonterminal = node.Value as Nonterminal;

                if (nonterminal.Equals(MyNonterminals.ASSIGN_STATEMENT) && node.ChildrenCount == 4)
                {
                    var    idToken         = (node[1].Value as ConcreteTerminal).Token;
                    string defVariableName = idToken.Value;

                    if (!_defindedVariables.Contains(defVariableName))
                    {
                        _defindedVariables.Add(defVariableName);
                    }
                    else
                    {
                        _errors.Add(new Error(idToken, ErrorKind.Semantic, "Variable redefinition"));
                    }
                }
            }
            else
            {
                ConcreteTerminal terminal = node.Value as ConcreteTerminal;

                if (terminal.Token.HasType(TokenType.Identifier) && !_defindedVariables.Contains(terminal.Token.Value))
                {
                    if (((Nonterminal)node.Parent.Value).Equals(MyNonterminals.FACTOR))
                    {
                        _errors.Add(new Error(terminal.Token, ErrorKind.Semantic, "Undefined variable"));
                    }
                }
            }
        }
        public void ParserONE_AND_MORE_OR__ASSIGN_OP__VAR()
        {
            Nonterminal expr = new Nonterminal(OR, "ASSIGN_OP", "VAR");
            Nonterminal lang = new Nonterminal(ONE_AND_MORE, expr);

            CheckTest(Resources.ParserONE_AND_MORE_OR__ASSIGN_OP__VAR, true, 21, new ParserLang(lang));
        }
Beispiel #14
0
 public void TestTraversal01()
 {
     ExecuteTest(new Grammar(new List <Production> {
         CFGParser.Production("<X_0> → ε [115.49728913674936]"),
         CFGParser.Production("<X_0> → 'x0' 'x0' <X_0> 'x0' 'x0' [32.857227595456521]")
     }, Nonterminal.Of("X_0")), "ε");
 }
Beispiel #15
0
        /// <summary>
        /// Converts the given cfg into a new one in 2NF, that means that every production has at most 2 symbols on the right hand side
        /// </summary>
        /// <param name="cfg">cfg</param>
        /// <returns>cfg in 2NF</returns>
        public static ContextFreeGrammar To2NF(ContextFreeGrammar cfg)
        {
            var productions = new List<Production>();

            int currentNumber = 0;

            var productionsToShorten = new Queue<Production>(cfg.GetProductions());
            while (productionsToShorten.Count() > 0)
            {
                var next = productionsToShorten.Dequeue();
                if (next.Rhs.Length <= 2)
                {
                    productions.Add(next);
                }
                else
                {
                    var newNonTerminal = new Nonterminal(PrefixOfAddedNonterminals + currentNumber);
                    currentNumber++;

                    Assertion.Assert(!cfg.Variables.Any(v => v.Name.Equals(newNonTerminal.Name)), 
                        string.Format("The nonterminal with id {0} already existed. Please ensure, that the CFG does not use ints as ids", newNonTerminal.Name));

                    productions.Add(new Production(next.Lhs, next.Rhs[0], newNonTerminal));
                    productionsToShorten.Enqueue(new Production(newNonTerminal, next.Rhs.Skip(1).ToArray()));
                }
            }

            return new ContextFreeGrammar(cfg.StartSymbol, productions);
        }
Beispiel #16
0
 public void TestTraversal05()
 {
     ExecuteTest(new Grammar(new List <Production> {
         CFGParser.Production("<S> → <S> <S>"),
         CFGParser.Production("<S> → 'x'"),
     }, Nonterminal.Of("S")), "x x x x x x x x x x x x x x x x");
 }
Beispiel #17
0
 public void TestTraversalAddition()
 {
     ExecuteTest(new Grammar(new List <Production> {
         CFGParser.Production("<S> → <S> '+' <S>"),
         CFGParser.Production("<S> → '1'")
     }, Nonterminal.Of("S")), "1 + 1 + 1");
 }
Beispiel #18
0
        public void TestParsing18()
        {
            var g = new Grammar(new List <Production> {
                CFGParser.Production("<X_9> → 'x3' <X_4> <X_9> [69.71867415901211]"),
                CFGParser.Production("<X_6> → 'x4' [43.169519673180545]"),
                CFGParser.Production("<X_0> → 'x0' 'x3' <X_6> <X_9> <X_9> [95.5660355475573]"),
                CFGParser.Production("<X_5> → <X_9> 'x1' 'x0' 'x1' 'x3' <X_2> [35.638882444537657]"),
                CFGParser.Production("<X_1> → 'x4' 'x3' 'x1' 'x1' <X_9> <X_8> [60.963767072169006]"),
                CFGParser.Production("<X_9> → <X_6> [96.869668710916145]"),
                CFGParser.Production("<X_8> → 'x1' <X_0> 'x0' <X_2> <X_2> [10.412202848779131]"),
                CFGParser.Production("<X_4> → ε [89.394112460498746]"),
                CFGParser.Production("<X_4> → <X_8> 'x2' <X_5> 'x1' [41.46934854261081]"),
                CFGParser.Production("<X_2> → ε [28.04076097674703]"),
                CFGParser.Production("<X_8> → ε [55.798571558109757]"),
                CFGParser.Production("<X_0> → 'x2' 'x2' 'x3' <X_6> [48.407048357374521]"),
                CFGParser.Production("<X_0> → <X_1> 'x3' 'x2' [82.3935272774629]"),
                CFGParser.Production("<X_1> → <X_8> <X_1> <X_2> [68.051246746932733]")
            }, Nonterminal.Of("X_0"));

            var sentences = new List <Sentence>();

            sentences.Add(Sentence.FromWords("x3 x2"));

            ExecuteTest(g, sentences);
        }
Beispiel #19
0
        private Nonterminal Map(NonterminalExpr rule)
        {
            if (!Nonterminals.TryGetValue(rule, out var mapped))
            {
                mapped = new Nonterminal(rule.Name);
                Nonterminals.Add(rule, mapped);

                foreach (var chain in rule.Body)
                {
                    var body = new List <Symbol>();

                    foreach (var symbol in chain)
                    {
                        switch (symbol)
                        {
                        case TerminalExpr terminal:
                            body.Add(Map(terminal));
                            break;

                        case NonterminalExpr nonterminal:
                            body.Add(Map(nonterminal));
                            break;
                        }
                    }

                    Productions.Add(new Production(mapped, body));
                }
            }

            return(mapped);
        }
Beispiel #20
0
        public void TestProduction()
        {
            var actualp   = CFGParser.Production(@"<S> -> <X> 'a' <S> [3.0]");
            var expectedp = new Production(
                Nonterminal.Of("S"),
                new Sentence {
                Nonterminal.Of("X"),
                Terminal.Of("a"),
                Nonterminal.Of("S")
            },
                3.0
                );
            var unexpectedp = new Production(
                Nonterminal.Of("S"),
                new Sentence {
                Terminal.Of("a"),
                Nonterminal.Of("X"),
                Nonterminal.Of("S")
            },
                3.0
                );

            Assert.IsTrue(actualp.ValueEquals(expectedp));
            Assert.IsFalse(actualp.ValueEquals(unexpectedp));
        }
Beispiel #21
0
        public void TestAccepts05()
        {
            var productions = new HashSet <Production> {
                CFGParser.Production("<X_2> -> <X_1> <X_0>"),
                CFGParser.Production("<X_1> -> <X_2> <X_1> <X_3> 'x2'"),
                CFGParser.Production("<X_3> -> <X_0> <X_0> <X_1> <X_3>"),
                CFGParser.Production("<X_3> -> ε"),
                CFGParser.Production("<X_2> -> <X_0> <X_1> <X_3> <X_1> <X_3>"),
                CFGParser.Production("<X_2> -> <X_1> <X_2> <X_2> <X_0>"),
                CFGParser.Production("<X_0> -> <X_3> 'x3'"),
                CFGParser.Production("<X_2> -> ε"),
                CFGParser.Production("<X_0> -> <X_2> <X_1>"),
                CFGParser.Production("<X_2> -> <X_0> <X_1> <X_2>"),
                CFGParser.Production("<X_1> -> <X_3> <X_3>"),
                CFGParser.Production("<X_3> -> 'x3' 'x4'"),
                CFGParser.Production("<X_3> -> <X_3> 'x4'"),
                CFGParser.Production("<X_1> -> 'x0' 'x4' 'x0' <X_2> <X_0>"),
            };
            var g = new Grammar(productions, Nonterminal.Of("X_0"));
            var h = g.ToCNF();

            Assert.IsTrue(h.Accepts(Sentence.FromWords("")));
            Assert.IsTrue(h.Accepts(Sentence.FromWords("x3")));
            Assert.IsTrue(h.Accepts(Sentence.FromWords("x3 x4 x3")));
            Assert.IsTrue(h.Accepts(Sentence.FromWords("x4 x3")));
            Assert.IsTrue(h.Accepts(Sentence.FromWords("x3 x4 x4 x3")));
            Assert.IsTrue(h.Accepts(Sentence.FromWords("x3 x4")));
            Assert.IsTrue(h.Accepts(Sentence.FromWords("x3 x4 x3 x4")));
        }
Beispiel #22
0
        public void TestParsing15()
        {
            // S -> aSa | bSb | ε
            var g = new Grammar(new List <Production> {
                CFGParser.Production(@"<S> -> 'a' <S> 'a'"),
                CFGParser.Production(@"<S> -> 'b' <S> 'b'"),
                CFGParser.Production(@"<S> -> ε"),
            }, Nonterminal.Of("S"));

            var sentences = new List <Sentence> {
                Sentence.FromLetters("ab"),
                Sentence.FromLetters("abc"),
                Sentence.FromLetters("aaa"),
                Sentence.FromLetters("abbba"),
                Sentence.FromLetters(""),
                Sentence.FromLetters("aa"),
                Sentence.FromLetters("bb"),
                Sentence.FromLetters("abba"),
                Sentence.FromLetters("baab"),
                Sentence.FromLetters("aaaa"),
                Sentence.FromLetters("bbbb"),
                Sentence.FromLetters("aaabbabbabbaaa"),
            };

            ExecuteTest(g, sentences);
        }
Beispiel #23
0
        private void InvocationHandler(Invocation invocation)
        {
            Nonterminal result;

            if (rules.TryGetValue(invocation.Method.Name, out result) && result.Expression != null)
            {
                invocation.ReturnValue = result;
            }
            else
            {
                if (activeMethod != null)
                {
                    Nonterminal rule = rules[invocation.Method.Name];
                    invocation.ReturnValue = rule;
                }
                else
                {
                    activeMethod = invocation.Method;
                    invocation.Proceed();
                    Nonterminal rule = rules[invocation.Method.Name];
                    if (rule.Expression == null)
                    {
                        rule.Expression = (Expression)invocation.ReturnValue;
                    }
                    invocation.ReturnValue = rule;
                    activeMethod           = null;
                }
            }
        }
Beispiel #24
0
        private string GenerateErrorMessage(Nonterminal disclosingNonterminal, ConcreteTerminal inputTerminal)
        {
            var expected = GetExpectedTerminalsFor(disclosingNonterminal)
                           .Except(new[] { GeneralizedTerminal.Epsilon, GeneralizedTerminal.EndOfText });

            //return string.Format("{0} expected, but received {1} (disclosing: {2})", string.Join(" or ", expected), inputTerminal, disclosingNonterminal);
            return(string.Format("{0} expected, but received {1} (start with one of {{{2}}})", disclosingNonterminal, inputTerminal, string.Join(", ", expected)));
        }
Beispiel #25
0
 public IList <EarleyItem> ItemsAtNonterminal(Nonterminal nonterminal)
 {
     if (!_nonterminalCache.TryGetValue(nonterminal, out var list))
     {
         return(null);
     }
     return(list);
 }
Beispiel #26
0
 public LeftRecursion(Nonterminal rule, LeftRecursion next, Grammar grammar)
 {
     Rule        = rule;
     InvolvedSet = new BooleanSet(grammar.Nonterminals.Count);
     Next        = next;
     EvalSet     = next.EvalSet.Copy();
     EvalSet.Add(next.Rule.Index);
 }
Beispiel #27
0
		internal ForestInternal(InteriorNode node, Nonterminal nonterminal) : base(node.StartPosition, node.EndPosition) {
			_node = node;
			_nonterminal = nonterminal;
			//_nodeLookup = new Dictionary<InteriorNode, ForestInternal>();
			//_nodeLookup[node] = this;

			_options = ForestOption.BuildOptions(node.Families, node.StartPosition, node.EndPosition);
		}
Beispiel #28
0
        public void TestGrammar1Letter()
        {
            TestGrammar1 grammar     = TestGrammar1.Create();
            Nonterminal  nonterminal = grammar.GetNonterminal(o => o.LetterA());

            Assert.AreEqual("LetterA", nonterminal.Name);
            Assert.AreEqual('a', ((CharacterTerminal)nonterminal.Expression).Character);
        }
Beispiel #29
0
        public LeftRecursion(Nonterminal rule, Grammar grammar)
        {
            Rule = rule;
            int size = grammar.Nonterminals.Count;

            InvolvedSet = new BooleanSet(size);
            EvalSet     = new BooleanSet(size);
        }
Beispiel #30
0
        /// <summary>
        /// Returns a Nonterminal that references the current expression, giving it the specified
        /// name.  Nonterminals are the only structure that retains structural meaning after
        /// parsing (i.e. it has representation in the output stream / CST.)  Thus, if you ever
        /// need to do something to your parse result by referring to elements in your pattern,
        /// this is how you can solidify them.
        /// </summary>
        public static Nonterminal Capture(this Expression expression, string name)
        {
            Nonterminal result = new Nonterminal();

            result.Name       = name;
            result.Expression = expression;
            return(result);
        }
Beispiel #31
0
        private void BuildList(PropertyInfo property, object astNode, CstNonterminalNode cstNode)
        {
            ConsumeExpression[] expressions = astAttributes[cstNode.Nonterminal].Select(o => o.GetExpression()).ToArray();
            Expression          expression  = cstNode.Nonterminal.Expression;

            if (expressions.Length > 0 || (expression is Sequence || expression is ZeroOrMore || expression is OneOrMore))
            {
                IEnumerable <ICstNonterminalNode> itemNodes;
                if (expressions.Length > 0)
                {
                    itemNodes = GetChildrenByAstExpression(cstNode, expressions);
                }
                else
                {
                    Func <Expression, Nonterminal> findNonterminal = null;
                    findNonterminal = current =>
                    {
                        if (current is Nonterminal)
                        {
                            return((Nonterminal)current);
                        }
                        else if (current is Sequence)
                        {
                            return(findNonterminal(((Sequence)current).Expressions.First()));
                        }
                        else if (current is ZeroOrMore)
                        {
                            return(findNonterminal(((ZeroOrMore)current).Operand));
                        }
                        else
                        {
                            return(findNonterminal(((OneOrMore)current).Operand));
                        }
                    };

                    Nonterminal nonterminal = findNonterminal(expression);
                    itemNodes = GetChildrenByNonterminal(cstNode, nonterminal);
                }

                IList list     = (IList)Activator.CreateInstance(property.PropertyType);
                Type  listType = property.PropertyType.GetListElementType();
                foreach (var childNode in itemNodes)
                {
                    object listItemAstNode = Build(listType, childNode);
                    list.Add(listItemAstNode);
                }
                property.SetValue(astNode, list, null);
            }
            else
            {
                IList list     = (IList)Activator.CreateInstance(property.PropertyType);
                Type  listType = property.PropertyType.GetListElementType();

                object listItemAstNode = Build(listType, cstNode);
                list.Add(listItemAstNode);
                property.SetValue(astNode, list, null);
            }
        }
Beispiel #32
0
		public StateSet(Nonterminal predictionSeedNonterminal = null) {
			_items = new List<Item>();
			_seenItems = new Dictionary<Item, Item>(new ItemComparer());
			_nonterminalsPredicted = new HashSet<Nonterminal>();
			if (predictionSeedNonterminal != null) {
				_nonterminalsPredicted.Add(predictionSeedNonterminal);
			}
			_magicItems = new List<Item>();
		}
Beispiel #33
0
        public SchemeGrammar()
        {
            var _expression = new Nonterminal("Expression");
            var _variable = new Nonterminal("Variable");
            var _literal = new Nonterminal("Literal");
            var _procedureCall = new Nonterminal("ProcedureCall");
            var _lambdaExpression = new Nonterminal("LambdaExpression");
            var _conditional = new Nonterminal("Conditional");
            var _assignment = new Nonterminal("Assignment");
            var _derivedExpression = new Nonterminal("DerivedExpression");
            var _macroUse = new Nonterminal("MacroUse");
            var _macroBlock = new Nonterminal("MacroBlock");

            var _quotation = new Nonterminal("Quotation");
            var _selfEvaluating = new Nonterminal("Self-Evaluating");

            var _boolean = new Nonterminal("Boolean");
            var _number = new Nonterminal("Number");
            var _character = new Nonterminal("Character");
            var _string = new Nonterminal("String");

            var _datum = new Nonterminal("Datum");

            _expression.Rule = _variable | _literal | _procedureCall | _lambdaExpression | _conditional | _assignment
                             | _derivedExpression | _macroUse | _macroBlock;

            _literal.Rule = _quotation | _selfEvaluating;

            _selfEvaluating.Rule = _boolean | _number | _character | _string;

            _quotation.Rule = Key("'") + _datum
                            | Key("(quote") + _datum;

            _root = null;
            throw new NotImplementedException();
        }
Beispiel #34
0
		internal bool PredictedAlreadyAndSet(Nonterminal nonterminal) {
			var predicted = _nonterminalsPredicted.Contains(nonterminal);
			_nonterminalsPredicted.Add(nonterminal);
			return predicted;
		}
Beispiel #35
0
		public SymbolNode(Nonterminal symbol, int start, int end) : base(start, end) {
			Symbol = symbol;
		}