Return to Matrices.c CVS log

Up to [Repository ATC2] / ADD_ver_10 / Source Code / Source Files

*** empty log message ***

/********************************************************************/
/*  Matrices.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: Matrices.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: Matrices.c                                                         */
/*                                                                            */
/* Este módulo contiene las funciones de manejo de las matrices de            */
/* dependencias de datos.                                                     */
/******************************************************************************/
/* Fecha: 16 de septiembre de 2005                                            */
/******************************************************************************/

#include <stdio.h>
#include <stdlib.h>

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

#include "matrices.h"

/* configuracion */
extern struct argumentos configuracion;

/* análisis de dependencias de datos */
extern struct punterosD matriz;



/* inicia a NULL todos los punteros de las matrices */

void IniciarPunterosMatrices()
{
    matriz.Ddatoexp = NULL;
    matriz.Ddir_exp = NULL;
    matriz.Dpilaexp = NULL;
    matriz.Destadoexp = NULL;
    matriz.Ddatoimp = NULL;
    matriz.Ddir_imp = NULL;
    matriz.Dpilaimp = NULL;
    matriz.Destadoimp = NULL;

    matriz.ADdatoexp = NULL;
    matriz.ADdir_exp = NULL;
    matriz.ADpilaexp = NULL;
    matriz.ADestadoexp = NULL;
    matriz.ADdatoimp = NULL;
    matriz.ADdir_imp = NULL;
    matriz.ADpilaimp = NULL;
    matriz.ADestadoimp = NULL;

    matriz.Sdatoexp = NULL;
    matriz.Sdir_exp = NULL;
    matriz.Spilaexp = NULL;
    matriz.Sestadoexp = NULL;
    matriz.Sdatoimp = NULL;
    matriz.Sdir_imp = NULL;
    matriz.Spilaimp = NULL;
    matriz.Sestadoimp = NULL;

    matriz.D = NULL;
}


/* reserva espacio para una matriz determinada y lo inicia a 0*/
/* devuelve el puntero */

unsigned char ** CrearMatriz()
{
    char mensaje[MAX_LINE];
    unsigned int i;
    unsigned char **matrizD;

    /* 1º un puntero por cada fila */
    matrizD = calloc(configuracion.ventana, sizeof(unsigned char *));
    if (matrizD == NULL)
    {
        sprintf(mensaje, "[CrearMatriz] Memoria insuficiente");
        Notificar(mensaje, ERROR_SALIR, ECO_NO);
        /* el programa finaliza si no hay memoria suficiente */
    }
    /* 2º un 'char' por cada columna */
    for(i=0; i<configuracion.ventana; i++)
    {
        matrizD[i] = calloc(configuracion.ventana, sizeof(unsigned char));
        if (matrizD[i] == NULL)
        {
            sprintf(mensaje, "[CrearMatriz] Memoria insuficiente");
            Notificar(mensaje, ERROR_SALIR, ECO_NO);
            /* el programa finaliza si no hay memoria suficiente */
        }
    }
    return matrizD;
}


/* otro modo de hacer lo mismo */

/* llamada en main() --> CrearMatriz(&matriz.Ddatoexp); */

/* CrearMatriz(unsigned char ***matrizD)
{


    *matrizD = calloc(configuracion.ventana , sizeof(unsigned char *));


    return *matrizD;
}*/


/* crea todas las matrices de dependencias necesarias en función de la configuración */

