public override object ejecutar(Entorno ent)
{
String nombreEntorno = ent.nombreEntorno;
//creamos una nueva variable
Tipo_MF f = new Tipo_MF(tipo, this.nombre);
//debemos guardarlo con caracter especial para diferenciarlo de variables
String nuevoNombre = nombre + "#";
//Si trae una listaDeclaraciones
if (this.listaDeclaraciones != null)
{
f.setTipo(this.listaDeclaraciones, this.listaInstruccionesMF);
//recorremos las declaraciones (parametros)
foreach (Instruccion parametro in this.listaDeclaraciones)
{
var declaracionType = new Declaracion().GetType();
var parametroType = parametro.GetType();
//verificamos si es una declaracion para guardarlo en el nombre
if (parametroType == declaracionType)
{
foreach (String nombreParametro in ((Declaracion)parametro).IDS)
{
nuevoNombre += ((Declaracion)parametro).tipo.tipo; //si vienen dos IDS en lista, seguiran siendo del mismo tipo
}
}
else
{
//Si no era declaracion entonces es un error
MasterClass.Instance.addError(new C_Error("Semantico", "Se esperaba una declaracion de parametro para el metodo o funcion: " + nombre, linea, columna));
}
}
}
else
{
//si no tiene parametros entonces solo seteamos la lista de instrucciones
f.setTipo(this.listaInstruccionesMF);
}
Variable p = new Variable(tipo, f);
switch (tipo.tipo)
{
case Tipo.enumTipo.Void:
ent.insertar(nuevoNombre, p, linea, columna, "El procedimiento");
//MessageBox.Show("Insertando procedimiento");
break;
default:
ent.insertar(nuevoNombre, p, linea, columna, "La funcion");
//MessageBox.Show("Insertando funcion");
break;
}
return(null);
}
public override object ejecutar(Entorno ent)
{ //ent en este caso es el main
LinkedList <Expresion> resueltos = new LinkedList <Expresion>();
MasterClass.PilaMF.AddFirst(MasterClass.TipoMF.Metodo_Funcion);
//Creamos un nuevo entorno para ejecutar el metodo
Entorno nuevo = new Entorno(ent); //El global es el del objeto
//crea un clon del acceso y no manda nada porque no hay lista de accesos
Lista_Accesos acceso = new Lista_Accesos();
foreach (Id myId in this.id_.accesos)
{
acceso.accesos.AddLast(myId);
}
//creamos un literal para poder regresar
Object retorno = null;
//Modificamos el nombre
String aux = "";
String a2 = acceso.accesos.Last.Value.id;
String a3 = a2.Substring(0, 1);
if (!a3.Equals("#"))
{
aux = "#";
}
String nombreFuncion2 = acceso.accesos.Last.Value.id + aux;
//ahora ejecutamos las expresiones -> parametros enviados si esque tiene
if (this.enviados != null)
{
//recorremos los parametros enviados
//Aqui se le puede enviar un id -> debemos ir a buscarlo
foreach (Expresion parametro in this.enviados)
{
var parametroType = parametro.GetType();
var listaAccesosType = new Lista_Accesos().GetType();
if (typeof(Lista_Accesos).IsInstanceOfType(parametro))
{
Lista_Accesos a = (Lista_Accesos)parametro;
Expresion retAcceso = a.getValor(nuevo);
nombreFuncion2 += retAcceso.tipo.tipo.ToString();
resueltos.AddLast(retAcceso);
/*
* foreach (Id id in a.accesos)
* {
* Variable sim = id.getSimbolo(nuevo);
* Primitivo l = new Primitivo(sim.tipo, sim.valor);
* nombreFuncion2 += l.tipo.tipo.ToString();
* resueltos.AddLast(l);
* }
*/
}
else
{
nombreFuncion2 += parametro.getValor(nuevo).tipo.tipo.ToString();
resueltos.AddLast(parametro.getValor(nuevo));
}
}
}
//adjuntar el último valor modificado para el método
if (!aux.Equals("", StringComparison.InvariantCultureIgnoreCase))
{
Id id = acceso.accesos.Last.Value;
acceso.accesos.RemoveLast();
acceso.accesos.AddLast(new Id(nombreFuncion2, id.linea, id.columna));
}
//obtenemos el entorno global del objeto cuando realizamos la llamada
if (id_.accesos.Count > 1)
{
Entorno nuevo2 = ent.getEntornoAcceso(id_);
if (nuevo2 != null)
{
nuevo.global = nuevo2;
}
else
{
nuevo.global = ent.global;
}
}
else
{
nuevo.global = ent.global;
}
Variable f;
//luego buscamos la funcion
f = nuevo.buscar(acceso, linea, columna, "El procedimiento");
//si lo encontro
if (f != null)
{
//aqui pedimos el tipo
//creamos una variable (exit)
LinkedList <String> lista = new LinkedList <String>();
lista.AddLast(acceso.accesos.Last.Value.id);
Declaracion nombreFuncionDec = new Declaracion(f.tipo, lista, 0, 0);
nombreFuncionDec.ejecutar(nuevo);
//creamos un iterador
int iterador = 0;
//si tiene parametros y tambien tiene parametros enviados
//transformamos el simbolo encontrado a un simbolo nuevo de tipo metodo_Funcion para obtener la lista de parametros
if (enviados != null && ((Tipo_MF)f.valor).getparametros() != null)
{
//resolvemos los parametros enviados para tener el valor
foreach (Expresion enviado in enviados)
{
resueltos.AddLast(enviado.getValor(ent));
}
int cont = 0;
//Ejecutamos la lista de declaraciones para crear las variables
//y le asignamos el valor del enviado correspondiente para que sea asignado de una vez
foreach (Instruccion declaracion in ((Tipo_MF)f.valor).getparametros())
{
//((Declaracion)declaracion).valor = resueltos.ElementAt(iterador);
Tipo tipe = new Tipo(((Declaracion)declaracion).tipo.tipo);
foreach (String identify in ((Declaracion)declaracion).IDS) //Identificador a,b:integer m:integer
{
if (((Declaracion)declaracion).PorReferencia)
{
if (typeof(Lista_Accesos).IsInstanceOfType(this.enviados.ElementAt(cont)))
{
Lista_Accesos accesopos = (Lista_Accesos)this.enviados.ElementAt(cont);
Entorno temporal = nuevo;
Variable sim = null;
for (var temp = accesopos.accesos.First; temp != null; temp = temp.Next)
{
sim = temporal.buscar(temp.Value.id, linea, columna, "La variable");
if (sim != null)
{
if (temp.Next != null)
{
//esperamos un objeto
}
}
else
{
//error no se encontro la variable
return(null);
}
}
if (tipe.tipo == sim.tipo.tipo && sim.tipo.referencia == tipe.referencia)
{
nuevo.insertar(identify, sim, linea, columna, "La variable");
}
}
else
{
//Se esperaba un valor por referencia
}
}
else
{
Declaracion temp = new Declaracion(tipe, identify, resueltos.ElementAt(iterador), 0, 0);
((Declaracion)temp).valor = resueltos.ElementAt(iterador);//Expresion 1,2
temp.ejecutar(nuevo);
iterador++;
}
cont += 1;
}
}
}
/*
* Ejecucion como tal de la lista de declaraciones y de la lista de instrucciones (bloque)
*/
if (((Tipo_MF)f.valor).listaDeclaraciones != null)
{
foreach (Instruccion declaration in ((Tipo_MF)f.valor).listaDeclaraciones)
{
declaration.ejecutar(nuevo);
}
}
if (((Tipo_MF)f.valor).getbloque() == null)
{
foreach (Instruccion ins in ((Tipo_MF)f.valor).listaInstrucciones)
{
retorno = ins.ejecutar(nuevo);
}
}
else
{
//ejecutamos el bloque de instrucciones
retorno = ((Tipo_MF)f.valor).getbloque().ejecutar(nuevo);
}
//verificamos si enviaron un return
if (retorno != null)
{
Primitivo sim = (Primitivo)retorno;
//validamos el retorno dentro del metodo o funcion
if (f.tipo.tipo == Tipo.enumTipo.Void)
{
//error, porque si retorna algo no debe ser null
MasterClass.Instance.addError(new C_Error("Semantico", "No se esperaba retorno en metodo: " + nombreFuncion, linea, columna));
retorno = null;
}
else
{
//como no es void tiene tipo y verificamos que sea el mismo que la expresion recibida
if (f.tipo.tipo != sim.tipo.tipo)
{
//si no es el mismo entonces es un error
MasterClass.Instance.addError(new C_Error("Semantico", "El tipo de retorno y funcion no coinciden: " + sim.tipo.tipo + " = " + f.tipo.tipo, linea, columna));
retorno = null;
}
}
}
}
else
{
MasterClass.Instance.addError(new C_Error("Semantico", "El metodo " + nombreFuncion + " no existe en el contexto", linea, columna));
}
MasterClass.PilaMF.RemoveLast();
return(null);
}
