//TODO: validar tipos
public override Objeto execute(Entorno entorno)
{
Simbolo simbolo = retornar_asignacion(entorno);
No_constante(simbolo);
Objeto valor = retornar_valor_nuevo(entorno);
Validar_tipos(simbolo.getValor(), valor);
simbolo.setValor(valor);
return(simbolo.getValor());
}
public override Objeto executar_funcion_usuario(Entorno entorno)
{
Simbolo simbolo_retorno = new Simbolo(base.getNombre(), this.retorno, base.getLinea(), base.getColumna());
entorno.addSimbolo(simbolo_retorno, base.getNombre());
foreach (Nodo instruccion in this.instrucciones)
{
if (instruccion != null)
{
try
{
Objeto retorno = instruccion.execute(entorno);
if (retorno != null)
{
if (retorno.getTipo() == Objeto.TipoObjeto.CONTINUE)
{
Sentencia_transferencia tem = (Sentencia_transferencia)retorno;
Error error = new Error(tem.linea, tem.columna, Error.Errores.Semantico,
"Sentencia continue debe estar dentro de un ciclo");
Captura_error(error);
}
else if (retorno.getTipo() == Objeto.TipoObjeto.BREAK)
{
Sentencia_transferencia tem = (Sentencia_transferencia)retorno;
Error error = new Error(tem.linea, tem.columna, Error.Errores.Semantico,
"Sentencia break debe estar dentro de un ciclo o case");
Captura_error(error);
}
else if (retorno.getTipo() == Objeto.TipoObjeto.NULO)
{
Sentencia_transferencia tem = (Sentencia_transferencia)retorno;
if (tem.valor != null)
{
Validar_retorno(tem.valor, instruccion);
return(tem.valor);
}
else
{
Error error = new Error(tem.linea, tem.columna, Error.Errores.Semantico,
"La sentencia de exit en funcion debe de retornar un valor");
Captura_error(error);
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
//throw new Exception(e.ToString());
}
}
}
Simbolo aux = entorno.GetSimbolo(base.getNombre());
return(aux.getValor());
}
public Simbolo retornar_simbolo(Entorno entorno)
{
if (this.llamada_anterior == null)
{
Simbolo simbolo_retorno = entorno.GetSimbolo(this.nombre_variable);
if (simbolo_retorno == null)
{
Error error = new Error(base.getLinea(), base.getColumna(), Error.Errores.Semantico,
"Error el simbolo: " + this.nombre_variable + " no se encontro");
Maestra.getInstancia.addError(error);
throw new Exception("Error el simbolo: " + this.nombre_variable + " no se encontro");
}
if (simbolo_retorno.getValor().getTipo() == Objeto.TipoObjeto.ARRAY)
{
return(Recorrer_array(entorno, simbolo_retorno));
}
return(simbolo_retorno);
}
else
{
Simbolo simbolo_retorno = llamada_anterior.retornar_simbolo(entorno);
if (simbolo_retorno.getValor().getTipo() == Objeto.TipoObjeto.ARRAY)
{
simbolo_retorno = Recorrer_array(entorno, simbolo_retorno);
}
Validar_Nivel(simbolo_retorno);
Simbolo atributo_objeto = simbolo_retorno.getValor().get_atributo(this.nombre_variable);
if (atributo_objeto == null)
{
Error error = new Error(base.getLinea(), base.getColumna(), Error.Errores.Semantico,
"Error el simbolo: " + this.nombre_variable + " no se encontro");
Maestra.getInstancia.addError(error);
throw new Exception("Error el simbolo: " + this.nombre_variable + " no se encontro");
}
return(atributo_objeto);
}
}
public void Validar_Nivel(Simbolo simbolo)
{
if (simbolo.getValor().getTipo() != Objeto.TipoObjeto.OBJECTS)
{
Error error = new Error(base.getLinea(), base.getColumna(), Error.Errores.Semantico,
"El simbolo: " + this.nombre_variable + "no es de tipo objeto");
Maestra.getInstancia.addError(error);
throw new Exception("El simbolo: " + this.nombre_variable + "no es de tipo objeto");
}
}
public Simbolo Recorrer_array(Entorno entorno, Simbolo array)
{
if (this.dimensiones == null)
{
return(array);
}
foreach (Nodo exp in this.dimensiones)
{
if (array.getValor().getTipo() == Objeto.TipoObjeto.ARRAY)
{
Objeto valor = exp.execute(entorno);
Validar_Entero(valor);
int valor_intero = int.Parse(valor.getValor().ToString());
try
{
array = array.getValor().get_posicion(valor_intero);
}
catch (Exception e)
{
Error error = new Error(base.getLinea(), base.getColumna(), Error.Errores.Semantico,
e.ToString() + this.nombre_variable);
Maestra.getInstancia.addError(error);
throw new Exception(e.ToString());
}
}
else
{
Error error = new Error(base.getLinea(), base.getColumna(), Error.Errores.Semantico,
"El simbolo definido: " + this.nombre_variable + " no es un arreglo o las dimensiones no son las correctas");
Maestra.getInstancia.addError(error);
throw new Exception("Dimensiones incorrectas");
}
}
return(array);
}
public override Objeto execute(Entorno entorno)
{
//TODO: implementar asignacion, validar que sea integer
Simbolo inicio = this.condicion.execute_for(entorno);
validar_integer(inicio.getValor());
Objeto final = obtener_expresion(entorno);
validar_integer(final);
int b = Int16.Parse(final.getValor().ToString());
// Asignacion se debe agregar aca
int a = Int16.Parse(inicio.getValor().getValor().ToString());
if (comportamiento)
{
for (int i = a; i >= b; i--)
{
Primitivo pr = new Primitivo(Objeto.TipoObjeto.INTEGER, i);
inicio.setValor(pr);
foreach (Nodo instruccion in this.instrucciones)
{
if (instruccion != null)
{
try
{
Objeto retorno = instruccion.execute(entorno);
if (retorno != null)
{
if (retorno.getTipo() == Objeto.TipoObjeto.CONTINUE)
{
break;
}
else if (retorno.getTipo() == Objeto.TipoObjeto.BREAK)
{
return(null);
}
else if (retorno.getTipo() == Objeto.TipoObjeto.NULO)
{
return(retorno);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
}
}
else
{
for (int i = a; i <= b; i++)
{
Primitivo pr = new Primitivo(Objeto.TipoObjeto.INTEGER, i);
inicio.setValor(pr);
foreach (Nodo instruccion in this.instrucciones)
{
if (instruccion != null)
{
try
{
//validar los retornos
Objeto retorno = instruccion.execute(entorno);
if (retorno != null)
{
if (retorno.getTipo() == Objeto.TipoObjeto.CONTINUE)
{
break;
}
else if (retorno.getTipo() == Objeto.TipoObjeto.BREAK)
{
return(null);
}
else if (retorno.getTipo() == Objeto.TipoObjeto.NULO)
{
return(retorno);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
}
}
return(null);
}
//ejecuta
public Objeto Ejecutar_Funcion_usuario(Entorno entorno, Funcion llamada)
{
// Se procede a copiar la lista de parametros a un arreglo
Parametro[] auxiliar = new Parametro[llamada.getParametros().Count];
llamada.getParametros().CopyTo(auxiliar, 0);
//Se procede a validar el total de parametros con el total enviados
Validar_total_parametros(llamada);
// enlaza los entornos, con el entorno global del programa
Entorno nuevo_entorno = new Entorno(entorno.getGlobal(), llamada.getNombre());
int contador = 0;
foreach (Nodo node in this.parametros)
{
if (node != null)
{
try
{
if (auxiliar[contador].GetTipo_Parametro() == Parametro.Tipo_Parametro.VALOR)
{
// obtiene lo que viene por valor
Objeto salida = node.execute(entorno);
Match_Parametro(auxiliar[contador], salida);
Simbolo simbolo = new Simbolo(auxiliar[contador].getNombreParametro(), salida, Simbolo.Tipo_variable.VAR, llamada.getLinea(), llamada.getColumna());
nuevo_entorno.addSimbolo(simbolo, auxiliar[contador].getNombreParametro());
}
else
{
//obtiene lo que se manda por referencia y se guarda ese mismo simbolo
if (node is Acceso aux)
{
Simbolo salida = aux.execute_no_clonador(entorno);
Match_Parametro(auxiliar[contador], salida.getValor());
nuevo_entorno.addSimbolo(salida, auxiliar[contador].getNombreParametro());
}
else
{
Error error = new Error(node.getLinea(), node.getColumna(), Error.Errores.Semantico,
"se esperaba un identificador de variable");
Maestra.getInstancia.addError(error);
throw new Exception("se esperaba un identificador de variable");
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw new Exception(e.ToString());
}
}
contador++;
}
// TODO: verificar el cambio de esto
//llamada.setLinea(base.getLinea());
//llamada.setColumna(base.getColumna());
auxiliar = null;
Objeto retorno = llamada.executar_funcion_usuario(nuevo_entorno);
return(retorno);
}
public override Objeto execute(Entorno entorno)
{
Simbolo valor = this.retornar_simbolo(entorno);
return(valor.getValor().Clonar_Objeto());
}