File:  [Repository ATC2] / ADD_ver_10 / Source Code / Source Files / Ficheros.c
Revision 1.2: download - view: text, annotated - select for diffs
Tue Feb 28 14:54:21 2006 UTC (18 years, 6 months ago) by rico
Branches: MAIN
CVS tags: HEAD
*** empty log message ***

/********************************************************************/
/*  Ficheros.c                                                      */
/*                                                                  */
/*                                                                  */
/*  Copyright (c) 1997-2006 Rafael Rico      (rafael.rico@uah.es)   */
/*                                                                  */
/*  Este fichero forma parte de ADD                                 */
/*  (Analizador de Dependencias de Datos)                           */
/*  Version 5.10.                                                   */
/*                                                                  */
/*                                                                  */
/*  ADD es software libre. Puede redistribuirlo y/o modificarlo     */
/*  bajo los términos de la Licencia Pública General de GNU         */
/*  según es publicada por la Free Software Foundation, bien bajo   */
/*  la versión 2 de dicha Licencia o bien (según su elección)       */
/*  bajo cualquier versión posterior.                               */
/*                                                                  */
/*  ADD se distribuye con la esperanza de que sea útil,             */
/*  pero SIN NINGUNA GARANTÍA, incluso sin la garantía MERCANTIL    */
/*  implícita y sin garantizar la CONVENIENCIA PARA UN PROPÓSITO    */
/*  PARTICULAR. Véase la Licencia Pública General de GNU para       */
/*  más detalles.                                                   */
/*                                                                  */
/*  Debería haber recibido una copia de la Licencia Pública General */
/*  junto con ADD. Si no ha sido así, escriba a la Free Software    */
/*  Foundation, Inc., 51 Franklin St, Fifth Floor,                  */
/*  Boston, MA  02110-1301  EEUU.                                   */
/*                                                                  */
/*  -------------------------- Historia --------------------------- */
/*                                                                  */
/*  $Id: Ficheros.c,v 1.2 2006/02/28 14:54:21 rico Exp $                                                            */
/*                                                                  */
/*  Revisión 1.2. 01/2006                                           */
/*  Se añade la licencia GPL y documentación en estilo Javadoc      */
/*                                                                  */
/*  Revisión 1.1. 09/2005                                           */
/*  Versión inicial                                                 */
/*                                                                  */
/********************************************************************/

/******************************************************************************/
/* MÓDULO: Ficheros.c                                                         */
/*                                                                            */
/* Este módulo contiene las funciones relacionadas con el almacenamiento de   */
/* información en ficheros.                                                   */
/******************************************************************************/
/* Fecha: 23 de septiembre de 2005                                            */
/******************************************************************************/

#include <stdio.h>
#include <string.h>
#include <time.h>

#include "defines.h"
#include "tipos.h"
#include "ficheros.h"

/* configuración */
extern struct argumentos configuracion;

/* bases de datos */
extern unsigned int num_nemonicos;
extern operacion *nemonicos;
extern unsigned int num_simbolos;
extern operando *simbolos;

extern unsigned int num_tiempos;
extern tiempo *ciclos;

/* recuentos */
extern unsigned long int *contadornemonicos;
extern unsigned long int *contadorlecturas;
extern unsigned long int *contadorescrituras;

/* contadores de instrucciones y ventanas */
extern unsigned long instruccion, ventana;

/* otros resultados */
extern double cpimedio;
extern double tiempoejecucion;
extern unsigned long *distribucionpasos;

/* posibles ubicaciones de datos */
extern unsigned int num_ubicaciones;
extern ubicacion *datos;

/* analisis de dependencias de datos */
extern struct punterosD matriz;
extern unsigned char **matrizC;
extern char **OrdenParcial;

/* parámetros asociados a las matrices */
extern parametromatriz *pasos;
extern parametromatriz *mediapasos;
extern parametromatriz *grado;
extern parametromatriz *mediagrado;
extern parametromatriz *acoplo;
extern parametromatriz *mediaacoplo;



/* BASES de DATOS */
/* función para salvar en un fichero la base de datos */

void CrearFicheroDB (char *fichero, int idtabla)
{
    FILE *handle;
    unsigned int i;
    char mensaje[MAX_LINE];

    /* los ficheros van a tener el formato de texto EXCEL */
    /* al nombre del fichero le asigno la extensión .XLS */

    strcat(fichero, ".xls");

    switch(idtabla)
    {
        case TABLA_NEMONICOS:
        /* abro el fichero */
        if((handle  = fopen(fichero, "w")) != NULL)
        {
            sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' se ha abierto con éxito", fichero);
            Notificar(mensaje, NO_ERROR, ECO_NO);

            /* escribo una pequeña cabecera */
            fprintf(handle, "BASE DE DATOS DE NEMÓNICOS\n\n");
            fprintf(handle, "%s\t", "índice");
            fprintf(handle, "%s\t", "nemónico");
            fprintf(handle, "%s\t", "tipo");
            fprintf(handle, "%s\t", "implicitos_escritos");
            fprintf(handle, "%s\t", "implicitos_leidos");
            fprintf(handle, "%s\t", "modo_op1");
            fprintf(handle, "%s\n", "modo_op2");
            /* fprintf(handle, "%s\n", "cuenta"); */
            
            /* copio la base de datos al fichero con formato EXCEL */
            for(i=0; i<num_nemonicos; i++)
            {
                fprintf(handle, "%d\t%s\t", i+1, nemonicos[i].nemonico);
                fprintf(handle, "%d\t", nemonicos[i].tipo);
                fprintf(handle, "%s\t", nemonicos[i].implicitos_escritos);
                fprintf(handle, "%s\t", nemonicos[i].implicitos_leidos);
                fprintf(handle, "%d\t", nemonicos[i].modo_op1);
                fprintf(handle, "%d\n", nemonicos[i].modo_op2);
                /* fprintf(handle, "%lu\n", nemonicos[i].cuenta); */
            }

            sprintf(mensaje, "[CrearFicheroDB] La Tabla Nemónicos se ha volcado al fichero '%s'", fichero);
            Notificar(mensaje, NO_ERROR, ECO_NO);

            /* cierro el fichero */
            if(fclose(handle))
            {
                sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' no se ha podido cerrar", fichero);
                Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
            }
            else
            {
                sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' ha sido cerrado con éxito", fichero);
                Notificar(mensaje, NO_ERROR, ECO_NO);
            }
        }
        else
        {
            sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' no se ha podido abrir", fichero);
            Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
        }
        break;

        case TABLA_SIMBOLOS:
        /* abro el fichero */
        if((handle  = fopen(fichero, "w")) != NULL)
        {
            sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' se ha abierto con éxito", fichero);
            Notificar(mensaje, NO_ERROR, ECO_NO);

            /* escribo una pequeña cabecera */
            fprintf(handle, "BASE DE DATOS DE UBICACIONES\n\n");
            fprintf(handle, "%s\t", "índice");
            fprintf(handle, "%s\t", "símbolo");
            fprintf(handle, "%s\t", "tipo");
            fprintf(handle, "%s\t", "dependencias");
            fprintf(handle, "%s\n", "segmento");
            /* fprintf(handle, "%s\t", "lecturas"); */
            /* fprintf(handle, "%s\n", "escrituras"); */
            
            /* copio la base de datos al fichero con formato EXCEL */
            for(i=0; i<num_simbolos; i++)
            {
                fprintf(handle, "%d\t%s\t", i+1, simbolos[i].simbolo);
                fprintf(handle, "%d\t", simbolos[i].tipo);
                fprintf(handle, "%s\t", simbolos[i].dependencias);
                fprintf(handle, "%d\n", simbolos[i].segmento);
                /* fprintf(handle, "%lu\t", simbolos[i].lecturas); */
                /* fprintf(handle, "%lu\n", simbolos[i].escrituras); */
            }

            sprintf(mensaje, "[CrearFicheroDB] La Tabla Símbolos se ha volcado al fichero '%s'", fichero);
            Notificar(mensaje, NO_ERROR, ECO_NO);

            /* cierro el fichero */
            if(fclose(handle))
            {
                sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' no se ha podido cerrar", fichero);
                Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
            }
            else
            {
                sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' ha sido cerrado con éxito", fichero);
                Notificar(mensaje, NO_ERROR, ECO_NO);
            }
        }
        else
        {
            sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' no se ha podido abrir", fichero);
            Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
        }
        break;

        case TABLA_CICLOS:
        /* abro el fichero */
        if((handle  = fopen(fichero, "w")) != NULL)
        {
            sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' se ha abierto con éxito", fichero);
            Notificar(mensaje, NO_ERROR, ECO_NO);

            /* escribo una pequeña cabecera */
            fprintf(handle, "BASE DE DATOS DE TIEMPOS DE EJECUCIÓN\n\n");
            fprintf(handle, "%s\t", "índice");
            fprintf(handle, "%s\t", "identificador");
            fprintf(handle, "%s\n", "ciclos");
            
            /* copio la base de datos al fichero con formato EXCEL */
            for(i=0; i<num_tiempos; i++)
            {
                fprintf(handle, "%d\t%s\t", i+1, ciclos[i].identificador);
                fprintf(handle, "%d\n", ciclos[i].ciclos);
            }

            sprintf(mensaje, "[CrearFicheroDB] La Tabla Ciclos se ha volcado al fichero '%s'", fichero);
            Notificar(mensaje, NO_ERROR, ECO_NO);

            /* cierro el fichero */
            if(fclose(handle))
            {
                sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' no se ha podido cerrar", fichero);
                Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
            }
            else
            {
                sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' ha sido cerrado con éxito", fichero);
                Notificar(mensaje, NO_ERROR, ECO_NO);
            }
        }
        else
        {
            sprintf(mensaje, "[CrearFicheroDB] El fichero '%s' no se ha podido abrir\n", fichero);
            Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
        }
        break;
    }
}


