public override void ejecutar(elementoEntorno elem)
{
if (tabla.hayErrores("lstPrincipal_ejecutar"))
{
return;
}
if (listaPolimorfa.Count > 0)
{
elementoPolimorfo temp = listaPolimorfa[0];
if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO"))
{
_LST_CUERPO val = (_LST_CUERPO)temp.LST_CUERPO;
itemValor retornoFuncion = new itemValor();
retornoFuncion.setTypeVacio();
val.ejecutar(elem);
imprimir(elem);
}
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se encuentra el main", new token());
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DE METODO CONSTRUCTOR Heredado
|-------------------------------------------------------------------------------------------------------------------
|
*/
public void ejecutarConstructorHeredad(lstValores parametros, elementoEntorno tablaEntorno, token mensaje)
{
//aqui es donde tengo que buscar si existe
Console.WriteLine("ejecutando Constructor Heredado:");
elementoPolimorfo temp = getConstructoHeredado(parametros, mensaje);
if (temp != null)
//neuvo entorno
{
elementoEntorno hijo1 = new elementoEntorno(tablaEntorno, tabla, "main", tablaEntorno.este);
guardarParametrosEnLaTabla(temp.lstParametros, parametros, hijo1);
if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO"))
/*
|----------------------------
| Ejecutando el cuerpo del metodo
|-----------------------
| Los constructores no retornan nada
*/
{
_LST_CUERPO val = (_LST_CUERPO)temp.LST_CUERPO;
val.ejecutar(hijo1);
}
}
}
public void cargarConstructor(elementoClase simbolo)
/*
|----------------------------
| Constructor
|----------------------------
| Este constructor también lo voy a crear manualmente
| y me va servir para pasar los parametros que vienen en la pregunta.
*/
{
if (hayErrores())
{
return;
}
token nombreClase = lstAtributos.getToken(1);
token tipo = new token("vacio");
elementoPolimorfo element = new elementoPolimorfo(new token("publico"), tablaSimbolos, tipo, nombreClase, new _LST_CUERPO2("LST_CUERPO2", tablaSimbolos), 0);
_LST_PARAMETROS parametros = (_LST_PARAMETROS)getNodo("LST_PARAMETROS");
foreach (elementoPolimorfo tempPolimorfo in parametros.getParametros())
{
element.insertarParametro(tempPolimorfo.nombre, tempPolimorfo.tipo, tempPolimorfo.dimension);
}
simbolo.lstConstructores.insertarElemento(element);
}
public override void ejecutar(elementoClase simbolo)
{
if (hayErrores())
{
return;
}
//Verificando si tengo como hijo a DECLARAR_VARIABLE_SINVISIBI
if (hay_DECLARAR_VARIABLE_SINVISIBI(simbolo))
{
return;
}
// println("llego al contructor");
token tipo = getTipo();
token nombre = getIdentificador();
//nodoModelo LST_CUERPO = getLST_CUERPO();
token visbilidad = getVisibilidad(simbolo);
int dimension = getDimensiones();
elementoPolimorfo element = new elementoPolimorfo(visbilidad, tablaSimbolos, tipo, nombre, getVAL(), dimension);
cargarPolimorfismoHijos(element);
simbolo.lstVariablesGlobales.insertarElemento(element);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| FORMULARiO
|-------------------------------------------------------------------------------------------------------------------
|
*/
public elementoPolimorfo getPolimorfo()
{
elementoPolimorfo retorno = null;
if (hayErrores())
{
return(retorno);
}
nodoModelo tempNodo = getNodo("TIPO");
if (tempNodo != null)
{
_TIPO temp = (_TIPO)tempNodo;
nodoModelo temp2 = getNodo("VAR_ARREGLO");
if (temp2 != null)
{
_VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2;
token visibilidad = new token("publico");
token tipo = temp.getTipo();
token nombre = tempVar.getIdentificador();
int dimensiones = tempVar.getDimensiones();
retorno = new elementoPolimorfo(visibilidad, tablaSimbolos, tipo, nombre, new _LST_CUERPO("LST_CUERPO", tablaSimbolos), dimensiones);
return(retorno);
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Heredando variables
|-------------------------------------------------------------------------------------------------------------------
|
*/
public void heredar(List <elementoPolimorfo> lstPolimorfos)
{
/* elementoPolimorfo element = new elementoPolimorfo(visbilidad, tablaSimbolos, tipo, nombre, getVAL(), dimension);
*
* cargarPolimorfismoHijos(element);
* simbolo.lstVariablesGlobales.insertarElemento(element);
*/
foreach (elementoPolimorfo tempPolimorfo in lstPolimorfos)
{
token tipo = tempPolimorfo.tipo;
token nombre = tempPolimorfo.nombre;
token visibilidad = tempPolimorfo.visibilidad;
if (visibilidad.valLower.Equals("privado"))
//los privados no los extiendos
{
Console.WriteLine("Los metodos/var privados no son cargados->:" + nombre.val);
}
else
{
int dimension = tempPolimorfo.dimension;
elementoPolimorfo element = new elementoPolimorfo(visibilidad, tabla, tipo, nombre, tempPolimorfo.LST_CUERPO, dimension);
//cargo los parámetros
element.lstParametros = tempPolimorfo.lstParametros;
insertarElementoHeredado(element);
}
}
}
public void ejecutarRespuesta(elementoClase simbolo)
/*
|----------------------------
| VISIBILIDAD + tRespuesta + sAbreParent + LST_PARAMETROS + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave
*/
{
if (hayErrores())
{
return;
}
token tipo = new token("vacio");
token nombre = lstAtributos.getToken(0);
nombre.val = "_respuesta";
nombre.valLower = "_respuesta";
nodoModelo LST_CUERPO = getLST_CUERPO();
token visbilidad = getVisibilidad(simbolo);
int dimension = 0;
elementoPolimorfo element = new elementoPolimorfo(visbilidad, tablaSimbolos, tipo, nombre, LST_CUERPO, dimension);
cargarPolimorfismoHijos(element);
simbolo.lstMetodo_funcion.insertarElemento(element);
}
public void insertarElemento(elementoPolimorfo elem)
{
//tengo que verificar si ya existe validando los parametros
if (siExiste(elem))//Si existe
{
tabla.tablaErrores.insertErrorSyntax("El metodo/funcion :" + elem.nombre.val + " ya está declarada con los mismos parámetros.", elem.nombre);
}
else
{
listaPolimorfa.Add(elem);
}
}
public void cargarPolimorfismoHijos(elementoPolimorfo elemento)
{
if (hayErrores())
{
return;
}
foreach (nodoModelo temp in hijos)
{
// Console.WriteLine("[nodoModelo]EjecutarHijos_padre:" + nombre + "->hijo:" + temp.nombre);
temp.cargarPolimorfismo(elemento);
}
}
public void insertarElementoHeredado(elementoPolimorfo elem)
{
//tengo que verificar si ya existe validando los parametros
if (siExiste(elem))//Si existe
{
Console.WriteLine("[lstPolimorfismo]InsertandoHeredados -> Ya existe el mteodo/var/func: " + elem.nombre.val);
// tabla.tablaErrores.insertErrorSyntax("El metodo/funcion :" + elem.nombre.val + " ya está declarada con los mismos parámetros.", elem.nombre);
}
else
{
listaPolimorfa.Add(elem);
}
}
public override void ejecutar(elementoClase simbolo)
{
if (hayErrores())
{
return;
}
token tipo = new token("vacio");
token nombre = new token("principal");
nodoModelo LST_CUERPO = getLST_CUERPO();
elementoPolimorfo element = new elementoPolimorfo(new token("publico"), tablaSimbolos, tipo, nombre, LST_CUERPO, 0);
simbolo.lstPrincipal.insertarElemento(element);
}
public override void ejecutar(elementoClase simbolo)
{
if (hayErrores())
{
return;
}
token tipo = new token("vacio");
token nombre = getIdentificador(simbolo.nombreClase);
nodoModelo LST_CUERPO = getLST_CUERPO();
elementoPolimorfo element = new elementoPolimorfo(new token("publico"), tablaSimbolos, tipo, nombre, LST_CUERPO, 0);
cargarPolimorfismoHijos(element);
simbolo.lstConstructores.insertarElemento(element);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Si existe
|-------------------------------------------------------------------------------------------------------------------
|
*/
public Boolean siExiste(elementoPolimorfo elem)
{
Boolean retorno = false;
foreach (elementoPolimorfo temp in listaPolimorfa)
{
if (elem.nombre.valLower.Equals(temp.nombre.valLower))
{
if (elem.compararParametros(temp.getListaLlaves()))
{
return(true);
}
//ahora hay que comprobar las llaves de los atributos
}
}
return(retorno);
}
public override void ejecutar(elementoClase simbolo)
{
if (hayErrores())
{
return;
}
// println("llego al contructor");
token tipo = getTipo();
token nombre = getIdentificador();
nodoModelo LST_CUERPO = getLST_CUERPO();
token visbilidad = getVisibilidad(simbolo);
int dimension = getDimensiones();
elementoPolimorfo element = new elementoPolimorfo(visbilidad, tablaSimbolos, tipo, nombre, LST_CUERPO, dimension);
cargarPolimorfismoHijos(element);
simbolo.lstMetodo_funcion.insertarElemento(element);
}
public void ejecutarOtros(elementoClase simbolo)
{
if (hayErrores())
{
return;
}
token tipo = new token("vacio");
token nombre = lstAtributos.getToken(0);
nodoModelo LST_CUERPO = getLST_CUERPO();
token visbilidad = getVisibilidad(simbolo);
int dimension = 0;
elementoPolimorfo element = new elementoPolimorfo(visbilidad, tablaSimbolos, tipo, nombre, LST_CUERPO, dimension);
cargarPolimorfismoHijos(element);
simbolo.lstMetodo_funcion.insertarElemento(element);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Primer analisis
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override void ejecutar(elementoClase simbolo)
{
if (hayErrores())
{
return;
}
// println("llego al contructor");
token tipo = new token("vacio");
token nombre = lstAtributos.getToken(1);
nodoModelo LST_CUERPO = getLST_CUERPO();
token visbilidad = new token("publico");
int dimension = 0;
elementoPolimorfo element = new elementoPolimorfo(visbilidad, tablaSimbolos, tipo, nombre, LST_CUERPO, dimension);
cargarPolimorfismoHijos(element);
simbolo.lstMetodo_funcion.insertarElemento(element);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DE METODO CONSTRUCTOR
|-------------------------------------------------------------------------------------------------------------------
|
*/
public void ejecutarMetodo(token nombre, lstValores parametros, elementoEntorno tablaEntorno)
{
//aqui es donde tengo que buscar si existe
Console.WriteLine("ejecutando Metodo:" + nombre.val);
elementoPolimorfo temp = getElementoPolimorfo2(nombre, parametros);
if (temp != null)
//neuvo entorno
{
elementoEntorno hijo1 = new elementoEntorno(tablaEntorno, tabla, "main", tablaEntorno.este);
if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO"))
/*
|----------------------------
| Ejecutando el cuerpo del metodo
|-----------------------
| Los constructores no retornan nada
*/
{
guardarParametrosEnLaTabla(temp.lstParametros, parametros, hijo1);
_LST_CUERPO val = (_LST_CUERPO)temp.LST_CUERPO;
val.ejecutar(hijo1);
}
else if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO2"))
/*
|----------------------------
| Ejecutando el cuerpo del metodo
|-----------------------
| Los constructores no retornan nada
*/
{
//cargo los parametros en el ambito global, jejejejeje
guardarParametrosEnLaTabla(temp.lstParametros, parametros, tablaEntorno);
//_LST_CUERPO2 val = (_LST_CUERPO2)temp.LST_CUERPO;
//val.ejecutarConstructor(hijo1, parametros);
}
}
}
public override void cargarPolimorfismo(elementoPolimorfo elem)
{
if (hayErrores())
{
return;
}
nodoModelo tempNodo = getNodo("TIPO");
if (tempNodo != null)
{
_TIPO temp = (_TIPO)tempNodo;
nodoModelo temp2 = getNodo("VAR_ARREGLO");
if (temp2 != null)
{
_VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2;
elem.insertarParametro(tempVar.getIdentificador(), temp.getTipo(), tempVar.getDimensiones());
}
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Para cargar las variables globales prro
|-------------------------------------------------------------------------------------------------------------------
|
*/
public void cargarVariableGlobal(elementoClase simbolo)
{
if (hayErrores())
{
return;
}
token tipo = getTipo();
token nombre = getIdentificador();
//nodoModelo LST_CUERPO = getLST_CUERPO();
token visbilidad = getVisibilidad(simbolo);
List <int> dimension = getDimensiones();
elementoPolimorfo element = new elementoPolimorfo(visbilidad, tablaSimbolos, tipo, nombre, getVAL(), dimension.Count);
cargarPolimorfismoHijos(element);
simbolo.lstVariablesGlobales.insertarElemento(element);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| FORMULARiO
|-------------------------------------------------------------------------------------------------------------------
|
*/
public List <elementoPolimorfo> getParametros()
{
List <elementoPolimorfo> lstElementosPolimorfos = new List <elementoPolimorfo>();
if (hayErrores())
{
return(lstElementosPolimorfos);
}
foreach (_PARAMETRO param in hijos)
{
elementoPolimorfo temp = param.getPolimorfo();
if (temp != null)
{
lstElementosPolimorfos.Add(temp);
}
else
{
println("Formulario, vino un elemento polimorfo nulo prro");
}
}
return(lstElementosPolimorfos);
}
/*
|--------------------------------------------------------------------------
| Cargando el elemento polimorfo, el que tiene metdos/func/vari
|--------------------------------------------------------------------------
|
*/
public virtual void cargarPolimorfismo(elementoPolimorfo elem)
{
cargarPolimorfismoHijos(elem);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DE METODO
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor getMetodoFuncion(token nombre, lstValores parametros, elementoEntorno tablaEntorno, String nombreAmbitoEntorno)
{
itemValor retorno = new itemValor();
retorno.setTypeVacio();
//aqui es donde tengo que buscar si existe
Console.WriteLine("ejecutando Metodo:" + nombre.val);
elementoPolimorfo temp = getElementoPolimorfo2(nombre, parametros);
if (temp != null)
//neuvo entorno
{
elementoEntorno hijo1 = new elementoEntorno(tablaEntorno, tabla, nombreAmbitoEntorno, tablaEntorno.este);
guardarParametrosEnLaTabla(temp.lstParametros, parametros, hijo1);
if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO"))
/*
|----------------------------
| Ejecutando el cuerpo del metodo
*/
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
_LST_CUERPO val = (_LST_CUERPO)temp.LST_CUERPO;
itemRetorno result = val.ejecutar(hijo1);
if (temp.tipo.valLower.Equals("vacio"))
{
if (result.isNormal())//que es el normal
{
}
else if (result.isRetorno())
{
if (result.valor.isTypeVacio())
//fue el return normla, sin expresion
{
}
else
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " está declarado como vacio, pero se retorno una expresión", temp.nombre);
}
}
else
{
}
}
else
/*
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
if (result.isNormal())
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " debe de retorar un valor", temp.nombre);
}
else if (result.isRetorno())
{
if (temp.dimension == result.valor.dimensiones.Count)
{
//para los tipos
if (itemEntorno.validandoTipo(temp.tipo.valLower, result.valor))
{
return(result.valor);
}
else
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " es de tipo :" + temp.tipo.val + " sin embargo tiene un retorno de tipo: " + result.valor.getTipo(), temp.nombre);
return(retorno);
}
}
else
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " es de dimensión :" + temp.dimension + " sin embargo tiene un retorno de dimensión: " + result.valor.dimensiones.Count, temp.nombre);
return(retorno);
}
}
else
{
}
}
///hay que comparar el retorno con el tipo definido
}
//Console.WriteLine("---------------------------Imprimiendo el metodo Funcion-------------------------");
//hijo1.imprimir();
}
return(retorno);
}
public override void cargarPolimorfismo(elementoPolimorfo elem)
{
//para no seguir ejecutando
}
