public Simbolo BuscarMetodoHerencia(String nombre, List <Nodo3D> parametros)
{
Simbolo var = null;
Simbolo sim = BuscarClasePadre();
FClase clase = (FClase)sim.Valor;
if (!clase.Herencia.Equals(""))
{
Simbolo bc = BuscarClase(clase.Herencia, clase.ArchivoPadre);
if (bc != null)
{
var = bc.BuscarMetodo(nombre, parametros);
if (var != null)
{
if (!var.Visibilidad.Equals(Constante.TPublico) && !var.Visibilidad.Equals(Constante.TProtegido))
{
var = null;
}
}
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro una clase para herederar con el nombre " + clase.Herencia, TitusTools.GetRuta(), sim.Fila, sim.Columna);
}
}
return(var);
}
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);
}
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);
}
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 FElegir(FNodoExpresion condicion, Ambito ambito, List <FCaso> casos, FCaso defecto)
{
this.Casos = casos;
this.Defecto = defecto;
this.Ambito = ambito;
this.Condicion = condicion;
FNodoExpresion aux = null;
foreach (FCaso caso in Casos)
{
if (aux != null)
{
if (aux.Tipo != caso.Valor.Tipo)
{
TitusTools.InsertarError(Constante.TErrorSemantico, "Los valores de los casos de la sentencia elegir deben ser iguales", TitusTools.GetRuta(), caso.Valor.Fila, caso.Valor.Columna);
}
}
else
{
aux = caso.Valor;
}
}
}
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 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 void ImprimirDecimal()
{
Variable v = Tabla3D.BuscarVariable(Temporal);
if (v != null)
{
if (v.Valor != null)
{
FNodoExpresion valor = (FNodoExpresion)v.Valor;
if (valor.Tipo.Equals(Constante.TDecimal))
{
TitusTools.ImprimirConsola(valor.Decimal.ToString());
TitusTools.ImprimirConsola("\n");
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede imprimir un decimal porque el valor no es decimal del temporal " + Temporal, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
}
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se ha asignado ningun valor al temporal " + Temporal, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
}
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No existe el temporal " + Temporal, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
}
}
public void ImprimirCaracter()
{
Variable v = Tabla3D.BuscarVariable(Temporal);
if (v != null)
{
if (v.Valor != null)
{
FNodoExpresion valor = (FNodoExpresion)v.Valor;
if (valor.Tipo.Equals(Constante.TEntero))
{
if (valor.Entero >= 0)
{
char c = (char)valor.Entero;
TitusTools.ImprimirConsola(c.ToString());
if (valor.Entero == 0)
{
TitusTools.ImprimirConsola("\n");
}
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se pueden imprimir un caracter con un ascii negativo en el temporal " + Temporal, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
}
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede imprimir un caracter porque el valor no es entero del temporal " + Temporal, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
}
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se ha asignado ningun valor al temporal " + Temporal, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
}
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No existe el temporal " + Temporal, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
}
}
public int EjecutarGoTo(Simbolo sim)
{
Boolean estado = false;
int i = -1;
Simbolo anterior = sim.Anterior;
while (anterior != null)
{
if (anterior.Rol.Equals(Constante.Etiqueta) && anterior.Nombre.Equals(sim.Nombre))
{
estado = true;
break;
}
i--;
anterior = anterior.Anterior;
}
if (!estado)
{
i = 1;
Simbolo siguiente = sim.Siguiente;
while (siguiente != null)
{
if (siguiente.Rol.Equals(Constante.Etiqueta) && siguiente.Nombre.Equals(sim.Nombre))
{
estado = true;
break;
}
i++;
siguiente = siguiente.Siguiente;
}
}
if (estado)
{
return(i);
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se econtro la etiqueta " + sim.Nombre, TitusTools.GetRuta(), sim.Fila, sim.Columna);
return(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);
}
public void EjecutarLlamadaMetodo(Simbolo sim)
{
FMetodo metodo = Tabla3D.BuscarMetodo(sim.Nombre);
if (metodo != null)
{
metodo.Ejecutar();
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro el metodo " + sim.Nombre, TitusTools.GetRuta(), sim.Fila, sim.Columna);
}
}
public void EjecutarError(Simbolo sim)
{
switch (sim.Nombre)
{
case "1":
TitusTools.InsertarError(Constante.TErrorSemantico, "Acceso fuera de los limites", TitusTools.GetRuta(), sim.Fila, sim.Columna);
break;
case "2":
TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede asignar el arreglo por que las dimensiones y sus tamaños no son iguales", TitusTools.GetRuta(), sim.Fila, sim.Columna);
break;
case "3":
TitusTools.InsertarError(Constante.TErrorSemantico, "No se puedo convertir de cadena a entero", TitusTools.GetRuta(), sim.Fila, sim.Columna);
break;
case "4":
TitusTools.InsertarError(Constante.TErrorSemantico, "No se puede convertir de cadena a decimal", TitusTools.GetRuta(), sim.Fila, sim.Columna);
break;
default:
TitusTools.InsertarError(Constante.TErrorSemantico, "Error desconocido", TitusTools.GetRuta(), sim.Fila, sim.Columna);
break;
}
}
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);
}
private Simbolo BuscarVariableHerencia(String nombre)
{
Simbolo var = null;
Simbolo sim = BuscarClasePadre();
FClase clase = (FClase)sim.Valor;
if (!clase.Herencia.Equals(""))
{
Simbolo bc = BuscarClase(clase.Herencia, clase.ArchivoPadre);
if (bc != null)
{
var = bc.BuscarVariable(nombre);
if (var != null)
{
if (var.Visibilidad.Equals(Constante.TPublico) || var.Visibilidad.Equals(Constante.TProtegido))
{
var.Posicion += sim.Tamaño;
}
else
{
var = null;
}
}
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro una clase para herederar con el nombre " + clase.Herencia, TitusTools.GetRuta(), sim.Fila, sim.Columna);
}
}
return(var);
}
//para asignacion
public Nodo3D Generar3DAsignacion()
{
Nodo3D nodo = new Nodo3D();
Simbolo sim = Padre.BuscarVariable(this.Nombre);
if (sim != null)//es un arreglo
{
FLlamadaArreglo arr = new FLlamadaArreglo(this.Nombre, Parametros, Fila, Columna);
arr.setPadre(Padre);
nodo = arr.Generar3DAsignacion();
}
else// es un metodo
{
FLlamadaMetodo metodo = new FLlamadaMetodo(this.Nombre, this.Parametros, Fila, Columna);
metodo.setPadre(Padre);
nodo = metodo.Generar3DAsignacion();
sim = metodo.Encontrado;
}
if (sim == null)
{
TitusTools.InsertarError(Constante.TErrorSemantico, "No se encontro un arreglo o metodo para ejecutar", TitusTools.GetRuta(), Fila, Columna);
}
return(nodo);
}
public String Generar3D()
{
String cadena = "\t\t//Comienza mientras\n";
String retorno = TitusTools.GetEtq();
Nodo3D cond = Condicion.Generar3D();
if (!TitusTools.HayErrores())
{
if (cond.Tipo == Constante.TBooleano)
{
cadena += "\t" + retorno + ":\n";
cadena += cond.Codigo;
if (cond.V == "" && cond.F == "")
{
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 " + retorno + ";\n";
cadena += "\t" + cond.F + "://Termina mientras\n";
cadena = cadena.Replace("§salir§;", "goto " + cond.F + ";\n");
cadena = cadena.Replace("§continuar§;", "goto " + cond.V + ";\n");
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "El ciclo while 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 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 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 cadena = "\t\t//Comienza si\n";
Nodo3D cond = Condicion.Generar3D();
if (cond.Tipo == Constante.TBooleano)
{
String salida = TitusTools.GetEtq();
//Parte del if
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";
//parte de los sinosi
foreach (FSinoSi sinosi in SinoSi)
{
cadena += sinosi.Generar3D(salida);
}
if (Sino != null)
{
cadena += Sino.Generar3D(salida);
}
cadena += "\t" + salida + "://Termina si\n";
}
else
{
TitusTools.InsertarError(Constante.TErrorSemantico, "La sentencia si esperaba un tipo booleano no un tipo " + cond.Tipo, TitusTools.GetRuta(), Padre.Fila, Padre.Columna);
}
return(cadena);
}
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);
}
}
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);
}
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 = "\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);
}