Ejemplo n.º 1
0
 public cl_error_Info(string _Id, string _detalle, string _sfecha, string _Estado, eTipoError _TipoError, eTipoRespuesta _TipoRespuesta)
 {
     Id             = _Id;
     detalle        = _detalle;
     sfecha         = _sfecha;
     Estado         = _Estado;
     TipoError      = _TipoError;
     TipoRespuesta  = _TipoRespuesta;
     sTipoRespuesta = _TipoRespuesta.ToString();
 }
 public tb_sis_Log_Error_Vzen_Info(string _detalle, eTipoError _Tipo, string _Clase, string _Pantalla, string _Asamble, string _Usuario, string _Ip, string _PC, DateTime _Fecha_Trans)
 {
     Detalle     = _detalle;
     Tipo        = _Tipo.ToString();
     Clase       = _Clase;
     Pantalla    = _Pantalla;
     Asamble     = _Asamble;
     Usuario     = _Usuario;
     Ip          = _Ip;
     PC          = _PC;
     Fecha_Trans = _Fecha_Trans;
 }
Ejemplo n.º 3
0
        public void Log_Error(string msg, eTipoError TipoError, string clase, string mensaje2 = null, Boolean GuardarLog = false)
        {
            try
            {
                string  mensaje = "";
                Boolean Guardar = true;


                if (TipoError == eTipoError.LOG)
                {
                    if (param.Parametro_Info != null)
                    {
                        if (param.Parametro_Info.Registra_Log == false || param.Parametro_Info.Registra_Log == null)
                        {
                            Guardar = false;
                        }
                    }
                }



                if (Guardar == true)
                {
                    tb_sis_Log_Error_Vzen_Info Log_Error_sis = new tb_sis_Log_Error_Vzen_Info(msg, TipoError, clase, mensaje2,
                                                                                              "", "", "", "", DateTime.Now);

                    oData.Guardar_Log_Error(Log_Error_sis, ref msg, true);
                }
            }
            catch (Exception ex)
            {
                //_path = Path.GetTempPath();
                string RutaFile = Path.GetTempPath();
                string _file    = RutaFile + "\\Log_" + DateTime.Now.Year + DateTime.Now.Month + DateTime.Now.Day + DateTime.Now.Hour + DateTime.Now.Minute + ".txt";
                System.IO.File.WriteAllText(_file, msg);
            }
        }
