public void Ejecutar()
{
reiniciarEjecucion();
definirContextoGlobal();
Contexto local = new Contexto();
foreach (ParseTreeNode declaracion in variables)
{
Declaracion decla = new Declaracion(declaracion);
decla.ejecutar(local, Constantes.GLOBAL);
}
Console.WriteLine("contexto global creado");
if (Principal == null)
{
ListaErrores.getInstance().nuevoErrorGeneral("El metodo principal no ha sido definido", archivo);
return;
}
Cuerpo _principal = new Cuerpo(Principal.ChildNodes[0], false);
_principal.ejecutar(local, Constantes.GLOBAL + 1);
Console.WriteLine("Ejecucion Exitosa");
Console.WriteLine("Salida");
Interprete.getContextoGlobal().reporte();
local.reporte();
Console.WriteLine(Interprete.Salida);
}
/*
* Metodo de la implementacion
* @ts tabla de simbolos global
* @user usuario que ejecuta la accion
* @baseD base de datos donde estamos ejecutando todo
* @mensajes linkedlist con la salida deseada
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje ms = new Mensaje();
TablaDeSimbolos newAmbito = new TablaDeSimbolos();
foreach (Simbolo s in ambito.tablaPadre)
{
newAmbito.AddLast(s);
}
if (tamanioTotalParametros() == valores.Count())
{
int index = 0;
//-------------------------------------------- CREACION Y ASIGNACION DE PARAMETROS --------------------------------------------------------------
for (int i = 0; i < parametros.Count(); i++)
{
LinkedList <InstruccionCQL> parametro = parametros.ElementAt(i).lista;
for (int j = 0; j < parametro.Count(); j++)
{
Declaracion d = (Declaracion)parametro.ElementAt(j);
d.parametro = true;
object rd = d.ejecutar(newAmbito, ambito, tsT);
if (rd == null)
{
return(null);
}
Asignacion a = new Asignacion(d.id, l, c, valores.ElementAt(index), "ASIGNACION");
a.tPadre = ts;
object ra = a.ejecutar(newAmbito, ambito, tsT);
if (ra == null)
{
return(null);
}
index++;
}
}
//--------------------------------------------------- INSTRUCCIONES DEL PROCEDURE ----------------------------------------------
foreach (InstruccionCQL ins in cuerpo)
{
object r = ins.ejecutar(newAmbito, ambito, tsT);
if (r == null)
{
return(null);
}
else if (r.GetType() == typeof(Retorno))
{
object re = ((Retorno)r).valor;
if (re != null)
{
LinkedList <object> temp;
if (re.GetType() == typeof(LinkedList <object>))
{
temp = (LinkedList <object>)re;
}
else
{
temp = new LinkedList <object>();
temp.AddLast(re);
}
string idGenerado = idOut(temp);
if (idGenerado == null)
{
return(null);
}
if (idGenerado.Equals(identificadorRetornos))
{
return(temp);
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("numberreturnsexception", "La cantidad de valores retornados no concuerda con el valor de parametros se esperaba: " + identificadorRetornos + " se obtuvo " + idGenerado));
ambito.mensajes.AddLast(ms.error("La cantidad de valores retornados no concuerda con el valor de parametros se esperaba: " + identificadorRetornos + " se obtuvo " + idGenerado, l, c, "Semantico"));
return(null);
}
}
return(null);
}
}
if (identificadorRetornos.Equals(""))
{
return("");
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("numberreturnsexception", "Se necesita retornar valores de tipo: " + identificadorRetornos));
ambito.mensajes.AddLast(ms.error("Se necesita retornar valores de tipo: " + identificadorRetornos, l, c, "Semantico"));
return(null);
}
}
else
{
ambito.mensajes.AddLast(ms.error("La cantidad de valores no concuerda con la cantidad de parametros", l, c, "Semantico"));
}
return(null);
}
public override Expresion getValor(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
//creamos un literal para poder regresar
Expresion retorno = null;
//Modificamos el nombre
String aux = "";
String a2 = this.id;
String a3 = a2.Substring(0, 1);
if (!a3.Equals("#"))
{
aux = "#";
}
String nombreFuncion2 = this.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));
*
* }
*/
nuevo.global = ent.global;
Variable f;
//luego buscamos la funcion
f = nuevo.buscar(nombreFuncion2, linea, columna, "La Funcion");
//si lo encontro
if (f != null)
{
//aqui pedimos el tipo
//creamos una variable (exit)
LinkedList <String> lista = new LinkedList <String>();
lista.AddLast(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 = (Expresion)ins.ejecutar(nuevo);
}
}
else
{
//ejecutamos el bloque de instrucciones
retorno = (Expresion)((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 && ((Expresion)retorno).tipo.tipo != Tipo.enumTipo.Void) //viene exit vacio
{
//error, porque si retorna algo no debe ser null
MasterClass.Instance.addError(new C_Error("Semantico", "No se esperaba retorno en metodo: " + nombreFuncion2, linea, columna));
retorno = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
}
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 = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
}
}
}
else
{
//buscamos la variable con el mismo de la funcion
Variable nombreFuncionVar = nuevo.buscar(id, linea, columna, "La variable");
retorno = new Primitivo(f.tipo, nombreFuncionVar.valor);
}
}
else
{
MasterClass.Instance.addError(new C_Error("Semantico", "El metodo " + nombreFuncion2 + " no existe en el contexto", linea, columna));
}
MasterClass.PilaMF.RemoveLast();
return(retorno);
}
/*
* Metodo de la implementacion
* @ts tabla de simbolos global
* @user usuario que ejecuta la accion
* @baseD base de datos donde estamos ejecutando todo
* @mensajes linkedlist con la salida deseada
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje ms = new Mensaje();
object res = ts.getValor(id);
if (!res.Equals("none"))
{
if (res.GetType() == typeof(TypeCursor))
{
TypeCursor tabla = (TypeCursor)res;
if (tabla.tabla != null)
{
generarIdentificador(tabla.tabla);
if (tabla.tabla.columnas.Count() == parametros.Count())
{
string identificadorParametros = generarIdentificadorDeclaracion();
if (identificadorParametros.Equals(identificador))
{
foreach (Data data in tabla.tabla.datos)
{
TablaDeSimbolos newAmbito = new TablaDeSimbolos();
foreach (Simbolo s in ambito.tablaPadre)
{
newAmbito.AddLast(s);
}
//-------------------------------------- ASIGNARLE A LOS PARAMETROS LOS VALORES DE LA CONSULTA ----------------------------
for (int i = 0; i < parametros.Count(); i++)
{
Declaracion d = (Declaracion)parametros.ElementAt(i);
d.parametro = true;
object rd = d.ejecutar(newAmbito, ambito, tsT);
if (rd == null)
{
return(null);
}
Atributo atributo = data.valores.ElementAt(i);
newAmbito.setValor(d.id, atributo.valor);
}
//---------------------------------------- EJECUTAR INSTRUCCIONES DENTRO DEL FOREACH -----------------------------------------
foreach (InstruccionCQL i in cuerpo)
{
object resultado = i.ejecutar(newAmbito, ambito, tsT);
if (resultado == null)
{
return(null);
}
else if (resultado.GetType() == typeof(Retorno))
{
return((Retorno)resultado);
}
else if (i.GetType() == typeof(Continue) || resultado.GetType() == typeof(Continue))
{
break;
}
}
}
return("");
}
else
{
ambito.mensajes.AddLast(ms.error("No coinciden el tipo de parametros con el tipo de columnas", l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(ms.error("No coincide la cantidad de parametros con la cantidad de columnas", l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(ms.error("El cursor: " + id + " no ha sido abierto", l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(ms.error("La variable tiene que ser de tipo Cursor no se reconoce: " + res, l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(ms.error("La variable : " + id + " no existe en este ambito", l, c, "Semantico"));
}
return(null);
}
public void codigoaEvaluar(string strCodigoaEvaluar)
{
//MessageBox.Show("" + codF);
Analizadores.Analizador analizar = new Analizador(new Gramatica());
ParseTree arbol = analizar.isValid(strCodigoaEvaluar);
if (arbol != null)
{
ConstructorAst constAst = new ConstructorAst();
AST arbolAux = constAst.Analizar(arbol.Root);
Ambito global = new Ambito(null);
try {
if (arbolAux != null)
{
foreach (Instruccion inst in arbolAux.Instrucciones)
{
//if (inst is Funcion) {
//}
if (inst is Declaracion)
{
Declaracion declaracion = (Declaracion)inst;
declaracion.ejecutar(global, arbolAux);
}
//toca deficion clase
}
foreach (Instruccion ins in arbolAux.Instrucciones)
{
if (ins is Funcion)
{
Funcion funcion = (Funcion)ins;
global.agregar(funcion.Id, funcion);
foreach (NodoAST instruccion in funcion.LLInstrucciones)
{
//if (instruccion is DefinicionStruct)
//{
// DefinicionStruct crear = (DefinicionStruct)instruccion;
// crear.ejecutar(global, auxArbol);
//}
}
}
if (ins is Declaracion)
{
Declaracion declaracion = (Declaracion)ins;
declaracion.ejecutar(global, arbolAux);
}
//if (ins is DefinicionStruct)
//{
// DefinicionStruct crear = (DefinicionStruct)ins;
// crear.ejecutar(global, auxArbol);
//}
}
foreach (Instruccion ins in arbolAux.Instrucciones)
{
if (ins is Principal)
{
Principal main = (Principal)ins;
Ambito local = new Ambito(global);
main.ejecutar(local, arbolAux);
}
}
}
else
{
MessageBox.Show("Cadena invalida");
}
}
catch (Exception ex) {
MessageBox.Show(ex.ToString());
}
//analizar.parse(arbol, new PrimeraPasada());
MessageBox.Show("Cadena Valida");
}
else
{
MessageBox.Show("No Valida");
}
}
private void btnInterpretar_Click(object sender, EventArgs e)
{
if (!txtEntrada.Text.Equals(string.Empty))
{
Gramatica grammar = new Gramatica();
LanguageData lenguaje = new LanguageData(grammar);
Parser parser = new Parser(lenguaje);
ParseTree arbol = parser.Parse(txtEntrada.Text);
if (arbol.ParserMessages.Count == 0)
{
Graficador j = new Graficador();
j.graficar(arbol.Root);
ConstructorAST an = new ConstructorAST();
AST auxArbol = an.Analizar(arbol.Root);
Entorno global = new Entorno(null);
try
{
if (auxArbol != null)
{
foreach (Instruccion ins in auxArbol.Instrucciones)
{
if (ins is Funcion)
{
Funcion funcion = (Funcion)ins;
global.agregar(funcion.Identificador, funcion);
foreach (NodoAST instruccion in funcion.Instrucciones)
{
if (instruccion is DefinicionStruct)
{
DefinicionStruct crear = (DefinicionStruct)instruccion;
crear.ejecutar(global, auxArbol);
}
}
}
if (ins is Declaracion)
{
Declaracion declaracion = (Declaracion)ins;
declaracion.ejecutar(global, auxArbol);
}
if (ins is DefinicionStruct)
{
DefinicionStruct crear = (DefinicionStruct)ins;
crear.ejecutar(global, auxArbol);
}
}
foreach (Instruccion ins in auxArbol.Instrucciones)
{
if (ins is Main)
{
Main main = (Main)ins;
foreach (NodoAST instruccion in main.Instrucciones)
{
if (instruccion is DefinicionStruct)
{
DefinicionStruct crear = (DefinicionStruct)instruccion;
crear.ejecutar(global, auxArbol);
}
}
Entorno local = new Entorno(global);
main.ejecutar(local, auxArbol);
}
}
}
else
{
MessageBox.Show("El arbol de Irony no se construyo. Cadena invalida!\n");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
else
{
// Aca deben gestionar esos errores :)
MessageBox.Show("Hay errores lexicos o sintacticos\n El arbol de Irony no se construyo. Cadena invalida!\n");
}
}
}
