/* |------------------------------------------------------------------------------------------------------------------- | 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 frmCadena(itemValorPregunta valor, elementoEntorno parametros) { InitializeComponent(); this.valor = valor; elementoEntorno carg = parametros.getGlobal(); if (carg != null) { SetValores(carg.getEtiqueta(), carg.getSugerir(), carg.getRequerido()); } else { println("no se encontro el global"); SetValores("", "", ""); } //solo tengo que traer los que estan globales, jejejejejejeje }
/* |------------------------------------------------------------------------------------------------------------------- | 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"); retorno.convertirCadena(temP); println(temP); return(retorno); }
public frmSeleccionarUno(itemValorPregunta valor, elementoEntorno parametros, List <String> lstString) { InitializeComponent(); this.valor = valor; elementoEntorno carg = parametros.getGlobal(); if (carg != null) { SetValores(carg.getEtiqueta(), carg.getSugerir(), carg.getRequerido()); } else { println("no se encontro el global"); SetValores("", "", ""); } int i = 0; foreach (String strTemp in lstString) { println(strTemp); RadioButton rad = new RadioButton(); rad.Text = strTemp; rad.Location = new Point(10, i * 20); lstButons.Add(rad); i++; grupoBox.Controls.Add(rad); } //cargando los elementos al panel //solo tengo que traer los que estan globales, jejejejejejeje }
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); }
public frmEntero(itemValorPregunta valor, elementoEntorno parametros, int limiteInferior, int limiteSuperior) { InitializeComponent(); this.limiteInferior = limiteInferior; this.limiteSuperior = limiteSuperior; this.valor = valor; elementoEntorno carg = parametros.getGlobal(); if (carg != null) { SetValores(carg.getEtiqueta(), carg.getSugerir(), carg.getRequerido()); } else { SetValores("", "", ""); } numericUpDown1.Maximum = decimal.MaxValue; numericUpDown1.Minimum = decimal.MinValue; }
/* |------------------------------------------------------------------------------------------------------------------- | 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); }
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 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 getArray(token tipo, elementoEntorno elemEntor) { if (hayErrores()) { return; } Dictionary <int, itemValor> diccionario = new Dictionary <int, itemValor>(); List <int> dimensioenes = new List <int>(); int dimensionActual = 0; foreach (nodoModelo temp in hijos) { _LLAVES_VAL_P llaves = (_LLAVES_VAL_P)temp; llaves.getArray(diccionario, dimensioenes, tipo, dimensionActual, elemEntor); } //this.imprimiendoLstInt(dimensioenes); this.diccionario = diccionario; this.lstDimensiones = dimensioenes; }
public itemValor getValor(elementoEntorno elementoEntor, token tipo) { itemValor retorno = new itemValor(); retorno.setTypeNulo(); if (hayErrores()) { return(retorno); } if (lstAtributos.listaAtributos.Count == 4) { String item1 = lstAtributos.listaAtributos[0].nombretoken; String item2 = lstAtributos.listaAtributos[1].nombretoken; if (item1.Equals("nuevo") && item2.Equals("valId")) /* |---------------------------- | tNuevo + valId + sAbreParent + LST_VAL + sCierraParent */ { /* |-------------------------------------------------------------------------- | nuevo Objeto() | nuevo valId() |-------------------------------------------------------------------------- | tNuevo + valId + sAbreParent + LST_VAL + sCierraParent | tengo que crear una nueva clase y cargar los valores globales con sus metdos, funciones, y validar constructores | hay que buscar la clase primero | */ //token tokId = lstAtributos.getToken(1); token tokInstancia = lstAtributos.getToken(1); elementoClase temp = tablaSimbolos.getClase(tokInstancia); if (temp != null) { objetoClase ObjClase = new objetoClase(temp, tablaSimbolos); lstValores lstValores2 = new lstValores(); //ahora tengo que llamar al constructor, pero digamos que no tiene, jejejeje if (hijos.Count > 0) { nodoModelo hijo = hijos[0]; _LST_VAL lstval = (_LST_VAL)hijo; lstValores2 = lstval.getLstValores(elementoEntor); //me tiene que devolver una lista de valores, } ObjClase.ejecutarGlobales(); //cargando sus valores globales // jlk ObjClase.ejecutarConstructor(lstAtributos.getToken(1), 0, lstValores2, ObjClase.tablaEntorno.raiz); //println("ejecutando constructor de la claes, new objeto()"); retorno.setValue(ObjClase, lstAtributos.getToken(1).valLower); retorno.setTypeObjeto(tokInstancia.valLower); //println("Es un objeto"); return(retorno); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede instanaciar la clase:" + tokInstancia.valLower + ", para crear el objeto, debido a que no se existe la clase ", tokInstancia); } return(retorno); } } if (hijos.Count > 0) { nodoModelo hijo = hijos[0]; switch (hijo.nombre) { case "PREGUNTA_NATIVA": _PREGUNTA_NATIVA preg = (_PREGUNTA_NATIVA)hijo; return(preg.getValor(elementoEntor)); case "TIPO": if (hayErrores()) { return(retorno); } /* |-------------------------------------------------------------------------- | ARREGLO |-------------------------------------------------------------------------- | Hay que mapear las variables para inicializar el array valores de item | Estoy definiendo las dimensiones del arreglo | tNuevo + TIPO + LST_CORCHETES_VAL | | | String[][] hola = new String[3][2]; | | String[] jejej = new String[12]; | int[][] jeje = { new int[12], { 2, 2 } }; | | int[][][] numeros = {{3,3,3},{2,2,2},{1,1,1}, {4,4,4},{5,5,5},{6,6,6}}; | hola = jejej;*/ nodoModelo tempTipo = getNodo("TIPO"); _TIPO nodoTipo = (_TIPO)tempTipo; retorno.setType(nodoTipo.getTipo().valLower); token item1 = lstAtributos.listaAtributos[0].tok; nodoModelo temp1 = getNodo("LST_CORCHETES_VAL"); if (temp1 != null) { _LST_CORCHETES_VAL lstVal = (_LST_CORCHETES_VAL)temp1; List <int> tempLstInt = lstVal.getLstInt(elementoEntor, item1); int dimensionMaxima = 1; foreach (int elemento in tempLstInt) { // println("dimen: " + elemento); if (elemento != 0) { dimensionMaxima = dimensionMaxima * elemento; } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede inicializar una matriz con tamaño 0", item1); } } //llenando la lista de nulos Dictionary <int, itemValor> diccionario = new Dictionary <int, itemValor>(); for (int i = 0; i < dimensionMaxima; i++) { diccionario.Add(i, new itemValor()); } retorno.setArrayTipo(tempLstInt, diccionario, tipo.valLower); //println("La dimensión mapeada -> indice máximo es " + retorno.arrayValores.Count); //tengo que mapear // sf } //println(itEntorno.nombre.valLower + "-> tNuevo + TIPO + LST_CORCHETES_VAL"); return(retorno); case "LST_LLAVES_VAL": /* |-------------------------------------------------------------------------- | ARREGLO |-------------------------------------------------------------------------- | Le estoy enviando directamente los valores al arreglo | LST_LLAVES_VAL esto retorna=Dictionary<int, itemValor> | */ nodoModelo tempLstLlaves = getNodo("LST_LLAVES_VAL"); _LST_LLAVES_VAL nodoLstLlaves = (_LST_LLAVES_VAL)tempLstLlaves; nodoLstLlaves.getArray(tipo, elementoEntor); int arrayLengthMapeado = getDimensionMapeada(nodoLstLlaves.lstDimensiones, tipo); if (arrayLengthMapeado == nodoLstLlaves.diccionario.Count) //se puede agregar correctamente { itemValor retorno2 = new itemValor(); retorno2.setType(tipo.valLower); retorno2.arrayValores = nodoLstLlaves.diccionario; retorno2.dimensiones = nodoLstLlaves.lstDimensiones; return(retorno2); } else { println("Hay problema en las dimensiones del arreglo" + tipo.linea); } return(retorno); case "E": /* |-------------------------------------------------------------------------- | E |-------------------------------------------------------------------------- */ _E ope = (_E)hijo; return(ope.getValor(elementoEntor)); default: println(hijo.nombre + "->No se reconoció la producción :("); return(retorno); } } else /* |---------------------------- | tNulo | tEste */ { String item1 = lstAtributos.listaAtributos[0].nombretoken; if (item1.Equals("tEste")) { itemValor it = new itemValor(); it.setTypeObjeto(elementoEntor.este.cuerpoClase.nombreClase.valLower); it.setValue(elementoEntor.este, elementoEntor.este.cuerpoClase.nombreClase.valLower); return(it); } else { /* |-------------------------------------------------------------------------- | return nulo |-------------------------------------------------------------------------- | tNulo */ return(retorno); } } }
public List <int> getLstInt(elementoEntorno tablaEntor, token nombreVar) { List <int> retorno = new List <int>(); foreach (nodoModelo temp in hijos) { //tiene que ser de dimensión cero prro if (hayErrores()) { return(retorno); } _PAR_CORCHETES_VAL par = (_PAR_CORCHETES_VAL)temp; itemValor te = par.getValor(tablaEntor, nombreVar); if (te.isTypeBooleano()) { if (te.getBooleano()) { retorno.Add(1); } else { retorno.Add(0); } } else if (te.isTypeDecimal()) { int valor = Convert.ToInt32(te.getDecimal()); if (valor >= 0) { retorno.Add(valor); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede crear una matriz con tamaño negativo", nombreVar); return(retorno); } } else if (te.isTypeEntero()) { if (te.getEntero() >= 0) { // println("Agreando:" + te.getEntero()); retorno.Add(te.getEntero()); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede crear una matriz con tamaño negativo", nombreVar); return(retorno); } } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede crear una matriz con tamaño de tipo : " + te.getTipo(), nombreVar); return(retorno); } } return(retorno); }
/* |------------------------------------------------------------------------------------------------------------------- | EJECUCIÓN FINAL |------------------------------------------------------------------------------------------------------------------- | */ public override itemRetorno ejecutar(elementoEntorno elementoEntor) /* |---------------------------- | EJECUTAR |---------------------------- | 0 = normal | 1 = return; | 2 = break | 3 = continue | 4 = errores */ { itemRetorno retorno = new itemRetorno(0); if (hayErrores()) { return(retorno); } _E nodoE = (_E)getNodo("E"); itemValor valE = nodoE.getValor(elementoEntor); 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); } if (hijos.Count == 2) /* |---------------------------- | tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave */ { if (condicion) { _LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO"); elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino_Si", elementoEntor.este); return(nodoCuerpo.ejecutar(entornoIf)); } } else if (hijos.Count == 3) { string caso = hijos[2].nombre; if (caso.Equals("SINO_SI")) /* |---------------------------- | tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO_SI */ { if (condicion) { _LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO"); elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino_Si", elementoEntor.este); return(nodoCuerpo.ejecutar(entornoIf)); } else { _SINO_SI sino_si = (_SINO_SI)getNodo("SINO_SI"); return(sino_si.ejecutar(elementoEntor)); } } else if (caso.Equals("SINO")) /* |---------------------------- | tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO; */ { if (condicion) { _LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO"); elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino_si", elementoEntor.este); return(nodoCuerpo.ejecutar(entornoIf)); } else { _SINO nodoSINO = (_SINO)getNodo("SINO"); elementoEntorno entornoSino = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino", elementoEntor.este); return(nodoSINO.ejecutar(entornoSino)); } } } return(retorno); }
public void getArray2(Dictionary <int, itemValor> diccionario, List <int> dimensioenes, token tipo, int dimensionActual, elementoEntorno elemEntor) { if (hayErrores()) { return; } //hay que contar cuántos hijos tiene, esa es una dimensión foreach (nodoModelo temp in hijos) { _LLAVES_VAL_P llaves = (_LLAVES_VAL_P)temp; if (dimensionActual > dimensioenes.Count) //voy a corroborar si ya hay un indice ingresado { dimensioenes.Add(hijos.Count); } else //indica que el indice ya esta, hay que corroborar si tiene la misma cantidad de hijos // dimensionActual-1 { if (dimensioenes[dimensionActual - 1] != hijos.Count) //hay problema con la cantidad de hijos { tablaSimbolos.tablaErrores.insertErrorSemantic("No coincide el tamaño de la dimension: " + dimensionActual + " en la matriz de tipo: " + tipo.val, tipo); } } llaves.getArray(diccionario, dimensioenes, tipo, dimensionActual, elemEntor); } return; }
/* |------------------------------------------------------------------------------------------------------------------- | EJECUCIÓN FINAL |------------------------------------------------------------------------------------------------------------------- | */ public itemValor opIgualacion(itemValor val1, itemValor val2, String ambito, elementoEntorno elem) { itemValor retorno = new itemValor(); if (val1 == null) { tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + "Hijo1 es null", new token("--")); return(retorno); } if (val2 == null) { tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + " Hijo1 es null", new token("--")); return(retorno); } println("----al principio---"); println("val1->" + val1.getTipo()); println("val2->" + val2.getTipo()); try { /* |-------------------------------------------------------------------------- | Booleano |-------------------------------------------------------------------------- */ /* * Booleano == Booleano */ if (val1.isTypeBooleano() && val2.isTypeBooleano()) { if (val1.getBooleano() == val2.getBooleano()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Booleano == Entero */ else if (val1.isTypeBooleano() && val2.isTypeEntero()) { int entero1 = 0; if (val1.getBooleano()) { entero1 = 1; } else { entero1 = 0; } if (entero1 == val2.getEntero()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Booleano == Decimal */ else if (val1.isTypeBooleano() && val2.isTypeDecimal()) { Double entero1 = 0.0; if (val1.getBooleano()) { entero1 = 1.0; } else { entero1 = 0.0; } if (entero1 == val2.getDecimal()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Booleano == Cadena */ else if (val1.isTypeBooleano() && val2.isTypeCadena()) { int entero1 = 0; if (val1.getBooleano()) { entero1 = 1; } else { entero1 = 0; } if (entero1 == val2.getCadena().Length) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* |-------------------------------------------------------------------------- | Entero |-------------------------------------------------------------------------- */ /* * Entero == Booleano */ else if (val1.isTypeEntero() && val2.isTypeBooleano()) { int entero2 = 0; if (val2.getBooleano()) { entero2 = 1; } else { entero2 = 0; } if (val1.getEntero() == entero2) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Entero == Entero */ else if (val1.isTypeEntero() && val2.isTypeEntero()) { if (val1.getEntero() == val2.getEntero()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Entero == Decimal */ else if (val1.isTypeEntero() && val2.isTypeDecimal()) { Double num2 = val2.getDecimal(); int valInt2 = (int)Math.Truncate(num2); if (val1.getEntero() == valInt2) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Entero == Cadena * */ else if (val1.isTypeEntero() && val2.isTypeCadena()) { if (val1.getEntero() == val2.getCadena().Length) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* |-------------------------------------------------------------------------- | Cadena |-------------------------------------------------------------------------- */ /* * Cadena * Booleano = Cadena */ else if (val1.isTypeCadena() && val2.isTypeBooleano()) { int entero2 = 0; if (val2.getBooleano()) { entero2 = 1; } else { entero2 = 0; } if (val1.getCadena().Length == entero2) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Cadena == Numerico */ else if (val1.isTypeCadena() && val2.isTypeEntero()) { if (val1.getCadena().Length == val2.getEntero()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Cadena == Decimal */ else if (val1.isTypeCadena() && val2.isTypeDecimal()) { if (val1.getCadena().Length == val2.getDecimal()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Cadena == Cadena */ else if (val1.isTypeCadena() && val2.isTypeCadena()) { if (val1.getCadena().Equals(val2.getCadena())) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* |-------------------------------------------------------------------------- | Decimal |-------------------------------------------------------------------------- */ /* * Decimal == Booleano */ else if (val1.isTypeDecimal() && val2.isTypeBooleano()) { Double entero2 = 0.0; if (val2.getBooleano()) { entero2 = 1.0; } else { entero2 = 0.0; } if (val1.getDecimal() == entero2) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Decimal == Numerico */ else if (val1.isTypeDecimal() && val2.isTypeEntero()) { int valInt1 = (int)Math.Truncate(val1.getDecimal()); if (valInt1 == val2.getEntero()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Decimal == Cadena */ else if (val1.isTypeDecimal() && val2.isTypeCadena()) { if (val1.getDecimal() == val2.getCadena().Length) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Decimal == Decimal */ else if (val1.isTypeDecimal() && val2.isTypeDecimal()) { if (val1.getDecimal() == val2.getDecimal()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* |-------------------------------------------------------------------------- | Comparando tipo date |-------------------------------------------------------------------------- */ /* * FechaHora == Fecha */ else if ((val1.isTypeFechaHora() || val1.isTypeFecha() || val1.isTypeHora()) && (val2.isTypeFechaHora() || val2.isTypeFecha() || val2.isTypeHora())) { if (val1.getFechaHora() == val2.getFechaHora()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* |-------------------------------------------------------------------------- | NULO |-------------------------------------------------------------------------- */ /* * Nulo == Nulo */ else if (val1.isTypeNulo() && val2.isTypeNulo()) { retorno.setValue(true); println("Si se recoocieron los tipos"); println("val1->" + val1.getTipo()); println("val2->" + val2.getTipo()); return(retorno); } else { println("No se recoocieron los tipos"); println("val1->" + val1.getTipo()); println("val2->" + val2.getTipo()); if (val1.valor.Equals(val2.valor)) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); //tabla.tablaErrores.insertErrorSemantic("No se pueden operar [" + ambito + "] " + val1.getTipo() + " con " + val2.getTipo(), signo); } } catch (Exception) { tabla.tablaErrores.insertErrorSemantic("[opRelacional]No se pudo efectuar [" + ambito + " ]", signo); } return(retorno); }
public itemValor opPotencia(elementoEntorno elem) { itemValor retorno = new itemValor(); itemValor val1 = hijo1.getValor(elem); itemValor val2 = hijo2.getValor(elem); if (val1 == null) { tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--")); return(retorno); } if (val2 == null) { tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--")); return(retorno); } try { /* |-------------------------------------------------------------------------- | Booleano |-------------------------------------------------------------------------- */ /* * Booleano ^ Booleano = Booleano */ /* * Booleano ^ Entero = Entero */ if (val1.isTypeBooleano() && val2.isTypeEntero()) { Double entero1 = 0.0; if (val1.getBooleano()) { entero1 = 1.0; } else { entero1 = 0.0; } retorno.setTypeDecimal(); retorno.valor = Math.Pow(entero1, (Double)val2.getEntero()); } /* * Booleano ^ Decimal = Decimal */ else if (val1.isTypeBooleano() && val2.isTypeDecimal()) { Double entero1 = 0.0; if (val1.getBooleano()) { entero1 = 1.0; } else { entero1 = 0.0; } retorno.setTypeDecimal(); retorno.valor = Math.Pow(entero1, val2.getDecimal()); } /* * Booleano^ Cadena = Cadena */ /* |-------------------------------------------------------------------------- | Entero |-------------------------------------------------------------------------- */ /* * Entero ^ Booleano = Entero */ else if (val1.isTypeEntero() && val2.isTypeBooleano()) { Double entero2 = 0.0; if (val2.getBooleano()) { entero2 = 1.0; } else { entero2 = 0.0; } retorno.setTypeDecimal(); retorno.valor = Math.Pow((Double)val1.getEntero(), entero2); } /* * Entero / Entero = Entero */ else if (val1.isTypeEntero() && val2.isTypeEntero()) { retorno.setTypeDecimal(); retorno.valor = Math.Pow((Double)val1.getEntero(), (Double)val2.getEntero()); } /* * Entero / Decimal = Decimal */ else if (val1.isTypeEntero() && val2.isTypeDecimal()) { retorno.setTypeDecimal(); retorno.valor = Math.Pow((Double)val1.getEntero(), val2.getDecimal()); } /* * Entero / Cadena = Cadena */ /* |-------------------------------------------------------------------------- | Cadena |-------------------------------------------------------------------------- */ /* * Cadena / Booleano = Cadena */ /* * Cadena / Numerico = Cadena */ /* * Cadena / Decimal = Cadena */ /* * Cadena / Cadena = Cadena */ /* |-------------------------------------------------------------------------- | Decimal |-------------------------------------------------------------------------- */ /* * Decimal / Booleano = Decimal */ else if (val1.isTypeDecimal() && val2.isTypeBooleano()) { Double entero2 = 0.0; if (val2.getBooleano()) { entero2 = 1.0; } else { entero2 = 0.0; } retorno.setTypeDecimal(); retorno.valor = Math.Pow(val1.getDecimal(), entero2); } /* * Decimal / Numerico = Decimal */ else if (val1.isTypeDecimal() && val2.isTypeEntero()) { retorno.setTypeDecimal(); retorno.valor = Math.Pow(val1.getDecimal(), (Double)val2.getEntero()); } /* * Decimal / Cadena = Cadena */ /* * Decimal / Decimal = Decimal */ else if (val1.isTypeDecimal() && val2.isTypeDecimal()) { if (val2.getDecimal() == 0.0) { tabla.tablaErrores.insertErrorSemantic("No puede haber denominador cero", signo); return(retorno); } retorno.setTypeDecimal(); retorno.valor = Math.Pow(val1.getDecimal(), val2.getDecimal()); } else { tabla.tablaErrores.insertErrorSemantic("No se pueden operar la [Potencia] " + val1.getTipo() + " elevado a " + val2.getTipo(), signo); } //aquí hay que parsear los objetos } catch (Exception e) { tabla.tablaErrores.insertErrorSemantic("[opAritmeticaSuma]No se pudo efectuar la potencia", signo); } 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); } }
public itemRetorno ejecutar(elementoEntorno elementoEntor, itemValor expresion) /* |---------------------------- | EJECUTAR |---------------------------- | 0 = normal | 1 = return; | 2 = break | 3 = continue | 4 = errores */ { itemRetorno retorno = new itemRetorno(0); if (hayErrores()) { return(retorno); } if (hijos.Count == 3) /* |---------------------------- | E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave + CUERPO_CASE */ { _E nodoE = (_E)getNodo("E"); itemValor valE = nodoE.getValor(elementoEntor); IgualQue igual = new IgualQue(new _E("temp1", tablaSimbolos), new _E("temp2", tablaSimbolos), tablaSimbolos, new token("=")); itemValor resultado = igual.opIgualacion(expresion, valE, "IGUALACION", elementoEntor); Object objetoValor = resultado.getValorParseado("booleano"); Boolean condicion = false; if (objetoValor != null) { condicion = (Boolean)objetoValor; if (condicion) { _LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO"); itemRetorno break1 = nodoCuerpo.ejecutar(elementoEntor); //voy a revisar si no hay break prro if (break1.isRomper()) { println("es romper"); itemRetorno ret2 = new itemRetorno(0); //asi retorno un normal return(ret2); //aquí rompo prro } else { println("no es romper"); _CUERPO_CASE cuerpoCase = (_CUERPO_CASE)getNodo("CUERPO_CASE"); return(cuerpoCase.ejecutar(elementoEntor, expresion)); } } else { println("ejecutando cuerpo clase"); _CUERPO_CASE sino_si = (_CUERPO_CASE)getNodo("CUERPO_CASE"); return(sino_si.ejecutar(elementoEntor, expresion)); } } else { println("E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave + CUERPO_CASE-> No se retorno un boolenano en la igualación"); return(retorno); } } else if (hijos.Count == 2) /* |---------------------------- | E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave */ { _E nodoE = (_E)getNodo("E"); itemValor valE = nodoE.getValor(elementoEntor); IgualQue igual = new IgualQue(new _E("temp1", tablaSimbolos), new _E("temp2", tablaSimbolos), tablaSimbolos, new token("=")); itemValor resultado = igual.opIgualacion(expresion, valE, "IGUALACION", elementoEntor); Object objetoValor = resultado.getValorParseado("booleano"); Boolean condicion = false; if (objetoValor != null) { condicion = (Boolean)objetoValor; if (condicion) { _LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO"); return(nodoCuerpo.ejecutar(elementoEntor)); } else { return(retorno); } } else { println(" E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave -> No se retorno un boolenano en la igualación"); return(retorno); } } else if (hijos.Count == 1) /* |---------------------------- | tDefecto + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave; */ { _LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO"); return(nodoCuerpo.ejecutar(elementoEntor)); } else { 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 != 2) { return(retorno); } String tipo2 = "entero"; _E nodoE2 = (_E)hijos[0]; _E nodoE3 = (_E)hijos[1]; if (hayErrores()) { return(retorno); } int inicioVal = 0; int finalVal = 0; itemValor itemInicio = nodoE2.getValor(elem); Object inicioTemp = itemInicio.getValorParseado(tipo2); itemValor itemFinal = nodoE3.getValor(elem); Object finalTemp = itemFinal.getValorParseado(tipo2); if (inicioTemp != null) { inicioVal = (int)inicioTemp; } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a entero el valor", lstAtributos.getToken(0)); return(retorno); } if (finalTemp != null) { finalVal = (int)finalTemp; } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a entero el valor", lstAtributos.getToken(0)); return(retorno); } if (inicioVal == 0 || finalVal == 0) { tablaSimbolos.tablaErrores.insertErrorSemantic("Potencia con base 0 elevado a 0 es indeterminado", lstAtributos.getToken(0)); return(retorno); } retorno.setValue(Math.Pow(inicioVal, finalVal)); return(retorno); }
/* |------------------------------------------------------------------------------------------------------------------- | EJECUCIÓN FINAL |------------------------------------------------------------------------------------------------------------------- | */ public override itemRetorno ejecutar(elementoEntorno elementoEntor) { itemRetorno retorno = new itemRetorno(0); return(retorno); }
/* |------------------------------------------------------------------------------------------------------------------- | EJECUCIÓN DE METODO |------------------------------------------------------------------------------------------------------------------- | */ public itemValor getMetodoFuncion(token nombre, lstValores parametros, elementoEntorno tablaEntorno, String nombreAmbitoEntorno) { itemValor retorno = new itemValor(); retorno.setTypeVacio(); //aqui es donde tengo que buscar si existe Console.WriteLine("ejecutando Metodo:" + nombre.val); elementoPolimorfo temp = getElementoPolimorfo2(nombre, parametros); if (temp != null) //neuvo entorno { elementoEntorno hijo1 = new elementoEntorno(tablaEntorno, tabla, nombreAmbitoEntorno, tablaEntorno.este); guardarParametrosEnLaTabla(temp.lstParametros, parametros, hijo1); if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO")) /* |---------------------------- | Ejecutando el cuerpo del metodo */ /* |---------------------------- | EJECUTAR |---------------------------- | 0 = normal | 1 = return; | 2 = break | 3 = continue | 4 = errores */ { _LST_CUERPO val = (_LST_CUERPO)temp.LST_CUERPO; itemRetorno result = val.ejecutar(hijo1); if (temp.tipo.valLower.Equals("vacio")) { if (result.isNormal())//que es el normal { } else if (result.isRetorno()) { if (result.valor.isTypeVacio()) //fue el return normla, sin expresion { } else { tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " está declarado como vacio, pero se retorno una expresión", temp.nombre); } } else { } } else /* | 0 = normal | 1 = return; | 2 = break | 3 = continue | 4 = errores */ { if (result.isNormal()) { tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " debe de retorar un valor", temp.nombre); } else if (result.isRetorno()) { if (temp.dimension == result.valor.dimensiones.Count) { //para los tipos if (itemEntorno.validandoTipo(temp.tipo.valLower, result.valor)) { return(result.valor); } else { tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " es de tipo :" + temp.tipo.val + " sin embargo tiene un retorno de tipo: " + result.valor.getTipo(), temp.nombre); return(retorno); } } else { tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " es de dimensión :" + temp.dimension + " sin embargo tiene un retorno de dimensión: " + result.valor.dimensiones.Count, temp.nombre); return(retorno); } } else { } } ///hay que comparar el retorno con el tipo definido } //Console.WriteLine("---------------------------Imprimiendo el metodo Funcion-------------------------"); //hijo1.imprimir(); } 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); //ya estoy recibiendo la tabla donde debo trabajar prro if (hayErrores()) { return(retorno); } _VALOR val = getNodoVALOR(); if (val != null) { //se estan guardando valores en la variable // println("Ejecutando el imprimir que tiene un hijo de valore ejejejejejejejejej"); itemValor temp = val.getValor(tablaEntornos, new token()); if (temp.isTypeNulo()) { tablaSimbolos.consola.insertar("nulo"); } else { if (tablaSimbolos.consola != null) { if (temp.valor != null) { try { tablaSimbolos.consola.insertar(temp.valor.ToString()); } catch (Exception e) { tablaSimbolos.consola.insertar(e.ToString()); } } //tablaSimbolos.consola.insertar("imprimiendo"); } else { println("tablaSimblo.consola is null"); } // } } else { tablaSimbolos.consola.insertar(""); } return(retorno); }
public itemValor opMayorQue(String ambito, elementoEntorno elem) { itemValor retorno = new itemValor(); itemValor val1 = hijo1.getValor(elem); itemValor val2 = hijo2.getValor(elem); if (val1 == null) { tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + "Hijo1 es null", new token("--")); return(retorno); } if (val2 == null) { tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + " Hijo1 es null", new token("--")); return(retorno); } try { /* |-------------------------------------------------------------------------- | Booleano |-------------------------------------------------------------------------- */ /* * Booleano > Booleano */ if (val1.isTypeBooleano() && val2.isTypeBooleano()) { tabla.tablaErrores.insertErrorSemantic("No se pueden comparar valores booleanos [" + ambito + "] " + val1.getTipo() + " == " + val2.getTipo(), signo); return(retorno); } /* * Booleano > Entero */ else if (val1.isTypeBooleano() && val2.isTypeEntero()) { int entero1 = 0; if (val1.getBooleano()) { entero1 = 1; } else { entero1 = 0; } if (entero1 > val2.getEntero()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Booleano > Decimal */ else if (val1.isTypeBooleano() && val2.isTypeDecimal()) { Double entero1 = 0.0; if (val1.getBooleano()) { entero1 = 1.0; } else { entero1 = 0.0; } if (entero1 > val2.getDecimal()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Booleano > Cadena */ else if (val1.isTypeBooleano() && val2.isTypeCadena()) { int entero1 = 0; if (val1.getBooleano()) { entero1 = 1; } else { entero1 = 0; } if (entero1 > val2.getCadena().Length) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* |-------------------------------------------------------------------------- | Entero |-------------------------------------------------------------------------- */ /* * Entero > Booleano */ else if (val1.isTypeEntero() && val2.isTypeBooleano()) { int entero2 = 0; if (val2.getBooleano()) { entero2 = 1; } else { entero2 = 0; } if (val1.getEntero() > entero2) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Entero > Entero */ else if (val1.isTypeEntero() && val2.isTypeEntero()) { if (val1.getEntero() > val2.getEntero()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Entero > Decimal */ else if (val1.isTypeEntero() && val2.isTypeDecimal()) { Double num2 = val2.getDecimal(); int valInt2 = (int)Math.Truncate(num2); if (val1.getEntero() > valInt2) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Entero > Cadena * */ else if (val1.isTypeEntero() && val2.isTypeCadena()) { if (val1.getEntero() > val2.getCadena().Length) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* |-------------------------------------------------------------------------- | Cadena |-------------------------------------------------------------------------- */ /* * Cadena * Booleano = Cadena */ else if (val1.isTypeCadena() && val2.isTypeBooleano()) { int entero2 = 0; if (val2.getBooleano()) { entero2 = 1; } else { entero2 = 0; } if (val1.getCadena().Length > entero2) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Cadena > Numerico */ else if (val1.isTypeCadena() && val2.isTypeEntero()) { if (val1.getCadena().Length > val2.getEntero()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Cadena > Decimal */ else if (val1.isTypeCadena() && val2.isTypeDecimal()) { if (val1.getCadena().Length > val2.getDecimal()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Cadena > Cadena */ else if (val1.isTypeCadena() && val2.isTypeCadena()) { if (val1.getCadena().Length > val2.getCadena().Length) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* |-------------------------------------------------------------------------- | Decimal |-------------------------------------------------------------------------- */ /* * Decimal > Booleano */ else if (val1.isTypeDecimal() && val2.isTypeBooleano()) { Double entero2 = 0.0; if (val2.getBooleano()) { entero2 = 1.0; } else { entero2 = 0.0; } if (val1.getDecimal() > entero2) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Decimal > Numerico */ else if (val1.isTypeDecimal() && val2.isTypeEntero()) { int valInt1 = (int)Math.Truncate(val1.getDecimal()); if (valInt1 > val2.getEntero()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Decimal > Cadena */ else if (val1.isTypeDecimal() && val2.isTypeCadena()) { if (val1.getDecimal() > val2.getCadena().Length) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Decimal > Decimal */ else if (val1.isTypeDecimal() && val2.isTypeDecimal()) { if (val1.getDecimal() > val2.getDecimal()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* |-------------------------------------------------------------------------- | Comparando tipo date |-------------------------------------------------------------------------- */ /* * FechaHora > Fecha */ else if ((val1.isTypeFechaHora() || val1.isTypeFecha() || val1.isTypeHora()) && (val2.isTypeFechaHora() || val2.isTypeFecha() || val2.isTypeHora())) { if (val1.getFechaHora() > val2.getFechaHora()) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } else { tabla.tablaErrores.insertErrorSemantic("No se pueden operar [" + ambito + "] " + val1.getTipo() + " con " + val2.getTipo(), signo); } } catch (Exception) { tabla.tablaErrores.insertErrorSemantic("[opAritmeticaSuma]No se pudo efectuar [" + ambito + " ]", signo); } return(retorno); }
/* |-------------------------------------------------------------------------- | La ejecución FINAL con ITem entorno |-------------------------------------------------------------------------- | | | | public virtual void ejecutar(elementoEntorno elem, itemEntorno item) | { | ejecutarHijos(elem, item); | } | | public void ejecutarHijos(elementoEntorno elem, itemEntorno item) | { | | if (hayErrores()) | return; | | foreach (nodoModelo temp in hijos) | { | temp.ejecutar(elem, item); | } | }*/ /* |-------------------------------------------------------------------------- | La ejecución FINAL |-------------------------------------------------------------------------- | 0= normal | 1 = return; | 2 = break | 3 = continue | 4 = errores */ public virtual itemRetorno ejecutar(elementoEntorno tablaEntornos) { itemRetorno resultado = ejecutarHijos(tablaEntornos); return(resultado); }
/* |------------------------------------------------------------------------------------------------------------------- | Funciones ope Tipo |------------------------------------------------------------------------------------------------------------------- | */ public override itemValor ope_tipo(elementoEntorno elem) { itemValor retorno = new itemValor(); retorno.setTypeNulo(); if (hayErrores()) { return(retorno); } if (hijos.Count != 2) { return(retorno); } String tipo1 = "cadena"; String tipo2 = "entero"; _E nodoE1 = (_E)hijos[0]; _E nodoE2 = (_E)hijos[1]; if (hayErrores()) { return(retorno); } String cadenaVal = ""; int inicioVal = 0; itemValor itemCadena = nodoE1.getValor(elem); Object cadenaTemp = itemCadena.getValorParseado(tipo1); itemValor itemInicio = nodoE2.getValor(elem); Object inicioTemp = itemInicio.getValorParseado(tipo2); if (cadenaTemp != null) { cadenaVal = (String)cadenaTemp; } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a cadena el valor", lstAtributos.getToken(0)); return(retorno); } if (inicioTemp != null) { inicioVal = (int)inicioTemp; } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a entero el valor", lstAtributos.getToken(0)); return(retorno); } if ((inicioVal) > cadenaVal.Length || (inicioVal) < 0) { tablaSimbolos.tablaErrores.insertErrorSemantic("El indice superior supera la longitud de la cadena", lstAtributos.getToken(0)); return(retorno); } Char[] temp1 = cadenaVal.ToCharArray(); String salida = temp1[inicioVal].ToString(); retorno.setValue(salida); 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) /* |---------------------------- | ID_VAR_FUNC + VAL */ { //PUNTERO DONDE VOY A GUARDAR EL VALOR _ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC"); itemEntorno destino = nodoFunc.getDestino(tablaEntornos); //AHORA OBTENGO EL VALOR _VAL nodoVal = (_VAL)getNodo("VAL"); if (nodoVal != null) { if (destino != null) { itemValor valor = nodoVal.getValor(tablaEntornos, destino.tipo); if (destino.lstDimensionesAcceso.Count > 0) //viene la posición de un arreglo { asignarValorMatriz(destino, valor); } else { asignarValor(destino, valor); } } else { println("Me retorno un itemEntorno vacio, no podré asignar la variable prro"); } } else { println("no tiene nodo VAl"); } } else if (hijos.Count == 1) { if (lstAtributos.getToken(0).valLower.Equals("+")) /* |---------------------------- | ID_VAR_FUNC + sMas + sMas */ { if (hayErrores()) { return(retorno); } _ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC"); itemEntorno destino = nodoFunc.getDestino(tablaEntornos); if (destino.lstDimensionesAcceso.Count > 0) //viene la posición de un arreglo { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede incrementar la matriz " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre); } else { itemValor valor = nodoFunc.getValor(tablaEntornos); itemValor valor2 = new itemValor(); valor2.setValue(1); suma sumatoria = new suma(new _E("hijo1", tablaSimbolos), new _E("hijo2", tablaSimbolos), tablaSimbolos, lstAtributos.getToken(0)); itemValor resultado = sumatoria.opSumaExterna(tablaEntornos, valor, valor2); Object ObjParseado = resultado.getValorParseado(destino.tipo.valLower); if (ObjParseado != null) { destino.valor.valor = ObjParseado; return(retorno); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede asignar un tipo :" + sumatoria.GetType() + " a la variable " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre); return(retorno); } } } else /* |---------------------------- | ID_VAR_FUNC + smenos + smenos */ { if (hayErrores()) { return(retorno); } _ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC"); itemEntorno destino = nodoFunc.getDestino(tablaEntornos); if (destino.lstDimensionesAcceso.Count > 0) //viene la posición de un arreglo { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede incrementar la matriz " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre); } else { itemValor valor = nodoFunc.getValor(tablaEntornos); itemValor valor2 = new itemValor(); valor2.setValue(1); resta sumatoria = new resta(new _E("hijo1", tablaSimbolos), new _E("hijo2", tablaSimbolos), tablaSimbolos, lstAtributos.getToken(0)); itemValor resultado = sumatoria.opRestaExterna(tablaEntornos, valor, valor2); Object ObjParseado = resultado.getValorParseado(destino.tipo.valLower); if (ObjParseado != null) { destino.valor.valor = ObjParseado; return(retorno); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede asignar un tipo :" + sumatoria.GetType() + " a la variable " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre); return(retorno); } } } } return(retorno); }
public override itemRetorno ejecutar(elementoEntorno elementoEntor) /* |---------------------------- | EJECUTAR |---------------------------- | 0 = normal | 1 = return; | 2 = break | 3 = continue | 4 = errores */ { itemRetorno retorno = new itemRetorno(0); if (hayErrores()) { return(retorno); } _E nodoE = (_E)getNodo("E"); itemValor valE = nodoE.getValor(elementoEntor); 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); } while (condicion) { _LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO"); elementoEntorno entornoWhile = new elementoEntorno(elementoEntor, tablaSimbolos, "While", elementoEntor.este); retorno = nodoCuerpo.ejecutar(entornoWhile); //analizando el continue, el break, y el return if (retorno.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 if (retorno.isRetorno()) { return(retorno); } else if (retorno.isContinuar()) { return(new itemRetorno(0)); //retorno = new itemRetorno(0); } else if (hayErrores()) { return(retorno); } //volviendo analizar el while nodoE = (_E)getNodo("E"); valE = nodoE.getValor(elementoEntor); objetoValor = valE.getValorParseado("booleano"); condicion = (Boolean)objetoValor; } if (retorno.isContinuar()) { return(new itemRetorno(0)); } return(retorno); }
public itemValor opIgualacion22(String ambito, elementoEntorno elem) { itemValor retorno = new itemValor(); itemValor val1 = hijo1.getValor(elem); itemValor val2 = hijo2.getValor(elem); if (val1 == null) { tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + "Hijo1 es null", new token("--")); return(retorno); } if (val2 == null) { tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + " Hijo1 es null", new token("--")); return(retorno); } /* |-------------------------------------------------------------------------- | Booleano |-------------------------------------------------------------------------- */ /* * Booleano + Booleano = Booleano * * if (val1.isTypeBooleano() && val2.isTypeBooleano()) * { * tabla.tablaErrores.insertErrorSemantic("No se pueden comparar valores booleanos [" + ambito + "] " + val1.getTipo() + " == " + val2.getTipo(), signo); * * * return retorno; * }*/ /* * Decimal + Numerico = Decimal */ else if (val1.isTypeDecimal() && val2.isTypeEntero()) { Double num1 = val1.getDecimal(); int valInt1 = (int)Math.Truncate(num1); if (valInt1.Equals(val2.getEntero())) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } /* * Entero + Decimal = Decimal */ else if (val1.isTypeEntero() && val2.isTypeDecimal()) { Double num2 = val2.getDecimal(); int valInt2 = (int)Math.Truncate(num2); if (valInt2.Equals(val1.getEntero())) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } else { if (val1.valor.Equals(val2.valor)) { retorno.setValue(true); } else { retorno.setValue(false); } return(retorno); } }
public void getArray(Dictionary <int, itemValor> diccionario, List <int> dimensioenes, token tipo, int dimensionActual, elementoEntorno elemEntor) { if (hayErrores()) { return; } if (hijos.Count > 0) { nodoModelo temp = hijos[0]; if (temp.nombre.Equals("LST_LLAVES_VAL")) { _LST_LLAVES_VAL lstLlaves = (_LST_LLAVES_VAL)temp; dimensionActual++; //incremento la dimensio lstLlaves.getArray2(diccionario, dimensioenes, tipo, dimensionActual, elemEntor); return; } else if (temp.nombre.Equals("LST_VAL")) { dimensionActual++; _LST_VAL lstVal = (_LST_VAL)temp; lstValores lstVals = lstVal.getLstValores(elemEntor); if (dimensionActual > dimensioenes.Count) { dimensioenes.Add(lstVals.listaValores.Count); } else { if (dimensioenes[dimensionActual - 1] != lstVals.listaValores.Count) //hay problema con la cantidad de hijos { tablaSimbolos.tablaErrores.insertErrorSemantic("No coincide el tamaño de la matriz: " + dimensionActual, tipo); } } foreach (itemValor it in lstVals.listaValores) { //validando los tipos if (it.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 de tipo:" + tipo.val, tipo); return; } object objeto = it.getValorParseado(tipo.valLower); if (it.isTypeNulo()) { itemValor item = new itemValor(); item.setTypeNulo(); int dimensionArray = diccionario.Count; diccionario.Add(dimensionArray, item); } else if (it.isTypeObjeto()) { if (objeto == null) //no se pudo parsear { println("Es de tipo objeto, pero no coincidieron los nombres"); //retorno un error tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede introducir un tipo : " + it.getTipo() + " a una matriz de tipo : " + tipo.val, tipo); return; } else //si se pudo parsear { itemValor item = new itemValor(); item.setValue(objeto, tipo.valLower); //hay que insertarlo al diccionario int dimensionArray = diccionario.Count; diccionario.Add(dimensionArray, item); } //hay que validar si son los mismos tipos de objeto } else { if (objeto == null) //no se pudo parsear { /*if (tipo.val.Equals("--")) //no indicaron el tipo, asi que se vaya alv * { * * itemValor item = new itemValor(); * item.setType(it.getTipo()); * item.valor = objeto; * * //hay que insertarlo al diccionario * int dimensionArray = diccionario.Count; * diccionario.Add(dimensionArray, item); * * } * else * { * * //retorno un error * tablaSimbolos.tablaErrores.insertErrorSemantic("NO se puede introducir un tipo : " + it.getTipo() + " a una matriz de tipo : " + tipo.val, tipo); * return; * }*/ //retorno un error tablaSimbolos.tablaErrores.insertErrorSemantic("NO se puede introducir un tipo : " + it.getTipo() + " a una matriz de tipo : " + tipo.val, tipo); return; } else //si se pudo parsear { itemValor item = new itemValor(); item.setType(tipo.valLower); item.valor = objeto; //hay que insertarlo al diccionario int dimensionArray = diccionario.Count; diccionario.Add(dimensionArray, item); } } } int listaFinal = getDimensionMapeada(dimensioenes, tipo); // println("la lista mapeada es de longitud->" + listaFinal.ToString()); } } else { //tiene que ser error, ya que no se apceta si trae cer en una dimension } return; }
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 { /* |-------------------------------------------------------------------------- | Booleano |-------------------------------------------------------------------------- */ /* * Booleano */ if (val1.isTypeBooleano()) { retorno.setValue(!val1.getBooleano()); return(retorno); } /* |-------------------------------------------------------------------------- | Entero |-------------------------------------------------------------------------- */ /* * Entero */ else if (val1.isTypeEntero()) { int bool1 = 0; int val1R = val1.getEntero(); if (val1R == 0) { bool1 = 1; } else if (val1R == 1) { bool1 = 0; } else { tabla.tablaErrores.insertErrorSemantic("El entero: " + val1R + " no se puede parsear a un valor booleano", signo); return(retorno); } retorno.setValue(bool1); return(retorno); } /* |-------------------------------------------------------------------------- | Decimal |-------------------------------------------------------------------------- */ /* * Decimal */ else if (val1.isTypeDecimal()) { double bool1 = 0.0; double val1R = val1.getDecimal(); if (val1R == 0.0) { bool1 = 1.0; } else if (val1R == 1.0) { bool1 = 0.0; } else { tabla.tablaErrores.insertErrorSemantic("El decimal: " + val1R + " no se puede parsear a un valor booleano", signo); return(retorno); } retorno.setValue(bool1); return(retorno); } else { tabla.tablaErrores.insertErrorSemantic("No se pueden operar [" + ambito + "] " + val1.getTipo(), signo); } } catch (Exception) { tabla.tablaErrores.insertErrorSemantic("[opLogica]No se pudo efectuar [" + ambito + " ]", signo); } return(retorno); }