void CrearMatricesDependencias()
{
    /* creo las matrices de dependencias que sean necesarias */
    /* mapa de posibles matrices por desacoplos */
    /* tipo        origen    fuente */
    /*   SI          SI     SI     */
    /*   SI          SI     NO     */
    /*   SI          NO     NO     */
    /*   NO          NO     NO     */        /* -> por defecto no se desacopla nada */

    if(configuracion.desacoplarfuentes == SI)
    {
        if(configuracion.datos == SI) matriz.Ddatoexp = CrearMatriz();
        if(configuracion.direcciones == SI) matriz.Ddir_exp = CrearMatriz();
        if(configuracion.pila == SI) matriz.Dpilaexp = CrearMatriz();
        if(configuracion.cc == SI) matriz.Destadoexp = CrearMatriz();
    
        if(configuracion.datos == SI) matriz.Ddatoimp = CrearMatriz();
        if(configuracion.direcciones == SI) matriz.Ddir_imp = CrearMatriz();
        if(configuracion.pila == SI) matriz.Dpilaimp = CrearMatriz();
        if(configuracion.cc == SI) matriz.Destadoimp = CrearMatriz();

        if(configuracion.datos == SI) matriz.ADdatoexp = CrearMatriz();
        if(configuracion.direcciones == SI) matriz.ADdir_exp = CrearMatriz();
        if(configuracion.pila == SI) matriz.ADpilaexp = CrearMatriz();
        if(configuracion.cc == SI) matriz.ADestadoexp = CrearMatriz();
        
        if(configuracion.datos == SI) matriz.ADdatoimp = CrearMatriz();
        if(configuracion.direcciones == SI) matriz.ADdir_imp = CrearMatriz();
        if(configuracion.pila == SI) matriz.ADpilaimp = CrearMatriz();
        if(configuracion.cc == SI) matriz.ADestadoimp = CrearMatriz();

        if(configuracion.datos == SI) matriz.Sdatoexp = CrearMatriz();
        if(configuracion.direcciones == SI) matriz.Sdir_exp = CrearMatriz();
        if(configuracion.pila == SI) matriz.Spilaexp = CrearMatriz();
        if(configuracion.cc == SI) matriz.Sestadoexp = CrearMatriz();
        
        if(configuracion.datos == SI) matriz.Sdatoimp = CrearMatriz();
        if(configuracion.direcciones == SI) matriz.Sdir_imp = CrearMatriz();
        if(configuracion.pila == SI) matriz.Spilaimp = CrearMatriz();
        if(configuracion.cc == SI) matriz.Sestadoimp = CrearMatriz();
    }

    else if(configuracion.desacoplarorigen == SI)
    {
        if(configuracion.explicitos == SI) matriz.Ddatoexp = CrearMatriz();
        if(configuracion.implicitos == SI) matriz.Ddatoimp = CrearMatriz();

        if(configuracion.explicitos == SI) matriz.ADdatoexp = CrearMatriz();
        if(configuracion.implicitos == SI) matriz.ADdatoimp = CrearMatriz();

        if(configuracion.explicitos == SI) matriz.Sdatoexp = CrearMatriz();
        if(configuracion.implicitos == SI) matriz.Sdatoimp = CrearMatriz();
    }

    else if(configuracion.desacoplartipos == SI)
    {
        if(configuracion.verdaderas == SI) matriz.Ddatoexp = CrearMatriz();
        if(configuracion.antidependencias == SI) matriz.ADdatoexp = CrearMatriz();
        if(configuracion.salida == SI) matriz.Sdatoexp = CrearMatriz();
    }

    matriz.D = CrearMatriz();
}


/* inicia una matriz poniendo sus componentes a 0 */

void IniciarMatriz(unsigned char **matriz)
{
    unsigned int i, j;

    if(matriz != NULL) for(i=0; i<configuracion.ventana; i++) for(j=0; j<configuracion.ventana; j++) matriz[i][j] = 0; 
}


/* inicia las matrices abiertas poniendo a 0 todas sus componentes */
/* utilizando la función anterior es más compacto aunque quizá algo más lento */

