public BaseEmpleados ObtenerPosiblesEvaluadores(CentroTrabajo centro, Asig asig) { SqlConnection oCon = new SqlConnection(cadena); string comando = string.Empty; if (asig == Asig.Posibles) { comando = "dbo.getEvaluadoresPosiblesCentroTrabajo"; } else { comando = "dbo.getEvaluadoresAsignadosCentroTrabajo"; } SqlCommand oCmd = new SqlCommand(comando, oCon); oCmd.CommandType = CommandType.StoredProcedure; oCmd.Parameters.AddWithValue("@idCentro", centro.IDGlobal); SqlDataReader dr; BaseEmpleados lst = null; BaseEmpleado evaluador = null; try { oCon.Open(); dr = oCmd.ExecuteReader(); lst = new BaseEmpleados(); while (dr.Read()) { evaluador = new BaseEmpleado(); evaluador.IDGral = Convert.ToInt32(dr["IdGral"]); evaluador.CveEmpleado = Convert.ToInt32(dr["Empleado"]); evaluador.Paterno = dr["ApellidoPaterno"].ToString(); evaluador.Materno = dr["ApellidoMaterno"].ToString(); evaluador.Nombre = dr["Nombre"].ToString(); evaluador.RFC = dr["RFC"].ToString(); evaluador.DenominacionPlaza = dr["DenominacionPlaza"].ToString(); evaluador.Inicio = Convert.ToDateTime(dr["Inicio"]); evaluador.Fin = Convert.ToDateTime(dr["Fin"]); evaluador.Dias = Convert.ToInt32(dr["Dias"]); evaluador.IdFuncion = dr["Funcion"].ToString(); evaluador.IdUR = Convert.ToInt32(dr["idUR"]); evaluador.IdArea = Convert.ToInt32(dr["idArea"]); evaluador.IdEstado = Convert.ToInt32(dr["idEstado"]); evaluador.IdMunicipio = Convert.ToInt32(dr["idMunicipio"]); evaluador.IdCentroTrabajo = Convert.ToInt32(dr["idCentroTrabajo"]); evaluador.UnidadResponsable = dr["UnidadResponsable"].ToString(); evaluador.Area = dr["Area"].ToString(); evaluador.Municipio = dr["Municipio"].ToString(); evaluador.CentroDeTrabajo = dr["CentroDeTrabajo"].ToString(); evaluador.NivelSalarial = dr["NivelSalarial"].ToString(); lst.Add(evaluador); } oCon.Close(); } catch (Exception ex) { lst = null; } return(lst); }
public override TypeReturn CheckSemantics(List <Scope> scope_list, List <Error> errors) { countOfClicles++; bool problem = false; //para no meter una variable que esta mal en el Scope //hay que ver que no exista una variable ni una funcion con el mismo nombre que la del for foreach (Scope scope in scope_list) { if (scope.Vars.Any(s => s.Key.Equals(this.Name))) //pregunto por las variables { errors.Add(new Error(line, column, "Ya existe una variable con el nombre: " + Name)); problem = true; //no puedo anadirla porque ya existe } else if (scope.Funcs.Any(s => s.Key.Equals(this.Name))) //pregunto por las funciones { errors.Add(new Error(line, column, "Ya existe una funcion con el nombre: " + Name)); problem = true; //no puedo anadirla porque ya existe } } TypeReturn typeOfAsign = Asig.CheckSemantics(scope_list, errors); if (!(typeOfAsign is ReturnInt)) { errors.Add(new Error(line, column, "La expresion de asignacion debe retonar un entero")); problem = true; //no puedo anadirla porque la variable no es un entero } TypeReturn typeOfTo = To.CheckSemantics(scope_list, errors); if (!(typeOfTo is ReturnInt)) { errors.Add(new Error(line, column, "La expresion del To debe retornar un entero")); } if (!problem) //si no preguntara esto podria estar anadiendo una variable con problemas al Scope (en el Scope no hay nada con errores!) { varFor = new Var_Scope(Name, typeOfAsign, true); Dictionary <string, Var_Scope> param = new Dictionary <string, Var_Scope>(); param.Add(Name, varFor); Scope scopeBodyFor = new Scope(param, new Dictionary <string, TypeReturn>(), new Dictionary <string, Fun_Scope>()); //el scope para la variable del for scope_list.Add(scopeBodyFor); //agrego la variable del for a la lista de scope para que el body del for pueda verla //if(Body!=null) TypeReturn typeOfBody = Body.CheckSemantics(scope_list, errors); if (!(typeOfBody is ReturnNotValue)) { errors.Add(new Error(line, column, "La expresion del body del for no debe devolver nada")); } scope_list.Remove(scopeBodyFor); //remuevo la variable del for } countOfClicles--; return(new ReturnNotValue()); }
public override Type GenCode(ILGenerator ilGenerator, TypeBuilder parent, FieldBuilder IsBreakFields, List <FieldBuilder> level, Label endLabel) { FieldBuilder field = parent.DefineField(Name, v.Var_type.MyType(), FieldAttributes.Public); ilGenerator.Emit(OpCodes.Ldarg_0); //meto el this Asig.GenCode(ilGenerator, parent, IsBreakFields, level, endLabel); //meto el valor a asignar en la pila ilGenerator.Emit(OpCodes.Stfld, field); //asigna el valor del argumento al campo field v.VarbBuilder = field; //guardo el FieldBuilder de la variable para usarlo en el GenCode de VariableNode return(null); }
//Dada una tarea devuelve el sumatorio del trabajo asignado a cada recurso sobre esa tarea private decimal getSumatorioWork(XmlNodeList ListaAssignment, string sTaskUID) { decimal dRes = 0; foreach (XmlElement Asig in ListaAssignment) { //Recojo el código SUPER de la tarea XmlNodeList TaskUID = Asig.GetElementsByTagName("TaskUID"); if (sTaskUID == TaskUID[0].InnerText) { XmlNodeList Work = Asig.GetElementsByTagName("Work"); dRes += flDuracionSUPER(Work[0].InnerText); } } return(dRes); }
public override Type GenCode(ILGenerator ilGenerator, TypeBuilder parent, FieldBuilder IsBreakFields, List <FieldBuilder> level, Label endLabel) { //creo una clase para el for TypeBuilder forClass = parent.DefineNestedType("For" + Utils.AutoNumeric, TypeAttributes.NestedPublic | TypeAttributes.Class); //defino la clase anidada ConstructorBuilder forConstructor = forClass.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new List <Type>() { parent, typeof(int), typeof(int) }.ToArray()); ILGenerator ilFor = forConstructor.GetILGenerator(); //cojo el generador de la clase del for //creando el campo 'parent' FieldBuilder forParent = forClass.DefineField("parent", parent, FieldAttributes.Public); //defino el campo parent del for ilFor.Emit(OpCodes.Ldarg_0); //meto el this ilFor.Emit(OpCodes.Ldarg_1); //meto el padre en la pila ilFor.Emit(OpCodes.Stfld, forParent); //el padre ahora es el for (this.parent = forParent) //creando el campo 'Break' FieldBuilder field = forClass.DefineField("Break", typeof(bool), FieldAttributes.Public); ilFor.Emit(OpCodes.Ldarg_0); //meto el this ilFor.Emit(OpCodes.Ldc_I4_0); //meto un cero en la pila ilFor.Emit(OpCodes.Stfld, field); //crea el campo con false //creando el campo del i FieldBuilder index = forClass.DefineField(Name, typeof(int), FieldAttributes.Public); //i del for (de la clase) ilFor.Emit(OpCodes.Ldarg_0); //meto el this ilFor.Emit(OpCodes.Ldarg_2); //meto el padre en la pila ilFor.Emit(OpCodes.Stfld, index); //el padre ahora es el for (this.parent = forParent) //Type asignType = Asig.GenCode(ilFor, forClass, field,level, endLabel); //genero el codigo de la asignacion (mete la asignacion en la pila) //ilFor.Emit(OpCodes.Stfld, index); //actualizo el valor de la asignacion varFor.VarbBuilder = index; //creando el to del for FieldBuilder toBuilder = forClass.DefineField("To" + Utils.AutoNumeric, typeof(int), FieldAttributes.Public); //LocalBuilder to = ilFor.DeclareLocal(typeof(int)); //declaro el to del for (para quedarme con el valor) ilFor.Emit(OpCodes.Ldarg_0); //meto el this ilFor.Emit(OpCodes.Ldarg_3); //meto el padre en la pila ilFor.Emit(OpCodes.Stfld, toBuilder); //el padre ahora es el for (this.parent = forParent) //Type toType = To.GenCode(ilFor, forClass, field, level, endLabel); //en el tope esta el valor del to //ilFor.Emit(OpCodes.Stfld, toBuilder); //actualizo el valor de la asignacion //Cerrar el constructor ilFor.Emit(OpCodes.Ret); //creo el metodo donde se encuentra el body MethodBuilder bodyBuilder = forClass.DefineMethod("ForBody", MethodAttributes.Public, CallingConventions.HasThis, typeof(void), new Type[] { }); ILGenerator ilBody = bodyBuilder.GetILGenerator(); //comienza la generacion de codigo del for Label start = ilBody.DefineLabel(); Label end = ilBody.DefineLabel(); //comienza el for //meto en el tope el campo this.index ilBody.MarkLabel(start); //defino el comienzo del for ilBody.Emit(OpCodes.Ldarg_0); //meto el this ilBody.Emit(OpCodes.Ldfld, index); //meto la i del for //meto en el campo this.toBuilder ilBody.Emit(OpCodes.Ldarg_0); //meto el this ilBody.Emit(OpCodes.Ldfld, toBuilder); //meto el to del for ilBody.Emit(OpCodes.Bgt, end); //si i > to se acabo el for level.Add(forParent); //genero el codigo del body Type bodyType = Body.GenCode(ilBody, forClass, field, level, end); level.RemoveAt(level.Count - 1); ilBody.Emit(OpCodes.Ldarg_0); ilBody.Emit(OpCodes.Ldfld, field); ilBody.Emit(OpCodes.Ldc_I4_1); ilBody.Emit(OpCodes.Beq, end); //actualizo this.index ilBody.Emit(OpCodes.Ldarg_0); //meto el this ilBody.Emit(OpCodes.Ldarg_0); //meto el this ilBody.Emit(OpCodes.Ldfld, index); //busco el valor de this.i y lo dejo en el tope ilBody.Emit(OpCodes.Ldc_I4_1); //meto el 1 ilBody.Emit(OpCodes.Add); //i + 1 ilBody.Emit(OpCodes.Stfld, index); //i = i + 1 (uso el replace estatico porque lo que tengo en el tope es un valor y no una referencia) ilBody.Emit(OpCodes.Br, start); //comienza de nuevo el for ilBody.MarkLabel(end); //final ilBody.Emit(OpCodes.Ret); //se acabo el metodo del body del for forClass.CreateType(); //creo el tipo de la clase for // Crear una instancia del tipo que representa al for. ilGenerator.Emit(OpCodes.Ldarg_0); Asig.GenCode(ilGenerator, parent, IsBreakFields, level, endLabel); To.GenCode(ilGenerator, parent, IsBreakFields, level, endLabel); ilGenerator.Emit(OpCodes.Newobj, forConstructor); // Llamar al método que representa el cuerpo del for. ilGenerator.Emit(OpCodes.Callvirt, bodyBuilder); return(null); //el for no retorna valor }
public override TypeReturn CheckSemantics(List <Scope> scope_list, List <Error> errors) { int cant = errors.Count;//me da la cant de errores que hay hasta el momento TypeReturn typeOfAsign = Asig.CheckSemantics(scope_list, errors); TypeReturn typeVar; if (typeOfAsign == null) //cuando no existe la asignación { return(new ReturnNotValue()); } if (VarType == null) //no tiene tipo la variable { if ((typeOfAsign is ReturnNil) || (typeOfAsign is ReturnNotValue)) //si es nil o no retorna valor no se puede inferir el tipo { errors.Add(new Error(line, column, "No se puede inferir el tipo")); return(new ReturnNotValue()); } //Var_type = typeOfAsign.ToString(); //se infiere el tipo typeVar = typeOfAsign; } //tiene tipo la variable (VarType!=null) else { typeVar = Utils.FindType(scope_list, VarType); //busco el tipo de la variable if (typeVar == null) { errors.Add(new Error(line, column, "El tipo de la variable '" + Name + "' no existe")); //añado el error return(null); } // el tipo de la variable existe if (typeOfAsign is ReturnNil) //pregunto si la asignacion es nil y el Lvalue permite nil { if (typeVar is ReturnInt) { errors.Add(new Error(line, column, "No se le puede asignar un '" + typeOfAsign.ToString() + "' a un '" + typeVar + "'")); //añado el error } } else if (!typeVar.Equals(typeOfAsign)) { errors.Add(new Error(line, column, "No se le puede asignar un '" + typeOfAsign.ToString() + "' a un '" + typeVar + "'")); //añado el error } } if (scope_list[scope_list.Count - 1].Vars.ContainsKey(Name) || scope_list[scope_list.Count - 1].Funcs.ContainsKey(Name)) //ver si hay una funcion o una variable con ese nombre { errors.Add(new Error(line, column, "El nombre de la variable '" + Name + "' ya esta en uso")); //añado el error } if (cant == errors.Count) //si no hubo errores { v = new Var_Scope(Name, typeVar); scope_list[scope_list.Count - 1].Vars.Add(Name, v); //añado la variable al scope } return(new ReturnNotValue()); }