Annotation of ADD_ver_10/Source Code/Source Files/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: #include <stdio.h>
! 43: #include <stdlib.h>
! 44: #include <string.h>
! 45:
! 46: #include "defines.h"
! 47: #include "tipos.h"
! 48:
! 49: #include "analizadordependencias.h"
! 50:
! 51:
! 52: /* configuracion */
! 53: extern struct argumentos configuracion;
! 54:
! 55: /* bases de datos */
! 56: extern unsigned int num_simbolos;
! 57: extern operando *simbolos;
! 58:
! 59: /* posibles ubicaciones de datos */
! 60: extern unsigned int num_ubicaciones;
! 61: extern ubicacion *datos;
! 62:
! 63: /* análisis de dependencias de datos */
! 64: extern int *pizarra_escrituras;
! 65: extern int **pizarra_lecturas;
! 66:
! 67: extern unsigned char *vector;
! 68:
! 69: extern struct punterosD matriz;
! 70:
! 71:
! 72:
! 73: /* ver relación de ContarUbicaciones y CrearListadoUbicaciones con NormalizarUbicacion */
! 74: /* cuento el número de posibles ubicaciones que cumplen con lo exigido en la */
! 75: /* configuración (tipos admitidos) */
! 76:
! 77: int ContarUbicaciones()
! 78: {
! 79: unsigned int i; /* los registros de las bases de datos comienzan en el índice 0 */
! 80: unsigned int r = 0; /* recuento de ubicaciones */
! 81: char listado[MAX_LISTA];
! 82: char *elemento; /* es un puntero a char para la función strtok */
! 83: char tipo;
! 84:
! 85: strcpy(listado, configuracion.listaubis);
! 86:
! 87: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
! 88: while(elemento != NULL)
! 89: {
! 90: tipo = atoi(elemento);
! 91: i = 0;
! 92: while(i<num_simbolos)
! 93: {
! 94: if (simbolos[i].tipo == tipo) r++;
! 95: i++;
! 96: }
! 97: /* capturo el siguiente campo */
! 98: elemento = strtok(NULL, ":");
! 99: }
! 100: return r;
! 101: }
! 102:
! 103:
! 104: /* construyo el listado de posibles ubicaciones sobre una tabla nueva */
! 105:
! 106: void CrearListadoUbicaciones()
! 107: {
! 108: unsigned int i, r;
! 109: char mensaje[MAX_LINE];
! 110: char listado[MAX_LISTA];
! 111: char *elemento; /* es un puntero a char para la función strtok */
! 112: char tipo;
! 113:
! 114: /* doy valor a la variable global número total de ubicaciones */
! 115: num_ubicaciones = ContarUbicaciones();
! 116:
! 117: /* creo un listado de posibles ubicaciones */
! 118: datos = calloc(num_ubicaciones, sizeof (ubicacion));
! 119: if (datos == NULL)
! 120: {
! 121: sprintf(mensaje, "Memoria insuficiente");
! 122: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 123: /* el programa finaliza si no hay memoria suficiente */
! 124: }
! 125:
! 126: strcpy(listado, configuracion.listaubis);
! 127:
! 128: r = 0;
! 129: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
! 130: while(elemento != NULL)
! 131: {
! 132: tipo = atoi(elemento);
! 133: i = 0;
! 134: while(i<num_simbolos)
! 135: {
! 136: if (simbolos[i].tipo == tipo)
! 137: {
! 138: strcpy(datos[r].nombre, simbolos[i].simbolo);
! 139: r++;
! 140: }
! 141: i++;
! 142: }
! 143: /* capturo el siguiente campo */
! 144: elemento = strtok(NULL, ":");
! 145: }
! 146:
! 147: /* for(i=0; i<num_ubicaciones; i++) printf("%d\t%s\n", i, datos[i].nombre); */
! 148: }
! 149:
! 150:
! 151: /* libera la memoria reservada para el listado de ubicaciones */
! 152:
! 153: void LiberarMemoriaListadoUbicaciones()
! 154: {
! 155: free(datos);
! 156: }
! 157:
! 158:
! 159:
! 160: /* busca una determinada ubicación de entre las que se dan en el listado de tipos */
! 161: /* si no se encuentra devuelve el número total de posibles ubicaciones */
! 162:
! 163: /* BDBuscarUbicacion(char *cadena) NO IMPLEMENTADA */
! 164:
! 165: /* para buscar una determinada ubicación en el listado de posibles ubicaciones */
! 166: /* utilizo la función int BDBuscarCadena(int idtabla, int idcampo, char *cadena) */
! 167: /* con idtabla = TABLA_UBICACIONES e idcampo = CAMPO_NOMBRE */
! 168:
! 169:
! 170:
! 171: /* crear la pizarra de escrituras */
! 172:
! 173: void CrearPizarraEscrituras()
! 174: {
! 175: char mensaje[MAX_LINE];
! 176:
! 177: pizarra_escrituras = calloc(num_ubicaciones, sizeof (int));
! 178: if (pizarra_escrituras == NULL)
! 179: {
! 180: sprintf(mensaje, "[CrearPizarraEscrituras] Memoria insuficiente");
! 181: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 182: /* el programa finaliza si no hay memoria suficiente */
! 183: }
! 184: }
! 185:
! 186:
! 187: /* iniciar la pizarra de escrituras */
! 188:
! 189: void IniciarPizarraEscrituras()
! 190: {
! 191: unsigned int i;
! 192:
! 193: /* relleno con FFFF...FFF (-1) */
! 194:
! 195: for(i=0; i<num_ubicaciones; i++) pizarra_escrituras[i] = -1;
! 196:
! 197: /*for(i=0; i<num_ubicaciones; i++) printf("%6s", datos[i].nombre); printf("\n");
! 198: for(i=0; i<num_ubicaciones; i++) printf("%6d", pizarra_escrituras[i]);*/
! 199: }
! 200:
! 201:
! 202: /* crear la pizarra de lecturas */
! 203:
! 204: void CrearPizarraLecturas()
! 205: {
! 206: char mensaje[MAX_LINE];
! 207: unsigned int i;
! 208:
! 209: /* 1º un puntero a entero por cada ubicación */
! 210: pizarra_lecturas = calloc(num_ubicaciones, sizeof(int *));
! 211: if (pizarra_lecturas == NULL)
! 212: {
! 213: sprintf(mensaje, "[CrearPizarraLecturas] Memoria insuficiente");
! 214: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 215: /* el programa finaliza si no hay memoria suficiente */
! 216: }
! 217: /* 2º un entero por cada instrucción en la ventana de instrucciones */
! 218: for(i=0; i<num_ubicaciones; i++)
! 219: {
! 220: pizarra_lecturas[i] = calloc(configuracion.ventana, sizeof(int));
! 221: if (pizarra_lecturas[i] == NULL)
! 222: {
! 223: sprintf(mensaje, "[CrearPizarraLecturas] Memoria insuficiente");
! 224: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 225: /* el programa finaliza si no hay memoria suficiente */
! 226: }
! 227: }
! 228: }
! 229:
! 230:
! 231: /* iniciar la pizarra de lecturas */
! 232:
! 233: void IniciarPizarraLecturas()
! 234: {
! 235: unsigned int i, j;
! 236:
! 237: /* relleno con FFFF...FFF (-1) */
! 238:
! 239: for(i=0; i<num_ubicaciones; i++)
! 240: {
! 241: for(j=0; j<configuracion.ventana; j++) pizarra_lecturas[i][j] = -1;
! 242: }
! 243:
! 244: /*for(i=0; i<num_ubicaciones; i++)
! 245: {
! 246: printf("%s\t", datos[i].nombre);
! 247: for(j=0; j<configuracion.ventana; j++) printf("%d ", pizarra_lecturas[i][j]);
! 248: printf("\n");
! 249: }*/
! 250: }
! 251:
! 252:
! 253: /* crea las pizarras en las que se anotan las dependencias de datos de cada ventana */
! 254:
! 255: void CrearPizarras()
! 256: {
! 257: /* las pizarras se crean de acuerdo a un listado de ubicaciones */
! 258: CrearListadoUbicaciones();
! 259:
! 260: CrearPizarraEscrituras();
! 261: CrearPizarraLecturas();
! 262: }
! 263:
! 264:
! 265: /* inicia las pizarras */
! 266:
! 267: void IniciarPizarras()
! 268: {
! 269: IniciarPizarraEscrituras();
! 270: IniciarPizarraLecturas();
! 271: }
! 272:
! 273:
! 274: /* libera la memoria reservada para las pizarras */
! 275:
! 276: void LiberarMemoriaPizarras()
! 277: {
! 278: unsigned int i;
! 279:
! 280: /* libero el listado de ubicaciones con el que se han construido las pizarras */
! 281: LiberarMemoriaListadoUbicaciones();
! 282:
! 283: free(pizarra_escrituras);
! 284:
! 285: for (i=0; i<num_ubicaciones; i++) free(pizarra_lecturas[i]);
! 286: free(pizarra_lecturas);
! 287: }
! 288:
! 289:
! 290: /* crear el vector de dependencias */
! 291:
! 292: void CrearVectorDependencias()
! 293: {
! 294: char mensaje[MAX_LINE];
! 295:
! 296: vector = calloc(configuracion.ventana, sizeof (unsigned char));
! 297: if (vector == NULL)
! 298: {
! 299: sprintf(mensaje, "[CrearVectorDependencias] Memoria insuficiente");
! 300: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 301: /* el programa finaliza si no hay memoria suficiente */
! 302: }
! 303: }
! 304:
! 305:
! 306: /* limpiar vector de dependencias */
! 307:
! 308: void IniciarVectorDependencias()
! 309: {
! 310: unsigned int i;
! 311:
! 312: for(i=0; i<configuracion.ventana; i++) vector[i] = 0;
! 313: }
! 314:
! 315:
! 316: /* liberar memoria del vector de dependencias */
! 317:
! 318: void LiberarMemoriaVectorDependencias()
! 319: {
! 320: free(vector);
! 321: }
! 322:
! 323:
! 324:
! 325: /* genera un vector de dependencias para un tipo de dependencia y tipo de datos */
! 326: /* el resultado representa la SUMA con los valores previos del vector */
! 327:
! 328: void GenerarVector(fichainstruccion *tarjetaoperandos, char iddepen, char idfuente)
! 329: {
! 330: char mensaje[MAX_LINE];
! 331: char listado[MAX_LISTA];
! 332: char *elemento;
! 333: int indice_ubi;
! 334: unsigned int j;
! 335:
! 336: switch(idfuente)
! 337: {
! 338: case DATOSEXP: /* datos explícitos */
! 339: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexpldatos);
! 340: else strcpy(listado, tarjetaoperandos->escritoexpldatos);
! 341: break;
! 342:
! 343: case DATOSIMP: /* datos implícitos */
! 344: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimpldatos);
! 345: else strcpy(listado, tarjetaoperandos->escritoimpldatos);
! 346: break;
! 347:
! 348: case DIREXP: /* direcciones explícitos */
! 349: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexpldir);
! 350: else strcpy(listado, tarjetaoperandos->escritoexpldir);
! 351: break;
! 352:
! 353: case DIRIMP: /* direcciones implícitos */
! 354: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimpldir);
! 355: else strcpy(listado, tarjetaoperandos->escritoimpldir);
! 356: break;
! 357:
! 358: case PILAEXP: /* pila explícitos */
! 359: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexplpila);
! 360: else strcpy(listado, tarjetaoperandos->escritoexplpila);
! 361: break;
! 362:
! 363: case PILAIMP: /* pila implícitos */
! 364: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimplpila);
! 365: else strcpy(listado, tarjetaoperandos->escritoimplpila);
! 366: break;
! 367:
! 368: case CCEXP: /* códigos de condición explícitos */
! 369: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexplestado);
! 370: else strcpy(listado, tarjetaoperandos->escritoexplestado);
! 371: break;
! 372:
! 373: case CCIMP: /* códigos de condición implícitos */
! 374: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimplestado);
! 375: else strcpy(listado, tarjetaoperandos->escritoimplestado);
! 376: break;
! 377: }
! 378:
! 379: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
! 380: while(elemento != NULL)
! 381: {
! 382: indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);
! 383:
! 384: if(indice_ubi == -1)
! 385: {
! 386: /* emito un error al fichero de log */
! 387: sprintf(mensaje, "[GenerarVector] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
! 388: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 389: }
! 390:
! 391: switch(iddepen)
! 392: {
! 393: case RW: /* verdadera o lectura después de escritura */
! 394: if(pizarra_escrituras[indice_ubi] != -1)
! 395: {
! 396: vector[pizarra_escrituras[indice_ubi]] += 1;
! 397: if(vector[pizarra_escrituras[indice_ubi]] == 0)
! 398: {
! 399: sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
! 400: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 401: }
! 402: }
! 403: break;
! 404:
! 405: case WR: /* antidependencia o escritura después de lectura */
! 406: /* pizarra_lecturas[i][j] -> i: ubicaciones; j: instrucciones */
! 407: for(j=0; j<configuracion.ventana; j++)
! 408: {
! 409: if(pizarra_lecturas[indice_ubi][j] == 1)
! 410: {
! 411: vector[j] += 1;
! 412: if(vector[j] == 0)
! 413: {
! 414: sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
! 415: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 416: }
! 417: }
! 418: }
! 419: break;
! 420:
! 421: case WW: /* salida o escritura después de escritura */
! 422: if(pizarra_escrituras[indice_ubi] != -1)
! 423: {
! 424: vector[pizarra_escrituras[indice_ubi]] += 1;
! 425: if(vector[pizarra_escrituras[indice_ubi]] == 0)
! 426: {
! 427: sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
! 428: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 429: }
! 430: }
! 431: break;
! 432: }
! 433: /* capturo el siguiente campo */
! 434: elemento = strtok(NULL, ":");
! 435: }
! 436: }
! 437:
! 438:
! 439: /* traslada un vector de dependencias a la matriz indicada como parámetro */
! 440: /* en la posición indicada por el número de instrucción (índice) en la ventana */
! 441:
! 442: void Vector2Matriz(unsigned char **matriz, unsigned int indice)
! 443: {
! 444: char mensaje[MAX_LINE];
! 445: unsigned int i;
! 446:
! 447: if(matriz == NULL)
! 448: {
! 449: sprintf(mensaje, "[Vector2Matriz] La matriz indicada no existe");
! 450: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 451: }
! 452:
! 453: for(i=0; i<configuracion.ventana; i++) matriz[indice][i] = vector[i];
! 454: }
! 455:
! 456:
! 457: /* analiza todas las posibles dependencias de datos generando su vector */
! 458: /* de dependencias y almacenándolo en la matriz adecuada */
! 459:
! 460: void AnalizarDependencias(fichainstruccion *tarjetaoperandos, unsigned int indice)
! 461: {
! 462: /* evalúo las dependencias en el siguiente orden: verdaderas, anti y salida */
! 463: /* dentro de cada fuente: explícitas y luego implícitas */
! 464: /* dentro de cada origen por tipos: datos, direcciones, pila y estado */
! 465: /* si no limpio el vector de dependencias éste lleva la SUMA de los precedentes */
! 466:
! 467: /* mapa de posibles matrices */
! 468: /* tipo origen fuente */
! 469: /* SI SI SI */
! 470: /* SI SI NO */
! 471: /* SI NO NO */
! 472: /* NO NO NO */ /* -> por defecto no se desacopla nada */
! 473:
! 474:
! 475: /* VERDADERAS */
! 476: if(configuracion.verdaderas == SI)
! 477: {
! 478: if(configuracion.explicitos == SI)
! 479: {
! 480: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, RW, DATOSEXP);
! 481: /* for(i=0; i<configuracion.ventana; i++) printf("%d ", vector[i]); printf("\n"); */
! 482: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
! 483: {
! 484: Vector2Matriz(matriz.Ddatoexp, indice);
! 485: IniciarVectorDependencias();
! 486: }
! 487: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, RW, DIREXP);
! 488: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
! 489: {
! 490: Vector2Matriz(matriz.Ddir_exp, indice);
! 491: IniciarVectorDependencias();
! 492: }
! 493: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, RW, PILAEXP);
! 494: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
! 495: {
! 496: Vector2Matriz(matriz.Dpilaexp, indice);
! 497: IniciarVectorDependencias();
! 498: }
! 499: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, RW, CCEXP);
! 500: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
! 501: {
! 502: Vector2Matriz(matriz.Destadoexp, indice);
! 503: IniciarVectorDependencias();
! 504: }
! 505: }
! 506: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 507: {
! 508: Vector2Matriz(matriz.Ddatoexp, indice);
! 509: IniciarVectorDependencias();
! 510: }
! 511: if(configuracion.implicitos == SI)
! 512: {
! 513: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, RW, DATOSIMP);
! 514: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
! 515: {
! 516: Vector2Matriz(matriz.Ddatoimp, indice);
! 517: IniciarVectorDependencias();
! 518: }
! 519: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, RW, DIRIMP);
! 520: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
! 521: {
! 522: Vector2Matriz(matriz.Ddir_imp, indice);
! 523: IniciarVectorDependencias();
! 524: }
! 525: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, RW, PILAIMP);
! 526: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
! 527: {
! 528: Vector2Matriz(matriz.Dpilaimp, indice);
! 529: IniciarVectorDependencias();
! 530: }
! 531: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, RW, CCIMP);
! 532: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
! 533: {
! 534: Vector2Matriz(matriz.Destadoimp, indice);
! 535: IniciarVectorDependencias();
! 536: }
! 537: }
! 538: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 539: {
! 540: Vector2Matriz(matriz.Ddatoimp, indice);
! 541: IniciarVectorDependencias();
! 542: }
! 543: }
! 544: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
! 545: {
! 546: Vector2Matriz(matriz.Ddatoexp, indice);
! 547: IniciarVectorDependencias();
! 548: }
! 549:
! 550:
! 551: /* ANTIDEPENDENCIAS */
! 552: if(configuracion.antidependencias == SI)
! 553: {
! 554: if(configuracion.explicitos == SI)
! 555: {
! 556: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WR, DATOSEXP);
! 557: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
! 558: {
! 559: Vector2Matriz(matriz.ADdatoexp, indice);
! 560: IniciarVectorDependencias();
! 561: }
! 562: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WR, DIREXP);
! 563: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
! 564: {
! 565: Vector2Matriz(matriz.ADdir_exp, indice);
! 566: IniciarVectorDependencias();
! 567: }
! 568: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WR, PILAEXP);
! 569: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
! 570: {
! 571: Vector2Matriz(matriz.ADpilaexp, indice);
! 572: IniciarVectorDependencias();
! 573: }
! 574:
! 575: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WR, CCEXP);
! 576: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
! 577: {
! 578: Vector2Matriz(matriz.ADestadoexp, indice);
! 579: IniciarVectorDependencias();
! 580: }
! 581: }
! 582: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 583: {
! 584: Vector2Matriz(matriz.ADdatoexp, indice);
! 585: IniciarVectorDependencias();
! 586: }
! 587: if(configuracion.implicitos == SI)
! 588: {
! 589: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WR, DATOSIMP);
! 590: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
! 591: {
! 592: Vector2Matriz(matriz.ADdatoimp, indice);
! 593: IniciarVectorDependencias();
! 594: }
! 595: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WR, DIRIMP);
! 596: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
! 597: {
! 598: Vector2Matriz(matriz.ADdir_imp, indice);
! 599: IniciarVectorDependencias();
! 600: }
! 601: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WR, PILAIMP);
! 602: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
! 603: {
! 604: Vector2Matriz(matriz.ADpilaimp, indice);
! 605: IniciarVectorDependencias();
! 606: }
! 607: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WR, CCIMP);
! 608: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
! 609: {
! 610: Vector2Matriz(matriz.ADestadoimp, indice);
! 611: IniciarVectorDependencias();
! 612: }
! 613: }
! 614: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 615: {
! 616: Vector2Matriz(matriz.ADdatoimp, indice);
! 617: IniciarVectorDependencias();
! 618: }
! 619: }
! 620: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
! 621: {
! 622: Vector2Matriz(matriz.ADdatoexp, indice);
! 623: IniciarVectorDependencias();
! 624: }
! 625:
! 626:
! 627: /* SALIDA */
! 628: if(configuracion.salida == SI)
! 629: {
! 630: if(configuracion.explicitos == SI)
! 631: {
! 632: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WW, DATOSEXP);
! 633: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
! 634: {
! 635: Vector2Matriz(matriz.Sdatoexp, indice);
! 636: IniciarVectorDependencias();
! 637: }
! 638: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WW, DIREXP);
! 639: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
! 640: {
! 641: Vector2Matriz(matriz.Sdir_exp, indice);
! 642: IniciarVectorDependencias();
! 643: }
! 644: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WW, PILAEXP);
! 645: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
! 646: {
! 647: Vector2Matriz(matriz.Spilaexp, indice);
! 648: IniciarVectorDependencias();
! 649: }
! 650: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WW, CCEXP);
! 651: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
! 652: {
! 653: Vector2Matriz(matriz.Sestadoexp, indice);
! 654: IniciarVectorDependencias();
! 655: }
! 656: }
! 657: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 658: {
! 659: Vector2Matriz(matriz.Sdatoexp, indice);
! 660: IniciarVectorDependencias();
! 661: }
! 662: if(configuracion.implicitos == SI)
! 663: {
! 664: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WW, DATOSIMP);
! 665: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
! 666: {
! 667: Vector2Matriz(matriz.Sdatoimp, indice);
! 668: IniciarVectorDependencias();
! 669: }
! 670: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WW, DIRIMP);
! 671: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
! 672: {
! 673: Vector2Matriz(matriz.Sdir_imp, indice);
! 674: IniciarVectorDependencias();
! 675: }
! 676: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WW, PILAIMP);
! 677: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
! 678: {
! 679: Vector2Matriz(matriz.Spilaimp, indice);
! 680: IniciarVectorDependencias();
! 681: }
! 682: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WW, CCIMP);
! 683: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
! 684: {
! 685: Vector2Matriz(matriz.Sestadoimp, indice);
! 686: IniciarVectorDependencias();
! 687: }
! 688: }
! 689: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
! 690: {
! 691: Vector2Matriz(matriz.Sdatoimp, indice);
! 692: IniciarVectorDependencias();
! 693: }
! 694: }
! 695: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
! 696: {
! 697: Vector2Matriz(matriz.Sdatoexp, indice);
! 698: IniciarVectorDependencias();
! 699: }
! 700:
! 701: /* si no desacoplo por ningún concepto todo va a la matriz D */
! 702: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == NO)
! 703: {
! 704: Vector2Matriz(matriz.D, indice);
! 705: IniciarVectorDependencias();
! 706: }
! 707: }
! 708:
! 709:
! 710:
! 711: /* genera la matriz D a partir de las desacopladas */
! 712:
! 713: void GenerarMatrizD()
! 714: {
! 715: unsigned int i, j, dim;
! 716: unsigned char suma;
! 717:
! 718: dim = configuracion.ventana;
! 719:
! 720: /* si no desacoplo por ningún concepto ya tengo la matriz D */
! 721: /* en caso de que haya desacoplos debo SUMAR las matrices parciales para generar D */
! 722: if(configuracion.desacoplartipos != NO || configuracion.desacoplarorigen != NO || configuracion.desacoplarfuentes != NO)
! 723: {
! 724: for(i=0; i<dim; i++)
! 725: {
! 726: for(j=0; j<dim; j++)
! 727: {
! 728: suma = 0;
! 729: if(matriz.Ddatoexp != NULL) suma = suma + matriz.Ddatoexp[i][j];
! 730: if(matriz.Ddir_exp != NULL) suma = suma + matriz.Ddir_exp[i][j];
! 731: if(matriz.Dpilaexp != NULL) suma = suma + matriz.Dpilaexp[i][j];
! 732: if(matriz.Destadoexp != NULL) suma = suma + matriz.Destadoexp[i][j];
! 733:
! 734: if(matriz.Ddatoimp != NULL) suma = suma + matriz.Ddatoimp[i][j];
! 735: if(matriz.Ddir_imp != NULL) suma = suma + matriz.Ddir_imp[i][j];
! 736: if(matriz.Dpilaimp != NULL) suma = suma + matriz.Dpilaimp[i][j];
! 737: if(matriz.Destadoimp != NULL) suma = suma + matriz.Destadoimp[i][j];
! 738:
! 739: if(matriz.ADdatoexp != NULL) suma = suma + matriz.ADdatoexp[i][j];
! 740: if(matriz.ADdir_exp != NULL) suma = suma + matriz.ADdir_exp[i][j];
! 741: if(matriz.ADpilaexp != NULL) suma = suma + matriz.ADpilaexp[i][j];
! 742: if(matriz.ADestadoexp != NULL) suma = suma + matriz.ADestadoexp[i][j];
! 743:
! 744: if(matriz.ADdatoimp != NULL) suma = suma + matriz.ADdatoimp[i][j];
! 745: if(matriz.ADdir_imp != NULL) suma = suma + matriz.ADdir_imp[i][j];
! 746: if(matriz.ADpilaimp != NULL) suma = suma + matriz.ADpilaimp[i][j];
! 747: if(matriz.ADestadoimp != NULL) suma = suma + matriz.ADestadoimp[i][j];
! 748:
! 749: if(matriz.Sdatoexp != NULL) suma = suma + matriz.Sdatoexp[i][j];
! 750: if(matriz.Sdir_exp != NULL) suma = suma + matriz.Sdir_exp[i][j];
! 751: if(matriz.Spilaexp != NULL) suma = suma + matriz.Spilaexp[i][j];
! 752: if(matriz.Sestadoexp != NULL) suma = suma + matriz.Sestadoexp[i][j];
! 753:
! 754: if(matriz.Sdatoimp != NULL) suma = suma + matriz.Sdatoimp[i][j];
! 755: if(matriz.Sdir_imp != NULL) suma = suma + matriz.Sdir_imp[i][j];
! 756: if(matriz.Spilaimp != NULL) suma = suma + matriz.Spilaimp[i][j];
! 757: if(matriz.Sestadoimp != NULL) suma = suma + matriz.Sestadoimp[i][j];
! 758:
! 759: matriz.D[i][j] = suma;
! 760: }
! 761: }
! 762: }
! 763: }
! 764:
! 765:
! 766: /* anota en la pizarra de escrituras las que realiza una instrucción */
! 767: /* en una lista de ubicaciones */
! 768:
! 769: void AnotarListaEscrituras(char *listado, unsigned int indice)
! 770: {
! 771: char mensaje[MAX_LINE];
! 772: char *elemento;
! 773: int indice_ubi;
! 774:
! 775: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
! 776: while(elemento != NULL)
! 777: {
! 778: indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);
! 779:
! 780: if(indice_ubi == -1)
! 781: {
! 782: /* emito un error al fichero de log */
! 783: sprintf(mensaje, "[AnotarListaEscrituras] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
! 784: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 785: }
! 786:
! 787: pizarra_escrituras[indice_ubi] = indice;
! 788:
! 789: /* capturo el siguiente campo */
! 790: elemento = strtok(NULL, ":");
! 791: }
! 792: }
! 793:
! 794: /* anota en la pizarra de escrituras aquellas que realiza */
! 795: /* la instrucción, de todos los tipos y de todos los orígenes */
! 796:
! 797: void AnotarEscrituras(fichainstruccion *tarjetaoperandos, unsigned int indice)
! 798: {
! 799: char listado[MAX_LISTA];
! 800:
! 801: strcpy(listado, tarjetaoperandos->escritoexpldatos);
! 802: AnotarListaEscrituras(listado, indice);
! 803:
! 804: strcpy(listado, tarjetaoperandos->escritoimpldatos);
! 805: AnotarListaEscrituras(listado, indice);
! 806:
! 807: strcpy(listado, tarjetaoperandos->escritoexpldir);
! 808: AnotarListaEscrituras(listado, indice);
! 809:
! 810: strcpy(listado, tarjetaoperandos->escritoimpldir);
! 811: AnotarListaEscrituras(listado, indice);
! 812:
! 813: strcpy(listado, tarjetaoperandos->escritoexplpila);
! 814: AnotarListaEscrituras(listado, indice);
! 815:
! 816: strcpy(listado, tarjetaoperandos->escritoimplpila);
! 817: AnotarListaEscrituras(listado, indice);
! 818:
! 819: strcpy(listado, tarjetaoperandos->escritoexplestado);
! 820: AnotarListaEscrituras(listado, indice);
! 821:
! 822: strcpy(listado, tarjetaoperandos->escritoimplestado);
! 823: AnotarListaEscrituras(listado, indice);
! 824: }
! 825:
! 826:
! 827: /* anota en la pizarra de lecturas las que realiza una instrucción */
! 828: /* en una lista de ubicaciones */
! 829:
! 830: void AnotarListaLecturas(char *listado, unsigned int indice)
! 831: {
! 832: char mensaje[MAX_LINE];
! 833: char *elemento;
! 834: int indice_ubi;
! 835:
! 836: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
! 837: while(elemento != NULL)
! 838: {
! 839: indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);
! 840:
! 841: if(indice_ubi == -1)
! 842: {
! 843: /* emito un error al fichero de log */
! 844: sprintf(mensaje, "[AnotarListaLecturas] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
! 845: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 846: }
! 847:
! 848: pizarra_lecturas[indice_ubi][indice] = 1;
! 849:
! 850: /* capturo el siguiente campo */
! 851: elemento = strtok(NULL, ":");
! 852: }
! 853: }
! 854:
! 855: /* anota en la pizarra de lecturas aquellas que realiza */
! 856: /* la instrucción, de todos los tipos y de todos los orígenes */
! 857:
! 858: void AnotarLecturas(fichainstruccion *tarjetaoperandos, unsigned int indice)
! 859: {
! 860: char listado[MAX_LISTA];
! 861:
! 862: strcpy(listado, tarjetaoperandos->leidoexpldatos);
! 863: AnotarListaLecturas(listado, indice);
! 864:
! 865: strcpy(listado, tarjetaoperandos->leidoimpldatos);
! 866: AnotarListaLecturas(listado, indice);
! 867:
! 868: strcpy(listado, tarjetaoperandos->leidoexpldir);
! 869: AnotarListaLecturas(listado, indice);
! 870:
! 871: strcpy(listado, tarjetaoperandos->leidoimpldir);
! 872: AnotarListaLecturas(listado, indice);
! 873:
! 874: strcpy(listado, tarjetaoperandos->leidoexplpila);
! 875: AnotarListaLecturas(listado, indice);
! 876:
! 877: strcpy(listado, tarjetaoperandos->leidoimplpila);
! 878: AnotarListaLecturas(listado, indice);
! 879:
! 880: strcpy(listado, tarjetaoperandos->leidoexplestado);
! 881: AnotarListaLecturas(listado, indice);
! 882:
! 883: strcpy(listado, tarjetaoperandos->leidoimplestado);
! 884: AnotarListaLecturas(listado, indice);
! 885: }
! 886:
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 / Source Code / Source Files