/* |------------------------------------------------------------------------------------------------------------------- | EJECUCIÓN FINAL |------------------------------------------------------------------------------------------------------------------- | */ public itemEntorno getDestino(elementoEntorno elementoEntorno) { itemEntorno retorno = null; if (hayErrores()) { return(retorno); } if (lstAtributos.listaAtributos.Count == 0) /* |---------------------------- | ID_VAR_FUNC + LST_PUNTOSP */ { #region reg1 nodoModelo idVar = getNodo("ID_VAR_FUNC"); if (idVar != null) { nodoModelo lstPuntos = getNodo("LST_PUNTOSP"); if (lstPuntos != null) { _ID_VAR_FUNC temp1 = (_ID_VAR_FUNC)idVar; _LST_PUNTOSP puntos = (_LST_PUNTOSP)lstPuntos; itemValor te1 = temp1.getValor(elementoEntorno); itemEntorno te2 = puntos.getDestino(elementoEntorno, te1); return(te2); //tengo que obtener el objeto de id_var_func } } #endregion } else if (lstAtributos.listaAtributos.Count == 1) { if (hijos.Count > 0) /* |---------------------------- | valId + LST_CORCHETES_VAL |------------ | Lst_Corchtes tiene que retornar una lista de tipo entero | */ { #region reg2 String item1 = lstAtributos.listaAtributos[0].nombretoken; token nombreVar = lstAtributos.getToken(0); if (item1.Equals("valId")) { _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL"); return(getEntornoId(lstAtributos.listaAtributos[0].tok, elementoEntorno, lstCorchetes.getLstInt(elementoEntorno, nombreVar))); } #endregion } else /* |---------------------------- | valId */ { String item1 = lstAtributos.listaAtributos[0].nombretoken; if (item1.Equals("valId")) { return(getEntornoId(lstAtributos.listaAtributos[0].tok, elementoEntorno, new List <int>())); } } } else if (lstAtributos.listaAtributos.Count == 3) { String item1 = lstAtributos.listaAtributos[0].nombretoken; String item2 = lstAtributos.listaAtributos[1].nombretoken; String item3 = lstAtributos.listaAtributos[2].nombretoken; if (item1.Equals("este") && item2.Equals(".") && item3.Equals("valId")) { if (hijos.Count > 0) /* |---------------------------- | tEste + sPunto + valId + LST_CORCHETES_VAL */ { #region reg4 String valId = lstAtributos.listaAtributos[2].nombretoken; token nombreVar = lstAtributos.getToken(2); if (valId.Equals("valId")) { _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL"); return(getEntornoId(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz, lstCorchetes.getLstInt(elementoEntorno, nombreVar))); } #endregion } else /* |---------------------------- | tEste + sPunto + valId */ { String valId = lstAtributos.listaAtributos[2].nombretoken; if (valId.Equals("valId")) { return(getEntornoId(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz, new List <int>())); } } } if (item1.Equals("valId") && item2.Equals("(") && item3.Equals(")")) { if (hijos.Count == 2) /* |---------------------------- | valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL; |------------------------ * Primero ejecuto el metodo que me tiene que retornar siempre dimension>0 * luego enviarle ese valor, para extraer lo que se quiere */ { tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(0).val + "()[] ", lstAtributos.getToken(0)); } if (hijos.Count == 1) { String nombreHijo = hijos[0].nombre; if (nombreHijo.Equals("LST_VAL")) /* |---------------------------- | valId + sAbreParent + LST_VAL + sCierraParent; |------------- | Esto es un metodo */ { tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(0).val + "()", lstAtributos.getToken(0)); } } } } else if (lstAtributos.listaAtributos.Count == 5) { String item1 = lstAtributos.listaAtributos[0].nombretoken; String item2 = lstAtributos.listaAtributos[1].nombretoken; String item3 = lstAtributos.listaAtributos[2].nombretoken; if (item1.Equals("este") && item2.Equals(".") && item3.Equals("valId")) { if (hijos.Count == 2) /* |---------------------------- | tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL; */ { tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo este." + lstAtributos.getToken(0).val + "()[] ", lstAtributos.getToken(0)); } else if (hijos.Count == 1) { if (hijos[0].nombre.Equals("LST_VAL")) /* |---------------------------- | tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent */ { tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo este." + lstAtributos.getToken(0).val + "() ", lstAtributos.getToken(0)); } } } } return(retorno); }
/* |------------------------------------------------------------------------------------------------------------------- | EJECUCIÓN FINAL |------------------------------------------------------------------------------------------------------------------- | */ public itemValor getValor(elementoEntorno elementoEntorno) { itemValor retorno = new itemValor(); retorno.setTypeVacio(); retorno.setTypeVacio(); //no puede retornar nada, es un metodo mahe if (hayErrores()) { return(retorno); } if (lstAtributos.listaAtributos.Count == 0) /* |---------------------------- | ID_VAR_FUNC + LST_PUNTOSP */ { #region reg1 nodoModelo idVar = getNodo("ID_VAR_FUNC"); if (idVar != null) { nodoModelo lstPuntos = getNodo("LST_PUNTOSP"); if (lstPuntos != null) { _ID_VAR_FUNC temp1 = (_ID_VAR_FUNC)idVar; _LST_PUNTOSP puntos = (_LST_PUNTOSP)lstPuntos; itemValor te1 = temp1.getValor(elementoEntorno); itemValor te2 = puntos.getValor(elementoEntorno, te1); //aquí puedo revisar si fue una pregunta para poder guardarla en el entorno /* if (te2.isTypeObjeto()) * { * if (te2.nombreObjeto.Equals("form")) * { * * //guardando la pregunta dentro de la tabla de simbolos, jejejejejejejejejejejejejeje * itemEntorno sim = new itemEntorno(te1.nombrePregunta, te1.nombrePregunta, te1, new token("publico"), new List<int>(), tablaSimbolos); * elementoEntorno.insertarEntorno(sim); * * * ///ejecuto el metodo ejecutar final, es el que muestra las preguntas * //elementoEntorno.este.ejecutarMetodoFuncion(new token("ejecutarfinal"), new lstValores(), sim.valor.getObjeto().tablaEntorno.raiz); * //println("entorno de ejecutar final ===================================0"); * * // sim.valor.getObjeto().tablaEntorno.raiz.este.ejecutarMetodoFuncion(new token("ejecutarfinal"), new lstValores(), sim.valor.getObjeto().tablaEntorno.raiz); * * * } * } * * if(te1.nombrePregunta.esPregunta) * { * * if (temp1.lstAtributos.listaAtributos.Count > 0) * { * String nombreToken = temp1.lstAtributos.listaAtributos[0].nombretoken; * * if (nombreToken.Equals("valId")) * { * //ahora ya que revisar que se encuentre entre la lsita de preguntas. * // elementoEntorno.este.cuerpoClase.ls * if (tablaSimbolos.esPregunta(temp1.lstAtributos.getToken(0).valLower)) * { * //es pregunta * itemEntorno sim = new itemEntorno(te1.nombrePregunta, te1.nombrePregunta, te1, new token("publico"), new List<int>(), tablaSimbolos); * elementoEntorno.insertarEntorno(sim); * * } * * } * * } * * * } */ return(te2); //tengo que obtener el objeto de id_var_func } } #endregion } else if (lstAtributos.listaAtributos.Count == 1) { if (hijos.Count > 0) /* |---------------------------- | valId + LST_CORCHETES_VAL |------------ | Lst_Corchtes tiene que retornar una lista de tipo entero | */ { #region reg2 token nombreVar = lstAtributos.getToken(0); nodoModelo nodoLstCor = getNodo("LST_CORCHETES_VAL"); if (nodoLstCor != null) { _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCor; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, nombreVar); String item1 = lstAtributos.listaAtributos[0].nombretoken; //mapeando el indice if (item1.Equals("valId")) { return(getValIdCorchetes(lstAtributos.listaAtributos[0].tok, elementoEntorno, listaEntero)); } else { println(" valId + LST_CORCHETES_VAL -> No viene val id"); } } #endregion } else /* |---------------------------- | valId */ { #region reg3 String item1 = lstAtributos.listaAtributos[0].nombretoken; if (item1.Equals("valId")) { return(getValId(lstAtributos.listaAtributos[0].tok, elementoEntorno)); } #endregion } } else if (lstAtributos.listaAtributos.Count == 3) { String item1 = lstAtributos.listaAtributos[0].nombretoken; String item2 = lstAtributos.listaAtributos[1].nombretoken; String item3 = lstAtributos.listaAtributos[2].nombretoken; if (item1.Equals("este") && item2.Equals(".") && item3.Equals("valId")) { if (hijos.Count > 0) /* |---------------------------- | tEste + sPunto + valId + LST_CORCHETES_VAL */ { #region reg4 token nombreVar = lstAtributos.getToken(2); nodoModelo nodoLstCor = getNodo("LST_CORCHETES_VAL"); if (nodoLstCor != null) { _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCor; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, nombreVar); String item11 = lstAtributos.listaAtributos[2].nombretoken; //mapeando el indice if (item11.Equals("valId")) { return(getValIdCorchetes(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz, listaEntero)); } else { println(" tEste + sPunto + valId + LST_CORCHETES_VAL -> No viene val id"); } } #endregion } else /* |---------------------------- | tEste + sPunto + valId */ { #region cuerpo String esteId = lstAtributos.listaAtributos[2].nombretoken; if (esteId.Equals("valId")) { return(getValId(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz)); } else { println("(tEste + sPunto + valId) No se encontró valId"); } #endregion } } if (item1.Equals("valId") && item2.Equals("(") && item3.Equals(")")) { if (hijos.Count == 2) /* |---------------------------- | valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL; |------------------------ * Primero ejecuto el metodo que me tiene que retornar siempre dimension>0 * luego enviarle ese valor, para extraer lo que se quiere */ { #region cuerpo if (hayErrores()) { return(retorno); } String esteId = lstAtributos.listaAtributos[0].nombretoken; if (esteId.Equals("valId")) { //esto es del metodo nodoModelo nodoTemp = getNodo("LST_VAL"); _LST_VAL lstParametros = (_LST_VAL)nodoTemp; itemValor itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz); //esto es de la parte del arreglo nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL"); _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[0].tok); if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count) //tienen la misma dimension { println("getValCorchetes"); return(getValCorchetes(lstAtributos.getToken(0), elementoEntorno, listaEntero, itemValorRetornoMetodo)); } else //no tienen la misma dimensión. { tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(0).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(0)); return(retorno); } } else { println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId"); return(retorno); } #endregion } if (hijos.Count == 1) { String nombreHijo = hijos[0].nombre; if (nombreHijo.Equals("LST_CORCHETES_VAL")) /* |---------------------------- | valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL; */ { #region cuerpo if (hayErrores()) { return(retorno); } String esteId = lstAtributos.listaAtributos[0].nombretoken; if (esteId.Equals("valId")) { //esto es del metodo nodoModelo nodoTemp = getNodo("LST_VAL"); lstValores sinParametros = new lstValores(); itemValor itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), sinParametros, elementoEntorno.este.tablaEntorno.raiz); //esto es de la parte del arreglo nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL"); _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[0].tok); if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count) //tienen la misma dimension { println("getValCorchetes"); return(getValCorchetes(lstAtributos.getToken(0), elementoEntorno, listaEntero, itemValorRetornoMetodo)); } else //no tienen la misma dimensión. { tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(0).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(0)); return(retorno); } } else { println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId"); return(retorno); } #endregion } else if (nombreHijo.Equals("LST_VAL")) /* |---------------------------- | valId + sAbreParent + LST_VAL + sCierraParent; |------------- | Esto es un metodo | Desde aquí puedo llamar a las preguntas, y tiene mayor prioridad | si me encuentro dentro de un entorno de nombre, formulario, o de nombre grupo */ { #region cuerpo String esteId = lstAtributos.listaAtributos[0].nombretoken; /*if (elementoEntorno.nombre.Equals("formulario") || elementoEntorno.nombre.Equals("grupo")) * * Esto es como el constructor nuevo pregunta() * * { * }*/ //primero busco en las preguntas, luego en los metodos, jejejejeje itemValor ret = crearPregunta(elementoEntorno); if (ret != null) { //eso quiere decir que es una pregunta ret.nombrePregunta = lstAtributos.getToken(0); ret.nombrePregunta.esPregunta = true; itemEntorno sim = new itemEntorno(ret.nombrePregunta, ret.nombrePregunta, ret, new token("publico"), new List <int>(), tablaSimbolos); elementoEntorno.insertarEntorno(sim); return(ret); } //si no lo encuentro como pregunta, sigo la ejecución en busca de un metodo. if (esteId.Equals("valId")) { nodoModelo nodoTemp = getNodo("LST_VAL"); _LST_VAL lstParametros = (_LST_VAL)nodoTemp; return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz)); } else { println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId"); } #endregion } } if (hijos.Count == 0) /* |---------------------------- | valId + sAbreParent + sCierraParent; |------------- | Esto es un metodo sin parámetros | hay que buscarlo entre la lista de metodos */ { #region cuerpo String esteId = lstAtributos.listaAtributos[0].nombretoken; if (esteId.Equals("valId")) { lstValores sinParametros = new lstValores(); return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), sinParametros, elementoEntorno.este.tablaEntorno.raiz)); } else { println("valId + sAbreParent + sCierraParent -> no viene valId"); } #endregion } } } else if (lstAtributos.listaAtributos.Count == 5) { String item1 = lstAtributos.listaAtributos[0].nombretoken; String item2 = lstAtributos.listaAtributos[1].nombretoken; String item3 = lstAtributos.listaAtributos[2].nombretoken; if (item1.Equals("este") && item2.Equals(".") && item3.Equals("valId")) { if (hijos.Count == 2) /* |---------------------------- | tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL; */ { #region cuerpo if (hayErrores()) { return(retorno); } String esteId = lstAtributos.listaAtributos[2].nombretoken; if (esteId.Equals("valId")) { //esto es del metodo nodoModelo nodoTemp = getNodo("LST_VAL"); _LST_VAL lstParametros = (_LST_VAL)nodoTemp; itemValor itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz); //esto es de la parte del arreglo nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL"); _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[2].tok); if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count) //tienen la misma dimension { println("getValCorchetes"); return(getValCorchetes(lstAtributos.getToken(2), elementoEntorno, listaEntero, itemValorRetornoMetodo)); } else //no tienen la misma dimensión. { tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(2).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(2)); return(retorno); } } else { println("tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;"); } #endregion } else if (hijos.Count == 1) { if (hijos[0].nombre.Equals("LST_CORCHETES_VAL")) /* |---------------------------- | tEste + sPunto + valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL; */ { #region cuerpo if (hayErrores()) { return(retorno); } String esteId = lstAtributos.listaAtributos[2].nombretoken; if (esteId.Equals("valId")) { //esto es del metodo nodoModelo nodoTemp = getNodo("LST_VAL"); lstValores sinParametros = new lstValores(); itemValor itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), sinParametros, elementoEntorno.este.tablaEntorno.raiz); //esto es de la parte del arreglo nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL"); _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[2].tok); if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count) //tienen la misma dimension { println("getValCorchetes"); return(getValCorchetes(lstAtributos.getToken(2), elementoEntorno, listaEntero, itemValorRetornoMetodo)); } else //no tienen la misma dimensión. { tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(2).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(2)); return(retorno); } } else { println("tEste + sPunto + valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL"); } #endregion } else if (hijos[0].nombre.Equals("LST_VAL")) /* |---------------------------- | tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent */ { #region cuerpo print("tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent"); String esteId = lstAtributos.listaAtributos[2].nombretoken; if (esteId.Equals("valId")) { nodoModelo nodoTemp = getNodo("LST_VAL"); _LST_VAL lstParametros = (_LST_VAL)nodoTemp; return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz)); } else { println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId"); } } #endregion } else if (hijos.Count == 0) /* |---------------------------- | tEste + sPunto + valId + sAbreParent + sCierraParent */ { #region cuerpo print("tEste + sPunto + valId + sAbreParent + sCierraParent"); String esteId = lstAtributos.listaAtributos[2].nombretoken; if (esteId.Equals("valId")) { nodoModelo nodoTemp = getNodo("LST_VAL"); lstValores sinParametros = new lstValores(); return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), sinParametros, elementoEntorno.este.tablaEntorno.raiz)); } else { println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId"); } #endregion } } } return(retorno); }
public nodoModelo getNodo(String nombreNoTerminal, tablaSimbolos tabla) { nodoModelo retorno = null; switch (nombreNoTerminal) { case "S": retorno = new _S(nombreNoTerminal, tabla); break; case "LST_IMPORT": retorno = new _LST_IMPORT(nombreNoTerminal, tabla); break; case "IMPORT": retorno = new _IMPORT(nombreNoTerminal, tabla); break; case "LST_CLASE": retorno = new _LST_CLASE(nombreNoTerminal, tabla); break; case "CLASE": retorno = new _CLASE(nombreNoTerminal, tabla); break; case "TIPO": retorno = new _TIPO(nombreNoTerminal, tabla); break; case "EXTENDER": retorno = new _EXTENDER(nombreNoTerminal, tabla); break; case "VISIBILIDAD": retorno = new _VISIBILIDAD(nombreNoTerminal, tabla); break; case "LST_PARAMETROS": retorno = new _LST_PARAMETROS(nombreNoTerminal, tabla); break; case "PARAMETRO": retorno = new _PARAMETRO(nombreNoTerminal, tabla); break; case "LST_VAL": retorno = new _LST_VAL(nombreNoTerminal, tabla); break; case "CP_CLASE": retorno = new _CP_CLASE(nombreNoTerminal, tabla); break; case "CUERPO_CLASE": retorno = new _CUERPO_CLASE(nombreNoTerminal, tabla); break; case "METODO": retorno = new _METODO(nombreNoTerminal, tabla); break; case "SOBRESCRITURA": retorno = new _SOBRESCRITURA(nombreNoTerminal, tabla); break; case "MAIN": retorno = new _MAIN(nombreNoTerminal, tabla); break; case "CONSTRUCTOR": retorno = new _CONSTRUCTOR(nombreNoTerminal, tabla); break; case "DECLARAR_VARIABLE_GLOBAL": retorno = new _DECLARAR_VARIABLE_GLOBAL(nombreNoTerminal, tabla); break; case "DECLARAR_VARIABLE_SINVISIBI": retorno = new _DECLARAR_VARIABLE_SINVISIBI(nombreNoTerminal, tabla); break; case "VAL": retorno = new _VAL(nombreNoTerminal, tabla); break; case "LST_LLAVES_VAL": retorno = new _LST_LLAVES_VAL(nombreNoTerminal, tabla); break; case "LLAVES_VAL_P": retorno = new _LLAVES_VAL_P(nombreNoTerminal, tabla); break; case "VAR_ARREGLO": retorno = new _VAR_ARREGLO(nombreNoTerminal, tabla); break; case "LST_CORCHETES": retorno = new _LST_CORCHETES(nombreNoTerminal, tabla); break; case "LST_CORCHETES_VAL": retorno = new _LST_CORCHETES_VAL(nombreNoTerminal, tabla); break; case "USAR_METO_VAR": retorno = new _USAR_METO_VAR(nombreNoTerminal, tabla); break; case "USAR_VARIABLEP": retorno = new _USAR_VARIABLEP(nombreNoTerminal, tabla); break; case "USAR_VARIABLE": retorno = new _USAR_VARIABLE(nombreNoTerminal, tabla); break; case "USAR_METODO": retorno = new _USAR_METODO(nombreNoTerminal, tabla); break; case "LLAMADA_FORMULARIO": retorno = new _LLAMADA_FORMULARIO(nombreNoTerminal, tabla); break; case "LST_CUERPO": retorno = new _LST_CUERPO(nombreNoTerminal, tabla); break; case "CUERPO": retorno = new _CUERPO(nombreNoTerminal, tabla); break; case "VALOR": retorno = new _VALOR(nombreNoTerminal, tabla); break; case "PAR_CORCHETES_VACIOS": retorno = new _PAR_CORCHETES_VACIOS(nombreNoTerminal, tabla); break; case "E": retorno = new _E(nombreNoTerminal, tabla); break; case "FUNCIONES_NATIVAS": retorno = new _FUNCIONES_NATIVAS(nombreNoTerminal, tabla); break; case "IMPRIMIR": retorno = new _IMPRIMIR(nombreNoTerminal, tabla); break; case "ID_VAR_FUNC": retorno = new _ID_VAR_FUNC(nombreNoTerminal, tabla); break; case "LST_PUNTOSP": retorno = new _LST_PUNTOSP(nombreNoTerminal, tabla); break; case "ASIG_VALOR": retorno = new _ASIG_VALOR(nombreNoTerminal, tabla); break; case "PAR_CORCHETES_VAL": retorno = new _PAR_CORCHETES_VAL(nombreNoTerminal, tabla); break; case "RETORNO": retorno = new _RETORNO(nombreNoTerminal, tabla); break; case "SI": retorno = new _SI(nombreNoTerminal, tabla); break; case "SINO_SI": retorno = new _SINO_SI(nombreNoTerminal, tabla); break; case "SINO": retorno = new _SINO(nombreNoTerminal, tabla); break; case "SENTENCIAS": retorno = new _SENTENCIAS(nombreNoTerminal, tabla); break; case "SI_SIMPLIFICADO": retorno = new _SI_SIMPLIFICADO(nombreNoTerminal, tabla); break; case "CASO": retorno = new _CASO(nombreNoTerminal, tabla); break; case "CUERPO_CASE": retorno = new _CUERPO_CASE(nombreNoTerminal, tabla); break; case "ROMPER": retorno = new _ROMPER(nombreNoTerminal, tabla); break; case "WHILE": retorno = new _WHILE(nombreNoTerminal, tabla); break; case "CONTINUAR": retorno = new _CONTINUAR(nombreNoTerminal, tabla); break; case "FOR": retorno = new _FOR(nombreNoTerminal, tabla); break; case "DOWHILE": retorno = new _DOWHILE(nombreNoTerminal, tabla); break; case "REPETIR": retorno = new _REPETIR(nombreNoTerminal, tabla); break; case "MENSAJE": retorno = new _MENSAJE(nombreNoTerminal, tabla); break; case "TO_CADENA": retorno = new _TO_CADENA(nombreNoTerminal, tabla); break; case "SUB_CAD": retorno = new _SUB_CAD(nombreNoTerminal, tabla); break; case "POS_CAD": retorno = new _POS_CAD(nombreNoTerminal, tabla); break; case "TO_BOOLEAN": retorno = new _TO_BOOLEAN(nombreNoTerminal, tabla); break; case "TO_ENTERO": retorno = new _TO_ENTERO(nombreNoTerminal, tabla); break; case "HOY": retorno = new _HOY(nombreNoTerminal, tabla); break; case "AHORA": retorno = new _AHORA(nombreNoTerminal, tabla); break; case "TO_FECHA": retorno = new _TO_FECHA(nombreNoTerminal, tabla); break; case "TO_HORA": retorno = new _TO_HORA(nombreNoTerminal, tabla); break; case "TO_FECHAHORA": retorno = new _TO_FECHAHORA(nombreNoTerminal, tabla); break; case "TAM": retorno = new _TAM(nombreNoTerminal, tabla); break; case "RANDOM": retorno = new _RANDOM(nombreNoTerminal, tabla); break; case "MIN": retorno = new _MIN(nombreNoTerminal, tabla); break; case "MAX": retorno = new _MAX(nombreNoTerminal, tabla); break; case "OPE_TIPO": retorno = new _OPE_TIPO(nombreNoTerminal, tabla); break; case "OPE_ARITME": retorno = new _OPE_ARITME(nombreNoTerminal, tabla); break; case "POTENCIA": retorno = new _POTENCIA(nombreNoTerminal, tabla); break; case "LOGARITMO": retorno = new _LOGARITMO(nombreNoTerminal, tabla); break; case "LOGARITMO10": retorno = new _LOGARITMO10(nombreNoTerminal, tabla); break; case "ABSOLUTO": retorno = new _ABSOLUTO(nombreNoTerminal, tabla); break; case "SENO": retorno = new _SENO(nombreNoTerminal, tabla); break; case "COSENO": retorno = new _COSENO(nombreNoTerminal, tabla); break; case "TANGENTE": retorno = new _TANGENTE(nombreNoTerminal, tabla); break; case "RAIZ": retorno = new _RAIZ(nombreNoTerminal, tabla); break; case "PI": retorno = new _PI(nombreNoTerminal, tabla); break; case "SUPER": retorno = new _SUPER(nombreNoTerminal, tabla); return(retorno); case "FORMULARIO": retorno = new _FORMULARIO(nombreNoTerminal, tabla); return(retorno); case "PREGUNTA": retorno = new _PREGUNTA(nombreNoTerminal, tabla); return(retorno); case "GRUPO": retorno = new _GRUPO(nombreNoTerminal, tabla); return(retorno); case "LST_CUERPO_PREGUNTA": retorno = new _LST_CUERPO_PREGUNTA(nombreNoTerminal, tabla); return(retorno); case "CUERPO_PREGUNTA": retorno = new _CUERPO_PREGUNTA(nombreNoTerminal, tabla); return(retorno); case "PREGUNTA_NATIVA": retorno = new _PREGUNTA_NATIVA(nombreNoTerminal, tabla); return(retorno); case "ESCRIBIR_ARCHIVO": retorno = new _ESCRIBIR_ARCHIVO(nombreNoTerminal, tabla); return(retorno); case "FUNC_MULTIMEDIA": retorno = new _FUNC_MULTIMEDIA(nombreNoTerminal, tabla); return(retorno); case "AUDIO": retorno = new _AUDIO(nombreNoTerminal, tabla); return(retorno); case "VIDEO": retorno = new _VIDEO(nombreNoTerminal, tabla); return(retorno); case "IMAGEN": retorno = new _IMAGEN(nombreNoTerminal, tabla); return(retorno); case "LEN": retorno = new _LEN(nombreNoTerminal, tabla); return(retorno); default: retorno = new nodoModelo("Desc_" + nombreNoTerminal, tabla); Console.WriteLine("[generarArbol]No se encontró el nodo:" + nombreNoTerminal); break; } return(retorno); }
/* |------------------------------------------------------------------------------------------------------------------- | EJECUCIÓN FINAL |------------------------------------------------------------------------------------------------------------------- | elementoEntorno,es el ambito actual | itemValor es el objeto donde voy a seguir buscandos | solo puedo recibir item de tipo objeto */ public itemValor getValor(elementoEntorno elementoEntorno, itemValor item) { itemValor retorno = new itemValor(); retorno.setTypeVacio(); if (hayErrores()) { return(retorno); } if (item.isTypeObjeto()) { if (lstAtributos.listaAtributos.Count == 2) { if (hijos.Count > 0) /* |---------------------------- | sPunto + valId + LST_CORCHETES_VAL */ { token nombreVar = lstAtributos.getToken(1); nodoModelo nodoLstCor = getNodo("LST_CORCHETES_VAL"); if (nodoLstCor != null) { _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCor; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, nombreVar); String item1 = lstAtributos.listaAtributos[1].nombretoken; //mapeando el indice if (item1.Equals("valId")) { objetoClase tempObjeto = item.getObjeto(); if (tempObjeto != null) { return(getValIdCorchetes(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, listaEntero)); //return getValId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se pudo parsear el objeto", lstAtributos.listaAtributos[1].tok); return(retorno); } } else { println("sPunto + valId + LST_CORCHETES_VAL -> No viene val id"); } } } else /* |---------------------------- | sPunto + valId */ { String item1 = lstAtributos.listaAtributos[1].nombretoken; if (item1.Equals("valId")) { objetoClase tempObjeto = item.getObjeto(); if (tempObjeto != null) { return(getValId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz)); } else { tablaSimbolos.tablaErrores.insertErrorSemantic("No se pudo parsear el objeto", lstAtributos.listaAtributos[1].tok); return(retorno); } } } } else if (lstAtributos.listaAtributos.Count == 4) { if (hijos.Count == 2) /* |---------------------------- | sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL */ { if (hayErrores()) { return(retorno); } String esteId = lstAtributos.listaAtributos[1].nombretoken; if (esteId.Equals("valId")) { objetoClase tempObjeto = item.getObjeto(); //esto es del metodo nodoModelo nodoTemp = getNodo("LST_VAL"); _LST_VAL lstParametros = (_LST_VAL)nodoTemp; itemValor itemValorRetornoMetodo = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), lstParametros.getLstValores(elementoEntorno), tempObjeto.tablaEntorno.raiz); //esto es de la parte del arreglo nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL"); _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[1].tok); if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count) //tienen la misma dimension { return(getValCorchetes(lstAtributos.getToken(1), elementoEntorno, listaEntero, itemValorRetornoMetodo)); } else //no tienen la misma dimensión. { tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(1).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(1)); return(retorno); } } else { println(" sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL -> no viene valId"); return(retorno); } } else if (hijos.Count == 1) { if (hijos[0].nombre.Equals("LST_CORCHETES_VAL")) /* |---------------------------- | sPunto + valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL */ { if (hayErrores()) { return(retorno); } String esteId = lstAtributos.listaAtributos[1].nombretoken; if (esteId.Equals("valId")) { objetoClase tempObjeto = item.getObjeto(); //esto es del metodo nodoModelo nodoTemp = getNodo("LST_VAL"); lstValores sinParametros = new lstValores(); //elementoEntorno.este.tablaEntorno.raiz itemValor itemValorRetornoMetodo = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), sinParametros, tempObjeto.tablaEntorno.raiz); //esto es de la parte del arreglo nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL"); _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes; List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[1].tok); if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count) //tienen la misma dimension { return(getValCorchetes(lstAtributos.getToken(1), elementoEntorno, listaEntero, itemValorRetornoMetodo)); } else //no tienen la misma dimensión. { tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(1).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(1)); return(retorno); } } else { println(" sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL -> no viene valId"); return(retorno); } } else if (hijos[0].nombre.Equals("LST_VAL")) /* |---------------------------- | sPunto + valId + sAbreParent + LST_VAL + sCierraParent */ { #region cuerpo String esteId = lstAtributos.listaAtributos[1].nombretoken; objetoClase tempObjeto = item.getObjeto(); if (esteId.Equals("valId")) { nodoModelo nodoTemp = getNodo("LST_VAL"); _LST_VAL lstParametros = (_LST_VAL)nodoTemp; itemValor reto = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), lstParametros.getLstValores(elementoEntorno), tempObjeto.tablaEntorno.raiz); reto.nombrePregunta = item.nombrePregunta; return(reto); } else { println("sPunto + valId + sAbreParent + LST_VAL + sCierraParent "); } #endregion } } else if (hijos.Count == 0) /* |---------------------------- | sPunto + valId + sAbreParent + sCierraParent */ { #region cuerpo String esteId = lstAtributos.listaAtributos[1].nombretoken; objetoClase tempObjeto = item.getObjeto(); println("el nombre del objeto es " + tempObjeto.cuerpoClase.nombreClase.val); if (esteId.Equals("valId")) { nodoModelo nodoTemp = getNodo("LST_VAL"); lstValores sinParametros = new lstValores(); return(tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), sinParametros, tempObjeto.tablaEntorno.raiz)); } else { println("sPunto + valId + sAbreParent + sCierraParent "); } #endregion } } } else { tablaSimbolos.tablaErrores.insertErrorSyntax("[objeto.objeto]El atributo/arreglo/metodo al que se quiere acceder no es de tipo objeto", new token()); } return(retorno); }
public itemEntorno getDestino(elementoEntorno elementoEntorno, itemValor item) { itemEntorno retorno = null; if (hayErrores()) { return(retorno); } if (item.isTypeObjeto()) { if (lstAtributos.listaAtributos.Count == 2) { if (hijos.Count > 0) /* |---------------------------- | sPunto + valId + LST_CORCHETES_VAL */ { objetoClase tempObjeto = item.getObjeto(); String item1 = lstAtributos.listaAtributos[1].nombretoken; token nombreVar = lstAtributos.getToken(1); if (item1.Equals("valId")) { _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL"); return(getEntornoId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, lstCorchetes.getLstInt(elementoEntorno, nombreVar))); } } else /* |---------------------------- | sPunto + valId */ { objetoClase tempObjeto = item.getObjeto(); String item1 = lstAtributos.listaAtributos[1].nombretoken; token nombreVar = lstAtributos.getToken(1); if (item1.Equals("valId")) { _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL"); return(getEntornoId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, new List <int>())); } } } else if (lstAtributos.listaAtributos.Count == 4) { if (hijos.Count == 2) /* |---------------------------- | sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL */ { tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(1).val + "()[]", lstAtributos.getToken(1)); } else if (hijos.Count == 1) { if (hijos[0].nombre.Equals("LST_VAL")) /* |---------------------------- | sPunto + valId + sAbreParent + LST_VAL + sCierraParent */ { tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(1).val + "()", lstAtributos.getToken(1)); } } } } else { tablaSimbolos.tablaErrores.insertErrorSyntax("[objeto.objeto]El atributo/arreglo/metodo al que se quiere acceder no es de tipo objeto", new token()); } return(null); }