Ejemplo n.º 1
0
        public String Generar3DInit()
        {
            String temp = TitusTools.GetTemp();
            String init = "void init_" + this.Nombre + "(){\n";

            init += "\t\t" + temp + " = H;\n";
            int sizeherencia = Ambito.Tamaño;

            String init3 = "";

            foreach (Simbolo sim in Ambito.TablaSimbolo)
            {
                if (sim.Rol.Equals(Constante.DECLARACION))
                {
                    FDeclaracion decla = (FDeclaracion)sim.Valor;
                    init3 += decla.Generar3DInit(temp, 0);
                }
            }

            //buscamos los init de los hereda

            if (!Herencia.Equals(""))
            {
                String herencia = Herencia;
                while (herencia != "")
                {
                    Simbolo clase = Padre.BuscarClase(herencia, ArchivoPadre);
                    if (clase != null)
                    {
                        FClase nuevaclase = (FClase)clase.Valor;
                        foreach (Simbolo sim in nuevaclase.Ambito.TablaSimbolo)
                        {
                            if (sim.Rol.Equals(Constante.DECLARACION))
                            {
                                FDeclaracion decla = (FDeclaracion)sim.Valor;
                                init3 += decla.Generar3DInit(temp, sizeherencia);
                            }
                        }
                        sizeherencia += nuevaclase.Ambito.Tamaño;
                        herencia      = nuevaclase.Herencia;
                    }
                    else
                    {
                        TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro la clase para heredar " + herencia, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
                        break;
                    }
                }
            }

            String init2 = "\t\t" + "H = H + " + sizeherencia.ToString() + ";\n";

            init += init2 + init3;

            init += "}\n\n";
            return(init);
        }
Ejemplo n.º 2
0
        private String GenerarRetornar()
        {
            String  cadena      = "";
            Nodo3D  val         = ((FNodoExpresion)Valor).Generar3D();
            Simbolo metodopadre = BuscarMetodoPadre();
            FMetodo met         = (FMetodo)metodopadre.Valor;
            String  tipometodo  = metodopadre.Tipo;

            if (met.Dimensiones > 0)
            {
                tipometodo = "arreglo " + tipometodo;
            }

            if (val.Tipo.Equals(Constante.TBooleano))
            {
                if (val.V == "" && val.F == "")
                {//si trae etiquetas viene de una relacional si no es un bool nativo
                }
                else
                {
                    var cad = "";

                    var auxtemp = TitusTools.GetTemp();
                    var salida  = TitusTools.GetEtq();

                    cad += "\t" + val.V + ":\n";
                    cad += "\t\t" + auxtemp + " = 1;\n";
                    cad += "\t\t" + "goto " + salida + ";\n";
                    cad += "\t" + val.F + ":\n";
                    cad += "\t\t" + auxtemp + " = 0;\n";
                    cad += "\t" + salida + ":\n";

                    val.Valor  = auxtemp;
                    cad       += "\t\t" + val.Valor + " =  - " + auxtemp + ";\n";
                    val.Codigo = val.Codigo + cad;
                }
            }

            if (tipometodo.Equals(val.Tipo))
            {
                String retorno = TitusTools.GetTemp();
                cadena += val.Codigo;
                cadena += "\t\t" + retorno + " = P + 1;//Posicion de retorno\n";
                cadena += "\t\t" + "Stack[" + retorno + "] = " + val.Valor + ";//Asignacion de retorno\n";

                cadena += "\t\t§retornar§;\n";
            }
            else
            {
                TitusTools.InsertarError(Constante.TErrorSemantico, "El metodo " + met.Nombre + " solo puede retornar un tipo " + tipometodo + ", no un tipo " + val.Tipo, TitusTools.GetRuta(), Fila, Columna);
            }


            return(cadena);
        }
Ejemplo n.º 3
0
        public String Generar3D()
        {
            String cadena = "";

            Nodo3D val = Valor.Generar3D();

            cadena += val.Codigo;
            switch (val.Tipo)
            {
            case Constante.TCadena:
            {
                String temp = TitusTools.GetTemp();
                String etq  = TitusTools.GetEtq();

                cadena += "\t" + etq + "://comienza imprimir\n";
                cadena += "\t\t" + temp + " = " + "Heap[" + val.Valor + "];\n";
                cadena += "\t\t" + "print(\"%c\", " + temp + ");\n";
                cadena += "\t\t" + val.Valor + " = " + val.Valor + " + 1 ;\n";
                cadena += "\t\t" + "if " + temp + " != 0 goto " + etq + ";//Termina imprimir\n";
            }
            break;

            case Constante.TCaracter:
            {
                cadena += "\t\t" + "print(\"%c\", " + val.Valor + ");//Termina imprimir\n";
            }
            break;

            case Constante.TEntero:
            {
                cadena += "\t\t" + "print(\"%d\", " + val.Valor + ");//Termina imprimir\n";
            }
            break;

            case Constante.TDecimal:
            {
                cadena += "\t\t" + "print(\"%f\", " + val.Valor + ");//Termina imprimir\n";
            }
            break;

            default:
                TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede imprimir un tipo " + val.Tipo, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
                break;
            }

            return(cadena);
        }
Ejemplo n.º 4
0
        public String GenerarPrincipal3D()
        {
            String  cadena     = "";
            String  temp       = TitusTools.GetTemp();
            Simbolo clasePadre = Padre.BuscarClasePadre();

            cadena += "main(){\n";
            cadena += "\t\t" + temp + " = P + 0;\n";
            cadena += "\t\t" + "Stack[" + temp + "] = H;\n";
            cadena += "\t\t" + "init_" + clasePadre.Nombre + "();\n";
            foreach (Simbolo simbolo in Ambito.TablaSimbolo)
            {
                cadena += simbolo.Generar3D();
            }

            cadena += "}\n\n";
            return(cadena);
        }
