/* |------------------------------------------------------------------------------------------------------------------- | FORMULARiO |------------------------------------------------------------------------------------------------------------------- | */ public elementoPolimorfo getPolimorfo() { elementoPolimorfo retorno = null; if (hayErrores()) { return(retorno); } nodoModelo tempNodo = getNodo("TIPO"); if (tempNodo != null) { _TIPO temp = (_TIPO)tempNodo; nodoModelo temp2 = getNodo("VAR_ARREGLO"); if (temp2 != null) { _VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2; token visibilidad = new token("publico"); token tipo = temp.getTipo(); token nombre = tempVar.getIdentificador(); int dimensiones = tempVar.getDimensiones(); retorno = new elementoPolimorfo(visibilidad, tablaSimbolos, tipo, nombre, new _LST_CUERPO("LST_CUERPO", tablaSimbolos), dimensiones); return(retorno); } } return(retorno); }
public token getIdentificador() { token retorno = new token("--"); nodoModelo temp2 = getNodo("VAR_ARREGLO"); if (temp2 != null) { _VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2; retorno = tempVar.getIdentificador(); } return(retorno); }
public int getDimensiones() { int retorno = 0; nodoModelo temp2 = getNodo("VAR_ARREGLO"); if (temp2 != null) { _VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2; retorno = tempVar.getDimensiones(); } return(retorno); }
public _VAL getNodoVAL() { nodoModelo temp = getNodo("VAL"); if (temp != null) { return((_VAL)temp); } else { return(null); } }
public nodoModelo getLST_CUERPO() { nodoModelo tempNodo = getNodo("LST_CUERPO"); if (tempNodo != null) { return(tempNodo); } else { return(new nodoModelo("---", tablaSimbolos)); } }
public nodoModelo getVAL() { nodoModelo tempNodo = getNodo("VAL"); if (tempNodo != null) { return(tempNodo); } else { return(new nodoModelo("---", tablaSimbolos)); } }
public int getDimensiones() { int retorno = 0; nodoModelo tempNodo = getNodo("LST_CORCHETES"); if (tempNodo != null) { _LST_CORCHETES temp = (_LST_CORCHETES)tempNodo; return(temp.getDimension()); } return(retorno); }
public token getTipo() { nodoModelo tempNodo = getNodo("TIPO"); if (tempNodo != null) { _TIPO tipo = (_TIPO)tempNodo; return(tipo.getTipo()); } else { return(new token("vacio")); } }
public nodoModelo getNodo(String nombre) { nodoModelo retorno = null; foreach (nodoModelo temp in hijos) { if (temp.nombre.Equals(nombre)) { retorno = temp; break; } } return(retorno); }
public token getVisibilidad(elementoClase elem) { nodoModelo tempNodo = getNodo("VISIBILIDAD"); if (tempNodo != null) { _VISIBILIDAD visi = (_VISIBILIDAD)tempNodo; return(visi.getVisibilidad()); } else { //Si no tiene visibilidad retorno la visibilidad de la clase, jake mate ateo! return(elem.visibilidad); } }
public override void ejecutar(elementoClase simbolo) { if (hayErrores()) { return; } token tipo = new token("vacio"); token nombre = new token("principal"); nodoModelo LST_CUERPO = getLST_CUERPO(); elementoPolimorfo element = new elementoPolimorfo(new token("publico"), tablaSimbolos, tipo, nombre, LST_CUERPO, 0); simbolo.lstPrincipal.insertarElemento(element); }
public override void ejecutar(elementoClase simbolo) { if (hayErrores()) { return; } token tipo = new token("vacio"); token nombre = getIdentificador(simbolo.nombreClase); nodoModelo LST_CUERPO = getLST_CUERPO(); elementoPolimorfo element = new elementoPolimorfo(new token("publico"), tablaSimbolos, tipo, nombre, LST_CUERPO, 0); cargarPolimorfismoHijos(element); simbolo.lstConstructores.insertarElemento(element); }
public Boolean hay_DECLARAR_VARIABLE_SINVISIBI(elementoClase simbolo) { nodoModelo tempNodo = getNodo("DECLARAR_VARIABLE_SINVISIBI"); if (tempNodo != null) { _DECLARAR_VARIABLE_SINVISIBI var = (_DECLARAR_VARIABLE_SINVISIBI)tempNodo; var.cargarVariableGlobal(simbolo); return(true); } else { return(false); } }
public override void ejecutar(elementoClase simbolo) { if (hayErrores()) { return; } // println("llego al contructor"); token tipo = getTipo(); token nombre = getIdentificador(); nodoModelo LST_CUERPO = getLST_CUERPO(); token visbilidad = getVisibilidad(simbolo); int dimension = getDimensiones(); elementoPolimorfo element = new elementoPolimorfo(visbilidad, tablaSimbolos, tipo, nombre, LST_CUERPO, dimension); cargarPolimorfismoHijos(element); simbolo.lstMetodo_funcion.insertarElemento(element); }
public token getExtender() { token retorno = new token(); nodoModelo tempNodo = getNodo("EXTENDER"); if (tempNodo != null) { _EXTENDER temp = (_EXTENDER)tempNodo; retorno = temp.getExtender(); } else { retorno = new token(""); } return(retorno); }
public override void cargarPolimorfismo(elementoPolimorfo elem) { if (hayErrores()) { return; } nodoModelo tempNodo = getNodo("TIPO"); if (tempNodo != null) { _TIPO temp = (_TIPO)tempNodo; nodoModelo temp2 = getNodo("VAR_ARREGLO"); if (temp2 != null) { _VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2; elem.insertarParametro(tempVar.getIdentificador(), temp.getTipo(), tempVar.getDimensiones()); } } }
public token getVisibilidad() { token retorno = new token(); nodoModelo tempNodo = getNodo("VISIBILIDAD"); if (tempNodo != null) { _VISIBILIDAD temp = (_VISIBILIDAD)tempNodo; retorno = temp.getVisibilidad(); } else { retorno = new token("privado"); } 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); }
public List <int> getDimensiones() { List <int> retorno = new List <int>(); nodoModelo temp2 = getNodo("VAR_ARREGLO"); if (temp2 != null) { _VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2; int el = tempVar.getDimensiones(); for (int i = 0; i < el; i++) { //lo lleno de menos uno para indicar que no se ha establecido el limite retorno.Add(-1); } } return(retorno); }
public token getTipo() { nodoModelo tempNodo = getNodo("TIPO"); if (tempNodo != null) { _TIPO tipo = (_TIPO)tempNodo; token retorno = tipo.getTipo(); if (retorno.valLower.Equals("vacio")) { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede declarar una variable de tipo vacio:" + retorno.val, retorno); } return(retorno); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede declarar una variable de tipo vacio:", new token("vacio")); return(new token("vacio")); } }
public itemValor getValor(elementoEntorno elmen) { itemValor ob = new itemValor(); ob.setTypeNulo(); if (hayErrores()) { return(ob); } switch (hijos.Count) { case 0: if (lstAtributos.listaAtributos.Count > 0) { return(parseandoDato(lstAtributos.listaAtributos[0])); } else { tablaSimbolos.tablaErrores.insertErrorSyntax("[E] Se esperaba un valor ", new token()); return(ob); //hay un error } case 1: if (hijos[0].nombre.Equals("OPE_ARITME")) { return(hijos[0].ope_tipo(elmen)); } else if (hijos[0].nombre.Equals("OPE_TIPO")) { return(hijos[0].ope_tipo(elmen)); } else if (hijos[0].nombre.Equals("SI_SIMPLIFICADO")) { _SI_SIMPLIFICADO simplif = (_SI_SIMPLIFICADO)hijos[0]; return(simplif.getValor(elmen)); } else if (hijos[0].nombre.Equals("LEN")) { _LEN len = (_LEN)hijos[0]; return(len.getValor(elmen)); } //operador unario else if (lstAtributos.listaAtributos.Count > 0) { String signo = lstAtributos.getValItem(0); switch (signo) { //Logico case "-": negativo opNeg = new negativo(hijos[0], tablaSimbolos, lstAtributos.getToken(0)); return(opNeg.opNot(" Asignando valor Negativo", elmen)); case "!": Not opeNot = new Not(hijos[0], tablaSimbolos, lstAtributos.getToken(0)); return(opeNot.opNot("Not", elmen)); case "(": _E ope = (_E)hijos[0]; itemValor te = ope.getValor(elmen); return(te); default: tablaSimbolos.tablaErrores.insertErrorSyntax("[E]No se reconoció el signo", lstAtributos.getToken(0)); return(ob); } } else //ID_VAR_FUNC { nodoModelo busq = getNodo("ID_VAR_FUNC"); if (busq != null) { _ID_VAR_FUNC idFunc = (_ID_VAR_FUNC)busq; return(idFunc.getValor(elmen)); } tablaSimbolos.tablaErrores.insertErrorSyntax("[E]Se esperaba un signo para operación unaria", new token()); return(ob); } case 2: //operador binario if (lstAtributos.listaAtributos.Count > 0) { String signo = lstAtributos.getValItem(0); switch (signo) { //Aritmetica case "+": suma ope = new suma(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(ope.opSuma(elmen)); case "-": resta opeRes = new resta(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeRes.opResta(elmen)); case "*": multiplicacion opeMul = new multiplicacion(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeMul.opMultiplicacion(elmen)); case "/": division opeDiv = new division(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeDiv.opDivision(elmen)); case "^": potencia opePot = new potencia(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opePot.opPotencia(elmen)); case "%": modulo opeModulo = new modulo(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeModulo.opModulo(elmen)); //Relacional case "==": IgualQue opeIgualacion = new IgualQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeIgualacion.opIgualacion("Igualación", elmen)); case "!=": DiferenteQue opeDiferenciacion = new DiferenteQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeDiferenciacion.opDiferenciacion("Diferenciación", elmen)); case ">": MayorQue opeMayor = new MayorQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeMayor.opMayorQue("Mayor Que", elmen)); case ">=": MayorIgualQue opeMayorIgual = new MayorIgualQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeMayorIgual.opMayorIgualQue("Mayor o Igual Que", elmen)); case "<": MenorQue opeMenor = new MenorQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeMenor.opMenorQue("Menor Que", elmen)); case "<=": MenorIgualQue opeMenorIgual = new MenorIgualQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeMenorIgual.opMenorIgualQue("Menor o Igual Que", elmen)); //logicas case "&&": And opeAnd = new And(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeAnd.opAnd("And", elmen)); case "||": Or opeOr = new Or(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0)); return(opeOr.opOr("Or", elmen)); default: tablaSimbolos.tablaErrores.insertErrorSyntax("[E]No se reconoció el sigono", lstAtributos.getToken(0)); return(ob); } } else { tablaSimbolos.tablaErrores.insertErrorSyntax("[E]Se esperaba un signo para operación binaria", new token()); return(ob); } default: return(ob); } }
public void insertar(nodoModelo hijo) { hijos.Add(hijo); }
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 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; }