/* esta función salva todas las bases de datos utilizadas */

void SalvarBasesDatos()
{
    char cadena[MAX_LINE];

    /* genero los ficheros con las tablas de la BD para comprobar que todo va bien */
    strcpy(cadena, "nemos");
    CrearFicheroDB (cadena, TABLA_NEMONICOS);
    strcpy(cadena, "ubis");
    CrearFicheroDB (cadena, TABLA_SIMBOLOS);
    if(configuracion.cpi == SI)
    {
        strcpy(cadena, "ciclos");
        CrearFicheroDB (cadena, TABLA_CICLOS);
    }
}


/* VENTANAS de INSTRUCCIONES */
/* funciones para salvar en un fichero la información relativa a una ventana */
/* de instrucciones */
/* abro un fichero para salvar información de una ventana de instrucciones */

void IniciarFicheroVentana()
{
    FILE *handle;
    char fichero[MAX_LINE];
    char mensaje[MAX_LINE];
    int i;

    /* el fichero va a tener el formato de texto EXCEL */
    /* construyo el nombre a partir del número de ventana */
    /* al nombre del fichero le asigno la extensión .XLS */

    sprintf(fichero, "%lu.xls", ventana);
    
    /* esto no es ANSI  
    _ltoa(ventana, fichero, 10);
    strcat(fichero, ".xls"); */

    /* abro el fichero */
    if((handle  = fopen(fichero, "w")) != NULL)
    {
        sprintf(mensaje, "[IniciarFicheroVentana] El fichero '%s' se ha abierto con éxito", fichero);
        Notificar(mensaje, NO_ERROR, ECO_NO);

        /* escribo una pequeña cabecera con información */
        /* copiar de CrearFicheroResultados */

        fprintf(handle, "VENTANA NÚMERO:\t%lu\n\n", ventana);

        /* encabezado de la tabla */
        fprintf(handle, "SECUENCIA DE CÓDIGO\n");
        fprintf(handle, "\t\t\toperandos leidos\t\t\t\t\t\t\t\toperandos escritos\n");
        fprintf(handle, "\t\t\texplícitos\t\t\t\timplícitos\t\t\t\texplícitos\t\t\t\timplícitos\n");

        fprintf(handle, "instrucción\thexadecimal\tensamblador\t");
        for(i=0; i<4; i++) fprintf(handle, "datos\tdirecciones\tpila\testado\t");
        fprintf(handle, "longitud\ttipo\tciclos ALU\tciclos BIU\n");

            
        /* cierro el fichero */
        if(fclose(handle))
        {
            sprintf(mensaje, "[IniciarFicheroVentana] El fichero '%s' no se ha podido cerrar", fichero);
            Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
        }
        else
        {
            sprintf(mensaje, "[IniciarFicheroVentana] El fichero '%s' ha sido cerrado con éxito", fichero);
            Notificar(mensaje, NO_ERROR, ECO_NO);
        }
    }
    else
    {
        sprintf(mensaje, "[IniciarFicheroVentana] El fichero '%s' no se ha podido abrir", fichero);
        Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
    }
}


/* escribo información sobre una instrucción en el fichero de la ventana */

