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

Diff for /ADD_ver_10/Attic/Main.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 30 Line 30
 /*                                                                  */  /*                                                                  */
 /********************************************************************/  /********************************************************************/
   
   
 /******************************************************************************/  /******************************************************************************/
 /* MÓDULO: Main.c                                                             */  /* MÓDULO: Main.c                                                             */
 /*                                                                            */  /*                                                                            */
Line 82  int **pizarra_lecturas = NULL; Line 81  int **pizarra_lecturas = NULL;
 unsigned char *vector = NULL;  unsigned char *vector = NULL;
   
 struct punterosD matriz;  struct punterosD matriz;
 unsigned char **matrizC = NULL; /* matriz de caminos de dependencias */  unsigned char **matrizC = NULL;    /* matriz de caminos de dependencias */
 char **OrdenParcial = NULL;             /* lista de instrucciones según orden parcial de D */  char **OrdenParcial = NULL;        /* lista de instrucciones según orden parcial de D */
   
 /* parámetros asociados a las matrices */   /* parámetros asociados a las matrices */ 
 parametromatriz *pasos = NULL;  parametromatriz *pasos = NULL;
Line 98  parametromatriz *mediaacoplo = NULL; Line 97  parametromatriz *mediaacoplo = NULL;
   
 void ProcesarInstruccion(unsigned int ins, unsigned char secuencia[12], fichainstruccion *tarjetaoperandos)  void ProcesarInstruccion(unsigned int ins, unsigned char secuencia[12], fichainstruccion *tarjetaoperandos)
 {  {
         AnalizarOperandosIA16(secuencia, tarjetaoperandos);      AnalizarOperandosIA16(secuencia, tarjetaoperandos);
   
         if(configuracion.recuentos == SI) ActualizarRecuentos(tarjetaoperandos);      if(configuracion.recuentos == SI) ActualizarRecuentos(tarjetaoperandos);
   
         if(configuracion.cpi == SI) CalcularCiclosInstruccion(tarjetaoperandos);      if(configuracion.cpi == SI) CalcularCiclosInstruccion(tarjetaoperandos);
   
         if(configuracion.CPImedio == SI) ActualizarCPImedio(tarjetaoperandos->ciclosALU, tarjetaoperandos->ciclosBIU);      if(configuracion.CPImedio == SI) ActualizarCPImedio(tarjetaoperandos->ciclosALU, tarjetaoperandos->ciclosBIU);
   
         if(configuracion.dependencias == SI)      if(configuracion.dependencias == SI)
         {      {
                 AnalizarDependencias(tarjetaoperandos, ins);          AnalizarDependencias(tarjetaoperandos, ins);
   
                 AnotarEscrituras(tarjetaoperandos, ins);          AnotarEscrituras(tarjetaoperandos, ins);
                 AnotarLecturas(tarjetaoperandos, ins);          AnotarLecturas(tarjetaoperandos, ins);
   
                 /* si tengo que calcular el tiempo de ejecución */          /* si tengo que calcular el tiempo de ejecución */
                 /* debo construir un array con el tipo de instrucción */          /* debo construir un array con el tipo de instrucción */
                 /* y su latencia en ciclos */          /* y su latencia en ciclos */
         }      }
 }  }
   
 void IniciarVentana()  void IniciarVentana()
 {  {
         if(configuracion.dependencias == SI)      if(configuracion.dependencias == SI)
         {      {
                 IniciarPizarras();          IniciarPizarras();
                 IniciarVectorDependencias();          IniciarVectorDependencias();
                 IniciarMatricesDependencias();          IniciarMatricesDependencias();
                 if(configuracion.ordenparcial == SI) IniciarListaOrdenParcial();          if(configuracion.ordenparcial == SI) IniciarListaOrdenParcial();
                 if(configuracion.matrizcaminos == SI) IniciarMatrizCaminos();          if(configuracion.matrizcaminos == SI) IniciarMatrizCaminos();
                 if(configuracion.pasoscomputacion == SI) IniciarVariableAgregada(pasos);          if(configuracion.pasoscomputacion == SI) IniciarVariableAgregada(pasos);
                 if(configuracion.gradoparalelismo == SI) IniciarVariableAgregada(grado);;          if(configuracion.gradoparalelismo == SI) IniciarVariableAgregada(grado);;
                 if(configuracion.acoplamiento == SI) IniciarVariableAgregada(acoplo);          if(configuracion.acoplamiento == SI) IniciarVariableAgregada(acoplo);
         }      }
 }  }
   
 void ProcesarVentana()  void ProcesarVentana()
 {  {
         if(configuracion.dependencias == SI)      if(configuracion.dependencias == SI)
         {      {
                 GenerarMatrizD();               /* a partir de las matrices desacopladas */          GenerarMatrizD();        /* a partir de las matrices desacopladas */
   
                 /* EXTRAIGO INFORMACIÓN DE LAS MATRICES */          /* EXTRAIGO INFORMACIÓN DE LAS MATRICES */
                 /* lista orden parcial (la función también puede devolver pasos) */          /* lista orden parcial (la función también puede devolver pasos) */
                 if(configuracion.ordenparcial == SI) ListaOrdenParcial(matriz.D, OrdenParcial);          if(configuracion.ordenparcial == SI) ListaOrdenParcial(matriz.D, OrdenParcial);
                 /* matriz de caminos (la función también puede devolver pasos) */          /* matriz de caminos (la función también puede devolver pasos) */
                 if(configuracion.matrizcaminos == SI) CalcularMatrizCaminos(matriz.D, matrizC);          if(configuracion.matrizcaminos == SI) CalcularMatrizCaminos(matriz.D, matrizC);
                 /* pasos de computación */          /* pasos de computación */
                 if(configuracion.pasoscomputacion == SI)          if(configuracion.pasoscomputacion == SI)
                 {          {
                         /* pasos de computación de todas las matrices de dependencias */              /* pasos de computación de todas las matrices de dependencias */
                         CalcularPasosComputacion(pasos);              CalcularPasosComputacion(pasos);
                         if(configuracion.distribucionpasos == SI) ActualizarHistogramaPasos();              if(configuracion.distribucionpasos == SI) ActualizarHistogramaPasos();
                         /* valor medio de pasos de computación */              /* valor medio de pasos de computación */
                         CalcularPromedioVariableAgregada(mediapasos, pasos, ventana);              CalcularPromedioVariableAgregada(mediapasos, pasos, ventana);
                 }          }
                 /* grado de paralelismo (a partir de los pasos de computación) */          /* grado de paralelismo (a partir de los pasos de computación) */
                 if(configuracion.gradoparalelismo == SI)          if(configuracion.gradoparalelismo == SI)
                 {          {
                         /* grado de paralelismo a partir de los pasos de computación */              /* grado de paralelismo a partir de los pasos de computación */
                         CalcularGradoParalelismoNormalizado(pasos, grado);              CalcularGradoParalelismoNormalizado(pasos, grado);
                         /* valor medio del grado de paralelismo */              /* valor medio del grado de paralelismo */
                         CalcularPromedioVariableAgregada(mediagrado, grado, ventana);              CalcularPromedioVariableAgregada(mediagrado, grado, ventana);
                 }          }
                 /* acoplamiento */          /* acoplamiento */
                 if(configuracion.acoplamiento == SI);          if(configuracion.acoplamiento == SI);
                 {          {
                         /* grado de paralelismo a partir de los pasos de computación */              /* grado de paralelismo a partir de los pasos de computación */
                         CalcularAcoplamiento(acoplo);              CalcularAcoplamiento(acoplo);
                         /* valor medio del grado de paralelismo */              /* valor medio del grado de paralelismo */
                         CalcularPromedioVariableAgregada(mediaacoplo, acoplo, ventana);              CalcularPromedioVariableAgregada(mediaacoplo, acoplo, ventana);
                 }                         }        
   
                 if(configuracion.tiempo == SI) tiempoejecucion = CalcularTiempo();          if(configuracion.tiempo == SI) tiempoejecucion = CalcularTiempo();
         }      }
 }  }
   
 void ReservarMemoriaAnalisisDependencias()  void ReservarMemoriaAnalisisDependencias()
 {  {
         CrearPizarras();      CrearPizarras();
               
         CrearVectorDependencias();      CrearVectorDependencias();
   
         CrearMatricesDependencias();      CrearMatricesDependencias();
   
         if(configuracion.ordenparcial == SI) CrearListaOrdenParcial();      if(configuracion.ordenparcial == SI) CrearListaOrdenParcial();
         if(configuracion.matrizcaminos == SI) CrearMatrizCaminos();      if(configuracion.matrizcaminos == SI) CrearMatrizCaminos();
         if(configuracion.pasoscomputacion == SI)      if(configuracion.pasoscomputacion == SI)
         {      {
                 pasos = CrearVariableAgregada();          pasos = CrearVariableAgregada();
                 IniciarVariableAgregada(pasos);          IniciarVariableAgregada(pasos);
                 mediapasos = CrearVariableAgregada();          mediapasos = CrearVariableAgregada();
                 IniciarVariableAgregada(mediapasos);          IniciarVariableAgregada(mediapasos);
                 if(configuracion.distribucionpasos == SI) CrearHistogramaPasos();          if(configuracion.distribucionpasos == SI) CrearHistogramaPasos();
         }      }
         if(configuracion.gradoparalelismo == SI);      if(configuracion.gradoparalelismo == SI);
         {      {
                 grado = CrearVariableAgregada();          grado = CrearVariableAgregada();
                 IniciarVariableAgregada(grado);          IniciarVariableAgregada(grado);
                 mediagrado = CrearVariableAgregada();          mediagrado = CrearVariableAgregada();
                 IniciarVariableAgregada(mediagrado);          IniciarVariableAgregada(mediagrado);
         }      }
         if(configuracion.acoplamiento == SI);      if(configuracion.acoplamiento == SI);
         {      {
                 acoplo = CrearVariableAgregada();          acoplo = CrearVariableAgregada();
                 IniciarVariableAgregada(acoplo);          IniciarVariableAgregada(acoplo);
                 mediaacoplo = CrearVariableAgregada();          mediaacoplo = CrearVariableAgregada();
                 IniciarVariableAgregada(mediaacoplo);          IniciarVariableAgregada(mediaacoplo);
         }      }
 }  }
   
   
 void LiberarMemoriaAnalisisDependencias()  void LiberarMemoriaAnalisisDependencias()
 {  {
         LiberarMemoriaPizarras();      LiberarMemoriaPizarras();
         LiberarMemoriaVectorDependencias();      LiberarMemoriaVectorDependencias();
         LiberarMemoriaMatricesDependencias();      LiberarMemoriaMatricesDependencias();
   
         if(configuracion.ordenparcial == SI) LiberarMemoriaListaOrdenParcial();      if(configuracion.ordenparcial == SI) LiberarMemoriaListaOrdenParcial();
         if(configuracion.matrizcaminos == SI) LiberarMemoriaMatrizCaminos();      if(configuracion.matrizcaminos == SI) LiberarMemoriaMatrizCaminos();
   
         if(configuracion.pasoscomputacion == SI) {free(pasos); free(mediapasos);}      if(configuracion.pasoscomputacion == SI) {free(pasos); free(mediapasos);}
         if(configuracion.gradoparalelismo == SI) {free(grado); free(mediagrado);};      if(configuracion.gradoparalelismo == SI) {free(grado); free(mediagrado);};
         if(configuracion.acoplamiento == SI) {free(acoplo); free(mediaacoplo);};      if(configuracion.acoplamiento == SI) {free(acoplo); free(mediaacoplo);};
   
         if(configuracion.distribucionpasos == SI) LiberarMemoriaHistogramaPasos();      if(configuracion.distribucionpasos == SI) LiberarMemoriaHistogramaPasos();
 }  }
   
   
