public void cambiarAmbito(TablaSimbolo actual)
{
foreach (Simbolo s in actual.simbolos)
{
setSimbolo2(s);
}
}
public Resultado ejecutar(ParseTreeNode raiz)
{
Resultado resultado = null;
List <Resultado> valores = getvalParametros(raiz.ChildNodes[1]);
String id = getId(raiz.ChildNodes[0].Token.Text, valores);
//Simbolo metodo = Interprete.metodos.getSimboloId(id);
Procedimiento metodo = Form1.sistemaArchivos.getMetodo(id);
if (metodo != null)
{
TablaSimbolo aux = Interprete.tabla;
Interprete.tabla = new TablaSimbolo();
Interprete.tabla.anterior = getGlobal(aux);
ParseTreeNode nodoMetodo = (ParseTreeNode)metodo.getRaiz();
for (int i = 0; i < nodoMetodo.ChildNodes[1].ChildNodes.Count; i++)
{
Declaracion decla = new Declaracion();
decla.declaracionParametros(nodoMetodo.ChildNodes[1].ChildNodes[i], valores[i]);
}
if (nodoMetodo.Term.Name.Equals("PROCEDIMIENTO"))
{
resultado = interprete.ejecutar(nodoMetodo.ChildNodes[2]);
if (resultado != null)
{
agregarError("Semantico", "Los procedimientos no devuelven ningun valor", raiz.Span.Location.Line, raiz.Span.Location.Column);
resultado = new Resultado("", null);
}
}
else if (nodoMetodo.Term.Name.Equals("FUNCION"))
{
resultado = interprete.ejecutar(nodoMetodo.ChildNodes[3]);
if (resultado == null)
{
agregarError("Semantico", "La funcion " + metodo.nombre + " debe retornar algun valor ", raiz.Span.Location.Line, raiz.Span.Location.Column);
resultado = new Resultado("Error", null);
}
else
if (!resultado.tipo.Equals(metodo.tipoRetorno))
{
agregarError("Semantico", "La funcion " + metodo.nombre + " no es de tipo " + resultado.tipo, raiz.Span.Location.Line, raiz.Span.Location.Column);
resultado = new Resultado("Error", null);
}
}
Interprete.tabla = aux;
}
else
{
agregarError("Semantico", "El metodo " + id + " no existe", raiz.Span.Location.Line, raiz.Span.Location.Column);
}
return(resultado);
//return new Resultado("Error",null);
}
public TablaSimbolo getGlobal(TablaSimbolo actual)
{
TablaSimbolo global = actual;
while (actual.anterior != null)
{
global = actual.anterior;
actual = actual.anterior;
}
return(global);
}
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);
}
public Simbolo getSimbolo3(String nombre)
{
nombre = nombre.ToLower();
for (TablaSimbolo t = this; t.anterior != null; t = t.anterior)
{
foreach (Simbolo s in t.simbolos)
{
if (nombre.Equals(s.nombre.ToLower()))
{
return(s);
}
}
}
return(null);
}
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 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);
}
