Beispiel #1
0
        public void ReiniciarAnalizadorSintactico()
        {
            EstadoSintactico.Reiniciar();

            Pila          = new PilaGramatica(gramatica.SimboloInicial);
            CadenaEntrada = new CadenaEntrada();

            ArbolSemantico      = new ArbolSemantico(gramatica.SimboloInicial);
            Pila.ArbolSemantico = ArbolSemantico;

            finArch = false;
            cantErroresSintacticos = 0;
            cantParentesisAbiertos = 0;

            HabilitarSemantico = true;
        }
Beispiel #2
0
        internal List <ErrorCompilacion> AnalizarUnSoloPaso()
        {
            List <ErrorCompilacion> retorno = new List <ErrorCompilacion>();

            if (!(CadenaEntrada.EsFinDeCadena() && Pila.EsFinDePila()))
            {
                RellenarCadenaEntrada();

                if (Pila.ObtenerTope().GetType() == typeof(Terminal))
                {
                    Terminal term = (Terminal)Pila.ObtenerTope();

                    if (CadenaEntrada.ObtenerPrimerTerminal().Equals(Pila.ObtenerTope()))
                    {
                        if (term.Componente.Token == ComponenteLexico.TokenType.ParentesisApertura)
                        {
                            cantParentesisAbiertos++;
                        }
                        else if (term.Componente.Token == ComponenteLexico.TokenType.ParentesisClausura)
                        {
                            cantParentesisAbiertos--;
                        }

                        //flanzani 8/1/2012
                        //tokens repetidos
                        //Antes de pasar por el semantico, lo que hago es fijarme si el terminal justo no esta repetido,
                        //pq eso me caga todo el parseo de errores del sintactico
                        //Esto puede arrojar una excepcion sintactica
                        ChequearTokensRepetidosEnCadena(term);

                        if (HabilitarSemantico)
                        {
                            retorno = ArbolSemantico.CalcularAtributos(CadenaEntrada.ObtenerPrimerTerminal());
                        }

                        Pila.DescartarTope();

                        GlobalesCompilador.UltFila = CadenaEntrada.ObtenerPrimerTerminal().Componente.Fila;
                        GlobalesCompilador.UltCol  = CadenaEntrada.ObtenerPrimerTerminal().Componente.Columna;

                        EstadoSintactico.AgregarTerminal(term);

                        CadenaEntrada.EliminarPrimerTerminal();
                    }
                    else
                    {
                        if (term.NoEsLambda())
                        {
                            StringBuilder strbldr = new StringBuilder(string.Empty);
                            strbldr.Append("Se esperaba ");
                            strbldr.Append(EnumUtils.stringValueOf(term.Componente.Token));
                            strbldr.Append(" pero se encontro ");
                            strbldr.Append(EnumUtils.stringValueOf(CadenaEntrada.ObtenerPrimerTerminal().Componente.Token));
                            strbldr.Append(".");

                            if (term.Equals(Terminal.ElementoFinSentencia()))
                            {
                                //Descarto el ; de la pila pq asumo que simplemente se le olvido
                                strbldr.Append(" Se asume fin de sentencia para continuar con analisis.");
                            }

                            throw new ErrorSintacticoException(strbldr.ToString(),
                                                               AnalizadorLexico.FilaActual(),
                                                               AnalizadorLexico.ColumnaActual(),
                                                               true,
                                                               false,
                                                               false);
                        }
                        else
                        {
                            retorno = AnalizarPila();
                        }
                    }
                }
                else
                {
                    retorno = AnalizarPila();
                }
            }

            return(retorno);
        }