Line 233  void LiberarMemoriaAnalisisDependencias( Line 232  void LiberarMemoriaAnalisisDependencias(
 void main(int argc, char *argv[])  void main(int argc, char *argv[])
 {  {
     /* puntero al fichero origen de datos */      /* puntero al fichero origen de datos */
         FILE *origendatos;      FILE *origendatos;
         /* total instrucciones y ventanas a procesar */      /* total instrucciones y ventanas a procesar */
         unsigned long total_ins, total_ven;           unsigned long total_ins, total_ven;    
         /* secuencia en bytes de 2 instrucciones consecutivas */      /* secuencia en bytes de 2 instrucciones consecutivas */
     unsigned char secuencia[2*BYTES_POR_INSTRUCCION];      unsigned char secuencia[2*BYTES_POR_INSTRUCCION];
     /* reservo espacio para una estructura de tipo ficha de instrucción */      /* reservo espacio para una estructura de tipo ficha de instrucción */
     fichainstruccion tarjetaoperandos;      fichainstruccion tarjetaoperandos;
           
         unsigned int i, ins;      unsigned int i, ins;
         char cadena[MAX_LINE];      char cadena[MAX_LINE];
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
         unsigned char salvarventana = NO;      unsigned char salvarventana = NO;
         char listadoventanas[MAX_LINE];      char listadoventanas[MAX_LINE];
   
       /* inicio los punteros de las matrices de dependencias a NULL */
         /* inicio los punteros de las matrices de dependencias a NULL */      /* es una medida higiénica pero no necesaria ya que la reserva de memoria */
         /* es una medida higiénica pero no necesaria ya que la reserva de memoria */      /* correspondiente a la declaración se hace rellenando con 0s */
         /* correspondiente a la declaración se hace rellenando con 0s */  
       /* ver si es posible con {NULL, NULL...} */
         /* ver si es posible con {NULL, NULL...} */      IniciarPunterosMatrices();
         IniciarPunterosMatrices();  
       /* NOTIFICACIONES DE SUCESOS Y ERRORES */
         /* NOTIFICACIONES DE SUCESOS Y ERRORES */      /* inicio el fichero que va a recibir las notificaciones */
         /* inicio el fichero que va a recibir las notificaciones */      IniciarNotificaciones();
         IniciarNotificaciones();  
       /* CONFIGURACIÓN */
         /* CONFIGURACIÓN */      /* cargo la configuración de la aplicación por defecto */
         /* cargo la configuración de la aplicación por defecto */      CargarConfiguracionInicial();
         CargarConfiguracionInicial();      /* modifico la configuración de la aplicación en función de los argumentos */
         /* modifico la configuración de la aplicación en función de los argumentos */      CapturarArgumentos(argc, argv);
         CapturarArgumentos(argc, argv);  
       /* escribo la configuración en el fichero de notificaciones */
         /* escribo la configuración en el fichero de notificaciones */      if(configuracion.nivelnotificaciones != EX_CFG) NotificarConfiguracion();
         if(configuracion.nivelnotificaciones != EX_CFG) NotificarConfiguracion();  
       /* BASES DE DATOS */
         /* BASES DE DATOS */      CargarBasesDatos();
         CargarBasesDatos();  
       /* CALCULOS A REALIZAR */
         /* CALCULOS A REALIZAR */      if(configuracion.recuentos == SI) CrearContadores();
         if(configuracion.recuentos == SI) CrearContadores();      if(configuracion.dependencias == SI) ReservarMemoriaAnalisisDependencias();
         if(configuracion.dependencias == SI) ReservarMemoriaAnalisisDependencias();  
       /* FICHEROS A CREAR */
         /* FICHEROS A CREAR */      if(configuracion.volcarBD == SI) SalvarBasesDatos();
         if(configuracion.volcarBD == SI) SalvarBasesDatos();      if(configuracion.crearficheroconfig == SI) CrearFicheroConfiguracion();
         if(configuracion.crearficheroconfig == SI) CrearFicheroConfiguracion();  
       /* CABECERA EN LA PANTALLA */
         /* PROCESAMIENTO */      MostrarCabecera();
         if(configuracion.origen == TRAZA)  
         {      /* PROCESAMIENTO */
                 /* determino el rango de instrucciones a analizar */      if(configuracion.origen == TRAZA)
                 DeterminarRango();      {
                 /* determino el número total de instrucciones */          /* determino el rango de instrucciones a analizar */
                 total_ins = (unsigned long)(configuracion.ultima - configuracion.primera + 1);          DeterminarRango();
                 /* determino el número de ventanas de instrucciones */          /* determino el número total de instrucciones */
                 total_ven = (unsigned long)total_ins/configuracion.ventana;          total_ins = (unsigned long)(configuracion.ultima - configuracion.primera + 1);
                 /* inicio los contadores */          /* determino el número de ventanas de instrucciones */
                 instruccion = 1;        /* cuento las instrucciones desde el '1' */          total_ven = (unsigned long)total_ins/configuracion.ventana;
                 ventana = 0;          /* inicio los contadores */
                 /* listado de ventanas a volcar */          instruccion = 1;    /* cuento las instrucciones desde el '1' */
                 strcpy(listadoventanas, configuracion.volcarventana);          ventana = 0;
                           /* listado de ventanas a volcar */
                 /* abro el fichero de traza */          strcpy(listadoventanas, configuracion.volcarventana);
                 if((origendatos  = fopen(configuracion.ficherodatos, "rb")) != NULL)          
                 {          /* abro el fichero de traza */
                         sprintf(mensaje, "[Main] El fichero '%s' se ha abierto con éxito", configuracion.ficherodatos);          if((origendatos  = fopen(configuracion.ficherodatos, "rb")) != NULL)
                         Notificar(mensaje, NO_ERROR, ECO_NO);          {
               sprintf(mensaje, "[Main] El fichero '%s' se ha abierto con éxito", configuracion.ficherodatos);
                         /* sitúo el puntero del fichero en la instrucción de comienzo */              Notificar(mensaje, NO_ERROR, ECO_NO);
                         fseek(origendatos, (configuracion.primera - 1) * BYTES_POR_INSTRUCCION, SEEK_SET);  
               /* sitúo el puntero del fichero en la instrucción de comienzo */
                         /* leo el formato de la primera instrucción a tratar */              fseek(origendatos, (configuracion.primera - 1) * BYTES_POR_INSTRUCCION, SEEK_SET);
                         /* y lo coloco en la parte alta de la secuencia (2ª instrucción) */  
                         for(i=0; i<BYTES_POR_INSTRUCCION; i++) secuencia[i+BYTES_POR_INSTRUCCION] = fgetc(origendatos);              /* leo el formato de la primera instrucción a tratar */
               /* y lo coloco en la parte alta de la secuencia (2ª instrucción) */
                         while(total_ven-ventana)              for(i=0; i<BYTES_POR_INSTRUCCION; i++) secuencia[i+BYTES_POR_INSTRUCCION] = fgetc(origendatos);
                         {  
                                 ventana++;              while(total_ven-ventana)
                                 IniciarVentana();                                             {
                   ventana++;
                                 /* ¿salvar información de la ventana en curso? */  
                                 if(listadoventanas[0] != '\0')          /* si el listado no es vacío */                  /* indicar estado de procesamiento */
                                 {                  PresentarEstadoProcesamiento(total_ven, ventana);
                                         sprintf(cadena, "%lu", ventana);  
                                         if(BuscarElementoLista(listadoventanas, cadena) != 0)                  IniciarVentana();                
                                         {  
                                                 salvarventana = SI;                  /* ¿salvar información de la ventana en curso? */
                                                 EliminarElementoLista(listadoventanas, cadena);                  if(listadoventanas[0] != '\0')        /* si el listado no es vacío */
                                                 /* construyo una planilla con resultados de la ventana en curso */                  {
                                                 IniciarFicheroVentana();                      sprintf(cadena, "%lu", ventana);
                                         }                      if(BuscarElementoLista(listadoventanas, cadena) != 0)
                                         else salvarventana = NO;                      {
                                 }                          salvarventana = SI;
                           EliminarElementoLista(listadoventanas, cadena);
                                 for(ins=0; ins<configuracion.ventana; ins++, instruccion++)                          /* construyo una planilla con resultados de la ventana en curso */
                                 {                          IniciarFicheroVentana();
                                         /* paso el formato de la parte alta a la baja */                      }
                                         for(i=0; i<BYTES_POR_INSTRUCCION; i++) secuencia[i] = secuencia[i+BYTES_POR_INSTRUCCION];                      else salvarventana = NO;
                                         /* leo el formato de la instrucción siguiente desde la traza */                  }
                                         for(i=0; i<BYTES_POR_INSTRUCCION; i++) secuencia[i+BYTES_POR_INSTRUCCION] = fgetc(origendatos);  
                   for(ins=0; ins<configuracion.ventana; ins++, instruccion++)
                                         ProcesarInstruccion(ins, secuencia, &tarjetaoperandos);                  {
                                                               /* paso el formato de la parte alta a la baja */
                                         if(configuracion.verinstruccion == SI) MostrarTarjeta(&tarjetaoperandos);                      for(i=0; i<BYTES_POR_INSTRUCCION; i++) secuencia[i] = secuencia[i+BYTES_POR_INSTRUCCION];
                       /* leo el formato de la instrucción siguiente desde la traza */
                                         if(salvarventana == SI) Instruccion2FicheroVentana(&tarjetaoperandos);                      for(i=0; i<BYTES_POR_INSTRUCCION; i++) secuencia[i+BYTES_POR_INSTRUCCION] = fgetc(origendatos);
   
                                         /* _getch(); */                      ProcesarInstruccion(ins, secuencia, &tarjetaoperandos);
                                 }                      
                                 ProcesarVentana();                      if(configuracion.verinstruccion == SI) MostrarTarjeta(&tarjetaoperandos);
   
                                 if(configuracion.verventana == SI) MostrarVentana();                      if(salvarventana == SI) Instruccion2FicheroVentana(&tarjetaoperandos);
   
                                 /* salvo las matrices de la ventana en la planilla y sus parámetros */                      /* _getch(); */
                                 if(salvarventana == SI) Matrices2FicheroVentana();                  }
                         }                  ProcesarVentana();
   
                         /* cierro el fichero de traza */                  if(configuracion.verventana == SI) MostrarVentana();
                 if(fclose(origendatos))  
                         {                  /* salvo las matrices de la ventana en la planilla y sus parámetros */
                                 sprintf(mensaje, "[Main] El fichero '%s' no se ha podido cerrar", configuracion.ficherodatos);                  if(salvarventana == SI) Matrices2FicheroVentana();
                                 Notificar(mensaje, ERROR_SEGUIR, ECO_NO);              }
                         }  
                         else              /* cierro el fichero de traza */
                         {              if(fclose(origendatos))
                                 sprintf(mensaje, "[Main] El fichero '%s' ha sido cerrado con éxito", configuracion.ficherodatos);              {
                                 Notificar(mensaje, NO_ERROR, ECO_NO);                  sprintf(mensaje, "[Main] El fichero '%s' no se ha podido cerrar", configuracion.ficherodatos);
                         }                  Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
                 }              }
                 else              else
                 {              {
                         sprintf(mensaje, "[Main] El fichero '%s' no se ha podido abrir", configuracion.ficherodatos);                  sprintf(mensaje, "[Main] El fichero '%s' ha sido cerrado con éxito", configuracion.ficherodatos);
                         Notificar(mensaje, ERROR_SALIR, ECO_NO);                  Notificar(mensaje, NO_ERROR, ECO_NO);
                 }              }
         }          }
           else
         else if(configuracion.origen == SECUENCIA)          {
         {              sprintf(mensaje, "[Main] El fichero '%s' no se ha podido abrir", configuracion.ficherodatos);
                 /* abro el fichero de la secuencia */              Notificar(mensaje, ERROR_SALIR, ECO_NO);
                 if((origendatos  = fopen(configuracion.ficherodatos, "r")) != NULL)          }
                 {      }
                         sprintf(mensaje, "[Main] El fichero '%s' se ha abierto con éxito", configuracion.ficherodatos);  
                         Notificar(mensaje, NO_ERROR, ECO_NO);      else if(configuracion.origen == SECUENCIA)
       {
                         /* cuento las instrucciones de la secuencia */          /* abro el fichero de la secuencia */
                 ins = 0;          if((origendatos  = fopen(configuracion.ficherodatos, "r")) != NULL)
                         while(!feof(origendatos))          {
                     {              sprintf(mensaje, "[Main] El fichero '%s' se ha abierto con éxito", configuracion.ficherodatos);
                                 fgets (cadena, MAX_LINE, origendatos);              Notificar(mensaje, NO_ERROR, ECO_NO);
                                   
                                 if (cadena[0]!='\n' && cadena[0]!='#') ins++;              /* cuento las instrucciones de la secuencia */
                         }              ins = 0;
                         configuracion.primera = 1;              while(!feof(origendatos))
                         configuracion.ultima = ins;              {
                   fgets (cadena, MAX_LINE, origendatos);
                         /* determino el número total de instrucciones */                  
                         total_ins = (unsigned long)(configuracion.ultima - configuracion.primera + 1);                  if (cadena[0]!='\n' && cadena[0]!='#') ins++;
                         /* determino el número de ventanas de instrucciones */              }
                         total_ven = (unsigned long)total_ins/configuracion.ventana;              configuracion.primera = 1;
                         /* inicio los contadores */              configuracion.ultima = ins;
                         instruccion = 1;        /* cuento las instrucciones desde el '1' */  
                         ventana = 0;              /* determino el número total de instrucciones */
                         /* listado de ventanas a volcar */              total_ins = (unsigned long)(configuracion.ultima - configuracion.primera + 1);
                         strcpy(listadoventanas, configuracion.volcarventana);              /* determino el número de ventanas de instrucciones */
               total_ven = (unsigned long)total_ins/configuracion.ventana;
               /* inicio los contadores */
                         /* coloco el puntero del fichero al principio */              instruccion = 1;    /* cuento las instrucciones desde el '1' */
                         fseek(origendatos, 0L, SEEK_SET);              ventana = 0;
               /* listado de ventanas a volcar */
                         /* comienzo el análisis de la secuencia */              strcpy(listadoventanas, configuracion.volcarventana);
                         while(total_ven-ventana)  
                         {  
                                 ventana++;              /* coloco el puntero del fichero al principio */
                                 IniciarVentana();              fseek(origendatos, 0L, SEEK_SET);
   
                                 /* ¿salvar información de la ventana en curso? */              /* comienzo el análisis de la secuencia */
                                 if(listadoventanas[0] != '\0')          /* si el listado no es vacío */              while(total_ven-ventana)
                                 {              {
                                         sprintf(cadena, "%lu", ventana);                  ventana++;
                                         if(BuscarElementoLista(listadoventanas, cadena) != 0)  
                                         {                  /* indicar estado de procesamiento */
                                                 salvarventana = SI;                  PresentarEstadoProcesamiento(total_ven, ventana);
                                                 EliminarElementoLista(listadoventanas, cadena);  
                                                 /* construyo una planilla con resultados de la ventana en curso */                  IniciarVentana();
                                                 IniciarFicheroVentana();  
                                         }                  /* ¿salvar información de la ventana en curso? */
                                         else salvarventana = NO;                  if(listadoventanas[0] != '\0')        /* si el listado no es vacío */
                                 }                  {
                       sprintf(cadena, "%lu", ventana);
                                 for(ins=0; ins<configuracion.ventana; ins++, instruccion++)                      if(BuscarElementoLista(listadoventanas, cadena) != 0)
                                 {                      {
                                         do                          salvarventana = SI;
                                         {                          EliminarElementoLista(listadoventanas, cadena);
                                                 fgets (cadena, MAX_LINE, origendatos);                          /* construyo una planilla con resultados de la ventana en curso */
                                         }                          IniciarFicheroVentana();
                                         while (cadena[0]=='\n' || cadena[0]=='#');                      }
                                                       else salvarventana = NO;
                                         /* quito el caracter '\n' (0x0A) final de la cadena correspondiente a una línea de texto */                  }
                                         /* ¡OJO! si abro el fichero en modo binario el final de linea es "\r\n" (0x0D 0x0A) */  
                                         *(cadena+strlen(cadena)-1)='\0';                  for(ins=0; ins<configuracion.ventana; ins++, instruccion++)
                   {
                                         ConvertirHex2Bin(cadena, secuencia, BYTES_POR_INSTRUCCION);                      do
                       {
                                         ProcesarInstruccion(ins, secuencia, &tarjetaoperandos);                          fgets (cadena, MAX_LINE, origendatos);
                       }
                                         if(configuracion.verinstruccion == SI) MostrarTarjeta(&tarjetaoperandos);                      while (cadena[0]=='\n' || cadena[0]=='#');
                   
                                         /* salvo las instrucciones en la planilla de la ventana */                      /* quito el caracter '\n' (0x0A) final de la cadena correspondiente a una línea de texto */
                                         if(salvarventana == SI) Instruccion2FicheroVentana(&tarjetaoperandos);                      /* ¡OJO! si abro el fichero en modo binario el final de linea es "\r\n" (0x0D 0x0A) */
                                 }                      *(cadena+strlen(cadena)-1)='\0';
   
                                 ProcesarVentana();                      ConvertirHex2Bin(cadena, secuencia, BYTES_POR_INSTRUCCION);
   
                                 if(configuracion.verventana == SI) MostrarVentana();                      ProcesarInstruccion(ins, secuencia, &tarjetaoperandos);
   
                                 /* salvo las matrices de la ventana en la planilla y sus parámetros */                      if(configuracion.verinstruccion == SI) MostrarTarjeta(&tarjetaoperandos);
                                 if(salvarventana == SI) Matrices2FicheroVentana();  
                         }                      /* salvo las instrucciones en la planilla de la ventana */
                       if(salvarventana == SI) Instruccion2FicheroVentana(&tarjetaoperandos);
                         /* cierro el fichero de la secuencia */                  }
                 if(fclose(origendatos))  
                         {                  ProcesarVentana();
                                 sprintf(mensaje, "[Main] El fichero '%s' no se ha podido cerrar", configuracion.ficherodatos);  
                                 Notificar(mensaje, ERROR_SEGUIR, ECO_NO);                  if(configuracion.verventana == SI) MostrarVentana();
                         }  
                         else                  /* salvo las matrices de la ventana en la planilla y sus parámetros */
                         {                  if(salvarventana == SI) Matrices2FicheroVentana();
                                 sprintf(mensaje, "[Main] El fichero '%s' ha sido cerrado con éxito", configuracion.ficherodatos);              }
                                 Notificar(mensaje, NO_ERROR, ECO_NO);  
                         }              /* cierro el fichero de la secuencia */
                 }              if(fclose(origendatos))
                 else              {
                 {                  sprintf(mensaje, "[Main] El fichero '%s' no se ha podido cerrar", configuracion.ficherodatos);
                         sprintf(mensaje, "[Main] El fichero '%s' no se ha podido abrir", configuracion.ficherodatos);                  Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
                         Notificar(mensaje, ERROR_SALIR, ECO_NO);              }
                 }              else
         }              {
                   sprintf(mensaje, "[Main] El fichero '%s' ha sido cerrado con éxito", configuracion.ficherodatos);
         else if(configuracion.origen == CADENAHEX)                  Notificar(mensaje, NO_ERROR, ECO_NO);
         {              }
                 instruccion = 1;          }
                 ventana = 1;          else
           {
                 ConvertirHex2Bin(configuracion.cadenahex, secuencia, BYTES_POR_INSTRUCCION);              sprintf(mensaje, "[Main] El fichero '%s' no se ha podido abrir", configuracion.ficherodatos);
               Notificar(mensaje, ERROR_SALIR, ECO_NO);
                 AnalizarOperandosIA16(secuencia, &tarjetaoperandos);          }
       }
                 if(configuracion.cpi == SI) CalcularCiclosInstruccion(&tarjetaoperandos);  
       else if(configuracion.origen == CADENAHEX)
                 /* if(configuracion.verinstruccion == SI) */      {
                 /* muestro en la pantalla la información siempre */          instruccion = 1;
                 MostrarTarjeta(&tarjetaoperandos);          ventana = 1;
         }  
           ConvertirHex2Bin(configuracion.cadenahex, secuencia, BYTES_POR_INSTRUCCION);
         /* SALVAR RESULTADOS */  
         /* salvo los resultados en un fichero de formato EXCEL */          AnalizarOperandosIA16(secuencia, &tarjetaoperandos);
         if(configuracion.origen != CADENAHEX) CrearFicheroResultados(configuracion.ficheroresultados);  
           if(configuracion.cpi == SI) CalcularCiclosInstruccion(&tarjetaoperandos);
   
           /* if(configuracion.verinstruccion == SI) */
           /* muestro en la pantalla la información siempre */
           MostrarTarjeta(&tarjetaoperandos);
       }
   
       /* SALVAR RESULTADOS */
       /* salvo los resultados en un fichero de formato EXCEL */
       if(configuracion.origen != CADENAHEX) CrearFicheroResultados(configuracion.ficheroresultados);
   
     /* LIBERAR MEMORIA */      /* LIBERAR MEMORIA */
         /* al final hay que liberar toda la memoria reservada */      /* al final hay que liberar toda la memoria reservada */
         LiberarMemoriaBasesDatos();      LiberarMemoriaBasesDatos();
         if(configuracion.recuentos == SI) LiberarMemoriaContadores();      if(configuracion.recuentos == SI) LiberarMemoriaContadores();
         if(configuracion.dependencias == SI) LiberarMemoriaAnalisisDependencias();      if(configuracion.dependencias == SI) LiberarMemoriaAnalisisDependencias();
 }  }
Removed from v.1.1  
changed lines
  Added in v.1.2

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