public void AsignarTemporal()
{
Variable variable = Tabla3D.BuscarVariable(Temporal);
if (variable != null)
{
FNodoExpresion valor = this.Valor.ResolverExpresion();
if (!TitusTools.HayErrores())
{
if (valor.Tipo.Equals(Constante.TEntero) || valor.Tipo.Equals(Constante.TDecimal))
{
variable.Valor = valor;
Console.WriteLine(variable.Nombre + " = " + valor.Cadena);
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "Se esperaba un valor numerico.", TitusTools.GetRuta(), this.Valor.Fila, this.Valor.Columna);
}
}
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontroo el temporal " + this.Temporal, TitusTools.GetRuta(), this.Valor.Fila, this.Valor.Columna);
}
}
public String Ejecutar()
{
FNodoExpresion aux = Condicion.ResolverExpresion();
if (!TitusTools.HayErrores())
{
if (aux.Tipo.Equals(Constante.TBooleano))
{
if (this.Tipo.Equals(Constante.TIf))
{
if (aux.Bool)
{
return(Etiqueta);
}
}
else
{
if (!aux.Bool)
{
return(Etiqueta);
}
}
}
}
return("");
}
public void Ejecutar()
{
PrimerPasada();
if (!TitusTools.HayErrores())
{
MessageBox.Show("Ejecucion de codigo 3D finalizada con exito.", "Codigo 3D", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("Se encontraron errores", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public String Generar3D(String salida)
{
String cadena = "\t\t//Comienza sino\n";
if (!TitusTools.HayErrores())
{
foreach (Simbolo sim in Ambito.TablaSimbolo)//cuerpo si es verdadero
{
cadena += sim.Generar3D();
}
cadena += "\t\t" + "//Termina sino\n";
}
return(cadena);
}
public void PrimerPasada()
{
//Limpiamos las variables que utilizamos para la ejecucion
Tabla3D.IniciarTabla();
//buscamos el main y apartamos la primera posicion de la tabla de variables
foreach (Simbolo sim in Codigo3D.TablaSimbolo)
{
if (sim.Rol.Equals(Constante.TMain))
{
if (Tabla3D.Tabla.Count == 0)
{
Tabla3D.Tabla.Insert(0, new Variable(sim.Nombre, sim.Rol, sim.Fila, sim.Columna, sim.Ambito, sim.Valor));
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "Exite mas de un metodo main", TitusTools.GetRuta(), 1, 1);
}
}
}
foreach (Simbolo sim in Codigo3D.TablaSimbolo)
{
if (!sim.Rol.Equals(Constante.TMain))
{
Tabla3D.Tabla.Add(new Variable(sim.Nombre, sim.Rol, sim.Fila, sim.Columna, sim.Ambito, sim.Valor));
}
}
if (!TitusTools.HayErrores())
{
if (Tabla3D.Tabla.Count > 0)
{
if (!Tabla3D.Tabla[0].Rol.Equals(Constante.TMain))
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro un metodo main", TitusTools.GetRuta(), 1, 1);
}
else
{
FMetodo main = (FMetodo)Tabla3D.Tabla[0].Valor;
main.Ejecutar();
}
}
}
}
public String Generar3D()
{
String cadena = "";
String retorno = TitusTools.GetEtq();
if (!TitusTools.HayErrores())
{
cadena = "\t\t//Comienza para\n";
cadena += AccionAnterior.Generar3D();//asignacion de variables
cadena += "\t" + retorno + ":\n";
Nodo3D cond = Condicion.Generar3D();
cadena += cond.Codigo;
if (cond.Tipo == Constante.TBooleano)
{
if (cond.V == "" || cond.F == "")
{
cond.V = TitusTools.GetEtq();
cond.F = TitusTools.GetEtq();
cadena += "\t" + "if " + cond.Valor + " == 1 goto " + cond.V + ";\n";
cadena += "\t" + "goto " + cond.F + ";\n";
}
cadena += "\t" + cond.V + ":\n";
foreach (Simbolo sim in Ambito.TablaSimbolo)//cuerpo si es verdadero
{
cadena += sim.Generar3D();
}
cadena += AccionSiguiente.Generar3D();//actualizacion de varaibles
cadena += "\t\t" + "goto " + retorno + ";\n";
cadena += "\t" + cond.F + "://Termina para\n";
cadena = cadena.Replace("§salir§;", "goto " + cond.F + ";\n");
cadena = cadena.Replace("§continuar§;", "goto " + cond.V + ";\n");
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "El ciclo for esperaba un tipo booleano no un tipo " + cond.Tipo, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
}
}
return(cadena);
}
public void AsignarP()
{
FNodoExpresion valor = this.Valor.ResolverExpresion();
if (!TitusTools.HayErrores())
{
if (valor.Tipo.Equals(Constante.TEntero))
{
Tabla3D.P = valor.Entero;
Console.WriteLine("P = " + valor.Cadena);
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "Se esperaba un valor numerico.", TitusTools.GetRuta(), this.Valor.Fila, this.Valor.Columna);
}
}
}
public void AsignarStack()
{
FNodoExpresion acceso = this.Acceso.ResolverExpresion();
FNodoExpresion valor = this.Valor.ResolverExpresion();
if (!TitusTools.HayErrores())
{
if (acceso.Tipo.Equals(Constante.TEntero))
{
Tabla3D.InsertarStack(acceso.Entero, valor);
Console.WriteLine(Acceso.Fila.ToString() + " Stack[" + acceso.Cadena + "] = " + valor.Cadena);
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "Se esperaba un valor entero para acceder al heap.", TitusTools.GetRuta(), this.Acceso.Fila, this.Acceso.Columna);
}
}
}
public String Generar3D(String salida)
{
String cadena = "\t\t//Comienza sino si\n";
Nodo3D cond = Condicion.Generar3D();
if (!TitusTools.HayErrores())
{
if (cond.Tipo == Constante.TBooleano)
{
cadena += cond.Codigo;
if (cond.V != "" && cond.F != "")
{
cadena += "\t" + cond.V + ":\n";
foreach (Simbolo sim in Ambito.TablaSimbolo)//cuerpo si es verdadero
{
cadena += sim.Generar3D();
}
}
else
{
cond.V = TitusTools.GetEtq();
cond.F = TitusTools.GetEtq();
cadena += "\t\t" + "if " + cond.Valor + " == 1 goto " + cond.V + ";\n";
cadena += "\t\t" + "goto " + cond.F + ";\n";
cadena += "\t" + cond.V + ":\n";
foreach (Simbolo sim in Ambito.TablaSimbolo)//cuerpo si es verdadero
{
cadena += sim.Generar3D();
}
}
cadena += "\t\t" + "goto " + salida + ";\n";
cadena += "\t" + cond.F + ":\n";
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "La sentencia sino si esperaba un tipo booleano no un tipo " + cond.Tipo, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
}
}
return(cadena);
}
public String Generar3D(Nodo3D izq)
{
String cadena = "";
cadena = "\t\t//Comienza caso " + Valor.Cadena + "\n";
Nodo3D cond = Relacional3D(izq, Valor, Valor.Fila, Valor.Columna);
if (!TitusTools.HayErrores())
{
if (cond.Tipo == Constante.TBooleano)
{
if (cond.V != "" || cond.F != "")
{
cadena += cond.Codigo;
foreach (Simbolo sim in Ambito.TablaSimbolo)//cuerpo si es verdadero
{
cadena += sim.Generar3D();
}
}
else
{
cond.F = TitusTools.GetEtq();
cadena += "\t\t" + "ifFalse " + cond.Valor + " == 1 goto " + cond.F + ";\n";
cadena += cond.Codigo;
foreach (Simbolo sim in Ambito.TablaSimbolo)//cuerpo si es verdadero
{
cadena += sim.Generar3D();
}
}
cadena += "\t" + cond.F + "://Termina caso " + Valor.Cadena + "\n";
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "La sentencia caso esperaba un tipo booleano no un tipo " + cond.Tipo, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
}
}
return(cadena);
}
public String Generar3D()
{
String cadena = "\t\t//Comienza ciclo X\n";
String retorno = TitusTools.GetEtq();
FNodoExpresion or = new FNodoExpresion(Condicion1, Condicion2, Constante.TOr, Constante.TOr, Condicion1.Fila, Condicion1.Columna, null);
FNodoExpresion and = new FNodoExpresion(Condicion1, Condicion2, Constante.TAnd, Constante.TAnd, Condicion1.Fila, Condicion1.Columna, null);
Nodo3D cond1 = or.Generar3D();
Nodo3D cond2 = and.Generar3D();
if (!TitusTools.HayErrores())
{
cadena += cond1.Codigo;
cadena += "\t" + retorno + ":\n";
cadena += cond2.Codigo;
cadena += "\t" + cond1.V + ":\n";
cadena += "\t" + cond2.V + ":\n";
foreach (Simbolo sim in Ambito.TablaSimbolo)//cuerpo si es verdadero
{
cadena += sim.Generar3D();
}
cadena += "\t\t" + "goto " + retorno + ";\n";
cadena += "\t" + cond1.F + ":\n";
cadena += "\t" + cond2.F + ":\n";
}
cadena += "\t\t//Termina ciclo X\n";
cadena = cadena.Replace("§salir§;", "goto " + cond1.F + ";\n");
cadena = cadena.Replace("§continuar§;", "goto " + retorno + ";\n");
return(cadena);
}
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);
}
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);
}
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);
}
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);
}
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);
}
/***************************** ejecucion de 3d *****************************/
public void Ejecutar()
{
Tabla3D.InsertarAmbito(this.Ambito);
if (!TitusTools.HayErrores())
{
for (int i = 0; i < this.Ambito.TablaSimbolo.Count && i >= 0; i++)
{
Simbolo sim = Ambito.TablaSimbolo.ElementAt(i);
if (!TitusTools.HayErrores())
{
switch (sim.Rol)
{
case Constante.LLAMADA_METODO:
EjecutarLlamadaMetodo(sim);
break;
case Constante.TGoto:
{
int pos = EjecutarGoTo(sim);
if (pos != 0)
{
i += pos - 1;
}
else
{
break;
}
}
break;
case Constante.TIf:
{
int pos = EjecutarIf(sim);
if (pos != 0)
{
i += pos - 1;
}
else
{
break;
}
}
break;
case Constante.ASIGNACION:
EjecutarAsignacion(sim);
break;
case Constante.TPrint:
EjecutarPrint(sim);
break;
case Constante.TError:
EjecutarError(sim);
break;
}
}
else
{
break;
}
}
}
Tabla3D.SacarAmbito();
}
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);
}
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);
}
