public Resultado ejecutar(Contexto ctx, int nivel)
{
var _Si = instruccion.ChildNodes[0];
var _Sino = instruccion.ChildNodes[1];
Resultado cond = new Expresion(_Si.ChildNodes[0].ChildNodes[0]).resolver(ctx);
if (cond.Tipo != Constantes.T_BOOL)
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "Error de tipo", Interprete.archivo);
return(FabricarResultado.creaFail());
}
Resultado res = FabricarResultado.creaOk();
bool cond_b = cond.Boleano;
if (cond_b)
{
Cuerpo cp = new Cuerpo(_Si.ChildNodes[1], permiteInterrupciones);
res = cp.ejecutar(ctx, nivel + 1);
}
else
{
if (_Sino.ChildNodes.Count > 0)
{
Cuerpo cp = new Cuerpo(_Sino.ChildNodes[0], permiteInterrupciones);
res = cp.ejecutar(ctx, nivel + 1);
}
}
ctx.limpiarContexto(nivel);
return(res);
}
protected override T LeerRenglon <T>(string[] arreglo, int filaActual)
{
int?operadorId = operadores.FirstOrDefault(a => arreglo.Count() > 0 && arreglo[posIni + 1] == a.Id_Operador)?.Id;
if (operadorId == null)
{
ListaErrores.Add($"Línea {filaActual}: Operador {arreglo[posIni + 1]} no encontrado");
}
TarifaRoaming obj = new TarifaRoaming
{
Sentido = arreglo[posIni] == "IB" ? "INGRESO" : "COSTO",
Direccion = arreglo[posIni],
Code = operadorId,
Id_Operador = operadorId,
FechaInicio = DateTime.ParseExact(arreglo[posIni + 3], "dd/MM/yyyy", CultureInfo.InvariantCulture),
FechaFin = DateTime.ParseExact(arreglo[posIni + 4], "dd/MM/yyyy", CultureInfo.InvariantCulture),
ToData = (arreglo[posIni + 5] != "Gross") ? ConvertToDecimal(arreglo[posIni + 5]) : -1,
ToSMSMo = (arreglo[posIni + 6] != "Gross") ? ConvertToDecimal(arreglo[posIni + 6]) : -1,
ToVoiceMo = (arreglo[posIni + 7] != "Gross") ? ConvertToDecimal(arreglo[posIni + 7]) : -1,
ToVoiceMt = (arreglo[posIni + 8] != "Gross") ? ConvertToDecimal(arreglo[posIni + 8]) : -1,
iva = ConvertToDecimal(arreglo[posIni + 9]),
Tipo = esRecalculo?"RECALCULO":"ORIGEN",
Id_LineaNegocio = 1,
Activo = 1
};
obj.TfData = (obj.ToData != -1) ? obj.ToData - (obj.ToData * obj.iva) : -1;
obj.TfVoiceMo = (obj.ToVoiceMo != -1) ? obj.ToVoiceMo - (obj.ToVoiceMo * obj.iva) : -1;
obj.TfVoiceMt = (obj.ToVoiceMt != -1) ? obj.ToVoiceMt - (obj.ToVoiceMt * obj.iva) : -1;
obj.TfSMSMo = (obj.ToSMSMo != -1) ? obj.ToSMSMo - (obj.ToSMSMo * obj.iva) : -1;
return(obj as T);
}
private Resultado resolverNumeros(Resultado resIzq, Resultado resDer, Contexto ctx)
{
double dIzq, dDer;
if (resIzq.Tipo == Constantes.T_BOOL)
{
dIzq = Convert.ToInt32(Convert.ToBoolean(resIzq.Valor));
}
else
{
dIzq = resIzq.Doble;
}
if (resDer.Tipo == Constantes.T_BOOL)
{
dDer = Convert.ToInt32(Convert.ToBoolean(resDer.Valor));
}
else
{
dDer = resDer.Doble;
}
bool b = false;
switch (operando)
{
case "==":
b = dIzq == dDer;
break;
case "!=":
b = dIzq != dDer;
break;
case "<":
b = dIzq < dDer;
break;
case ">":
b = dIzq > dDer;
break;
case "<=":
b = dIzq <= dDer;
break;
case ">=":
b = dIzq >= dDer;
break;
case "~":
b = Math.Abs(dIzq - dDer) <= Interprete.Incerteza;
break;
default:
ListaErrores.getInstance().setErrorSemantico(izq.Token.Location.Line, izq.Token.Location.Line, "opearacion fuera de rango", Interprete.archivo);
break;
}
return(FabricarResultado.creaBooleano(b));
}
public ReporteErrores()
{
InitializeComponent();
List <Error> lista = ListaErrores.getInstance().getReporte();
dataGridView1.DataSource = lista;
}
private Resultado resolverBinaria(Contexto ctx)
{
Resultado resIzq = new Expresion(izq).resolver(ctx);
if (resIzq.esError())
{
ListaErrores.getInstance().setErrorSemantico(izq.Token.Location.Line, izq.Token.Location.Line, "No se puedo resolver la expresion", Interprete.archivo);
return(new Resultado());
}
Resultado resDer = new Expresion(der).resolver(ctx);
if (resDer.esError())
{
ListaErrores.getInstance().setErrorSemantico(izq.Token.Location.Line, izq.Token.Location.Line, "No se puedo resolver la expresion", Interprete.archivo);
return(new Resultado());
}
if (operando == "+")
{
return(resolverSuma(resIzq, resDer));
}
else if (operando == "*")
{
return(resolverMultiplicacion(resIzq, resDer));
}
else if (Constantes.esAlgunoDeEstos(operando, "-", "/", "%", "^"))
{
return(resolverNumerica(resIzq, resDer));
}
return(new Resultado());
}
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);
}
public static void addMetodo(ParseTreeNode fun)
{
String nom = fun.ChildNodes[1].Token.Text;
List <ParseTreeNode> funciones;
bool sePuedeGuardar = true;
int cantNodos = fun.ChildNodes.Count;
if (metodos.TryGetValue(nom, out funciones))
{
foreach (ParseTreeNode nodo in funciones)
{
if (cantNodos == 3 && nodo.ChildNodes.Count == cantNodos)
{
sePuedeGuardar = false;
break;
}
else if (cantNodos == 4 && nodo.ChildNodes.Count == cantNodos)
{
int par1 = nodo.ChildNodes[2].ChildNodes.Count;
int par2 = fun.ChildNodes[2].ChildNodes.Count;
if (par1 == par2)
{
int i, j = 0;
for (i = 0; i < par1; i++)
{
String tipo1 = fun.ChildNodes[2].ChildNodes[i].ChildNodes[0].ToString();
String tipo2 = nodo.ChildNodes[2].ChildNodes[i].ChildNodes[0].ToString();
if (tipo1 == tipo2)
{
j++;
}
}
if (i == j)
{
sePuedeGuardar = false;
ListaErrores.getInstance().setErrorSemantico(nodo.Token.Location.Line, nodo.Token.Location.Line, "No se puede crear la funcion con los mismos parametros y mismo nombre", Interprete.archivo);
break;
}
}
}
}
if (sePuedeGuardar)
{
funciones.Add(fun);
metodos[nom] = funciones;
}
else
{
Console.WriteLine("una funcion ya ha sido declarada con el mismo nombre y mismos parametros");
}
}
else
{
funciones = new List <ParseTreeNode>();
funciones.Add(fun);
metodos.Add(nom, funciones);
}
}
private Resultado resolverUnario(Contexto ctx)
{
Resultado resIzq = new Expresion(izq).resolver(ctx);
if (resIzq.Tipo != Constantes.T_BOOL)
{
ListaErrores.getInstance().setErrorSemantico(izq.Token.Location.Line, izq.Token.Location.Line, "No coinciden los tipos", Interprete.archivo);
return(new Resultado());
}
if (operando == "!")
{
return(resolverNot(resIzq));
}
return(new Resultado());
}
public void Analizar()
{
ListaErrores.resetInstance();
Gramatica gramatica = new Gramatica();
LanguageData lenguaje = new LanguageData(gramatica);
Parser parser = new Parser(lenguaje);
ParseTree arbol = parser.Parse(Entrada);
ParseTreeNode raiz = arbol.Root;
if (raiz == null)
{
MessageBox.Show("You're Drunk Irony, Go Home!!");
return;
}
Arbol = raiz;
// Gramatica.getImage(raiz);
}
private Resultado resolverCadenas(Resultado resIzq, Resultado resDer, Contexto ctx)
{
int comparacion = resIzq.Valor.CompareTo(resDer.Valor);
bool b = false;
switch (operando)
{
case "==":
b = comparacion == 0;
break;
case "!=":
b = comparacion != 0;
break;
case "<":
b = comparacion < 0;
break;
case ">":
b = comparacion > 0;
break;
case "<=":
b = comparacion <= 0;
break;
case ">=":
b = comparacion >= 0;
break;
case "~":
String v1 = resIzq.Valor.Trim();
String v2 = resDer.Valor.Trim();
b = String.Compare(v1, v2, true) == 0;
break;
default:
ListaErrores.getInstance().setErrorSemantico(izq.Token.Location.Line, izq.Token.Location.Line, "opreardor invalido", Interprete.archivo);
break;
}
return(FabricarResultado.creaBooleano(b));
}
public override Resultado ejecutar(Contexto ctx, int nivel)
{
ParseTreeNode fun = Interprete.getFuncion(instruccion, ctx);
if (fun == null)
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "El metodo no ha sido identificado", Interprete.archivo);
return(FabricarResultado.creaFail());
}
Contexto contexto = new Contexto();
Resultado ej;
Cuerpo cuerpo;
int cantParam = instruccion.ChildNodes[1].ChildNodes.Count;
if (cantParam > 0)
{
ParseTreeNode Params = fun.ChildNodes[2];
for (int i = 0; i < cantParam; i++)
{
String tipoVar = Params.ChildNodes[i].ChildNodes[0].ToString();
String nombreVar = Params.ChildNodes[i].ChildNodes[1].Token.Text;
Resultado valor = new Expresion(instruccion.ChildNodes[1].ChildNodes[i].ChildNodes[0]).resolver(ctx);
Variable var = new Variable(nombreVar, valor.Valor, tipoVar, nivel);
contexto.setVariable(var);
}
cuerpo = new Cuerpo(fun.ChildNodes[3], permiteInterrupciones);
}
else
{
cuerpo = new Cuerpo(fun.ChildNodes[2], permiteInterrupciones);
}
ej = cuerpo.ejecutar(contexto, nivel);
if (ej.Tipo != fun.ChildNodes[0].ToString())
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "No retorna el mismo tipo de la funcion", Interprete.archivo);
return(FabricarResultado.creaFail());
}
return(ej);
}
public Resultado resolver(Contexto ctx)
{
Resultado resIzq = new Expresion(izq).resolver(ctx);
Resultado resDer = new Expresion(der).resolver(ctx);
String tipoIzq = resIzq.Tipo;
String tipoDer = resDer.Tipo;
if ((tipoIzq != Constantes.T_STR && tipoIzq != Constantes.T_ERROR && tipoIzq != Constantes.T_VOID) &&
(tipoDer != Constantes.T_STR && tipoDer != Constantes.T_ERROR && tipoDer != Constantes.T_VOID))
{
return(resolverNumeros(resIzq, resDer, ctx));
}
else if (tipoIzq == Constantes.T_STR && tipoIzq == tipoDer)
{
return(resolverCadenas(resIzq, resDer, ctx));
}
ListaErrores.getInstance().setErrorSemantico(izq.Token.Location.Line, izq.Token.Location.Line, "Ambas tienen que ser numeros o cadenas", Interprete.archivo);
return(new Resultado());
}
public override Resultado ejecutar(Contexto ctx, int nivel)
{
Resultado exec = null;
while (true)
{
Resultado condicion = new Expresion(instruccion.ChildNodes[0].ChildNodes[0]).resolver(ctx);
if (condicion.Tipo != Constantes.T_BOOL)
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "La condicion no retorna un valor booleando", Interprete.archivo);
return(FabricarResultado.creaFail());
}
bool cond = condicion.Boleano;
if (!cond)
{
exec = FabricarResultado.creaOk();
break;
}
Cuerpo cuerpo = new Cuerpo(instruccion.ChildNodes[1], true);
exec = cuerpo.ejecutar(ctx, nivel);
if (exec.esContinuar())
{
continue;
}
if (exec.esDetener())
{
exec = FabricarResultado.creaOk();
break;
}
if (exec.esRetorno())
{
break;
}
ctx.limpiarContexto(nivel);
}
ctx.limpiarContexto(nivel);
return(exec);
}
private Resultado resolverBinaria(Contexto ctx)
{
Resultado resIzq = new Expresion(izq).resolver(ctx);
Resultado resDer = new Expresion(der).resolver(ctx);
String tipoIzq = resIzq.Tipo;
String tipoDer = resDer.Tipo;
int comparacion1 = tipoIzq.CompareTo(Constantes.T_BOOL);
int comparacion2 = tipoIzq.CompareTo(tipoDer);
if (comparacion1 != comparacion2)
{
ListaErrores.getInstance().setErrorSemantico(izq.Token.Location.Line, izq.Token.Location.Line, "Deben ser booleanos las dos expresiones", Interprete.archivo);
return(new Resultado());
}
bool bIzq = resIzq.Boleano;
bool bDer = resDer.Boleano;
switch (operando)
{
case "&&":
bIzq = bIzq && bDer;
break;
case "||":
bIzq = bIzq || bDer;
break;
case "!&":
bIzq = bIzq ^ bDer;
break;
default:
ListaErrores.getInstance().setErrorSemantico(izq.Token.Location.Line, izq.Token.Location.Line, "Expresion fuera de rango", Interprete.archivo);
break;
}
return(FabricarResultado.creaBooleano(bIzq));
}
public Resultado ejecutar(Contexto ctx, int nivel)
{
String nombreVar = instruccion.ChildNodes[0].Token.Text;
if (!existeVariable(ctx, nombreVar))
{
return(FabricarResultado.creaFail());
}
Resultado res = new Expresion(instruccion.ChildNodes[1].ChildNodes[0]).resolver(ctx);
String tipo = res.Tipo;
if (tipo == Constantes.T_ERROR)
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "No se puedo resolver la expresion", Interprete.archivo);
return(FabricarResultado.creaFail());
//error en la expresion
}
Variable destino = obtenerVariable(ctx, nombreVar);
String tipoVar = destino.Tipo;
String casteo = Constantes.ValidarTipos(tipoVar, tipo, Constantes.MT_ASIG);
String valor = null;
if (casteo == Constantes.T_ERROR)
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "No se puede asignar ese tipo de dato", Interprete.archivo);
//no se puede asignar ese tipo
}
else
{
String tmp = "";
switch (tipoVar)
{
case Constantes.T_STR:
switch (tipo)
{
case Constantes.T_BOOL:
tmp = "" + Convert.ToInt32(Convert.ToBoolean(res.Valor));
break;
default:
tmp = res.Valor;
break;
}
break;
case Constantes.T_NUM:
switch (tipo)
{
case Constantes.T_BOOL:
tmp = "" + Convert.ToInt32(Convert.ToBoolean(res.Valor));
break;
case Constantes.T_NUM:
tmp = res.Valor;
break;
default:
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "error de casteo", Interprete.archivo);
//error por si llegara a pasar aunque no lo creo
break;
}
break;
case Constantes.T_BOOL:
switch (tipo)
{
case Constantes.T_BOOL:
tmp = res.Valor;
break;
default:
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "error de casteo", Interprete.archivo);
//error por si llegara a pasar aunque no lo creo
break;
}
break;
}
valor = tmp;
}
destino.Valor = valor;
ctx.ActualizarValor(nombreVar, destino);
return(FabricarResultado.creaOk());
}
public override Resultado ejecutar(Contexto ctx, int nivel)
{
//Obiene nombre de la variable, el valor, si es incremento o decremento y el cuerpo de la funcion
String nombreVar = instruccion.ChildNodes[0].Token.Text;
String tipoVar = Constantes.T_NUM;
Resultado ValorVar = new Expresion(instruccion.ChildNodes[1].ChildNodes[0]).resolver(ctx);
ParseTreeNode NodoCuerpo = instruccion.ChildNodes[4];
String inc_dec = instruccion.ChildNodes[3].ToString();
//si el valor de la variable no es el mismo a number se sale
String castValue = "";
switch (tipoVar)
{
case Constantes.T_BOOL:
castValue = "" + Convert.ToInt32(Convert.ToBoolean(ValorVar.Valor));
break;
case Constantes.T_NUM:
castValue = ValorVar.Valor;
break;
default:
return(FabricarResultado.creaFail());
}
// Creo variablew
Variable var = new Variable(nombreVar, castValue, tipoVar, nivel);
//si existe, es error entonces
if (ctx.existeVariable(nombreVar))
{
return(FabricarResultado.creaFail());
}
ctx.setVariable(var);
Resultado exec = null;
while (true)
{
Resultado condicionPara = new Expresion(instruccion.ChildNodes[2].ChildNodes[0]).resolver(ctx);
if (condicionPara.Tipo != Constantes.T_BOOL)
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "La condicion no retorna un valor booleando", Interprete.archivo);
return(FabricarResultado.creaFail());
}
bool cond = condicionPara.Boleano;
if (!cond)
{
exec = FabricarResultado.creaOk();
break;
}
Cuerpo cuerpo = new Cuerpo(NodoCuerpo, true);
exec = cuerpo.ejecutar(ctx, nivel + 1);
if (exec.esContinuar())
{
continue;
}
if (exec.esDetener())
{
exec = FabricarResultado.creaOk();
break;
}
if (exec.esRetorno())
{
break;
}
Variable asigTemp = ctx.getVariable(nombreVar);
if (asigTemp != null)
{
if (asigTemp.Tipo == Constantes.T_NUM)
{
double valor = Convert.ToDouble(asigTemp.Valor);
if (inc_dec == Constantes.INCREMENTO)
{
valor++;
}
else
{
valor--;
}
asigTemp.Valor = valor.ToString();
}
ctx.ActualizarValor(nombreVar, asigTemp);
}
ctx.limpiarContexto(nivel + 1);
}
ctx.limpiarContexto(nivel + 1);
ctx.limpiarContexto(nivel);
return(exec);
}
private Resultado resolverNumerica(Resultado resIzq, Resultado resDer)
{
double dIzq, dDer;
if (resIzq.Tipo == Constantes.T_BOOL)
{
dIzq = Convert.ToInt32(Convert.ToBoolean(resIzq.Valor));
}
else
{
dIzq = resIzq.Doble;
}
if (resDer.Tipo == Constantes.T_BOOL)
{
dDer = Convert.ToInt32(Convert.ToBoolean(resDer.Valor));
}
else
{
dDer = resDer.Doble;
}
switch (operando)
{
case "+":
if (Constantes.ValidarTipos(resIzq.Tipo, resDer.Tipo, Constantes.MT_SUMA) == Constantes.T_NUM)
{
dIzq += dDer;
}
break;
case "-":
if (Constantes.ValidarTipos(resIzq.Tipo, resDer.Tipo, Constantes.MT_RESTA) == Constantes.T_NUM)
{
dIzq -= dDer;
}
break;
case "*":
if (Constantes.ValidarTipos(resIzq.Tipo, resDer.Tipo, Constantes.MT_MULTPLICACION) == Constantes.T_NUM)
{
dIzq *= dDer;
}
break;
case "/":
if (dDer == 0)
{
ListaErrores.getInstance().setErrorSemantico(der.Token.Location.Line, der.Token.Location.Line, "No se puede dividir entre 0", Interprete.archivo);
return(new Resultado());
}
if (Constantes.ValidarTipos(resIzq.Tipo, resDer.Tipo, Constantes.MT_DIVISION) == Constantes.T_NUM)
{
dIzq /= dDer;
}
break;
case "%":
if (dDer == 0)
{
ListaErrores.getInstance().setErrorSemantico(der.Token.Location.Line, der.Token.Location.Line, "No se puede dividir entre 0", Interprete.archivo);
return(new Resultado());
}
if (Constantes.ValidarTipos(resIzq.Tipo, resDer.Tipo, Constantes.MT_MODULO) == Constantes.T_NUM)
{
int mod = (int)dIzq % (int)dDer;
return(FabricarResultado.creaNumero(Convert.ToString(mod)));
}
break;
case "^":
if (Constantes.ValidarTipos(resIzq.Tipo, resDer.Tipo, Constantes.MT_POTENCIA) == Constantes.T_NUM)
{
dIzq = Math.Pow(dIzq, dDer);
}
break;
}
return(FabricarResultado.creaNumero(Convert.ToString(dIzq)));
}
public Resultado ejecutar(Contexto ctx, int nivel)
{
if (instruccion.ToString() != Constantes.CUERPO_FUNCION)
{
return(new Resultado());
}
foreach (var instruccion in instruccion.ChildNodes)
{
Resultado res = null;
switch (instruccion.ToString())
{
case Constantes.DECLARACION:
res = new Declaracion(instruccion).ejecutar(ctx, nivel);
break;
case Constantes.ASIGNACION:
res = new Asignacion(instruccion).ejecutar(ctx, nivel);
break;
case Constantes.LLAMADA:
res = new Llamada(instruccion).ejecutar(ctx, nivel);
break;
case Constantes.MOSTRAR:
res = new Mostrar(instruccion).ejecutar(ctx, nivel);
break;
case Constantes.DIBUJARAST:
res = new GraficarAST(instruccion).ejecutar(ctx, nivel);
break;
case Constantes.DIBUJAREXP:
res = new GraficarEXP(instruccion).ejecutar(ctx, nivel);
break;
case Constantes.SI_SINO:
res = new Si(instruccion, permiteInterrupciones).ejecutar(ctx, nivel + 1);
break;
case Constantes.SELECCIONA:
res = new Selecciona(instruccion, true).ejecutar(ctx, nivel + 1);
break;
case Constantes.PARA:
res = new Para(instruccion, true).ejecutar(ctx, nivel + 1);
break;
case Constantes.HASTA:
res = new Hasta(instruccion, true).ejecutar(ctx, nivel + 1);
break;
case Constantes.MIENTRAS:
res = new Mientras(instruccion, true).ejecutar(ctx, nivel + 1);
break;
case Constantes.RETORNO:
if (instruccion.ChildNodes.Count == 1)
{
res = new Retorno(instruccion.ChildNodes[0]).ejecutar(ctx, nivel);
}
break;
case Constantes.DETENER:
res = FabricarResultado.creaDetener();
break;
case Constantes.CONTINUAR:
res = FabricarResultado.creaContinuar();
break;
}
if (res == null)
{
//error
continue;
}
if (res.esRetorno())
{
return(res);
}
if (res.esDetener() || res.esContinuar())
{
if (permiteInterrupciones)
{
return(res);
}
else
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "La instruccion no pertence al contexto", Interprete.archivo);
}
}
}
return(FabricarResultado.creaOk());
}
public override Resultado ejecutar(Contexto ctx, int nivel)
{
bool cumplio = false;
Resultado res = FabricarResultado.creaOk();
Resultado cond = new Expresion(instruccion.ChildNodes[0].ChildNodes[0]).resolver(ctx);
ParseTreeNode CuerpoSelecciona = instruccion.ChildNodes[1].ChildNodes[0];
String val = cond.Valor;
String tipo = cond.Tipo;
if (tipo == Constantes.T_BOOL || tipo == Constantes.T_ERROR)
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "Error de tipo", Interprete.archivo);
return(FabricarResultado.creaFail());
}
foreach (var ValorN in CuerpoSelecciona.ChildNodes)
{
String valN = ValorN.ChildNodes[0].Token.Text;
String tipoN = ValorN.ChildNodes[0].Term.ToString();
if (tipoN == Constantes.T_STR)
{
valN = valN.Substring(1, valN.Length - 2);
}
if (tipo != tipoN)
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "los tipos no coinciden", Interprete.archivo);
res = FabricarResultado.creaFail();
break;
}
if (cumplio == true || val.CompareTo(valN) != 0)
{
continue;
}
cumplio = true;
Cuerpo cuerpo = new Cuerpo(ValorN.ChildNodes[1], true);
res = cuerpo.ejecutar(ctx, nivel);
if (res.esRetorno())
{
break;
}
if (res.esDetener())
{
res = FabricarResultado.creaOk();
break;
}
ctx.limpiarContexto(nivel);
}
if (instruccion.ChildNodes[1].ChildNodes.Count > 1)
{
if (cumplio == false)
{
var defecto = instruccion.ChildNodes[1].ChildNodes[1];
Cuerpo cuerpo = new Cuerpo(defecto.ChildNodes[0], true);
res = cuerpo.ejecutar(ctx, nivel);
if (res.esDetener())
{
res = FabricarResultado.creaOk();
}
}
}
return(res);
}
public Resultado ejecutar(Contexto ctx, int nivel)
{
String valor = null;
String varTipo = instruccion.ChildNodes[0].ToString();
if (instruccion.ChildNodes.Count == 3)
{
Resultado res = new Expresion(instruccion.ChildNodes[2].ChildNodes[0]).resolver(ctx);
String tipo = res.Tipo;
String casteo = Constantes.ValidarTipos(varTipo, tipo, Constantes.MT_ASIG);
if (tipo == Constantes.T_ERROR)
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "error de tipo", Interprete.archivo);
}
else if (casteo == Constantes.T_ERROR)
{
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "error de casteo", Interprete.archivo);
}
else
{
String tmp = "";
switch (varTipo)
{
case Constantes.T_STR:
switch (tipo)
{
case Constantes.T_BOOL:
tmp = "" + Convert.ToInt32(Convert.ToBoolean(res.Valor));
break;
default:
tmp = res.Valor;
break;
}
break;
case Constantes.T_NUM:
switch (tipo)
{
case Constantes.T_BOOL:
tmp = "" + Convert.ToInt32(Convert.ToBoolean(res.Valor));
break;
case Constantes.T_NUM:
tmp = res.Valor;
break;
default:
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "Error de casteo", Interprete.archivo);
break;
}
break;
case Constantes.T_BOOL:
switch (tipo)
{
case Constantes.T_BOOL:
tmp = res.Valor;
break;
default:
ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "error de casteo", Interprete.archivo);
break;
}
break;
}
valor = tmp;
}
}
foreach (var id in instruccion.ChildNodes[1].ChildNodes)
{
String nombre = id.Token.Text;
Variable var = new Variable(nombre, valor, varTipo, nivel);
if (nivel == Constantes.GLOBAL)
{
if (existeVariableGlobal(nombre))
{
//error ya existe la variable
}
crearVariableGlobal(var);
}
else
{
if (existeVariableLocal(ctx, nombre))
{
//ya existe la variable local
}
crearVariableLocal(ctx, var);
}
}
return(FabricarResultado.creaOk());
}
private void definirContextoGlobal()
{
if (Arbol != null)
{
if (Arbol.ChildNodes.Count == 1)
{
var Nodo = Arbol.ChildNodes[0];
switch (Nodo.ToString())
{
case Constantes.ENCABEZADO:
foreach (var nodo_encabezado in Nodo.ChildNodes)
{
switch (nodo_encabezado.ToString())
{
case Constantes.INCERTEZA:
Interprete.Incerteza = Convert.ToDouble(nodo_encabezado.ChildNodes[0].Token.Text);
break;
case Constantes.RUTA:
String _ruta = nodo_encabezado.ChildNodes[0].Token.Text;
if (Directory.Exists(_ruta))
{
Interprete.Ruta = _ruta + "\\";
}
break;
case Constantes.INCLUYE:
Encabezado e = new Encabezado(nodo_encabezado.ChildNodes[0].Token.Text, archivo);
encabezado.Add(e);
break;
}
}
break;
case Constantes.CUERPO_PROGRAMA:
foreach (var nodo in Nodo.ChildNodes)
{
foreach (var nodo_cuerpo in Nodo.ChildNodes)
{
switch (nodo_cuerpo.ToString())
{
case Constantes.DECLARACION:
variables.Add(nodo_cuerpo);
break;
case Constantes.FUNCION:
Interprete.addMetodo(nodo_cuerpo);
break;
case Constantes.PRINCIPAL:
if (Principal != null)
{
ListaErrores.getInstance().nuevoErrorGeneral("No pueden haber dos funciones principales", archivo);
}
else
{
Principal = nodo_cuerpo;
}
break;
}
}
}
break;
}
}
else if (Arbol.ChildNodes.Count == 2)
{
foreach (var Nodo in Arbol.ChildNodes)
{
switch (Nodo.ToString())
{
case Constantes.ENCABEZADO:
foreach (var nodo_encabezado in Nodo.ChildNodes)
{
switch (nodo_encabezado.ToString())
{
case Constantes.INCERTEZA:
Interprete.Incerteza = Convert.ToDouble(nodo_encabezado.ChildNodes[0].Token.Text);
break;
case Constantes.RUTA:
String _ruta = nodo_encabezado.ChildNodes[0].Token.Text;
_ruta = _ruta.Substring(1, _ruta.Length - 2);
if (Directory.Exists(_ruta) == true)
{
Interprete.Ruta = _ruta + "\\";
}
break;
case Constantes.INCLUYE:
Encabezado e = new Encabezado(nodo_encabezado.ChildNodes[0].Token.Text, archivo);
encabezado.Add(e);
break;
}
}
break;
case Constantes.CUERPO_PROGRAMA:
foreach (var nodo_cuerpo in Nodo.ChildNodes)
{
switch (nodo_cuerpo.ToString())
{
case Constantes.DECLARACION:
variables.Add(nodo_cuerpo);
break;
case Constantes.FUNCION:
Interprete.addMetodo(nodo_cuerpo);
break;
case Constantes.PRINCIPAL:
if (Principal != null)
{
ListaErrores.getInstance().nuevoErrorGeneral("No pueden haber dos funciones principales", archivo);
}
else
{
Principal = nodo_cuerpo;
}
break;
}
}
break;
default:
break;
}
}
}
else
{
Console.WriteLine("Arbol Vacio!");
}
}
}