Exemple #1
0
        static void Regla19(List <Simbolo> Mirilla)
        {
            foreach (Simbolo sim in Mirilla.ToList())
            {
                if (sim.Rol.Equals(Constante.ASIGNACION))
                {
                    FAsignacion3D asignacion = (FAsignacion3D)sim.Valor;

                    if (asignacion.Valor.Tipo.Equals(Constante.TDivision))
                    {
                        FNodoExpresion izq = asignacion.Valor.Izquierda;
                        FNodoExpresion der = asignacion.Valor.Derecha;

                        if (izq.Tipo.Equals(Constante.TEntero))
                        {
                            if (der.Tipo == Constante.TP || der.Tipo == Constante.Temporal || der.Tipo == Constante.TH)
                            {
                                if (izq.Entero == 0)
                                {
                                    asignacion.Valor = izq;
                                    TitusTools.InsertarReporteOptimizacion("Regla 19", asignacion.Temporal + " = 0 / " + der.Nombre + ";", sim.Fila, sim.Columna);
                                    //Mirilla.Remove(sim);
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #2
0
        static void Regla16(List <Simbolo> Mirilla)
        {
            foreach (Simbolo sim in Mirilla.ToList())
            {
                if (sim.Rol.Equals(Constante.ASIGNACION))
                {
                    FAsignacion3D asignacion = (FAsignacion3D)sim.Valor;

                    if (asignacion.Valor.Tipo.Equals(Constante.TPotenciaOCL))
                    {
                        FNodoExpresion izq = asignacion.Valor.Izquierda;
                        FNodoExpresion der = asignacion.Valor.Derecha;

                        if (der.Tipo.Equals(Constante.TEntero))
                        {
                            if (izq.Tipo == Constante.TP || izq.Tipo == Constante.Temporal || izq.Tipo == Constante.TH)
                            {
                                if (der.Entero == 2)
                                {
                                    asignacion.Valor = new FNodoExpresion(izq, izq, Constante.TPor, Constante.TPor, asignacion.Valor.Fila, asignacion.Valor.Columna, null);
                                    TitusTools.InsertarReporteOptimizacion("Regla 16", asignacion.Temporal + " = " + izq.Nombre + " ^ 2;", sim.Fila, sim.Columna);
                                    //Mirilla.Remove(sim);
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #3
0
        static void Regla11(List <Simbolo> Mirilla)
        {
            foreach (Simbolo sim in Mirilla.ToList())
            {
                if (sim.Rol.Equals(Constante.ASIGNACION))
                {
                    FAsignacion3D asignacion = (FAsignacion3D)sim.Valor;
                    if (asignacion.Tipo.Equals(Constante.Temporal))
                    {
                        if (asignacion.Valor.Tipo.Equals(Constante.TDivision))
                        {
                            FNodoExpresion izq = asignacion.Valor.Izquierda;
                            FNodoExpresion der = asignacion.Valor.Derecha;

                            if (izq != null)
                            {
                                if (izq.Tipo.Equals(Constante.TEntero) || der.Tipo.Equals(Constante.TEntero))
                                {
                                    if (izq.Tipo == Constante.Temporal && asignacion.Temporal.Equals(izq.Nombre))
                                    {
                                        if (der.Entero == 1)
                                        {
                                            TitusTools.InsertarReporteOptimizacion("Regla 11", asignacion.Temporal + " = " + izq.Nombre + " / 1;", sim.Fila, sim.Columna);
                                            Mirilla.Remove(sim);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #4
0
        public String Generar3DOptimizadoAsignacion()
        {
            String        cadena = "";
            FAsignacion3D asig   = (FAsignacion3D)Valor;

            cadena = asig.Generar3DOptimizado();
            return(cadena);
        }
Exemple #5
0
        static void Regla1(List <Simbolo> Mirilla)
        {
            FAsignacion3D anterior = null;

            foreach (Simbolo sim in Mirilla.ToList())
            {
                if (sim.Rol.Equals(Constante.ASIGNACION))
                {
                    FAsignacion3D asignacion = (FAsignacion3D)sim.Valor;

                    if (asignacion.Tipo.Equals(Constante.Temporal))
                    {
                        if (asignacion.Valor.Izquierda == null && asignacion.Valor.Derecha == null)
                        {
                            if (anterior != null)
                            {
                                if (anterior.Temporal.Equals(asignacion.Valor.Nombre) && anterior.Valor.Nombre.Equals(asignacion.Temporal))
                                {
                                    TitusTools.InsertarReporteOptimizacion("Regla 1", anterior.Temporal + " = " + anterior.Valor.Nombre + " <=> " + asignacion.Temporal + " = " + asignacion.Valor.Nombre, sim.Fila, sim.Columna);
                                    Mirilla.Remove(sim);
                                }
                            }
                            else
                            {
                                anterior = asignacion;
                            }
                        }
                        else
                        {
                            anterior = null;
                        }
                    }
                    else
                    {
                        anterior = null;
                    }
                }
                else
                {
                    anterior = null;
                }
            }
        }
Exemple #6
0
 public static void InsertarAmbito(Ambito ambito)
 {
     //insertamos el tope de ambito
     Tabla.Add(new Variable(Constante.Tope, Constante.Tope, 0, 0, null, null));
     foreach (Simbolo sim in ambito.TablaSimbolo)
     {
         if (sim.Rol.Equals(Constante.ASIGNACION))
         {
             FAsignacion3D asignacion = (FAsignacion3D)sim.Valor;
             if (asignacion.Tipo.Equals(Constante.Temporal))
             {
                 if (!ExisteVariable(asignacion.Temporal))
                 {
                     InsertarVariable(new Variable(asignacion.Temporal, Constante.Id, 0, 0, null, null));
                 }
             }
         }
     }
 }
        public static Object RecorrerArbol(ParseTreeNode Nodo)
        {
            switch (Nodo.Term.Name)
            {
            case Constante.INICIO:
            {
                //LISTA_CLASE;
                List <Simbolo> clases = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[0]);
                Ambito         ambito = new Ambito(Constante.ARCHIVO, clases);


                Ejecucion3D ArchivoEjecucion = new Ejecucion3D(ambito);
                return(ArchivoEjecucion);
            }

            case Constante.LISTA_SENTENCIAS:
            {
                List <Simbolo> tabla = new List <Simbolo>();
                if (Nodo.ChildNodes.Count > 0)
                {
                    tabla = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[0]);
                }
                return(tabla);
            }

            case Constante.LISTA_SENTENCIA:
            {
                List <Simbolo> tabla = new List <Simbolo>();
                foreach (ParseTreeNode nodo in Nodo.ChildNodes)
                {
                    foreach (Simbolo sim in (List <Simbolo>)RecorrerArbol(nodo))
                    {
                        tabla.Add(sim);
                    }
                }
                return(tabla);
            }

            case Constante.SENTENCIA:
            {
                List <Simbolo> lista = new List <Simbolo>();
                if (Nodo.ChildNodes.Count == 2)
                {
                    List <Simbolo> cuerpo = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[1]);
                    FMetodo        metodo = new FMetodo(Constante.TPublico, Constante.TMain, Constante.TMain, new List <Simbolo>(), new Ambito(Constante.TMain, cuerpo), Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1);
                    Simbolo        s      = new Simbolo(metodo.Visibilidad, metodo.Tipo, metodo.Nombre, Constante.TMain, metodo.Fila, metodo.Columna, metodo.Ambito, metodo);

                    Simbolo anterior = null;

                    foreach (Simbolo sim in metodo.Ambito.TablaSimbolo)
                    {
                        sim.Anterior = anterior;
                        if (anterior != null)
                        {
                            anterior.Siguiente = sim;
                            sim.Anterior       = anterior;
                        }

                        anterior = sim;
                    }

                    lista.Add(s);
                }
                else
                {
                    List <Simbolo> cuerpo = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[2]);
                    FMetodo        metodo = new FMetodo(Constante.TPublico, Constante.TVoid, Nodo.ChildNodes[1].Token.ValueString, new List <Simbolo>(), new Ambito(Constante.TMain, cuerpo), Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1);
                    Simbolo        s      = new Simbolo(metodo.Visibilidad, metodo.Tipo, metodo.Nombre, Constante.TMetodo, metodo.Fila, metodo.Columna, metodo.Ambito, metodo);

                    Simbolo anterior = null;

                    foreach (Simbolo sim in metodo.Ambito.TablaSimbolo)
                    {
                        sim.Anterior = anterior;
                        if (anterior != null)
                        {
                            anterior.Siguiente = sim;
                            sim.Anterior       = anterior;
                        }

                        anterior = sim;
                    }

                    lista.Add(s);
                }
                return(lista);
            }

            case Constante.LISTA_INSTRUCCIONES:
            {
                List <Simbolo> tabla = new List <Simbolo>();
                if (Nodo.ChildNodes.Count > 0)
                {
                    tabla = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[0]);
                }
                return(tabla);
            }

            case Constante.LISTA_INSTRUCCION:
            {
                List <Simbolo> tabla = new List <Simbolo>();
                foreach (ParseTreeNode nodo in Nodo.ChildNodes)
                {
                    Simbolo sim = (Simbolo)RecorrerArbol(nodo);

                    tabla.Add(sim);
                }
                return(tabla);
            }

            case Constante.INSTRUCCION:
            {
                if (Nodo.ChildNodes.Count == 1)
                {
                    switch (Nodo.ChildNodes[0].Term.Name)
                    {
                    case Constante.Etiqueta:
                        return(new Simbolo(Constante.TPublico, Constante.Etiqueta, Nodo.ChildNodes[0].Token.ValueString, Constante.Etiqueta, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.Etiqueta), null));

                    case Constante.Id:
                        return(new Simbolo(Constante.TPublico, Constante.LLAMADA_METODO, Nodo.ChildNodes[0].Token.ValueString, Constante.LLAMADA_METODO, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.LLAMADA_METODO), null));

                    default:
                        return(RecorrerArbol(Nodo.ChildNodes[0]));
                    }
                }
                else if (Nodo.ChildNodes.Count == 2)
                {
                    if (Nodo.ChildNodes[0].Token.ValueString.Equals(Constante.TGoto))
                    {
                        return(new Simbolo(Constante.TPublico, Constante.TGoto, Nodo.ChildNodes[1].Token.ValueString, Constante.TGoto, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TGoto), null));
                    }
                    else
                    {
                        return(new Simbolo(Constante.TPublico, Constante.TError, Nodo.ChildNodes[1].Token.ValueString, Constante.TError, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TError), null));
                    }
                }
                else if (Nodo.ChildNodes.Count == 3)
                {
                    String  tipo  = (String)RecorrerArbol(Nodo.ChildNodes[1]);
                    String  temp  = Nodo.ChildNodes[2].Token.ValueString;
                    FPrint  print = new FPrint(tipo, temp);
                    Simbolo sim   = new Simbolo(Constante.TPublico, Constante.TPrint, Constante.TPrint, Constante.TPrint, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TPrint), print);
                    print.Padre = sim;
                    return(sim);
                }
                else
                {
                    String Tipo = Constante.TIf;
                    if (Nodo.ChildNodes[0].Term.Name.Equals(Constante.TIfFalse))
                    {
                        Tipo = Constante.TIfFalse;
                    }
                    FNodoExpresion cond = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[1]);
                    String         etq  = Nodo.ChildNodes[3].Token.ValueString;

                    FIf     si  = new FIf(Tipo, cond, etq);
                    Simbolo sim = new Simbolo(Constante.TPublico, Constante.TIf, Constante.TIf, Constante.TIf, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TIf), si);
                    si.Padre = sim;
                    return(sim);
                }
            }

            case Constante.ASIGNACION:
                if (Nodo.ChildNodes.Count == 2)
                {
                    if (Nodo.ChildNodes[0].Term.Name.Equals(Constante.Temporal))
                    {
                        FNodoExpresion val = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[1]);
                        FAsignacion3D  asi = new FAsignacion3D(Constante.Temporal, null, val, Nodo.ChildNodes[0].Token.ValueString);
                        Simbolo        sim = new Simbolo(Constante.TPublico, Constante.ASIGNACION, Constante.ASIGNACION, Constante.ASIGNACION, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.ASIGNACION), asi);

                        return(sim);
                    }
                    else
                    {
                        FNodoExpresion val = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[1]);
                        FAsignacion3D  asi = new FAsignacion3D(Nodo.ChildNodes[0].Term.Name, null, val, "");
                        Simbolo        sim = new Simbolo(Constante.TPublico, Constante.ASIGNACION, Constante.ASIGNACION, Constante.ASIGNACION, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.ASIGNACION), asi);

                        return(sim);
                    }
                }
                else
                {
                    FNodoExpresion acceos = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[1]);
                    FNodoExpresion val    = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[2]);
                    FAsignacion3D  asi    = new FAsignacion3D(Nodo.ChildNodes[0].Token.ValueString, acceos, val, "");
                    Simbolo        sim    = new Simbolo(Constante.TPublico, Constante.ASIGNACION, Constante.ASIGNACION, Constante.ASIGNACION, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.ASIGNACION), asi);

                    return(sim);
                }

            case Constante.TPrint:
                return(Nodo.ChildNodes[0].Term.Name);


            case Constante.RELACIONAL:
            {
                FNodoExpresion izq = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[0]);
                FNodoExpresion der = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[2]);
                return(new FNodoExpresion(izq, der, Nodo.ChildNodes[1].Token.ValueString, Nodo.ChildNodes[1].Token.ValueString, Nodo.ChildNodes[1].Token.Location.Line + 1, Nodo.ChildNodes[1].Token.Location.Column + 1, null));
            }

            case Constante.ARITMETICA:

                if (Nodo.ChildNodes.Count == 3)
                {
                    FNodoExpresion izq = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[0]);
                    FNodoExpresion der = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[2]);
                    return(new FNodoExpresion(izq, der, Nodo.ChildNodes[1].Token.ValueString, Nodo.ChildNodes[1].Token.ValueString, Nodo.ChildNodes[1].Token.Location.Line + 1, Nodo.ChildNodes[1].Token.Location.Column + 1, null));
                }
                else
                {
                    if (Nodo.ChildNodes[0].Term.Name.Equals(Constante.TMenos))
                    {
                        FNodoExpresion der = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[1]);
                        return(new FNodoExpresion(null, der, Nodo.ChildNodes[0].Token.ValueString, Nodo.ChildNodes[0].Token.ValueString, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, null));
                    }
                    else if (Nodo.ChildNodes[0].Term.Name.Equals(Constante.THeap))
                    {
                        FNodoExpresion der = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[1]);
                        return(new FNodoExpresion(null, der, Constante.THeap, Constante.THeap, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, null));
                    }
                    else
                    {
                        FNodoExpresion der = (FNodoExpresion)RecorrerArbol(Nodo.ChildNodes[1]);
                        return(new FNodoExpresion(null, der, Constante.TStack, Constante.TStack, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, null));
                    }
                }

            case Constante.EXP:
            {
                return(RecorrerArbol(Nodo.ChildNodes[0]));
            }

            case Constante.Entero:
                return(new FNodoExpresion(null, null, Constante.TEntero, Constante.TEntero, Nodo.Token.Location.Line + 1, Nodo.Token.Location.Column + 1, Nodo.Token.ValueString));

            case Constante.Decimal:
                return(new FNodoExpresion(null, null, Constante.TDecimal, Constante.TDecimal, Nodo.Token.Location.Line + 1, Nodo.Token.Location.Column + 1, Nodo.Token.ValueString));

            case Constante.TH:
                return(new FNodoExpresion(null, null, Constante.TH, Constante.TH, Nodo.Token.Location.Line + 1, Nodo.Token.Location.Column + 1, Nodo.Token.ValueString));

            case Constante.TP:
                return(new FNodoExpresion(null, null, Constante.TP, Constante.TP, Nodo.Token.Location.Line + 1, Nodo.Token.Location.Column + 1, Nodo.Token.ValueString));

            case Constante.Temporal:
                return(new FNodoExpresion(null, null, Constante.Temporal, Nodo.Token.ValueString, Nodo.Token.Location.Line + 1, Nodo.Token.Location.Column + 1, Nodo.Token.ValueString));
            }
            return(null);
        }