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                                            */
/******************************************************************************/

#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 */
/* cuento el número de posibles ubicaciones que cumplen con lo exigido en la */
/* configuración (tipos admitidos) */

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;
}


/* 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); */
}


/* libera la memoria reservada para el listado de ubicaciones */

void LiberarMemoriaListadoUbicaciones()
{
    free(datos);
}



/* 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 */



/* 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 */
    }
}


/* 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]);*/
}


/* 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 */
        }
    }
}


/* 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");
    }*/
}


/* 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();
}


/* inicia las pizarras */

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


/* 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);
}


/* 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 */
    }
}


/* limpiar vector de dependencias */

void IniciarVectorDependencias()
{
    unsigned int i;

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


/* liberar memoria del vector de dependencias */

void LiberarMemoriaVectorDependencias()
{
    free(vector);
}



/* 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 */

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, ":");
    }
}


/* 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 */

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];
}


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

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 */
    /* tipo        origen    fuente */
    /*   SI          SI     SI     */
    /*   SI          SI     NO     */
    /*   SI          NO     NO     */
    /*   NO          NO     NO     */    /* -> por defecto no se desacopla nada */


    /* 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 && configuracion.datos == SI)
            {
                Vector2Matriz(matriz.Ddatoexp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, RW, DIREXP);
            if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
            {
                Vector2Matriz(matriz.Ddir_exp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, RW, PILAEXP);
            if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
            {
                Vector2Matriz(matriz.Dpilaexp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, RW, CCEXP);
            if(configuracion.desacoplartipos == SI && configuracion.cc == 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 && configuracion.datos == SI)
            {
                Vector2Matriz(matriz.Ddatoimp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, RW, DIRIMP);
            if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
            {
                Vector2Matriz(matriz.Ddir_imp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, RW, PILAIMP);
            if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
            {
                Vector2Matriz(matriz.Dpilaimp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, RW, CCIMP);
            if(configuracion.desacoplartipos == SI && configuracion.cc == 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 && configuracion.datos == SI)
            {
                Vector2Matriz(matriz.ADdatoexp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WR, DIREXP);
            if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
            {
                Vector2Matriz(matriz.ADdir_exp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WR, PILAEXP);
            if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
            {
                Vector2Matriz(matriz.ADpilaexp, indice);
                IniciarVectorDependencias();
            }

            if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WR, CCEXP);
            if(configuracion.desacoplartipos == SI && configuracion.cc == 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 && configuracion.datos == SI)
            {
                Vector2Matriz(matriz.ADdatoimp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WR, DIRIMP);
            if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
            {
                Vector2Matriz(matriz.ADdir_imp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WR, PILAIMP);
            if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
            {
                Vector2Matriz(matriz.ADpilaimp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WR, CCIMP);
            if(configuracion.desacoplartipos == SI && configuracion.cc == 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 && configuracion.datos == SI)
            {
                Vector2Matriz(matriz.Sdatoexp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WW, DIREXP);
            if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
            {
                Vector2Matriz(matriz.Sdir_exp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WW, PILAEXP);
            if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
            {
                Vector2Matriz(matriz.Spilaexp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WW, CCEXP);
            if(configuracion.desacoplartipos == SI && configuracion.cc == 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 && configuracion.datos == SI)
            {
                Vector2Matriz(matriz.Sdatoimp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WW, DIRIMP);
            if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
            {
                Vector2Matriz(matriz.Sdir_imp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WW, PILAIMP);
            if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
            {
                Vector2Matriz(matriz.Spilaimp, indice);
                IniciarVectorDependencias();
            }
            if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WW, CCIMP);
            if(configuracion.desacoplartipos == SI && configuracion.cc == 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();
    }
}



/* 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;
            }
        }
    }
}


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

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, ":");
    }
}

/* anota en la pizarra de escrituras aquellas que realiza */
/* la instrucción, de todos los tipos y de todos los orígenes */

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);
}


/* anota en la pizarra de lecturas las que realiza una instrucción */
/* en una lista de ubicaciones */

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, ":");
    }
}

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

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);
}