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