Ejemplo n.º 5
0
        public String Generar3D()
        {
            String cadena = "\t//comienza asignacion\n";

            if (Tipo.Equals(Constante.LLAMADA_OBJETO))
            {
                Nodo3D izq = Nombre.Generar3DAsginacion();
                Nodo3D val = Valor.Generar3D();
                cadena += izq.Codigo;
                cadena += val.Codigo;
                if (!TitusTools.HayErrores())
                {
                    switch (izq.Tipo)
                    {
                    case Constante.TEntero:
                    {
                        switch (val.Tipo)
                        {
                        case Constante.TEntero:
                        {
                            cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TCaracter:
                        {
                            cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TBooleano:
                        {
                            if (val.V == "" && val.F == "")
                            {                //si trae etiquetas viene de una relacional si no es un bool nativo
                                cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                            }
                            else
                            {
                                var auxtemp = TitusTools.GetTemp();
                                var salida  = TitusTools.GetEtq();

                                cadena += "\t" + val.V + ":\n";
                                cadena += "\t\t" + auxtemp + " = 1;\n";
                                cadena += "\t\t" + "goto " + salida + ";\n";
                                cadena += "\t" + val.F + ":\n";
                                cadena += "\t\t" + auxtemp + " = 0;\n";
                                cadena += "\t" + salida + ":\n";

                                cadena += "\t\t" + izq.Valor + " = " + auxtemp + ";\n";
                            }
                        }
                        break;

                        default:
                        {
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede  asignar un valor " + val.Tipo + " a una variable " + izq.Tipo, TitusTools.GetRuta(), this.Padre.Fila, this.Padre.Columna);
                        }
                        break;
                        }
                    }
                    break;

                    case Constante.TDecimal:
                    {
                        switch (val.Tipo)
                        {
                        case Constante.TEntero:
                        {
                            cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TDecimal:
                        {
                            cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TCaracter:
                        {
                            cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TBooleano:
                        {
                            if (val.V == "" && val.F == "")
                            {                //si trae etiquetas viene de una relacional si no es un bool nativo
                                cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                            }
                            else
                            {
                                var auxtemp = TitusTools.GetTemp();
                                var salida  = TitusTools.GetEtq();

                                cadena += "\t" + val.V + ":\n";
                                cadena += "\t\t" + auxtemp + " = 1;\n";
                                cadena += "\t\t" + "goto " + salida + ";\n";
                                cadena += "\t" + val.F + ":\n";
                                cadena += "\t\t" + auxtemp + " = 0;\n";
                                cadena += "\t" + salida + ":\n";

                                cadena += "\t\t" + izq.Valor + " = " + auxtemp + ";\n";
                            }
                        }
                        break;

                        default:
                        {
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede  asignar un valor " + val.Tipo + " a una variable " + izq.Tipo, TitusTools.GetRuta(), this.Padre.Fila, this.Padre.Columna);
                        }
                        break;
                        }
                    }
                    break;

                    case Constante.TCaracter:
                    {
                        switch (val.Tipo)
                        {
                        case Constante.TEntero:
                        {
                            cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TCaracter:
                        {
                            cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                        }
                        break;

                        default:
                        {
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede  asignar un valor " + val.Tipo + " a una variable " + izq.Tipo, TitusTools.GetRuta(), this.Padre.Fila, this.Padre.Columna);
                        }
                        break;
                        }
                    }
                    break;

                    case Constante.TCadena:
                    {
                        switch (val.Tipo)
                        {
                        case Constante.TCadena:
                        {
                            cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                        }
                        break;

                        default:
                        {
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede  asignar un valor " + val.Tipo + " a una variable " + izq.Tipo, TitusTools.GetRuta(), this.Padre.Fila, this.Padre.Columna);
                        }
                        break;
                        }
                    }
                    break;

                    case Constante.TBooleano:
                    {
                        switch (val.Tipo)
                        {
                        case Constante.TBooleano:
                        {
                            if (val.V == "" && val.F == "")
                            {                //si trae etiquetas viene de una relacional si no es un bool nativo
                                cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                            }
                            else
                            {
                                var auxtemp = TitusTools.GetTemp();
                                var salida  = TitusTools.GetEtq();

                                cadena += "\t" + val.V + ":\n";
                                cadena += "\t\t" + auxtemp + " = 1;\n";
                                cadena += "\t\t" + "goto " + salida + ";\n";
                                cadena += "\t" + val.F + ":\n";
                                cadena += "\t\t" + auxtemp + " = 0;\n";
                                cadena += "\t" + salida + ":\n";

                                cadena += "\t\t" + izq.Valor + " = " + auxtemp + ";\n";
                            }
                        }
                        break;

                        default:
                        {
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede  asignar un valor " + val.Tipo + " a una variable " + izq.Tipo, TitusTools.GetRuta(), this.Padre.Fila, this.Padre.Columna);
                        }
                        break;
                        }
                    }
                    break;

                    default:
                    {
                        if (izq.Tipo.Equals(val.Tipo))
                        {
                            cadena += "\t\t" + izq.Valor + " = " + val.Valor + ";\n";
                        }
                        else
                        {
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede  asignar un valor " + val.Tipo + " a una variable " + izq.Tipo, TitusTools.GetRuta(), this.Padre.Fila, this.Padre.Columna);
                        }
                    }
                    break;
                    }
                }
            }
            else
            {
                if (this.Operacion.Tipo.Equals(Constante.LLAMADA_OBJETO))
                {
                    Nodo3D nodo = this.Operacion.LlamadaObjeto.Generar3DAsginacion();
                    if (nodo.Tipo.Equals(Constante.TEntero) || nodo.Tipo.Equals(Constante.TDecimal) || nodo.Tipo.Equals(Constante.TCaracter))
                    {
                        cadena += nodo.Codigo;
                        String temp     = TitusTools.GetTemp();
                        String tempcosa = TitusTools.GetTemp();
                        cadena += "\t\t" + temp + " = " + nodo.Valor + ";\n";
                        if (Tipo.Equals(Constante.TAumento))
                        {
                            cadena += "\t\t" + tempcosa + " = " + temp + " + 1;\n";
                        }
                        else
                        {
                            cadena += "\t\t" + tempcosa + " = " + temp + " - 1;\n";
                        }
                        cadena += "\t\t" + nodo.Valor + " = " + tempcosa + ";\n";
                    }
                }
                else
                {
                    TitusTools.InsertarError(Constante.TErrorSemantico, "Solo se puede hacer aumento o decremento a una variable", TitusTools.GetRuta(), this.Padre.Fila, this.Padre.Columna);
                }
            }
            cadena += "\t//termina asignacion\n";
            return(cadena);
        }
Ejemplo n.º 6
0
        private Nodo3D Relacional3D(Nodo3D izq, FNodoExpresion der, int Fila, int Columna)
        {
            var codigo3d = new Nodo3D();
            var auxder   = der.Generar3D();

            if (!TitusTools.HayErrores())
            {
                switch (izq.Tipo)
                {
                case Constante.TEntero:
                {
                    switch (auxder.Tipo)
                    {
                    case Constante.TEntero:
                    {
                        String cad = "";
                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "ifFalse " + izq.Valor + " " + "==" + " " + auxder.Valor + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    case Constante.TDecimal:
                    {
                        String cad = "";
                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "ifFalse " + izq.Valor + " " + "==" + " " + auxder.Valor + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    case Constante.TCaracter:
                    {
                        String cad = "";

                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "ifFalse " + izq.Valor + " " + "==" + " " + auxder.Valor + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    default:
                        TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede " + izq.Tipo + " " + "==" + " " + auxder.Tipo, TitusTools.GetRuta(), Fila, Columna);
                        break;
                    }
                }
                break;

                case Constante.TDecimal:
                {
                    switch (auxder.Tipo)
                    {
                    case Constante.TEntero:
                    {
                        String cad = "";

                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "ifFalse " + izq.Valor + " " + "==" + " " + auxder.Valor + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    case Constante.TDecimal:
                    {
                        String cad = "";

                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "if " + izq.Valor + " " + "==" + " " + auxder.Valor + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    case Constante.TCaracter:
                    {
                        String cad = "";

                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "if " + izq.Valor + " " + "==" + " " + auxder.Valor + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    default:
                        TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede " + izq.Tipo + " " + "==" + " " + auxder.Tipo, TitusTools.GetRuta(), Fila, Columna);
                        break;
                    }
                }
                break;

                case Constante.TCaracter:
                {
                    switch (auxder.Tipo)
                    {
                    case Constante.TEntero:
                    {
                        String cad = "";

                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "if " + izq.Valor + " " + "==" + " " + auxder.Valor + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    case Constante.TDecimal:
                    {
                        String cad = "";

                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "if " + izq.Valor + " " + "==" + " " + auxder.Valor + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    case Constante.TCaracter:
                    {
                        String cad = "";

                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "if " + izq.Valor + " " + "==" + " " + auxder.Valor + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    case Constante.TCadena:
                    {
                        String cad = "";

                        String etqcad1 = TitusTools.GetEtq();
                        String etqcad2 = TitusTools.GetEtq();

                        String tempascii2 = TitusTools.GetTemp();
                        String tempcad2   = TitusTools.GetTemp();

                        cad += "\t\t" + tempascii2 + " = 0 ;\n";
                        cad += "\t" + etqcad1 + ":\n";
                        cad += "\t\t" + tempcad2 + " = Heap[" + auxder.Valor + "];\n";
                        cad += "\t\t" + "if " + tempcad2 + " == 0 goto " + etqcad2 + ";\n";
                        cad += "\t\t" + tempascii2 + " = " + tempascii2 + " + " + tempcad2 + ";\n";
                        cad += "\t\t" + auxder.Valor + " = " + auxder.Valor + " + 1;\n";
                        cad += "\t\t" + "goto " + etqcad1 + ";\n";
                        cad += "\t" + etqcad2 + ":\n";

                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "if " + izq.Valor + " " + "==" + " " + tempascii2 + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    default:
                        TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede " + izq.Tipo + " " + "==" + " " + auxder.Tipo, TitusTools.GetRuta(), Fila, Columna);
                        break;
                    }
                }
                break;

                case Constante.TCadena:
                {
                    switch (auxder.Tipo)
                    {
                    case Constante.TCaracter:
                    {
                        String cad = "";

                        String tempascii1 = TitusTools.GetTemp();
                        String tempcad1   = TitusTools.GetTemp();
                        String etqcad1    = TitusTools.GetEtq();
                        String etqcad2    = TitusTools.GetEtq();

                        cad += "\t\t" + tempascii1 + " = 0 ;\n";
                        cad += "\t" + etqcad1 + ":\n";
                        cad += "\t\t" + tempcad1 + " = Heap[" + izq.Valor + "];\n";
                        cad += "\t\t" + "if " + tempcad1 + " == 0 goto " + etqcad2 + ";\n";
                        cad += "\t\t" + tempascii1 + " = " + tempascii1 + " + " + tempcad1 + ";\n";
                        cad += "\t\t" + izq.Valor + " = " + izq.Valor + " + 1;\n";
                        cad += "\t\t" + "goto " + etqcad1 + ";\n";
                        cad += "\t" + etqcad2 + ":\n";

                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "if " + tempascii1 + " " + "==" + " " + auxder.Valor + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    case Constante.TCadena:
                    {
                        String cad = "";

                        String tempascii1 = TitusTools.GetTemp();
                        String tempcad1   = TitusTools.GetTemp();
                        String etqcad1    = TitusTools.GetEtq();
                        String etqcad2    = TitusTools.GetEtq();

                        cad += "\t\t" + tempascii1 + " = 0 ;\n";
                        cad += "\t" + etqcad1 + ":\n";
                        cad += "\t\t" + tempcad1 + " = Heap[" + izq.Valor + "];\n";
                        cad += "\t\t" + "if " + tempcad1 + " == 0 goto " + etqcad2 + ";\n";
                        cad += "\t\t" + tempascii1 + " = " + tempascii1 + " + " + tempcad1 + ";\n";
                        cad += "\t\t" + izq.Valor + " = " + izq.Valor + " + 1;\n";
                        cad += "\t\t" + "goto " + etqcad1 + ";\n";
                        cad += "\t" + etqcad2 + ":\n";

                        String tempascii2 = TitusTools.GetTemp();
                        String tempcad2   = TitusTools.GetTemp();
                        etqcad1 = TitusTools.GetEtq();
                        etqcad2 = TitusTools.GetEtq();

                        cad += "\t\t" + tempascii2 + " = 0 ;\n";
                        cad += "\t" + etqcad1 + ":\n";
                        cad += "\t\t" + tempcad2 + " = Heap[" + auxder.Valor + "];\n";
                        cad += "\t\t" + "if " + tempcad2 + " == 0 goto " + etqcad2 + ";\n";
                        cad += "\t\t" + tempascii2 + " = " + tempascii2 + " + " + tempcad2 + ";\n";
                        cad += "\t\t" + auxder.Valor + " = " + auxder.Valor + " + 1;\n";
                        cad += "\t\t" + "goto " + etqcad1 + ";\n";
                        cad += "\t" + etqcad2 + ":\n";

                        codigo3d.F = TitusTools.GetEtq();

                        cad += "\t\t" + "if " + tempascii1 + " " + "==" + " " + tempascii2 + " goto " + codigo3d.F + ";\n";

                        codigo3d.Codigo = auxder.Codigo + cad;

                        codigo3d.Tipo = Constante.TBooleano;
                    }
                    break;

                    default:
                        TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede " + izq.Tipo + " " + "==" + " " + auxder.Tipo, TitusTools.GetRuta(), Fila, Columna);
                        break;
                    }
                }
                break;
                }
            }
            return(codigo3d);
        }
Ejemplo n.º 7
0
        public Nodo3D Generar3DSuperAsignacion(String temporal)
        {
            Nodo3D nodo = new Nodo3D();

            String cadena = "";

            Simbolo simulacion = Padre.BuscarMetodoPadre();

            String tempsimulacion = TitusTools.GetTemp();

            cadena += "\t\t" + tempsimulacion + " = P + " + (simulacion.Ambito.Tamaño).ToString() + ";//simulacion de cambio de ambito \n";


            List <Nodo3D> resueltas = new List <Nodo3D>();

            int i = 2;

            foreach (FNodoExpresion p in this.Parametros)
            {
                String temporalstack = TitusTools.GetTemp();

                cadena += "\t\t" + temporalstack + " = " + tempsimulacion + " + " + i.ToString() + ";\n";
                Nodo3D r = p.Generar3D();
                if (r.Tipo.Equals(Constante.TBooleano))//conversion siviene de una relacional
                {
                    if (r.V == "" && r.F == "")
                    {//si trae etiquetas viene de una relacional si no es un bool nativo
                    }
                    else
                    {
                        var cad = "";

                        var auxtemp = TitusTools.GetTemp();
                        var salida  = TitusTools.GetEtq();

                        cad += "\t" + r.V + ":\n";
                        cad += "\t\t" + auxtemp + " = 1;\n";
                        cad += "\t\t" + "goto " + salida + ";\n";
                        cad += "\t" + r.F + ":\n";
                        cad += "\t\t" + auxtemp + " = 0;\n";
                        cad += "\t" + salida + ":\n";

                        r.Valor  = auxtemp;
                        r.Codigo = r.Codigo + cad;
                    }
                }


                cadena += r.Codigo;
                resueltas.Add(r);

                //ahora asignamos al stack el valor resuelto
                cadena += "\t\t" + "Stack[" + temporalstack + "] = " + r.Valor + ";//Asignacino del parametro\n";

                i++;
            }

            if (!TitusTools.HayErrores())
            {
                Simbolo sim = Padre.BuscarMetodo(this.Nombre, resueltas);

                if (sim != null)
                {
                    Encontrado = sim;
                    FMetodo m = (FMetodo)sim.Valor;
                    if (m.Parametros.Count == this.Parametros.Count)
                    {
                        String este = TitusTools.GetTemp();
                        cadena += "\t\t" + este + " = " + tempsimulacion + " + 0;//metiendo el this\n";

                        String here = TitusTools.GetTemp();
                        cadena += "\t\t" + here + " = " + temporal + " + " + (sim.este).ToString() + ";//calculo si hay herencia\n";//calculo de la herencia
                        cadena += "\t\t" + "Stack[" + este + "] = " + here + ";\n";
                        ////
                        cadena += "\t\t" + "P = P + " + (simulacion.Ambito.Tamaño).ToString() + ";//cambio de ambito para llamar al metodo\n";
                        cadena += "\t\t" + m.GetNombre3D() + "();\n";
                        cadena += "\t\t" + "P = P - " + (simulacion.Ambito.Tamaño).ToString() + ";//regresando al ambito actual\n";
                        if (!sim.Tipo.Equals(Constante.TVoid))
                        {
                            String retorno = TitusTools.GetTemp();
                            nodo.Valor = TitusTools.GetTemp();
                            cadena    += "\t\t" + retorno + " = " + tempsimulacion + " + 1;//Posicion del retorno\n";
                            cadena    += "\t\t" + nodo.Valor + " = Stack[" + retorno + "];//obteniendo el valor del retorno\n";
                            if (m.Dimensiones > 0)
                            {
                                nodo.Tipo = "arreglo " + m.Tipo;
                            }
                            else
                            {
                                nodo.Tipo = m.Tipo;
                            }
                        }
                        else
                        {
                            nodo.Tipo  = Constante.TVoid;
                            nodo.Valor = "";
                        }
                    }
                    else
                    {
                        TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro el metodo " + this.Nombre, TitusTools.GetRuta(), this.Fila, this.Columna);
                    }
                }
                else
                {
                    TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro el constructor para la clase " + this.Nombre, TitusTools.GetRuta(), this.Fila, this.Columna);
                }
            }

            nodo.Codigo = cadena;

            return(nodo);
        }
Ejemplo n.º 8
0
        public String Generar3D()
        {
            String cadena = "";

            Simbolo simclasepadre = Padre.BuscarClasePadre();

            FClase clasepadre = (FClase)simclasepadre.Valor;

            if (!clasepadre.Herencia.Equals(""))
            {
                Simbolo simclasehere = simclasepadre.BuscarClase(clasepadre.Herencia, clasepadre.ArchivoPadre);
                if (simclasehere != null)
                {
                    Simbolo simulacion = Padre.BuscarMetodoPadre();

                    String tempsimulacion = TitusTools.GetTemp();

                    cadena += "\t\t" + tempsimulacion + " = P + " + (simulacion.Ambito.Tamaño).ToString() + ";//simulacion de cambio de ambito \n";
                    String posstack = TitusTools.GetTemp();
                    cadena += "\t\t" + posstack + " = Stack[P];\n";
                    String nuevapos = TitusTools.GetTemp();
                    cadena += "\t\t" + nuevapos + " = " + posstack + " + " + clasepadre.Ambito.Tamaño.ToString() + ";//posicion en el this de la herencia\n";

                    List <Nodo3D> resueltas = new List <Nodo3D>();

                    int i = 2;
                    foreach (FNodoExpresion p in this.Parametros)
                    {
                        String temporalstack = TitusTools.GetTemp();

                        cadena += "\t\t" + temporalstack + " = " + tempsimulacion + " + " + i.ToString() + ";\n";
                        Nodo3D r = p.Generar3D();
                        if (r.Tipo.Equals(Constante.TBooleano))//conversion siviene de una relacional
                        {
                            if (r.V == "" && r.F == "")
                            {//si trae etiquetas viene de una relacional si no es un bool nativo
                            }
                            else
                            {
                                var cad = "";

                                var auxtemp = TitusTools.GetTemp();
                                var salida  = TitusTools.GetEtq();

                                cad += "\t" + r.V + ":\n";
                                cad += "\t\t" + auxtemp + " = 1;\n";
                                cad += "\t\t" + "goto " + salida + ";\n";
                                cad += "\t" + r.F + ":\n";
                                cad += "\t\t" + auxtemp + " = 0;\n";
                                cad += "\t" + salida + ":\n";

                                r.Valor  = auxtemp;
                                cad     += "\t\t" + r.Valor + " =  - " + auxtemp + ";\n";
                                r.Codigo = r.Codigo + cad;
                            }
                        }


                        cadena += r.Codigo;
                        resueltas.Add(r);

                        //ahora asignamos al stack el valor resuelto
                        cadena += "\t\t" + "Stack[" + temporalstack + "] = " + r.Valor + ";//Asignacino del parametro\n";

                        i++;
                    }



                    String este = TitusTools.GetTemp();

                    cadena += "\t\t" + este + " = " + tempsimulacion + " + 0;//metiendo el this\n";
                    cadena += "\t\t" + "Stack[" + este + "] = " + nuevapos + ";\n";


                    if (!TitusTools.HayErrores())
                    {
                        Simbolo constructor = simclasehere.BuscarConstructor(simclasehere.Nombre, resueltas);

                        cadena += "\t\t" + "P = P + " + (simulacion.Ambito.Tamaño).ToString() + ";//cambio de ambito para llamar al constructor\n";
                        if (constructor != null)
                        {
                            FMetodo m = (FMetodo)constructor.Valor;
                            if (m.Parametros.Count == this.Parametros.Count)
                            {
                                cadena += "\t\t" + simclasehere.Nombre + "_constructor";
                                foreach (Simbolo p in m.Parametros)
                                {
                                    FParametro parametro = (FParametro)p.Valor;
                                    cadena += "_" + parametro.Tipo + parametro.Dimensiones.ToString();
                                }

                                cadena += "();\n";
                            }
                            else
                            {
                                TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro el constructor para la clase " + constructor.Nombre, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
                            }
                        }
                        else
                        {
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro el constructor para la clase " + simclasehere.Nombre, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
                        }
                        cadena += "\t\t" + "P = P - " + (simulacion.Ambito.Tamaño).ToString() + ";//cambio de ambito para llamar al constructor\n";
                    }
                }
                else
                {
                    TitusTools.InsertarError(Constante.TErrorSemantico, "No existe ninguna clase " + clasepadre.Herencia, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
                }
            }
            else
            {
                TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede llamar la instruccion super porque no existe una herencia", TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
            }


            return(cadena);
        }
Ejemplo n.º 9
0
        public Nodo3D Generar3DSuperAsignacion(String temporal)
        {
            Nodo3D nodo = new Nodo3D();

            Simbolo sim = Padre.BuscarVariable(this.Nombre);


            if (sim != null)
            {
                FDeclaracion decla = (FDeclaracion)sim.Valor;

                if (decla.Dimensiones.Count == this.Dimensiones.Count)
                {
                    nodo.Tipo = sim.Tipo;


                    String heap = TitusTools.GetTemp();
                    nodo.Valor   = TitusTools.GetTemp();
                    nodo.Codigo += "\t\t" + heap + " = " + temporal + " + " + sim.Posicion.ToString() + ";//posicion de la variable " + sim.Nombre + "\n";
                    nodo.Codigo += "\t\t" + nodo.Valor + " = Heap[" + heap + "];\n";


                    String tempAcceso    = TitusTools.GetTemp();
                    String cadenaArreglo = "";
                    String etqError      = TitusTools.GetEtq();
                    String etqSalida     = TitusTools.GetEtq();
                    cadenaArreglo += "\t\t" + tempAcceso + " = Heap[" + nodo.Valor + "];//acceso a las dimensiones\n";
                    cadenaArreglo += "\t\t" + "ifFalse " + tempAcceso + " == " + this.Dimensiones.Count.ToString() + " goto " + etqError + ";\n";
                    cadenaArreglo += "\t\t" + nodo.Valor + " = " + nodo.Valor + " + 1;\n";

                    String mapeo = TitusTools.GetTemp();

                    String dsize = TitusTools.GetTemp();

                    String indice = TitusTools.GetTemp();

                    cadenaArreglo += "\t\t" + mapeo + " = 0;\n";
                    int i = 0;
                    foreach (FNodoExpresion d in Dimensiones)
                    {
                        Nodo3D dtemp = d.Generar3D();
                        if (dtemp.Tipo.Equals(Constante.TEntero) && !TitusTools.HayErrores())
                        {
                            cadenaArreglo += dtemp.Codigo;
                            cadenaArreglo += "\t\t" + dsize + " = Heap[" + nodo.Valor + "];\n";
                            cadenaArreglo += "\t\t" + indice + " = " + dsize + " - 1;\n";
                            cadenaArreglo += "\t\t" + nodo.Valor + " = " + nodo.Valor + " + 1;\n";
                            cadenaArreglo += "\t\t" + "ifFalse " + dtemp.Valor + " >= 0 goto " + etqError + ";\n";
                            cadenaArreglo += "\t\t" + "ifFalse " + dtemp.Valor + " <= " + indice + " goto " + etqError + ";\n";
                            if (i > 0)
                            {
                                cadenaArreglo += "\t\t" + mapeo + " = " + mapeo + " * " + dsize + ";\n";
                            }

                            cadenaArreglo += "\t\t" + mapeo + " = " + mapeo + " + " + dtemp.Valor + ";\n";
                        }
                        else
                        {
                            TitusTools.InsertarError(Constante.TErrorSemantico, "Solo se puede acceder al arreglo " + this.Nombre + " con un tipo entero no un tipo " + dtemp.Tipo, TitusTools.GetRuta(), this.Fila, this.Columna);
                        }

                        i++;
                    }

                    cadenaArreglo += "\t\t" + "goto " + etqSalida + ";\n";
                    cadenaArreglo += "\t" + etqError + ":\n";
                    cadenaArreglo += "\t\t" + "Error(1);\n";
                    cadenaArreglo += "\t" + etqSalida + ":\n";
                    cadenaArreglo += "\t\t" + nodo.Valor + " = " + nodo.Valor + " + " + mapeo + ";//posicion lexicografica\n";

                    nodo.Valor = "Heap[" + nodo.Valor + "]";

                    nodo.Codigo += cadenaArreglo;
                }
                else
                {
                    TitusTools.InsertarError(Constante.TErrorSemantico, "El arreglo " + this.Nombre + ", tiene " + decla.Dimensiones.Count.ToString() + " dimensiones no " + this.Dimensiones.Count.ToString(), TitusTools.GetRuta(), this.Fila, this.Columna);
                }
            }
            else
            {
                TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro la variable " + this.Nombre, TitusTools.GetRuta(), this.Fila, this.Columna);
            }

            return(nodo);
        }
Ejemplo n.º 10
0
        public String Generar3DInit(String tempH, int nueva_pos)
        {
            int    pos    = Padre.Posicion + nueva_pos;//sumamos la posicion donde se van a generar las variables en el Heap
            String cadena = "";

            if (Dimensiones.Count == 0)//no es arreglo
            {
                if (Valor != null)
                {
                    Nodo3D val = Valor.Generar3D();
                    switch (Tipo)
                    {
                    case Constante.TEntero:    //asginacion a una variable de tipo entero
                        switch (val.Tipo)
                        {
                        case Constante.TEntero:
                        {
                            String temp = TitusTools.GetTemp();
                            cadena += val.Codigo;
                            cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                            cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TCaracter:
                        {
                            String temp = TitusTools.GetTemp();
                            cadena += val.Codigo;
                            cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                            cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TBooleano:
                        {
                            cadena += val.Codigo;
                            if (val.V == "" && val.F == "")
                            {            //si trae etiquetas viene de una relacional si no es un bool nativo
                                String temp = TitusTools.GetTemp();

                                cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                                cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                            }
                            else
                            {
                                var auxtemp = TitusTools.GetTemp();
                                var salida  = TitusTools.GetEtq();

                                cadena += "\t" + val.V + ":\n";
                                cadena += "\t\t" + auxtemp + " = 1;\n";
                                cadena += "\t\t" + "goto " + salida + ";\n";
                                cadena += "\t" + val.F + ":\n";
                                cadena += "\t\t" + auxtemp + " = 0;\n";
                                cadena += "\t" + salida + ":\n";

                                String temp = TitusTools.GetTemp();

                                cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                                cadena += "\t\t" + "Heap[" + temp + "] = " + auxtemp + ";\n";
                            }
                        }
                        break;

                        default:
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede asignar un tipo " + val.Tipo + " a una variable tipo " + this.Tipo, TitusTools.GetRuta(), Fila, Columna);
                            break;
                        }
                        break;

                    case Constante.TDecimal:    //asginacion a una variable de tipo decimal
                        switch (val.Tipo)
                        {
                        case Constante.TEntero:
                        {
                            String temp = TitusTools.GetTemp();
                            cadena += val.Codigo;
                            cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                            cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TCaracter:
                        {
                            String temp = TitusTools.GetTemp();
                            cadena += val.Codigo;
                            cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                            cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TBooleano:
                        {
                            cadena += val.Codigo;
                            if (val.V == "" && val.F == "")
                            {            //si trae etiquetas viene de una relacional si no es un bool nativo
                                String temp = TitusTools.GetTemp();

                                cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                                cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                            }
                            else
                            {
                                var auxtemp = TitusTools.GetTemp();
                                var salida  = TitusTools.GetEtq();

                                cadena += "\t" + val.V + ":\n";
                                cadena += "\t\t" + auxtemp + " = 1;\n";
                                cadena += "\t\t" + "goto " + salida + ";\n";
                                cadena += "\t" + val.F + ":\n";
                                cadena += "\t\t" + auxtemp + " = 0;\n";
                                cadena += "\t" + salida + ":\n";

                                String temp = TitusTools.GetTemp();

                                cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                                cadena += "\t\t" + "Heap[" + temp + "] = " + auxtemp + ";\n";
                            }
                        }
                        break;

                        case Constante.TDecimal:
                        {
                            String temp = TitusTools.GetTemp();
                            cadena += val.Codigo;
                            cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                            cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                        }
                        break;

                        default:
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede asignar un tipo " + val.Tipo + " a una variable tipo " + this.Tipo, TitusTools.GetRuta(), Fila, Columna);
                            break;
                        }
                        break;

                    case Constante.TCaracter:    //asginacion a una variable de tipo caracter
                        switch (val.Tipo)
                        {
                        case Constante.TEntero:
                        {
                            String temp = TitusTools.GetTemp();
                            cadena += val.Codigo;
                            cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                            cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TCaracter:
                        {
                            String temp = TitusTools.GetTemp();
                            cadena += val.Codigo;
                            cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                            cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                        }
                        break;

                        default:
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede asignar un tipo " + val.Tipo + " a una variable tipo " + this.Tipo, TitusTools.GetRuta(), Fila, Columna);
                            break;
                        }
                        break;

                    case Constante.TCadena:    //asginacion a una variable de tipo cadena
                        switch (val.Tipo)
                        {
                        case Constante.TCaracter:
                        {
                            cadena += val.Codigo;
                            String tem = TitusTools.GetTemp();
                            cadena += "\t\t" + tem + " = H;\n";
                            cadena += "\t\t" + "Heap[H] = " + val.Valor + ";\n";
                            cadena += "\t\t" + "H = H + 1;\n";
                            cadena += "\t\t" + "Heap[H] = 0;\n";
                            cadena += "\t\t" + "H = H + 1;\n";

                            String temp = TitusTools.GetTemp();
                            cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                            cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                        }
                        break;

                        case Constante.TCadena:
                        {
                            String temp = TitusTools.GetTemp();
                            cadena += val.Codigo;
                            cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                            cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                        }
                        break;

                        default:
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede asignar un tipo " + val.Tipo + " a una variable tipo " + this.Tipo, TitusTools.GetRuta(), Fila, Columna);
                            break;
                        }
                        break;

                    case Constante.TBooleano:    //asginacion a una variable de tipo booleano
                        switch (val.Tipo)
                        {
                        case Constante.TBooleano:
                        {
                            cadena += val.Codigo;
                            if (val.V == "" && val.F == "")
                            {            //si trae etiquetas viene de una relacional si no es un bool nativo
                                String temp = TitusTools.GetTemp();

                                cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                                cadena += "\t\t" + "Heap[" + temp + "] = " + val.Valor + ";\n";
                            }
                            else
                            {
                                var auxtemp = TitusTools.GetTemp();
                                var salida  = TitusTools.GetEtq();

                                cadena += "\t" + val.V + ":\n";
                                cadena += "\t\t" + auxtemp + " = 1;\n";
                                cadena += "\t\t" + "goto " + salida + ";\n";
                                cadena += "\t" + val.F + ":\n";
                                cadena += "\t\t" + auxtemp + " = 0;\n";
                                cadena += "\t" + salida + ":\n";

                                String temp = TitusTools.GetTemp();

                                cadena += "\t\t" + temp + " = " + tempH + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                                cadena += "\t\t" + "Heap[" + temp + "] = " + auxtemp + ";\n";
                            }
                        }
                        break;

                        default:
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede asignar un tipo " + val.Tipo + " a una variable tipo " + this.Tipo, TitusTools.GetRuta(), Fila, Columna);
                            break;
                        }
                        break;

                    default:    //asginacion a una variable de tipo objeto
                        if (Tipo == val.Tipo)
                        {
                            cadena += val.Codigo;
                            String temp    = TitusTools.GetTemp();
                            String heap    = TitusTools.GetTemp();
                            String posheap = TitusTools.GetTemp();
                            cadena += "\t\t" + temp + " = P + 0;//Posicion del this\n";
                            cadena += "\t\t" + heap + " = Stack[" + temp + "];\n";
                            cadena += "\t\t" + posheap + " = " + heap + " + " + pos.ToString() + ";//Declaracion de la variable " + this.Nombre + "\n";
                            cadena += "\t\t" + "Heap[" + posheap + "] = " + val.Valor + ";\n";
                        }
                        else
                        {
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede asignar un tipo " + val.Tipo + " a una variable tipo " + this.Tipo, TitusTools.GetRuta(), Fila, Columna);
                        }
                        break;
                    }
                }
            }
            else//es arreglo
            {
                String stack   = TitusTools.GetTemp();
                String posheap = TitusTools.GetTemp();
                String arr     = TitusTools.GetTemp();
                String cont    = TitusTools.GetTemp();
                cadena += "\t\t" + stack + " = P + 0;\n";
                cadena += "\t\t" + posheap + " = Stack[" + stack + "];\n";
                cadena += "\t\t" + arr + " = " + posheap + " + " + pos.ToString() + ";//Declaracion de arreglo " + this.Nombre + "\n";
                cadena += "\t\t" + "Heap[" + arr + "]" + " = H;\n";
                cadena += "\t\t" + cont + "= 1;\n";
                cadena += "\t\t" + "Heap[H] = " + Dimensiones.Count.ToString() + ";//Guardamos dimensiones\n";
                cadena += "\t\t" + "H = H + 1;\n";
                int i = 1;
                foreach (FNodoExpresion dimension in Dimensiones)
                {
                    Nodo3D size = dimension.Generar3D();

                    if (!TitusTools.HayErrores())
                    {
                        if (size.Tipo == Constante.TEntero)
                        {
                            cadena += size.Codigo;
                            cadena += "\t\t" + cont + " = " + cont + " * " + size.Valor + ";\n";
                            cadena += "\t\t" + "Heap[H] = " + size.Valor + ";//Guardamos el tamaño de la dimension " + i.ToString() + "\n";
                            cadena += "\t\t" + "H = H + 1;\n";
                        }
                        else
                        {
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede iniciar una dimension de un arreglo con un tipo de dato  " + size.Tipo + ", se esperaba un valor entero.", TitusTools.GetRuta(), Fila, Columna);
                        }
                    }
                    i++;
                }
                cadena += "\t\t" + "H = H + " + cont + ";//termina declaracion de arreglo\n";
                if (Valor != null)
                {
                    Nodo3D val = Valor.Generar3D();

                    if (!TitusTools.HayErrores())
                    {
                        if (val.Tipo == "arreglo " + this.Tipo)
                        {
                            cadena += val.Codigo;
                            String etqerror  = TitusTools.GetEtq();
                            String etqsalida = TitusTools.GetEtq();

                            String contador  = TitusTools.GetTemp();
                            String contador2 = TitusTools.GetTemp();
                            String val1      = TitusTools.GetTemp();
                            String val2      = TitusTools.GetTemp();
                            cadena += "\t\t" + contador + " = Heap[" + arr + "];\n";
                            cadena += "\t\t" + contador2 + " = " + val.Valor + ";\n";
                            cadena += "\t\t" + val1 + " = Heap[" + contador + "];//acceso a la declaracion del arreglo\n";
                            cadena += "\t\t" + val2 + " = Heap[" + contador2 + "];\n";
                            cadena += "\t\t" + "ifFalse " + val1 + " == " + val2 + " goto " + etqerror + ";\n";
                            String ciclo = TitusTools.GetTemp();
                            String tope  = TitusTools.GetTemp();
                            cadena += "\t\t" + ciclo + " = 0;\n";
                            cadena += "\t\t" + tope + " = " + val1 + ";\n";
                            String recursivo = TitusTools.GetEtq();
                            cadena += "\t" + recursivo + ":\n";
                            cadena += "\t\t" + "ifFalse " + ciclo + " < " + tope + " goto " + etqsalida + ";\n";
                            cadena += "\t\t" + val1 + " = Heap[" + contador + "];//acceso a tamanio dimension\n";
                            cadena += "\t\t" + val2 + " = Heap[" + contador2 + "];//acceso a tamanio dimension 2\n";
                            cadena += "\t\t" + contador + " = " + contador + " + 1;\n";
                            cadena += "\t\t" + contador2 + " = " + contador2 + " + 1;\n";
                            cadena += "\t\t" + ciclo + " = " + ciclo + " + 1;\n";
                            cadena += "\t\t" + "if " + val1 + " == " + val2 + " goto " + recursivo + ";\n";
                            cadena += "\t\t" + "goto " + etqerror + ";\n";
                            cadena += "\t\t" + "goto " + etqsalida + ";\n";
                            cadena += "\t" + etqerror + ":\n";
                            cadena += "\t\t" + "Error(2);\n";
                            cadena += "\t" + etqsalida + ":\n";

                            //validacio de dimensiones
                            cadena += "\t\t" + "Heap[" + arr + "]" + " = " + val.Valor + ";//Declaracion de arreglo global" + this.Nombre + "\n";
                        }
                        else
                        {
                            TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede asignar un " + val.Tipo + " a un arreglo de tipo " + this.Tipo, TitusTools.GetRuta(), Fila, Columna);
                        }
                    }
                }
            }

            return(cadena);
        }
Ejemplo n.º 11
0
        public Nodo3D Generar3D()
        {
            Nodo3D nodo = new Nodo3D();

            String cadena = "";

            Simbolo simulacion = Padre.BuscarMetodoPadre();

            String tempsimulacion = TitusTools.GetTemp();

            cadena += "\t\t" + tempsimulacion + " = P + " + (simulacion.Ambito.Tamaño).ToString() + ";//simulacion de cambio de ambito \n";

            nodo.Valor = TitusTools.GetTemp();

            nodo.Tipo = this.Nombre;
            String este = TitusTools.GetTemp();

            cadena += "\t\t" + nodo.Valor + " = H;//posicion del objeto\n";
            cadena += "\t\t" + este + " = " + tempsimulacion + " + 0;//metiendo el this\n";
            cadena += "\t\t" + "Stack[" + este + "] = " + nodo.Valor + ";\n";
            cadena += "\t\t" + "P = P + " + (simulacion.Ambito.Tamaño).ToString() + ";//cambio de ambito para llamar al constructor\n";
            cadena += "\t\t" + "init_" + this.Nombre + "();\n";
            cadena += "\t\t" + "P = P - " + (simulacion.Ambito.Tamaño).ToString() + ";//cambio de ambito para llamar al constructor\n";
            cadena += "\t\t" + "Stack[" + este + "] = " + nodo.Valor + ";\n";
            List <Nodo3D> resueltas = new List <Nodo3D>();

            int i = 2;

            foreach (FNodoExpresion p in this.Parametros)
            {
                String temporalstack = TitusTools.GetTemp();

                cadena += "\t\t" + temporalstack + " = " + tempsimulacion + " + " + i.ToString() + ";\n";
                Nodo3D r = p.Generar3D();
                if (r.Tipo.Equals(Constante.TBooleano))//conversion siviene de una relacional
                {
                    if (r.V == "" && r.F == "")
                    {//si trae etiquetas viene de una relacional si no es un bool nativo
                    }
                    else
                    {
                        var cad = "";

                        var auxtemp = TitusTools.GetTemp();
                        var salida  = TitusTools.GetEtq();

                        cad += "\t" + r.V + ":\n";
                        cad += "\t\t" + auxtemp + " = 1;\n";
                        cad += "\t\t" + "goto " + salida + ";\n";
                        cad += "\t" + r.F + ":\n";
                        cad += "\t\t" + auxtemp + " = 0;\n";
                        cad += "\t" + salida + ":\n";

                        r.Valor  = auxtemp;
                        cad     += "\t\t" + r.Valor + " =  - " + auxtemp + ";\n";
                        r.Codigo = r.Codigo + cad;
                    }
                }


                cadena += r.Codigo;
                resueltas.Add(r);

                //ahora asignamos al stack el valor resuelto
                cadena += "\t\t" + "Stack[" + temporalstack + "] = " + r.Valor + ";//Asignacino del parametro\n";

                i++;
            }

            if (!TitusTools.HayErrores())
            {
                Simbolo sim = Padre.BuscarConstructor(this.Nombre, resueltas);

                cadena += "\t\t" + "P = P + " + (simulacion.Ambito.Tamaño).ToString() + ";//cambio de ambito para llamar al constructor\n";
                if (sim != null)
                {
                    FMetodo m = (FMetodo)sim.Valor;
                    if (m.Parametros.Count == this.Parametros.Count)
                    {
                        cadena += "\t\t" + this.Nombre + "_constructor";
                        foreach (Simbolo p in m.Parametros)
                        {
                            FParametro parametro = (FParametro)p.Valor;
                            cadena += "_" + parametro.Tipo + parametro.Dimensiones.ToString();
                        }

                        cadena += "();\n";
                    }
                    else
                    {
                        TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro el constructor para la clase " + this.Nombre, TitusTools.GetRuta(), this.Fila, this.Columna);
                    }
                }
                else
                {
                    TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro el constructor para la clase " + this.Nombre, TitusTools.GetRuta(), this.Fila, this.Columna);
                }
                cadena += "\t\t" + "P = P - " + (simulacion.Ambito.Tamaño).ToString() + ";//cambio de ambito para llamar al constructor\n";
            }

            nodo.Codigo = cadena;

            return(nodo);
        }