void Instruccion2FicheroVentana(fichainstruccion *tarjetaoperandos)
{
    FILE *handle;
    char fichero[MAX_LINE];
    char mensaje[MAX_LINE];

    /* construyo el nombre a partir del número de ventana */

    sprintf(fichero, "%lu.xls", ventana);
    
    /* esto no es ANSI  
    _ltoa(ventana, fichero, 10);
    strcat(fichero, ".xls"); */

    /* abro el fichero */
    if((handle  = fopen(fichero, "a")) != NULL)
    {
        sprintf(mensaje, "[Instruccion2FicheroVentana] El fichero '%s' se ha abierto con éxito", fichero);
        Notificar(mensaje, NO_ERROR, ECO_NO);

        /* escribo la información relativa a la instrucción */

        fprintf(handle, "%d\t", instruccion);
        fprintf(handle, "%s\t", tarjetaoperandos->hexadecimal);

        /* formato de instrucción (notación de INTEL) */
        /*
        fprintf(handle, "%s%s", tarjetaoperandos->prefijo, tarjetaoperandos->prefijo[0]!='\0' ? " ":"");
        fprintf(handle, "%s", tarjetaoperandos->nemonico);
        fprintf(handle, "%s%s", tarjetaoperandos->op1[0]!='\0' ? " ":"", tarjetaoperandos->op1);
        fprintf(handle, "%s%s%s", (tarjetaoperandos->op1[0]!='\0' && tarjetaoperandos->op2[0]!='\0') ? ",":"", tarjetaoperandos->op2[0]!='\0' ? " ":"", tarjetaoperandos->op2);    
        fprintf(handle, "\t");
        */

        /* igual con la función del módulo 'Auxiliares.c' */
        CadenaEnsamblador(tarjetaoperandos->prefijo, tarjetaoperandos->nemonico, tarjetaoperandos->op1, tarjetaoperandos->op2, INTEL, mensaje);
        fprintf(handle, "%s\t", mensaje);


        /* operandos */
        fprintf(handle, "%s\t", tarjetaoperandos->leidoexpldatos);
        fprintf(handle, "%s\t", tarjetaoperandos->leidoexpldir);
        fprintf(handle, "%s\t", tarjetaoperandos->leidoexplpila);
        fprintf(handle, "%s\t", tarjetaoperandos->leidoexplestado);
        fprintf(handle, "%s\t", tarjetaoperandos->leidoimpldatos);
        fprintf(handle, "%s\t", tarjetaoperandos->leidoimpldir);
        fprintf(handle, "%s\t", tarjetaoperandos->leidoimplpila);
        fprintf(handle, "%s\t", tarjetaoperandos->leidoimplestado);
        fprintf(handle, "%s\t", tarjetaoperandos->escritoexpldatos);
        fprintf(handle, "%s\t", tarjetaoperandos->escritoexpldir);
        fprintf(handle, "%s\t", tarjetaoperandos->escritoexplpila);
        fprintf(handle, "%s\t", tarjetaoperandos->escritoexplestado);
        fprintf(handle, "%s\t", tarjetaoperandos->escritoimpldatos);
        fprintf(handle, "%s\t", tarjetaoperandos->escritoimpldir);
        fprintf(handle, "%s\t", tarjetaoperandos->escritoimplpila);
        fprintf(handle, "%s\t", tarjetaoperandos->escritoimplestado);

        fprintf(handle, "%d\t", tarjetaoperandos->longitud);
        switch(tarjetaoperandos->salto)
        {
            case INCONDICIONAL:
            fprintf(handle, "INCONDICIONAL\t");
            break;

            case NO_SALTO:
            fprintf(handle, "NO SALTO\t");
            break;

            case TOMADO:
            fprintf(handle, "TOMADO\t");
            break;

            case NOTOMADO:
            fprintf(handle, "NO TOMADO\t");
            break;
        }

        fprintf(handle, "%d\t", tarjetaoperandos->ciclosALU);
        fprintf(handle, "%d", tarjetaoperandos->ciclosBIU);

        fprintf(handle, "\n");
        

        /* cierro el fichero */
        if(fclose(handle))
        {
            sprintf(mensaje, "[Instruccion2FicheroVentana] El fichero '%s' no se ha podido cerrar", fichero);
            Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
        }
        else
        {
            sprintf(mensaje, "[Instruccion2FicheroVentana] El fichero '%s' ha sido cerrado con éxito", fichero);
            Notificar(mensaje, NO_ERROR, ECO_NO);
        }
    }
    else
    {
        sprintf(mensaje, "[Instruccion2FicheroVentana] El fichero '%s' no se ha podido abrir", fichero);
        Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
    }
}


/* escribo las matrices de la ventana en el fichero correspondiente */

