public object Ejecutar(Ambito ambito)
{
try
{
List <Object> valores = getValoresParam(ambito);
ClaveFuncion clave = new ClaveFuncion("padre", "vacio", getNodoParametros(ambito));
Ambito aux = buscaElGlobal(ambito);
Constructor c = aux.getConstructor(clave);
if (c != null)
{
Ambito local = new Ambito(ambito, "padre", ambito.archivo);
local = c.seteaParametrosLocales(local, valores);
c.Ejecutar(local);
return(new Nulo());
}
else if (c == null && this.expresiones.Count == 0)
{
return(new Nulo());
}
else
{
TError error = new TError("Ejecucion", "No existe un construcotr de la clase padre que contenga los parametros indicados en Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
catch (Exception e)
{
TError error = new TError("Ejecucion", "Error al intentar ejecutar Super en Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Error: " + e.Message, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
return(new Nulo());
}
public object Ejecutar(Ambito ambito)
{
try
{
ClaveFuncion clave = new ClaveFuncion(this.clase.ToLower(), "vacio", this.parametros);
if (!ambito.existeConstructor(clave))
{
Constructor c = new Constructor(this.parametros, instrucciones, this.linea, this.columna, this.clase);
ambito.agregarConstructor(clave, c);
}
else
{
TError error = new TError("Semantico", "Ya existe una definicion de Constructor: " + this.clase + " con la misma cantidad de parametros y tipo | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
catch (Exception e)
{
TError error = new TError("Ejecucion", "Error en la ejecucion de Declaracion de Constructor: " + this.clase + " | Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Error: " + e.Message, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
return(null);
}
public Constructor getConstructor(ClaveFuncion clave)
{
if (this.tablaConst.existeConstructor(clave))
{
return(this.tablaConst.getConstructro(clave));
}
return(null);
}
public Constructor getConstructro(ClaveFuncion clave)
{
if (existeConstructor(clave))
{
return((Constructor)this.constructores[clave]);
}
else
{
return(null);
}
}
public void tomarConstructores(TablaConstructores tablaPadre)
{
Hashtable auxiliar = tablaPadre.constructores;
foreach (DictionaryEntry data in auxiliar)
{
if (data.Value is Constructor)
{
Constructor cons = (Constructor)data.Value;
ClaveFuncion c = (ClaveFuncion)data.Key;
this.tablaConst.AgregaConstrucor(c, cons);
}
}
}
public void heredaConstructores(TablaConstructores tabla)
{
Hashtable auxiliar = tabla.constructores;
foreach (DictionaryEntry data in auxiliar)
{
if (data.Value is Constructor)
{
Constructor cons = (Constructor)data.Value;
ClaveFuncion c = (ClaveFuncion)data.Key;
c.idFuncion = "padre";
c.Tipo = "vacio";
this.tablaConst.AgregaConstrucor(c, cons);
}
}
}
public void agregarConstructor(ClaveFuncion clave, Constructor constr)
{
this.tablaConst.AgregaConstrucor(clave, constr);
}
public Boolean existeConstructor(ClaveFuncion clave)
{
return(this.tablaConst.existeConstructor(clave));
}
public object Ejecutar(Ambito ambito)
{
try
{
Simbolo s = (Simbolo)ambito.getSimbolo(this.identificador.ToLower());
if (s != null)
{
if (s is Variable)
{
Variable v = (Variable)s;
Object valor = v.valor;
if (valor is Objeto)
{
Objeto ob = (Objeto)valor;
List <Object> valores = getValoresParams(ambito);
if (ob.idClase.ToLower().Equals("pregunta"))
{
Ambito ambitoPregunta = ob.ambito; // obtengo el ambito de la pregunta
/*obtendre el constructor de la pregunta para poder setear los parametros que hagan falta*/
ClaveFuncion clave = new ClaveFuncion(this.identificador.ToLower(), "vacio", getNodosParametros(ambito));
Constructor constructor = (Constructor)ambitoPregunta.getConstructor(clave);
if (constructor != null)
{
Variable instruc = (Variable)ambitoPregunta.getSimbolo("instr");
List <Instruccion> declaraciones = (List <Instruccion>)instruc.valor;/*ya tengo las instrucciones que hacen la ejecucion de delcaraciones*/
if (existePropiedad("etiqueta", ambitoPregunta))
{
/*EN CASO QUE LA PROPIEDAD YA EXISTA EN LA PREGUNTA: RESETEO EL AMBITO*/
ambitoPregunta = new Ambito(ambitoPregunta.Anterior, ambitoPregunta.idAmbito, ambitoPregunta.archivo);
ambitoPregunta.agregarConstructor(clave, constructor);
ambitoPregunta.agregarVariableAlAmbito("instr", instruc);
}
/*aqui ya setee los parametros que venian en la pregunta en el ambito global ahora voy a ejecutar las declaraciones sobre este ambito*/
ambitoPregunta = constructor.seteaParametrosLocales(ambitoPregunta, valores);
ejecutaLasDeclaracionesPregunta(ambitoPregunta, declaraciones); /*carga todo lo de la pregunta*/
Pregunta p = new Pregunta(ambitoPregunta, this.identificador.ToLower(), this.numero); // formo la pregunta
Nota n = new Nota(p);
n.ShowDialog();
if (llamaMostar)
{
Ambito aux = ambitoPregunta.Anterior;
ambitoPregunta.Anterior = null;
LLamadaFuncion l = new LLamadaFuncion(clase, linea, columna, new Llamada("mostrar", linea, columna, clase));
l.Ejecutar(ambitoPregunta);
ambitoPregunta.Anterior = aux;
}
ob.ambito = ambitoPregunta; /*ASIGNO EL NUEVO AMBITO A OB*/
if (n.salir != null)
{
return(n.salir);
}
}
else
{
TError error = new TError("Semantico", "Para el simbolo: \"" + identificador + "\" No existe una pregunta de tipo Nota que rebiba los parametros especificados | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
}
else
{
TError error = new TError("Semantico", "El simbolo: \"" + identificador + "\" No es un objeto de tipo Pregunta, por lo que no es aplicable la instrucccion | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
}
else
{
TError error = new TError("Semantico", "El simbolo: \"" + identificador + "\" No es un objeto de tipo Nota, por lo que no es aplicable la instrucccion | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
}
else
{
TError error = new TError("Semantico", "El simbolo: \"" + identificador + "\" No es un objeto de tipo Nota, por lo que no es aplicable la instrucccion | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
}
else
{
TError error = new TError("Semantico", "La referencia a la pregunta de tipo Nota: \"" + identificador + "\" es Nulo, no existe en este ambito | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
}
catch (Exception e)
{
TError error = new TError("Ejecucion", "Error al ejecutar la Instrccion Nota() | Clase: " + clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
return(new Nulo());
}
public object getValor(Ambito ambito)
{
try
{
Clase obj = Estatico.clasesDisponibles.getClase(this.tipo);
if (obj != null)
{
//TENGO QUE COMPILAR LA CLASE PRIMERO
///
List <Object> valores = getValoresParams(ambito);
///
Ambito auxiliar = new Ambito(null, obj.idClase, obj.ArchivoOrigen);
auxiliar = (Ambito)obj.Ejecutar(auxiliar);
/////////////////////////////////////
ClaveFuncion clave = new ClaveFuncion(obj.idClase.ToLower(), "vacio", getNodosParametros(ambito));
////////////////////////////////////////////////
/// TOMO EL CONSTRUCCTOR
Constructor c = auxiliar.getConstructor(clave);
/////////////////////////////////////////////////
if (c != null)
{
/// SETEANDO LOS PARAMETROS
/// 1) CREO EL CONSTRUCTOR LOCAL
Ambito local = new Ambito(auxiliar, this.clase.ToLower(), ambito.archivo);
/// 2) SETEO SUS PARAMETROS
//local = c.seteaParametrosLocales(local, getValoresParams(ambito));
local = c.seteaParametrosLocales(local, valores);
/// EJECUCION DEL CONSTRUCTOR EN SI
c.Ejecutar(local);
/// 3) LE PASO EL AMBITO AUXILIAR DE LA CLASE AL OBJETO
Objeto objeto = new Objeto(obj.idClase.ToLower(), auxiliar);
this.valorAux = obj.idClase.ToLower();
/// 4) LO RETORNO
return(objeto);
}
else if (c == null && this.parametros.Count == 0)//CLASE SIN CONSTRUCTOR
{
/// 1) CREO EL AMBITO LOCAL
Ambito local = new Ambito(auxiliar, this.clase.ToLower(), ambito.archivo);
Objeto objeto = new Objeto(obj.idClase.ToLower(), auxiliar);
this.valorAux = obj.idClase.ToLower();
return(objeto);
}
else
{
TError error = new TError("Semantico", "Error Constructor: " + clave.mensajeError + " | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
return(null);
}
else
{
TError error = new TError("Semantico", "No existe una clase: \"" + this.tipo + "\" Para realizar una Instancia, En Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
catch (Exception e)
{
TError error = new TError("Ejecucion", "Error al Crear un Objeto en Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Error: " + e.Message, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
return(new Nulo());
}
public void AgregaConstrucor(ClaveFuncion clave, Constructor constructor)
{
this.constructores.Add(clave, constructor);
}
public Boolean existeConstructor(ClaveFuncion clave)
{
return(this.constructores.ContainsKey(clave));
}
public object Ejecutar(Ambito ambito)
{
try
{
Simbolo s = (Simbolo)ambito.getSimbolo(this.identificador.ToLower());
if (s != null)
{
if (s is Variable)
{
Variable v = (Variable)s;
Object valor = v.valor;
if (valor is Objeto)
{
Objeto ob = (Objeto)valor;
List <Object> valores = getValoresParams(ambito);
if (ob.idClase.ToLower().Equals("pregunta"))
{
Ambito ambitoPregunta = ob.ambito; /*oteniendo el ambito de la pregunta*/
/*obtendre el constructor de la pregunta para poder setear los parametros que hagan falta*/
ClaveFuncion clave = new ClaveFuncion(this.identificador.ToLower(), "vacio", getNodosParametros(ambito));
Constructor constructor = (Constructor)ambitoPregunta.getConstructor(clave);
if (constructor != null)
{
Variable instruc = (Variable)ambitoPregunta.getSimbolo("instr");
List <Instruccion> declaraciones = (List <Instruccion>)instruc.valor;/*ya tengo las instrucciones que hacen la ejecucion de delcaraciones*/
if (existePropiedad("etiqueta", ambitoPregunta))
{
/*EN CASO QUE LA PROPIEDAD YA EXISTA EN LA PREGUNTA: RESETEO EL AMBITO*/
ambitoPregunta = new Ambito(ambitoPregunta.Anterior, ambitoPregunta.idAmbito, ambitoPregunta.archivo);
ambitoPregunta.agregarConstructor(clave, constructor);
ambitoPregunta.agregarVariableAlAmbito("instr", instruc);
}
ambitoPregunta = constructor.seteaParametrosLocales(ambitoPregunta, valores);
ejecutaLasDeclaracionesPregunta(ambitoPregunta, declaraciones); /*carga todo lo de la pregunta*/
Pregunta p = new Pregunta(ambitoPregunta, this.identificador.ToLower(), this.numero); // formo la pregunta
if (this.extensiones != null)
{
/*AQUI CUANDO ADMITEN SOLO CIERTAS EXTENSIONES*/
Object ext = this.extensiones.getValor(ambito);
if (ext is String)
{
this.numero = Estatico.numPregunta;
Estatico.numPregunta++;
Fichero f = new Fichero(p, (String)ext, linea, columna, clase, ambito.archivo);
f.ShowDialog();
String resp = f.rutaArchivo;
if (resp.Equals(""))
{
resp = "No se subio ningun Archivo!";
}
PreguntaAlmacenada pr = new PreguntaAlmacenada(p.idPregunta, p.etiqueta, this.numero);
pr.addAnswer(" Archivo Almacenado en: " + resp);
Estatico.resps.Add(pr);
ob.ambito = ambitoPregunta;/*ASIGNO EL NUEVO AMBITO A OB*/
if (f.salir != null)
{
return(f.salir);
}
}
else
{
TError error = new TError("Semantico", "Para el simbolo: \"" + identificador + "\", Se espera una cadena especificando el formato de las Extensiones de Archivos | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
}
else
{
/*AQUI CUANDO ADMITEN CUALQUIER EXTENSION*/
this.numero = Estatico.numPregunta;
Estatico.numPregunta++;
Fichero f = new Fichero(p, "", linea, columna, clase, ambito.archivo);
f.ShowDialog();
String resp = f.rutaArchivo;
if (resp.Equals(""))
{
resp = "No se subio ningun Archivo!";
}
PreguntaAlmacenada pr = new PreguntaAlmacenada(p.idPregunta, p.etiqueta, this.numero);
pr.addAnswer(" Archivo Almacenado en: " + resp);
Estatico.resps.Add(pr);
ob.ambito = ambitoPregunta;/*ASIGNO EL NUEVO AMBITO A OB*/
if (f.salir != null)
{
return(f.salir);
}
}
}
else
{
TError error = new TError("Semantico", "Para el simbolo: \"" + identificador + "\" No existe una pregunta de tipo Fichero que rebiba los parametros especificados | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
}
else
{
TError error = new TError("Semantico", "El simbolo: \"" + this.identificador + "\" no es de tipo Pregunta | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
}
else
{
TError error = new TError("Semantico", "El simbolo: \"" + this.identificador + "\" no es de tipo Pregunta | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
}
else
{
TError error = new TError("Semantico", "El simbolo: \"" + this.identificador + "\" no es de tipo Pregunta | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
}
else
{
TError error = new TError("Semantico", "No existe la pregunta de tipo Fichero: \"" + this.identificador + "\" | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
}
catch (Exception e)
{
TError error = new TError("Ejecucion", "Error al ejecutar el guardar un Fichero | Clase: " + clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false);
Estatico.ColocaError(error);
Estatico.errores.Add(error);
}
return(new Nulo());
}