Ejemplo n.º 4
0
        void EvaluarInstruccion()
        {
            emTipoError = eTipoError.TE_TODO_BIEN;
            switch (emInstruccion)
            {
                case eInsrucciones.MOV:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO_REGISTRO:
                            registros[imValDestino] = registros[imValOrigen];
                            programLength += 2;
                            break;
                        case eTipoOperando.TO_REGISTRO_INMEDIATO:
                            registros[imValDestino] = imValOrigen;
                            break;
                        case eTipoOperando.TO_INMEDIATO_REGISTRO:
                            // Error
                            emTipoError = eTipoError.TE_OPERANDO_DESTINO_NO_INMEDIATO;
                            break;
                        case eTipoOperando.TO_REGISTRO_MEMORIA:
                            registros[imValDestino] = memoria[imValOrigen].getContenido();
                            programLength += 3;
                            break;
                        case eTipoOperando.TO_MEMORIA_REGISTRO:
                            memoria[imValDestino].setContenido(registros[imValOrigen]);
                            break;
                        default:
                            break;
                    }
                    break;
                case eInsrucciones.ADD:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO_REGISTRO:
                            registros[imValDestino] += registros[imValOrigen];
                            break;
                        case eTipoOperando.TO_REGISTRO_INMEDIATO:
                            registros[imValDestino] += imValOrigen;
                            break;
                        case eTipoOperando.TO_INMEDIATO_REGISTRO:
                            // Error
                            emTipoError = eTipoError.TE_OPERANDO_DESTINO_NO_INMEDIATO;
                            break;
                        case eTipoOperando.TO_REGISTRO_MEMORIA:
                            registros[imValDestino] += memoria[imValOrigen].getContenido();
                            break;
                        case eTipoOperando.TO_MEMORIA_REGISTRO:
                            int contenido = memoria[imValDestino].getContenido();
                            contenido += registros[imValOrigen];
                            memoria[imValDestino].setContenido(contenido);
                            break;
                        default:
                            break;
                    }
                    break;
                case eInsrucciones.SUB:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO_REGISTRO:
                            registros[imValDestino] -= registros[imValOrigen];
                            break;
                        case eTipoOperando.TO_REGISTRO_INMEDIATO:
                            registros[imValDestino] -= imValOrigen;
                            break;
                        case eTipoOperando.TO_INMEDIATO_REGISTRO:
                            // Error
                            emTipoError = eTipoError.TE_OPERANDO_DESTINO_NO_INMEDIATO;
                            break;
                        case eTipoOperando.TO_REGISTRO_MEMORIA:
                            registros[imValDestino] -= memoria[imValOrigen].getContenido();
                            break;
                        case eTipoOperando.TO_MEMORIA_REGISTRO:
                            int contenido = memoria[imValDestino].getContenido();
                            contenido -= registros[imValOrigen];
                            memoria[imValDestino].setContenido(contenido);
                            break;
                        default:
                            break;
                    }

                    break;
                case eInsrucciones.MUL:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO_REGISTRO:
                            registros[imValDestino] *= registros[imValOrigen];
                            break;
                        case eTipoOperando.TO_REGISTRO_INMEDIATO:
                            registros[imValDestino] *= imValOrigen;
                            break;
                        case eTipoOperando.TO_INMEDIATO_REGISTRO:
                            // Error
                            emTipoError = eTipoError.TE_OPERANDO_DESTINO_NO_INMEDIATO;
                            break;
                        case eTipoOperando.TO_REGISTRO_MEMORIA:
                            registros[imValDestino] *= memoria[imValOrigen].getContenido();
                            break;
                        case eTipoOperando.TO_MEMORIA_REGISTRO:
                            int contenido = memoria[imValDestino].getContenido();
                            contenido *= registros[imValOrigen];
                            memoria[imValDestino].setContenido(contenido);
                            break;
                        default:
                            break;
                    }
                    break;
                case eInsrucciones.DIV:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO_REGISTRO:
                            registros[imValDestino] /= registros[imValOrigen];
                            break;
                        case eTipoOperando.TO_REGISTRO_INMEDIATO:
                            registros[imValDestino] /= imValOrigen;
                            break;
                        case eTipoOperando.TO_INMEDIATO_REGISTRO:
                            // Error
                            emTipoError = eTipoError.TE_OPERANDO_DESTINO_NO_INMEDIATO;
                            break;
                        case eTipoOperando.TO_REGISTRO_MEMORIA:
                            registros[imValDestino] /= memoria[imValOrigen].getContenido();
                            break;
                        case eTipoOperando.TO_MEMORIA_REGISTRO:
                            int contenido = memoria[imValDestino].getContenido();
                            contenido /= registros[imValOrigen];
                            memoria[imValDestino].setContenido(contenido);
                            break;
                        default:
                            break;
                    }
                    break;
                case eInsrucciones.AND:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO_REGISTRO:
                            registros[imValDestino] &= registros[imValOrigen];
                            break;
                        case eTipoOperando.TO_REGISTRO_INMEDIATO:
                            registros[imValDestino] &= imValOrigen;
                            break;
                        case eTipoOperando.TO_INMEDIATO_REGISTRO:
                            // Error
                            emTipoError = eTipoError.TE_OPERANDO_DESTINO_NO_INMEDIATO;
                            break;
                        case eTipoOperando.TO_REGISTRO_MEMORIA:
                            registros[imValDestino] &= memoria[imValOrigen].getContenido();
                            break;
                        case eTipoOperando.TO_MEMORIA_REGISTRO:
                            int contenido = memoria[imValDestino].getContenido();
                            contenido &= registros[imValOrigen];
                            memoria[imValDestino].setContenido(contenido);
                            break;
                        default:
                            break;
                    }
                    break;
                case eInsrucciones.OR:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO_REGISTRO:
                            registros[imValDestino] |= registros[imValOrigen];
                            break;
                        case eTipoOperando.TO_REGISTRO_INMEDIATO:
                            registros[imValDestino] |= imValOrigen;
                            break;
                        case eTipoOperando.TO_INMEDIATO_REGISTRO:
                            // Error
                            emTipoError = eTipoError.TE_OPERANDO_DESTINO_NO_INMEDIATO;
                            break;
                        case eTipoOperando.TO_REGISTRO_MEMORIA:
                            registros[imValDestino] |= memoria[imValOrigen].getContenido();
                            break;
                        case eTipoOperando.TO_MEMORIA_REGISTRO:
                            int contenido = memoria[imValDestino].getContenido();
                            contenido |= registros[imValOrigen];
                            memoria[imValDestino].setContenido(contenido);

                            break;
                        default:
                            break;
                    }
                    break;
                case eInsrucciones.XOR:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO_REGISTRO:
                            registros[imValDestino] |= registros[imValOrigen];
                            break;
                        case eTipoOperando.TO_REGISTRO_INMEDIATO:
                            registros[imValDestino] |= imValOrigen;
                            break;
                        case eTipoOperando.TO_INMEDIATO_REGISTRO:
                            // Error
                            emTipoError = eTipoError.TE_OPERANDO_DESTINO_NO_INMEDIATO;
                            break;
                        case eTipoOperando.TO_REGISTRO_MEMORIA:
                            registros[imValDestino] |= memoria[imValOrigen].getContenido();
                            break;
                        case eTipoOperando.TO_MEMORIA_REGISTRO:
                            int contenido = memoria[imValDestino].getContenido();
                            contenido |= registros[imValOrigen];
                            memoria[imValDestino].setContenido(contenido); ;
                            break;
                        default:
                            break;
                    }
                    break;
                case eInsrucciones.XNOR:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO_REGISTRO:
                            registros[imValDestino] |= registros[imValOrigen];
                            break;
                        case eTipoOperando.TO_REGISTRO_INMEDIATO:
                            registros[imValDestino] |= imValOrigen;
                            break;
                        case eTipoOperando.TO_INMEDIATO_REGISTRO:
                            // Error
                            emTipoError = eTipoError.TE_OPERANDO_DESTINO_NO_INMEDIATO;
                            break;
                        case eTipoOperando.TO_REGISTRO_MEMORIA:
                            registros[imValDestino] |= memoria[imValOrigen].getContenido();
                            break;
                        case eTipoOperando.TO_MEMORIA_REGISTRO:
                            int contenido = memoria[imValDestino].getContenido();
                            contenido |= registros[imValOrigen];
                            memoria[imValDestino].setContenido(contenido);
                            break;
                        default:
                            break;
                    }
                    break;
                case eInsrucciones.INC:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO:
                            registros[imValDestino]++;
                            break;
                        case eTipoOperando.TO_MEMORIA:
                            int contenido = memoria[imValDestino].getContenido();
                            contenido++;
                            memoria[imValDestino].setContenido(contenido);
                            break;
                        default:
                            break;
                    }
                    break;
                case eInsrucciones.DEC:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO:
                            registros[imValDestino]--;
                            break;
                        case eTipoOperando.TO_MEMORIA:
                            int contenido = memoria[imValDestino].getContenido();
                            contenido--;
                            memoria[imValDestino].setContenido(contenido);
                            ;
                            break;
                        default:
                            break;
                    }
                    break;
                case eInsrucciones.CMP:
                    switch (emTipoOperando)
                    {
                        case eTipoOperando.TO_REGISTRO_REGISTRO:
                            if (registros[imValDestino] == registros[imValOrigen])
                            {
                                zf = false;
                            }
                            else {
                                zf = true;
                            }
                            break;
                        case eTipoOperando.TO_REGISTRO_INMEDIATO:
                            if (registros[imValDestino] == imValOrigen)
                            {
                                zf = false;
                            }
                            else {
                                zf = true;
                            }
                            break;
                        case eTipoOperando.TO_INMEDIATO_INMEDIATO:
                            // Error el primer operando no puede ser un inmediato
                            break;
                        case eTipoOperando.TO_INMEDIATO_REGISTRO:
                            if (imValDestino == registros[imValOrigen])
                            {
                                zf = false;
                            }
                            else {
                                zf = true;
                            }
                            break;
                        case eTipoOperando.TO_REGISTRO_MEMORIA:
                            if (registros[imValDestino] == memoria[imValOrigen].getContenido())
                            {
                                zf = false;
                            }
                            else {
                                zf = true;
                            }
                            break;
                        case eTipoOperando.TO_MEMORIA_REGISTRO:
                            if (memoria[imValDestino].getContenido() == registros[imValOrigen])
                            {
                                zf = false;
                            }
                            else {
                                zf = true;
                            }
                            break;
                        default:
                            break;
                    }
                    break;
                default:
                    break;
            }
        }