Annotation of ADD_ver_10/AnalizadorDependencias.c, revision 1.1
1.1 ! rico 1: /********************************************************************/
! 2: /* AnalizadorDependencias.c */
! 3: /* */
! 4: /* Copyright (c) 1997-2006 Rafael Rico (rafael.rico@uah.es) */
! 5: /* */
! 6: /* This file is part of ADD version 5.10. */
! 7: /* */
! 8: /* ADD is free software; you can redistribute it and/or modify */
! 9: /* it under the terms of the GNU General Public License as */
! 10: /* published by the Free Software Foundation; either version 2 of */
! 11: /* the License, or (at your option) any later version. */
! 12: /* */
! 13: /* ADD is distributed in the hope that it will be useful, */
! 14: /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
! 15: /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
! 16: /* GNU General Public License for more details. */
! 17: /* */
! 18: /* You should have received a copy of the GNU General Public */
! 19: /* License along with ADD; if not, write to the Free Software */
! 20: /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA */
! 21: /* 02111-1307 USA */
! 22: /* */
! 23: /* --------------------------- History --------------------------- */
! 24: /* */
! 25: /* Revision 1.2. 01/2006 */
! 26: /* Added GPL License and JavaDoc style documentation */
! 27: /* */
! 28: /* Revision 1.1. 09/2005 */
! 29: /* Initial Revision */
! 30: /* */
! 31: /********************************************************************/
! 32:
! 33: /******************************************************************************/
! 34: /** MÓDULO: AnalizadorDependencias.c */
! 35: /** */
! 36: /** Este módulo contiene las funciones que permiten analizar dependencias */
! 37: /** de datos entre instrucciones. */
! 38: /******************************************************************************/
! 39: /** Fecha: 23 de septiembre de 2005 */
! 40: /******************************************************************************/
! 41:
! 42: /**@file AnalizadosDependencias.c
! 43: Este módulo contiene las funciones que permiten analizar dependencias
! 44: de datos entre instrucciones
! 45: */
! 46:
! 47: /**@author Sergio Alvarez Moreno
! 48: */
! 49:
! 50:
! 51:
! 52: #include <stdio.h>
! 53: #include <stdlib.h>
! 54: #include <string.h>
! 55:
! 56: #include "defines.h"
! 57: #include "tipos.h"
! 58:
! 59: #include "analizadordependencias.h"
! 60:
! 61:
! 62: /* configuracion */
! 63: extern struct argumentos configuracion;
! 64:
! 65: /* bases de datos */
! 66: extern unsigned int num_simbolos;
! 67: extern operando *simbolos;
! 68:
! 69: /* posibles ubicaciones de datos */
! 70: extern unsigned int num_ubicaciones;
! 71: extern ubicacion *datos;
! 72:
! 73: /* análisis de dependencias de datos */
! 74: extern int *pizarra_escrituras;
! 75: extern int **pizarra_lecturas;
! 76:
! 77: extern unsigned char *vector;
! 78:
! 79: extern struct punterosD matriz;
! 80:
! 81:
! 82:
! 83: /** ver relación de ContarUbicaciones y CrearListadoUbicaciones con NormalizarUbicacion
! 84:
! 85: @brief Cuento el número de posibles ubicaciones que cumplen con lo exigido en la
! 86: configuración (tipos admitidos)
! 87:
! 88: @return r como el valor de ubicaciones encontradas
! 89: */
! 90:
! 91: int ContarUbicaciones()
! 92: {
! 93: unsigned int i; /* los registros de las bases de datos comienzan en el índice 0 */
! 94: unsigned int r = 0; /* recuento de ubicaciones */
! 95: char listado[MAX_LISTA];
! 96: char *elemento; /* es un puntero a char para la función strtok */
! 97: char tipo;
! 98:
! 99: strcpy(listado, configuracion.listaubis);
! 100:
! 101: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
! 102: while(elemento != NULL)
! 103: {
! 104: tipo = atoi(elemento);
! 105: i = 0;
! 106: while(i<num_simbolos)
! 107: {
! 108: if (simbolos[i].tipo == tipo) r++;
! 109: i++;
! 110: }
! 111: /* capturo el siguiente campo */
! 112: elemento = strtok(NULL, ":");
! 113: }
! 114: return r;
! 115: }
! 116:
! 117:
! 118: /**
! 119:
! 120: @brief Construyo el listado de posibles ubicaciones sobre una tabla nueva
! 121: */
! 122:
! 123: void CrearListadoUbicaciones()
! 124: {
! 125: unsigned int i, r;
! 126: char mensaje[MAX_LINE];
! 127: char listado[MAX_LISTA];
! 128: char *elemento; /* es un puntero a char para la función strtok */
! 129: char tipo;
! 130:
! 131: /* doy valor a la variable global número total de ubicaciones */
! 132: num_ubicaciones = ContarUbicaciones();
! 133:
! 134: /* creo un listado de posibles ubicaciones */
! 135: datos = calloc(num_ubicaciones, sizeof (ubicacion));
! 136: if (datos == NULL)
! 137: {
! 138: sprintf(mensaje, "Memoria insuficiente");
! 139: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 140: /* el programa finaliza si no hay memoria suficiente */
! 141: }
! 142:
! 143: strcpy(listado, configuracion.listaubis);
! 144:
! 145: r = 0;
! 146: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
! 147: while(elemento != NULL)
! 148: {
! 149: tipo = atoi(elemento);
! 150: i = 0;
! 151: while(i<num_simbolos)
! 152: {
! 153: if (simbolos[i].tipo == tipo)
! 154: {
! 155: strcpy(datos[r].nombre, simbolos[i].simbolo);
! 156: r++;
! 157: }
! 158: i++;
! 159: }
! 160: /* capturo el siguiente campo */
! 161: elemento = strtok(NULL, ":");
! 162: }
! 163:
! 164: /* for(i=0; i<num_ubicaciones; i++) printf("%d\t%s\n", i, datos[i].nombre); */
! 165: }
! 166:
! 167:
! 168: /**
! 169:
! 170: @brief Libera la memoria reservada para el listado de ubicaciones
! 171: */
! 172:
! 173: void LiberarMemoriaListadoUbicaciones()
! 174: {
! 175: free(datos);
! 176: }
! 177:
! 178:
! 179:
! 180:
! 181:
! 182: /*@brief Busca una determinada ubicación de entre las que se dan en el listado de tipos
! 183: si no se encuentra devuelve el número total de posibles ubicaciones
! 184:
! 185: BDBuscarUbicacion(char *cadena) NO IMPLEMENTADA
! 186:
! 187: para buscar una determinada ubicación en el listado de posibles ubicaciones
! 188: utilizo la función int BDBuscarCadena(int idtabla, int idcampo, char *cadena)
! 189: con idtabla = TABLA_UBICACIONES e idcampo = CAMPO_NOMBRE */
! 190:
! 191:
! 192:
! 193:
! 194: /**
! 195: @brief Crear la pizarra de escrituras
! 196: */
! 197:
! 198: void CrearPizarraEscrituras()
! 199: {
! 200: char mensaje[MAX_LINE];
! 201:
! 202: pizarra_escrituras = calloc(num_ubicaciones, sizeof (int));
! 203: if (pizarra_escrituras == NULL)
! 204: {
! 205: sprintf(mensaje, "[CrearPizarraEscrituras] Memoria insuficiente");
! 206: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 207: /* el programa finaliza si no hay memoria suficiente */
! 208: }
! 209: }
! 210:
! 211:
! 212: /**
! 213: @brief Iniciar la pizarra de escrituras
! 214: */
! 215:
! 216: void IniciarPizarraEscrituras()
! 217: {
! 218: unsigned int i;
! 219:
! 220: /* relleno con FFFF...FFF (-1) */
! 221:
! 222: for(i=0; i<num_ubicaciones; i++) pizarra_escrituras[i] = -1;
! 223:
! 224: /*for(i=0; i<num_ubicaciones; i++) printf("%6s", datos[i].nombre); printf("\n");
! 225: for(i=0; i<num_ubicaciones; i++) printf("%6d", pizarra_escrituras[i]);*/
! 226: }
! 227:
! 228:
! 229: /**
! 230: @brief Crear la pizarra de lecturas
! 231: */
! 232:
! 233: void CrearPizarraLecturas()
! 234: {
! 235: char mensaje[MAX_LINE];
! 236: unsigned int i;
! 237:
! 238: /* 1º un puntero a entero por cada ubicación */
! 239: pizarra_lecturas = calloc(num_ubicaciones, sizeof(int *));
! 240: if (pizarra_lecturas == NULL)
! 241: {
! 242: sprintf(mensaje, "[CrearPizarraLecturas] Memoria insuficiente");
! 243: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 244: /* el programa finaliza si no hay memoria suficiente */
! 245: }
! 246: /* 2º un entero por cada instrucción en la ventana de instrucciones */
! 247: for(i=0; i<num_ubicaciones; i++)
! 248: {
! 249: pizarra_lecturas[i] = calloc(configuracion.ventana, sizeof(int));
! 250: if (pizarra_lecturas[i] == NULL)
! 251: {
! 252: sprintf(mensaje, "[CrearPizarraLecturas] Memoria insuficiente");
! 253: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 254: /* el programa finaliza si no hay memoria suficiente */
! 255: }
! 256: }
! 257: }
! 258:
! 259:
! 260: /**
! 261: @brief Iniciar la pizarra de lecturas
! 262: */
! 263:
! 264: void IniciarPizarraLecturas()
! 265: {
! 266: unsigned int i, j;
! 267:
! 268: /* relleno con FFFF...FFF (-1) */
! 269:
! 270: for(i=0; i<num_ubicaciones; i++)
! 271: {
! 272: for(j=0; j<configuracion.ventana; j++) pizarra_lecturas[i][j] = -1;
! 273: }
! 274:
! 275: /*for(i=0; i<num_ubicaciones; i++)
! 276: {
! 277: printf("%s\t", datos[i].nombre);
! 278: for(j=0; j<configuracion.ventana; j++) printf("%d ", pizarra_lecturas[i][j]);
! 279: printf("\n");
! 280: }*/
! 281: }
! 282:
! 283:
! 284: /**
! 285: @brief Crea las pizarras en las que se anotan las dependencias de datos de cada ventana
! 286: */
! 287:
! 288: void CrearPizarras()
! 289: {
! 290: /* las pizarras se crean de acuerdo a un listado de ubicaciones */
! 291: CrearListadoUbicaciones();
! 292:
! 293: CrearPizarraEscrituras();
! 294: CrearPizarraLecturas();
! 295: }
! 296:
! 297:
! 298: /**
! 299: @brief Inicia las pizarras
! 300: */
! 301:
! 302: void IniciarPizarras()
! 303: {
! 304: IniciarPizarraEscrituras();
! 305: IniciarPizarraLecturas();
! 306: }
! 307:
! 308:
! 309: /**
! 310: @brief Libera la memoria reservada para las pizarras
! 311: */
! 312:
! 313: void LiberarMemoriaPizarras()
! 314: {
! 315: unsigned int i;
! 316:
! 317: /* libero el listado de ubicaciones con el que se han construido las pizarras */
! 318: LiberarMemoriaListadoUbicaciones();
! 319:
! 320: free(pizarra_escrituras);
! 321:
! 322: for (i=0; i<num_ubicaciones; i++) free(pizarra_lecturas[i]);
! 323: free(pizarra_lecturas);
! 324: }
! 325:
! 326:
! 327: /**
! 328: @brief Crear el vector de dependencias
! 329: */
! 330:
! 331: void CrearVectorDependencias()
! 332: {
! 333: char mensaje[MAX_LINE];
! 334:
! 335: vector = calloc(configuracion.ventana, sizeof (unsigned char));
! 336: if (vector == NULL)
! 337: {
! 338: sprintf(mensaje, "[CrearVectorDependencias] Memoria insuficiente");
! 339: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 340: /* el programa finaliza si no hay memoria suficiente */
! 341: }
! 342: }
! 343:
! 344:
! 345: /**
! 346: @brief Limpiar vector de dependencias
! 347: */
! 348:
! 349: void IniciarVectorDependencias()
! 350: {
! 351: unsigned int i;
! 352:
! 353: for(i=0; i<configuracion.ventana; i++) vector[i] = 0;
! 354: }
! 355:
! 356:
! 357: /**
! 358: @brief Liberar memoria del vector de dependencias
! 359: */
! 360:
! 361: void LiberarMemoriaVectorDependencias()
! 362: {
! 363: free(vector);
! 364: }
! 365:
! 366:
! 367:
! 368: /**
! 369: @brief Genera un vector de dependencias para un tipo de dependencia y tipo de datos
! 370: el resultado representa la SUMA con los valores previos del vector
! 371: @param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion
! 372: @param iddepen: Cadena de caracteres que indica el identificador del tipo de dependencia que se quiere generar el vector (WW, WR. RW)
! 373: @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)
! 374: */
! 375:
! 376: void GenerarVector(fichainstruccion *tarjetaoperandos, char iddepen, char idfuente)
! 377: {
! 378: char mensaje[MAX_LINE];
! 379: char listado[MAX_LISTA];
! 380: char *elemento;
! 381: int indice_ubi;
! 382: unsigned int j;
! 383:
! 384: switch(idfuente)
! 385: {
! 386: case DATOSEXP: /* datos explícitos */
! 387: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexpldatos);
! 388: else strcpy(listado, tarjetaoperandos->escritoexpldatos);
! 389: break;
! 390:
! 391: case DATOSIMP: /* datos implícitos */
! 392: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimpldatos);
! 393: else strcpy(listado, tarjetaoperandos->escritoimpldatos);
! 394: break;
! 395:
! 396: case DIREXP: /* direcciones explícitos */
! 397: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexpldir);
! 398: else strcpy(listado, tarjetaoperandos->escritoexpldir);
! 399: break;
! 400:
! 401: case DIRIMP: /* direcciones implícitos */
! 402: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimpldir);
! 403: else strcpy(listado, tarjetaoperandos->escritoimpldir);
! 404: break;
! 405:
! 406: case PILAEXP: /* pila explícitos */
! 407: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexplpila);
! 408: else strcpy(listado, tarjetaoperandos->escritoexplpila);
! 409: break;
! 410:
! 411: case PILAIMP: /* pila implícitos */
! 412: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimplpila);
! 413: else strcpy(listado, tarjetaoperandos->escritoimplpila);
! 414: break;
! 415:
! 416: case CCEXP: /* códigos de condición explícitos */
! 417: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexplestado);
! 418: else strcpy(listado, tarjetaoperandos->escritoexplestado);
! 419: break;
! 420:
! 421: case CCIMP: /* códigos de condición implícitos */
! 422: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimplestado);
! 423: else strcpy(listado, tarjetaoperandos->escritoimplestado);
! 424: break;
! 425: }
! 426:
! 427: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
! 428: while(elemento != NULL)
! 429: {
! 430: indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);
! 431:
! 432: if(indice_ubi == -1)
! 433: {
! 434: /* emito un error al fichero de log */
! 435: sprintf(mensaje, "[GenerarVector] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
! 436: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 437: }
! 438:
! 439: switch(iddepen)
! 440: {
! 441: case RW: /* verdadera o lectura después de escritura */
! 442: if(pizarra_escrituras[indice_ubi] != -1)
! 443: {
! 444: vector[pizarra_escrituras[indice_ubi]] += 1;
! 445: if(vector[pizarra_escrituras[indice_ubi]] == 0)
! 446: {
! 447: sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
! 448: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 449: }
! 450: }
! 451: break;
! 452:
! 453: case WR: /* antidependencia o escritura después de lectura */
! 454: /* pizarra_lecturas[i][j] -> i: ubicaciones; j: instrucciones */
! 455: for(j=0; j<configuracion.ventana; j++)
! 456: {
! 457: if(pizarra_lecturas[indice_ubi][j] == 1)
! 458: {
! 459: vector[j] += 1;
! 460: if(vector[j] == 0)
! 461: {
! 462: sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
! 463: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 464: }
! 465: }
! 466: }
! 467: break;
! 468:
! 469: case WW: /* salida o escritura después de escritura */
! 470: if(pizarra_escrituras[indice_ubi] != -1)
! 471: {
! 472: vector[pizarra_escrituras[indice_ubi]] += 1;
! 473: if(vector[pizarra_escrituras[indice_ubi]] == 0)
! 474: {
! 475: sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
! 476: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 477: }
! 478: }
! 479: break;
! 480: }
! 481: /* capturo el siguiente campo */
! 482: elemento = strtok(NULL, ":");
! 483: }
! 484: }
! 485:
! 486:
! 487: /**
! 488: @brief Traslada un vector de dependencias a la matriz indicada como parámetro
! 489: en la posición indicada por el número de instrucción (índice) en la ventana
! 490:
! 491: @param **matriz: Matriz a la cual se le va a trasladar el vector
! 492: @param indice: Posición dentro de la matriz en la cual se va a trasladar el vector
! 493: */
! 494:
! 495: void Vector2Matriz(unsigned char **matriz, unsigned int indice)
! 496: {
! 497: char mensaje[MAX_LINE];
! 498: unsigned int i;
! 499:
! 500: if(matriz == NULL)
! 501: {
! 502: sprintf(mensaje, "[Vector2Matriz] La matriz indicada no existe");
! 503: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 504: }
! 505:
! 506: for(i=0; i<configuracion.ventana; i++) matriz[indice][i] = vector[i];
! 507: }
! 508:
! 509:
! 510: /**
! 511: @brief Analiza todas las posibles dependencias de datos generando su vector
! 512: de dependencias y almacenándolo en la matriz adecuada
! 513:
! 514: @param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion
! 515: @param indice: posición de la matriz en la cual se va a analizar la dependencia
! 516: */
! 517:
! 518: void AnalizarDependencias(fichainstruccion *tarjetaoperandos, unsigned int indice)
! 519: {
! 520: /* evalúo las dependencias en el siguiente orden: verdaderas, anti y salida */
! 521: /* dentro de cada fuente: explícitas y luego implícitas */
! 522: /* dentro de cada origen por tipos: datos, direcciones, pila y estado */
! 523: /* si no limpio el vector de dependencias éste lleva la SUMA de los precedentes */
! 524:
! 525: /* mapa de posibles matrices */
! 526: /* fuente origen tipo */
! 527: /* SI SI SI */
! 528: /* SI SI NO */
! 529: /* SI NO NO */
! 530: /* NO NO NO */
! 531:
! 532:
! 533: /* VERDADERAS */
! 534: if(configuracion.verdaderas == SI)
! 535: {
! 536: if(configuracion.explicitos == SI)
! 537: {
! 538: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, RW, DATOSEXP);
! 539: /* for(i=0; i<configuracion.ventana; i++) printf("%d ", vector[i]); printf("\n"); */
! 540: if(configuracion.desacoplartipos == SI)
! 541: {
! 542: Vector2Matriz(matriz.Ddatoexp, indice);
! 543: IniciarVectorDependencias();
! 544: }
! 545: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, RW, DIREXP);
! 546: if(configuracion.desacoplartipos == SI)
! 547: {
! 548: Vector2Matriz(matriz.Ddir_exp, indice);
! 549: IniciarVectorDependencias();
! 550: }
! 551: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, RW, PILAEXP);
! 552: if(configuracion.desacoplartipos == SI)
! 553: {
! 554: Vector2Matriz(matriz.Dpilaexp, indice);
! 555: IniciarVectorDependencias();
! 556: }
! 557: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, RW, CCEXP);
! 558: if(configuracion.desacoplartipos == SI)
! 559: {
! 560: Vector2Matriz(matriz.Destadoexp, indice);
! 561: IniciarVectorDependencias();
! 562: }
! 563: }
! 564: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 565: {
! 566: Vector2Matriz(matriz.Ddatoexp, indice);
! 567: IniciarVectorDependencias();
! 568: }
! 569: if(configuracion.implicitos == SI)
! 570: {
! 571: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, RW, DATOSIMP);
! 572: if(configuracion.desacoplartipos == SI)
! 573: {
! 574: Vector2Matriz(matriz.Ddatoimp, indice);
! 575: IniciarVectorDependencias();
! 576: }
! 577: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, RW, DIRIMP);
! 578: if(configuracion.desacoplartipos == SI)
! 579: {
! 580: Vector2Matriz(matriz.Ddir_imp, indice);
! 581: IniciarVectorDependencias();
! 582: }
! 583: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, RW, PILAIMP);
! 584: if(configuracion.desacoplartipos == SI)
! 585: {
! 586: Vector2Matriz(matriz.Dpilaimp, indice);
! 587: IniciarVectorDependencias();
! 588: }
! 589: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, RW, CCIMP);
! 590: if(configuracion.desacoplartipos == SI)
! 591: {
! 592: Vector2Matriz(matriz.Destadoimp, indice);
! 593: IniciarVectorDependencias();
! 594: }
! 595: }
! 596: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 597: {
! 598: Vector2Matriz(matriz.Ddatoimp, indice);
! 599: IniciarVectorDependencias();
! 600: }
! 601: }
! 602: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
! 603: {
! 604: Vector2Matriz(matriz.Ddatoexp, indice);
! 605: IniciarVectorDependencias();
! 606: }
! 607:
! 608:
! 609: /* ANTIDEPENDENCIAS */
! 610: if(configuracion.antidependencias == SI)
! 611: {
! 612: if(configuracion.explicitos == SI)
! 613: {
! 614: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WR, DATOSEXP);
! 615: if(configuracion.desacoplartipos == SI)
! 616: {
! 617: Vector2Matriz(matriz.ADdatoexp, indice);
! 618: IniciarVectorDependencias();
! 619: }
! 620: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WR, DIREXP);
! 621: if(configuracion.desacoplartipos == SI)
! 622: {
! 623: Vector2Matriz(matriz.ADdir_exp, indice);
! 624: IniciarVectorDependencias();
! 625: }
! 626: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WR, PILAEXP);
! 627: if(configuracion.desacoplartipos == SI)
! 628: {
! 629: Vector2Matriz(matriz.ADpilaexp, indice);
! 630: IniciarVectorDependencias();
! 631: }
! 632:
! 633: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WR, CCEXP);
! 634: if(configuracion.desacoplartipos == SI)
! 635: {
! 636: Vector2Matriz(matriz.ADestadoexp, indice);
! 637: IniciarVectorDependencias();
! 638: }
! 639: }
! 640: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 641: {
! 642: Vector2Matriz(matriz.ADdatoexp, indice);
! 643: IniciarVectorDependencias();
! 644: }
! 645: if(configuracion.implicitos == SI)
! 646: {
! 647: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WR, DATOSIMP);
! 648: if(configuracion.desacoplartipos == SI)
! 649: {
! 650: Vector2Matriz(matriz.ADdatoimp, indice);
! 651: IniciarVectorDependencias();
! 652: }
! 653: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WR, DIRIMP);
! 654: if(configuracion.desacoplartipos == SI)
! 655: {
! 656: Vector2Matriz(matriz.ADdir_imp, indice);
! 657: IniciarVectorDependencias();
! 658: }
! 659: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WR, PILAIMP);
! 660: if(configuracion.desacoplartipos == SI)
! 661: {
! 662: Vector2Matriz(matriz.ADpilaimp, indice);
! 663: IniciarVectorDependencias();
! 664: }
! 665: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WR, CCIMP);
! 666: if(configuracion.desacoplartipos == SI)
! 667: {
! 668: Vector2Matriz(matriz.ADestadoimp, indice);
! 669: IniciarVectorDependencias();
! 670: }
! 671: }
! 672: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 673: {
! 674: Vector2Matriz(matriz.ADdatoimp, indice);
! 675: IniciarVectorDependencias();
! 676: }
! 677: }
! 678: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
! 679: {
! 680: Vector2Matriz(matriz.ADdatoexp, indice);
! 681: IniciarVectorDependencias();
! 682: }
! 683:
! 684:
! 685: /* SALIDA */
! 686: if(configuracion.salida == SI)
! 687: {
! 688: if(configuracion.explicitos == SI)
! 689: {
! 690: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WW, DATOSEXP);
! 691: if(configuracion.desacoplartipos == SI)
! 692: {
! 693: Vector2Matriz(matriz.Sdatoexp, indice);
! 694: IniciarVectorDependencias();
! 695: }
! 696: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WW, DIREXP);
! 697: if(configuracion.desacoplartipos == SI)
! 698: {
! 699: Vector2Matriz(matriz.Sdir_exp, indice);
! 700: IniciarVectorDependencias();
! 701: }
! 702: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WW, PILAEXP);
! 703: if(configuracion.desacoplartipos == SI)
! 704: {
! 705: Vector2Matriz(matriz.Spilaexp, indice);
! 706: IniciarVectorDependencias();
! 707: }
! 708: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WW, CCEXP);
! 709: if(configuracion.desacoplartipos == SI)
! 710: {
! 711: Vector2Matriz(matriz.Sestadoexp, indice);
! 712: IniciarVectorDependencias();
! 713: }
! 714: }
! 715: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 716: {
! 717: Vector2Matriz(matriz.Sdatoexp, indice);
! 718: IniciarVectorDependencias();
! 719: }
! 720: if(configuracion.implicitos == SI)
! 721: {
! 722: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WW, DATOSIMP);
! 723: if(configuracion.desacoplartipos == SI)
! 724: {
! 725: Vector2Matriz(matriz.Sdatoimp, indice);
! 726: IniciarVectorDependencias();
! 727: }
! 728: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WW, DIRIMP);
! 729: if(configuracion.desacoplartipos == SI)
! 730: {
! 731: Vector2Matriz(matriz.Sdir_imp, indice);
! 732: IniciarVectorDependencias();
! 733: }
! 734: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WW, PILAIMP);
! 735: if(configuracion.desacoplartipos == SI)
! 736: {
! 737: Vector2Matriz(matriz.Spilaimp, indice);
! 738: IniciarVectorDependencias();
! 739: }
! 740: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WW, CCIMP);
! 741: if(configuracion.desacoplartipos == SI)
! 742: {
! 743: Vector2Matriz(matriz.Sestadoimp, indice);
! 744: IniciarVectorDependencias();
! 745: }
! 746: }
! 747: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 748: {
! 749: Vector2Matriz(matriz.Sdatoimp, indice);
! 750: IniciarVectorDependencias();
! 751: }
! 752: }
! 753: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
! 754: {
! 755: Vector2Matriz(matriz.Sdatoexp, indice);
! 756: IniciarVectorDependencias();
! 757: }
! 758:
! 759: /* si no desacoplo por ningún concepto todo va a la matriz D */
! 760: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == NO)
! 761: {
! 762: Vector2Matriz(matriz.D, indice);
! 763: IniciarVectorDependencias();
! 764: }
! 765: }
! 766:
! 767:
! 768:
! 769: /**
! 770: @brief Genera la matriz D a partir de las desacopladas
! 771: */
! 772:
! 773: void GenerarMatrizD()
! 774: {
! 775: unsigned int i, j, dim;
! 776: unsigned char suma;
! 777:
! 778: dim = configuracion.ventana;
! 779:
! 780: /* si no desacoplo por ningún concepto ya tengo la matriz D */
! 781: /* en caso de que haya desacoplos debo SUMAR las matrices parciales para generar D */
! 782: if(configuracion.desacoplartipos != NO || configuracion.desacoplarorigen != NO || configuracion.desacoplarfuentes != NO)
! 783: {
! 784: for(i=0; i<dim; i++)
! 785: {
! 786: for(j=0; j<dim; j++)
! 787: {
! 788: suma = 0;
! 789: if(matriz.Ddatoexp != NULL) suma = suma + matriz.Ddatoexp[i][j];
! 790: if(matriz.Ddir_exp != NULL) suma = suma + matriz.Ddir_exp[i][j];
! 791: if(matriz.Dpilaexp != NULL) suma = suma + matriz.Dpilaexp[i][j];
! 792: if(matriz.Destadoexp != NULL) suma = suma + matriz.Destadoexp[i][j];
! 793:
! 794: if(matriz.Ddatoimp != NULL) suma = suma + matriz.Ddatoimp[i][j];
! 795: if(matriz.Ddir_imp != NULL) suma = suma + matriz.Ddir_imp[i][j];
! 796: if(matriz.Dpilaimp != NULL) suma = suma + matriz.Dpilaimp[i][j];
! 797: if(matriz.Destadoimp != NULL) suma = suma + matriz.Destadoimp[i][j];
! 798:
! 799: if(matriz.ADdatoexp != NULL) suma = suma + matriz.ADdatoexp[i][j];
! 800: if(matriz.ADdir_exp != NULL) suma = suma + matriz.ADdir_exp[i][j];
! 801: if(matriz.ADpilaexp != NULL) suma = suma + matriz.ADpilaexp[i][j];
! 802: if(matriz.ADestadoexp != NULL) suma = suma + matriz.ADestadoexp[i][j];
! 803:
! 804: if(matriz.ADdatoimp != NULL) suma = suma + matriz.ADdatoimp[i][j];
! 805: if(matriz.ADdir_imp != NULL) suma = suma + matriz.ADdir_imp[i][j];
! 806: if(matriz.ADpilaimp != NULL) suma = suma + matriz.ADpilaimp[i][j];
! 807: if(matriz.ADestadoimp != NULL) suma = suma + matriz.ADestadoimp[i][j];
! 808:
! 809: if(matriz.Sdatoexp != NULL) suma = suma + matriz.Sdatoexp[i][j];
! 810: if(matriz.Sdir_exp != NULL) suma = suma + matriz.Sdir_exp[i][j];
! 811: if(matriz.Spilaexp != NULL) suma = suma + matriz.Spilaexp[i][j];
! 812: if(matriz.Sestadoexp != NULL) suma = suma + matriz.Sestadoexp[i][j];
! 813:
! 814: if(matriz.Sdatoimp != NULL) suma = suma + matriz.Sdatoimp[i][j];
! 815: if(matriz.Sdir_imp != NULL) suma = suma + matriz.Sdir_imp[i][j];
! 816: if(matriz.Spilaimp != NULL) suma = suma + matriz.Spilaimp[i][j];
! 817: if(matriz.Sestadoimp != NULL) suma = suma + matriz.Sestadoimp[i][j];
! 818:
! 819: matriz.D[i][j] = suma;
! 820: }
! 821: }
! 822: }
! 823: }
! 824:
! 825:
! 826: /**
! 827: @brief Anota en la pizarra de escrituras las que realiza una instrucción
! 828: en una lista de ubicaciones
! 829:
! 830: @param *listado: Cadena de caracteres que indican las operaciones que hace la instruccion
! 831: @param indice: Posición dentro de la matriz que ocupa dicha operaciones con su dependencia correspondiente
! 832: */
! 833:
! 834: void AnotarListaEscrituras(char *listado, unsigned int indice)
! 835: {
! 836: char mensaje[MAX_LINE];
! 837: char *elemento;
! 838: int indice_ubi;
! 839:
! 840: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
! 841: while(elemento != NULL)
! 842: {
! 843: indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);
! 844:
! 845: if(indice_ubi == -1)
! 846: {
! 847: /* emito un error al fichero de log */
! 848: sprintf(mensaje, "[AnotarListaEscrituras] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
! 849: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 850: }
! 851:
! 852: pizarra_escrituras[indice_ubi] = indice;
! 853:
! 854: /* capturo el siguiente campo */
! 855: elemento = strtok(NULL, ":");
! 856: }
! 857: }
! 858:
! 859: /**
! 860: @brief Anota en la pizarra de escrituras aquellas que realiza
! 861: la instrucción, de todos los tipos y de todos los orígenes
! 862:
! 863: @param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion
! 864: @param indice: Posición dentro de la matriz
! 865: */
! 866:
! 867: void AnotarEscrituras(fichainstruccion *tarjetaoperandos, unsigned int indice)
! 868: {
! 869: char listado[MAX_LISTA];
! 870:
! 871: strcpy(listado, tarjetaoperandos->escritoexpldatos);
! 872: AnotarListaEscrituras(listado, indice);
! 873:
! 874: strcpy(listado, tarjetaoperandos->escritoimpldatos);
! 875: AnotarListaEscrituras(listado, indice);
! 876:
! 877: strcpy(listado, tarjetaoperandos->escritoexpldir);
! 878: AnotarListaEscrituras(listado, indice);
! 879:
! 880: strcpy(listado, tarjetaoperandos->escritoimpldir);
! 881: AnotarListaEscrituras(listado, indice);
! 882:
! 883: strcpy(listado, tarjetaoperandos->escritoexplpila);
! 884: AnotarListaEscrituras(listado, indice);
! 885:
! 886: strcpy(listado, tarjetaoperandos->escritoimplpila);
! 887: AnotarListaEscrituras(listado, indice);
! 888:
! 889: strcpy(listado, tarjetaoperandos->escritoexplestado);
! 890: AnotarListaEscrituras(listado, indice);
! 891:
! 892: strcpy(listado, tarjetaoperandos->escritoimplestado);
! 893: AnotarListaEscrituras(listado, indice);
! 894: }
! 895:
! 896:
! 897: /**
! 898: @brief Anota en la pizarra de lecturas las que realiza una instrucción
! 899: en una lista de ubicaciones
! 900:
! 901: @param *listado: Cadena de caracteres que indican las operaciones que hace la instruccion
! 902: @param indice: Posición dentro de la matriz que ocupa dicha operaciones con su dependencia correspondiente
! 903:
! 904: */
! 905:
! 906: void AnotarListaLecturas(char *listado, unsigned int indice)
! 907: {
! 908: char mensaje[MAX_LINE];
! 909: char *elemento;
! 910: int indice_ubi;
! 911:
! 912: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
! 913: while(elemento != NULL)
! 914: {
! 915: indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);
! 916:
! 917: if(indice_ubi == -1)
! 918: {
! 919: /* emito un error al fichero de log */
! 920: sprintf(mensaje, "[AnotarListaLecturas] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
! 921: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 922: }
! 923:
! 924: pizarra_lecturas[indice_ubi][indice] = 1;
! 925:
! 926: /* capturo el siguiente campo */
! 927: elemento = strtok(NULL, ":");
! 928: }
! 929: }
! 930:
! 931: /**
! 932: @brief Anota en la pizarra de lecturas aquellas que realiza
! 933: la instrucción, de todos los tipos y de todos los orígenes
! 934:
! 935: @param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion
! 936: @param indice: Posición dentro de la matriz
! 937: */
! 938:
! 939: void AnotarLecturas(fichainstruccion *tarjetaoperandos, unsigned int indice)
! 940: {
! 941: char listado[MAX_LISTA];
! 942:
! 943: strcpy(listado, tarjetaoperandos->leidoexpldatos);
! 944: AnotarListaLecturas(listado, indice);
! 945:
! 946: strcpy(listado, tarjetaoperandos->leidoimpldatos);
! 947: AnotarListaLecturas(listado, indice);
! 948:
! 949: strcpy(listado, tarjetaoperandos->leidoexpldir);
! 950: AnotarListaLecturas(listado, indice);
! 951:
! 952: strcpy(listado, tarjetaoperandos->leidoimpldir);
! 953: AnotarListaLecturas(listado, indice);
! 954:
! 955: strcpy(listado, tarjetaoperandos->leidoexplpila);
! 956: AnotarListaLecturas(listado, indice);
! 957:
! 958: strcpy(listado, tarjetaoperandos->leidoimplpila);
! 959: AnotarListaLecturas(listado, indice);
! 960:
! 961: strcpy(listado, tarjetaoperandos->leidoexplestado);
! 962: AnotarListaLecturas(listado, indice);
! 963:
! 964: strcpy(listado, tarjetaoperandos->leidoimplestado);
! 965: AnotarListaLecturas(listado, indice);
! 966: }
! 967:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to AnalizadorDependencias.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository ATC2] / ADD_ver_10