Esempio n. 1
0
 public void EvalProg(CNodo nodo)
 {
     if (nodo.Hijo != null)
     {
         EvalSentencia(nodo.Hijo.Hijo);
         CNodo siguienteProg = nodo.Hijo.Hermano.Hermano;
         if (siguienteProg.Hijo != null && !String.IsNullOrEmpty(siguienteProg.Hijo.Dato))
         {
             EvalProg(siguienteProg);
         }
     }
 }
Esempio n. 2
0
        public void EvalAsignacion(CNodo nodo)
        {
            CNodo nodoVariable  = nodo.Hijo;
            CNodo nodoExpresion = nodoVariable.Hermano.Hermano;

            if (mapaDatos.ContainsKey(nodoVariable.Dato))
            {
                mapaDatos[nodoVariable.Dato] = EvalExpresion(nodoExpresion);
            }
            else
            {
                mapaDatos.Add(nodoVariable.Dato, EvalExpresion(nodoExpresion));
            }
        }
Esempio n. 3
0
        public void EvalLeer(CNodo nodo)
        {
            String   mostrar        = nodo.Hijo.Hermano.Hermano.Dato;
            Double   valorIngresado = 0D;
            FormLeer formLeer       = new FormLeer(mostrar);

            formLeer.ShowDialog();
            if (String.IsNullOrEmpty(formLeer.ValorIngresado))
            {
                throw new ArgumentException("Debe de agregar un valor", "parametro");
            }
            Double.TryParse(formLeer.ValorIngresado, out valorIngresado);
            mapaDatos.Add(nodo.Hijo.Hermano.Hermano.Hermano.Hermano.Dato, valorIngresado);
        }
Esempio n. 4
0
        public List <String> EvalProgPrincipal(CArbol arbol)
        {
            listaMostrar = new List <String>();
            mapaDatos    = new Dictionary <String, Double>();
            CNodo nodoEncontrado = arbol.Buscar(SENT, arbol.Raiz);

            if (nodoEncontrado != null)
            {
                EvalSentencia(nodoEncontrado.Hijo);
                if (nodoEncontrado.Hermano.Hermano.Hijo != null)
                {
                    EvalProg(nodoEncontrado.Hermano.Hermano);
                }
            }
            return(listaMostrar);
        }
Esempio n. 5
0
        public Double EvalExpresion(CNodo nodo)
        {
            CNodo nodoTermino = nodo.Hijo;

            if (nodoTermino != null)
            {
                Double var1 = EvalTermino(nodoTermino);
                CNodo  nodoOperacionSumaResta = nodoTermino.Hermano.Hijo;
                if (nodoOperacionSumaResta != null && !String.IsNullOrEmpty(nodoOperacionSumaResta.Dato))
                {
                    Double var2 = EvalExpresion(nodoOperacionSumaResta.Hermano);
                    var1 += (nodoOperacionSumaResta.Dato == "+") ? var2 : (var2 * -1); //evalua expresion, si verdadero suma var2, else suma negativo var2
                }
                return(var1);
            }
            return(0D);
        }
Esempio n. 6
0
        public Double EvalFactor(CNodo nodo)//nodo dato, que puede ser num, id o exp
        {
            String Dato  = nodo.Dato;
            Double valor = 0D;

            if (!Double.TryParse(Dato, out valor))
            {
                if (Dato.First() == '(')
                {
                    valor = EvalExpresion(nodo.Hermano);
                }
                else
                {
                    mapaDatos.TryGetValue(Dato, out valor);
                }
            }
            else
            {
                Double.TryParse(Dato, out valor);
            }
            return(valor);
        }
Esempio n. 7
0
        public void EvalCondicional(CNodo nodo)
        {
            CNodo nodoIF   = nodo.Hijo;
            CNodo nodoProg = null;

            if (EvalCondicion(nodoIF.Hermano))
            {
                nodoProg = nodoIF.Hermano.Hermano.Hermano;
            }
            else
            {
                CNodo nodoSino = nodoIF.Hermano.Hermano.Hermano.Hermano;
                if (nodoSino != null)
                {
                    nodoProg = nodoSino.Hijo.Hermano;
                }
            }
            if (nodoProg != null)
            {
                EvalProg(nodoProg);
            }
        }
Esempio n. 8
0
 public Boolean EvalCondAnd(CNodo nodo)
 {
     return(EvalCondNot(nodo.Hijo) && EvalAnd(nodo.Hijo.Hermano));
 }
