public override object Execute(Ambit ambit)
{
//VERIFICA QUE LAS SENTNECIAS NO VENGAN VACIAS
if (!sentence.IsNull)
{
var element = sentence.Execute(ambit);
if (element != null)
{
if (element is Instruction)
{
var inst = (Instruction)element;
if (inst.Name.Equals("Break") || inst.Name.Equals("Exit"))
{
return(element);
}
}
}
else
{
return(null);
}
}
else
{
return(0);
}
return(0);
}
public override object Execute(Ambit ambit)
{
var ifAmbit = new Ambit(ambit, ambit.Ambit_name, "If", false);
//CONDICION
var condition = this.condition.Execute(ifAmbit);
//VERIFICA QUE LLA CONDICION SEA BOOLEANA
if (condition.getDataType != DataType.BOOLEAN)
{
setError("Semantico - La condicion del If no es booleana", row, column);
return(null);
}
if ((bool)condition.Value == true)
{
if (sentences.IsNull)
{
return(0);
}
return(this.sentences.Execute(ifAmbit));
}
else
{
if (elif.IsNull)
{
return(0);
}
var elseAmbit = new Ambit(ambit, ambit.Ambit_name, "Else", false);
return(elif.Execute(elseAmbit));
}
}
public override Returned Execute(Ambit ambit)
{
var returned = new Returned();
if (this.type == 1)
{
returned = new Returned(int.Parse(this.value.ToString()), DataType.INTEGER);
}
else if (this.type == 2)
{
returned = new Returned(this.value.ToString(), DataType.STRING);
}
else if (this.type == 3)
{
if (this.value.ToString() == "false")
{
returned = new Returned(false, DataType.BOOLEAN);
}
else
{
returned = new Returned(true, DataType.BOOLEAN);
}
}
else if (this.type == 4)
{
returned = new Returned(double.Parse(this.value.ToString()), DataType.REAL);
}
else if (this.type == 7)
{
returned = new Returned(this.value.ToString(), DataType.IDENTIFIER);
}
return(returned);
}
public override object Execute(Ambit a)
{
var texto = "";
foreach (var el in value)
{
var element = el.Execute(a);
if (element.getDataType == DataType.ERROR)
{
return(null);
}
else
{
texto = texto + (element.Value.ToString()) + " ";
}
}
if (this.isln)
{
texto = texto + "\n";
}
ConsolaController.Instance.Add(texto);
return(0);
}
public override object Execute(Ambit ambit)
{
var newAmbit = new Ambit(ambit, ambit.Ambit_name, ambit.Ambit_name_inmediato, false);
if (isNull)
{
return(0);
}
foreach (var inst in this.list)
{
try
{
//EJECUTA LAS INSTRUCCIONES
var element = inst.Execute(newAmbit);
if (element == null)
{
return(null);
}
if (element is Instruction)
{
return(element);
}
}
catch (Exception ex)
{
return(null);
}
}
return(0);
}
public override object Execute(Ambit ambit)
{
var generator = C3D.C3DController.Instance;
var switch_string = generator.save_comment("Inicia CASE", cant_tabs, false);
//Condicion de switch
var conSwitch = condicion.Execute(ambit);
switch_string += conSwitch.Texto_anterior;
var switchAmbit = new Ambit(ambit, ambit.Ambit_name + "_Case", "Case", false, ambit.IsFunction);
switchAmbit.Break = generator.newLabel();
for (int i = 0; i < cases.Count; i++)
{
var @case = (Case)cases[i];
var condCase = @case.getCaseCondition(ambit);
//CONDICION
var condicion = new Relational(new Literal(conSwitch.Value.ToString(), GetDataType(conSwitch.getDataType), row, column, cant_tabs),
new Literal(condCase.Value.ToString(), GetDataType(condCase.getDataType), row, column, cant_tabs), "=", row, column, cant_tabs);
var cond = condicion.Execute(ambit);
switch_string += cond.Texto_anterior;
switch_string += generator.addLabel(condicion.TrueLabel, cant_tabs);
var resultado = @case.Execute(switchAmbit);
if (resultado == null)
{
return(null);
}
switch_string += resultado;
switch_string += generator.addLabel(condicion.FalseLabel, cant_tabs);
}
if (!else_case.IsNull)
{
var element = else_case.Execute(ambit);
if (element == null)
{
return(null);
}
switch_string += element;
}
switch_string += generator.addLabel(switchAmbit.Break, cant_tabs);
switch_string = generator.replace_temp(switchAmbit.Break, "LTEMP", switch_string);
switch_string += generator.save_comment("Fin CASE", cant_tabs, true);
return(switch_string);
}
public void graficarTSAmbit(Ambit ambit)
{
var res_graphi = "";
var ambito_name = "";
var ambito_name2 = ambit.Ambit_name.Replace("General_", "");
var graphi = "digraph G{\n";
graphi += "label = \"" + "Ambito Graficado: " + ambito_name2 + "\"\n";
graphi += "graph [pad=\"" + 0.5 + "\", nodesep=\"" + 0.5 + "\", ranksep=\"" + 2 + "\"]\nnode[shape = plain]\nrankdir = LR;\nBaz [label=<";
graphi += "\n<table border=\"" + 0 + "\" cellborder=\"" + 1 + "\" cellspacing=\"" + 0 + "\">";
graphi += "\n<tr>\n\t<td width='100'><i>Nombre</i></td>\n\t<td width='100'><i>Tipo</i></td>\n\t<td width='100'><i>Ambito</i></td>\n\t<td><i width='100'>Valor</i></td>\n\t<td><i width='100'>Tipo Objeto</i></td>\n</tr>\n";
while (ambit != null)
{
if (ambit.Variables.Count > 0)
{
foreach (var item in ambit.Variables)
{
Identifier id = (Identifier)item.Value;
ambito_name = ambit.Ambit_name.Replace("General_", "");
res_graphi = "\n<tr>\n\t<td height='25'>" + id.Id + "</td>\n\t<td height='25'>" + id.DataType + "</td>\n\t<td height='25'>" + ambito_name + "</td>\n\t<td height='25'>" + id.Value.ToString() + "</td>\n\t<td height='25'>" + id.Tipo_dato + "</td>\n</tr>" + res_graphi;
}
}
if (ambit.Functions.Count > 0)
{
var type = "void";
var isfunc = "Procedure";
foreach (var item in ambit.Functions)
{
type = "void";
isfunc = "Procedure";
Function func = (Function)item.Value;
if (!func.IsProcedure)
{
isfunc = "Function";
type = func.Tipe.ToString();
}
res_graphi = "<tr>\n<td height='25'>" + func.Id + "</td>\n<td height='25'>" + type + "</td>\n<td height='25'>" + ambit.Ambit_name + "</td>\n<td height='25'>" + func.Retorno.ToString() + "</td>\n<td height='25'>" + isfunc + "</td>\n</tr>" + res_graphi;
}
}
var temp = ambit.anterior;
ambit = temp;
}
graphi += res_graphi + "\n</table>>];\n" + "}";
print_image(this.path, "tabla_simbolos", ambito_name2, graphi);
}
public override object Execute(Ambit ambit)
{
Identifier buscar = new Identifier();
//BUSCA LA VARIABLE SI NO HA SIDO DECLARADA
if (!ambit.Ambit_name_inmediato.Equals("Function") && !ambit.Ambit_name_inmediato.Equals("Procedure"))
{
buscar = ambit.getVariable(id);
}
//SIGFINICA QUE ES UNA DECLARACION EN FUNCION
else
{
buscar = ambit.getVariableFunctionInAmbit(id);
}
if (buscar.IsNull)
{
try
{
Returned val = this.value.Execute(ambit);
//VERIFICA QUE NO HAYA ERROR
if (val.getDataType == DataType.ERROR)
{
return(null);
}
if (this.type == DataType.CONST)
{
ambit.save(this.id, val.Value, val.getDataType, true, true, "Constante");
return(val.Value);
}
else
{
if (val.getDataType == this.type)
{
ambit.save(this.id, val.Value, val.getDataType, false, isAssigned, "Variable");
return(val.Value);
}
else
{
set_error("El tipo " + val.getDataType + " no es asignable con " + this.type.ToString(), row, column);
return(null);
}
}
}
catch (Exception)
{
}
}
else
{
set_error("La variable '" + id + "' ya fue declarada", row, column);
return(null);
}
return(0);
}
public void saveFunc(Ambit ambit)
{
if (ambit.Anterior != null)
{
this.UniqId = ambit.Ambit_name + "_" + id;
}
ambit.saveFuncion(this.id, this);
}
public override object Execute(Ambit ambit)
{
//Condicion de switch
var conSwitch = condicion.Execute(ambit);
var numeroCaso = -1;
var switchAmbit = new Ambit(ambit, ambit.Ambit_name, "Case", false);
for (int i = 0; i < cases.Count; i++)
{
var condCase = ((Case)(cases[i])).getCaseCondition(ambit);
if (conSwitch.Value.ToString() == condCase.Value.ToString())
{
numeroCaso = i;
var element = (Case)cases[i];
var resultado = element.Execute(switchAmbit);
if (resultado == null)
{
return(null);
}
if (resultado is Instruction)
{
var inst = (Instruction)resultado;
if (inst.Name.Equals("Break") || inst.Name.Equals("Exit"))
{
return(resultado);
}
}
break;
}
}
if (numeroCaso == -1)
{
if (!else_case.IsNull)
{
var element = else_case.Execute(ambit);
if (element == null)
{
return(null);
}
return(element);
}
}
return(0);
}
public override Returned Execute(Ambit ambit)
{
var result = new Returned();
var operacion = GetOpLogical(this.type);
if (operacion != OpLogical.NOT)
{
var varIz = this.left.Execute(ambit);
var valDer = right.Execute(ambit);
if (varIz.Value is bool && valDer.Value is bool)
{
var izq = (bool)(varIz.Value);
switch (operacion)
{
case OpLogical.AND:
var der = (bool)(valDer.Value);
result = new Returned((izq && der), DataType.BOOLEAN);
break;
case OpLogical.OR:
var valDere = right.Execute(ambit);
var dere = (bool)(valDere.Value);
result = new Returned((izq || dere), DataType.BOOLEAN);
break;
default:
break;
}
}
else
{
set_error("Operador '" + this.type + "' NO puede ser aplicado a los tipos " + varIz.getDataType + " con " + valDer.getDataType, 0, 0);
return(new Returned());
}
}
else
{
var varIz = this.left.Execute(ambit);
if (varIz.Value is bool)
{
var izq = (bool)(varIz.Value);
result = new Returned(!(izq), DataType.BOOLEAN);
}
else
{
set_error("Operador '" + this.type + "' NO puede ser aplicado al tipo " + varIz.getDataType, 0, 0);
return(new Returned());
}
}
return(result);
}
//METODO PARA SINTETIZAR VALORES
public void sintetizar_referencia(Ambit ambit, Function funcion_llamada)
{
if (funcion_llamada.Parametros_referencia.Count > 0)
{
foreach (SimboloReferencia simbolo in funcion_llamada.Parametros_referencia)
{
var variable = ambit.getVariableFunctionInAmbit(simbolo.Actual);
ambit.setVariableInAmbit(simbolo.Padre, variable.Value, variable.DataType, false, "Variable");
}
funcion_llamada.Parametros_referencia.Clear();
}
}
public override object Execute(Ambit ambit)
{
var while_string = "";
var generator = C3D.C3DController.Instance;
var whileAmbit = new Ambit(ambit, ambit.Ambit_name, "While", false, ambit.IsFunction);
var label_recurrencia = generator.newLabel();
while_string += generator.save_comment("Inicia While", cant_tabs, false);
while_string += generator.addLabel(label_recurrencia, cant_tabs);
//CONDICION
var cond = condition.Execute(whileAmbit);
while_string += cond.Texto_anterior;
if (cond.getDataType != DataType.BOOLEAN)
{
set_error("La condicion del While no es booleana", row, column);
return(null);
}
whileAmbit.Break = cond.FalseLabel;
whileAmbit.Continue = label_recurrencia;
//TAG VERDADERA
while_string += generator.addLabel(cond.TrueLabel, cant_tabs);
//EJECUTA SENTENCIAS
var result = this.sentences.Execute(whileAmbit);
if (result == null)
{
return(null);
}
while_string += result;
while_string += generator.add_Goto(label_recurrencia, cant_tabs + 1);
while_string += generator.addLabel(cond.FalseLabel, cant_tabs);
while_string += generator.save_comment("Fin while", cant_tabs, true);
return(while_string);
}
public override object Execute(Ambit ambit)
{
try
{
var val = this.value.Execute(ambit);
if (val == null || val.getDataType == DataType.ERROR)
{
return(null);
}
Identifier variable = ambit.getVariable(id);
/**
* VALIDAR EXISTENCIA
*/
if (!variable.IsNull)
{
/**
* VERIFICA QUE NO SEA CONSTABTE
*/
if (variable.Esconstante)
{
setError("No se puede cambiar el valor a una constante", row, column);
return(null);
}
else
{
/**
* VALIDAR VALOR: VERIFICA SI EL TIPO DE LA VARIABLE ES IGUAL AL DEL VALOR A ASIGNAR
*/
if (variable.DataType == val.getDataType)
{
ambit.setVariable(id, val.Value, val.getDataType, false, "Variable");
return(variable.Value);
}
else
{
setError("El tipo " + val.getDataType + " no es asignable con " + variable.DataType, row, column);
return(null);
}
}
}
else
{
Function function = ambit.getFuncion(id);
if (function != null)
{
if (function.IsProcedure)
{
setError("No puede asignarse ningun valor al procedimiento '" + id + "' ", row, column);
return(null);
}
/**
* VALIDAR VALOR: VERIFICA SI EL TIPO DE LA VARIABLE ES IGUAL AL DEL VALOR A ASIGNAR
*/
if (function.Tipe == val.getDataType)
{
function.Retorno = val.Value.ToString();
ambit.setFunction(Id, function);
return(new Returned(function.Retorno, function.Tipe));
}
else
{
setError("El tipo " + val.getDataType + " no es asignable con " + variable.DataType, row, column);
return(null);
}
}
else
{
setError("La variable '" + id + "' no esta declara", row, column);
return(null);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
ConsolaController.Instance.Add("Recuperado de error, Row:" + row + " Col: " + column);
return(null);
}
}
public override object Execute(Ambit ambit)
{
var repeatAmbit = new Ambit(ambit, ambit.Ambit_name, "Repeat", false);
//CONDICION
var condicion = condition.Execute(repeatAmbit);
//VERIFICA QUE SEA BOOL
if (condicion.getDataType != DataType.BOOLEAN)
{
set_error("La condicion del repeat no es booleana", row, column);
return(null);
}
if (!sentences.IsNull)
{
do
{
var element = sentences.Execute(repeatAmbit);
////VERIFICA QUE NO HAYA ERROR
if (element == null)
{
return(null);
}
//VUELVE A EVALUAR LA CONDICION
condicion = this.condition.Execute(repeatAmbit);
if (condicion.getDataType != DataType.BOOLEAN)
{
set_error("La condicion del repeat no es booleana", row, column);
return(null);
}
//EVALUA LO QUE VIENE
if (element is Instruction)
{
Instruction inst = (Instruction)element;
if (inst.Name.Equals("Break"))
{
break;
}
else if (inst.Name.Equals("Continue"))
{
continue;
}
else if (inst.Name.Equals("Exit"))
{
return(element);
}
}
} while ((bool)condicion.Value == false);
}
else
{
return(0);
}
return(0);
}
public override object Execute(Ambit ambit)
{
try
{
var val = this.value.Execute(ambit);
if (val == null || val.getDataType == DataType.ERROR)
{
return(null);
}
//VERIFICO LA EXISTENCIA
Arrays arr = ambit.getArray(id);
if (arr != null)
{
if (arr.DataType == val.getDataType)
{
var ind = index.Execute(ambit);
var limiteinf = arr.Inf.Execute(ambit);
var larraysup = arr.Sup.Execute(ambit);
var inferior = int.Parse(limiteinf.Value.ToString());
var superior = int.Parse(larraysup.Value.ToString());
var indice = int.Parse(ind.Value.ToString());
if (indice < inferior || indice > superior)
{
setError("Indice fuera de rango al acceder al arreglo '" + this.id + "'", row, column);
return(null);
}
try
{
switch (arr.DataType)
{
case DataType.INTEGER:
arr.Elementos[indice] = int.Parse(val.Value.ToString());
break;
case DataType.STRING:
arr.Elementos[indice] = val.Value.ToString();
break;
case DataType.BOOLEAN:
arr.Elementos[indice] = (bool)val.Value;
break;
case DataType.REAL:
arr.Elementos[indice] = double.Parse(val.Value.ToString());
break;
default:
break;
}
}
catch (Exception e)
{
ConsolaController.Instance.Add(e.Message + "\n");
}
ambit.setArray(id, arr);
return(val.Value);
}
else
{
setError("El tipo " + val.getDataType + " no es asignable con " + arr.DataType, row, column);
return(null);
}
}
else
{
setError("El arreglo '" + id + "' no esta declaro", row, column);
return(null);
}
}
catch (Exception)
{
return(null);
}
}
public override object Execute(Ambit ambit)
{
var whileAmbit = new Ambit(ambit, ambit.Ambit_name, "While", false);
//CONDICION
var cond = condition.Execute(whileAmbit);
if (cond.getDataType != DataType.BOOLEAN)
{
set_error("La condicion del While no es booleana", row, column);
return(null);
}
while ((bool)cond.Value == true)
{
//VERIFICA QUE LA SENTENCIA NO ESTE VACIA
if (!sentences.IsNull)
{
//EJECUTA LA SENTENCIA
var element = sentences.Execute(whileAmbit);
//VERIFICA QUE NO HAYA ERROR
if (element == null)
{
return(null);
}
//VUELVE A EVALUAR LA CONDICION
cond = condition.Execute(whileAmbit);
if (cond.getDataType != DataType.BOOLEAN)
{
set_error("La condicion del While no es booleana", row, column);
return(null);
}
if (element is Instruction)
{
Instruction ins = (Instruction)element;
//console.log(element);
if (ins.Name.Equals("Break"))
{
break;
}
else if (ins.Name.Equals("Continue"))
{
continue;
}
else if (ins.Name.Equals("Exit"))
{
return(element);
}
}
}
else
{
break;
}
}
return(0);
}
public override Returned Execute(Ambit ambit)
{
var logical_str = "";
var result = new Returned();
var operacion = GetOpLogical(this.type);
//INSTANCIA DEL GENERADOR C3D
var generator = C3DController.Instance;
if (this.TrueLabel == "")
{
this.TrueLabel = generator.newLabel();
}
if (this.FalseLabel == "")
{
this.FalseLabel = generator.newLabel();
}
logical_str += generator.save_comment("Empieza " + operacion, cant_tabs, false);
switch (operacion)
{
case OpLogical.AND:
this.left.TrueLabel = this.TrueLabel;
this.left.FalseLabel = this.FalseLabel;
//EXPRESIONES
var varIz = this.left.Execute(ambit);
logical_str += varIz.Texto_anterior;
if (varIz.getDataType == DataType.BOOLEAN)
{
logical_str += generator.addLabel(varIz.TrueLabel, cant_tabs);
this.right.TrueLabel = generator.newLabel();
this.right.FalseLabel = varIz.FalseLabel;
var valDer = right.Execute(ambit);
logical_str += valDer.Texto_anterior;
if (valDer.getDataType != DataType.BOOLEAN)
{
set_error("Operador '" + this.type + "' NO puede ser aplicado alos tipos " + varIz.getDataType + " con " + valDer.getDataType, row, column);
return(result);
}
logical_str += generator.save_comment("Termina " + operacion, cant_tabs, true);
return(new Returned("", DataType.BOOLEAN, false, valDer.TrueLabel, valDer.FalseLabel, logical_str, "false", 0, 0));
}
set_error("Operador '" + this.type + "' NO puede ser aplicado al tipo " + varIz.getDataType, row, column);
return(result);
case OpLogical.OR:
this.left.TrueLabel = this.TrueLabel;
this.left.FalseLabel = this.FalseLabel;
//EXPRESIONES
var valIz = this.left.Execute(ambit);
logical_str += valIz.Texto_anterior;
if (valIz.getDataType == DataType.BOOLEAN)
{
logical_str += generator.addLabel(valIz.FalseLabel, cant_tabs);
this.right.TrueLabel = valIz.TrueLabel;
this.right.FalseLabel = generator.newLabel();
var valDer = right.Execute(ambit);
logical_str += valDer.Texto_anterior;
if (valDer.getDataType != DataType.BOOLEAN)
{
set_error("Operador '" + this.type + "' NO puede ser aplicado alos tipos " + valIz.getDataType + " con " + valDer.getDataType, row, column);
return(result);
}
logical_str += generator.save_comment("Termina " + operacion, cant_tabs, true);
return(new Returned("", DataType.BOOLEAN, false, valDer.TrueLabel, valDer.FalseLabel, logical_str, "false", 0, 0));
}
set_error("Operador '" + this.type + "' NO puede ser aplicado al tipo " + valIz.getDataType, row, column);
return(result);
case OpLogical.NOT:
this.left.TrueLabel = this.FalseLabel;
this.left.FalseLabel = this.TrueLabel;
//EXPRESIONES
var varrIz = this.left.Execute(ambit);
logical_str += varrIz.Texto_anterior;
if (varrIz.getDataType != DataType.BOOLEAN)
{
set_error("Operador '" + this.type + "' NO puede ser aplicado al tipo " + varrIz.getDataType, row, column);
return(result);
}
logical_str += generator.save_comment("Termina " + operacion, cant_tabs, true);
return(new Returned("", DataType.BOOLEAN, false, varrIz.FalseLabel, varrIz.TrueLabel, logical_str, "false", 0, 0));
default:
break;
}
return(result);
}
public Returned getCaseCondition(Ambit ambit)
{
return(this.condition.Execute(ambit));
}
public override object Execute(Ambit ambit)
{
var generator = C3D.C3DController.Instance;
if (!this.isProcedure)
{
generator.update_posision_global();
}
var funcion_total = generator.save_code("void " + uniqId + "(" + ") { \n", 0);
var tempo_return = "";
var exit_label = "";
var size = 0;
if (!IsProcedure)
{
tempo_return = "T13";
exit_label = generator.newLabel();
funcion_total += generator.save_code("//Temporal de retorno", 1);
funcion_total += generator.addExpression(tempo_return, "SP", "0", "+", 1);
size = 1;
}
//AMBITO DE LA FUNCION
Ambit ambit_func = new Ambit(ambit, this.uniqId, tipo, tempo_return, exit_label, !isProcedure, this.tipe, size);
foreach (Declaration dec in parametos)
{
ambit_func.saveVarFunction(dec.Id, "0", "0", dec.Type, dec.isRefer, "Parameter", 0);
}
funcion_total += generator.save_comment("Inicia Declaracion de variables", 1, false);
//DECLARACIONES
foreach (var declas in declaraciones)
{
var result = declas.Execute(ambit_func);
if (result == null)
{
return(null);
}
funcion_total += result;
}
funcion_total += generator.save_comment("Fin Declaracion de variables", 1, false);
//FUNCIONES HIJAS
foreach (Function fun_hija in funciones_hijas)
{
fun_hija.saveFunc(ambit_func);
}
var funcion_hija = "";
foreach (Function fun_hija in funciones_hijas)
{
fun_hija.Variables_padres = this.declaraciones;
var result = fun_hija.Execute(ambit_func);
if (result == null)
{
return(null);
}
funcion_hija += result;
}
//INSTRUCCIONES
foreach (Instruction instruction in sentences)
{
var instruccion = instruction.Execute(ambit_func);
if (instruccion == null)
{
return(null);
}
funcion_total += instruccion;
}
if (!isProcedure)
{
funcion_total += generator.addLabel(exit_label, 1);
}
funcion_total += generator.save_code(" return;\n", 2);
funcion_total += generator.save_code("}\n", 0);
ReporteController.Instance.save_ambit(ambit_func, ambit_func.Ambit_name);
return(funcion_hija + funcion_total);
}
public override Returned Execute(Ambit ambit)
{
var relational_Str = "";
var valIz = this.left.Execute(ambit);
relational_Str += valIz.Texto_anterior;
var result = new Returned();
var generator = C3DController.Instance;
var op = GetType(this.type);
switch (op)
{
case OpRelational.EQUALS:
relational_Str += generator.save_comment("Empieza EQUALS", cant_tabs, false);
//VERIFICA SI EL IZQUIERDO ES REAL O INT
if (valIz.getDataType == DataType.REAL || valIz.getDataType == DataType.INTEGER)
{
var valDer = this.right.Execute(ambit);
relational_Str += valDer.Texto_anterior;
if (valDer.getDataType == DataType.INTEGER || valDer.getDataType == DataType.REAL)
{
if (this.TrueLabel == "")
{
this.TrueLabel = generator.newLabel();
}
if (this.FalseLabel == "")
{
this.FalseLabel = generator.newLabel();
}
ambit.free_temp(valIz.getValue());
ambit.free_temp(valDer.getValue());
relational_Str += generator.add_If(valIz.getValue(), valDer.getValue(), "==", this.TrueLabel, cant_tabs);
relational_Str += generator.add_Goto(this.FalseLabel, cant_tabs);
relational_Str += generator.save_comment("Termina EQUALS", cant_tabs, true);
result = new Returned("", DataType.BOOLEAN, false, this.TrueLabel, this.FalseLabel, relational_Str, "", 0, 0);
}
else
{
set_error("Operador '" + this.type + "' NO puede ser aplicado a los tipos " + valIz.getDataType + " con " + valDer.getDataType, row, column);
return(result);
}
}
//VERIFICA SI EL IZQUIERDO ES BOOLEAN
else if (valIz.getDataType == DataType.BOOLEAN)
{
var trueLabel = generator.newLabel();
var falseLabel = generator.newLabel();
relational_Str += generator.addLabel(valIz.TrueLabel, cant_tabs);
this.right.TrueLabel = trueLabel;
this.right.FalseLabel = falseLabel;
var valDer = this.right.Execute(ambit);
relational_Str += valDer.Texto_anterior;
relational_Str += generator.addLabel(valIz.FalseLabel, cant_tabs);
this.right.TrueLabel = falseLabel;
this.right.FalseLabel = trueLabel;
valDer = this.right.Execute(ambit);
relational_Str += valDer.Texto_anterior;
//VERIFICA QUE EL DERECHO SEA BOOLEAN
if (valDer.getDataType == DataType.BOOLEAN)
{
relational_Str += generator.save_comment("Termina EQUALS", cant_tabs, true);
ambit.free_temp(valIz.getValue());
ambit.free_temp(valDer.getValue());
result = new Returned("", DataType.BOOLEAN, false, trueLabel, falseLabel, relational_Str, "", 0, 0);
}
else
{
set_error("Operador '" + this.type + "' NO puede ser aplicado a los tipos " + valIz.getDataType + " con " + valDer.getDataType, row, column);
return(result);
}
}
////VERIFICA QUE EL IZQUIERDO SEA STRING
else if (valIz.getDataType == DataType.STRING)
{
generator.Native_equals = true;
var valDer = this.right.Execute(ambit);
relational_Str += valDer.Texto_anterior;
if (valDer.getDataType == DataType.STRING)
{
if (this.TrueLabel == "")
{
this.TrueLabel = generator.newLabel();
}
if (this.FalseLabel == "")
{
this.FalseLabel = generator.newLabel();
}
var tempo_izq = valIz.Value.ToString();
var tempo_der = valDer.Value.ToString();
relational_Str += generator.addExpression("T3", tempo_izq, "", "", cant_tabs);
relational_Str += generator.addExpression("T4", tempo_der, "", "", cant_tabs);
relational_Str += generator.addExpression("T8", "native_cmp_str()", "", "", cant_tabs);
relational_Str += generator.add_If("T8", "1", "==", this.TrueLabel, cant_tabs);
relational_Str += generator.add_Goto(this.FalseLabel, cant_tabs);
ambit.free_temp(tempo_der);
ambit.free_temp(tempo_izq);
relational_Str += generator.save_comment("Termina EQUALS", cant_tabs, true);
result = new Returned("", DataType.BOOLEAN, false, this.TrueLabel, this.FalseLabel, relational_Str, "", 0, 0);
}
else
{
set_error("Operador '" + this.type + "' NO puede ser aplicado a los tipos " + valIz.getDataType + " con " + valDer.getDataType, row, column);
return(result);
}
}
else
{
set_error("Operador '" + this.type + "' NO puede ser aplicado al tipo " + valIz.getDataType, row, column);
return(result);
}
break;
case OpRelational.DISCTINCT:
relational_Str += generator.save_comment("Empieza DISTICT", cant_tabs, false);
//VERIFICA QUE EL IZQUIERDO ESA REAL O INTEGER
if (valIz.getDataType == DataType.REAL || valIz.getDataType == DataType.INTEGER)
{
var valDer = this.right.Execute(ambit);
relational_Str += valDer.Texto_anterior;
if (valDer.getDataType == DataType.INTEGER || valDer.getDataType == DataType.REAL)
{
if (this.TrueLabel == "")
{
this.TrueLabel = generator.newLabel();
}
if (this.FalseLabel == "")
{
this.FalseLabel = generator.newLabel();
}
ambit.free_temp(valIz.getValue());
ambit.free_temp(valDer.getValue());
relational_Str += generator.add_If(valIz.getValue(), valDer.getValue(), "!=", this.TrueLabel, cant_tabs);
relational_Str += generator.add_Goto(this.FalseLabel, cant_tabs);
relational_Str += generator.save_comment("Termina DISTICT", cant_tabs, true);
result = new Returned("", DataType.BOOLEAN, false, this.TrueLabel, this.FalseLabel, relational_Str, "", 0, 0);
}
else
{
set_error("Operador '" + this.type + "' NO puede ser aplicado a los tipos " + valIz.getDataType + " con " + valDer.getDataType, row, column);
return(result);
}
}
else if (valIz.getDataType == DataType.BOOLEAN)
{
var trueLabel = generator.newLabel();
var falseLabel = generator.newLabel();
relational_Str += generator.addLabel(valIz.TrueLabel, cant_tabs);
this.right.TrueLabel = falseLabel;
this.right.FalseLabel = trueLabel;
var valDer = this.right.Execute(ambit);
relational_Str += valDer.Texto_anterior;
relational_Str += generator.addLabel(valIz.FalseLabel, cant_tabs);
this.right.TrueLabel = trueLabel;
this.right.FalseLabel = falseLabel;
valDer = this.right.Execute(ambit);
relational_Str += valDer.Texto_anterior;
//VERIFICA QUE EL DERECHO SEA BOOLEAN
if (valDer.getDataType == DataType.BOOLEAN)
{
ambit.free_temp(valIz.getValue());
ambit.free_temp(valDer.getValue());
relational_Str += generator.save_comment("Termina DISTICT", cant_tabs, true);
result = new Returned("", DataType.BOOLEAN, false, trueLabel, falseLabel, relational_Str, "", 0, 0);
}
else
{
set_error("Operador '" + this.type + "' NO puede ser aplicado a los tipos " + valIz.getDataType + " con " + valDer.getDataType, row, column);
return(result);
}
}
else
{
set_error("Operador '" + this.type + "' NO puede ser aplicado al tipo " + valIz.getDataType, row, column);
return(result);
}
break;
case OpRelational.LESS:
case OpRelational.LESS_EQUALS:
case OpRelational.HIGHER:
case OpRelational.HIGHER_EQUALS:
relational_Str += generator.save_comment("Empieza " + op, cant_tabs, false);
if (valIz.getDataType == DataType.REAL || valIz.getDataType == DataType.INTEGER)
{
var valDer = this.right.Execute(ambit);
relational_Str += valDer.Texto_anterior;
if (valDer.getDataType == DataType.REAL || valDer.getDataType == DataType.INTEGER)
{
if (this.TrueLabel == "")
{
this.TrueLabel = generator.newLabel();
}
if (this.FalseLabel == "")
{
this.FalseLabel = generator.newLabel();
}
ambit.free_temp(valIz.getValue());
ambit.free_temp(valDer.getValue());
relational_Str += generator.add_If(valIz.getValue(), valDer.getValue(), this.type, this.TrueLabel, cant_tabs);
relational_Str += generator.add_Goto(this.FalseLabel, cant_tabs);
relational_Str += generator.save_comment("Termina " + op, cant_tabs, true);
result = new Returned("", DataType.BOOLEAN, false, this.TrueLabel, this.FalseLabel, relational_Str, "", 0, 0);
}
else
{
set_error("Operador '" + this.type + "' NO puede ser aplicado a los tipos " + valIz.getDataType + " con " + valDer.getDataType, row, column);
return(result);
}
}
else
{
set_error("Operador '" + this.type + "' NO puede ser aplicado al tipo " + valIz.getDataType, row, column);
return(result);
}
break;
default:
return(result);
}
return(result);
}
public override Returned Execute(Ambit ambit)
{
var varIz = new Returned();
var valDer = new Returned();
var arithmetic_string = "";
var texto_original = "";
if ((this.left is CallFunction) && !(this.right is CallFunction))
{
varIz = this.left.Execute(ambit);
valDer = this.right.Execute(ambit);
arithmetic_string = varIz.Texto_anterior + valDer.Texto_anterior;
texto_original = varIz.Valor_original + type + valDer.Valor_original;
}
else if (!(this.left is CallFunction) && (this.right is CallFunction))
{
valDer = this.right.Execute(ambit);
varIz = this.left.Execute(ambit);
arithmetic_string = valDer.Texto_anterior + varIz.Texto_anterior;
texto_original = varIz.Valor_original + type + valDer.Valor_original;
}
else
{
varIz = this.left.Execute(ambit);
valDer = this.right.Execute(ambit);
arithmetic_string = varIz.Texto_anterior + valDer.Texto_anterior;
texto_original = varIz.Valor_original + type + valDer.Valor_original;
}
var generator = C3DController.Instance;
if (varIz.getDataType == DataType.INTEGER || varIz.getDataType == DataType.REAL)
{
if (valDer.getDataType == DataType.INTEGER || valDer.getDataType == DataType.REAL)
{
var temp = generator.newTemporal();
arithmetic_string += generator.addExpression(temp, varIz.getValue(), valDer.getValue(), type, cant_tabs);
if (valDer.getDataType == DataType.REAL || varIz.getDataType == DataType.REAL)
{
return(new Returned(temp, DataType.REAL, true, "", "", arithmetic_string, texto_original, 0, 0));
}
return(new Returned(temp, DataType.INTEGER, true, "", "", arithmetic_string, texto_original, 0, 0));
}
set_error("Operador '" + this.type + "' NO puede ser aplicado a los tipos " + varIz.getDataType + " con " + valDer.getDataType, row, column);
return(new Returned());
}
else if (varIz.getDataType == DataType.STRING && valDer.getDataType == DataType.STRING)
{
arithmetic_string += generator.addExpression("T9", varIz.getValue(), "", "", cant_tabs);
arithmetic_string += generator.addExpression("T10", valDer.getValue(), "", "", cant_tabs);
arithmetic_string += generator.save_code("native_concat_str();", cant_tabs);
return(new Returned("T12", DataType.STRING, true, "", "", arithmetic_string, texto_original, 0, 0));
}
set_error("Operador '" + this.type + "' NO puede ser aplicado a los tipos " + varIz.getDataType + " con " + valDer.getDataType, row, column);
return(new Returned());
}
public override Returned Execute(Ambit ambit)
{
{
var funcion_llamada = ambit.getFuncion(this.id);
if (funcion_llamada == null)
{
set_error("La funcion '" + this.id + "' no esta definido", row, column);
return(new Returned());
}
if (funcion_llamada.Parametos.Count != parametros.Count)
{
set_error("La funcion '" + this.id + "' no recibe la misma cantidad de parametros", row, column);
return(new Returned());
}
//GUARDAR LOS PARAMETROS EN LA TABLA DE SIMBOLOS
Ambit function_ambit = new Ambit();
if (funcion_llamada.IsProcedure)
{
set_error("El procedimiento'" + this.id + "' no puede asignarse como valor de retorno", row, column);
return(new Returned());
}
else
{
function_ambit = new Ambit(ambit, "Function_" + funcion_llamada.Id, "Function", false);
}
//FOREACH PARA GUARDAR LOS PARAMETROS EN EL AMBITO,
//LOS PARAMETROS QUE RECIBE LA FUNCION CUANDO SE DECLARA SON 'DECLARACIONES'
//POR TANTO AL HACER EL EXECUTE LA VARIABLE SE GUARDA EN EL AMBITO QUE SE ENVIA
foreach (var param in funcion_llamada.Parametos)
{
param.Execute(function_ambit);
}
//SE ASIGNAN LOS VALORES RECIBIDOS A LOS PARAMETROS DE LA FUNCION
for (int i = 0; i < parametros.Count; i++)
{
var variable = (Declaration)(funcion_llamada.getParameterAt(i));
if (variable.Referencia)
{
if (parametros[i] is Access)
{
Access acceso = (Access)parametros[i];
funcion_llamada.Parametros_referencia.Add(new SimboloReferencia(variable.Id, acceso.Id));
}
else if (parametros[i] is Access_array)
{
}
}
var result = ((Expression)parametros[i]).Execute(ambit);
if (variable.getDataType == result.getDataType)
{
function_ambit.setVariableFuncion(variable.Id, result.Value, result.getDataType, false, "Parametro");
}
else
{
set_error("El tipo " + result.getDataType + " no es asignable con " + variable.getDataType, row, column);
return(new Returned());
}
}
//GUARDA LAS VARIABLES QUE ESTEN DECLARADAS EN LA FUNCION
if (funcion_llamada.Declaraciones.Count > 0)
{
foreach (var declaracion in funcion_llamada.Declaraciones)
{
declaracion.Execute(function_ambit);
}
}
//EJECUCION DEL CODIGO
var funcion_Elementos = funcion_llamada.Sentences.Execute(function_ambit);
//si viene null significa que viene error
if (funcion_Elementos == null)
{
return(new Returned());
}
else
{
if (funcion_llamada.IsProcedure)
{
if (funcion_Elementos is Instruction)
{
var inst = (Instruction)funcion_Elementos;
if (inst.Name.Equals("Exit"))
{
Exit ex = (Exit)funcion_Elementos;
set_error("Los procediminetos no pueden retornar ningun valor", ex.Row, ex.Column);
return(new Returned());
}
}
if (funcion_Elementos is Break)
{
var r = (Break)funcion_Elementos;
set_error("La sentencia Break solo puede aparece en ciclos o en la sentencia CASE", r.Row, r.Column);
}
else if (funcion_Elementos is Continue)
{
var r = (Continue)funcion_Elementos;
set_error("La sentencia Continue solo puede aparece en ciclos", r.Row, r.Column);
}
}
else
{
if (funcion_Elementos is Instruction)
{
var inst = (Instruction)funcion_Elementos;
if (inst.Name.Equals("Exit"))
{
var response = ((Exit)funcion_Elementos);
if (response.Return_func_return)
{
GraphController.Instance.getAmbitoGraficar(function_ambit, false);
//SINTETIZA LOS PARAMETROS POR REFERENCIA
sintetizar_referencia(function_ambit, funcion_llamada);
switch (funcion_llamada.Tipe)
{
case DataType.INTEGER:
return(new Returned(int.Parse(funcion_llamada.Retorno), funcion_llamada.Tipe));
case DataType.STRING:
return(new Returned((funcion_llamada.Retorno), funcion_llamada.Tipe));
case DataType.BOOLEAN:
return(new Returned(bool.Parse(funcion_llamada.Retorno), funcion_llamada.Tipe));
case DataType.REAL:
return(new Returned(double.Parse(funcion_llamada.Retorno), funcion_llamada.Tipe));
}
}
else
{
var ext = (Exit)funcion_Elementos;
var result = (ext).Value.Execute(function_ambit);
//HAY ERROR
if (result.getDataType == DataType.ERROR || result == null)
{
return(new Returned());
}
//VERIFICA QUE EL TIPO DE RETORNO SEA VALIDO
if (result.getDataType == funcion_llamada.Tipe)
{
//SINTETIZA LOS PARAMETROS POR REFERENCIA
sintetizar_referencia(function_ambit, funcion_llamada);
GraphController.Instance.getAmbitoGraficar(function_ambit, false);
switch (funcion_llamada.Tipe)
{
case DataType.INTEGER:
return(new Returned((int)result.Value, result.getDataType));
case DataType.STRING:
return(new Returned((string)result.Value, result.getDataType));
case DataType.BOOLEAN:
return(new Returned((bool)result.Value, result.getDataType));
case DataType.REAL:
return(new Returned((double)result.Value, result.getDataType));
}
}
else
{
set_error("Tipos incompatibles, la funcion '" + funcion_llamada.Id + "' retorna " + funcion_llamada.Tipe + " en lugar de" + result.getDataType, ext.Row, ext.Column);
return(new Returned());
}
}
}
}
else if (funcion_Elementos is Returned)
{
//SINTETIZA LOS PARAMETROS POR REFERENCIA
sintetizar_referencia(function_ambit, funcion_llamada);
GraphController.Instance.getAmbitoGraficar(function_ambit, false);
return((Returned)funcion_Elementos);
}
else
{
//SINTETIZA LOS PARAMETROS POR REFERENCIA
sintetizar_referencia(function_ambit, funcion_llamada);
GraphController.Instance.getAmbitoGraficar(function_ambit, false);
switch (funcion_llamada.Tipe)
{
case DataType.INTEGER:
return(new Returned(int.Parse(funcion_llamada.Retorno), funcion_llamada.Tipe));
case DataType.STRING:
return(new Returned((funcion_llamada.Retorno), funcion_llamada.Tipe));
case DataType.BOOLEAN:
return(new Returned(bool.Parse(funcion_llamada.Retorno), funcion_llamada.Tipe));
case DataType.REAL:
return(new Returned(double.Parse(funcion_llamada.Retorno), funcion_llamada.Tipe));
}
}
}
}
return(new Returned());
}
}
public override object Execute(Ambit ambit)
{
//INSTANCIA GENERADOR C3D
var generator = C3DController.Instance;
var label_print = "";
var write_Str = "";
write_Str += generator.save_comment("Inicia Print PRINTTEMP", cant_tabs, false);
//FOREACH DE LAS EXPRESIONES A HACER PRINT
foreach (Expresion el in value)
{
if (el is Literal)
{
if (((Literal)el).Type == 3)
{
var res = ((Literal)el).Value.ToString();
write_Str += generator.print_boolean(cant_tabs, res);
continue;
}
if (((Literal)el).Type == 2)
{
var res = ((Literal)el).Value.ToString();
if (res.ToLower().Equals("true") || res.ToLower().Equals("false"))
{
write_Str += generator.print_boolean(cant_tabs, res);
continue;
}
}
}
if (el is Access)
{
label_print = ":" + ((Access)el).Id;
}
var element = el.Execute(ambit);
if (element.IsTemporal)
{
ambit.free_temp(element.getValue());
}
write_Str += element.Texto_anterior;
if (element.getDataType == DataType.ERROR)
{
return(null);
}
switch (element.getDataType)
{
case DataType.INTEGER:
write_Str += generator.generate_print("i", element.getValue(), "(int)", cant_tabs);
break;
case DataType.STRING:
generator.Native_str = true;
var temp_stack = element.getValue();
write_Str += generator.addExpression("T1", temp_stack, "", "", cant_tabs);
write_Str += generator.save_code("native_print_str();", cant_tabs);
/*var label_temp = generator.newLabel();
* generator.addLabel(label_temp, cant_tabs);
* var temp_heap = generator.newTemporal();
*
* generator.get_Heap(temp_heap, temp_stack, cant_tabs);
*
* var true_label = generator.newLabel();
*
* generator.add_If(temp_heap, "-1", "==", true_label, cant_tabs);
*
* generator.generate_print("c", temp_heap, "(int)", cant_tabs);
*
* generator.addExpression(temp_stack, temp_stack, "1", "+", cant_tabs);
*
* generator.add_Goto(label_temp, cant_tabs);
* generator.addLabel(true_label, cant_tabs);*/
break;
case DataType.BOOLEAN:
write_Str += generator.addLabel(element.TrueLabel, cant_tabs);
write_Str += generator.addLabel(element.FalseLabel, cant_tabs);
write_Str += generator.print_boolean(cant_tabs, element.Valor_original);
break;
case DataType.REAL:
write_Str += generator.generate_print("f", element.getValue(), "(float)", cant_tabs);
break;
default:
break;
}
}
if (this.isln)
{
write_Str += generator.generate_print("c", "10", "(int)", cant_tabs);
}
write_Str += generator.save_comment("Fin Print PRINTTEMP", cant_tabs, true);
write_Str = generator.replace_temp(label_print, "PRINTTEMP", write_Str);
return(write_Str);
}
public override object Execute(Ambit ambit)
{
try
{
var val = this.value.Execute(ambit);
Identifier variableAmbit = ambit.getVariable(id);
var generator = C3DController.Instance;
/**
* VALIDAR EXISTENCIA
*/
if (!variableAmbit.IsNull)
{
/**
* VERIFICA QUE NO SEA CONSTABTE
*/
if (variableAmbit.Esconstante)
{
setError("No se puede cambiar el valor a una constante", row, column);
return(null);
}
else
{
assignation_string += val.Texto_anterior;
if (val == null || val.getDataType == DataType.ERROR)
{
return(null);
}
/**
* VALIDAR VALOR: VERIFICA SI EL TIPO DE LA VARIABLE ES IGUAL AL DEL VALOR A ASIGNAR
*/
if (variableAmbit.DataType == val.getDataType)
{
if (val.IsTemporal)
{
ambit.free_temp(val.Value);
}
if (variableAmbit.IsGlobal)
{
if (variableAmbit.DataType == DataType.BOOLEAN)
{
var templabel = generator.newLabel();
assignation_string += generator.addLabel(val.TrueLabel, tabs);
assignation_string += generator.set_stack(variableAmbit.Position.ToString(), "1", tabs);
assignation_string += generator.add_Goto(templabel, tabs + 1);
assignation_string += generator.addLabel(val.FalseLabel, tabs);
assignation_string += generator.set_stack(variableAmbit.Position.ToString(), "0", tabs);
assignation_string += generator.addLabel(templabel, tabs);
}
else
{
var tempAux = variableAmbit.Position_global.ToString();
if (variableAmbit.IsReference)
{
var temp = generator.newTemporal();
assignation_string += generator.get_stack(temp, variableAmbit.Position_global.ToString(), tabs);
generator.freeTemp(temp);
tempAux = temp;
}
assignation_string += generator.set_stack(tempAux, val.getValue(), tabs);
}
}
else
{
var temp = generator.newTemporal();
ambit.set_temp(temp);
assignation_string += generator.addExpression(temp, "SP", variableAmbit.Position.ToString(), "+", tabs);
if (variableAmbit.IsReference)
{
var newTemp = generator.newTemporal();
ambit.set_temp(newTemp);
ambit.free_temp(temp);
generator.freeTemp(temp);
assignation_string += generator.get_stack(newTemp, temp, tabs);
temp = newTemp;
}
if (variableAmbit.DataType == DataType.BOOLEAN)
{
generator.freeTemp(temp);
var templabel = generator.newLabel();
assignation_string += generator.addLabel(val.TrueLabel, tabs);
assignation_string += generator.set_stack(temp, "1", tabs);
assignation_string += generator.add_Goto(templabel, tabs + 1);
assignation_string += generator.addLabel(val.FalseLabel, tabs);
assignation_string += generator.set_stack(temp, "0", tabs);
assignation_string += generator.addLabel(templabel, tabs);
}
else
{
generator.freeTemp(temp);
assignation_string += generator.set_stack(temp, val.getValue(), tabs);
}
}
return(assignation_string);
}
else
{
setError("El tipo " + val.getDataType + " no es asignable con " + variableAmbit.DataType, row, column);
return(null);
}
}
}
else
{
Function function = ambit.getFuncion(id);
if (function != null)
{
if (function.IsProcedure)
{
setError("No puede asignarse ningun valor al procedimiento '" + id + "' ", row, column);
return(null);
}
/**
* VALIDAR VALOR: VERIFICA SI EL TIPO DE LA VARIABLE ES IGUAL AL DEL VALOR A ASIGNAR
*/
if (function.Tipe == val.getDataType)
{
function.Retorno = val.getValue();
ambit.setFunction(Id, function);
assignation_string += val.Texto_anterior;
assignation_string += generator.set_stack("T13", function.Retorno, tabs);
}
else
{
setError("El tipo " + val.getDataType + " no es asignable con " + function.Tipo, row, column);
return(null);
}
}
else
{
setError("La variable '" + id + "' no esta declara", row, column);
return(null);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
ConsolaController.Instance.Add("Recuperado de error, Row:" + row + " Col: " + column);
return(null);
}
return(assignation_string);
}
public override object Execute(Ambit ambit)
{
var forAmbit = new Ambit(ambit, ambit.Ambit_name, "For", false, ambit.IsFunction);
//SE HACE LA ASIGNACION INICIAL
Assignation assignation = new Assignation(initId, inicializacion, row, column, cant_tabs);
Identifier identifier = ambit.getVariable(initId);
var for_str = "";
//VERIFICA QUE EL IDENTIFICADOR EXISTA
if (!identifier.IsNull)
{
//VERIFICA QUE LA VARIABLE NO HAYA SIDO ASIGNADA EN LA DECLARACION
if (!identifier.IsAssiged)
{
var generator = C3D.C3DController.Instance;
var simb2 = (direccion.ToLower().Equals("to")) ? "+" : "-";
var simb = (direccion.ToLower().Equals("to")) ? ">" : "<";
for_str += generator.save_comment("Inicia For", cant_tabs, false);
//ETIQUETA DE RECURRENCIA
//var recurrence_label = generator.newLabel();
//SE ASIGNA EL NUEVO VALOR A LA VARIABLE
for_str += assignation.Execute(forAmbit);
//IMPRIMRE TAG RECURRENCIA
//for_str += generator.save_comment(recurrence_label+ ": //Etiqueta Recurrencia", cant_tabs, false);
//SE CREA LA CONDICION
//Relational cond_temp = new Relational((new Access(initId, row, column, cant_tabs)), actualizacion, simb, row, column, cant_tabs);
var trueLabel = generator.newLabel();
var continueLabel = generator.newLabel();
var falseLabel = generator.newLabel();
var actual = actualizacion.Execute(forAmbit);
for_str += actual.Texto_anterior;
for_str += generator.addLabel(trueLabel, cant_tabs);
var acceso = (new Access(initId, row, column, cant_tabs)).Execute(forAmbit);
for_str += acceso.Texto_anterior;
for_str += generator.add_If(acceso.Value.ToString(), actual.Value, simb, falseLabel, cant_tabs);
forAmbit.Continue = continueLabel;
forAmbit.Break = falseLabel;
//SE IMPRIMEN LAS INSTRUCCIONES
foreach (Instruction item in sentences)
{
var element = item.Execute(forAmbit);
if (element == null)
{
return(null);
}
for_str += element.ToString();
}
for_str += generator.addLabel(continueLabel, cant_tabs);
for_str += generator.addExpression(acceso.Value.ToString(),
acceso.Value.ToString(), "1", simb2, cant_tabs);
Assignation assignation1 = new Assignation(initId,
new Literal(acceso.Value.ToString(), 1, row, column, cant_tabs), row, column, cant_tabs);
for_str += (assignation1.Execute(forAmbit));
//goto a etiqueta verdadera
for_str += generator.add_Goto(trueLabel, cant_tabs);
//etiqueta falsa
for_str += generator.addLabel(falseLabel, cant_tabs);
}
else
{
set_error("Variable de contador ilegal: La variable '" + initId + "' no debe estar inicializada al momento de su declaracion", row, column);
return(null);
}
}
else
{
set_error("La variable '" + initId + "' no esta declarada.", row, column);
return(null);
}
return(for_str);
}
public void getAmbitoGraficar(Ambit ambit, bool isgeneral)
{
if (ambitos.Count <= 20)
{
var ambito_name = ambit.Ambit_name.Replace("General_", "");
var enlace = "";
var texto =
ambito_name + "[label=<\n" +
"<table border='0' cellborder='1' cellspacing='0'>\n" +
"<tr>\n" +
"<td>" + ambito_name + "</td>" +
"</tr>\n" +
"<tr>\n" +
"<td cellpadding='4'>\n" +
"<table color='orange' cellspacing='0'>\n" +
"<tr>\n" +
"<td width='100'><i>Nombre</i></td>\n" +
"<td width='100'><i>Tipo</i></td>\n" +
"<td width='100'><i>Ambito</i></td>\n" +
"<td width='100'><i>Valor</i></td>\n" +
"<td width='100'><i>Tipo objeto</i></td>\n" +
"</tr>\n";
if (ambit.anterior != null)
{
var ambit_temp = ambit.anterior.Ambit_name.Replace("General_", "");
enlace = ambit_temp + "->" + ambito_name + ";\n";
}
var res_graphi = "";
while (ambit != null)
{
if (ambit.Variables.Count > 0)
{
foreach (var item in ambit.Variables)
{
Identifier id = (Identifier)item.Value;
ambito_name = ambit.Ambit_name.Replace("General_", "");
res_graphi = "\n<tr>\n\t<td height='25'>" + id.Id + "</td>\n\t<td height='25'>" + id.DataType + "</td>\n\t<td height='25'>" + ambito_name + "</td>\n\t<td height='25'>" + id.Value.ToString() + "</td>\n\t<td height='25'>" + id.Tipo_dato + "</td>\n</tr>" + res_graphi;
}
}
if (isgeneral)
{
if (ambit.Functions.Count > 0)
{
var type = "void";
var isfunc = "Procedure";
foreach (var item in ambit.Functions)
{
type = "void";
isfunc = "Procedure";
Function func = (Function)item.Value;
if (!func.IsProcedure)
{
isfunc = "Function";
type = func.Tipe.ToString();
}
res_graphi = "<tr>\n<td height='25'>" + func.Id + "</td>\n<td height='25'>" + type + "</td>\n<td height='25'>" + ambit.Ambit_name + "</td>\n<td height='25'>" + func.Retorno.ToString() + "</td>\n<td height='25'>" + isfunc + "</td>\n</tr>" + res_graphi;
}
}
}
var temp = ambit.anterior;
ambit = temp;
}
texto += res_graphi
+ "</table>\n</td>\n</tr>\n </table>>];\n";
ambitos.Add(new Simbolo(ambito_name, texto, enlace));
}
}
public override Returned Execute(Ambit ambit)
{
var valIz = this.left.Execute(ambit);
var valDer = this.right.Execute(ambit);
TablaTipo tablaTipo = new TablaTipo();
var res = tablaTipo.getTipoRel(valIz.getDataType, valDer.getDataType);
if (res == DataType.ERROR)
{
set_error("Operador '" + this.type + "' NO puede ser aplicado a los tipos " + valIz.getDataType + " con " + valDer.getDataType, 0, 0);
return(new Returned());
}
var result = new Returned();
var op = GetType(this.type);
switch (op)
{
case OpRelational.EQUALS:
var equals = (bool)(valIz.Value.ToString() == valDer.Value.ToString());
result = new Returned(equals, DataType.BOOLEAN);
break;
case OpRelational.DISCTINCT:
var distict = (bool)(valIz.Value.ToString() != valDer.Value.ToString());
result = new Returned(distict, DataType.BOOLEAN);
break;
case OpRelational.LESS:
var less = (bool)(double.Parse(valIz.Value.ToString()) < double.Parse(valDer.Value.ToString()));
result = new Returned(less, DataType.BOOLEAN);
break;
case OpRelational.LESS_EQUALS:
var lessE = (bool)(double.Parse(valIz.Value.ToString()) <= double.Parse(valDer.Value.ToString()));
result = new Returned(lessE, DataType.BOOLEAN);
break;
case OpRelational.HIGHER:
var higher = (bool)(double.Parse(valIz.Value.ToString()) > double.Parse(valDer.Value.ToString()));
result = new Returned(higher, DataType.BOOLEAN);
break;
case OpRelational.HIGHER_EQUALS:
var higherE = (bool)(double.Parse(valIz.Value.ToString()) >= double.Parse(valDer.Value.ToString()));
result = new Returned(higherE, DataType.BOOLEAN);
break;
default:
break;
}
return(result);
}
public override object Execute(Ambit ambit)
{
ambit.saveFuncion(this.id, this);
return(0);
}
public override object Execute(Ambit ambit)
{
var repeat_String = "";
//INSTANCIA DEL GENERADOR C3D
var generator = C3D.C3DController.Instance;
//AMBITO DEL REPEAT
var repeatAmbit = new Ambit(ambit, ambit.Ambit_name + "_Repeat", "Repeat", false, ambit.IsFunction);
repeat_String += generator.save_comment("Inicia Repeat", cant_tabs, false);
//SETEO Continue y break por defecto
repeatAmbit.Break = "LBREAK";
repeatAmbit.Continue = "LCONTINUE";
condition.TrueLabel = generator.newLabel();
condition.FalseLabel = generator.newLabel();
//IMPRIMIR ETIQUETA RECURRENCIA
repeat_String += generator.addLabel("LCONTINUE", cant_tabs);
//INSTRUCCIONES
var result = sentences.Execute(repeatAmbit);
if (result == null)
{
return(null);
}
repeat_String += result.ToString();
//CONDICION
var condicion = condition.Execute(repeatAmbit);
repeat_String += condicion.Texto_anterior;
repeatAmbit.Break = condicion.TrueLabel;
repeatAmbit.Continue = condicion.FalseLabel;
repeat_String = generator.replace_temp(condicion.TrueLabel, "LBREAK", repeat_String);
repeat_String = generator.replace_temp(repeatAmbit.Continue, "LCONTINUE", repeat_String);
//VERIFICA QUE SEA BOOL
if (condicion.getDataType != DataType.BOOLEAN)
{
set_error("La condicion del repeat no es booleana", row, column);
return(null);
}
//IMPRIMIR ETIQUETA VERDADERA
repeat_String += generator.addLabel(condicion.TrueLabel, cant_tabs);
repeat_String += generator.save_comment("Fin Repeat", cant_tabs, true);
return(repeat_String);
}
