/*
|-------------------------------------------------------------------------------------------------------------------
| 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 elementoPolimorfo getConstructoHeredado(lstValores listaValores, token mensaje)
{
foreach (elementoPolimorfo temp in listaPolimorfa)
{
if (temp.compararParametrosLstValores(listaValores))
{
return(temp);
}
//ahora hay que comprobar las llaves de los atributos
}
tabla.tablaErrores.insertErrorSemantic("No se encuentra el constructor Heredado: super(" + listaValores.getCadenaParam() + ")", mensaje);
return(null);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Busca el elemento polimorfo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public elementoPolimorfo getElementoPolimorfo2(token nombre, lstValores listaValores)
{
foreach (elementoPolimorfo temp in listaPolimorfa)
{
if (nombre.valLower.Equals(temp.nombre.valLower))
{
//ahora hay que validar los parametros
if (temp.compararParametrosLstValores(listaValores))
{
return(temp);
}
//ahora hay que comprobar las llaves de los atributos
}
}
tabla.tablaErrores.insertErrorSemantic("No se encuentra " + nombre.val + "(" + listaValores.getCadenaParam() + ")", nombre);
return(null);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DE PRINCIPAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public void guardarParametrosEnLaTabla(Dictionary <llaveParametro, elementoParametro> lstParametros, lstValores lstParametros2, elementoEntorno elementoEntor)
{
if (lstParametros.Count == lstParametros2.listaValores.Count)
{
int i = 0;
foreach (var dic in lstParametros)
{
itemValor parametro2 = lstParametros2.getItemValor(i);
//Console.WriteLine("------------------------");
//Console.WriteLine("dic.key.dimension-> " + dic.Key.dimension);
//Console.WriteLine("parametro2.dimensiones->" + parametro2.dimensiones.Count);
if ((dic.Key.dimension == parametro2.dimensiones.Count) && (itemEntorno.validandoTipo(dic.Value.tipo.valLower, parametro2)))
{
token tNombre = new token(dic.Key.nombre);
token tTipo = new token(dic.Value.tipo.valLower);
//println("guardarParametrosEnLaTabla_ tipo->" + tTipo.valLower);
token tVisibilidad = new token("privado");
//listado de enteros
List <int> listaEntero = new List <int>();
for (int j = 0; i < dic.Key.dimension; i++)
{
listaEntero.Add(-1);
}
itemEntorno varParametro = new itemEntorno(tNombre, tTipo, parametro2, tVisibilidad, listaEntero, tabla);
elementoEntor.insertarEntorno(varParametro);
}
else
{
Console.WriteLine("[lstPolimorfismo]guardarParametrosEnLaTabla_Son de diferentes en tipo, o en dimensiones, aunque esto ya se tuvo que validar :/");
}
i++;
}
}
else
{
Console.WriteLine("[lstPolimorfismo]guardarParametrosEnLaTabla_Son de diferentes dimensiones, aunque esto ya se tuvo que validar :/");
}
}
