/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public virtual itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
return(retorno);
}
public itemValor opMenorQue(String ambito, elementoEntorno elem)
{
MayorIgualQue mayorIgualQue = new MayorIgualQue(hijo1, hijo2, tabla, signo);
itemValor retorno = mayorIgualQue.opMayorIgualQue(ambito, elem);
if (retorno.isTypeBooleano())
{
if (retorno.getBooleano())
{
retorno.setValue(false);
return(retorno);
}
else
{
retorno.setValue(true);
return(retorno);
}
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se recibió un booleano en" + ambito, signo);
return(retorno);
}
}
public itemValor opDiferenciacion(String ambito, elementoEntorno elem)
{
IgualQue dif = new IgualQue(hijo1, hijo2, tabla, signo);
itemValor retorno = dif.opIgualacion(ambito, elem);
if (retorno.isTypeBooleano())
{
if (retorno.getBooleano())
{
retorno.setValue(false);
return(retorno);
}
else
{
retorno.setValue(true);
return(retorno);
}
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se recibió un booleano en" + ambito, signo);
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elem);
String tipo = "cadena";
Object resul = valE.getValorParseado(tipo);
if (resul != null)
{
String cadena = (String)resul;
retorno.setValue(cadena);
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a " + tipo + " el valor", lstAtributos.getToken(0));
return(retorno);
}
}
public override void ejecutar(elementoEntorno elem)
{
if (tabla.hayErrores("lstPrincipal_ejecutar"))
{
return;
}
if (listaPolimorfa.Count > 0)
{
elementoPolimorfo temp = listaPolimorfa[0];
if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO"))
{
_LST_CUERPO val = (_LST_CUERPO)temp.LST_CUERPO;
itemValor retornoFuncion = new itemValor();
retornoFuncion.setTypeVacio();
val.ejecutar(elem);
imprimir(elem);
}
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se encuentra el main", new token());
}
}
public itemValor opNot(String ambito, elementoEntorno elem)
{
itemValor retorno = new itemValor();
itemValor val1 = hijo1.getValor(elem);
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opLogica]" + ambito + "Hijo1 es null", new token("--"));
return(retorno);
}
try
{
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero
*/
if (val1.isTypeEntero())
{
int val1R = (-1) * val1.getEntero();
retorno.setValue(val1R);
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal
*/
else if (val1.isTypeDecimal())
{
double val1R = (-1) * val1.getDecimal();
retorno.setValue(val1R);
return(retorno);
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se pueden operar [" + ambito + "] " + val1.getTipo(), signo);
}
}
catch (Exception)
{
tabla.tablaErrores.insertErrorSemantic("[OpAritemetica]No se pudo efectuar [" + ambito + " ]", signo);
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor getValor(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 3)
{
return(retorno);
}
_VALOR nodoE = (_VALOR)hijos[0];
itemValor valE = nodoE.getValor(elem, new token(""));
Object objetoValor = valE.getValorParseado("booleano");
Boolean condicion = false;
if (objetoValor != null)
{
condicion = (Boolean)objetoValor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("La condición devulelta no es de tipo booleano,es de tipo:" + valE.getTipo(), lstAtributos.getToken(0));
return(retorno);
}
_E nodoE2 = (_E)hijos[1];
_E nodoE3 = (_E)hijos[2];
if (hayErrores())
{
return(retorno);
}
itemValor itemVerdadero = nodoE2.getValor(elem);
itemValor itemFalso = nodoE3.getValor(elem);
if (condicion)
{
return(itemVerdadero);
}
else
{
return(itemFalso);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 1)
{
return(retorno);
}
_E nodoE2 = (_E)hijos[0];
if (hayErrores())
{
return(retorno);
}
itemValor itemInicio = nodoE2.getValor(elem);
if (itemInicio.isTypeFecha())
{
return(itemInicio);
}
else if (itemInicio.isTypeCadena())
{
itemValor tel = new itemValor();
tel.convertirCadena(itemInicio.getCadena());
if (tel.isTypeFecha())
{
retorno = tel;
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se pudo parsear a fecha", lstAtributos.getToken(0));
return(retorno);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se pueden parsear a fecha expresiones que no sean cadenas", lstAtributos.getToken(0));
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
_LST_VAL temp = (_LST_VAL)getNodo("LST_VAL");
lstValores listaValores = temp.getLstValores(tablaEntornos);
if (listaValores.listaValores.Count == 2)
/*
|----------------------------
| NOMBRE, TEXTO
*/
{
}
else if (listaValores.listaValores.Count == 1)
/*
|----------------------------
| TEXTO
*/
{
itemValor limitInf = listaValores.listaValores[0];
Object obj = limitInf.getValorParseado("cadena");
if (obj != null)
{
String contenido = (String)obj;
contenido = "\n < tr > " +
"\n <td>" + numPregunta + "</td>" + contenido;
numPregunta++;
_ESCRIBIR_ARCHIVO.contenido = _ESCRIBIR_ARCHIVO.contenido + contenido;
escribirArchivo(_ESCRIBIR_ARCHIVO.contenido, _ESCRIBIR_ARCHIVO.nombreArchivo);
return(retorno);
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 2)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se estan esperando dos parametros, ruta de audio, y valor booleano", lstAtributos.getToken(0));
return(retorno);
}
_E nodo1 = (_E)hijos[0];
_E nodo2 = (_E)hijos[1];
itemValor itRuta = nodo1.getValor(tablaEntornos);
itemValor itBoolean = nodo2.getValor(tablaEntornos);
Object objRuta = itRuta.getValorParseado("cadena");
Object objBool = itBoolean.getValorParseado("booleano");
if (objRuta == null || objBool == null)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Uno de los parámetros no fue cadena y/o booleano", lstAtributos.getToken(0));
return(retorno);
}
else
{
string ruta = (string)objRuta;
ruta = tablaSimbolos.getRutaProyecto() + "\\" + ruta;
Boolean booleano = (Boolean)objBool;
frmAudio fdecimal = new frmAudio(tablaEntornos, ruta, booleano);
fdecimal.ShowDialog();
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(1);
if (hayErrores())
{
return(retorno);
}
if (hijos.Count > 0)
/*
|----------------------------
| tRetorno + VALOR + sPuntoComa;
*/
{
nodoModelo nodoTemp = getNodo("VALOR");
if (nodoTemp != null)
{
_VALOR val = (_VALOR)nodoTemp;
itemValor tempValor = val.getValor(tablaEntornos, new token(""));
retorno.setValueRetorno(tempValor);
return(retorno);
}
else
{
return(retorno);
}
}
else
/*
|----------------------------
| RETORNO.Rule = tRetorno + sPuntoComa
|------------------------------
| Desde aquí ya no sigue la ejecución.
*/
{
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 1)
{
return(retorno);
}
String tipo2 = "entero";
_E nodoE2 = (_E)hijos[0];
if (hayErrores())
{
return(retorno);
}
int inicioVal = 0;
itemValor itemInicio = nodoE2.getValor(elem);
Object inicioTemp = itemInicio.getValorParseado(tipo2);
if (itemInicio.isTypeDecimal())
{
retorno.setValue(Math.Cos(itemInicio.getDecimal()));
return(retorno);
}
else if (inicioTemp != null)
{
inicioVal = (int)inicioTemp;
retorno.setValue(Math.Cos(inicioVal));
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a entero el valor", lstAtributos.getToken(0));
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 1)
{
return(retorno);
}
_LST_VAL nodoVals = (_LST_VAL)getNodo("LST_VAL");
if (nodoVals == null)
{
return(retorno);
}
lstValores listaValroes = nodoVals.getLstValores(elem);
Random rnd = new Random();
if (listaValroes.listaValores.Count > 0)
{
int month = rnd.Next(0, listaValroes.listaValores.Count);
itemValor item = listaValroes.getItemValor(month);
if (item.isTypeNulo())
{
retorno.setValue(0);
return(retorno);
}
else
{
return(item);
}
}
else
{
int dice = rnd.Next(0, 2);
retorno.setValue(dice);
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DE PRINCIPAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public void guardarParametrosEnLaTabla(Dictionary <llaveParametro, elementoParametro> lstParametros, lstValores lstParametros2, elementoEntorno elementoEntor)
{
if (lstParametros.Count == lstParametros2.listaValores.Count)
{
int i = 0;
foreach (var dic in lstParametros)
{
itemValor parametro2 = lstParametros2.getItemValor(i);
//Console.WriteLine("------------------------");
//Console.WriteLine("dic.key.dimension-> " + dic.Key.dimension);
//Console.WriteLine("parametro2.dimensiones->" + parametro2.dimensiones.Count);
if ((dic.Key.dimension == parametro2.dimensiones.Count) && (itemEntorno.validandoTipo(dic.Value.tipo.valLower, parametro2)))
{
token tNombre = new token(dic.Key.nombre);
token tTipo = new token(dic.Value.tipo.valLower);
//println("guardarParametrosEnLaTabla_ tipo->" + tTipo.valLower);
token tVisibilidad = new token("privado");
//listado de enteros
List <int> listaEntero = new List <int>();
for (int j = 0; i < dic.Key.dimension; i++)
{
listaEntero.Add(-1);
}
itemEntorno varParametro = new itemEntorno(tNombre, tTipo, parametro2, tVisibilidad, listaEntero, tabla);
elementoEntor.insertarEntorno(varParametro);
}
else
{
Console.WriteLine("[lstPolimorfismo]guardarParametrosEnLaTabla_Son de diferentes en tipo, o en dimensiones, aunque esto ya se tuvo que validar :/");
}
i++;
}
}
else
{
Console.WriteLine("[lstPolimorfismo]guardarParametrosEnLaTabla_Son de diferentes dimensiones, aunque esto ya se tuvo que validar :/");
}
}
public lstValores getLstValores(elementoEntorno elemento)
{
lstValores retorno = new lstValores();
foreach (nodoModelo hijo in hijos)
{
_VALOR temp = (_VALOR)hijo;
itemValor temporal1 = temp.getValor(elemento, new token());
retorno.insertar(temporal1);
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 1)
{
return(retorno);
}
String tipo1 = "booleano";
_E nodoE1 = (_E)hijos[0];
if (hayErrores())
{
return(retorno);
}
Boolean boolVal = false;
itemValor itemBool = nodoE1.getValor(elem);
Object boolObject = itemBool.getValorParseado(tipo1);
if (boolObject != null)
{
boolVal = (Boolean)boolObject;
retorno.setValue(boolVal);
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a booleano el valor", lstAtributos.getToken(0));
return(retorno);
}
}
public itemValor calcularTamanio(itemValor itemInicio, elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (itemInicio.valor != null)
{
if (itemInicio.isTypeBooleano() || itemInicio.isTypeEntero() || itemInicio.isTypeDecimal())
{
Object intObject = itemInicio.getValorParseado("entero");
if (intObject != null)
{
int reton = (int)intObject;
retorno.setValue(reton);
return(retorno);
}
}
Object cadeObject = itemInicio.getValorParseado("cadena");
if (cadeObject != null)
{
String caden = (String)cadeObject;
retorno.setValue(caden.Length);
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a cadena para verificar su tamaño", lstAtributos.getToken(0));
return(retorno);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear un objeto nulo", lstAtributos.getToken(0));
return(retorno);
}
}
public Boolean validandoTipo(String tipo1, String tipo2)
{
//aquí también hay que verificar las dimensiones
//if (tipo1.Equals(tipo2) || tipo2.Equals("nulo"))
itemValor tempIt = new itemValor();
if (tempIt.getTipoApartirDeString(tipo1).Equals(tipo2) || tipo2.Equals("nulo"))
{
return(true);
}
else
{
return(false);
}
}
/*
*
* ID_VAR_FUNC.Rule = ID_VAR_FUNC + LST_PUNTOSP
| tEste + sPunto + valId
| valId
| tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent
| valId + sAbreParent + LST_VAL + sCierraParent
|
|
#para los corchetes
|
| tEste + sPunto + valId + LST_CORCHETES_VAL
| valId + LST_CORCHETES_VAL
| tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL
| valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;
| ;
*/
//elementoEntorno elementoEntorno;
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DESDE EL CUERPO DEL METODO
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
itemValor te2 = getValor(tablaEntornos);
//println(te2.getTipo() + "|" + te2.nombrePregunta.valLower + "|entorno de ejecutar final ===================================0");
//if (!(te2.nombrePregunta.valLower.Equals("---") && te2.nombrePregunta.valLower.Equals("") && te2.nombrePregunta.valLower.Equals("--")))
if (te2.nombrePregunta.esPregunta)
{
//println("Estoy ejecutando");
if (te2 != null)
{
//ahora hay que buscarl la pregunta en la tabla de simbolos prro.
itemValor te3 = getValId(te2.nombrePregunta, tablaEntornos);
if (te3.isTypeObjeto())
{
elementoEntorno entor = te3.getObjeto().tablaEntorno.raiz;
entor.este.ejecutarMetodoFuncion(new token("ejecutarfinal"), new lstValores(), entor);
}
else
{
println("no me retorno un objeto");
}
}
else
{
println("[Error]sin mvalor fue nulo");
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count > 0)
{
return(hijos[0].ope_tipo(elem));
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones
|-------------------------------------------------------------------------------------------------------------------
|
*/
/* public void asignarValor(itemValor destino, itemValor valor, token tokIgual)
* {
*
* if (destino.dimensiones.Count > 0)
* {
* if (destino.dimensiones.Count == valor.dimensiones.Count)
* {
* if (validandoTipo(destino.getTipo(), valor.getTipo()))
* {
*
* //aquí se hace la asignación
* destino = valor;
* }
* {
* tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en una variable de tipo " + destino.getTipo() + ", un valor de tipo " + valor.getTipo(), tokIgual);
*
* }
* }
* else
* {
* tablaSimbolos.tablaErrores.insertErrorSemantic("Se esta recibiendo una dimensión :" + valor.dimensiones.Count + " para asignarlo a la matriz : de dimension:" + destino.dimensiones.Count, tokIgual);
* }
* }
* else
* {
* if (valor.dimensiones.Count != 0)
* {
* tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en la variable de tipo " + destino.getTipo() + ", una matriz de dimension : " + valor.dimensiones.Count, tokIgual);
* }
* else if (validandoTipo(destino.getTipo(), valor.getTipo()))
* {
*
* //aquí se hace la asignación
* destino = valor;
* }
* else
* {
* tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en una variable de tipo " + destino.getTipo() + ", un valor de tipo " + valor.getTipo(), tokIgual);
* }
* }
*
* }*/
public void asignarValor(itemEntorno destino, itemValor valor)
{
//validando si lo que estoy esperando es un arreglo
if (destino.dimension.Count > 0)
{
if (destino.dimension.Count == valor.dimensiones.Count)
{
if (validandoTipo(destino.tipo.valLower, valor.getTipo()))
{
//aquí le asigno el valor
destino.valor = valor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en :" + destino.nombre.val + " de tipo " + destino.tipo.valLower + ", un valor de tipo " + valor.getTipo(), destino.nombre);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se esta recibiendo :" + valor.dimensiones.Count + " en la matriz : " + destino.nombre.val + " de dimension:" + destino.dimension.Count, destino.nombre);
}
}
else
{
if (valor.dimensiones.Count != 0)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en la variable :" + destino.nombre.val + " de tipo " + destino.tipo.valLower + ", una matriz de dimension : " + valor.dimensiones.Count, destino.nombre);
}
else if (validandoTipo(destino.tipo.valLower, valor.getTipo()))
{
//aquí le asigno el valor
destino.valor = valor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en :" + destino.nombre.val + " de tipo " + destino.tipo.valLower + ", un valor de tipo " + valor.getTipo(), destino.nombre);
//error semantico, se está intentando asiganar un valor diferente al declarado por la variable
}
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
String temP = DateTime.Now.ToString("dd/MM/yyyy hh:mm:ss");
retorno.convertirCadena(temP);
println(temP);
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
Double pi = Math.PI;
retorno.setValue(pi);
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno elementoEntor)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
/*
|----------------------------
| tCaso + sAbreParent + E + sCierraParent + tDe + sAbreLlave + CUERPO_CASE + sCierraLlave;
*/
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
_CUERPO_CASE nodoCuerpo = (_CUERPO_CASE)hijos[1];
elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "case", elementoEntor.este);
itemRetorno cuerpoCase = nodoCuerpo.ejecutar(entornoIf, valE);
if (cuerpoCase.isRomper())
//este codigo sirve para eliminar el romper en los nodos, más arriba, y solo se quede en el case
{
return(new itemRetorno(0));
}
else
{
return(retorno);
}
}
public itemValor getValor(elementoEntorno elemento, token tipo)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count > 0)
{
nodoModelo hijo = hijos[0];
_VALOR ope = (_VALOR)hijo;
return(ope.getValor(elemento, tipo));
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor getValId(token idVal, elementoEntorno elem)
// aquí hay que buscar dentro de la tabla de simbolos y devoler el valor, e ir buscando
// hacia atraás para encontral el id
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
itemEntorno et = elem.getItemValor(idVal.valLower);
if (et != null)
{
return(et.valor);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("La variable : " + idVal.val + "no se encuentra en el ambito correcto para su acceso, no se ha declarado o no tiene permisos para acceder a ella", idVal);
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor getValor(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 1)
{
return(retorno);
}
_E nodoE2 = (_E)hijos[0];
if (hayErrores())
{
return(retorno);
}
itemValor itVal = nodoE2.getValor(elem);
if (itVal.dimensiones.Count <= 0)
{
retorno.setValue(0);
}
else
{
retorno.setValue(itVal.dimensiones[0]);
}
return(retorno);
}
public void asignarValorMatriz(itemEntorno destino, itemValor valor)
{
//validando si lo que estoy esperando es un arreglo
if (destino.dimension.Count > 0)
{
if (destino.dimension.Count == destino.lstDimensionesAcceso.Count)
{
if (validandoTipo(destino.tipo.valLower, valor.getTipo()))
{
int indiceFinal = indiceMapeado(destino.dimension, destino.lstDimensionesAcceso, destino.nombre);
if (indiceFinal > -1)
{
if (indiceFinal < destino.valor.arrayValores.Count)
{
destino.valor.arrayValores[indiceFinal] = valor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede acceder a la posición de la matriz: " + destino.nombre.val, destino.nombre);
}
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en :" + destino.nombre.val + " de tipo " + destino.tipo.valLower + ", un valor de tipo " + valor.getTipo(), destino.nombre);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se esta recibiendo :" + valor.dimensiones.Count + " en la matriz : " + destino.nombre.val + " de dimension:" + destino.dimension.Count, destino.nombre);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando acceder a una matriz en una variable :" + destino.nombre.val + "que no lo es.", destino.nombre);
}
}
public itemValor getValor(elementoEntorno elementoEntor, token tipo)
{
itemValor retorno = new itemValor();
if (hayErrores())
{
return(retorno);
}
//println(hijos[0].nombre);
nodoModelo temp = getNodo("E");
if (temp != null)
/*
|----------------------------
| PAR_CORCHETES_VAL.Rule = sAbreCorchete + E + sCierraCorchete;
*/
{
_E ret = (_E)temp;
// ret.getValor(elementoEntor).imprimirVariable();
///return ret.getValor(elementoEntor);
itemValor temporal = ret.getValor(elementoEntor);
if (temporal.dimensiones.Count > 0)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("El lenguaje no soporta variables, o nuevos arreglos anidados de una forma diferente de {{E,E},{E,E}}: Error en matriz", tipo);
return(retorno);
}
else
{
//temporal.imprimirVariable();
return(temporal);
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 1)
{
return(retorno);
}
_LST_VAL nodoVals = (_LST_VAL)getNodo("LST_VAL");
if (nodoVals == null)
{
return(retorno);
}
_TAM taman = new _TAM("TAM", tablaSimbolos);
lstValores listaValroes = nodoVals.getLstValores(elem);
if (listaValroes.listaValores.Count > 0)
{
int minimo = 0;
int i = 0;
foreach (itemValor itemVal in listaValroes.listaValores)
{
if (i == 0)
{
itemValor minimoItem = taman.calcularTamanio(itemVal, elem);
if (hayErrores())
{
return(retorno);
}
minimo = (int)minimoItem.getValorParseado("entero");
}
else
{
itemValor minimoItem = taman.calcularTamanio(itemVal, elem);
if (hayErrores())
{
return(retorno);
}
int enteroAnterio = (int)minimoItem.getValorParseado("entero");
if (enteroAnterio < minimo)
{
minimo = enteroAnterio;
}
}
i++;
}
retorno.setValue(minimo);
return(retorno);
}
else
{
retorno.setValue(0);
return(retorno);
}
}
