Return to Matrices.c CVS log

Up to [Repository ATC2] / ADD_ver_10

*** empty log message ***

/********************************************************************/
/*  Matrices.c                                                      */
/*                                                                  */
/*  Copyright (c) 1997-2006 Rafael Rico      (rafael.rico@uah.es)   */
/*                                                                  */
/*  This file is part of ADD version 5.10.                          */
/*                                                                  */
/*  ADD is free software; you can redistribute it and/or modify     */
/*  it under the terms of the GNU General Public License as         */
/*  published by the Free Software Foundation; either version 2 of  */
/*  the License, or (at your option) any later version.             */
/*                                                                  */
/*  ADD is distributed in the hope that it will be useful,          */
/*  but WITHOUT ANY WARRANTY; without even the implied warranty of  */
/*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   */
/*  GNU General Public License for more details.                    */
/*                                                                  */
/*  You should have received a copy of the GNU General Public       */
/*  License along with ADD; if not, write to the Free Software      */
/*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA        */
/*  02111-1307  USA                                                 */
/*                                                                  */
/*  --------------------------- History --------------------------- */
/*                                                                  */
/*  Revision 1.2. 01/2006                                           */
/*  Added GPL License and JavaDoc style documentation               */
/*                                                                  */
/*  Revision 1.1. 09/2005                                           */
/*  Initial Revision                                                */
/*                                                                  */
/********************************************************************/


/******************************************************************************/
/* 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 */
	/* fuente	origen	tipo */
	/*   SI		  SI	 SI	 */
	/*   SI		  SI	 NO	 */
	/*   SI		  NO	 NO	 */
	/*   NO		  NO	 NO	 */

	if(configuracion.desacoplartipos == 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.desacoplarfuentes == 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);} 
}