[BACK]Return to Auxiliares.c CVS log [TXT] [DIR] Up to [Repository ATC2] / ADD_ver_10

Diff for /ADD_ver_10/Attic/Auxiliares.c between versions 1.1 and 1.2

version 1.1, 2006/01/19 17:16:29 version 1.2, 2006/02/15 13:00:30
Line 22 Line 22
 /*                                                                  */  /*                                                                  */
 /*  --------------------------- History --------------------------- */  /*  --------------------------- History --------------------------- */
 /*                                                                  */  /*                                                                  */
   /*  Revision 1.3. 02/2006                                           */
   /*  Fix overflow error in expresion evaluating 'cantidad'           */
   /*                                                                  */
 /*  Revision 1.2. 01/2006                                           */  /*  Revision 1.2. 01/2006                                           */
 /*  Added GPL License and JavaDoc style documentation               */  /*  Added GPL License and JavaDoc style documentation               */
 /*                                                                  */  /*                                                                  */
Line 29 Line 32
 /*  Initial Revision                                                */  /*  Initial Revision                                                */
 /*                                                                  */  /*                                                                  */
 /********************************************************************/  /********************************************************************/
   
   
 /******************************************************************************/  /******************************************************************************/
 /* MÓDULO: Auxiliares.c                                                       */  /* MÓDULO: Auxiliares.c                                                       */
 /*                                                                            */  /*                                                                            */
