Example #1
0
 /// <summary>
 /// Dado um símbolo retorna um não terminal ou um terminal dependendo de seu tipo
 /// </summary>
 /// <param name="symbol"></param>
 /// <returns></returns>
 public static Symbol GetSymbol(string symbol)
 {
     if (NonTerminalHash.ContainsKey(symbol))
     {
         return(NonTerminalHash[symbol]);
     }
     //Se não contiver, verificamos a lista de terminais
     else if (TerminalHash.ContainsKey(symbol))
     {
         return(TerminalHash[symbol]);
     }
     else
     {
         return(null);
     }
 }
Example #2
0
        /// <summary>
        /// Gera a lista de firsts do não terminal
        /// </summary>
        /// <returns></returns>
        public List <First> First(bool initialSymbol)
        {
            if (Rule == null || Rule.Length == 0)
            {
                return(null);
            }

            //Separa as regras pelo |
            string[] rules = Rule.Split('|');
            foreach (string rule in rules)
            {
                if (rule.Contains(' '))
                {
                    string[] symbols = rule.Split(' ');

                    int    i           = 0;
                    string symbol      = symbols[i];
                    bool   loopBreaker = false;

                    while (!loopBreaker)
                    {
                        //Se contiver e o símbolo, logo ele é um não terminal
                        if (NonTerminalHash.ContainsKey(symbol))
                        {
                            NonTerminal anotherNonTerminal = NonTerminalHash[symbol];
                            if (anotherNonTerminal.Value.Equals(Value))
                            {
                                return(null);
                            }

                            List <First> anotherNonTerminalFirsts = anotherNonTerminal.First();

                            foreach (First firstElement in anotherNonTerminalFirsts)
                            {
                                if (AddTerminalToFirst(firstElement.FirstValue, rule) == false)
                                {
                                    loopBreaker = true;
                                }
                            }

                            if (anotherNonTerminal.FirstContainsEmpty())
                            {
                                if (i < symbols.Length - 1)
                                {
                                    i++;
                                    symbol = symbols[i];
                                }
                                else
                                {
                                    AddTerminalToFirst(Terminal.Empty, rule);
                                    loopBreaker = true;
                                }
                            }
                            else
                            {
                                loopBreaker = true;
                            }
                        }
                        //Se não contiver, verificamos a lista de terminais
                        else if (TerminalHash.ContainsKey(symbol))
                        {
                            Terminal terminal = TerminalHash[symbol];

                            AddTerminalToFirst(terminal, rule);

                            loopBreaker = true;
                        }
                        else
                        //Se não contiver, é uma situação de erro
                        {
                            return(null);
                        }
                    }
                }
                else
                {
                    //Apenas para facilitar a leitura
                    string symbol = rule;

                    //Se contiver e o símbolo, logo ele é um não terminal
                    if (NonTerminalHash.ContainsKey(symbol))
                    {
                        NonTerminal  anotherNonTerminal       = NonTerminalHash[symbol];
                        List <First> anotherNonTerminalFirsts = anotherNonTerminal.First();

                        if ((anotherNonTerminalFirsts != null) && (anotherNonTerminalFirsts.Count > 0))
                        {
                            foreach (First firstElement in anotherNonTerminalFirsts)
                            {
                                AddTerminalToFirst(firstElement.FirstValue, rule);
                            }
                        }
                    }
                    //Se não contiver, verificamos a lista de terminais
                    else if (TerminalHash.ContainsKey(symbol))
                    {
                        Terminal terminal = TerminalHash[symbol];

                        AddTerminalToFirst(terminal, rule);
                    }
                    else
                    //Se não contiver, é uma situação de erro
                    {
                        return(null);
                    }
                }
            }

            return(Firsts);
        }