void Matrices2FicheroVentana()
{
    FILE *handle;
    char fichero[MAX_LINE];
    char mensaje[MAX_LINE];
    int i, j, dim;

    dim = configuracion.ventana;
    
    /* construyo el nombre a partir del número de ventana */

    sprintf(fichero, "%lu.xls", ventana);
    
    /* esto no es ANSI  
    _ltoa(ventana, fichero, 10);
    strcat(fichero, ".xls"); */

    /* abro el fichero */
    if((handle  = fopen(fichero, "a")) != NULL)
    {
        sprintf(mensaje, "[Matrices2FicheroVentana] El fichero '%s' se ha abierto con éxito", fichero);
        Notificar(mensaje, NO_ERROR, ECO_NO);

        /* escribo las matrices y los parámetros que de ellas se derivan */

        fprintf(handle, "\n\nMATRICES\n");

        /* FILA 1: etiquetas */
        if(matriz.Ddatoexp != NULL) {fprintf(handle, "Ddatoexp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Ddir_exp != NULL) {fprintf(handle, "Ddir_exp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Dpilaexp != NULL) {fprintf(handle, "Dpilaexp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Destadoexp != NULL) {fprintf(handle, "Destadoexp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        fprintf(handle, "\n");

        /* matrices */
        for(i=0; i<dim; i++)
        {
            if(matriz.Ddatoexp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Ddatoexp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Ddir_exp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Ddir_exp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Dpilaexp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Dpilaexp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Destadoexp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Destadoexp[i][j]); fprintf(handle, "\n");
        }

        /* parámetros calculados */
        /* ¡OJO!: los separadores del sistema en EXCEL son los del castellano */
        /* la función 'fprintf' usa los del inglés (',' para miles y '.' para decimales) */
        /* lo mejor es anular en Opciones de EXCEL los separadores del sistema */
        /* y cambiarlos a los del idioma inglés antes de abrir mis ficheros */
        /* pasos de computación */
        if(configuracion.pasoscomputacion == SI)
        {
            if(matriz.Ddatoexp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Ddatoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Ddir_exp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Ddir_exp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Dpilaexp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Dpilaexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Destadoexp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Destadoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* grado de paralelismo */
        if(configuracion.gradoparalelismo == SI)
        {
            if(matriz.Ddatoexp != NULL) {fprintf(handle, "grado\t%.3f", grado->Ddatoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Ddir_exp != NULL) {fprintf(handle, "grado\t%.3f", grado->Ddir_exp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Dpilaexp != NULL) {fprintf(handle, "grado\t%.3f", grado->Dpilaexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Destadoexp != NULL) {fprintf(handle, "grado\t%.3f", grado->Destadoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* acoplamiento */
        if(configuracion.acoplamiento == SI)
        {
            if(matriz.Ddatoexp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Ddatoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Ddir_exp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Ddir_exp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Dpilaexp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Dpilaexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Destadoexp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Destadoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        fprintf(handle, "\n\n");

        
        /* FILA 2: etiquetas */
        if(matriz.Ddatoimp != NULL) {fprintf(handle, "Ddatoimp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Ddir_imp != NULL) {fprintf(handle, "Ddir_imp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Dpilaimp != NULL) {fprintf(handle, "Dpilaimp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Destadoimp != NULL) {fprintf(handle, "Destadoimp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        fprintf(handle, "\n");

        /* matrices */
        for(i=0; i<dim; i++)
        {
            if(matriz.Ddatoimp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Ddatoimp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Ddir_imp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Ddir_imp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Dpilaimp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Dpilaimp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Destadoimp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Destadoimp[i][j]); fprintf(handle, "\n");
        }

        /* parámetros calculados */
        /* pasos de computación */
        if(configuracion.pasoscomputacion == SI)
        {
            if(matriz.Ddatoimp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Ddatoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Ddir_imp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Ddir_imp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Dpilaimp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Dpilaimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Destadoimp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Destadoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* grado de paralelismo */
        if(configuracion.gradoparalelismo == SI)
        {
            if(matriz.Ddatoimp != NULL) {fprintf(handle, "grado\t%.3f", grado->Ddatoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Ddir_imp != NULL) {fprintf(handle, "grado\t%.3f", grado->Ddir_imp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Dpilaimp != NULL) {fprintf(handle, "grado\t%.3f", grado->Dpilaimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Destadoimp != NULL) {fprintf(handle, "grado\t%.3f", grado->Destadoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* acoplamiento */
        if(configuracion.acoplamiento == SI)
        {
            if(matriz.Ddatoimp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Ddatoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Ddir_imp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Ddir_imp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Dpilaimp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Dpilaimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Destadoimp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Destadoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        fprintf(handle, "\n\n");

        
        /* FILA 3: etiquetas */
        if(matriz.ADdatoexp != NULL) {fprintf(handle, "ADdatoexp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.ADdir_exp != NULL) {fprintf(handle, "ADdir_exp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.ADpilaexp != NULL) {fprintf(handle, "ADpilaexp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.ADestadoexp != NULL) {fprintf(handle, "ADestadoexp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        fprintf(handle, "\n");

        /* matrices */
        for(i=0; i<dim; i++)
        {
            if(matriz.ADdatoexp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.ADdatoexp[i][j]); fprintf(handle, "\t\t");
            if(matriz.ADdir_exp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.ADdir_exp[i][j]); fprintf(handle, "\t\t");
            if(matriz.ADpilaexp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.ADpilaexp[i][j]); fprintf(handle, "\t\t");
            if(matriz.ADestadoexp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.ADestadoexp[i][j]); fprintf(handle, "\n");
        }
                
        /* parámetros calculados */
        /* pasos de computación */
        if(configuracion.pasoscomputacion == SI)
        {
            if(matriz.ADdatoexp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->ADdatoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADdir_exp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->ADdir_exp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADpilaexp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->ADpilaexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADestadoexp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->ADestadoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* grado de paralelismo */
        if(configuracion.gradoparalelismo == SI)
        {
            if(matriz.ADdatoexp != NULL) {fprintf(handle, "grado\t%.3f", grado->ADdatoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADdir_exp != NULL) {fprintf(handle, "grado\t%.3f", grado->ADdir_exp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADpilaexp != NULL) {fprintf(handle, "grado\t%.3f", grado->ADpilaexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADestadoexp != NULL) {fprintf(handle, "grado\t%.3f", grado->ADestadoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* acoplamiento */
        if(configuracion.acoplamiento == SI)
        {
            if(matriz.ADdatoexp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->ADdatoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADdir_exp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->ADdir_exp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADpilaexp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->ADpilaexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADestadoexp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->ADestadoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        fprintf(handle, "\n\n");

        
        /* FILA 4: etiquetas */
        if(matriz.ADdatoimp != NULL) {fprintf(handle, "ADdatoimp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.ADdir_imp != NULL) {fprintf(handle, "ADdir_imp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.ADpilaimp != NULL) {fprintf(handle, "ADpilaimp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.ADestadoimp != NULL) {fprintf(handle, "ADestadoimp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        fprintf(handle, "\n");

        /* matrices */
        for(i=0; i<dim; i++)
        {
            if(matriz.ADdatoimp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.ADdatoimp[i][j]); fprintf(handle, "\t\t");
            if(matriz.ADdir_imp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.ADdir_imp[i][j]); fprintf(handle, "\t\t");
            if(matriz.ADpilaimp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.ADpilaimp[i][j]); fprintf(handle, "\t\t");
            if(matriz.ADestadoimp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.ADestadoimp[i][j]); fprintf(handle, "\n");
        }

        /* parámetros calculados */
        /* pasos de computación */
        if(configuracion.pasoscomputacion == SI)
        {
            if(matriz.ADdatoimp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->ADdatoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADdir_imp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->ADdir_imp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADpilaimp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->ADpilaimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADestadoimp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->ADestadoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* grado de paralelismo */
        if(configuracion.gradoparalelismo == SI)
        {
            if(matriz.ADdatoimp != NULL) {fprintf(handle, "grado\t%.3f", grado->ADdatoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADdir_imp != NULL) {fprintf(handle, "grado\t%.3f", grado->ADdir_imp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADpilaimp != NULL) {fprintf(handle, "grado\t%.3f", grado->ADpilaimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADestadoimp != NULL) {fprintf(handle, "grado\t%.3f", grado->ADestadoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* acoplamiento */
        if(configuracion.acoplamiento == SI)
        {
            if(matriz.ADdatoimp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->ADdatoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADdir_imp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->ADdir_imp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADpilaimp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->ADpilaimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.ADestadoimp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->ADestadoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        fprintf(handle, "\n\n");


        /* FILA 5: etiquetas */
        if(matriz.Sdatoexp != NULL) {fprintf(handle, "Sdatoexp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Sdir_exp != NULL) {fprintf(handle, "Sdir_exp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Spilaexp != NULL) {fprintf(handle, "Spilaexp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Sestadoexp != NULL) {fprintf(handle, "Sestadoexp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        fprintf(handle, "\n");

        /* matrices */
        for(i=0; i<dim; i++)
        {
            if(matriz.Sdatoexp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Sdatoexp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Sdir_exp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Sdir_exp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Spilaexp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Spilaexp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Sestadoexp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Sestadoexp[i][j]); fprintf(handle, "\n");
        }

        /* parámetros calculados */
        /* pasos de computación */
        if(configuracion.pasoscomputacion == SI)
        {
            if(matriz.Sdatoexp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Sdatoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sdir_exp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Sdir_exp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Spilaexp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Spilaexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sestadoexp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Sestadoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* grado de paralelismo */
        if(configuracion.gradoparalelismo == SI)
        {
            if(matriz.Sdatoexp != NULL) {fprintf(handle, "grado\t%.3f", grado->Sdatoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sdir_exp != NULL) {fprintf(handle, "grado\t%.3f", grado->Sdir_exp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Spilaexp != NULL) {fprintf(handle, "grado\t%.3f", grado->Spilaexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sestadoexp != NULL) {fprintf(handle, "grado\t%.3f", grado->Sestadoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* acoplamiento */
        if(configuracion.acoplamiento == SI)
        {
            if(matriz.Sdatoexp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Sdatoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sdir_exp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Sdir_exp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Spilaexp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Spilaexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sestadoexp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Sestadoexp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        fprintf(handle, "\n\n");


        /* FILA 6: etiquetas */
        if(matriz.Sdatoimp != NULL) {fprintf(handle, "Sdatoimp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Sdir_imp != NULL) {fprintf(handle, "Sdir_imp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Spilaimp != NULL) {fprintf(handle, "Spilaimp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        if(matriz.Sestadoimp != NULL) {fprintf(handle, "Sestadoimp"); for(i=0; i<dim+2; i++) fprintf(handle, "\t");}
        fprintf(handle, "\n");

        /* matrices */
        for(i=0; i<dim; i++)
        {
            if(matriz.Sdatoimp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Sdatoimp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Sdir_imp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Sdir_imp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Spilaimp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Spilaimp[i][j]); fprintf(handle, "\t\t");
            if(matriz.Sestadoimp != NULL) for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.Sestadoimp[i][j]); fprintf(handle, "\n");
        }

        /* parámetros calculados */
        /* pasos de computación */
        if(configuracion.pasoscomputacion == SI)
        {
            if(matriz.Sdatoimp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Sdatoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sdir_imp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Sdir_imp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Spilaimp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Spilaimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sestadoimp != NULL) {fprintf(handle, "pasos\t%.3f", pasos->Sestadoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* grado de paralelismo */
        if(configuracion.gradoparalelismo == SI)
        {
            if(matriz.Sdatoimp != NULL) {fprintf(handle, "grado\t%.3f", grado->Sdatoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sdir_imp != NULL) {fprintf(handle, "grado\t%.3f", grado->Sdir_imp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Spilaimp != NULL) {fprintf(handle, "grado\t%.3f", grado->Spilaimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sestadoimp != NULL) {fprintf(handle, "grado\t%.3f", grado->Sestadoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        /* acoplamiento */
        if(configuracion.acoplamiento == SI)
        {
            if(matriz.Sdatoimp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Sdatoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sdir_imp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Sdir_imp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Spilaimp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Spilaimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            if(matriz.Sestadoimp != NULL) {fprintf(handle, "acoplo\t%.3f", acoplo->Sestadoimp); for(i=0; i<dim+1; i++) fprintf(handle, "\t");}
            fprintf(handle, "\n");
        }
        fprintf(handle, "\n\n");

        
        /* matriz D */
        /* etiqueta */
        fprintf(handle, "D\n");
        /* matriz */
        for(i=0; i<dim; i++) {for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matriz.D[i][j]); fprintf(handle, "\n");}
        /* parámetros calculados */
        /* pasos de computación */
        if(configuracion.pasoscomputacion == SI) fprintf(handle, "pasos\t%.3f\n", pasos->D);
        /* grado de paralelismo */
        if(configuracion.gradoparalelismo == SI) fprintf(handle, "grado\t%.3f\n", grado->D);
        /* acoplamiento */
        if(configuracion.acoplamiento == SI) fprintf(handle, "acoplo\t%.3f\n", acoplo->D);
        fprintf(handle, "\n\n");

        /* orden parcial asociado a la matriz D */
        if(configuracion.ordenparcial == SI)
        {
            fprintf(handle, "orden parcial asociado a la matriz D\n");
            /* coloco el caracter "'" delante del listado del OrdenParcial */
            /* para que EXCEL lo tome como cadena y no como fecha */
            for(i=0; i<dim; i++) fprintf(handle, "paso\t%3d\t'%s\n", i+1, OrdenParcial[i]);
            fprintf(handle, "\n\n");
        }

        /* matriz C */
        if(configuracion.matrizcaminos == SI)
        {
            fprintf(handle, "C\n");
            for(i=0; i<dim; i++) {for(j=0; j<dim; j++) fprintf(handle, "%3d\t", matrizC[i][j]); fprintf(handle, "\n");}
            fprintf(handle, "\n\n");
        }

        

        /* cierro el fichero */
        if(fclose(handle))
        {
            sprintf(mensaje, "[Matrices2FicheroVentana] El fichero '%s' no se ha podido cerrar", fichero);
            Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
        }
        else
        {
            sprintf(mensaje, "[Matrices2FicheroVentana] El fichero '%s' ha sido cerrado con éxito", fichero);
            Notificar(mensaje, NO_ERROR, ECO_NO);
        }
    }
    else
    {
        sprintf(mensaje, "[Matrices2FicheroVentana] El fichero '%s' no se ha podido abrir", fichero);
        Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
    }
}


/* función que salva la configuración en un fichero previamente abierto */
/* OJO -> faltan parámetros */
/* ¿usar tantas cadenas constantes puede consumir memoria de una manera relevante?*/
#if 0
void SalvarConfiguracion(FILE *handle)
{
        /* escribo la configuración */
        fprintf(handle, "CAPTURA DE CONFIGURACIÓN =\t%s\n", configuracion.captura);
        /* FICHERO DE CONFIGURACIÓN POR DEFECTO */
        fprintf(handle, "FICHERO DE CONFIGURACIÓN =\t%s\n", configuracion.ficheroconfig);
        /* FICHEROS DE BASE DE DATOS */
        fprintf(handle, "FICHERO DE OPERACIONES =\t%s\n", configuracion.ficheronemos);
        fprintf(handle, "FICHERO DE SÍMBOLOS =\t%s\n", configuracion.ficheroubis);
        if(configuracion.cpi == SI)
        fprintf(handle, "FICHERO DE CICLOS =\t%s\n", configuracion.ficherociclos);

        /* ORIGEN DE DATOS */
        switch(configuracion.origen)
        {
            case TRAZA:
            fprintf(handle, "ORIGEN DE DATOS =\t%s\n", "TRAZA");
            break;

            case SECUENCIA:
            fprintf(handle, "ORIGEN DE DATOS =\t%s\n", "SECUENCIA");
            break;

            case CADENAHEX:
            fprintf(handle, "ORIGEN DE DATOS =\t%s\n", "CADENAHEX");
            break;
        }

        if(configuracion.origen != CADENAHEX)
        fprintf(handle, "FICHERO DE DATOS =\t%s\n", configuracion.ficherodatos);
        else
        fprintf(handle, "SECUENCIA DE INSTRUCCIÓN =\t%s\n", configuracion.cadenahex);

        if(configuracion.origen == TRAZA)
        {
            fprintf(handle, "RANGO =\t%.2f%%\n", configuracion.rango);
            fprintf(handle, "COMIENZO =\t%.2f%%\n", configuracion.comienzo);
            fprintf(handle, "INSTRUCCIÓN DE COMIENZO =\t%lu\n", configuracion.primera);
            fprintf(handle, "INSTRUCCIÓN FINAL =\t%lu\n", configuracion.ultima);
        }
    
        /* EVALUAR */
        fprintf(handle, "RECUENTOS =\t%s\n", configuracion.recuentos==SI ? "SI":"NO");
        fprintf(handle, "ASIGNAR CPI =\t%s\n", configuracion.cpi==SI ? "SI":"NO");
    
        /* PARÁMETROS DE ANÁLISIS DE DEPENDENCIAS DE DATOS */
        fprintf(handle, "TAMAÑO VENTANA INSTRUCCIONES =\t%u\n", configuracion.ventana);
        fprintf(handle, "LISTADO DE UBICACIONES =\t%s\n", configuracion.listaubis);
        fprintf(handle, "DESACOPLAR TIPOS DE DEPENDENCIAS =\t%s\n", configuracion.desacoplartipos==SI ? "SI":"NO");
        fprintf(handle, "DEPENDENCIAS VERDADERAS =\t%s\n", configuracion.verdaderas==SI ? "SI":"NO");
        fprintf(handle, "ANTIDEPENDENCIAS =\t%s\n", configuracion.antidependencias==SI ? "SI":"NO");
        fprintf(handle, "DEPENDENCIAS DE SALIDA =\t%s\n", configuracion.salida==SI ? "SI":"NO");
        fprintf(handle, "DESACOPLAR ORIGEN DE OPERANDOS =\t%s\n", configuracion.desacoplarorigen==SI ? "SI":"NO");
        fprintf(handle, "OPERANDOS EXPLÍCITOS =\t%s\n", configuracion.explicitos==SI ? "SI":"NO");
        fprintf(handle, "OPERANDOS IMPLÍCITOS =\t%s\n", configuracion.implicitos==SI ? "SI":"NO");
        fprintf(handle, "DESACOPLAR FUENTES DE DEPENDENCIAS =\t%s\n", configuracion.desacoplarfuentes==SI ? "SI":"NO");
        fprintf(handle, "DEPENDENCIAS DE DATOS =\t%s\n", configuracion.datos==SI ? "SI":"NO");
        fprintf(handle, "DEPENDENCIAS DE DIRECCIONES =\t%s\n", configuracion.direcciones==SI ? "SI":"NO");
        fprintf(handle, "DEPENDENCIAS DE PILA =\t%s\n", configuracion.pila==SI ? "SI":"NO");
        fprintf(handle, "DEPENDENCIAS DE CÓDIGOS DE CONDICIÓN =\t%s\n", configuracion.cc==SI ? "SI":"NO");
    
        /* CALCULAR */
        fprintf(handle, "CALCULAR GRADO DE PARALELISMO =\t%s\n", configuracion.gradoparalelismo==SI ? "SI":"NO");
        fprintf(handle, "CALCULAR TIEMPO DE EJECUCIÓN =\t%s\n", configuracion.tiempo==SI ? "SI":"NO");

        /* CONFIGURACIÓN DEL INFORME */
        fprintf(handle, "FICHERO DE RESULTADOS =\t%s.xls\n", configuracion.ficheroresultados);
        fprintf(handle, "VOLCAR BD EN FICHEROS =\t%s\n\n", configuracion.volcarBD==SI ? "SI":"NO");
}
#endif

/* función SOFISTICADA que salva la configuración en un fichero previamente abierto */

/* cabecera -> cadena con un texto explicativo */
/* fecha -> SI / NO incluir fecha */
/* completo -> SI;CFG incluir todos los parámetros; excluir los de captura de cfg */
/* comentarios -> SI / NO incluir comentarios de clases de parámetros */
/* separador de campos de datos (' ', '\t') */

/* cualquier información que no sea campo de datos se comenta con '[ ]' */
/* el fichero de configuración admite líneas en blanco */
/* la función 'completo' no está implementada */

void SalvarConfiguracionFichero(FILE *handle, char *cabecera, char fecha, char completo, char comentarios, char separador)
{
    time_t tiempo;
    struct tm *ptr_tm;
    char cadena[MAX_LINE];

    /* si hay cabecera la vuelco en el fichero */
    if(strcmp(cabecera, "") != 0) 
    {
        fprintf(handle, "[ADD v5.1 --Analizador de Dependencias de Datos--]\n\n");
        fprintf(handle, "[%s]\n\n", cabecera);
    }
    
    /* si hay que volcar la fecha la capturo y la vuelco */
    if(fecha == SI)
    {
        /* fecha y hora */
        tiempo = time(NULL);
        ptr_tm = localtime(&tiempo);
        strftime(cadena, MAX_LINE, "%d/%m/%y - %H:%M:%S", ptr_tm);

        fprintf(handle, "[Fecha de creación del fichero:\t%s]\n\n", cadena);
    }

    /* PARÁMETROS DE CONFIGURACIÓN */
    if(comentarios == SI) fprintf(handle, "\n[%s]\n", etiquetas[0]);

    if(completo != CFG)
    {
        /* OBSERVACIONES */
        if(comentarios == SI) fprintf(handle, "\n[%s]\n", etiquetas[1]);
        /* captura de configuración */
        fprintf(handle, "%s =%c%s\n", claves[0], separador, configuracion.captura);

        /* FICHERO DE CONFIGURACIÓN POR DEFECTO */
        if(comentarios == SI) fprintf(handle, "\n[%s]\n", etiquetas[2]);
        fprintf(handle, "%s =%c'%s'\n", claves[1], separador, configuracion.ficheroconfig);
    }

    /* FICHEROS DE BASE DE DATOS */
    if(comentarios == SI) fprintf(handle, "\n[%s]\n", etiquetas[3]);
    /* fichero de operaciones */
    fprintf(handle, "%s =%c'%s'\n", claves[2], separador, configuracion.ficheronemos);
    /* fichero de símbolos */
    fprintf(handle, "%s =%c'%s'\n", claves[3], separador, configuracion.ficheroubis);
    /* fichero de ciclos */
    fprintf(handle, "%s =%c'%s'\n", claves[4], separador, configuracion.ficherociclos);

    /* ORIGEN DE DATOS */
    if(comentarios == SI) fprintf(handle, "\n[%s]\n", etiquetas[4]);
    /* origen de datos */
    fprintf(handle, "%s =%c", claves[5], separador);
    switch(configuracion.origen)
    {
        case TRAZA:
        fprintf(handle, "TRAZA\n");
        break;

        case SECUENCIA:
        fprintf(handle, "SECUENCIA\n");
        break;

        case CADENAHEX:
        fprintf(handle, "CADENAHEX\n");
        break;
    }
    /* fichero de datos */
    fprintf(handle, "%s =%c'%s'\n", claves[6], separador, configuracion.ficherodatos);
    /* secuencia hexadecimal de una instrucción */
    fprintf(handle, "%s =%c%s\n", claves[7], separador, configuracion.cadenahex);
    /* rango de análisis en porcentaje (sólo trazas) */
    fprintf(handle, "%s =%c%2.2f%%\n", claves[8], separador, configuracion.rango);
    /* instrucción de comienzo en porcentaje */
    fprintf(handle, "%s =%c%2.2f%%\n", claves[9], separador, configuracion.comienzo);
    /* primera instrucción */
    fprintf(handle, "%s =%c%lu\n", claves[10], separador, configuracion.primera);
    /* última instrucción */
    fprintf(handle, "%s =%c%lu\n", claves[11], separador, configuracion.ultima);

    /* EVALUAR */
    if(comentarios == SI) fprintf(handle, "\n[%s]\n", etiquetas[5]);
    /* ¿hacer recuentos? */
    fprintf(handle, "%s =%c%s\n", claves[12], separador, configuracion.recuentos==SI ? "SI":"NO");
    /* ¿asignar ciclos a cada instrucción? */
    fprintf(handle, "%s =%c%s\n", claves[13], separador, configuracion.cpi==SI ? "SI":"NO");
    /* ¿hacer análisis de dependencias? */
    fprintf(handle, "%s =%c%s\n", claves[14], separador, configuracion.dependencias==SI ? "SI":"NO");

    /* PARÁMETROS DE ANÁLISIS DE DEPENDENCIAS */
    if(comentarios == SI) fprintf(handle, "\n[%s]\n", etiquetas[6]);
    /* tamaño de la ventana de instrucciones */
    fprintf(handle, "%s =%c%d\n", claves[15], separador, configuracion.ventana);
    /* listado de ubicaciones que van a la pizarra de dependencias */
    fprintf(handle, "%s =%c'%s'\n", claves[16], separador, configuracion.listaubis);
    /* ¿desacoplar tipos de dependencias? */
    fprintf(handle, "%s =%c%s\n", claves[17], separador, configuracion.desacoplartipos==SI ? "SI":"NO");
    /* ¿considerar dependencias verdaderas? */
    fprintf(handle, "%s =%c%s\n", claves[18], separador, configuracion.verdaderas==SI ? "SI":"NO");
    /* ¿considerar antidependencias? */
    fprintf(handle, "%s =%c%s\n", claves[19], separador, configuracion.antidependencias==SI ? "SI":"NO");
    /* ¿considerar dependencias de salida? */
    fprintf(handle, "%s =%c%s\n", claves[20], separador, configuracion.salida==SI ? "SI":"NO");
    /* ¿desacoplar origen de dependencias? */
    fprintf(handle, "%s =%c%s\n", claves[21], separador, configuracion.desacoplarorigen==SI ? "SI":"NO");
    /* ¿considerar explícitas? */
    fprintf(handle, "%s =%c%s\n", claves[22], separador, configuracion.explicitos==SI ? "SI":"NO");
    /* ¿considerar implícitas? */
    fprintf(handle, "%s =%c%s\n", claves[23], separador, configuracion.implicitos==SI ? "SI":"NO");
    /* ¿desacoplar fuentes de dependencias? */
    fprintf(handle, "%s =%c%s\n", claves[24], separador, configuracion.desacoplarfuentes==SI ? "SI":"NO");
    /* ¿procesamiento de datos? */
    fprintf(handle, "%s =%c%s\n", claves[25], separador, configuracion.datos==SI ? "SI":"NO");
    /* ¿cómputo de direcciones? */
    fprintf(handle, "%s =%c%s\n", claves[26], separador, configuracion.direcciones==SI ? "SI":"NO");
    /* ¿tráfico con la pila? */
    fprintf(handle, "%s =%c%s\n", claves[27], separador, configuracion.pila==SI ? "SI":"NO");
    /* ¿códigos de condición? */
    fprintf(handle, "%s =%c%s\n", claves[28], separador, configuracion.cc==SI ? "SI":"NO");

    /* CALCULAR */
    if(comentarios == SI) fprintf(handle, "\n[%s]\n", etiquetas[7]);
    /* ¿calcular CPI promedio? */
    fprintf(handle, "%s =%c%s\n", claves[29], separador, configuracion.CPImedio==SI ? "SI":"NO");
    /* ¿calcular tiempo de ejecución? */
    fprintf(handle, "%s =%c%s\n", claves[30], separador, configuracion.tiempo==SI ? "SI":"NO");
    /* ¿obtener la lista de orden parcial? */
    fprintf(handle, "%s =%c%s\n", claves[31], separador, configuracion.ordenparcial==SI ? "SI":"NO");
    /* ¿calcular la matriz de caminos? */
    fprintf(handle, "%s =%c%s\n", claves[32], separador, configuracion.matrizcaminos==SI ? "SI":"NO");
    /* ¿calcular pasos de computación para cada ventana? */
    fprintf(handle, "%s =%c%s\n", claves[33], separador, configuracion.pasoscomputacion==SI ? "SI":"NO");
    /* ¿determinar grado de paralelismo? */
    fprintf(handle, "%s =%c%s\n", claves[34], separador, configuracion.gradoparalelismo==SI ? "SI":"NO");
    /* ¿calcular acoplamiento? */
    fprintf(handle, "%s =%c%s\n", claves[35], separador, configuracion.acoplamiento==SI ? "SI":"NO");
    /* ¿generar histograma de pasos de computación? */
    fprintf(handle, "%s =%c%s\n", claves[36], separador, configuracion.distribucionpasos==SI ? "SI":"NO");

    /* CONFIGURACIÓN DEL INFORME */
    if(comentarios == SI) fprintf(handle, "\n[%s]\n", etiquetas[8]);
    /* volcar bases de datos en ficheros */
    fprintf(handle, "%s =%c%s\n", claves[37], separador, configuracion.volcarBD==SI ? "SI":"NO");
    /* volcar la configuración en curso en un fichero nuevo */
    fprintf(handle, "%s =%c%s\n", claves[38], separador, configuracion.crearficheroconfig==SI ? "SI":"NO");
    /* nombre del nuevo fichero de configuración */
    fprintf(handle, "%s =%c'%s'\n", claves[39], separador, configuracion.nuevoficheroconfig);
    /* lista de ventanas a volcar en ficheros EXCEL */
    fprintf(handle, "%s =%c'%s'\n", claves[40], separador, configuracion.volcarventana);
    /* nombre del fichero de resultados */
    fprintf(handle, "%s =%c'%s'\n", claves[41], separador, configuracion.ficheroresultados);
    /* nivel de notificación en el fichero de log  */
    fprintf(handle, "%s =%c", claves[42], separador);
    switch(configuracion.nivelnotificaciones)
    {
        case ALL:
        fprintf(handle, "ALL\n");
        break;

        case EX_CFG:
        fprintf(handle, "EX_CFG\n");
        break;

        case ERRORS:
        fprintf(handle, "ERRORS\n");
        break;
    }

    /* INTERFASE GRÁFICA */
    if(comentarios == SI) fprintf(handle, "\n[%s]\n", etiquetas[9]);
    /* mostrar información de la instrucción en curso */
    fprintf(handle, "%s =%c%s\n", claves[43], separador, configuracion.verinstruccion==SI ? "SI":"NO");
    /* mostrar información de la ventna en curso */
    fprintf(handle, "%s =%c%s\n", claves[44], separador, configuracion.verventana==SI ? "SI":"NO");

    fprintf(handle, "\n\n");
}


/* función que crea un fichero de configuración con los parámetros de configuración en curso */

void CrearFicheroConfiguracion()
{
    FILE *handle;
    char nombrefichero[MAX_LINE];
    char mensaje[MAX_LINE];

    sprintf(nombrefichero, "%s.cfg", configuracion.nuevoficheroconfig);

    /* abro el fichero */
    if((handle  = fopen(nombrefichero, "w")) != NULL)
    {
        sprintf(mensaje, "[CrearFicheroConfiguracion] El fichero '%s' se ha abierto con éxito", nombrefichero);
        Notificar(mensaje, NO_ERROR, ECO_NO);

        /* vuelco la configuración */
        strcpy(mensaje, "Nuevo fichero de configuración");
        /* fecha SI, completo CFG, comentarios SI, separador " "); */
        SalvarConfiguracionFichero(handle, mensaje, SI, CFG, SI, ' ');
        
        /* SalvarConfiguracion(handle);    */

        /* cierro el fichero */
        if(fclose(handle))
        {
            sprintf(mensaje, "[CrearFicheroConfiguracion] El fichero '%s' no se ha podido cerrar", nombrefichero);
            Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
        }
        else
        {
            sprintf(mensaje, "[CrearFicheroConfiguracion] El fichero '%s' ha sido cerrado con éxito", nombrefichero);
            Notificar(mensaje, NO_ERROR, ECO_NO);
        }
    }
    else
    {
        sprintf(mensaje, "[CrearFicheroConfiguracion] El fichero '%s' no se ha podido abrir", nombrefichero);
        Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
    }
}


/* EJEMPLO de manejo de funciones de fecha y hora */
/*
#include <stdio.h>
#include <time.h>

int main()
{
  time_t tiempo;
  char cad[80];
  struct tm *tmPtr;

  tiempo = time(NULL);
  tmPtr = localtime(&tiempo);
  strftime( cad, 80, "%H:%M.%S, %A de %B de %Y", tmPtr );

  printf( "La hora local es: %s\n", asctime(tmPtr) );
  printf( "La hora y fecha locales son: %s\n", cad );

  return 0;
}
*/


/* esta función escribe una variable agregada en un fichero */

void SalvarVariableAgregada(char *cadena, parametromatriz *variable, FILE *handle)
{
    if(matriz.Ddatoexp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Ddatoexp", variable->Ddatoexp);
    if(matriz.Ddir_exp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Ddir_exp", variable->Ddir_exp);
    if(matriz.Dpilaexp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Dpilaexp", variable->Dpilaexp); 
    if(matriz.Destadoexp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Destadoexp", variable->Destadoexp); 
        
    if(matriz.Ddatoimp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Ddatoimp", variable->Ddatoimp); 
    if(matriz.Ddir_imp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Ddir_imp", variable->Ddir_imp); 
    if(matriz.Dpilaimp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Dpilaimp", variable->Dpilaimp); 
    if(matriz.Destadoimp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Destadoimp", variable->Destadoimp); 

    if(matriz.ADdatoexp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "ADdatoexp", variable->ADdatoexp); 
    if(matriz.ADdir_exp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "ADdir_exp", variable->ADdir_exp); 
    if(matriz.ADpilaexp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "ADpilaexp", variable->ADpilaexp); 
    if(matriz.ADestadoexp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "ADestadoexp", variable->ADestadoexp); 
        
    if(matriz.ADdatoimp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "ADdatoimp", variable->ADdatoimp); 
    if(matriz.ADdir_imp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "ADdir_imp", variable->ADdir_imp); 
    if(matriz.ADpilaimp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "ADpilaimp", variable->ADpilaimp); 
    if(matriz.ADestadoimp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "ADestadoimp", variable->ADestadoimp); 

    if(matriz.Sdatoexp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Sdatoexp", variable->Sdatoexp); 
    if(matriz.Sdir_exp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Sdir_exp", variable->Sdir_exp); 
    if(matriz.Spilaexp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Spilaexp", variable->Spilaexp); 
    if(matriz.Sestadoexp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Sestadoexp", variable->Sestadoexp); 
        
    if(matriz.Sdatoimp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Sdatoimp", variable->Sdatoimp); 
    if(matriz.Sdir_imp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Sdir_imp", variable->Sdir_imp); 
    if(matriz.Spilaimp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Spilaimp", variable->Spilaimp); 
    if(matriz.Sestadoimp != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "Sestadoimp", variable->Sestadoimp); 

    if(matriz.D != NULL) fprintf(handle, "%s %s\t%f\n", cadena, "D", variable->D); 

    fprintf(handle, "\n");
}



/* RESULTADOS */
/* función que crea un fichero EXCEL con los resultados */

void CrearFicheroResultados (char *fichero)
{
    time_t tiempo;
    struct tm *ptr_tm;

    FILE *handle;
    unsigned int i;
    char nombrefichero[MAX_LINE];
    
    char mensaje[MAX_LINE];
    char *ptr;

    
    /* el fichero de resultados va a tener el formato de texto EXCEL */
    /* construyo el nombre del fichero con el prefijo indicado en la */
    /* configuración más el nombre del fichero origen de datos sin */
    /* extensión más el tamaño de la ventana de instrucciones */
    /* al nombre del fichero le asigno la extensión .XLS */

    /* esto cambia la configuración ya que añade la extensión => strcat(fichero, ".xls"); */
    /* otro modo de hacer lo mismo => sprintf(cadena, "%s.xls", fichero); */

    /* construyo el nombre del fichero de resultados */
    /* palabra + fichero de datos + tamaño de ventana + mapa de dependencias */
    strcpy(mensaje, configuracion.ficherodatos);
    ptr = mensaje + strlen(mensaje);        /* coloco un puntero al final */
    /* busco la última barra viajando hacia atrás hasta alcanzar el comienzo */
    while(*(--ptr)!='/' && *ptr!='\\' && ptr!=mensaje-1);
    strcpy(mensaje, ++ptr);                    /* actualizo la cadena */
    ptr = mensaje;                            /* coloco el puntero al principio */
    /* finalizo la cadena cuando encuentro la .ext */
    while(*(++ptr)!='.' && *ptr!='\0'); *ptr = '\0';
    sprintf(nombrefichero, "%s %s %u (%c%c%c)(%c%c)(%c%c%c%c).xls",
        fichero,
        mensaje,
        configuracion.ventana,
        configuracion.verdaderas==SI ? 'x':'o',
        configuracion.antidependencias==SI ? 'x':'o',
        configuracion.salida==SI ? 'x':'o',
        configuracion.explicitos==SI ? 'x':'o',
        configuracion.implicitos==SI ? 'x':'o',
        configuracion.datos==SI ? 'x':'o',
        configuracion.direcciones==SI ? 'x':'o',
        configuracion.pila==SI ? 'x':'o',
        configuracion.cc==SI ? 'x':'o');

    
    /* abro el fichero */
    if((handle  = fopen(nombrefichero, "w")) != NULL)
    {
        sprintf(mensaje, "[CrearFicheroResultados] El fichero '%s' se ha abierto con éxito", nombrefichero);
        Notificar(mensaje, NO_ERROR, ECO_NO);

        /* escribo una pequeña cabecera */
        fprintf(handle, "RESULTADOS DEL ANÁLISIS\n\n");
        /* fecha y hora */
        tiempo = time(NULL);
        ptr_tm = localtime(&tiempo);
        /* la cadena devuelta tiene formato inglés => strcpy(mensaje, asctime(ptr_tm)); */
        strftime(mensaje, MAX_LINE, "%d/%m/%y\t%H:%M:%S", ptr_tm);
        /*
        strftime(mensaje, MAX_LINE, "%c", ptr_tm);
        strftime(mensaje, MAX_LINE, "%#c", ptr_tm);
        strftime(mensaje, MAX_LINE, "%x", ptr_tm);
        strftime(mensaje, MAX_LINE, "%#x", ptr_tm);
        */

        fprintf(handle, "Fecha de creación del fichero\t%s \n\n", mensaje);

        /* vuelco la configuración en el fichero de resultados */
        /* sin cabecera, fecha NO, completo SI, comentarios SI, separador "\t"); */
        SalvarConfiguracionFichero(handle, "", NO, SI, SI, '\t');    

        /* SalvarConfiguracion(handle);    */


        /* VOLUMEN DE INFORMACIÓN PROCESADA */
        fprintf(handle, "VOLUMEN DE INFORMACIÓN PROCESADA\n");
        fprintf(handle, "Instrucciones procesadas\t%lu\n", instruccion-1);
        fprintf(handle, "Ventanas procesadas\t%lu", ventana);
        fprintf(handle, "\n\n");
            
        /* INFORME DE RECUENTOS */
        if(configuracion.recuentos == SI)
        {
            fprintf(handle, "RECUENTOS:\n");
            fprintf(handle, "Nemónicos:\n");            
            for(i=0; i<num_nemonicos; i++)        /* RECUENTO DE NEMÓNICOS */
            {
                fprintf(handle, "%s\t%lu\n", nemonicos[i].nemonico, contadornemonicos[i]);
            }
            
            fprintf(handle, "\n");
            fprintf(handle, "Acceso a operandos explícitos:\n");
            fprintf(handle, "Símbolos\tlecturas\tescrituras\n");
            for(i=0; i<num_simbolos; i++)        /* RECUENTO DE ACCESO A DATOS */
            {
                fprintf(handle, "%s\t%lu\t%lu\n", simbolos[i].simbolo, contadorlecturas[i], contadorescrituras[i]);
            }
            fprintf(handle, "\n\n");
        }

        /* INFORME CPI MEDIO */
        if(configuracion.CPImedio == SI)
        {
            fprintf(handle, "CPI medio:\t%f", cpimedio);
            fprintf(handle, "\n\n");
        }

        /* TIEMPO DE EJECUCIÓN */
        if(configuracion.tiempo == SI)
        {
            fprintf(handle, "Tiempo de ejecución:\t%f\tseg", tiempoejecucion);
            fprintf(handle, "\n\n");
        }
        
        /* RESULTADOS DEL ANÁLISIS DE DEPENDENCIAS DE DATOS */
        if(configuracion.dependencias == SI)
        {
            fprintf(handle, "ANÁLISIS DE DEPENDENCIAS DE DATOS:\n");
            if(configuracion.pasoscomputacion == SI)
            {
                fprintf(handle, "Promedio de pasos de computación\n");
                SalvarVariableAgregada("promedio pasos", mediapasos, handle);
                fprintf(handle, "\n");
            }
            if(configuracion.gradoparalelismo == SI)
            {
                fprintf(handle, "Promedio de grado de paralelismo normalizado\n");
                SalvarVariableAgregada("grado de paralelismo", mediagrado, handle);
                fprintf(handle, "\n");
            }
            if(configuracion.acoplamiento == SI)
            {
                fprintf(handle, "Promedio de acoplamiento\n");
                SalvarVariableAgregada("acoplamiento", mediaacoplo, handle);
                fprintf(handle, "\n");
            }
            if(configuracion.distribucionpasos == SI)
            {
                fprintf(handle, "Histograma de pasos de computación para la matriz D\n");
                fprintf(handle, "pasos\tnúmero ventanas\n");
                /* OJO, el histograma va de 1 al tamaño de la ventana (el 0 no sirve) */
                for(i=1; i<configuracion.ventana+1; i++)
                {
                    fprintf(handle, "%u\t%lu\n", i, distribucionpasos[i]);
                }
            }
            fprintf(handle, "\n\n");
        }



        /* cierro el fichero */
        if(fclose(handle))
        {
            sprintf(mensaje, "[CrearFicheroResultados] El fichero '%s' no se ha podido cerrar", nombrefichero);
            Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
        }
        else
        {
            sprintf(mensaje, "[CrearFicheroResultados] El fichero '%s' ha sido cerrado con éxito", nombrefichero);
            Notificar(mensaje, NO_ERROR, ECO_NO);
        }
    }
    else
    {
        sprintf(mensaje, "[CrearFicheroResultados] El fichero '%s' no se ha podido abrir", nombrefichero);
        Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
    }
}


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