public void RunAnalizadorSintatico()
        {
            MontagemTabelaNaoTerminais();
            MontagemTabelaTerminais();
            MontagemTabelaParsing();

            NaoTerminal _retorno = RetornarCodigoNaoTerminal("PROGRAMA");
            Item        item     = VerificarPilhaParsingPorCodigo(_retorno.Codigo + "," + "1");

            CarregarArvoreDerivacao(item);
            string arvoreDerivacaoUnida;


            while (ArvoreDerivacao.Count > 0 && TokenController.PilhaTokenPrincipal.Count > 0)
            {
                if (VerificaTerminal(ArvoreDerivacao[0]))
                {
                    if (ArvoreDerivacao[0].Equals(TokenController.PilhaTokenPrincipal[0].token.Simbolo))
                    {
                        arvoreDerivacaoUnida = string.Join("|", ArvoreDerivacao);
                        _frmInicio.EscreverGrid(TokenController.PilhaTokenPrincipal[0].Linha.ToString(), ArvoreDerivacao[0], arvoreDerivacaoUnida);

                        // Rodar analizador semantico.
                        // Sempre que for um Identificador, Constante, Procedure, Label, VAR
                        if (TokenController.PilhaTokenPrincipal[0].token.Codigo.Equals(4) || TokenController.PilhaTokenPrincipal[0].token.Codigo.Equals(2) || TokenController.PilhaTokenPrincipal[0].token.Codigo.Equals(5) || TokenController.PilhaTokenPrincipal[0].token.Codigo.Equals(1) || TokenController.PilhaTokenPrincipal[0].token.Codigo.Equals(3) || TokenController.PilhaTokenPrincipal[0].token.Codigo.Equals(25) && TokenController.PilhaTokenPrincipal[0].token.Codigo.Equals(38) || TokenController.PilhaTokenPrincipal[0].token.Codigo.Equals(7) || TokenController.PilhaTokenPrincipal[0].token.Codigo.Equals(6))
                        {
                            if (!MontarTabelaSimbolos(TokenController.PilhaTokenPrincipal))
                            {
                                break;
                            }
                        }

                        TokenController.PilhaTokenPrincipal.RemoveAt(0);
                        ArvoreDerivacao.RemoveAt(0);
                    }
                    else
                    {
                        _frmInicio.EscreverSaida("ERROS ENCONTRADOS >> Simbolo incorreto  | Proximo a linha: " + TokenController.PilhaTokenPrincipal[0].Linha);
                        break;
                    }
                }
                else
                {
                    _retorno = RetornarCodigoNaoTerminal(ArvoreDerivacao[0]);

                    if (VerificarPilhaParsingPorCodigoBool(_retorno.Codigo.ToString() + "," + TokenController.PilhaTokenPrincipal[0].token.Codigo.ToString()))
                    {
                        arvoreDerivacaoUnida = string.Join("|", ArvoreDerivacao);
                        _frmInicio.EscreverGrid(TokenController.PilhaTokenPrincipal[0].Linha.ToString(), ArvoreDerivacao[0], arvoreDerivacaoUnida);
                        ArvoreDerivacao.RemoveAt(0);
                        CarregarArvoreDerivacao(VerificarPilhaParsingPorCodigo(_retorno.Codigo.ToString() + "," + TokenController.PilhaTokenPrincipal[0].token.Codigo.ToString()));
                    }
                    else
                    {
                        _frmInicio.EscreverSaida("ERROS ENCONTRADOS >> Simbolo incorreto  | Proximo a linha: " + TokenController.PilhaTokenPrincipal[0].Linha);
                        break;
                    }
                }
            }
        }
 private bool VerficaNaoTerminal(NaoTerminal naoTerminal)
 {
     if (ListNaoTerminais.Contains(naoTerminal))
     {
         return(true);
     }
     return(false);
 }
        public void RodarAnalizadoSintatico()
        {
            int i = 0;

            // CRIAR O ANALIZADO LEXICO AQUI SOMENTE NESTA CLASSE POR FAVOR.
            MontagemTabelaNaoTerminais();
            MontagemTabelaTerminais();
            MontagemTabelaParsing();

            // Colocar no Proximo o proximo da pilha.

            #region --- EXECUCAO DO AUTOMATO ---

            // Colocar em proximo o simbolo $ e o incial da gramatica PROGRAM
            while (TokenController.PilhaTokenPrincipal.Count > 0)
            {
                // Encontrar proximo elemento analizado.
                //Proximo = TokenController.PilhaTokenPrincipal[i + 1];

                // Verificar se o elemento e um terminal ou o simbolo final.

                /*if (VerificaTerminal(TokenController.PilhaTokenPrincipal[i]))
                 *              {
                 *                      if (TokenController.PilhaTokenPrincipal[i].Equals(Proximo))
                 *                      {
                 *                              TokenController.PilhaTokenPrincipal.RemoveAt(i);
                 *                              Proximo = null;
                 *                      }
                 *                      else
                 *                      {
                 *                              // Carecteriza erro.
                 *                              // Colocar na saida.
                 *                      }
                 *              }
                 *              else
                 *              {
                 *
                 *              }*/

                // Algoritimo proprio.


                // ir percorrendo lista, verificando se esta na tabela de parsing.
                // se estiver mandar pear o retorno e procurar na tabela de nao terminais.
                // pegar o codigo do nao terminal encontrado e mandar par tabela de parsing.
                // assim encontramos a proxima linha de derivacao.

                // verificamos se o item esta na tabela de parsing.
                Item _item = null;
                if (i.Equals(0))
                {
                    if (TokenController.PilhaTokenPrincipal[i].token.Simbolo.Equals("PROGRAM"))
                    {
                        _item = VerificarPilhaParsing(TokenController.PilhaTokenPrincipal[i].token.Simbolo);
                        CarregarArvoreDerivacao(_item);

                        TokenController.PilhaTokenPrincipal.RemoveAt(i);
                        ArvoreDerivacao.RemoveAt(i);
                        _frmInicio.EscreverGrid(Convert.ToString(TokenController.PilhaTokenPrincipal[i].Linha), Convert.ToString(_item.Codigo), Convert.ToString(_item.Derivacao));
                    }
                    else
                    {
                        _frmInicio.EscreverSaida("ERROS ENCONTRADOS >> Simbolo incorreto  | Proximo a linha: " + TokenController.PilhaTokenPrincipal[i].Linha);
                        break;
                    }
                }
                else
                {
                    // Primeiro precisa ver se eum terminal.
                    if (VerificaTerminal(TokenController.PilhaTokenPrincipal[0].token.Simbolo))
                    {
                        if (TokenController.PilhaTokenPrincipal[0].token.Simbolo.Equals(ArvoreDerivacao[0]))
                        {
                            // terminal
                            TokenController.PilhaTokenPrincipal.RemoveAt(0);
                            ArvoreDerivacao.RemoveAt(0);
                        }
                        else if (RetornarCodigoNaoTerminal(ArvoreDerivacao[0]) != null)
                        {
                            // Proximo da arvore e nao terminal.
                            // Buscar por esse nao terminal, no parsing.
                            // Enquanto o termo mais a esquerda for um nao terminal vai derivando.
                            while (RetornarCodigoNaoTerminal(ArvoreDerivacao[0]) != null)
                            {
                                NaoTerminal _chaveNaoTerminal = RetornarCodigoNaoTerminal(ArvoreDerivacao[0]);
                                Item        _itemRetornado    = VerificarPilhaParsingPorCodigo(_chaveNaoTerminal.Codigo);

                                // pegar recursao mais a esquerda.
                                string _recursaoEsquerda = _itemRetornado.Derivacao.Split('|')[0];

                                if (TokenController.PilhaTokenPrincipal[0].token.Simbolo.Equals(_recursaoEsquerda))
                                {
                                    ArvoreDerivacao.RemoveAt(0);
                                    CarregarArvoreDerivacao(_itemRetornado);
                                    _frmInicio.EscreverGrid(Convert.ToString(TokenController.PilhaTokenPrincipal[i].Linha), Convert.ToString(_itemRetornado.Codigo), Convert.ToString(_itemRetornado.Derivacao));
                                }
                                else
                                {
                                    ArvoreDerivacao.RemoveAt(0);
                                    ArvoreDerivacao.Insert(0, _recursaoEsquerda);
                                    _frmInicio.EscreverGrid(Convert.ToString(TokenController.PilhaTokenPrincipal[i].Linha), "0", Convert.ToString(_recursaoEsquerda));
                                }
                            }
                        }
                        else
                        {
                            _frmInicio.EscreverSaida("ERROS ENCONTRADOS >> Simbolo invalido conforme gramatica  | linha: " + TokenController.PilhaTokenPrincipal[i].Linha);
                            break;
                        }
                    }
                }

                i++;
            }

            #endregion
        }