static void Main(string[] args) { //Generalidades Funcion.Ejecutar(); //Enumeraciones Ejercicio_1_y_2_enum.Ejecutar(); //Conversiones Conversion.Ejecutar(); //Condicionales Ejercicio_3_Condicionales.Ejecutar(); Ejercicio_4_y_5_Condicionales.Ejecutar(); Ejercicio_6_y_7_Condicionales.Ejecutar(); }
public bool Ejecutar() { Operar operar = new Operar(this, this); //Ejecutará las OPER y ARR de los simbolos foreach (var symClass in ClaseSym) { //Se recupera el tipo de simbolo var symClasType = symClass.Value.TipoDato; //Si no es null opera el DIMENSIONLST if (symClass.Value.Arr != null) { var symClassArr = operar.Interpretar(symClass.Value.Arr); symClass.Value.Arreglo = symClassArr.Arreglo; } //Si no es null opera el OPER if (symClass.Value.Oper != null) { var symClassOper = operar.Interpretar(symClass.Value.Oper); //Determina si los tipos son los mismo if (symClassOper.TipoDato != symClass.Value.TipoDato) { Main.Imprimir(String.Format("Los tipos no coinciden {0} -> {1} : ({2},{3})", symClassOper.TipoDato, symClass.Value.TipoDato, symClass.Value.Posicion.Fila, symClass.Value.Posicion.Columna)); return(true); } //Los tipos coinciden //Se debe determinar si es un arreglo if (symClassOper.TipoDato > Tipo.CLASE) { if (symClassOper.Arreglo.Dimension != symClass.Value.Arreglo.Dimension) { Main.Imprimir(String.Format("Las dimensiones de {0} no coincide con {1} : ({2},{3})", symClassOper.TipoDato, symClass.Value.TipoDato, symClassOper.Posicion != null ? symClassOper.Posicion.Fila : 0, symClassOper.Posicion != null ? symClassOper.Posicion.Columna : 0)); return(true); } //Es un arreglo, debe asegurarse que las dimensiones coincidan if (symClassOper.Arreglo.SizeUni != symClass.Value.Arreglo.SizeUni) { Main.Imprimir(String.Format("El arreglo unidemensional de {0} no coincide con {1} : ({2},{3})", symClassOper.TipoDato, symClass.Value.TipoDato, symClassOper.Posicion != null ? symClassOper.Posicion.Fila : 0, symClassOper.Posicion != null ? symClassOper.Posicion.Columna : 0)); return(true); } if (symClassOper.Arreglo.SizeBi != symClass.Value.Arreglo.SizeBi) { Main.Imprimir(String.Format("El arreglo bidemensional de {0} no coincide con {1} : ({2},{3})", symClassOper.TipoDato, symClass.Value.TipoDato, symClassOper.Posicion != null ? symClassOper.Posicion.Fila : 0, symClassOper.Posicion != null ? symClassOper.Posicion.Columna : 0)); return(true); } if (symClassOper.Arreglo.SizeTri != symClass.Value.Arreglo.SizeTri) { Main.Imprimir(String.Format("El arreglo tridemensional de {0} no coincide con {1} : ({2},{3})", symClassOper.TipoDato, symClass.Value.TipoDato, symClassOper.Posicion != null ? symClassOper.Posicion.Fila : 0, symClassOper.Posicion != null ? symClassOper.Posicion.Columna : 0)); return(true); } } //Asigna el valor de symClassOpera al dato del diccionar de clases actual symClass.Value.Dato = symClassOper.Dato; } //Si es un arreglo se asegurará de inicializar el arreglo else if (symClass.Value.TipoDato > Tipo.CLASE) { //Inicializa el dato object arrDato = null; var dimArrSym = symClass.Value; //Según las dimensiones switch (dimArrSym.Arreglo.Dimension) { case TipoArreglo.UNI: switch (dimArrSym.TipoDato) { case Tipo.INTARR: arrDato = new int[dimArrSym.Arreglo.SizeUni]; break; case Tipo.STRINGARR: arrDato = new string[dimArrSym.Arreglo.SizeUni]; break; case Tipo.DOUBLEARR: arrDato = new double[dimArrSym.Arreglo.SizeUni]; break; case Tipo.CHARARR: arrDato = new char[dimArrSym.Arreglo.SizeUni]; break; case Tipo.BOOLEANARR: arrDato = new bool[dimArrSym.Arreglo.SizeUni]; break; case Tipo.CLASEARR: arrDato = new Clase[dimArrSym.Arreglo.SizeUni]; break; } break; case TipoArreglo.BI: switch (dimArrSym.TipoDato) { case Tipo.INTARR: arrDato = new int[dimArrSym.Arreglo.SizeBi][]; //recorre el arreglo inicializando el arreglo for (int i = 0; i < (arrDato as int[][]).Length; i++) { (arrDato as int[][])[i] = new int[dimArrSym.Arreglo.SizeUni]; } break; case Tipo.STRINGARR: arrDato = new string[dimArrSym.Arreglo.SizeBi][]; for (int i = 0; i < (arrDato as string[][]).Length; i++) { (arrDato as string[][])[i] = new string[dimArrSym.Arreglo.SizeUni]; } break; case Tipo.DOUBLEARR: arrDato = new double[dimArrSym.Arreglo.SizeBi][]; for (int i = 0; i < (arrDato as double[][]).Length; i++) { (arrDato as double[][])[i] = new double[dimArrSym.Arreglo.SizeUni]; } break; case Tipo.CHARARR: arrDato = new char[dimArrSym.Arreglo.SizeBi][]; for (int i = 0; i < (arrDato as char[][]).Length; i++) { (arrDato as char[][])[i] = new char[dimArrSym.Arreglo.SizeUni]; } break; case Tipo.BOOLEANARR: arrDato = new bool[dimArrSym.Arreglo.SizeBi][]; for (int i = 0; i < (arrDato as bool[][]).Length; i++) { (arrDato as bool[][])[i] = new bool[dimArrSym.Arreglo.SizeUni]; } break; case Tipo.CLASEARR: arrDato = new Clase[dimArrSym.Arreglo.SizeBi][]; for (int i = 0; i < (arrDato as Clase[][]).Length; i++) { (arrDato as Clase[][])[i] = new Clase[dimArrSym.Arreglo.SizeUni]; } break; } break; case TipoArreglo.TRI: switch (dimArrSym.TipoDato) { case Tipo.INTARR: arrDato = new int[dimArrSym.Arreglo.SizeTri][][]; for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++) { (arrDato as int[][][])[i] = new int[dimArrSym.Arreglo.SizeBi][]; for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++) { (arrDato as int[][][])[i][j] = new int[dimArrSym.Arreglo.SizeUni]; } } break; case Tipo.STRINGARR: arrDato = new string[dimArrSym.Arreglo.SizeTri][][]; for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++) { (arrDato as string[][][])[i] = new string[dimArrSym.Arreglo.SizeBi][]; for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++) { (arrDato as string[][][])[i][j] = new string[dimArrSym.Arreglo.SizeUni]; } } break; case Tipo.DOUBLEARR: arrDato = new double[dimArrSym.Arreglo.SizeTri][][]; for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++) { (arrDato as double[][][])[i] = new double[dimArrSym.Arreglo.SizeBi][]; for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++) { (arrDato as double[][][])[i][j] = new double[dimArrSym.Arreglo.SizeUni]; } } break; case Tipo.CHARARR: arrDato = new char[dimArrSym.Arreglo.SizeTri][][]; for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++) { (arrDato as char[][][])[i] = new char[dimArrSym.Arreglo.SizeBi][]; for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++) { (arrDato as char[][][])[i][j] = new char[dimArrSym.Arreglo.SizeUni]; } } break; case Tipo.BOOLEANARR: arrDato = new bool[dimArrSym.Arreglo.SizeTri][][]; for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++) { (arrDato as bool[][][])[i] = new bool[dimArrSym.Arreglo.SizeBi][]; for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++) { (arrDato as bool[][][])[i][j] = new bool[dimArrSym.Arreglo.SizeUni]; } } break; case Tipo.CLASEARR: arrDato = new Clase[dimArrSym.Arreglo.SizeTri][][]; for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++) { (arrDato as Clase[][][])[i] = new Clase[dimArrSym.Arreglo.SizeBi][]; for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++) { (arrDato as Clase[][][])[i][j] = new Clase[dimArrSym.Arreglo.SizeUni]; } } break; } break; } //asigna el dato al symClass symClass.Value.Dato = arrDato; } } //Importar clases foreach (var impNameClass in ClaseImpNames) { //Buscará coincidencias en el diccionario de clases if (Recorrido.Clases.ContainsKey(impNameClass)) { ClaseImp.Add(impNameClass, Clase.Copiar(Recorrido.Clases[impNameClass])); } else { Main.Imprimir(String.Format("No se encontró la importación : {0}", impNameClass)); return(true); } } //Verificará que las funciones marcadas como override existan en alguna clase importada bool flagOverride = false; foreach (var funClass in ClaseEnt) { if (funClass.Value.Override) { //Es una sobrecarga, lo que obliga que exista una función con el mismo nombre en //el listado de entornos de clases importadas foreach (var impClass in ClaseImp) { //Buscará en sus entornos un nombre igual if (impClass.Value.ClaseEnt.ContainsKey(funClass.Key)) { flagOverride = true; break; } } //No encontró ninguna coinciden, se termina la operación if (!flagOverride) { Main.Imprimir(String.Format("La función {0} no permite sobrecarga", funClass.Key)); return(true); } } } //Buscará una ocurrencia del main if (ClaseEnt.ContainsKey("main")) { //Recupera dicha ocurrencia Funcion func = ClaseEnt["main"]; //Ejecuta la ocurrencia Nativa.Print(String.Format("El main terminó en : {0}", func.Ejecutar())); } //Al finalizar copia las variables que se encuentran en el diccionario de simbolos local foreach (var locSym in ClaseSym) { Main.AgregarSimbolo(locSym.Key, locSym.Value, this.ToString()); } return(false); }
public object getValor(Ambito ambito) { try { List <Object> valores = getValoresParam(ambito); /// GENERO MI CLAVE PARA PODER OBTENER LA FUNCION QUE DESEO Clave clave = new Clave(this.id.ToLower(), getNodoParametros(ambito), ""); /// LLAMO A LA FUNCION QUE DESEO EJECUTAR Ambito aux = AmbitoDeClase(ambito); Funcion f = aux.GetFuncion(clave); if (f != null) { this.vibililidad = f.Vibililidad; ///CREO EL AMBITO DE LA FUNCION Ambito auxliar = new Ambito(aux, this.clase.ToLower(), ambito.archivo); this.vibililidad = f.Vibililidad; if (this.vibililidad == Estatico.Vibililidad.PROTEGIDO && !(ambito.idAmbito.ToLower().Contains(Estatico.temporal.idAmbito.ToLower()))) { return(new Nulo()); } ///SETEO LOS PARAMETROS QUE RECIBE auxliar = f.seteaParametrosLocales(auxliar, valores); ///OBTENGO EL VALOR QUE DEFINE Object valor = f.Ejecutar(auxliar); if (valor is NodoReturn) { Object valorReal = ((NodoReturn)valor).valor; String tipoEsperado = f.Tipo.ToLower(); if (tipoEsperado.Equals(((NodoReturn)valor).tipo.ToLower()) || ((NodoReturn)valor).tipo.ToLower().Equals("nulo")) { this.ValorAux = valorReal; return(valorReal); } else { TError error = new TError("Semantico", "El tipo de retorno no coincide: Tipo de Funcion: \"" + tipoEsperado + "\", encontrado: \"" + ((NodoReturn)valor).tipo.ToLower() + "\" | Clase: " + this.clase + " | " + ambito.archivo, this.linea, this.columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); return(new Nulo()); } } } else if (this.id.ToLower().Equals("buscar")) { Simbolo l = (Simbolo)ambito.getSimbolo("cutz");/// :) if (l != null) { Variable v = (Variable)l; Opciones listado = (Opciones)v.valor; if (valores.Count == 2) { if (valores.ElementAt(1) is int) { Object index1 = valores.ElementAt(0); int index2 = (int)valores.ElementAt(1); Object val = listado.obtenerDeLista(index1, index2); NodoReturn n = creaNodoReturn(val); this.ValorAux = n.valor; return(n.valor); } } } } else if (this.id.ToLower().Equals("obtener")) { Simbolo l = (Simbolo)ambito.getSimbolo("cutz"); if (l != null) { Variable v = (Variable)l; Opciones listado = (Opciones)v.valor; if (valores.ElementAt(0) is int && valores.ElementAt(1) is int) { int index1 = (int)valores.ElementAt(0); int index2 = (int)valores.ElementAt(1); Object val = listado.obtenerDeLista(index1, index2); NodoReturn n = creaNodoReturn(val); this.ValorAux = n.valor; return(n.valor); } } } else if (this.id.ToLower().Equals("insertar")) { Simbolo l = (Simbolo)ambito.getSimbolo("cutz"); if (l != null) { Variable v = (Variable)l; Opciones listado = (Opciones)v.valor; listado.agregarElementos(valores);/// INSERTA ELEMENTOS VACIOS return(new Vacio()); } } else { TError error = new TError("Semantico", "No existe funcion: " + this.id + " que reciba parametro: " + getMensajeError(ambito) + " | Clase: " + this.clase + " | " + ambito.archivo, this.linea, this.columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } } catch (Exception e) { TError error = new TError("Ejecucion", "Error al Buscar la funcion, en ejecucion | Erro: " + e.Message, this.linea, this.columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } return(new Nulo()); }