public void EjecutarMientras(Simbolo mientras)
{
FMientras fmientras = (FMientras)mientras.Objeto;
NodoExpresion condicion = fmientras.Condicion.ResolverExpresion(fmientras.Incerteza, fmientras.RutaArchivo);
if (TitusNotifiaciones.ContarErrores() == 0)
{
if (condicion.Tipo == Constante.TBool)
{
while (TitusNotifiaciones.ContarErrores() == 0 && condicion.Booleano && !TablaVariables.IsRetorno() && !TablaVariables.IsDetener() && !TablaVariables.IsRetorno())
{
EjecutarInstrucciones(fmientras.ambito.TablaSimbolo);
if (TablaVariables.IsContinuar())
{
TablaVariables.SacarVariable();
}
condicion = fmientras.Condicion.ResolverExpresion(fmientras.Incerteza, fmientras.RutaArchivo);
SacarAmbito(fmientras.ambito.TablaSimbolo);
}
if (TablaVariables.IsDetener())
{
TablaVariables.SacarVariable();
}
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "Se esperaba un valor Bool no uno de tipo: " + condicion.Tipo, fmientras.RutaArchivo, mientras.Fila.ToString(), mientras.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
}
public void LlenarGlobal()
{
//metemos las variables globales a la tabla y los metodos del primer archivo
foreach (Simbolo global in Inicio.Global.TablaSimbolo)
{
switch (global.Rol)
{
case Constante.DECLARACION:
if (!TablaVariables.BuscarNombre(global.Nombre))
{
EjecutarDeclaracion(global);
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "Ya hay declarado un metodo o variable con el nombre " + global.Nombre, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
break;
case Constante.TPrincipal:
if (TablaVariables.Tabla[0].Nombre != Constante.TPrincipal)
{
TablaVariables.Tabla[0] = new Variables(Constante.TPrincipal, Constante.TPrincipal, Constante.TPrincipal, global.Objeto, global.Ambito, global.Fila, global.Columna);
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "Ya hay declarado un metodo principal", global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
break;
case Constante.FUNCION:
if (TablaVariables.BuscarVariable(global.Nombre) == null)
{
if (TablaVariables.BuscarMetodo(global.Nombre, (FFuncion)global.Objeto) == false)
{
TablaVariables.Tabla.Add(new Variables(global.Tipo, global.Nombre, Constante.TMetodo, global.Objeto, global.Ambito, global.Fila, global.Columna));
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "Ya hay declarado un metodo con el nombre " + global.Nombre + " y los mismos parametros", global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "Ya hay declarada una variable con el metodo " + global.Nombre, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
break;
}
}
}
public void SacarAmbito(List <Simbolo> variables)
{
int cont = variables.Count - 1;
while (cont >= 0)
{
if (variables[cont].Rol == Constante.DECLARACION)
{
if (TablaVariables.ExisteVariableTope(variables[cont].Nombre))
{
TablaVariables.SacarVariable(variables[cont].Nombre);
}
}
cont--;
}
}
public void EjecutarAsignacion(Simbolo global)
{
FExpresion expresion = (FExpresion)global.Objeto;
if (expresion != null)
{
NodoExpresion valor = expresion.ResolverExpresion(expresion.Incerteza, expresion.RutaArchivo);
Variables aux = TablaVariables.BuscarVariable(global.Nombre);
if (TitusNotifiaciones.ContarErrores() == 0)
{
if (aux != null)
{
if (aux.Tipo == Constante.TString)
{
if (valor.Tipo == Constante.TString || valor.Tipo == Constante.TNumber || valor.Tipo == Constante.TBool)
{
valor.Tipo = valor.Tipo;
aux.Valor = new NodoExpresion(valor);
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "No se puede asignar una variable de tipo " + global.Tipo + " un valor " + valor.Tipo, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
else if (aux.Tipo == Constante.TNumber)
{
if (valor.Tipo == Constante.TNumber || valor.Tipo == Constante.TBool)
{
valor.Tipo = valor.Tipo;
aux.Valor = new NodoExpresion(valor);
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "No se puede asignar una variable de tipo " + global.Tipo + " un valor " + valor.Tipo, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
else if (aux.Tipo == Constante.TBool)
{
if (valor.Tipo == Constante.TBool)
{
valor.Tipo = valor.Tipo;
aux.Valor = new NodoExpresion(valor);
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "No se puede asignar una variable de tipo " + global.Tipo + " un valor " + valor.Tipo, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "Variable no declarada: " + global.Nombre, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
}
}
public void EjecutarSelecciona(Simbolo selecciona)
{
FSelecciona fselecciona = (FSelecciona)selecciona.Objeto;
NodoExpresion condicion = fselecciona.Expresion.ResolverExpresion(fselecciona.Incerteza, fselecciona.RutaArchivo);
if (TitusNotifiaciones.ContarErrores() == 0)
{
int cont = 0;
int posencontrado = -1;
Boolean encontrado = false;
while (cont < fselecciona.Casos.Count && !TablaVariables.IsDetener() && !TablaVariables.IsRetorno() && TitusNotifiaciones.ContarErrores() == 0 && !TablaVariables.IsRetorno())
{
if (fselecciona.Casos[cont].Tipo == condicion.Tipo)
{
if (!encontrado)
{
if (fselecciona.Casos[cont].Tipo == Constante.TNumber)
{
if (fselecciona.Casos[cont].ValNumero == condicion.Numero)
{
EjecutarCaso(fselecciona.Casos[cont]);
encontrado = true;
posencontrado = cont;
SacarAmbito(fselecciona.Casos[cont].ambito.TablaSimbolo);
}
}
else
{
if (fselecciona.Casos[cont].ValCadena == condicion.Cadena)
{
EjecutarCaso(fselecciona.Casos[cont]);
SacarAmbito(fselecciona.Casos[cont].ambito.TablaSimbolo);
}
}
}
//seguimos ejcutando si no hay detener en el algun caso
if (encontrado && cont > posencontrado)
{
EjecutarCaso(fselecciona.Casos[cont]);
SacarAmbito(fselecciona.Casos[cont].ambito.TablaSimbolo);
}
}
cont++;
}
if (!encontrado && !TablaVariables.IsDetener() && !TablaVariables.IsRetorno() && TitusNotifiaciones.ContarErrores() == 0 && !TablaVariables.IsRetorno())
{
if (fselecciona.Defecto != null)
{
EjecutarCaso(fselecciona.Defecto);
}
}
//si encontro un detener lo sacamos para que siga metiendo mas ambitos
if (TablaVariables.IsDetener())
{
TablaVariables.SacarVariable();
}
}
}
public void EjecutarFuncion(Simbolo simbolo)
{
FLlamada listaparametros = (FLlamada)simbolo.Objeto;
Variables metodo = TablaVariables.BuscarMetodo(simbolo.Nombre, listaparametros);
if (metodo != null)
{
FFuncion funcion = (FFuncion)metodo.Valor;
FLlamada llamada = (FLlamada)simbolo.Objeto;
if (funcion.Parametros.Count == llamada.Parametros.Count)
{
//metemos el return
//Variables retorno = new Variables(Constante.TRetorno, Constante.TRetorno, Constante.RETORNO, null, null, 0, 0);
//TablaVariables.Tabla.Add(retorno);
int cont = 0;
//meter variables de los parametros
while (cont < funcion.Parametros.Count && TitusNotifiaciones.ContarErrores() == 0)
{
FExpresion f = (FExpresion)llamada.Parametros[cont];
NodoExpresion resultadoparametro = f.ResolverExpresion(funcion.Incerteza, funcion.RutaArchivo);
if (TitusNotifiaciones.ContarErrores() == 0)
{
if (funcion.Parametros[cont].Tipo == resultadoparametro.Tipo)
{
Variables parametro = new Variables(funcion.Parametros[cont].Tipo, funcion.Parametros[cont].Nombre, Constante.TVariable, resultadoparametro, null, simbolo.Fila, simbolo.Columna);
TablaVariables.Tabla.Add(parametro);
}
else
{
//error de asignacion del tipo de parametro
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "Se esperaba un tipo: " + funcion.Parametros[cont].Tipo + ", no un tipo: " + resultadoparametro.Tipo, funcion.RutaArchivo, resultadoparametro.Linea.ToString(), resultadoparametro.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
cont++;
}
//ejecuatamos el metodo
if (TitusNotifiaciones.ContarErrores() == 0)
{
Ejecutar execute = new Ejecutar();
execute.EjecutarInstrucciones(metodo.Ambito.TablaSimbolo);
//obtenemos el valor del return
if (TablaVariables.IsRetorno())
{
TablaVariables.SacarVariable();
}
execute.SacarAmbito(metodo.Ambito.TablaSimbolo);
execute.SacarAmbito(funcion.Parametros);
}
}
else
{
//error de cantidad de parametros
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "La funcion esperaba " + funcion.Parametros.Count + " parametros", funcion.RutaArchivo, simbolo.Fila.ToString(), simbolo.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "No existe la funcion " + simbolo.Nombre + "()", simbolo.RutaArchivo, simbolo.Fila.ToString(), simbolo.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
public void EjecutarPara(Simbolo para)
{
FPara fpara = (FPara)para.Objeto;
//ejecutamos la declaracion
EjecutarDeclaracion(fpara.Declaracion);
NodoExpresion condicion = fpara.Condicion.ResolverExpresion(fpara.Incerteza, fpara.RutaArchivo);
if (TitusNotifiaciones.ContarErrores() == 0)
{
if (condicion.Tipo == Constante.TBool)
{
while (TitusNotifiaciones.ContarErrores() == 0 && condicion.Booleano && !TablaVariables.IsRetorno() && !TablaVariables.IsDetener() && !TablaVariables.IsRetorno())
{
condicion = fpara.Condicion.ResolverExpresion(fpara.Incerteza, fpara.RutaArchivo);
if (condicion.Booleano)
{
EjecutarInstrucciones(fpara.ambito.TablaSimbolo);
}
if (TablaVariables.IsContinuar())
{
TablaVariables.SacarVariable();
}
condicion = fpara.Condicion.ResolverExpresion(fpara.Incerteza, fpara.RutaArchivo);
//sacamos el ambito
SacarAmbito(fpara.ambito.TablaSimbolo);
//realizamos la operacion ya sea ++ o --
if (fpara.Operacion == Constante.TAumento)
{
Variables var = TablaVariables.ObtenerTope();
if (var.Nombre == fpara.Declaracion.Nombre)
{
NodoExpresion val = (NodoExpresion)(var.Valor);
val.Numero = val.Numero + 1;
val.Cadena = val.Numero.ToString();
}
}
else
{
Variables var = TablaVariables.ObtenerTope();
if (var.Nombre == fpara.Declaracion.Nombre)
{
NodoExpresion val = (NodoExpresion)(var.Valor);
val.Numero = val.Numero - 1;
val.Cadena = val.Numero.ToString();
}
}
}
if (TablaVariables.IsDetener())
{
TablaVariables.SacarVariable();
}
//sacamos la variable de operacion
if (TablaVariables.ExisteVariableTope(fpara.Declaracion.Nombre))
{
TablaVariables.SacarVariable();
}
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "Se esperaba un valor Bool no uno de tipo: " + condicion.Tipo, fpara.RutaArchivo, para.Fila.ToString(), para.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
}
public void EjecutarInstrucciones(List <Simbolo> instrucciones)
{
foreach (Simbolo instruccion in instrucciones)
{
if (TitusNotifiaciones.ContarErrores() == 0 && !TablaVariables.IsContinuar() && !TablaVariables.IsDetener() && !TablaVariables.IsRetorno())
{
switch (instruccion.Rol)
{
case Constante.DECLARACION:
EjecutarDeclaracion(instruccion);
break;
case Constante.ASIGNACION:
EjecutarAsignacion(instruccion);
break;
case Constante.TDetener:
EjecutarDetener(instruccion);
break;
case Constante.TRetorno:
EjecutarRetorno(instruccion);
break;
case Constante.TContinuar:
EjecutarContinuar(instruccion);
break;
case Constante.TSelecciona:
EjecutarSelecciona(instruccion);
break;
case Constante.TMientras:
EjecutarMientras(instruccion);
break;
case Constante.THasta:
EjecutarHasta(instruccion);
break;
case Constante.TMostrar:
FMostrar mostrar = (FMostrar)instruccion.Objeto;
mostrar.Mostrar(instruccion.Fila, instruccion.Columna, mostrar.RutaArchivo);
break;
case Constante.TDibujarEXP:
FDibujarExpresion dexp = (FDibujarExpresion)instruccion.Objeto;
dexp.DibujarExpresion();
break;
case Constante.TDibujarAST:
FDibujarAST dast = (FDibujarAST)instruccion.Objeto;
dast.DibujarAst(instruccion.Fila, instruccion.Columna);
break;
case Constante.TPara:
EjecutarPara(instruccion);
break;
case Constante.LLAMADA_FUNCION:
EjecutarFuncion(instruccion);
break;
case Constante.TSi:
EjecutarSi(instruccion);
break;
}
}
}
}
