public Resultado ejecutar(ParseTreeNode raiz)
{
Resultado resultado = null;
opL = new Logica();
Resultado valor = opL.operar(raiz.ChildNodes[0]);
Boolean estado = false;
foreach (ParseTreeNode nodoCaso in raiz.ChildNodes[1].ChildNodes)
{
opL = new Logica();
Resultado valorCaso = opL.operar(nodoCaso.ChildNodes[0]);
if (valorCaso.tipo.Equals(valor.tipo))
{
if (valorCaso.valor.ToString().Equals(valor.valor.ToString()))
{
TablaSimbolo aux = Interprete.tabla;
Interprete.tabla = new TablaSimbolo();
Interprete.tabla.anterior = aux;
resultado = interprete.ejecutar(nodoCaso.ChildNodes[1]);
Interprete.tabla = aux;
estado = true;
}
}
else
{
agregarError("Semantico", "El valor a comparar debe ser de igual tipo al valor del caso", nodoCaso.Span.Location.Line, nodoCaso.Span.Location.Column);
}
if (resultado != null)
{
if (resultado.detener)
{
resultado = null;
break;
}
}
}
if (!estado && raiz.ChildNodes.Count == 3)
{
TablaSimbolo aux = Interprete.tabla;
Interprete.tabla = new TablaSimbolo();
Interprete.tabla.anterior = aux;
resultado = interprete.ejecutar(raiz.ChildNodes[2].ChildNodes[0]);
Interprete.tabla = aux;
}
return(resultado);
}
private List <Resultado> getvalParametros(ParseTreeNode nodoValores)
{
List <Resultado> valores = new List <Resultado>();
foreach (ParseTreeNode exp in nodoValores.ChildNodes)
{
Logica opL = new Logica();
Resultado resultado = opL.operar(exp);
if (!resultado.tipo.Equals("Error"))
{
valores.Add(resultado);
}
}
return(valores);
}
public Boolean asignar(ParseTreeNode raiz)
{
Object variable = getVariable(raiz.ChildNodes[0].ChildNodes[0]);
opL = new Logica();
Resultado resultado = opL.operar(raiz.ChildNodes[1]);
if (variable.GetType().Name.Equals("Simbolo"))
{
Simbolo s = (Simbolo)variable;
s.valor = resultado.valor;;
}
else if (variable.GetType().Name.Equals("Atributo"))
{
Atributo a = (Atributo)variable;
a.valor = resultado.valor;
}
return(false);
}
public Resultado ejecutar(ParseTreeNode raiz)
{
Resultado resultado = null;
opL = new Logica();
Resultado condicion = opL.operar(raiz.ChildNodes[0]);
if (condicion.valor != null)
{
if ((condicion.tipo.Equals("bool") || condicion.tipo.Equals("integer")) && (condicion.valor.ToString().Equals("0") || condicion.valor.ToString().Equals("1")))
{
if (condicion.valor.ToString().Equals("1"))
{
TablaSimbolo aux = Interprete.tabla;
Interprete.tabla = new TablaSimbolo();
Interprete.tabla.anterior = aux;
resultado = interprete.ejecutar(raiz.ChildNodes[1]);
Interprete.tabla = aux;
}
else if (condicion.valor.ToString().Equals("0") && raiz.ChildNodes.Count == 3)
{
TablaSimbolo aux = Interprete.tabla;
Interprete.tabla = new TablaSimbolo();
Interprete.tabla.anterior = aux;
resultado = interprete.ejecutar(raiz.ChildNodes[2]);
Interprete.tabla = aux;
}
}
else
{
agregarError("Semantico", "La condicion de una sentencia de control solo puede ser tipo Bool o Integer(0|1)", raiz.Span.Location.Line, raiz.Span.Location.Column);
return(null);
}
}
else
{
//error
return(null);
}
return(resultado);
}
public Boolean declaracion(ParseTreeNode raiz)
{
if (raiz.ChildNodes.Count == 3)
{
ParseTreeNodeList ids = raiz.ChildNodes[0].ChildNodes;
String tipoDato = raiz.ChildNodes[1].ChildNodes[0].Token.Text.ToLower();
opL = new Logica();
foreach (ParseTreeNode id in ids)
{
opL = new Logica();
Resultado resultado = opL.operar(raiz.ChildNodes[2].ChildNodes[0]);
resultado = comprobarTipos(tipoDato, resultado.tipo, resultado, raiz.Span.Location.Line, raiz.Span.Location.Column);
if (!resultado.tipo.Equals("Error"))
{
Simbolo variable = new Simbolo(tipoDato, id.Token.Text, resultado.valor);
Boolean estado = Interprete.tabla.setSimbolo3(variable);
if (!estado)
{
agregarError("Semantico", "La variable " + id.Token.Text + " ya existe", id.Span.Location.Line, id.Span.Location.Column);
}
}
}
}
else if (raiz.ChildNodes.Count == 2)
{
ParseTreeNodeList ids = raiz.ChildNodes[0].ChildNodes;
String tipoDato = raiz.ChildNodes[1].ChildNodes[0].Token.Text.ToLower();
foreach (ParseTreeNode id in ids)
{
Simbolo variable = null;
DateTime today;
switch (tipoDato)
{
case "text":
variable = new Simbolo(tipoDato, id.Token.Text, "");
break;
case "integer":
variable = new Simbolo(tipoDato, id.Token.Text, 0);
break;
case "double":
variable = new Simbolo(tipoDato, id.Token.Text, 0.0);
break;
case "bool":
variable = new Simbolo(tipoDato, id.Token.Text, 0);
break;
case "date":
today = DateTime.Today;
variable = new Simbolo(tipoDato, id.Token.Text, today.ToString("dd-MM-yyyy"));
break;
case "datetime":
today = DateTime.Today;
variable = new Simbolo(tipoDato, id.Token.Text, today.ToString("dd-MM-yyyy hh:mm:ss"));
break;
default:
Objeto objeto = instanciarObjeto(tipoDato, id.Span.Location.Line, id.Span.Location.Column);
if (objeto != null)
{
String nombreObjeto = raiz.ChildNodes[0].ChildNodes[0].Token.Text.ToLower();
variable = new Simbolo(tipoDato, nombreObjeto, objeto);
}
else
{
return(false);
}
break;
}
Boolean estado = Interprete.tabla.setSimbolo3(variable);
if (!estado)
{
agregarError("Semantico", "La variable " + id.Token.Text + " ya existe", id.Span.Location.Line, id.Span.Location.Column);
}
}
}
return(false);
}
public Resultado ejecutar(ParseTreeNode raiz)
{
Resultado resultado = null;
ParseTreeNode nodoDeclaracion = raiz.ChildNodes[0];
if (!nodoDeclaracion.ChildNodes[1].ChildNodes[0].Token.Text.ToLower().Equals("integer"))
{
//reportar error
return(null);
}
//cambiar ambito
TablaSimbolo aux = Interprete.tabla;
Interprete.tabla = new TablaSimbolo();
Interprete.tabla.anterior = aux;
ParseTreeNode SENTSPROC = new ParseTreeNode(new NonTerminal("SENTSPROC"), raiz.Span);
SENTSPROC.ChildNodes.Add(nodoDeclaracion);
interprete.ejecutar(SENTSPROC);
opL = new Logica();
Resultado condicion = opL.operar(raiz.ChildNodes[1]);
String operacion = raiz.ChildNodes[2].ChildNodes[0].Token.Text;
ParseTreeNode nodoSentencias = raiz.ChildNodes[3];
if (condicion.valor != null && (condicion.tipo.Equals("integer") || (condicion.tipo.Equals("bool"))))
{
while (condicion.valor.ToString().Equals("1"))
{
TablaSimbolo aux2 = Interprete.tabla;
Interprete.tabla = new TablaSimbolo();
Interprete.tabla.anterior = aux2;
resultado = interprete.ejecutar(nodoSentencias);
Interprete.tabla = aux2;
if (condicion.valor.ToString().Equals("1"))
{
if (resultado != null)
{
if (resultado.detener)
{
resultado = null;
break;
}
}
Simbolo simbolo = Interprete.tabla.getSimbolo2(nodoDeclaracion.ChildNodes[0].ChildNodes[0].Token.Text.Replace("@", "").ToLower());
if (operacion.Equals("++"))
{
simbolo.valor = Convert.ToInt64(simbolo.valor) + 1;
}
else
{
simbolo.valor = Convert.ToInt64(simbolo.valor) - 1;
}
opL = new Logica();
condicion = opL.operar(raiz.ChildNodes[1]);
}
}
}
else
{
agregarError("Semantico", "La condicion de una sentencia de control solo puede ser tipo Bool o Integer(0|1)", raiz.Span.Location.Line, raiz.Span.Location.Column);
return(null);
}
Interprete.tabla = aux;
return(resultado);
}
