private ArrayList elementos; //Valor
#endregion Fields
#region Constructors
public ValorArreglo(Arreglo tipo)
{
ArrayList dimensiones = tipo.Rangos; //Dimensiones Expresiones
Valor tmpsize = ((Expresiones) (dimensiones[0])).interpretar();
int size = ((ValorEntero)tmpsize).Valor;
for (int i = 1; i < dimensiones.Count; i++)
{
Valor tmp = ((Expresiones) (dimensiones[i])).interpretar();
size *= ((ValorEntero)tmp).Valor;//POIO LO TIENE CON MAS
}
Elementos = new ArrayList();
for (int i = 0; i < size;i++)
{
if (tipo.Contenido is Entero)
Elementos.Add(new ValorEntero(0));
if (tipo.Contenido is Cadena)
Elementos.Add(new ValorCadena(""));
if (tipo.Contenido is Flotante)
Elementos.Add(new ValorFlotante((float)(0.0)));
if (tipo.Contenido is Caracter)
Elementos.Add(new ValorCaracter(""));
if (tipo.Contenido is Booleano)
Elementos.Add(new ValorBooleano(true));
}
this.Tipo = tipo;
}
public IActionResult Index(Arreglo arr, string calcular)
{
if (calcular == "cal")
{
for (int i = 0; i < 10; i++)
{
arr.Numeros[i] = int.Parse(Request.Form["num"][i]);
}
arr.Mayor = arr.Numeros.Max().ToString();
arr.Menor = arr.Numeros.Min().ToString();
}
return(View(arr));
}
public Objeto Copia(Objeto entrada)
{
if (entrada.getTipo() == Objeto.TipoObjeto.OBJECTS)
{
Type_obj salida = new Type_obj();
salida = (Type_obj)entrada.Clonar_Objeto();
return(salida);
}
else if (entrada.getTipo() == Objeto.TipoObjeto.ARRAY)
{
Arreglo salida = new Arreglo();
salida = (Arreglo)entrada.Clonar_Objeto();
return(salida);
}
return(null);
}
private static bool validarArreglo(Arreglo arr, object[] arreglo)
{
if (arreglo[0] == null)
{
throw new Exception("El arreglo que intenta usar no tiene valores asignados");
}
switch (arr.tipo)
{
case "Int":
if (!(arreglo[0] is int))
{
return(false);
}
break;
case "String":
if (!(arreglo[0] is string))
{
return(false);
}
break;
case "Double":
if (!(arreglo[0] is double))
{
return(false);
}
break;
case "Bool":
if (!(arreglo[0] is bool))
{
return(false);
}
break;
case "Char":
if (!(arreglo[0] is char))
{
return(false);
}
break;
}
return(true);
}
private void declaracionApartirDeArbol(Ambito ambito)
{
if (!ambito.existeVariable(this.idArr.ToLower()))
{
GeneradorArreglo gen = new GeneradorArreglo(this.arbolArreglo);
if (!gen.huboError)
{
int numaux = gen.numDimensiones;
if (NumDim == gen.numDimensiones)
{
///FALTA COMPROBAR SI TODOS LOS ELEMENTOS DEL ARREGLO SON DEL MISMO TIPO
///
List <Object> valores = linealizadaValores(gen.linealizacion, ambito);
if (valores != null)
{
Arreglo arr = new Arreglo(this.arbolArreglo, valores, gen.dimensiones, this.NumDim, this.idArr.ToLower(), true, this.visibilidad, this.tipo);
ambito.agregarVariableAlAmbito(this.idArr.ToLower(), arr);
}
else
{
TError error = new TError("Semantico", "El Arreglo: \"" + this.idArr + "\" no concuerda con el tipo esperado: " + this.tipo + " | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
TError error = new TError("Semantico", "Las dimensiones declaradas para: \"" + this.idArr + "\" No concuerdan, Se esperaban: " + this.NumDim + " y se encontro: " + gen.numDimensiones + " | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
TError error = new TError("Semantico", "Declaracion erreonea de Arreglo: \"" + this.idArr + "\" en este Ambito | Error: " + gen.mensajesError + " | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
TError error = new TError("Semantico", "Ya existe una declaracion de: \"" + this.idArr + "\" en este Ambito | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
object resEx = Operacion.Validar(exp.ejecutar(ctx, stuff), ctx, stuff, exp.getLinea(), exp.getColumna());
if (resEx == null)
{
return(null);
}
if (resEx is Arreglo)
{
object resIndice = Operacion.Validar(indice.ejecutar(ctx, stuff), ctx, stuff, indice.getLinea(), indice.getColumna());
if (resIndice == null)
{
return(null);
}
if (resIndice is BigInteger index)
{
Arreglo arr = (Arreglo)resEx;
if (index < 0)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado pequeño. Encontrado: " + index + ", Minimo: 0.", indice.getLinea(), indice.getColumna(), ctx);
return(null);
}
if (index >= arr.val.Count)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado grande. Encontrado: " + index + ", Maximo: " + (arr.val.Count - 1) + ".", indice.getLinea(), indice.getColumna(), ctx);
return(null);
}
return(arr.val.ElementAt((int)index));
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del indice es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resIndice) + ", Esperado: 'ENTERO'.", indice.getLinea(), indice.getColumna(), ctx);
return(null);
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resEx) + ", Esperado: 'ARREGLO'.", exp.getLinea(), exp.getColumna(), ctx);
return(null);
}
public static bool validarParametros(object arg1, object arg2)
{
if (arg1 is Simbolo)
{
if (arg2 is Simbolo)
{
Simbolo uno = (Simbolo)arg1;
Simbolo dos = (Simbolo)arg2;
if (uno.tipo.Equals(dos.tipo))
{
return(true);
}
}
else
{
return(false);
}
}
else if (arg1 is Arreglo)
{
if (arg2 is Arreglo)
{
Arreglo one = (Arreglo)arg1;
Arreglo two = (Arreglo)arg2;
if (one.tipo.Equals(two.tipo))
{
return(true);
}
}
else
{
return(false);
}
}
return(false);
}
public object getValor(Ambito ambito)
{
if (this.identificador.ToLower().Equals("nada"))
{
return(-1);
}
if (this.identificador.ToLower().Equals("este"))
{
return(new Este());
}
Simbolo aux = ambito.getSimbolo(this.identificador.ToLower());
if (aux != null)
{
if (aux is Variable)
{
Variable v = (Variable)aux;
this.ValorAux = v.valor;
return(v.valor);
}
else if (aux is Arreglo)
{
//RETORNO SI ES OTRO TIPO
Arreglo arr = (Arreglo)aux;
this.ValorAux = arr;
return(arr);
}
}
else
{
TError erro = new TError("Semantico", "Se hacer referencia a: " + this.identificador + ", La cual no Existe en este Contexto: Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(erro);
Estatico.ColocaError(erro);
}
return(new Nulo());
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
if (exp1 is Operacion)
{
Operacion op1 = (Operacion)exp1;
if (op1.tipo == Operacion.Tipo.IDENTIFICADOR)
{
Simbolo s = ctx.findSymbol(op1.value.ToString());
if (s == null)
{
stuff.error("Semántico", "'ASIGNACION', la variable '" + op1.value.ToString() + "' no existe.", exp1.getLinea(), exp1.getColumna(), ctx);
return(null);
}
object resOp = Operacion.Validar(exp2.ejecutar(ctx, stuff), ctx, stuff, exp2.getLinea(), exp2.getColumna());
if (resOp == null)
{
resOp = Simbolo.NULL;
}
s.value = resOp;
return(null);
}
else
{
stuff.error("Semántico", "'ASIGNACION', El lado izquierdo de una asignación debe ser una variable, propiedad o indizador.", exp1.getLinea(), exp1.getColumna(), ctx);
return(null);
}
}
else if (exp1 is AccesoArreglo)
{
AccesoArreglo aa = (AccesoArreglo)exp1;
object resEx = Operacion.Validar(aa.exp.ejecutar(ctx, stuff), ctx, stuff, aa.exp.getLinea(), aa.exp.getColumna());
if (resEx == null)
{
return(null);
}
if (resEx is Arreglo)
{
object resIndice = Operacion.Validar(aa.indice.ejecutar(ctx, stuff), ctx, stuff, aa.indice.getLinea(), aa.indice.getColumna());
if (resIndice == null)
{
return(null);
}
if (resIndice is BigInteger index)
{
Arreglo arr = (Arreglo)resEx;
if (index < 0)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado pequeño. Encontrado: " + index + ", Minimo: 0.", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
if (index >= arr.val.Count)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado grande. Encontrado: " + index + ", Maximo: " + (arr.val.Count - 1) + ".", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
object resOp = Operacion.Validar(exp2.ejecutar(ctx, stuff), ctx, stuff, exp2.getLinea(), exp2.getColumna());
if (resOp == null)
{
resOp = Simbolo.NULL;
}
arr.val.RemoveAt((int)index);
arr.val.Insert((int)index, resOp);
return(null);
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del indice es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resIndice) + ", Esperado: 'ENTERO'.", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resEx) + ", Esperado: 'ARREGLO'.", aa.exp.getLinea(), aa.exp.getColumna(), ctx);
return(null);
}
else if (exp1 is AccesoPropiedad)
{
AccesoPropiedad ap = (AccesoPropiedad)exp1;
object resExp1 = Operacion.Validar(ap.exp1.ejecutar(ctx, stuff), ctx, stuff, ap.exp1.getLinea(), ap.exp1.getColumna());
if (resExp1 == null)
{
return(null);
}
if (resExp1 is Objeto)
{
if (ap.exp2 is LlamadaMetodo)
{
stuff.error("Semántico", "'ASIGNACION', El lado izquierdo de una asignación debe ser una variable, propiedad o indizador.", exp1.getLinea(), exp1.getColumna(), ctx);
return(null);
}
else if (ap.exp2 is Operacion)
{
Operacion op = (Operacion)ap.exp2;
Objeto ob = (Objeto)resExp1;
Simbolo s = ob.atributos.findAttribute(op.value.ToString());
if (s == null)
{
stuff.error("Semántico", "'ACCESO PROPIEDAD', la variable '" + op.value.ToString() + "' no existe como propiedad de la clase '" + ob.nombre_clase + "'.", op.getLinea(), op.getColumna(), ctx);
return(null);
}
object resOp = Operacion.Validar(exp2.ejecutar(ctx, stuff), ctx, stuff, exp2.getLinea(), exp2.getColumna());
if (resOp == null)
{
resOp = Simbolo.NULL;
}
s.value = resOp;
return(null);
}
}
else
{
stuff.error("Semántico", "'ACCESO PROPIEDAD', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resExp1) + ", Esperado: 'OBJETO'.", ap.exp1.getLinea(), ap.exp1.getColumna(), ctx);
}
return(null);
}
else if (exp1 is LlamadaMetodo)
{
stuff.error("Semántico", "'ASIGNACION', El lado izquierdo de una asignación debe ser una variable, propiedad o indizador.", exp1.getLinea(), exp1.getColumna(), ctx);
return(null);
}
return(null);
}
public object Ejecutar(Ambito ambito)
{
try
{
Simbolo s = (Simbolo)ambito.getSimbolo(this.idArr.ToLower());
if (s != null)
{
if (s is Arreglo)
{
Arreglo arr = (Arreglo)s;
/// DIMENSIONES DEL ARREGLO
List <int> dimensiones = getDimensiones(ambito);
if (dimensiones != null)
{
Object valorAsignado = val.getValor(ambito);
String tipoVal = val.getTipo(ambito);
if (tipoVal.ToLower().Equals(arr.Tipo.ToLower()))
{
//ASIGNO EL VALOR
if (arr.esCoordenadaValida(dimensiones))
{
int realIndex = arr.calcularPosicion(dimensiones);
arr.setValueAtPosition(realIndex, valorAsignado);
}
else
{
TError error = new TError("Semantico", "Asignacion a Arreglo: \"" + this.idArr + "\" no se puede realizar ya que la posicion no es valida! | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
TError error = new TError("Semantico", "El valor asignar al arreglo: \"" + this.idArr + "\" no coincide con el tipo esperado. Se esperaba: \"" + arr.Tipo + "\" y se encontro:\"" + tipoVal + "\" | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
TError error = new TError("Semantico", "Las dimensiones no contienen valores valodos, solo enteros son admitidos: \"" + this.idArr + "\" | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
TError error = new TError("Semantico", "El simbolo: \"" + this.idArr + "\" No es un arreglo para poder realizara la asignacion | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
TError error = new TError("Semantico", "El arreglo: \"" + idArr + "\" no existe en este ambito! | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
catch (Exception e)
{
TError error = new TError("Ejecucion", "Error de Ejecucion al intentar asignar posicion de un Arreglo | Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, this.linea, this.columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
return(null);
}
public object getValor(Ambito ambito)
{
try
{
if (tipo == 1)
{
double v = 0;
int iteracion = 0;
foreach (Expresion e in this.expresiones)
{
Object val = e.getValor(ambito);
double auxiliar = 0;
if (val is int)
{
int aux = (int)val;
auxiliar = Convert.ToDouble(aux);
if (iteracion == 0)
{
v = auxiliar;
}
}
else if (val is double)
{
double aux = (double)val;
auxiliar = aux;
if (iteracion == 0)
{
v = auxiliar;
}
}
else if (val is String)
{
String aux = (String)val;
double x = 0;
foreach (char c in aux)
{
x = x + Convert.ToInt32(c);
}
auxiliar = x;
if (iteracion == 0)
{
v = auxiliar;
}
}
else if (val is Objeto || val is Nulo)
{
this.valor = 0;
return(0);
}
if (auxiliar < v)
{
v = auxiliar;
}
iteracion++;
}
this.valor = v;
return(v);
}
else
{
Simbolo s = (Simbolo)ambito.getSimbolo(this.identificador.ToLower());
if (s != null)
{
if (s is Arreglo)
{
Arreglo aux = (Arreglo)s;
List <object> linealizado = aux.linealizacion;
double auxiliar = 0;
int iteracion = 0;
foreach (object ob in linealizado)
{
double v = 0;
if (ob is int)
{
int x = (int)ob;
v = Convert.ToDouble(x);
if (iteracion == 0)
{
auxiliar = v;
}
}
else if (ob is double)
{
double x = (double)ob;
v = x;
if (iteracion == 0)
{
auxiliar = v;
}
}
else if (ob is String)
{
String x = (String)ob;
double y = 0;
foreach (char c in x)
{
y = y + Convert.ToInt32(c);
}
v = y;
if (iteracion == 0)
{
auxiliar = v;
}
}
else if (ob is Objeto || ob is Nulo)
{
this.valor = 0;
return(0.0);
}
if (v < auxiliar)
{
auxiliar = v;
}
iteracion++;
}
this.valor = auxiliar;
return(auxiliar);
}
else
{
TError error = new TError("Semantico", "El simbolo: \"" + identificador + "\" no es un arreglo para poder aplicar la funcion Min() | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
TError error = new TError("Semantico", "En funcion Min() se hace referencia a Arreglo: \"" + s.idSimbolo + "\" el cual no existe | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
}
catch (Exception e)
{
TError error = new TError("Ejecucion", "Error al ejecutar la funcion Min() | Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
return(0.0);
}
protected void Page_Load(object sender, EventArgs e)
{
this.arr = new Arreglo();
this.datos = this.arr.getLista();
texto.Text = "controlandoDesdeCodeBehind";
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
if (op is Operacion)
{
Operacion op1 = (Operacion)op;
if (op1.tipo == Operacion.Tipo.IDENTIFICADOR)
{
Simbolo s = ctx.findSymbol(op1.value.ToString());
if (s == null)
{
stuff.error("Semántico", "'AUMENTO', la variable '" + op1.value.ToString() + "' no existe.", op1.getLinea(), op1.getColumna(), ctx);
return(null);
}
if (s.value is BigInteger)
{
BigInteger r1 = (BigInteger)s.value;
s.value = Operacion.Validar(r1 + 1, ctx, stuff, op1.getLinea(), op1.getColumna());
return(r1);
}
if (s.value is double)
{
double r1 = (double)s.value;
s.value = Operacion.Validar(r1 + 1.0, ctx, stuff, op1.getLinea(), op1.getColumna());
return(r1);
}
if (s.value is char)
{
BigInteger r1 = (char)s.value;
s.value = Operacion.Validar(r1 + 1, ctx, stuff, op1.getLinea(), op1.getColumna());
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(s.value) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
else
{
object resOp = Operacion.Validar(op.ejecutar(ctx, stuff), ctx, stuff, fila, columna);
if (resOp == null)
{
return(null);
}
if (resOp is BigInteger)
{
BigInteger r1 = (BigInteger)resOp + 1;
return(r1);
}
if (resOp is double)
{
double r1 = (double)resOp + 1.0;
return(r1);
}
if (resOp is char)
{
BigInteger r1 = ((char)resOp + 1);
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resOp) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
}
else if (op is AccesoArreglo)
{
AccesoArreglo aa = (AccesoArreglo)op;
object resEx = Operacion.Validar(aa.exp.ejecutar(ctx, stuff), ctx, stuff, aa.exp.getLinea(), aa.exp.getColumna());
if (resEx == null)
{
return(null);
}
if (resEx is Arreglo)
{
object resIndice = Operacion.Validar(aa.indice.ejecutar(ctx, stuff), ctx, stuff, aa.indice.getLinea(), aa.indice.getColumna());
if (resIndice == null)
{
return(null);
}
if (resIndice is BigInteger index)
{
Arreglo arr = (Arreglo)resEx;
if (index < 0)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado pequeño. Encontrado: " + index + ", Minimo: 0.", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
if (index >= arr.val.Count)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado grande. Encontrado: " + index + ", Maximo: " + (arr.val.Count - 1) + ".", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
if (arr.val.ElementAt((int)index) is BigInteger)
{
BigInteger r1 = (BigInteger)arr.val.ElementAt((int)index);
arr.val.RemoveAt((int)index);
arr.val.Insert((int)index, Operacion.Validar(r1 + 1, ctx, stuff, aa.indice.getLinea(), aa.indice.getColumna()));
return(r1);
}
if (arr.val.ElementAt((int)index) is double)
{
double r1 = (double)arr.val.ElementAt((int)index);
arr.val.RemoveAt((int)index);
arr.val.Insert((int)index, Operacion.Validar(r1 + 1.0, ctx, stuff, aa.indice.getLinea(), aa.indice.getColumna()));
return(r1);
}
if (arr.val.ElementAt((int)index) is char)
{
BigInteger r1 = (char)arr.val.ElementAt((int)index);
arr.val.RemoveAt((int)index);
arr.val.Insert((int)index, Operacion.Validar(r1 + 1, ctx, stuff, aa.indice.getLinea(), aa.indice.getColumna()));
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del elemento indizado es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(arr.val.ElementAt((int)index)) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del indice es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resIndice) + ", Esperado: 'ENTERO'.", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resEx) + ", Esperado: 'ARREGLO'.", aa.exp.getLinea(), aa.exp.getColumna(), ctx);
return(null);
}
else if (op is AccesoPropiedad)
{
AccesoPropiedad ap = (AccesoPropiedad)op;
object resExp1 = Operacion.Validar(ap.exp1.ejecutar(ctx, stuff), ctx, stuff, ap.exp1.getLinea(), ap.exp1.getColumna());
if (resExp1 == null)
{
return(null);
}
if (resExp1 is Objeto)
{
if (ap.exp2 is LlamadaMetodo)
{
LlamadaMetodo ll = (LlamadaMetodo)ap.exp2;
Objeto ob = (Objeto)resExp1;
Metodo m = ob.atributos.findLocalMethod(ll.id, ll.expresiones_params.Count);
if (m == null)
{
stuff.error("Semántico", "'LLAMADA METODO/FUNCION', el método o función '" + ll.id + "' no está definido dentro de la clase '" + ob.nombre_clase + "', o no tiene '" + ll.expresiones_params.Count + "' parametros.", ll.getLinea(), ll.getColumna(), ctx);
return(null);
}
else
{
Contexto ctx_metodo = new Contexto();
ctx_metodo.otrosArchivos = ob.atributos.otrosArchivos;
ctx_metodo.currentFile = ob.atributos.currentFile;
ctx_metodo.globales = ob.atributos.globales;
ctx_metodo.atributos = ob.atributos.atributos;
ctx_metodo.clases = ob.atributos.clases;
ctx_metodo.metodos = ob.atributos.metodos;
ctx_metodo.metodos_globales = ob.atributos.metodos_globales;
ctx_metodo.terminable = false;
ctx_metodo.continuable = false;
ctx_metodo.retornable = true;
ctx_metodo.esVoid = m.esVoid;
if (m.decl_params != null)
{
m.decl_params.ejecutar(ctx_metodo, stuff);
}
for (int j = 0; j < m.cantidad_params; j++)
{
Simbolo s = ctx_metodo.locales_mismo_nivel.ElementAt(j);
Instruccion i = ll.expresiones_params.ElementAt(j);
object resIns = Operacion.Validar(i.ejecutar(ctx, stuff), ctx, stuff, i.getLinea(), i.getColumna());
if (resIns == null)
{
resIns = Simbolo.NULL;
}
s.value = resIns;
}
foreach (Instruccion i in m.listaInstrucciones)
{
object res = i.ejecutar(ctx_metodo, stuff);
if (res is Return r)
{
if (r.expresionEvaluada is BigInteger)
{
BigInteger r1 = (BigInteger)r.expresionEvaluada + 1;
return(r1);
}
if (r.expresionEvaluada is double)
{
double r1 = (double)r.expresionEvaluada + 1.0;
return(r1);
}
if (r.expresionEvaluada is char)
{
BigInteger r1 = ((char)r.expresionEvaluada + 1);
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(r.expresionEvaluada) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
}
if (!m.esVoid)
{
stuff.error("Semántico", "'LLAMADA METODO/FUNCION', la función '" + ob.nombre_clase + "." + ll.id + "' de " + m.cantidad_params + " parametros carece de una instrucción 'RETURN' con expresion.", ll.getLinea(), ll.getColumna(), ctx);
return(null);
}
return(new lang.engine.Void(ob.nombre_clase, ll.id, m.cantidad_params));
}
}
else if (ap.exp2 is Operacion)
{
Operacion op = (Operacion)ap.exp2;
Objeto ob = (Objeto)resExp1;
Simbolo s = ob.atributos.findAttribute(op.value.ToString());
if (s == null)
{
stuff.error("Semántico", "'ACCESO PROPIEDAD', la variable '" + op.value.ToString() + "' no existe como propiedad de la clase '" + ob.nombre_clase + "'.", op.getLinea(), op.getColumna(), ctx);
return(null);
}
if (s.value is BigInteger)
{
BigInteger r1 = (BigInteger)s.value;
s.value = Operacion.Validar(r1 + 1, ctx, stuff, op.getLinea(), op.getColumna());
return(r1);
}
if (s.value is double)
{
double r1 = (double)s.value;
s.value = Operacion.Validar(r1 + 1.0, ctx, stuff, op.getLinea(), op.getColumna());
return(r1);
}
if (s.value is char)
{
BigInteger r1 = (char)s.value;
s.value = Operacion.Validar(r1 + 1, ctx, stuff, op.getLinea(), op.getColumna());
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(s.value) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
}
else
{
stuff.error("Semántico", "'ACCESO PROPIEDAD', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resExp1) + ", Esperado: 'OBJETO'.", ap.exp1.getLinea(), ap.exp1.getColumna(), ctx);
}
return(null);
}
else if (op is LlamadaMetodo)
{
object resOp = Operacion.Validar(op.ejecutar(ctx, stuff), ctx, stuff, fila, columna);
if (resOp == null)
{
return(null);
}
if (resOp is BigInteger)
{
BigInteger r1 = (BigInteger)resOp + 1;
return(r1);
}
if (resOp is double)
{
double r1 = (double)resOp + 1.0;
return(r1);
}
if (resOp is char)
{
BigInteger r1 = ((char)resOp + 1);
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resOp) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
else
{
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(op) + ", Esperado: 'EXPRESION', 'LLAMADA METODO', 'VARIABLE', 'PROPIEDAD' , 'INDIZADOR'.", fila, columna, ctx);
}
return(null);
}
public Declaracion DeclarsCstruct(Declaracion decl)
{
try
{
if (currentToken.Tipo == Lexico.TipoToken.TK_COMA)
{
currentToken = lex.NextToken();
if (currentToken.Tipo != Lexico.TipoToken.TK_ID)
throw new Exception("Se esperaba un token ID");
Variable nombre = new Variable(currentToken.Lexema, null);
decl.Sig.Var = nombre;
decl.Sig.Tip = decl.Tip;
DeclarsCstruct(decl.Sig);
return decl;
}
else if (currentToken.Tipo == Lexico.TipoToken.TK_OPENCOR)
{
currentToken = lex.NextToken();
Expresiones E1 = Expression();
if (currentToken.Tipo != Lexico.TipoToken.TK_CLOSECOR)
throw new Exception("Se esperaba el token ] ");
currentToken = lex.NextToken();
Arreglo tipoArreglo = new Arreglo();
tipoArreglo.Rangos.Add(E1);
tipoArreglo.Contenido = decl.Tip;
decl.Tip = tipoArreglo;
DeclarsCstruct(decl.Sig);
return decl;
}
return decl;
}
catch (Exception ex)
{
throw ex;
}
}
protected void Page_Load(object sender, EventArgs e)
{
this.arr = new Arreglo();
this.datos = this.arr.getLista();
this.texto = "mi muñeca me habló";
}
public Sentencia DeclaracionesClase()
{
Declaracion Decl = new Declaracion();
VARTYPE();
try
{
Class c = new Class();
c.Nombre = currentToken.Lexema;
c.Campos=new T_Campos();
Decl.Tip =c;
currentToken = lex.NextToken();
}
catch (Exception ex)
{
throw ex;
}
if (currentToken.Tipo == TipoToken.TK_OPENCOR) //ARREGLO
{
int dim = arrayDimensions(1);
Arreglo ArrTip = new Arreglo();
ArrTip.Contenido = Decl.Tip;
ArrTip.Dimensiones = dim;
Decl.Tip = ArrTip;
if (currentToken.Tipo == TipoToken.TK_ID)
{
Decl.Var.id = currentToken.Lexema;
currentToken = lex.NextToken();
if (currentToken.Tipo == TipoToken.TK_FINSENTENCIA)
{
currentToken = lex.NextToken();
return Decl;
}
try
{
Decl = DeclOption(Decl);
}
catch (Exception ex)
{
throw ex;
}
if (currentToken.Tipo != TipoToken.TK_FINSENTENCIA)
{
currentToken = lex.NextToken();
return Decl;
}
else
{
throw new Exception("Error Sintactico - Se esperaba Fin Sentencia");
}
}
else
{
throw new Exception("Error Sintactico - Se esperaba un ID");
}
}
else if (currentToken.Tipo == TipoToken.TK_ID)
{
Decl.Var.id = currentToken.Lexema;
currentToken = lex.NextToken();
if (currentToken.Tipo == TipoToken.TK_COMA || currentToken.Tipo == TipoToken.TK_ASSIGN)
{
try
{
DeclaracionesVarias(Decl);
DeclOption(Decl);
}
catch (Exception ex)
{
throw ex;
}
}
else if (currentToken.Tipo == TipoToken.TK_OPENPAR)
{
currentToken = lex.NextToken();
S_Functions sFunctions = new S_Functions();
sFunctions.Retorno = Decl.Tip;
sFunctions.Var = Decl.Var.id;
try
{
sFunctions.Campo = ParameterList();
}
catch (Exception ex)
{
throw ex;
}
if (currentToken.Tipo == TipoToken.TK_CLOSEPAR)
{
currentToken = lex.NextToken();
try
{
sFunctions.S = CompoundStatement();
}
catch (Exception ex)
{
throw ex;
}
return sFunctions;
}
else
{
throw new Exception("Error Sintactico - Se esperaba simbolo )");
}
}
else if (currentToken.Tipo == TipoToken.TK_OPENLLAVE)
{
currentToken = lex.NextToken();
S_Class sClass = new S_Class();
sClass.Var.id = Decl.Var.id;
try
{
sClass.CamposClase = ListaDeclaracion(sClass.CamposClase);
}
catch (Exception ex)
{
throw ex;
}
if (currentToken.Tipo != TipoToken.TK_CLOSELLAVE)
throw new Exception("Error Sintactico - Se esperaba simbolo }");
currentToken = lex.NextToken();
return sClass;
}
else if (currentToken.Tipo == TipoToken.TK_FINSENTENCIA)
{
currentToken = lex.NextToken();
return Decl;
}
else
throw new Exception("Error Sintactico - Se esperaba simbolo ;");
}
return Decl;
}
public object Ejecutar(Ambito ambito)
{
try
{
Simbolo s = (Simbolo)ambito.getSimbolo(this.identificador.ToLower());
if (s != null)
{
if (s is Variable)
{
Variable vari = (Variable)s;
String tipoEsperado = vari.Tipo;
Object val = this.valor.getValor(ambito);
String tipoEncontrado = this.valor.getTipo(ambito);
if (tipoEncontrado.ToLower().Equals(tipoEsperado.ToLower()) || tipoEncontrado.ToLower().Equals("nulo"))
{
vari.valor = val;//ASIGNO EL NUEVO VALOR
}
////////////////////////////////////////////////////////////////
else if (tipoEsperado.ToLower().Equals("entero") && val is double)
{
Double valor = (Double)val;
int real = Convert.ToInt32(valor);
vari.valor = real;
}
else if (tipoEsperado.ToLower().Equals("decimal") && val is int)
{
int valor = (int)val;
double real = Convert.ToDouble(valor);
vari.valor = real;
}
else if (tipoEsperado.ToLower().Equals("entero") && val is bool)
{
Boolean valor = (Boolean)val;
int real = Convert.ToInt32(valor);
vari.valor = real;
}
else if (tipoEsperado.ToLower().Equals("booleano") && val is int)
{
int valor = (int)val;
Boolean real = false;
if (valor == 1)
{
real = true;
}
vari.valor = real;
}
////////////////////////////////////////////////////////////////
else
{
TError error = new TError("Semantico", "Tipos no Coinciden al Asignar, Esperado: \"" + tipoEsperado + "\", Encontrado: " + tipoEncontrado + "\" | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else if (s is Arreglo)
{
Arreglo a = (Arreglo)s;
Object v = this.valor.getValor(ambito);
String tipoEncontrado = this.valor.getTipo(ambito);
if (v is Arreglo)
{
Arreglo asig = (Arreglo)v;
if (a.numDimensiones == asig.numDimensiones && a.Tipo.ToLower().Equals(asig.Tipo.ToLower()))
{
Ambito aux = buscarAmbitoDondeEsta(this.identificador.ToLower(), ambito);
aux.removerArreglo(this.identificador.ToLower());
aux.agregarVariableAlAmbito(this.identificador.ToLower(), new Arreglo(asig.linealizacion, asig.dimensiones, asig.numDimensiones, a.idSimbolo, true, a.Visibilidad, a.Tipo));
}
else
{
TError error = new TError("Semantico", " Arreglos no tienen la misma caracteristicas, Se esperaba arreglo: Dimensiones: " + a.numDimensiones + " y Tipo: " + a.Tipo + ", Se econtro: Dimensiones: " + asig.numDimensiones + " y Tipo: " + asig.Tipo + "| Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
TError error = new TError("Semantico", "Tipos no Coinciden al Asignar, Esperado: \"" + "Arreglo" + "\", Encontrado: " + tipoEncontrado + "\" | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
else
{
throw new NotImplementedException();
}
}
else
{
TError error = new TError("Semantico", "Referencia a Simbolo: \"" + this.identificador + "\" inexistente | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
}
catch (Exception e)
{
TError error = new TError("Ejecuccion", "Error al ejecutar la asignacion a Var: \"" + this.identificador + "\" | Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | " + e.Message, linea, columna, false);
Estatico.errores.Add(error);
Estatico.ColocaError(error);
}
return(null);
}
public Declaracion ParameterList()
{
if (currentToken.Tipo == TipoToken.TK_CHAR || currentToken.Tipo == TipoToken.TK_BOOL || currentToken.Tipo == TipoToken.TK_STRING || currentToken.Tipo == TipoToken.TK_FLOAT || currentToken.Tipo == TipoToken.TK_INT)
{
Declaracion C = new Declaracion();
try
{
C.Tip = Type();
}
catch (Exception ex)
{
throw ex;
}
if (currentToken.Tipo == TipoToken.TK_OPENCOR) //ARREGLO
{
int dim = arrayDimensions(1);
Arreglo ArrTip = new Arreglo();
ArrTip.Contenido = C.Tip;
ArrTip.Dimensiones = dim;
C.Tip = ArrTip;
if (currentToken.Tipo == TipoToken.TK_ID)
{
C.Var.id = currentToken.Lexema;
currentToken = lex.NextToken();
//C = DeclOption(C); /////PORQUE NO DEVUELVO NADA ACA??????????????????????????????
try
{
C.Sig = ParameterListP();
}
catch (Exception ex)
{
throw ex;
}
return C;
}
else
{
throw new Exception("Error Sintactico - Se esperaba un ID");
}
}
else if (currentToken.Tipo == TipoToken.TK_ID)
{
C.Var.id = currentToken.Lexema;
currentToken = lex.NextToken();
try
{
C.Sig = ParameterListP();
}
catch (Exception ex)
{
throw ex;
}
return C;
}
else
{
throw new Exception("Error Sintactico - Se esperaba un identificador");
}
}
else
{
return null;
}
}
protected void Page_Load(object sender, EventArgs e)
{
this.arr = new Arreglo();
this.datos = this.arr.GetLista();
this.texto = "la mona hablo";
}
public Sentencia DeclaracionesCPrima(Declaracion decl)
{
try
{
/*Cuando se declaran varias variables seguidas int x,t,y */
#region
if (currentToken.Tipo == Lexico.TipoToken.TK_COMA)
{
currentToken = lex.NextToken();
if (currentToken.Tipo != Lexico.TipoToken.TK_ID)
throw new Exception("Se esperaba un token ID");
Variable nombre = new Variable(currentToken.Lexema, null);
decl.Sig.Tip = decl.Tip;
decl.Sig.Var = nombre;
currentToken = lex.NextToken();
DeclCPrima(decl.Sig);
return decl;
}
#endregion
/*Declaracion de arreglos */
#region
else if (currentToken.Tipo == Lexico.TipoToken.TK_OPENCOR)
{
currentToken = lex.NextToken();
Expresiones E1 = Expression();
if (currentToken.Tipo != Lexico.TipoToken.TK_CLOSECOR)
throw new Exception("Se esperaba el token ] ");
currentToken = lex.NextToken();
Arreglo tipoArreglo = new Arreglo();
tipoArreglo.Contenido = decl.Tip;
tipoArreglo.Rangos.Add(E1);
DeclArreglo(tipoArreglo);
tipoArreglo.Dimensiones = tipoArreglo.Rangos.Count;
decl.Tip = tipoArreglo;
return decl;
}
#endregion
/*Declaracion de funciones */
#region
else if (currentToken.Tipo == Lexico.TipoToken.TK_OPENPAR)
{
currentToken = lex.NextToken();
Declaracion listaParams = FuncionesParams();
if (currentToken.Tipo != Lexico.TipoToken.TK_CLOSEPAR)
throw new Exception("Se esperaba el token )");
currentToken = lex.NextToken();
S_Functions declFuncion = new S_Functions();
declFuncion.Retorno = decl.Tip;
declFuncion.Var = decl.Var.id;
declFuncion.S = CompoundStatement();
if (listaParams != null)
declFuncion.Campo = listaParams;
return declFuncion;
}
#endregion
/*Declaracion de Structs */
#region
else if (currentToken.Tipo == Lexico.TipoToken.TK_OPENLLAVE)
{
currentToken = lex.NextToken();
Declaracion strDec = StructDeclaration();
Declaracion tmp = StructDeclaration();
while (tmp != null)
{
strDec.Sig = tmp;
tmp = StructDeclaration();
}
Structs s = new Structs();
s.nombre = decl.Var.id;
s.campos = strDec;
if (currentToken.Tipo != Lexico.TipoToken.TK_CLOSELLAVE)
throw new Exception("Error sintactico se esperaba }");
currentToken = lex.NextToken();
if (currentToken.Tipo != Lexico.TipoToken.TK_FINSENTENCIA)
throw new Exception("Error sintactico se esperaba ;");
currentToken = lex.NextToken();
return s;
}
#endregion
return decl;
}
catch (Exception ex)
{
throw ex;
}
}
Tipo ParseType()
{
switch (currentToken.Tipo)
{
case TipoToken.TK_INT:
{
currentToken = lex.NextToken();
return new Entero();
}
case TipoToken.TK_BOOL:
{
currentToken = lex.NextToken();
return new Booleano();
}
case TipoToken.TK_CHAR:
{
currentToken = lex.NextToken();
return new Caracter();
}
case TipoToken.TK_ID:
{
if (InfSemantica.getInstance().tblTipos.ContainsKey(currentToken.Lexema))
{
string nom = currentToken.Lexema;
currentToken = lex.NextToken();
return InfSemantica.getInstance().tblTipos[nom];
}
else throw new Exception("Tipo no reconocido.");
}
case TipoToken.TK_ARRAY:
{
currentToken = lex.NextToken();
if (currentToken.Tipo != TipoToken.TK_OPENCOR)
throw new Exception("Se esperaba [");
else
{
currentToken = lex.NextToken();
Arreglo ret = new Arreglo();
try
{
ret.Rangos = ExprList();
}
catch (Exception ex) { throw ex; }
ret.Dimensiones = ret.Rangos.Count;
if (currentToken.Tipo != TipoToken.TK_CLOSECOR)
throw new Exception("Se esperaba ]");
else
{
currentToken = lex.NextToken();
if (currentToken.Tipo != TipoToken.TK_OF)
throw new Exception("Se esperaba of.");
else
{
currentToken = lex.NextToken();
try
{
ret.Contenido = ParseType();
}
catch (Exception ex) { throw ex; }
return ret;
}
}
}
}
case TipoToken.TK_STRING:
{
currentToken = lex.NextToken();
return new Cadena();
}
default: throw new Exception("Eso no es un tipo.");
}
}
/*Aqui se efectua la recursividad de [][][]*/
public Arreglo DeclArreglo(Arreglo tipoArreglo)
{
try
{
if (currentToken.Tipo == Lexico.TipoToken.TK_OPENCOR)
{
currentToken = lex.NextToken();
Expresiones E1 = Expression();
if (currentToken.Tipo != Lexico.TipoToken.TK_CLOSECOR)
throw new Exception("Se esperaba el token ] ");
currentToken = lex.NextToken();
tipoArreglo.Rangos.Add(E1);
DeclArreglo(tipoArreglo);
return tipoArreglo;
}
return tipoArreglo;
}
catch (Exception ex)
{
throw ex;
}
}
