public override Expresion getValor(Entorno ent)
{
Primitivo resultadoN = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
Expresion resultado = dato.getValor(ent);
switch (resultado.tipo.tipo)
{
case Tipo.enumTipo.entero:
resultadoN = new Primitivo(new Tipo(Tipo.enumTipo.entero), -int.Parse(resultado.valor.ToString()));
return(resultadoN);
case Tipo.enumTipo.real:
resultadoN = new Primitivo(new Tipo(Tipo.enumTipo.real), -float.Parse(resultado.valor.ToString()));
return(resultadoN);
/*
* case caracter:
* int contrario = -resultado.valor.toString().charAt(0);
* resultadoN = new Literal(new Tipo(Tipo.EnumTipo.caracter), contrario);
* return resultadoN;
*/
}
//si llega aqui es porque ningun tipo fue compatible para volverlo negativo
//entonces es error
MasterClass.Instance.addError(new C_Error("Semantico", "No se le puede asignar signo negativo a: " + resultado.tipo.tipo, linea, columna));
return(resultadoN);
}
public override Expresion getValor(Entorno ent)
{
//declaramos un valor que por defecto sera error
Primitivo resultadoGeneral = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
Expresion resultadoIzq = this.hijoIzq.getValor(ent);
Expresion resultadoDer = this.hijoDer.getValor(ent);
//Hijo izquierdo y dentro de cada uno se puede validar el hijo derecho (para saber con cual se esta sumando)
switch (resultadoIzq.tipo.tipo)
{
case Tipo.enumTipo.entero:
switch (resultadoDer.tipo.tipo)
{
case Tipo.enumTipo.entero:
resultadoGeneral = new Primitivo(new Tipo(Tipo.enumTipo.entero), int.Parse(resultadoIzq.valor.ToString()) - int.Parse(resultadoDer.valor.ToString()));
return(resultadoGeneral);
case Tipo.enumTipo.real:
resultadoGeneral = new Primitivo(new Tipo(Tipo.enumTipo.real), float.Parse(resultadoIzq.valor.ToString()) - float.Parse(resultadoDer.valor.ToString()));
return(resultadoGeneral);
default:
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede restar: " + resultadoDer.tipo.tipo + " con: " + resultadoIzq.tipo.tipo, linea, columna));
break;
}
break;
case Tipo.enumTipo.real:
switch (resultadoDer.tipo.tipo)
{
case Tipo.enumTipo.entero:
resultadoGeneral = new Primitivo(new Tipo(Tipo.enumTipo.real), float.Parse(resultadoIzq.valor.ToString()) - float.Parse(resultadoDer.valor.ToString()));
return(resultadoGeneral);
case Tipo.enumTipo.real:
resultadoGeneral = new Primitivo(new Tipo(Tipo.enumTipo.real), float.Parse(resultadoIzq.valor.ToString()) - float.Parse(resultadoDer.valor.ToString()));
return(resultadoGeneral);
default:
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede restar: " + resultadoDer.tipo.tipo + " con: " + resultadoIzq.tipo.tipo, linea, columna));
break;
}
break;
default:
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede restar: " + resultadoDer.tipo.tipo + " con: " + resultadoIzq.tipo.tipo, linea, columna));
break;
}
return(resultadoGeneral);
}
public void validarEtiquetas(Entorno ent)
{
foreach (Expresion etiqueta in etiquetas)
{
if (etiqueta is Primitivo)
{
Primitivo prim = (Primitivo)etiqueta;
if (prim.type == Tipos.REAL)
{
throw new Error("Semántico", "No se puede colocar un valor de tipo REAL como opcion en el case", ent.obtenerAmbito(), linea, columna);
}
}
}
}
public override Expresion getValor(Entorno ent)
{
//MessageBox.Show("Estoy en el get valor de la variable "+id);
Variable sim = ent.buscar(id, linea, columna, "La variable");
if (sim != null)
{ //Si se encontró la variable
//MessageBox.Show("Si se encontro la variable " + id);
Primitivo retorno = new Primitivo(sim.tipo, sim.valor);
//retorna tal cual el valor
return(retorno);
}
//Quiere decir que la variable NO existe, devuelvo un error
return(new Primitivo(new Tipo(Tipo.enumTipo.error), "@Error@"));
}
public void validarLimites(Entorno ent)
{
foreach (Dimension dimension in dimensiones)
{
Primitivo inferior = dimension.inferior;
if (inferior.value.ToString().Contains("."))
{
throw new Error("Semántico", "El limite inferior tiene que ser de tipo integer", ent.obtenerAmbito(), linea, columna);
}
Primitivo superior = dimension.superior;
if (superior.value.ToString().Contains("."))
{
throw new Error("Semántico", "El limite superior tiene que ser de tipo integer", ent.obtenerAmbito(), linea, columna);
}
}
}
public override Expresion getValor(Entorno ent)
{
//creamos el objeto que vamos a devolver
Expresion l = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
//Creamos una variable de entorno para ir buscando en ellos
//Iniciamos en el entorno actual
Entorno entBuscar = ent;
//recorremos la lista
foreach (Id id in accesos)
{
//buscamos el objeto en el entorno que viene
Expresion sim = id.getValor(entBuscar);
//vamos preguntando si es el ultimo
if (id == accesos.Last.Value)
{
//si es el ultimo no debe ser un objeto
//retornamos el simbolo
l = new Primitivo(sim.tipo, sim.valor);
break;
}
else
{
//Como no es ultimo de la lista de ids
//Tiene que ser de tipo objeto
if (sim.tipo.tipo != Tipo.enumTipo.Objecto)
{
//Si es diferente de objeto no puede ser acceso
/*Error*/
}
//Si es de tipo objeto nos metemos a su entorno y seguimos buscando
//entBuscar = ((Objecto)sim.valor).global;
}
}
return(l);
}
public override Expresion getValor(Entorno ent)
{
//ent en este caso es el main
LinkedList <Expresion> resueltos = new LinkedList <Expresion>();
MasterClass.PilaMF.AddFirst(MasterClass.TipoMF.Metodo_Funcion);
//Creamos un nuevo entorno para ejecutar el metodo
Entorno nuevo = new Entorno(ent); //El global es el del objeto
//creamos un literal para poder regresar
Expresion retorno = null;
//Modificamos el nombre
String aux = "";
String a2 = this.id;
String a3 = a2.Substring(0, 1);
if (!a3.Equals("#"))
{
aux = "#";
}
String nombreFuncion2 = this.id + aux;
//ahora ejecutamos las expresiones -> parametros enviados si esque tiene
if (this.enviados != null)
{
//recorremos los parametros enviados
//Aqui se le puede enviar un id -> debemos ir a buscarlo
foreach (Expresion parametro in this.enviados)
{
var parametroType = parametro.GetType();
var listaAccesosType = new Lista_Accesos().GetType();
if (typeof(Lista_Accesos).IsInstanceOfType(parametro))
{
Lista_Accesos a = (Lista_Accesos)parametro;
Expresion retAcceso = a.getValor(nuevo);
nombreFuncion2 += retAcceso.tipo.tipo.ToString();
resueltos.AddLast(retAcceso);
/*
* foreach (Id id in a.accesos)
* {
* Variable sim = id.getSimbolo(nuevo);
* Primitivo l = new Primitivo(sim.tipo, sim.valor);
* nombreFuncion2 += l.tipo.tipo.ToString();
* resueltos.AddLast(l);
* }
*/
}
else
{
nombreFuncion2 += parametro.getValor(nuevo).tipo.tipo.ToString();
resueltos.AddLast(parametro.getValor(nuevo));
}
}
}
//adjuntar el último valor modificado para el método
/*
* if (!aux.Equals("", StringComparison.InvariantCultureIgnoreCase))
* {
*
* Id id = acceso.accesos.Last.Value;
* acceso.accesos.RemoveLast();
* acceso.accesos.AddLast(new Id(nombreFuncion2, id.linea, id.columna));
*
* }
*/
nuevo.global = ent.global;
Variable f;
//luego buscamos la funcion
f = nuevo.buscar(nombreFuncion2, linea, columna, "La Funcion");
//si lo encontro
if (f != null)
{
//aqui pedimos el tipo
//creamos una variable (exit)
LinkedList <String> lista = new LinkedList <String>();
lista.AddLast(id);
Declaracion nombreFuncionDec = new Declaracion(f.tipo, lista, 0, 0);
nombreFuncionDec.ejecutar(nuevo);
//creamos un iterador
int iterador = 0;
//si tiene parametros y tambien tiene parametros enviados
//transformamos el simbolo encontrado a un simbolo nuevo de tipo metodo_Funcion para obtener la lista de parametros
if (enviados != null && ((Tipo_MF)f.valor).getparametros() != null)
{
//resolvemos los parametros enviados para tener el valor
foreach (Expresion enviado in enviados)
{
resueltos.AddLast(enviado.getValor(ent));
}
int cont = 0;
//Ejecutamos la lista de declaraciones para crear las variables
//y le asignamos el valor del enviado correspondiente para que sea asignado de una vez
foreach (Instruccion declaracion in ((Tipo_MF)f.valor).getparametros())
{
//((Declaracion)declaracion).valor = resueltos.ElementAt(iterador);
Tipo tipe = new Tipo(((Declaracion)declaracion).tipo.tipo);
foreach (String identify in ((Declaracion)declaracion).IDS)
{//Identificador a,b:integer m:integer
if (((Declaracion)declaracion).PorReferencia)
{
if (typeof(Lista_Accesos).IsInstanceOfType(this.enviados.ElementAt(cont)))
{
Lista_Accesos accesopos = (Lista_Accesos)this.enviados.ElementAt(cont);
Entorno temporal = nuevo;
Variable sim = null;
for (var temp = accesopos.accesos.First; temp != null; temp = temp.Next)
{
sim = temporal.buscar(temp.Value.id, linea, columna, "La variable");
if (sim != null)
{
if (temp.Next != null)
{
//esperamos un objeto
}
}
else
{
//error no se encontro la variable
return(null);
}
}
if (tipe.tipo == sim.tipo.tipo && sim.tipo.referencia == tipe.referencia)
{
nuevo.insertar(identify, sim, linea, columna, "La variable");
}
}
else
{
//Se esperaba un valor por referencia
}
}
else
{
Declaracion temp = new Declaracion(tipe, identify, resueltos.ElementAt(iterador), 0, 0);
((Declaracion)temp).valor = resueltos.ElementAt(iterador);//Expresion 1,2
temp.ejecutar(nuevo);
iterador++;
}
cont += 1;
}
}
}
/*
* Ejecucion como tal de la lista de declaraciones y de la lista de instrucciones (bloque)
*/
if (((Tipo_MF)f.valor).listaDeclaraciones != null)
{
foreach (Instruccion declaration in ((Tipo_MF)f.valor).listaDeclaraciones)
{
declaration.ejecutar(nuevo);
}
}
if (((Tipo_MF)f.valor).getbloque() == null)
{
foreach (Instruccion ins in ((Tipo_MF)f.valor).listaInstrucciones)
{
retorno = (Expresion)ins.ejecutar(nuevo);
}
}
else
{
//ejecutamos el bloque de instrucciones
retorno = (Expresion)((Tipo_MF)f.valor).getbloque().ejecutar(nuevo);
}
//verificamos si enviaron un return
if (retorno != null)
{
Primitivo sim = (Primitivo)retorno;
//validamos el retorno dentro del metodo o funcion
if (f.tipo.tipo == Tipo.enumTipo.Void && ((Expresion)retorno).tipo.tipo != Tipo.enumTipo.Void) //viene exit vacio
{
//error, porque si retorna algo no debe ser null
MasterClass.Instance.addError(new C_Error("Semantico", "No se esperaba retorno en metodo: " + nombreFuncion2, linea, columna));
retorno = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
}
else
{
//como no es void tiene tipo y verificamos que sea el mismo que la expresion recibida
if (f.tipo.tipo != sim.tipo.tipo)
{
//si no es el mismo entonces es un error
MasterClass.Instance.addError(new C_Error("Semantico", "El tipo de retorno y funcion no coinciden: " + sim.tipo.tipo + " = " + f.tipo.tipo, linea, columna));
retorno = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
}
}
}
else
{
//buscamos la variable con el mismo de la funcion
Variable nombreFuncionVar = nuevo.buscar(id, linea, columna, "La variable");
retorno = new Primitivo(f.tipo, nombreFuncionVar.valor);
}
}
else
{
MasterClass.Instance.addError(new C_Error("Semantico", "El metodo " + nombreFuncion2 + " no existe en el contexto", linea, columna));
}
MasterClass.PilaMF.RemoveLast();
return(retorno);
}
public int numero; //La dimension que es (primera, segunda)
public Dimension(Primitivo inferior, Primitivo superior)
{
this.inferior = inferior;
this.superior = superior;
}
public override Expresion getValor(Entorno ent)
{
Primitivo resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
Expresion resultado1 = hijo1.getValor(ent);
Expresion resultado2;
if (hijo2 == null)
{
resultado2 = null;
}
switch (this.operacion)
{
case "or":
if (resultado1.tipo.tipo == Tipo.enumTipo.booleano)
{
bool comparador1 = bool.Parse(resultado1.valor.ToString());
if (comparador1 == true)
{
//acepta la condicion y devuelve true
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), true);
}
else
{
//si no funciono el primero resolvemos el segundo
resultado2 = hijo2.getValor(ent);
if (resultado2.tipo.tipo == Tipo.enumTipo.booleano)
{
bool comparador2 = bool.Parse(resultado2.valor.ToString());
if (comparador2 == true)
{
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), true);
}
else
{
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), false);
}
}
}
}
else
{
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede comparar tipo de dato: " + resultado1.tipo.tipo + " con: " + hijo2.getValor(ent).tipo.tipo, linea, columna));
}
return(resultadoBool);
case "and":
if (resultado1.tipo.tipo == Tipo.enumTipo.booleano)
{
bool comparador1 = bool.Parse(resultado1.valor.ToString());
if (comparador1 == false)
{
//si es falso el primero lo devuelve y termina
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), false);
}
else
{
//si el primero es verdadero, debemos verificar el otro
resultado2 = hijo2.getValor(ent);
if (resultado2.tipo.tipo == Tipo.enumTipo.booleano)
{
bool comparador2 = bool.Parse(resultado2.valor.ToString());
if (comparador2 == true)
{
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), true);
}
else
{
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), false);
}
}
}
}
else
{
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede comparar tipo de dato: " + resultado1.tipo.tipo + " con: " + hijo2.getValor(ent).tipo.tipo, linea, columna));
}
return(resultadoBool);
case "xor":
resultado2 = hijo2.getValor(ent);
if (resultado1.tipo.tipo == Tipo.enumTipo.booleano && resultado2.tipo.tipo == Tipo.enumTipo.booleano)
{
bool comparador1 = bool.Parse(resultado1.valor.ToString());
bool comparador2 = bool.Parse(resultado2.valor.ToString());
if (comparador1 == true && comparador2 == true)
{
//iguales devuelve false
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), false);
}
else if (comparador1 == false && comparador2 == false)
{
//iguales devuelve false
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), false);
}
else if (comparador1 == true && comparador2 == false)
{
//diferentes devuelve true
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), true);
}
else if (comparador1 == false && comparador2 == true)
{
//diferentes devuelve true
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), true);
}
}
else
{
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede comparar tipo de dato: " + resultado1.tipo.tipo + " con: " + resultado2.tipo.tipo, linea, columna));
}
return(resultadoBool);
case "not":
resultado2 = null;
if (resultado1.tipo.tipo == Tipo.enumTipo.booleano && resultado2 == null)
{
bool comparador1 = bool.Parse(resultado1.valor.ToString());
if (comparador1 == true)
{
//negamos y devuelve false
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), false);
}
else if (comparador1 == false)
{
//negamos y devuelve true
resultadoBool = new Primitivo(new Tipo(Tipo.enumTipo.booleano), true);
}
}
else
{
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede comparar tipo de dato para negarse: " + resultado1.tipo.tipo, linea, columna));
}
return(resultadoBool);
}
return(resultadoBool);
}
public override object ejecutar(Entorno ent)
{
//insertamos a la pila de ciclos
MasterClass.Display.AddFirst(MasterClass.TipoCiclo.Ciclo);
//creamos un nuevo entorno y ejecutamos la instruccion inicial
Entorno entIntermedio = new Entorno(ent);
this.InsInicial.ejecutar(entIntermedio);
//ahora obtenemos el valor del valorFinal
Expresion valorFinal = this.valorFinal.getValor(entIntermedio);
//mandamos a buscar la variable que acabamos de asignar
Variable variable = entIntermedio.buscar(this.nombreVarAsignacion, this.linea, this.columna, "La variable");
//pasamos las variables a un tipo integer
int valorInicial = int.Parse(variable.valor.ToString());
int valorCondicional = int.Parse(valorFinal.valor.ToString());
//Bifurcacion Up_to vs Down_to
if (this.up_to)
{
//validamos que el valor sea menor o igual que el valor final
while (valorInicial <= valorCondicional)
{
//MessageBox.Show("To "+valorInicial +" , "+valorCondicional);
//creamos un nuevo entorno para ejecutar las instrucciones del bloque
Entorno ent3 = new Entorno(entIntermedio);
Object retornar = this.instrucciones.ejecutar(ent3);
if (retornar != null)
{
if (typeof(Break).IsInstanceOfType(retornar))
{
//si viene un break se detiene el flujo del ciclo
break;
}
else if (typeof(Continue).IsInstanceOfType(retornar))
{
//aqui solo se debe continuar el ciclo
//continue;
}
else if (typeof(Primitivo).IsInstanceOfType(retornar))
{
//Aqui devolvemos el valor del retorno
return(retornar);
}
}
Tipo tempTipo = new Tipo(Tipo.enumTipo.entero);
Primitivo temp = new Primitivo(tempTipo, valorInicial + 1);
//aumentamos el valor de la variable - Creamos una asignacion con un +1
Instruccion cheat = new Asignacion(this.nombreVarAsignacion, temp, this.linea, this.columna);
cheat.ejecutar(ent3);
//evaluamos de nuevo el valor inicial
Variable variable2 = ent3.buscar(this.nombreVarAsignacion, this.linea, this.columna, "La variable");
valorInicial = int.Parse(variable2.valor.ToString());
//MessageBox.Show("Saliendo" + valorInicial + " , " + valorCondicional);
}
}
else
{
//validamos que el valor sea menor o igual que el valor final
while (valorInicial >= valorCondicional)
{
//MessageBox.Show("Downto "+valorInicial + " , " + valorCondicional);
//creamos un nuevo entorno para ejecutar las instrucciones del bloque
Entorno ent3 = new Entorno(entIntermedio);
Object retorno = this.instrucciones.ejecutar(ent3);
if (retorno != null)
{
}
Tipo tempTipo = new Tipo(Tipo.enumTipo.entero);
Primitivo temp = new Primitivo(tempTipo, valorInicial - 1);
//aumentamos el valor de la variable - Creamos una asignacion con un +1
Instruccion cheat = new Asignacion(this.nombreVarAsignacion, temp, this.linea, this.columna);
cheat.ejecutar(ent3);
//evaluamos de nuevo el valor inicial
Variable variable2 = ent3.buscar(this.nombreVarAsignacion, this.linea, this.columna, "La variable");
valorInicial = int.Parse(variable2.valor.ToString());
//MessageBox.Show("Saliendo" + valorInicial + " , " + valorCondicional);
}
}
MasterClass.Display.RemoveFirst();
return(null);
}
public object compilar(Entorno ent, Errores errores)
{
//CREO MIS UTILIDADES
//ASIGNACION INICIAL
AsignacionId target = new AsignacionId(id, null, linea, columna);
Asignacion asignacionInicial = new Asignacion(target, primero, linea, columna);
//ACTUALIZACION DE LA VARIABLE Y CONDICION A EVALUAR
Asignacion actualizarVariable;
Primitivo valorFAD = new Primitivo(Tipos.INTEGER, "1", linea, columna);
Expresion condicion;
AccessId left = new AccessId(id, null, linea, columna);
if (fad.Equals("to"))
{
Less menorIgual = new Less(true, left, segundo, linea, columna);
condicion = (Expresion)menorIgual;
Suma suma = new Suma(left, valorFAD, linea, columna);
actualizarVariable = new Asignacion(target, (Expresion)suma, linea, columna);
}
else //downto
{
Greater mayorIgual = new Greater(true, left, segundo, linea, columna);
condicion = (Expresion)mayorIgual;
Resta resta = new Resta(left, valorFAD, linea, columna);
actualizarVariable = new Asignacion(target, (Expresion)resta, linea, columna);
}
//INICIO LA COMPILACION
try
{
Generator generator = Generator.getInstance();
generator.addComment("Inicia FOR");
asignacionInicial.compilar(ent, errores);
string lblFor = generator.newLabel();
generator.addLabel(lblFor);
Retorno retcondicion = condicion.compilar(ent);
if (retcondicion.type.tipo == Tipos.BOOLEAN)
{
ent.fors.AddLast(new IteFor(true, actualizarVariable));
ent.ybreak.AddLast(retcondicion.falseLabel);
ent.ycontinue.AddLast(lblFor);
generator.addLabel(retcondicion.trueLabel);
foreach (Instruccion sentencia in sentencias)
{
sentencia.compilar(ent, errores);
}
actualizarVariable.compilar(ent, errores);
generator.addGoto(lblFor);
generator.addLabel(retcondicion.falseLabel);
ent.fors.RemoveLast();
ent.ybreak.RemoveLast();
ent.ycontinue.RemoveLast();
generator.addComment("Finaliza FOR");
}
else
{
throw new Error("Semántico", "La condicion a evaluar en el for no es de tipo Boolean", ent.obtenerAmbito(), linea, columna);
}
} catch (Error ex)
{
errores.agregarError(ex);
}
return(null);
}
public object compilar(Entorno ent, Errores errores)
{
try
{
Generator generator = Generator.getInstance();
Retorno value;
if (this.value != null)
{
value = this.value.compilar(ent);
if (!sameType(this.type, value.type))
{
throw new Error("Semántico", "Valor no compatible con el tipo de dato", ent.obtenerAmbito(), linea, columna);
}
}
else //LITERAL POR DEFECTO
{
switch (type.tipo)
{
case Tipos.INTEGER:
Primitivo defecto = new Primitivo(Tipos.INTEGER, "0", linea, columna);
value = defecto.compilar(ent);
break;
case Tipos.REAL:
Primitivo defecto1 = new Primitivo(Tipos.REAL, "0.0", linea, columna);
value = defecto1.compilar(ent);
break;
case Tipos.BOOLEAN:
Primitivo defecto2 = new Primitivo(Tipos.BOOLEAN, false, linea, columna);
value = defecto2.compilar(ent);
break;
default: //case Tipos.STRING:
PrimitivoString defecto3 = new PrimitivoString(Tipos.STRING, "", linea, columna);
value = defecto3.compilar(ent);
break;
}
}
this.validateType(ent);
foreach (string id in idList)
{
Simbolo newVar = ent.addVar(id, type, false, false, linea, columna);
if (newVar.isGlobal)
{
if (this.type.tipo == Tipos.BOOLEAN)
{
//Mi modificacion
//para cuando viene mas de una variable en la declaracion
if (!idList.ElementAt(0).Equals(id))
{
value.trueLabel = generator.newLabel();
value.falseLabel = generator.newLabel();
}
if (value.getValue().Equals("1"))
{
generator.addGoto(value.trueLabel);
}
else
{
generator.addGoto(value.falseLabel);
}
string templabel = generator.newLabel();
generator.addLabel(value.trueLabel);
generator.addSetStack("" + newVar.position, "1");
generator.addGoto(templabel);
generator.addLabel(value.falseLabel);
generator.addSetStack("" + newVar.position, "0");
generator.addLabel(templabel);
}
else
{
generator.addSetStack("" + newVar.position, value.getValue());
}
}
else
{
string temp = generator.newTemporal();
generator.freeTemp(temp);
generator.addExpression(temp, "SP", "" + newVar.position, "+");
if (this.type.tipo == Tipos.BOOLEAN)
{
//Mi modificacion
//para cuando viene mas de una variable en la declaracion
if (!idList.ElementAt(0).Equals(id))
{
value.trueLabel = generator.newLabel();
value.falseLabel = generator.newLabel();
}
if (value.getValue().Equals("1"))
{
generator.addGoto(value.trueLabel);
}
else
{
generator.addGoto(value.falseLabel);
}
string templabel = generator.newLabel();
generator.addLabel(value.trueLabel);
generator.addSetStack(temp, "1");
generator.addGoto(templabel);
generator.addLabel(value.falseLabel);
generator.addSetStack(temp, "0");
generator.addLabel(templabel);
}
else
{
generator.addSetStack(temp, value.getValue());
}
}
}
}
catch (Error ex)
{
errores.agregarError(ex);
}
return(null);
}
public override Objeto execute(Entorno entorno)
{
//TODO: implementar asignacion, validar que sea integer
Simbolo inicio = this.condicion.execute_for(entorno);
validar_integer(inicio.getValor());
Objeto final = obtener_expresion(entorno);
validar_integer(final);
int b = Int16.Parse(final.getValor().ToString());
// Asignacion se debe agregar aca
int a = Int16.Parse(inicio.getValor().getValor().ToString());
if (comportamiento)
{
for (int i = a; i >= b; i--)
{
Primitivo pr = new Primitivo(Objeto.TipoObjeto.INTEGER, i);
inicio.setValor(pr);
foreach (Nodo instruccion in this.instrucciones)
{
if (instruccion != null)
{
try
{
Objeto retorno = instruccion.execute(entorno);
if (retorno != null)
{
if (retorno.getTipo() == Objeto.TipoObjeto.CONTINUE)
{
break;
}
else if (retorno.getTipo() == Objeto.TipoObjeto.BREAK)
{
return(null);
}
else if (retorno.getTipo() == Objeto.TipoObjeto.NULO)
{
return(retorno);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
}
}
else
{
for (int i = a; i <= b; i++)
{
Primitivo pr = new Primitivo(Objeto.TipoObjeto.INTEGER, i);
inicio.setValor(pr);
foreach (Nodo instruccion in this.instrucciones)
{
if (instruccion != null)
{
try
{
//validar los retornos
Objeto retorno = instruccion.execute(entorno);
if (retorno != null)
{
if (retorno.getTipo() == Objeto.TipoObjeto.CONTINUE)
{
break;
}
else if (retorno.getTipo() == Objeto.TipoObjeto.BREAK)
{
return(null);
}
else if (retorno.getTipo() == Objeto.TipoObjeto.NULO)
{
return(retorno);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
}
}
return(null);
}
private object analizarNodo(ParseTreeNode actual)
{
//INICIO DE LA GRAMATICA
if (compararNodo(actual, "S"))
{
LinkedList <Instruccion> instrucciones = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[0]);
return(new AST(instrucciones));
}
else if (compararNodo(actual, "P"))
{
LinkedList <Instruccion> pilatemp = new LinkedList <Instruccion>();
if (actual.ChildNodes.Count == 4)
{
//MAIN
Bloque bloque = (Bloque)analizarNodo(actual.ChildNodes[3]);
recorrerBloque(pilatemp, bloque);
}
else if (actual.ChildNodes.Count == 5)
{
//L_AC; MAIN
LinkedList <Bloque> bloques = ((LinkedList <Bloque>)analizarNodo(actual.ChildNodes[3])); //L_AC
foreach (Bloque bloque in bloques)
{
recorrerBloque(pilatemp, bloque); //Agrego las instrucciones que viene en pilatemp
}
recorrerBloque(pilatemp, (Bloque)analizarNodo(actual.ChildNodes[4])); //MAIN
}
return(pilatemp);
}
else if (compararNodo(actual, "L_AC"))
{
LinkedList <Bloque> acciones = new LinkedList <Bloque>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
acciones.AddLast((Bloque)analizarNodo(hijo)); //AC
}
return(acciones);
}
else if (compararNodo(actual, "AC"))
{
return(analizarNodo(actual.ChildNodes[0])); //retornando Bloque
}
else if (compararNodo(actual, "G_CNT"))
{
return(new Bloque((LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[1])));
}
else if (compararNodo(actual, "L_CNT"))
{
LinkedList <Instruccion> constantes = new LinkedList <Instruccion>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
constantes.AddLast((Instruccion)analizarNodo(hijo));
}
return(constantes);
}
else if (compararNodo(actual, "CNT"))
{
string id = getLexema(actual.ChildNodes[0]);
Expresion value = (Expresion)analizarNodo(actual.ChildNodes[2]);
return(new DeclaConstante(id, value, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararNodo(actual, "G_TY"))
{
return(new Bloque((LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[1])));
}
else if (compararNodo(actual, "L_TY"))
{
LinkedList <Instruccion> instrucciones = new LinkedList <Instruccion>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
instrucciones.AddLast((Instruccion)analizarNodo(hijo));
}
return(instrucciones);
}
else if (compararNodo(actual, "TY"))
{
string id = getLexema(actual.ChildNodes[0]);
if (compararNodo(actual.ChildNodes[2].ChildNodes[0], "OBJ"))
{
LinkedList <Param> paramList = (LinkedList <Param>)analizarNodo(actual.ChildNodes[2].ChildNodes[0]); //OBJ
return(new StructSt(id, paramList, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else //ARRAY
{
LinkedList <Dimension> dimensiones = (LinkedList <Dimension>)analizarNodo(actual.ChildNodes[2].ChildNodes[0].ChildNodes[2]); //L_DIM
Tipo tipoArreglo = (Tipo)analizarNodo(actual.ChildNodes[2].ChildNodes[0].ChildNodes[5]); //ZTIPO
return(new ArraySt(id, dimensiones, tipoArreglo, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
}
else if (compararNodo(actual, "L_DIM"))
{
LinkedList <Dimension> dimensiones = new LinkedList <Dimension>();
int numero = 0;
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
Dimension dimension = (Dimension)analizarNodo(hijo);
numero++;
dimension.numero = numero;
dimensiones.AddLast(dimension);
}
return(dimensiones);
}
else if (compararNodo(actual, "DIM"))
{
Primitivo inferior = (Primitivo)obtenerLiteral(actual.ChildNodes[0]);
Primitivo superior = (Primitivo)obtenerLiteral(actual.ChildNodes[3]);
return(new Dimension(inferior, superior));
}
else if (compararNodo(actual, "OBJ"))
{
return(analizarNodo(actual.ChildNodes[2]));
}
else if (compararNodo(actual, "L_AT"))
{
LinkedList <Param> paramList = new LinkedList <Param>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
LinkedList <Param> paramhijos = (LinkedList <Param>)analizarNodo(hijo);
foreach (Param paramhijo in paramhijos)
{
paramList.AddLast(paramhijo);
}
}
return(paramList);
}
else if (compararNodo(actual, "AT"))
{
LinkedList <string> idList = (LinkedList <string>)analizarNodo(actual.ChildNodes[0]); //L_ID
Tipo tipo = (Tipo)analizarNodo(actual.ChildNodes[2]); //ZTIPO
LinkedList <Param> atributos = new LinkedList <Param>();
foreach (string id in idList)
{
atributos.AddLast(new Param(id, tipo));
}
return(atributos);
}
else if (compararNodo(actual, "DECLAS"))
{
return(new Bloque((LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[1])));
}
else if (compararNodo(actual, "L_VR"))
{
LinkedList <Instruccion> declaraciones = new LinkedList <Instruccion>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
declaraciones.AddLast((Instruccion)analizarNodo(hijo));
}
return(declaraciones);
}
else if (compararNodo(actual, "VR"))
{
LinkedList <string> idList;
Tipo tipo;
if (actual.ChildNodes.Count == 6)
{
idList = (LinkedList <string>)analizarNodo(actual.ChildNodes[0]);
tipo = (Tipo)analizarNodo(actual.ChildNodes[2]);
Expresion value = (Expresion)analizarNodo(actual.ChildNodes[4]);
return(new Declaracion(tipo, idList, value, actual.ChildNodes[1].Token.Location.Line, actual.ChildNodes[1].Token.Location.Column));
}
else //4 HIJOS
{
idList = (LinkedList <string>)analizarNodo(actual.ChildNodes[0]);
tipo = (Tipo)analizarNodo(actual.ChildNodes[2]);
Expresion value = null;
if (tipo.tipo == Tipos.STRUCT)
{
value = new NewStruct(tipo.tipoId, actual.ChildNodes[1].Token.Location.Line, actual.ChildNodes[1].Token.Location.Column);
}
return(new Declaracion(tipo, idList, value, actual.ChildNodes[1].Token.Location.Line, actual.ChildNodes[1].Token.Location.Column));
}
}
else if (compararNodo(actual, "L_ID"))
{
LinkedList <string> idList = new LinkedList <string>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
idList.AddLast(getLexema(hijo));
}
return(idList);
}
else if (compararNodo(actual, "ZTIPO"))
{
Tipos tipoenum;
if (compararID(actual.ChildNodes[0]))
{
tipoenum = Tipo.Tipos.STRUCT;
return(new Tipo(tipoenum, getLexema(actual.ChildNodes[0])));
}
else //TIPO
{
tipoenum = (Tipos)analizarNodo(actual.ChildNodes[0]);
return(new Tipo(tipoenum));
}
}
else if (compararNodo(actual, "TIPO"))
{
string tipocadena = getLexema(actual.ChildNodes[0]).ToLower();
switch (tipocadena)
{
case "integer": return(Tipos.INTEGER);
case "real": return(Tipos.REAL);
case "string": return(Tipos.STRING);
default: return(Tipos.BOOLEAN); //boolean
}
}
else if (compararNodo(actual, "L_PROF"))
{
LinkedList <Instruccion> funciones = new LinkedList <Instruccion>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
funciones.AddLast((Instruccion)analizarNodo(hijo));
}
return(new Bloque(funciones));
}
else if (compararNodo(actual, "PROF"))
{
return(analizarNodo(actual.ChildNodes[0]));
}
else if (compararNodo(actual, "PRO"))
{
Tipo tipo = new Tipo(Tipo.Tipos.VOID);
string id = getLexema(actual.ChildNodes[1]);
LinkedList <Param> parametros = new LinkedList <Param>();
LinkedList <Bloque> bloques;
if (actual.ChildNodes.Count == 7)
{
parametros = (LinkedList <Param>)analizarNodo(actual.ChildNodes[3]);
bloques = (LinkedList <Bloque>)analizarNodo(actual.ChildNodes[6]);
}
else if (actual.ChildNodes.Count == 6)
{
bloques = (LinkedList <Bloque>)analizarNodo(actual.ChildNodes[5]);
}
else //4 hijos
{
bloques = (LinkedList <Bloque>)analizarNodo(actual.ChildNodes[3]);
}
return(new FunctionSt(tipo, id, parametros, bloques, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararNodo(actual, "FUN"))
{
string id = getLexema(actual.ChildNodes[1]);
Tipo tipo;
LinkedList <Param> parametros = new LinkedList <Param>();
LinkedList <Bloque> bloques;
if (actual.ChildNodes.Count == 9)
{
parametros = (LinkedList <Param>)analizarNodo(actual.ChildNodes[3]);
tipo = (Tipo)analizarNodo(actual.ChildNodes[6]);
bloques = (LinkedList <Bloque>)analizarNodo(actual.ChildNodes[8]);
}
else if (actual.ChildNodes.Count == 8)
{
tipo = (Tipo)analizarNodo(actual.ChildNodes[5]);
bloques = (LinkedList <Bloque>)analizarNodo(actual.ChildNodes[7]);
}
else //6 hijos
{
tipo = (Tipo)analizarNodo(actual.ChildNodes[3]);
bloques = (LinkedList <Bloque>)analizarNodo(actual.ChildNodes[5]);
}
return(new FunctionSt(tipo, id, parametros, bloques, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararNodo(actual, "L_PARAM"))
{
LinkedList <Param> parametros = new LinkedList <Param>();
LinkedList <Param> paramhijos;
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
paramhijos = (LinkedList <Param>)analizarNodo(hijo);
foreach (Param param in paramhijos)
{
parametros.AddLast(param);
}
}
return(parametros);
}
else if (compararNodo(actual, "PARAM"))
{
LinkedList <string> idList;
Tipo tipo;
bool isRef;
if (actual.ChildNodes.Count == 3)
{
idList = (LinkedList <string>)analizarNodo(actual.ChildNodes[0]);
tipo = (Tipo)analizarNodo(actual.ChildNodes[2]); //ZTIPO
isRef = false;
}
else //4 HIJOS
{
idList = (LinkedList <string>)analizarNodo(actual.ChildNodes[1]);
tipo = (Tipo)analizarNodo(actual.ChildNodes[3]); //ZTIPO
isRef = true;
}
LinkedList <Param> atributos = new LinkedList <Param>();
foreach (string id in idList)
{
atributos.AddLast(new Param(id, tipo, isRef));
}
return(atributos);
}
else if (compararNodo(actual, "SPACE"))
{
LinkedList <Bloque> bloques;
Bloque nuevobloque;
LinkedList <Instruccion> sentencias;
if (actual.ChildNodes.Count == 1) //BEG
{
bloques = new LinkedList <Bloque>();
sentencias = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[0]);
nuevobloque = new Bloque(sentencias);
bloques.AddLast(nuevobloque);
}
else //L_DEF BEG
{
bloques = (LinkedList <Bloque>)analizarNodo(actual.ChildNodes[0]);
sentencias = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[1]);
nuevobloque = new Bloque(sentencias);
bloques.AddLast(nuevobloque);
}
return(bloques);
}
else if (compararNodo(actual, "L_DEF"))
{
LinkedList <Bloque> bloques = new LinkedList <Bloque>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
bloques.AddLast((Bloque)analizarNodo(hijo));
}
return(bloques);
}
else if (compararNodo(actual, "DEF"))
{
//retorno un bloque
return(analizarNodo(actual.ChildNodes[0]));
}
else if (compararNodo(actual, "MAIN"))
{
//L_SEN
return(new Bloque((LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[1])));
}
else if (compararNodo(actual, "L_SEN"))
{
LinkedList <Instruccion> sentencias = new LinkedList <Instruccion>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
sentencias.AddLast((Instruccion)analizarNodo(hijo)); //SEN
}
return(sentencias);
}
else if (compararNodo(actual, "SEN"))
{
return(analizarNodo(actual.ChildNodes[0]));
}
else if (compararNodo(actual, "BEG"))
{
return(analizarNodo(actual.ChildNodes[1])); //retorna lista de sentencias
}
else if (compararNodo(actual, "L_SENCU"))
{
LinkedList <Instruccion> sentencias = new LinkedList <Instruccion>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
LinkedList <Instruccion> sentenciashijo = (LinkedList <Instruccion>)analizarNodo(hijo);
foreach (Instruccion senhijo in sentenciashijo)
{
sentencias.AddLast(senhijo);
}
}
return(sentencias);
}
else if (compararNodo(actual, "SENCU"))
{
LinkedList <Instruccion> sentencias;
if (compararNodo(actual.ChildNodes[0], "BEG"))
{
sentencias = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[0]);
}
else //SEN
{
sentencias = new LinkedList <Instruccion>();
sentencias.AddLast((Instruccion)analizarNodo(actual.ChildNodes[0]));
}
return(sentencias);
}
else if (compararNodo(actual, "ASIG"))
{
Expresion target = (Expresion)analizarNodo(actual.ChildNodes[0]);
Expresion value = (Expresion)analizarNodo(actual.ChildNodes[2]);
return(new Asignacion(target, value, actual.ChildNodes[1].Token.Location.Line, actual.ChildNodes[1].Token.Location.Column));
}
else if (compararNodo(actual, "ASID"))
{
if (actual.ChildNodes.Count == 3)
{
Expresion anterior = (Expresion)analizarNodo(actual.ChildNodes[0]);
string id = getLexema(actual.ChildNodes[2]);
return(new AsignacionId(id, anterior, actual.ChildNodes[1].Token.Location.Line, actual.ChildNodes[1].Token.Location.Column));
}
else //UN HIJO
{
string id = getLexema(actual.ChildNodes[0]);
return(new AsignacionId(id, null, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
}
else if (compararNodo(actual, "IF"))
{
Expresion condicion = (Expresion)analizarNodo(actual.ChildNodes[1]);
LinkedList <Instruccion> sentencias = new LinkedList <Instruccion>();
LinkedList <Instruccion> sentenciasElse;
if (actual.ChildNodes.Count <= 5)
{
if (compararNodo(actual.ChildNodes[3], "BEG"))
{
sentencias = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[3]);
}
else //SEN
{
sentencias.AddLast((Instruccion)analizarNodo(actual.ChildNodes[3]));
}
sentenciasElse = null;
if (actual.ChildNodes.Count == 5)
{
sentenciasElse = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[4]); //ELSE
}
}
else //7 HIJOS
{
sentencias = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[4]);
sentenciasElse = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[6]);
}
return(new If(condicion, sentencias, sentenciasElse, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararNodo(actual, "ELSE"))
{
LinkedList <Instruccion> sentencias;
if (compararNodo(actual.ChildNodes[1], "BEG"))
{
sentencias = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[1]);
}
else //SEN
{
sentencias = new LinkedList <Instruccion>();
sentencias.AddLast((Instruccion)analizarNodo(actual.ChildNodes[1]));
}
return(sentencias);
}
else if (compararNodo(actual, "CASE"))
{
string id;
AccessId variable;
LinkedList <Opcion> opciones;
LinkedList <Instruccion> sentenciasElse = null;
if (actual.ChildNodes.Count == 6)
{
id = getLexema(actual.ChildNodes[1]);
variable = new AccessId(id, null, actual.ChildNodes[1].Token.Location.Line, actual.ChildNodes[1].Token.Location.Column);
opciones = (LinkedList <Opcion>)analizarNodo(actual.ChildNodes[3]);
}
else if (actual.ChildNodes.Count == 7)
{
id = getLexema(actual.ChildNodes[1]);
variable = new AccessId(id, null, actual.ChildNodes[1].Token.Location.Line, actual.ChildNodes[1].Token.Location.Column);
opciones = (LinkedList <Opcion>)analizarNodo(actual.ChildNodes[3]);
sentenciasElse = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[4]);
}
else if (actual.ChildNodes.Count == 8)
{
id = getLexema(actual.ChildNodes[2]);
variable = new AccessId(id, null, actual.ChildNodes[2].Token.Location.Line, actual.ChildNodes[2].Token.Location.Column);
opciones = (LinkedList <Opcion>)analizarNodo(actual.ChildNodes[5]);
}
else // 9 HIJOS
{
id = getLexema(actual.ChildNodes[2]);
variable = new AccessId(id, null, actual.ChildNodes[2].Token.Location.Line, actual.ChildNodes[2].Token.Location.Column);
opciones = (LinkedList <Opcion>)analizarNodo(actual.ChildNodes[5]);
sentenciasElse = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[6]);
}
return(new Case(variable, opciones, sentenciasElse, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararNodo(actual, "L_OPC"))
{
LinkedList <Opcion> opciones = new LinkedList <Opcion>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
opciones.AddLast((Opcion)analizarNodo(hijo));
}
return(opciones);
}
else if (compararNodo(actual, "OPC"))
{
LinkedList <Expresion> etiquetas = (LinkedList <Expresion>)analizarNodo(actual.ChildNodes[0]);
LinkedList <Instruccion> sentencias = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[2]);
return(new Opcion(etiquetas, sentencias, actual.ChildNodes[1].Token.Location.Line, actual.ChildNodes[1].Token.Location.Column));
}
else if (compararNodo(actual, "LETC"))
{
LinkedList <Expresion> etiquetas = new LinkedList <Expresion>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
etiquetas.AddLast((Expresion)analizarNodo(hijo));
}
return(etiquetas);
}
else if (compararNodo(actual, "ETC"))
{
if (actual.ChildNodes.Count == 2)
{
Primitivo numero = (Primitivo)obtenerLiteral(actual.ChildNodes[1]);
numero.value = "-" + numero.value.ToString();
return(numero);
}
else
{
return(obtenerLiteral(actual.ChildNodes[0]));
}
}
else if (compararNodo(actual, "REP"))
{
LinkedList <Instruccion> sentencias = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[1]);
Expresion condicion = (Expresion)analizarNodo(actual.ChildNodes[3]);
return(new Repeat(condicion, sentencias, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararNodo(actual, "WH"))
{
Expresion condicion = (Expresion)analizarNodo(actual.ChildNodes[1]);
LinkedList <Instruccion> sentencias = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[3]);
return(new While(condicion, sentencias, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararNodo(actual, "FOR"))
{
string id = getLexema(actual.ChildNodes[1]);
Expresion primero = (Expresion)analizarNodo(actual.ChildNodes[3]);
string fad = getLexema(actual.ChildNodes[4].ChildNodes[0]);
Expresion segundo = (Expresion)analizarNodo(actual.ChildNodes[5]);
LinkedList <Instruccion> sentencias = (LinkedList <Instruccion>)analizarNodo(actual.ChildNodes[7]);
return(new For(id, primero, fad, segundo, sentencias, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararNodo(actual, "BRK"))
{
return(new Break(actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararNodo(actual, "COT"))
{
return(new Continue(actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararNodo(actual, "WRT"))
{
bool esSalto = false;
if (getLexema(actual.ChildNodes[0]).ToLower() == "writeln")
{
esSalto = true; //sino es write
}
return(new Writeln((LinkedList <Expresion>)analizarNodo(actual.ChildNodes[2]), esSalto, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararNodo(actual, "EXT"))
{
if (actual.ChildNodes.Count == 5)
{
return(new Return((Expresion)analizarNodo(actual.ChildNodes[2]), actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else // 4 HIJOS
{
return(new Return(null, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
}
else if (compararNodo(actual, "L_EXP"))
{
LinkedList <Expresion> expresiones = new LinkedList <Expresion>();
foreach (ParseTreeNode hijo in actual.ChildNodes)
{
expresiones.AddLast((Expresion)analizarNodo(hijo));
}
return(expresiones);
}
else if (compararNodo(actual, "EXPLOG"))
{
if (actual.ChildNodes.Count == 3)
{
if (compararNodo(actual.ChildNodes[0], "(")) // ( EXPLOG )
{
return(analizarNodo(actual.ChildNodes[1]));
}
else
{
//EXPLOG SIGNO EXPLOG
Expresion izquierda = (Expresion)analizarNodo(actual.ChildNodes[0]);
Expresion derecha = (Expresion)analizarNodo(actual.ChildNodes[2]);
return(getOperacion(actual.ChildNodes[1], izquierda, derecha));
}
}
else if (actual.ChildNodes.Count == 2)
{
//not EXPLOG
return(new Not((Expresion)analizarNodo(actual.ChildNodes[1]), actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
if (actual.ChildNodes.Count == 1)
{
//UN HIJO
return(analizarNodo(actual.ChildNodes[0]));
}
}
else if (compararNodo(actual, "EXPRELA"))
{
if (actual.ChildNodes.Count == 3)
{
if (compararNodo(actual.ChildNodes[0], "(")) // ( EXPRELA )
{
return(analizarNodo(actual.ChildNodes[1]));
}
else
{
//EXPRELA SIGNO EXPRELA
Expresion izquierda = (Expresion)analizarNodo(actual.ChildNodes[0]);
Expresion derecha = (Expresion)analizarNodo(actual.ChildNodes[2]);
return(getOperacion(actual.ChildNodes[1], izquierda, derecha));
}
}
else //UN HIJO
{
return(analizarNodo(actual.ChildNodes[0]));
}
}
else if (compararNodo(actual, "EXPNUMERICA"))
{
if (actual.ChildNodes.Count == 3)
{
if (compararNodo(actual.ChildNodes[0], "(")) // ( EXPNUMERICA )
{
return(analizarNodo(actual.ChildNodes[1]));
}
else
{
//EXPNUMERICA operador EXPNUMERICA
Expresion izquierda = (Expresion)analizarNodo(actual.ChildNodes[0]);
Expresion derecha = (Expresion)analizarNodo(actual.ChildNodes[2]);
return(getOperacion(actual.ChildNodes[1], izquierda, derecha));
}
}
else if (actual.ChildNodes.Count == 2)
{
Expresion unario = (Expresion)analizarNodo(actual.ChildNodes[1]);
return(new RestaUni(unario, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else //UN HIJO
{
if (compararID(actual.ChildNodes[0]))
{
}
else
{
return(analizarNodo(actual.ChildNodes[0])); //LITERAL o ACCESS
}
}
}
else if (compararNodo(actual, "ACCESS"))
{
return(analizarNodo(actual.ChildNodes[0]));
}
else if (compararNodo(actual, "ACCID"))
{
if (actual.ChildNodes.Count == 3)
{
Expresion anterior = (Expresion)analizarNodo(actual.ChildNodes[0]);
string id = getLexema(actual.ChildNodes[2]);
return(new AccessId(id, anterior, actual.ChildNodes[1].Token.Location.Line, actual.ChildNodes[1].Token.Location.Column));
}
else //UN HIJO
{
string id = getLexema(actual.ChildNodes[0]);
return(new AccessId(id, null, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
}
else if (compararNodo(actual, "CALL"))
{
string id = getLexema(actual.ChildNodes[0]);
LinkedList <Expresion> parametros = new LinkedList <Expresion>();
if (actual.ChildNodes.Count == 5)
{
parametros = (LinkedList <Expresion>)analizarNodo(actual.ChildNodes[2]);
}
return(new AsignacionFunc(id, parametros, null, actual.ChildNodes[0].Token.Location.Line, actual.ChildNodes[0].Token.Location.Column));
}
else if (compararLiteral(actual)) //LITERAL
{
return(obtenerLiteral(actual));
}
return(null);
}
public override Expresion getValor(Entorno ent)
{
Primitivo resultadoDivi = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
Expresion resultado1 = hijo1.getValor(ent);
Expresion resultado2 = hijo2.getValor(ent);
switch (resultado1.tipo.tipo)
{
//si el primer hijo es entero
case Tipo.enumTipo.entero:
switch (resultado2.tipo.tipo)
{
case Tipo.enumTipo.entero:
//si hijo1 es entero e hijo2 es entero = entero
if (int.Parse(resultado2.valor.ToString()) == 0)
{
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir entre 0 una cantidad ", linea, columna));
return(resultadoDivi);
}
resultadoDivi = new Primitivo(new Tipo(Tipo.enumTipo.entero), int.Parse(resultado1.valor.ToString()) / int.Parse(resultado2.valor.ToString()));
return(resultadoDivi);
case Tipo.enumTipo.real:
//si hijo1 es entero e hijo2 es doble = doble
if (float.Parse(resultado2.valor.ToString()) == 0.0)
{
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir entre 0 una cantidad ", linea, columna));
return(resultadoDivi);
}
resultadoDivi = new Primitivo(new Tipo(Tipo.enumTipo.real), float.Parse(resultado1.valor.ToString()) / float.Parse(resultado2.valor.ToString()));
return(resultadoDivi);
/*
* case Tipo.enumTipo.caracter:
* //si hijo1 es entero e hijo2 es un caracter = entero
* if ((int)(resultado2.valor.ToString().charAt(0)) == 0)
* {
* MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir entre 0 una cantidad ", linea, columna));
* return resultadoDivi;
* }
* resultadoDivi = new Primitivo(new Tipo(Tipo.enumTipo.entero), int.Parse(resultado1.valor.ToString()) / (int)(resultado2.valor.ToString().charAt(0)));
* return resultadoDivi;
*/
default:
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir: " + resultado1.tipo.tipo + " con: " + resultado2.tipo.tipo, linea, columna));
break;
}
break;
//si el primer hijo es double
case Tipo.enumTipo.real:
switch (resultado2.tipo.tipo)
{
case Tipo.enumTipo.entero:
//si el hijo1 es doble y el hijo2 es entero = doble
if (float.Parse(resultado2.valor.ToString()) == 0.0)
{
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir entre 0 una cantidad ", linea, columna));
return(resultadoDivi);
}
resultadoDivi = new Primitivo(new Tipo(Tipo.enumTipo.real), float.Parse(resultado1.valor.ToString()) / float.Parse(resultado2.valor.ToString()));
return(resultadoDivi);
case Tipo.enumTipo.real:
if (float.Parse(resultado2.valor.ToString()) == 0.0)
{
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir entre 0 una cantidad ", linea, columna));
return(resultadoDivi);
}
//si el hijo1 es doble y el hijo2 es doble = doble
resultadoDivi = new Primitivo(new Tipo(Tipo.enumTipo.real), float.Parse(resultado1.valor.ToString()) / float.Parse(resultado2.valor.ToString()));
return(resultadoDivi);
/*
* case Tipo.enumTipo.caracter:
* if ((double)(resultado2.valor.ToString().charAt(0)) == 0.0)
* {
* MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir entre 0 una cantidad ", linea, columna));
* return resultadoDivi;
* }
* //si el hijo1 es doble y el hijo2 es caracter = doble
* resultadoDivi = new Primitivo(new Tipo(Tipo.enumTipo.entero), float.Parse(resultado1.valor.ToString()) / (double)resultado2.valor.ToString().charAt(0));
* return resultadoDivi;
*/
default:
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir: " + resultado1.tipo.tipo + " con: " + resultado2.tipo.tipo, linea, columna));
break;
}
break;
//si el primer hijo es caracter
/*
* case caracter:
*
* switch (resultado2.tipo.tipo)
* {
*
* case entero:
* //si el hijo1 es caracter y el hijo2 es entero = entero
* if (int.Parse(resultado2.valor.ToString()) == 0)
* {
* MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir entre 0 una cantidad ", linea, columna));
* return resultadoDivi;
* }
* resultadoDivi = new Primitivo(new Tipo(Tipo.enumTipo.entero), (int)resultado1.valor.ToString().charAt(0) / int.Parse(resultado2.valor.ToString()));
* return resultadoDivi;
* case doble:
* //si el hijo1 es caracter y el hijo2 es doble = doble
* if (float.Parse(resultado2.valor.ToString()) == 0.0)
* {
* MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir entre 0 una cantidad ", linea, columna));
* return resultadoDivi;
* }
* resultadoDivi = new Primitivo(new Tipo(Tipo.enumTipo.doble), (double)resultado1.valor.ToString().charAt(0) / float.Parse(resultado2.valor.ToString()));
* return resultadoDivi;
* case caracter:
* //si el hijo1 es caracter y el hijo2 es caracter = entero
* if ((int)(resultado2.valor.ToString().charAt(0)) == 0)
* {
* MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir entre 0 una cantidad ", linea, columna));
* return resultadoDivi;
* }
* resultadoDivi = new Primitivo(new Tipo(Tipo.enumTipo.entero), (int)resultado1.valor.ToString().charAt(0) / (int)resultado2.valor.ToString().charAt(0));
* return resultadoDivi;
* default:
* MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir: " + resultado1.tipo.tipo + " con: " + resultado2.tipo.tipo, linea, columna));
* break;
* }
* break;
*/
}
MasterClass.Instance.addError(new C_Error("Semantico", "No se puede dividir: " + resultado1.tipo.tipo + " con: " + resultado2.tipo.tipo, linea, columna));
return(resultadoDivi);
}