void IniciarMatricesDependencias()
{
    unsigned int i, j, dim;

    dim = configuracion.ventana;
    
    if(matriz.Ddatoexp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Ddatoexp[i][j] = 0; 
    if(matriz.Ddir_exp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Ddir_exp[i][j] = 0; 
    if(matriz.Dpilaexp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Dpilaexp[i][j] = 0; 
    if(matriz.Destadoexp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Destadoexp[i][j] = 0; 
        
    if(matriz.Ddatoimp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Ddatoimp[i][j] = 0; 
    if(matriz.Ddir_imp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Ddir_imp[i][j] = 0; 
    if(matriz.Dpilaimp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Dpilaimp[i][j] = 0; 
    if(matriz.Destadoimp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Destadoimp[i][j] = 0; 

    if(matriz.ADdatoexp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.ADdatoexp[i][j] = 0; 
    if(matriz.ADdir_exp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.ADdir_exp[i][j] = 0; 
    if(matriz.ADpilaexp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.ADpilaexp[i][j] = 0; 
    if(matriz.ADestadoexp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.ADestadoexp[i][j] = 0; 
        
    if(matriz.ADdatoimp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.ADdatoimp[i][j] = 0; 
    if(matriz.ADdir_imp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.ADdir_imp[i][j] = 0; 
    if(matriz.ADpilaimp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.ADpilaimp[i][j] = 0; 
    if(matriz.ADestadoimp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.ADestadoimp[i][j] = 0; 

    if(matriz.Sdatoexp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Sdatoexp[i][j] = 0; 
    if(matriz.Sdir_exp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Sdir_exp[i][j] = 0; 
    if(matriz.Spilaexp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Spilaexp[i][j] = 0; 
    if(matriz.Sestadoexp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Sestadoexp[i][j] = 0; 
        
    if(matriz.Sdatoimp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Sdatoimp[i][j] = 0; 
    if(matriz.Sdir_imp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Sdir_imp[i][j] = 0; 
    if(matriz.Spilaimp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Spilaimp[i][j] = 0; 
    if(matriz.Sestadoimp != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.Sestadoimp[i][j] = 0; 

    if(matriz.D != NULL) for(i=0; i<dim; i++) for(j=0; j<dim; j++) matriz.D[i][j] = 0; 
}


/* libera la memoria reservada para una matriz */

void LiberarMemoriaMatriz(unsigned char **matriz)
{
    unsigned int i;

    if(matriz != NULL) {for(i=0; i<configuracion.ventana; i++) free(matriz[i]); free(matriz);} 
}


/* libera la memoria reservada para las matrices abiertas */
/* utilizando la función anterior es más compacto aunque quizá algo más lento */

void LiberarMemoriaMatricesDependencias()
{
    unsigned int i,dim;

    dim = configuracion.ventana;

    if(matriz.Ddatoexp != NULL) {for(i=0; i<dim; i++) free(matriz.Ddatoexp[i]); free(matriz.Ddatoexp);}
    if(matriz.Ddir_exp != NULL) {for(i=0; i<dim; i++) free(matriz.Ddir_exp[i]); free(matriz.Ddir_exp);}
    if(matriz.Dpilaexp != NULL) {for(i=0; i<dim; i++) free(matriz.Dpilaexp[i]); free(matriz.Dpilaexp);}
    if(matriz.Destadoexp != NULL) {for(i=0; i<dim; i++) free(matriz.Destadoexp[i]); free(matriz.Destadoexp);}
        
    if(matriz.Ddatoimp != NULL) {for(i=0; i<dim; i++) free(matriz.Ddatoimp[i]); free(matriz.Ddatoimp);}
    if(matriz.Ddir_imp != NULL) {for(i=0; i<dim; i++) free(matriz.Ddir_imp[i]); free(matriz.Ddir_imp);}
    if(matriz.Dpilaimp != NULL) {for(i=0; i<dim; i++) free(matriz.Dpilaimp[i]); free(matriz.Dpilaimp);} 
    if(matriz.Destadoimp != NULL) {for(i=0; i<dim; i++) free(matriz.Destadoimp[i]); free(matriz.Destadoimp);}

    if(matriz.ADdatoexp != NULL) {for(i=0; i<dim; i++) free(matriz.ADdatoexp[i]); free(matriz.ADdatoexp);} 
    if(matriz.ADdir_exp != NULL) {for(i=0; i<dim; i++) free(matriz.ADdir_exp[i]); free(matriz.ADdir_exp);} 
    if(matriz.ADpilaexp != NULL) {for(i=0; i<dim; i++) free(matriz.ADpilaexp[i]); free(matriz.ADpilaexp);} 
    if(matriz.ADestadoexp != NULL) {for(i=0; i<dim; i++) free(matriz.ADestadoexp[i]); free(matriz.ADestadoexp);}
        
    if(matriz.ADdatoimp != NULL) {for(i=0; i<dim; i++) free(matriz.ADdatoimp[i]); free(matriz.ADdatoimp);} 
    if(matriz.ADdir_imp != NULL) {for(i=0; i<dim; i++) free(matriz.ADdir_imp[i]); free(matriz.ADdir_imp);} 
    if(matriz.ADpilaimp != NULL) {for(i=0; i<dim; i++) free(matriz.ADpilaimp[i]); free(matriz.ADpilaimp);} 
    if(matriz.ADestadoimp != NULL) {for(i=0; i<dim; i++) free(matriz.ADestadoimp[i]); free(matriz.ADestadoimp);}

    if(matriz.Sdatoexp != NULL) {for(i=0; i<dim; i++) free(matriz.Sdatoexp[i]); free(matriz.Sdatoexp);} 
    if(matriz.Sdir_exp != NULL) {for(i=0; i<dim; i++) free(matriz.Sdir_exp[i]); free(matriz.Sdir_exp);} 
    if(matriz.Spilaexp != NULL) {for(i=0; i<dim; i++) free(matriz.Spilaexp[i]); free(matriz.Spilaexp);} 
    if(matriz.Sestadoexp != NULL) {for(i=0; i<dim; i++) free(matriz.Sestadoexp[i]); free(matriz.Sestadoexp);}
        
    if(matriz.Sdatoimp != NULL) {for(i=0; i<dim; i++) free(matriz.Sdatoimp[i]); free(matriz.Sdatoimp);} 
    if(matriz.Sdir_imp != NULL) {for(i=0; i<dim; i++) free(matriz.Sdir_imp[i]); free(matriz.Sdir_imp);} 
    if(matriz.Spilaimp != NULL) {for(i=0; i<dim; i++) free(matriz.Spilaimp[i]); free(matriz.Spilaimp);} 
    if(matriz.Sestadoimp != NULL) {for(i=0; i<dim; i++) free(matriz.Sestadoimp[i]); free(matriz.Sestadoimp);}

    if(matriz.D != NULL) {for(i=0; i<dim; i++) free(matriz.D[i]); free(matriz.D);} 
}