Esempio n. 1
0
        private HashSet <IToken> First(IToken token)
        {
            if (token.IsTerminal)
            {
                return new HashSet <IToken>()
                       {
                           token
                       }
            }
            ;

            NonTerminal nonterm = token as NonTerminal;

            if (LeftRecursiveNonterminals.Contains(nonterm))
            {
                throw new InvalidOperationException("Nonterminal can't be left recursive!");
            }

            HashSet <IToken> firstSet = new HashSet <IToken>();
            HashSet <IToken> eps      = new HashSet <IToken>()
            {
                __Epsilon
            };
            bool containsEps = true;

            foreach (var rule in nonterm.Rules)
            {
                containsEps = true;
                foreach (var t in rule.RightPart)
                {
                    if (containsEps)
                    {
                        var first_yi = First(t);
                        containsEps = first_yi.Contains(__Epsilon);
                        first_yi.ExceptWith(eps);
                        firstSet.UnionWith(first_yi);
                    }
                    else
                    {
                        break;
                    }
                }
            }

            if (containsEps || EpsilonNonterminals.Contains(nonterm))
            {
                firstSet.Add(__Epsilon);
            }

            return(firstSet);
        }
Esempio n. 2
0
 private bool IsEpsilonProductive(IToken token)
 {
     return(token.IsTerminal ? token == __Epsilon : (EpsilonNonterminals.Contains(token)));
 }