Пример #1
0
        private bool ChequearQueNoSeEsteOperandoLaPilaParaUnErrorSintactico(Produccion prod)
        {
            bool retorno      = false;
            bool pararChequeo = false;

            if (prod.ProduceElementoVacio())
            {
                int posPila = 1;
                while (!(CadenaEntrada.EsFinDeCadena() && Pila.EsFinDePila()) && (Pila.Count > posPila) && !pararChequeo)
                {
                    if (Pila.ObtenerPosicion(posPila).GetType() == typeof(Terminal))
                    {
                        Terminal term = (Terminal)Pila.ObtenerPosicion(posPila);

                        if (CadenaEntrada.ObtenerPrimerTerminal().Equals(Pila.ObtenerPosicion(posPila)))
                        {
                            //No hay error pq coincide el terminal, y se va a poder descartar en el proximo paso.
                            retorno      = false;
                            pararChequeo = true;
                        }
                        else
                        {
                            if (term.NoEsLambda())
                            {
                                //Hay error pq el terminal no coindiria con el de la cadena de entrada.
                                retorno      = true;
                                pararChequeo = true;
                            }
                        }
                    }
                    else
                    {
                        Terminal   t  = CadenaEntrada.ObtenerPrimerTerminal();
                        NoTerminal nt = (NoTerminal)Pila.ObtenerPosicion(posPila);

                        bool generaProdVacia = false;

                        //Que es esto??
                        if (!PerteneceNoTerminalesNoEscapeables(nt))
                        {
                            generaProdVacia = gramatica.NoTerminalGeneraProduccionVacia(nt);
                        }

                        Produccion prodAux = tabla.BuscarEnTablaProduccion(nt, t, false, generaProdVacia);

                        if (prodAux != null)
                        {
                            if (prodAux.ProduceElementoVacio())
                            {
                                posPila++;
                            }
                            else
                            {
                                //Significa que llegue a algo concreto con el terminal que tengo en el tope, y dejo seguir.
                                retorno      = false;
                                pararChequeo = true;
                            }
                        }
                        else
                        {
                            //Significa que en la tabla ni figura, o sea que es un error
                            retorno      = true;
                            pararChequeo = true;
                        }
                    }
                }

                if (posPila > Pila.Count)
                {
                    //Hubo error pq el terminal tope no servia para nada de la pila
                    retorno = true;
                }
            }

            return(retorno);
        }
Пример #2
0
 public bool EsFinAnalisisSintactico()
 {
     return(CadenaEntrada.EsFinDeCadena() && Pila.EsFinDePila());
 }
Пример #3
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);
        }