Esempio n. 9
0
 public Boolean EvalCondicion(CNodo nodo)
 {
     return(EvalCondAnd(nodo.Hijo) || EvalOr(nodo.Hijo.Hermano));
 }
Esempio n. 10
0
        public bool Analizar()           // devuelve true si la expresion es correcta , lexemas en orden obtenidos del lexer
        {
            int longlexemas = lexemas.Length;
            //puntero  para recorrer lexemas
            string tope   = Convert.ToString(pila.Peek());
            bool   estado = true; // es true mientras no haya dos terminales diferentes en tope y lexema[0]

            string[] terminales = tas.GetTerminales();

            String valorDato = "";

            while (tope != "$" && lexemas[0] != "$" && estado)  // mientras top sea diferente de fin y la lista no este vacia
            {
                if (lexemas[0].Contains("STRING@") || lexemas[0].Contains("id@") || lexemas[0].Contains("num@") || lexemas[0].Contains("oprel@"))
                {
                    String[] lexemaAux = lexemas[0].Split('@');
                    lexemas[0] = lexemaAux[0];
                    valorDato  = lexemaAux[1];
                }

                if (tope == lexemas[0]) // se van eliminando el primero del vector con lexemas
                {
                    eliminarPrimero();
                    pila.Pop();
                    tope = Convert.ToString(pila.Peek());
                }
                else if (EsTerminal(tope, terminales) && EsTerminal(lexemas[0], terminales) && tope != lexemas[0]) // para de analizar si tope != de lexema y ambos son terminales
                {
                    estado = false;
                }
                else
                {
                    int    poscolumna  = tas.PosicionTerminales(lexemas[0]); //fila lo del buffer de entrada
                    int    posfila     = tas.PosicionNoTerminales(tope);     // columna lo de a pila
                    string valorPosTas = tas.Elemento(posfila, poscolumna);
                    pila.Pop();                                              // desapila el top
                    nodoAux         = arbol.BuscarNoTratado(tope, raiz);     // busca el nodo no tratado para luego insertarle los hijos
                    nodoAux.Tratado = true;                                  // cambia el valor a true ya que va a insertar los datos en ese nodo
                    if (valorPosTas != null && (valorPosTas.Contains("READ") || valorPosTas.Contains("WRITE")))
                    {
                        String valorCampo       = lexemas[2].Split('@')[1];
                        String nombreId         = lexemas[4].Split('@')[1];
                        String nuevaValorPosTas = valorPosTas.Replace("STRING", valorCampo).Replace("id", nombreId);
                        CargarHojas(nuevaValorPosTas, nodoAux);
                    }
                    else if (valorPosTas != null && valorPosTas.Contains("id"))
                    {
                        String nuevaValorPosTas = valorPosTas.Replace("id", valorDato);
                        CargarHojas(nuevaValorPosTas, nodoAux);
                    }
                    else if (valorPosTas != null && valorPosTas.Contains("num"))
                    {
                        String nuevaValorPosTas = valorPosTas.Replace("num", valorDato);
                        CargarHojas(nuevaValorPosTas, nodoAux);
                    }
                    else if (valorPosTas != null && valorPosTas.Contains("oprel"))
                    {
                        String nuevaValorPosTas = valorPosTas.Replace("oprel", lexemas[1].Split('@')[1]);
                        CargarHojas(nuevaValorPosTas, nodoAux);
                    }
                    else
                    {
                        CargarHojas(valorPosTas, nodoAux); // carga en el arbol el valor de la tas
                    }
                    ApilarCampo(valorPosTas);              // apila lo correspondiente a la interseccion de fila y columna , si el valor es nulo no hace nada
                    tope = Convert.ToString(pila.Peek());
                }
            }
            if (tope != "$" && lexemas[0] == "$" && !EsTerminal(tope, terminales)) // verifica el epsilon del ante ultimo simbolo de la pila, si solo es no terminal
            {
                int    poscolumna  = tas.PosicionTerminales(lexemas[0]);           //fila lo del buffer de entrada
                int    posfila     = tas.PosicionNoTerminales(tope);               // columna lo de a pila
                string valorPosTas = tas.Elemento(posfila, poscolumna);
                pila.Pop();                                                        // desapila el top
                ApilarCampo(valorPosTas);                                          // apila lo correspondiente a la interseccion de fila y columna , si el valor es nulo no hace nada
                tope = Convert.ToString(pila.Peek());
            }
            if (tope == "$" && lexemas[0] == "$")
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }