Return to AnalizadorDependencias.c CVS log

Up to [Repository ATC2] / ADD_ver_10

*** empty log message ***

/********************************************************************/
/*  AnalizadorDependencias.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: AnalizadorDependencias.c                                          */
/**                                                                           */
/** Este módulo contiene las funciones que permiten analizar dependencias     */
/** de datos entre instrucciones.                                             */
/******************************************************************************/
/** Fecha: 23 de septiembre de 2005                                           */
/******************************************************************************/

/**@file AnalizadosDependencias.c
	Este módulo contiene las funciones que permiten analizar dependencias
	de datos entre instrucciones
*/

/**@author Sergio Alvarez Moreno
*/



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

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

#include "analizadordependencias.h"


/* configuracion */
extern struct argumentos configuracion;

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

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

/* análisis de dependencias de datos */
extern int *pizarra_escrituras;
extern int **pizarra_lecturas;

extern unsigned char *vector;

extern struct punterosD matriz;



/** ver relación de ContarUbicaciones y CrearListadoUbicaciones con NormalizarUbicacion 

@brief Cuento el número de posibles ubicaciones que cumplen con lo exigido en la 
       configuración (tipos admitidos)
       
@return r como el valor de ubicaciones encontradas
*/

int ContarUbicaciones()
{
    unsigned int i;	    /* los registros de las bases de datos comienzan en el índice 0 */
	unsigned int r = 0;	/* recuento de ubicaciones */
	char listado[MAX_LISTA];
    char *elemento;           /* es un puntero a char para la función strtok */
	char tipo;

	strcpy(listado, configuracion.listaubis);

	elemento = strtok(listado, ":");    /* el separador de elementos de la lista es ':' */
    while(elemento != NULL)
    {
		tipo = atoi(elemento);
		i = 0;
		while(i<num_simbolos)
		{
			if (simbolos[i].tipo == tipo) r++;
			i++;
		}
        /* capturo el siguiente campo */
        elemento = strtok(NULL, ":");
    }
	return r;
}


/**

@brief Construyo el listado de posibles ubicaciones sobre una tabla nueva 
*/

void CrearListadoUbicaciones()
{
    unsigned int i, r;
	char mensaje[MAX_LINE];
	char listado[MAX_LISTA];
    char *elemento;           /* es un puntero a char para la función strtok */
	char tipo;

	/* doy valor a la variable global número total de ubicaciones */
	num_ubicaciones = ContarUbicaciones();

	/* creo un listado de posibles ubicaciones */
	datos = calloc(num_ubicaciones, sizeof (ubicacion));
	if (datos == NULL)
	{
		sprintf(mensaje, "Memoria insuficiente");
		Notificar(mensaje, ERROR_SALIR, ECO_NO);
		/* el programa finaliza si no hay memoria suficiente */
	}

	strcpy(listado, configuracion.listaubis);

	r = 0;
	elemento = strtok(listado, ":");    /* el separador de elementos de la lista es ':' */
    while(elemento != NULL)
    {
		tipo = atoi(elemento);
		i = 0;
		while(i<num_simbolos)
		{
			if (simbolos[i].tipo == tipo)
			{
				strcpy(datos[r].nombre, simbolos[i].simbolo); 
				r++;
			}
			i++;
		}
        /* capturo el siguiente campo */
        elemento = strtok(NULL, ":");
    }

	/* for(i=0; i<num_ubicaciones; i++) printf("%d\t%s\n", i, datos[i].nombre); */
}


/**

@brief Libera la memoria reservada para el listado de ubicaciones 
*/

void LiberarMemoriaListadoUbicaciones()
{
	free(datos);
}




 
/*@brief Busca una determinada ubicación de entre las que se dan en el listado de tipos 
       si no se encuentra devuelve el número total de posibles ubicaciones 

 BDBuscarUbicacion(char *cadena)     NO IMPLEMENTADA 

 para buscar una determinada ubicación en el listado de posibles ubicaciones 
 utilizo la función int BDBuscarCadena(int idtabla, int idcampo, char *cadena) 
 con idtabla = TABLA_UBICACIONES e idcampo = CAMPO_NOMBRE */




/** 
@brief Crear la pizarra de escrituras 
*/

void CrearPizarraEscrituras()
{
	char mensaje[MAX_LINE];

	pizarra_escrituras = calloc(num_ubicaciones, sizeof (int));
	if (pizarra_escrituras == NULL)
	{
		sprintf(mensaje, "[CrearPizarraEscrituras] Memoria insuficiente");
		Notificar(mensaje, ERROR_SALIR, ECO_NO);
		/* el programa finaliza si no hay memoria suficiente */
	}
}


/** 
@brief Iniciar la pizarra de escrituras 
*/

void IniciarPizarraEscrituras()
{
	unsigned int i;

	/* relleno con FFFF...FFF (-1) */

	for(i=0; i<num_ubicaciones; i++) pizarra_escrituras[i] = -1;

	/*for(i=0; i<num_ubicaciones; i++) printf("%6s", datos[i].nombre); printf("\n");
	for(i=0; i<num_ubicaciones; i++) printf("%6d", pizarra_escrituras[i]);*/
}


/** 
@brief Crear la pizarra de lecturas 
*/

void CrearPizarraLecturas()
{
	char mensaje[MAX_LINE];
	unsigned int i;

	/* 1º un puntero a entero por cada ubicación */
	pizarra_lecturas = calloc(num_ubicaciones, sizeof(int *));
	if (pizarra_lecturas == NULL)
	{
		sprintf(mensaje, "[CrearPizarraLecturas] Memoria insuficiente");
		Notificar(mensaje, ERROR_SALIR, ECO_NO);
		/* el programa finaliza si no hay memoria suficiente */
	}
	/* 2º un entero por cada instrucción en la ventana de instrucciones */
	for(i=0; i<num_ubicaciones; i++)
	{
		pizarra_lecturas[i] = calloc(configuracion.ventana, sizeof(int));
		if (pizarra_lecturas[i] == NULL)
		{
			sprintf(mensaje, "[CrearPizarraLecturas] Memoria insuficiente");
			Notificar(mensaje, ERROR_SALIR, ECO_NO);
			/* el programa finaliza si no hay memoria suficiente */
		}
	}
}


/** 
@brief Iniciar la pizarra de lecturas 
*/

void IniciarPizarraLecturas()
{
	unsigned int i, j;

	/* relleno con FFFF...FFF (-1) */

	for(i=0; i<num_ubicaciones; i++)
	{
		for(j=0; j<configuracion.ventana; j++) pizarra_lecturas[i][j] = -1;
	}

	/*for(i=0; i<num_ubicaciones; i++)
	{
		printf("%s\t", datos[i].nombre);
		for(j=0; j<configuracion.ventana; j++) printf("%d ", pizarra_lecturas[i][j]);
		printf("\n");
	}*/
}


/** 
@brief Crea las pizarras en las que se anotan las dependencias de datos de cada ventana 
*/

void CrearPizarras()
{
	/* las pizarras se crean de acuerdo a un listado de ubicaciones */
	CrearListadoUbicaciones();
		
	CrearPizarraEscrituras();
	CrearPizarraLecturas();
}


/** 
@brief Inicia las pizarras 
*/

void IniciarPizarras()
{
		IniciarPizarraEscrituras();
		IniciarPizarraLecturas();
}


/** 
@brief Libera la memoria reservada para las pizarras 
*/

void LiberarMemoriaPizarras()
{
	unsigned int i;
	
	/* libero el listado de ubicaciones con el que se han construido las pizarras */
	LiberarMemoriaListadoUbicaciones();

	free(pizarra_escrituras);
			
	for (i=0; i<num_ubicaciones; i++) free(pizarra_lecturas[i]);
	free(pizarra_lecturas);
}


/** 
@brief Crear el vector de dependencias 
*/

void CrearVectorDependencias()
{
	char mensaje[MAX_LINE];

	vector = calloc(configuracion.ventana, sizeof (unsigned char));
	if (vector == NULL)
	{
		sprintf(mensaje, "[CrearVectorDependencias] Memoria insuficiente");
		Notificar(mensaje, ERROR_SALIR, ECO_NO);
		/* el programa finaliza si no hay memoria suficiente */
	}
}


/** 
@brief Limpiar vector de dependencias 
*/

void IniciarVectorDependencias()
{
	unsigned int i;

	for(i=0; i<configuracion.ventana; i++) vector[i] = 0;
}


/**
@brief Liberar memoria del vector de dependencias 
*/

void LiberarMemoriaVectorDependencias()
{
	free(vector);
}



/** 
@brief Genera un vector de dependencias para un tipo de dependencia y tipo de datos 
       el resultado representa la SUMA con los valores previos del vector 
@param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion
@param	iddepen: Cadena de caracteres que indica el identificador del tipo de dependencia que se quiere generar el vector (WW, WR. RW)
@param	idfuente: Cadena de caracteres que indica el identificador del fuente del cual se quiere generar el vector (DATOSEXP,DATOSIMP,DIREXP,DIRIMP,PILAEXP,PILAIMP,CCEXP)
*/

void GenerarVector(fichainstruccion *tarjetaoperandos, char iddepen, char idfuente)
{
	char mensaje[MAX_LINE];
	char listado[MAX_LISTA];
	char *elemento;
	int indice_ubi;
	unsigned int j;

	switch(idfuente)
	{
		case DATOSEXP:		/* datos explícitos */
		if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexpldatos);
		else strcpy(listado, tarjetaoperandos->escritoexpldatos);
		break;

		case DATOSIMP:		/* datos implícitos */
		if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimpldatos);
		else strcpy(listado, tarjetaoperandos->escritoimpldatos);
		break;

		case DIREXP:		/* direcciones explícitos */
		if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexpldir);
		else strcpy(listado, tarjetaoperandos->escritoexpldir);
		break;

		case DIRIMP:		/* direcciones implícitos */
		if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimpldir);
		else strcpy(listado, tarjetaoperandos->escritoimpldir);
		break;

		case PILAEXP:		/* pila explícitos */
		if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexplpila);
		else strcpy(listado, tarjetaoperandos->escritoexplpila);
		break;

		case PILAIMP:		/* pila implícitos */
		if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimplpila);
		else strcpy(listado, tarjetaoperandos->escritoimplpila);
		break;

		case CCEXP: 		/* códigos de condición explícitos */
		if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexplestado);
		else strcpy(listado, tarjetaoperandos->escritoexplestado);
		break;

		case CCIMP: 		/* códigos de condición implícitos */
		if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimplestado);
		else strcpy(listado, tarjetaoperandos->escritoimplestado);
		break;
	}

	elemento = strtok(listado, ":");    /* el separador de elementos de la lista es ':' */
    while(elemento != NULL)
    {
		indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);

		if(indice_ubi == -1)
        {
            /* emito un error al fichero de log */ 
			sprintf(mensaje, "[GenerarVector] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
			Notificar(mensaje, ERROR_SALIR, ECO_NO);
        }

		switch(iddepen)
		{
			case RW:	/* verdadera o lectura después de escritura */
			if(pizarra_escrituras[indice_ubi] != -1)
			{
				vector[pizarra_escrituras[indice_ubi]] += 1;
				if(vector[pizarra_escrituras[indice_ubi]] == 0)
				{
					sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
					Notificar(mensaje, ERROR_SALIR, ECO_NO);
				}
			}
			break;

			case WR:	/* antidependencia o escritura después de lectura */
			/* pizarra_lecturas[i][j] -> i: ubicaciones; j: instrucciones */
			for(j=0; j<configuracion.ventana; j++)
			{
				if(pizarra_lecturas[indice_ubi][j] == 1)
				{
					vector[j] += 1;
					if(vector[j] == 0)
					{
						sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
						Notificar(mensaje, ERROR_SALIR, ECO_NO);
					}
				}
			}
			break;

			case WW:	/* salida o escritura después de escritura */
			if(pizarra_escrituras[indice_ubi] != -1)
			{
				vector[pizarra_escrituras[indice_ubi]] += 1;
				if(vector[pizarra_escrituras[indice_ubi]] == 0)
				{
					sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
					Notificar(mensaje, ERROR_SALIR, ECO_NO);
				}
			}
			break;
		}
		/* capturo el siguiente campo */
        elemento = strtok(NULL, ":");
    }
}


/** 
@brief Traslada un vector de dependencias a la matriz indicada como parámetro 
       en la posición indicada por el número de instrucción (índice) en la ventana 

@param **matriz: Matriz a la cual se le va a trasladar el vector
@param indice: Posición dentro de la matriz en la cual se va a trasladar el vector
*/

void Vector2Matriz(unsigned char **matriz, unsigned int indice)
{
	char mensaje[MAX_LINE];
	unsigned int i;

	if(matriz == NULL)
	{
		sprintf(mensaje, "[Vector2Matriz] La matriz indicada no existe");
		Notificar(mensaje, ERROR_SALIR, ECO_NO);
	}
	
	for(i=0; i<configuracion.ventana; i++) matriz[indice][i] = vector[i];
}


/**
@brief Analiza todas las posibles dependencias de datos generando su vector 
       de dependencias y almacenándolo en la matriz adecuada 

@param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion 
@param indice: posición de la matriz en la cual se va a analizar la dependencia
*/

void AnalizarDependencias(fichainstruccion *tarjetaoperandos, unsigned int indice)
{
	/* evalúo las dependencias en el siguiente orden: verdaderas, anti y salida */
	/* dentro de cada fuente: explícitas y luego implícitas */
	/* dentro de cada origen por tipos: datos, direcciones, pila y estado */
	/* si no limpio el vector de dependencias éste lleva la SUMA de los precedentes */

	/* mapa de posibles matrices */
	/* fuente	origen	tipo */
	/*   SI		  SI	 SI	 */
	/*   SI		  SI	 NO	 */
	/*   SI		  NO	 NO	 */
	/*   NO		  NO	 NO	 */


	/* VERDADERAS */
	if(configuracion.verdaderas == SI)
	{
		if(configuracion.explicitos == SI)
		{
			if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, RW, DATOSEXP);
			/* for(i=0; i<configuracion.ventana; i++) printf("%d ", vector[i]); printf("\n"); */
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Ddatoexp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, RW, DIREXP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Ddir_exp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, RW, PILAEXP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Dpilaexp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, RW, CCEXP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Destadoexp, indice);
				IniciarVectorDependencias();
			}
		}
		if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
		{
			Vector2Matriz(matriz.Ddatoexp, indice);
			IniciarVectorDependencias();
		}
		if(configuracion.implicitos == SI)
		{
			if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, RW, DATOSIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Ddatoimp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, RW, DIRIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Ddir_imp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, RW, PILAIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Dpilaimp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, RW, CCIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Destadoimp, indice);
				IniciarVectorDependencias();
			}
		}
		if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
		{
			Vector2Matriz(matriz.Ddatoimp, indice);
			IniciarVectorDependencias();
		}
	}
	if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
	{
		Vector2Matriz(matriz.Ddatoexp, indice);
		IniciarVectorDependencias();
	}


	/* ANTIDEPENDENCIAS */
	if(configuracion.antidependencias == SI)
	{
		if(configuracion.explicitos == SI)
		{
			if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WR, DATOSEXP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.ADdatoexp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WR, DIREXP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.ADdir_exp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WR, PILAEXP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.ADpilaexp, indice);
				IniciarVectorDependencias();
			}

			if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WR, CCEXP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.ADestadoexp, indice);
				IniciarVectorDependencias();
			}
		}
		if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
		{
			Vector2Matriz(matriz.ADdatoexp, indice);
			IniciarVectorDependencias();
		}
		if(configuracion.implicitos == SI)
		{
			if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WR, DATOSIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.ADdatoimp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WR, DIRIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.ADdir_imp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WR, PILAIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.ADpilaimp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WR, CCIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.ADestadoimp, indice);
				IniciarVectorDependencias();
			}
		}						
		if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
		{
			Vector2Matriz(matriz.ADdatoimp, indice);
			IniciarVectorDependencias();
		}
	}
	if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
	{
		Vector2Matriz(matriz.ADdatoexp, indice);
		IniciarVectorDependencias();
	}


	/* SALIDA */
	if(configuracion.salida == SI)
	{
		if(configuracion.explicitos == SI)
		{
			if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WW, DATOSEXP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Sdatoexp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WW, DIREXP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Sdir_exp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WW, PILAEXP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Spilaexp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WW, CCEXP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Sestadoexp, indice);
				IniciarVectorDependencias();
			}
		}
		if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
		{
			Vector2Matriz(matriz.Sdatoexp, indice);
			IniciarVectorDependencias();
		}
		if(configuracion.implicitos == SI)
		{
			if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WW, DATOSIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Sdatoimp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WW, DIRIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Sdir_imp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WW, PILAIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Spilaimp, indice);
				IniciarVectorDependencias();
			}
			if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WW, CCIMP);
			if(configuracion.desacoplartipos == SI)
			{
				Vector2Matriz(matriz.Sestadoimp, indice);
				IniciarVectorDependencias();
			}
		}						
		if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
		{
			Vector2Matriz(matriz.Sdatoimp, indice);
			IniciarVectorDependencias();
		}
	}
	if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
	{
		Vector2Matriz(matriz.Sdatoexp, indice);
		IniciarVectorDependencias();
	}

	/* si no desacoplo por ningún concepto todo va a la matriz D */
	if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == NO)
	{
		Vector2Matriz(matriz.D, indice);
		IniciarVectorDependencias();
	}
}



/**
@brief Genera la matriz D a partir de las desacopladas 
*/

void GenerarMatrizD()
{
	unsigned int i, j, dim;
	unsigned char suma;

	dim = configuracion.ventana;

	/* si no desacoplo por ningún concepto ya tengo la matriz D */
	/* en caso de que haya desacoplos debo SUMAR las matrices parciales para generar D */
	if(configuracion.desacoplartipos != NO || configuracion.desacoplarorigen != NO || configuracion.desacoplarfuentes != NO)
	{
		for(i=0; i<dim; i++)
		{
			for(j=0; j<dim; j++)
			{
				suma = 0;
				if(matriz.Ddatoexp != NULL) suma = suma + matriz.Ddatoexp[i][j];
				if(matriz.Ddir_exp != NULL) suma = suma + matriz.Ddir_exp[i][j];
				if(matriz.Dpilaexp != NULL) suma = suma + matriz.Dpilaexp[i][j];
				if(matriz.Destadoexp != NULL) suma = suma + matriz.Destadoexp[i][j];
		
				if(matriz.Ddatoimp != NULL) suma = suma + matriz.Ddatoimp[i][j];
				if(matriz.Ddir_imp != NULL) suma = suma + matriz.Ddir_imp[i][j];
				if(matriz.Dpilaimp != NULL) suma = suma + matriz.Dpilaimp[i][j];
				if(matriz.Destadoimp != NULL) suma = suma + matriz.Destadoimp[i][j];

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

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

				matriz.D[i][j] = suma;
			}
		}
	}
}


/** 
@brief Anota en la pizarra de escrituras las que realiza una instrucción 
       en una lista de ubicaciones 

@param *listado: Cadena de caracteres que indican las operaciones que hace la instruccion
@param indice: Posición dentro de la matriz que ocupa dicha operaciones con su dependencia correspondiente
*/

void AnotarListaEscrituras(char *listado, unsigned int indice)
{
	char mensaje[MAX_LINE];
	char *elemento;	
	int indice_ubi;
	
	elemento = strtok(listado, ":");    /* el separador de elementos de la lista es ':' */
    while(elemento != NULL)
    {
		indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);

	    if(indice_ubi == -1)
		{
	        /* emito un error al fichero de log */ 
			sprintf(mensaje, "[AnotarListaEscrituras] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
			Notificar(mensaje, ERROR_SALIR, ECO_NO);
		}

		pizarra_escrituras[indice_ubi] = indice;
		
		/* capturo el siguiente campo */
        elemento = strtok(NULL, ":");
    }
}

/**
@brief Anota en la pizarra de escrituras aquellas que realiza 
       la instrucción, de todos los tipos y de todos los orígenes 
       
@param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion
@param indice: Posición dentro de la matriz
*/

void AnotarEscrituras(fichainstruccion *tarjetaoperandos, unsigned int indice)
{
	char listado[MAX_LISTA];

	strcpy(listado, tarjetaoperandos->escritoexpldatos);
	AnotarListaEscrituras(listado, indice);

	strcpy(listado, tarjetaoperandos->escritoimpldatos);
	AnotarListaEscrituras(listado, indice);

	strcpy(listado, tarjetaoperandos->escritoexpldir);
	AnotarListaEscrituras(listado, indice);

	strcpy(listado, tarjetaoperandos->escritoimpldir);
	AnotarListaEscrituras(listado, indice);

	strcpy(listado, tarjetaoperandos->escritoexplpila);
	AnotarListaEscrituras(listado, indice);

	strcpy(listado, tarjetaoperandos->escritoimplpila);
	AnotarListaEscrituras(listado, indice);

	strcpy(listado, tarjetaoperandos->escritoexplestado);
	AnotarListaEscrituras(listado, indice);

	strcpy(listado, tarjetaoperandos->escritoimplestado);
	AnotarListaEscrituras(listado, indice);
}


/** 
@brief Anota en la pizarra de lecturas las que realiza una instrucción 
       en una lista de ubicaciones 
       
@param *listado: Cadena de caracteres que indican las operaciones que hace la instruccion
@param indice: Posición dentro de la matriz que ocupa dicha operaciones con su dependencia correspondiente

*/

void AnotarListaLecturas(char *listado, unsigned int indice)
{
	char mensaje[MAX_LINE];
	char *elemento;	
	int indice_ubi;
	
	elemento = strtok(listado, ":");    /* el separador de elementos de la lista es ':' */
    while(elemento != NULL)
    {
		indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);

	    if(indice_ubi == -1)
		{
	        /* emito un error al fichero de log */ 
			sprintf(mensaje, "[AnotarListaLecturas] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
			Notificar(mensaje, ERROR_SALIR, ECO_NO);
		}

		pizarra_lecturas[indice_ubi][indice] = 1;
		
		/* capturo el siguiente campo */
        elemento = strtok(NULL, ":");
    }
}

/** 
@brief Anota en la pizarra de lecturas aquellas que realiza 
       la instrucción, de todos los tipos y de todos los orígenes 

@param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion
@param indice: Posición dentro de la matriz
*/

void AnotarLecturas(fichainstruccion *tarjetaoperandos, unsigned int indice)
{
	char listado[MAX_LISTA];

	strcpy(listado, tarjetaoperandos->leidoexpldatos);
	AnotarListaLecturas(listado, indice);

	strcpy(listado, tarjetaoperandos->leidoimpldatos);
	AnotarListaLecturas(listado, indice);

	strcpy(listado, tarjetaoperandos->leidoexpldir);
	AnotarListaLecturas(listado, indice);

	strcpy(listado, tarjetaoperandos->leidoimpldir);
	AnotarListaLecturas(listado, indice);

	strcpy(listado, tarjetaoperandos->leidoexplpila);
	AnotarListaLecturas(listado, indice);

	strcpy(listado, tarjetaoperandos->leidoimplpila);
	AnotarListaLecturas(listado, indice);

	strcpy(listado, tarjetaoperandos->leidoexplestado);
	AnotarListaLecturas(listado, indice);

	strcpy(listado, tarjetaoperandos->leidoimplestado);
	AnotarListaLecturas(listado, indice);
}