Line 74  int BDBuscarCadena(int idtabla, int idca Line 75  int BDBuscarCadena(int idtabla, int idca
 {  {
     unsigned int i = 0;    /* los registros de las bases de datos comienzan en el índice 0 */      unsigned int i = 0;    /* los registros de las bases de datos comienzan en el índice 0 */
     int encontrado = NO;      int encontrado = NO;
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
   
     switch (idtabla)      switch (idtabla)
     {      {
Line 91  int BDBuscarCadena(int idtabla, int idca Line 92  int BDBuscarCadena(int idtabla, int idca
   
             default:              default:
             /* emitir un error al fichero de log */              /* emitir un error al fichero de log */
                         sprintf(mensaje, "[BDBuscarCadena] El campo no existe en la Tabla Nemónicos");              sprintf(mensaje, "[BDBuscarCadena] El campo no existe en la Tabla Nemónicos");
                         Notificar(mensaje, ERROR_SALIR, ECO_NO);              Notificar(mensaje, ERROR_SALIR, ECO_NO);
             break;              break;
         }          }
         break;          break;
Line 110  int BDBuscarCadena(int idtabla, int idca Line 111  int BDBuscarCadena(int idtabla, int idca
   
             default:              default:
             /* emitir un error al fichero de log */              /* emitir un error al fichero de log */
                         sprintf(mensaje, "[BDBuscarCadena] El campo no existe en la Tabla Símbolos");              sprintf(mensaje, "[BDBuscarCadena] El campo no existe en la Tabla Símbolos");
                         Notificar(mensaje, ERROR_SALIR, ECO_NO);              Notificar(mensaje, ERROR_SALIR, ECO_NO);
             break;              break;
         }          }
         break;          break;
Line 129  int BDBuscarCadena(int idtabla, int idca Line 130  int BDBuscarCadena(int idtabla, int idca
   
             default:              default:
             /* emitir un error al fichero de log */              /* emitir un error al fichero de log */
                         sprintf(mensaje, "[BDBuscarCadena] El campo no existe en la Tabla Ciclos");              sprintf(mensaje, "[BDBuscarCadena] El campo no existe en la Tabla Ciclos");
                         Notificar(mensaje, ERROR_SALIR, ECO_NO);              Notificar(mensaje, ERROR_SALIR, ECO_NO);
             break;              break;
         }          }
         break;          break;
Line 148  int BDBuscarCadena(int idtabla, int idca Line 149  int BDBuscarCadena(int idtabla, int idca
   
             default:              default:
             /* emitir un error al fichero de log */              /* emitir un error al fichero de log */
                         sprintf(mensaje, "[BDBuscarCadena] El campo no existe en la Tabla Ubicaciones");              sprintf(mensaje, "[BDBuscarCadena] El campo no existe en la Tabla Ubicaciones");
                         Notificar(mensaje, ERROR_SALIR, ECO_NO);              Notificar(mensaje, ERROR_SALIR, ECO_NO);
             break;              break;
         }          }
         break;          break;
   
                 default:          default:
         /* emitir un error al fichero de log */          /* emitir un error al fichero de log */
                 sprintf(mensaje, "[BDBuscarCadena] La tabla especificada no existe");          sprintf(mensaje, "[BDBuscarCadena] La tabla especificada no existe");
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
                 break;          break;
     }      }
     if(encontrado == NO) return(-1);      if(encontrado == NO) return(-1);
     else return(i);      else return(i);
Line 180  void AgregarElementoLista(char *lista, c Line 181  void AgregarElementoLista(char *lista, c
   
 unsigned int BuscarElementoLista(char *lista, char *cadena)  unsigned int BuscarElementoLista(char *lista, char *cadena)
 {  {
         char copialista[MAX_LISTA];      char copialista[MAX_LISTA];
     char *elemento;           /* es un puntero a char para la función strtok */      char *elemento;           /* es un puntero a char para la función strtok */
         unsigned int indice = 1;       unsigned int indice = 1; 
   
         strcpy(copialista, lista);      strcpy(copialista, lista);
   
         elemento = strtok(copialista, ":");    /* el separador de elementos de la lista es ':' */      elemento = strtok(copialista, ":");    /* el separador de elementos de la lista es ':' */
     while(elemento != NULL)      while(elemento != NULL)
     {      {
         if(strcmp(elemento, cadena) == 0) return indice;          if(strcmp(elemento, cadena) == 0) return indice;
                 else indice++;          else indice++;
   
                 /* capturo el siguiente campo */          /* capturo el siguiente campo */
         elemento = strtok(NULL, ":");          elemento = strtok(NULL, ":");
     }      }
         return 0;      return 0;
 /* esta función se puede implementar también usando 'strstr' */  /* esta función se puede implementar también usando 'strstr' */
 }  }
   
Line 205  unsigned int BuscarElementoLista(char *l Line 206  unsigned int BuscarElementoLista(char *l
   
 void EliminarElementoLista(char *lista, char *cadena)  void EliminarElementoLista(char *lista, char *cadena)
 {  {
         char *puntero;      char *puntero;
         unsigned int indice1;      unsigned int indice1;
         unsigned int indice2 = 1;      unsigned int indice2 = 1;
               
         puntero = lista;      puntero = lista;
         indice1 = BuscarElementoLista(lista, cadena);      indice1 = BuscarElementoLista(lista, cadena);
   
         if(indice1 == 0) return;      if(indice1 == 0) return;
   
         while(indice2 != indice1)      while(indice2 != indice1)
         {      {
                 if(*puntero == ':') indice2++;          if(*puntero == ':') indice2++;
                 puntero++;          puntero++;
         }      }
   
         if(puntero != lista)            /* el elemento no es el primero */      if(puntero != lista)        /* el elemento no es el primero */
         {      {
                 *(puntero - 1) = '\0';  /* corto la cadena en el separador antes del elemento */          *(puntero - 1) = '\0';    /* corto la cadena en el separador antes del elemento */
                 if(*(puntero + strlen(cadena)) == ':')  /* el elemento no es el último */          if(*(puntero + strlen(cadena)) == ':')    /* el elemento no es el último */
                 {          {
                         strcat(lista, (puntero + strlen(cadena)));              strcat(lista, (puntero + strlen(cadena)));
                 }          }
         }      }
         else strcpy(lista, (puntero + strlen(cadena) + 1));      else strcpy(lista, (puntero + strlen(cadena) + 1));
 }  }
   
   
Line 237  void EliminarElementoLista(char *lista, Line 238  void EliminarElementoLista(char *lista,
   
 void IniciarTarjeta(fichainstruccion *tarjetaoperandos)  void IniciarTarjeta(fichainstruccion *tarjetaoperandos)
 {  {
         strcpy(tarjetaoperandos->nemonico, "");      strcpy(tarjetaoperandos->nemonico, "");
     strcpy(tarjetaoperandos->op1, "");      strcpy(tarjetaoperandos->op1, "");
     strcpy(tarjetaoperandos->op2, "");      strcpy(tarjetaoperandos->op2, "");
     strcpy(tarjetaoperandos->hexadecimal, "");      strcpy(tarjetaoperandos->hexadecimal, "");
Line 270  void IniciarTarjeta(fichainstruccion *ta Line 271  void IniciarTarjeta(fichainstruccion *ta
   
 unsigned long TamanoFichero(char *fichero)  unsigned long TamanoFichero(char *fichero)
 {  {
         FILE *handle;      FILE *handle;
         unsigned long tamano = 0;      unsigned long tamano = 0;
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
   
   
         if((handle = fopen(fichero, "rb")) != NULL)      if((handle = fopen(fichero, "rb")) != NULL)
     {      {
         /*          /*
                 sprintf(mensaje, "[TamañoFichero] El fichero '%s' se ha abierto con éxito", fichero);          sprintf(mensaje, "[TamañoFichero] El fichero '%s' se ha abierto con éxito", fichero);
                 Notificar(mensaje, NO_ERROR, ECO_NO);          Notificar(mensaje, NO_ERROR, ECO_NO);
                 */          */
   
                 fseek(handle, 0L, SEEK_END);          fseek(handle, 0L, SEEK_END);
                 tamano = ftell(handle);          tamano = ftell(handle);
   
         /* cierro el fichero */          /* cierro el fichero */
         if(fclose(handle))          if(fclose(handle))
                 {          {
                         sprintf(mensaje, "[TamañoFichero] El fichero '%s' no se ha podido cerrar", fichero);              sprintf(mensaje, "[TamañoFichero] El fichero '%s' no se ha podido cerrar", fichero);
                         Notificar(mensaje, ERROR_SEGUIR, ECO_NO);              Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
                 }          }
     }      }
     else      else
         {      {
                 sprintf(mensaje, "[TamañoFichero] El fichero '%s' no se ha podido abrir", fichero);          sprintf(mensaje, "[TamañoFichero] El fichero '%s' no se ha podido abrir", fichero);
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
         }      }
   
         return tamano;      return tamano;
 }  }
   
   
   
 void DeterminarRango()  void DeterminarRango()
 {  {
         unsigned long total_instrucciones;      /* total en la traza */      unsigned long total_instrucciones;    /* total en la traza */
         unsigned long cantidad;                         /* cantidad a analizar */      unsigned long cantidad;                /* cantidad a analizar */
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
   
         /* calculo la cantidad de instrucciones en la traza a partir del tamaño del fichero */       /* calculo la cantidad de instrucciones en la traza a partir del tamaño del fichero */ 
         total_instrucciones = TamanoFichero(configuracion.ficherodatos)/BYTES_POR_INSTRUCCION;      total_instrucciones = TamanoFichero(configuracion.ficherodatos)/BYTES_POR_INSTRUCCION;
   
         /*      /*
         printf("Total instrucciones en '%s' = %lu\n", configuracion.ficherodatos, total_instrucciones);      printf("Total instrucciones en '%s' = %lu\n", configuracion.ficherodatos, total_instrucciones);
         _getch();      _getch();
         */      */
   
         if(configuracion.ultima == 0)   /* significa que manda el rango */      if(configuracion.ultima == 0)    /* significa que manda el rango */
         {      {
                 cantidad = (unsigned long)(configuracion.rango * total_instrucciones)/100.00;          /* cantidad = (unsigned long)(configuracion.rango * total_instrucciones)/100.00; */
                   
                 if(configuracion.primera == 0)  /* significa que manda el porcentaje de comienzo */          cantidad = (unsigned long)((configuracion.rango/100.00) * total_instrucciones);
                 configuracion.primera = (unsigned long) 1 + (configuracion.comienzo * total_instrucciones)/100.00;  
                 /* la cuenta de instrucciones comienza en '1' */          
           if(configuracion.primera == 0)    /* significa que manda el porcentaje de comienzo */
                 else if(configuracion.primera > total_instrucciones)  
                 {          /* configuracion.primera = (unsigned long) 1 + (configuracion.comienzo * total_instrucciones)/100.00; */
                         sprintf(mensaje, "[DeterminarRango] La primera instrucción está fuera del fichero de datos");          
                         Notificar(mensaje, ERROR_SALIR, ECO_NO);          configuracion.primera = (unsigned long) 1 + (configuracion.comienzo/100.00) * total_instrucciones;
                 }          /* la cuenta de instrucciones comienza en '1' */
                 configuracion.ultima = configuracion.primera + cantidad;  
                 if(configuracion.ultima > total_instrucciones) configuracion.ultima = total_instrucciones;          else if(configuracion.primera > total_instrucciones)
         }          {
               sprintf(mensaje, "[DeterminarRango] La primera instrucción está fuera del fichero de datos");
         cantidad = configuracion.ultima - configuracion.primera + 1;              Notificar(mensaje, ERROR_SALIR, ECO_NO);
                   }
         if(cantidad < configuracion.ventana)          configuracion.ultima = configuracion.primera + cantidad;
         {          if(configuracion.ultima > total_instrucciones) configuracion.ultima = total_instrucciones;
                 sprintf(mensaje, "[DeterminarRango] El rango de análisis es demasiado pequeño");      }
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);  
         }      cantidad = configuracion.ultima - configuracion.primera + 1;
       
       if(cantidad < configuracion.ventana)
       {
           sprintf(mensaje, "[DeterminarRango] El rango de análisis es demasiado pequeño");
           Notificar(mensaje, ERROR_SALIR, ECO_NO);
       }
 }  }
   
   
Line 353  void DeterminarRango() Line 360  void DeterminarRango()
   
 double CalcularNuevoPromedio (double promedioanterior, double valoractual, unsigned long n)  double CalcularNuevoPromedio (double promedioanterior, double valoractual, unsigned long n)
 {  {
         double nuevopromedio;      double nuevopromedio;
   
       /* nuevopromedio = ((n - 1) * promedioanterior + valoractual) / n; */
   
         nuevopromedio = ((n - 1) * promedioanterior + valoractual) / n;      nuevopromedio = promedioanterior + (double)((valoractual - promedioanterior) / n);
   
         return nuevopromedio;      return nuevopromedio;
 }  }
   
   
Line 365  double CalcularNuevoPromedio (double pro Line 374  double CalcularNuevoPromedio (double pro
   
 double InversoNormalizado (unsigned int dimension, double valor)  double InversoNormalizado (unsigned int dimension, double valor)
 {  {
         double inverso;      double inverso;
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
   
         if(valor == 0.0)      if(valor == 0.0)
         {      {
                 sprintf(mensaje, "[InversoNormalizado] El valor del denominador es nulo");          sprintf(mensaje, "[InversoNormalizado] El valor del denominador es nulo");
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
         }      }
   
         if(dimension == 0)      if(dimension == 0)
         {      {
                 sprintf(mensaje, "[InversoNormalizado] La dimensión de la normalización es nula");          sprintf(mensaje, "[InversoNormalizado] La dimensión de la normalización es nula");
                 Notificar(mensaje, ERROR_SEGUIR, ECO_NO);          Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
         }      }
   
         inverso = dimension / valor;      inverso = dimension / valor;
   
         return inverso;      return inverso;
 }  }
   
   
Line 395  double InversoNormalizado (unsigned int Line 404  double InversoNormalizado (unsigned int
   
 void CadenaEnsamblador(char *prefijo, char *nemonico, char *operando1, char *operando2, unsigned char notacion, char *cadena)  void CadenaEnsamblador(char *prefijo, char *nemonico, char *operando1, char *operando2, unsigned char notacion, char *cadena)
 {  {
         char auxiliar[2*MAX_NEMO + 2*MAX_OPE];      char auxiliar[2*MAX_NEMO + 2*MAX_OPE];
               
         switch(notacion)      switch(notacion)
         {      {
                 case 0:         /* notación de INTEL */          case 0:        /* notación de INTEL */
   
                 sprintf(cadena, "%s%s", prefijo, prefijo[0]!='\0' ? " ":"");          sprintf(cadena, "%s%s", prefijo, prefijo[0]!='\0' ? " ":"");
   
                 sprintf(auxiliar, "%s", nemonico);          sprintf(auxiliar, "%s", nemonico);
                 strcat(cadena, auxiliar);          strcat(cadena, auxiliar);
   
                 sprintf(auxiliar, "%s%s", operando1[0]!='\0' ? " ":"", operando1);          sprintf(auxiliar, "%s%s", operando1[0]!='\0' ? " ":"", operando1);
                 strcat(cadena, auxiliar);          strcat(cadena, auxiliar);
   
                 sprintf(auxiliar, "%s%s%s", (operando1[0]!='\0' && operando2[0]!='\0') ? ",":"", operando2[0]!='\0' ? " ":"", operando2);          sprintf(auxiliar, "%s%s%s", (operando1[0]!='\0' && operando2[0]!='\0') ? ",":"", operando2[0]!='\0' ? " ":"", operando2);
                 strcat(cadena, auxiliar);          strcat(cadena, auxiliar);
   
                 /* más elegante usar el índice que devuelve sprintf y sumarlo al puntero cadena */          /* más elegante usar el índice que devuelve sprintf y sumarlo al puntero cadena */
                 /* sprintf(cadena + i, ""... */          /* sprintf(cadena + i, ""... */
                 break;          break;
   
                 case 1:         /* notación ATT */          case 1:        /* notación ATT */
                 break;          break;
         }      }
 }  }
   
   
Line 426  void CadenaEnsamblador(char *prefijo, ch Line 435  void CadenaEnsamblador(char *prefijo, ch
   
 void ConvertirHex2Bin(char *cadenahex, unsigned char *secuencia, unsigned char maxformato)  void ConvertirHex2Bin(char *cadenahex, unsigned char *secuencia, unsigned char maxformato)
 {  {
         int i;      int i;
         char bytehex[3];      char bytehex[3];
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
   
         /* control de errores */      /* control de errores */
         if(strlen(cadenahex)==0)      if(strlen(cadenahex)==0)
         {      {
                 sprintf(mensaje, "[ConvertirHex2Bin] La cadena hexadecimal está vacía");          sprintf(mensaje, "[ConvertirHex2Bin] La cadena hexadecimal está vacía");
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
         }      }
         else if(strlen(cadenahex)%2!=0)      else if(strlen(cadenahex)%2!=0)
         {      {
                 sprintf(mensaje, "[ConvertirHex2Bin] La cadena hexadecimal '%s' no contiene un número entero de bytes", cadenahex);          sprintf(mensaje, "[ConvertirHex2Bin] La cadena hexadecimal '%s' no contiene un número entero de bytes", cadenahex);
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
         }      }
               
         /* relleno la secuencia de 2 instrucciones en binario con 0s */      /* relleno la secuencia de 2 instrucciones en binario con 0s */
         /* (2 instrucciones de tamaño máximo 'maxformato') */      /* (2 instrucciones de tamaño máximo 'maxformato') */
         for(i=0; i<2*maxformato; i++) *(secuencia+i) = 0;      for(i=0; i<2*maxformato; i++) *(secuencia+i) = 0;
               
         do      do
         {      {
                 for(i=0; i<2; i++)          for(i=0; i<2; i++)
                 {          {
                         bytehex[i]=*(cadenahex+i);              bytehex[i]=*(cadenahex+i);
                         if(isxdigit(bytehex[i])==0)             /* error -> dígito no hexadecimal */              if(isxdigit(bytehex[i])==0)        /* error -> dígito no hexadecimal */
                         {              {
                                 sprintf(mensaje, "[ConvertirHex2Bin] El byte '%s' contiene un dígito no hexadecimal", cadenahex);                  sprintf(mensaje, "[ConvertirHex2Bin] El byte '%s' contiene un dígito no hexadecimal", cadenahex);
                                 Notificar(mensaje, ERROR_SALIR, ECO_NO);                  Notificar(mensaje, ERROR_SALIR, ECO_NO);
                         }              }
                 }          }
                 bytehex[3]='\0';          bytehex[3]='\0';
                 sscanf(bytehex, "%2X", secuencia);          sscanf(bytehex, "%2X", secuencia);
                 secuencia++;          secuencia++;
         }      }
         while(*(cadenahex+=2)!='\0');      while(*(cadenahex+=2)!='\0');
 }  }
   
 /* NOTA: otra posibilidad para esta función consiste en copiar la cadena hexadecimal */  /* NOTA: otra posibilidad para esta función consiste en copiar la cadena hexadecimal */
Removed from v.1.1  
changed lines
  Added in v.1.2

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>