Annotation of ADD_ver_10/Source Code/Source Files/AnalizadorDependencias.c, revision 1.2
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.2 ! rico 31: /* $Id$ */
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:
239: /* iniciar la pizarra de lecturas */
240:
241: void IniciarPizarraLecturas()
242: {
243: unsigned int i, j;
244:
245: /* relleno con FFFF...FFF (-1) */
246:
247: for(i=0; i<num_ubicaciones; i++)
248: {
249: for(j=0; j<configuracion.ventana; j++) pizarra_lecturas[i][j] = -1;
250: }
251:
252: /*for(i=0; i<num_ubicaciones; i++)
253: {
254: printf("%s\t", datos[i].nombre);
255: for(j=0; j<configuracion.ventana; j++) printf("%d ", pizarra_lecturas[i][j]);
256: printf("\n");
257: }*/
258: }
259:
260:
261: /* crea las pizarras en las que se anotan las dependencias de datos de cada ventana */
262:
263: void CrearPizarras()
264: {
265: /* las pizarras se crean de acuerdo a un listado de ubicaciones */
266: CrearListadoUbicaciones();
267:
268: CrearPizarraEscrituras();
269: CrearPizarraLecturas();
270: }
271:
272:
273: /* inicia las pizarras */
274:
275: void IniciarPizarras()
276: {
277: IniciarPizarraEscrituras();
278: IniciarPizarraLecturas();
279: }
280:
281:
282: /* libera la memoria reservada para las pizarras */
283:
284: void LiberarMemoriaPizarras()
285: {
286: unsigned int i;
287:
288: /* libero el listado de ubicaciones con el que se han construido las pizarras */
289: LiberarMemoriaListadoUbicaciones();
290:
291: free(pizarra_escrituras);
292:
293: for (i=0; i<num_ubicaciones; i++) free(pizarra_lecturas[i]);
294: free(pizarra_lecturas);
295: }
296:
297:
298: /* crear el vector de dependencias */
299:
300: void CrearVectorDependencias()
301: {
302: char mensaje[MAX_LINE];
303:
304: vector = calloc(configuracion.ventana, sizeof (unsigned char));
305: if (vector == NULL)
306: {
307: sprintf(mensaje, "[CrearVectorDependencias] Memoria insuficiente");
308: Notificar(mensaje, ERROR_SALIR, ECO_NO);
309: /* el programa finaliza si no hay memoria suficiente */
310: }
311: }
312:
313:
314: /* limpiar vector de dependencias */
315:
316: void IniciarVectorDependencias()
317: {
318: unsigned int i;
319:
320: for(i=0; i<configuracion.ventana; i++) vector[i] = 0;
321: }
322:
323:
324: /* liberar memoria del vector de dependencias */
325:
326: void LiberarMemoriaVectorDependencias()
327: {
328: free(vector);
329: }
330:
331:
332:
333: /* genera un vector de dependencias para un tipo de dependencia y tipo de datos */
334: /* el resultado representa la SUMA con los valores previos del vector */
335:
336: void GenerarVector(fichainstruccion *tarjetaoperandos, char iddepen, char idfuente)
337: {
338: char mensaje[MAX_LINE];
339: char listado[MAX_LISTA];
340: char *elemento;
341: int indice_ubi;
342: unsigned int j;
343:
344: switch(idfuente)
345: {
346: case DATOSEXP: /* datos explícitos */
347: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexpldatos);
348: else strcpy(listado, tarjetaoperandos->escritoexpldatos);
349: break;
350:
351: case DATOSIMP: /* datos implícitos */
352: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimpldatos);
353: else strcpy(listado, tarjetaoperandos->escritoimpldatos);
354: break;
355:
356: case DIREXP: /* direcciones explícitos */
357: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexpldir);
358: else strcpy(listado, tarjetaoperandos->escritoexpldir);
359: break;
360:
361: case DIRIMP: /* direcciones implícitos */
362: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimpldir);
363: else strcpy(listado, tarjetaoperandos->escritoimpldir);
364: break;
365:
366: case PILAEXP: /* pila explícitos */
367: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexplpila);
368: else strcpy(listado, tarjetaoperandos->escritoexplpila);
369: break;
370:
371: case PILAIMP: /* pila implícitos */
372: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimplpila);
373: else strcpy(listado, tarjetaoperandos->escritoimplpila);
374: break;
375:
376: case CCEXP: /* códigos de condición explícitos */
377: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoexplestado);
378: else strcpy(listado, tarjetaoperandos->escritoexplestado);
379: break;
380:
381: case CCIMP: /* códigos de condición implícitos */
382: if (iddepen == RW) strcpy(listado, tarjetaoperandos->leidoimplestado);
383: else strcpy(listado, tarjetaoperandos->escritoimplestado);
384: break;
385: }
386:
387: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
388: while(elemento != NULL)
389: {
390: indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);
391:
392: if(indice_ubi == -1)
393: {
394: /* emito un error al fichero de log */
395: sprintf(mensaje, "[GenerarVector] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
396: Notificar(mensaje, ERROR_SALIR, ECO_NO);
397: }
398:
399: switch(iddepen)
400: {
401: case RW: /* verdadera o lectura después de escritura */
402: if(pizarra_escrituras[indice_ubi] != -1)
403: {
404: vector[pizarra_escrituras[indice_ubi]] += 1;
405: if(vector[pizarra_escrituras[indice_ubi]] == 0)
406: {
407: sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
408: Notificar(mensaje, ERROR_SALIR, ECO_NO);
409: }
410: }
411: break;
412:
413: case WR: /* antidependencia o escritura después de lectura */
414: /* pizarra_lecturas[i][j] -> i: ubicaciones; j: instrucciones */
415: for(j=0; j<configuracion.ventana; j++)
416: {
417: if(pizarra_lecturas[indice_ubi][j] == 1)
418: {
419: vector[j] += 1;
420: if(vector[j] == 0)
421: {
422: sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
423: Notificar(mensaje, ERROR_SALIR, ECO_NO);
424: }
425: }
426: }
427: break;
428:
429: case WW: /* salida o escritura después de escritura */
430: if(pizarra_escrituras[indice_ubi] != -1)
431: {
432: vector[pizarra_escrituras[indice_ubi]] += 1;
433: if(vector[pizarra_escrituras[indice_ubi]] == 0)
434: {
435: sprintf(mensaje, "[GenerarVector] La componente del vector de dependencias ha excedido el valor 255");
436: Notificar(mensaje, ERROR_SALIR, ECO_NO);
437: }
438: }
439: break;
440: }
441: /* capturo el siguiente campo */
442: elemento = strtok(NULL, ":");
443: }
444: }
445:
446:
447: /* traslada un vector de dependencias a la matriz indicada como parámetro */
448: /* en la posición indicada por el número de instrucción (índice) en la ventana */
449:
450: void Vector2Matriz(unsigned char **matriz, unsigned int indice)
451: {
452: char mensaje[MAX_LINE];
453: unsigned int i;
454:
455: if(matriz == NULL)
456: {
457: sprintf(mensaje, "[Vector2Matriz] La matriz indicada no existe");
458: Notificar(mensaje, ERROR_SALIR, ECO_NO);
459: }
460:
461: for(i=0; i<configuracion.ventana; i++) matriz[indice][i] = vector[i];
462: }
463:
464:
465: /* analiza todas las posibles dependencias de datos generando su vector */
466: /* de dependencias y almacenándolo en la matriz adecuada */
467:
468: void AnalizarDependencias(fichainstruccion *tarjetaoperandos, unsigned int indice)
469: {
470: /* evalúo las dependencias en el siguiente orden: verdaderas, anti y salida */
471: /* dentro de cada fuente: explícitas y luego implícitas */
472: /* dentro de cada origen por tipos: datos, direcciones, pila y estado */
473: /* si no limpio el vector de dependencias éste lleva la SUMA de los precedentes */
474:
475: /* mapa de posibles matrices */
476: /* tipo origen fuente */
477: /* SI SI SI */
478: /* SI SI NO */
479: /* SI NO NO */
480: /* NO NO NO */ /* -> por defecto no se desacopla nada */
481:
482:
483: /* VERDADERAS */
484: if(configuracion.verdaderas == SI)
485: {
486: if(configuracion.explicitos == SI)
487: {
488: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, RW, DATOSEXP);
489: /* for(i=0; i<configuracion.ventana; i++) printf("%d ", vector[i]); printf("\n"); */
490: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
491: {
492: Vector2Matriz(matriz.Ddatoexp, indice);
493: IniciarVectorDependencias();
494: }
495: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, RW, DIREXP);
496: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
497: {
498: Vector2Matriz(matriz.Ddir_exp, indice);
499: IniciarVectorDependencias();
500: }
501: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, RW, PILAEXP);
502: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
503: {
504: Vector2Matriz(matriz.Dpilaexp, indice);
505: IniciarVectorDependencias();
506: }
507: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, RW, CCEXP);
508: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
509: {
510: Vector2Matriz(matriz.Destadoexp, indice);
511: IniciarVectorDependencias();
512: }
513: }
514: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
515: {
516: Vector2Matriz(matriz.Ddatoexp, indice);
517: IniciarVectorDependencias();
518: }
519: if(configuracion.implicitos == SI)
520: {
521: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, RW, DATOSIMP);
522: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
523: {
524: Vector2Matriz(matriz.Ddatoimp, indice);
525: IniciarVectorDependencias();
526: }
527: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, RW, DIRIMP);
528: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
529: {
530: Vector2Matriz(matriz.Ddir_imp, indice);
531: IniciarVectorDependencias();
532: }
533: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, RW, PILAIMP);
534: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
535: {
536: Vector2Matriz(matriz.Dpilaimp, indice);
537: IniciarVectorDependencias();
538: }
539: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, RW, CCIMP);
540: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
541: {
542: Vector2Matriz(matriz.Destadoimp, indice);
543: IniciarVectorDependencias();
544: }
545: }
546: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
547: {
548: Vector2Matriz(matriz.Ddatoimp, indice);
549: IniciarVectorDependencias();
550: }
551: }
552: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
553: {
554: Vector2Matriz(matriz.Ddatoexp, indice);
555: IniciarVectorDependencias();
556: }
557:
558:
559: /* ANTIDEPENDENCIAS */
560: if(configuracion.antidependencias == SI)
561: {
562: if(configuracion.explicitos == SI)
563: {
564: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WR, DATOSEXP);
565: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
566: {
567: Vector2Matriz(matriz.ADdatoexp, indice);
568: IniciarVectorDependencias();
569: }
570: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WR, DIREXP);
571: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
572: {
573: Vector2Matriz(matriz.ADdir_exp, indice);
574: IniciarVectorDependencias();
575: }
576: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WR, PILAEXP);
577: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
578: {
579: Vector2Matriz(matriz.ADpilaexp, indice);
580: IniciarVectorDependencias();
581: }
582:
583: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WR, CCEXP);
584: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
585: {
586: Vector2Matriz(matriz.ADestadoexp, indice);
587: IniciarVectorDependencias();
588: }
589: }
590: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
591: {
592: Vector2Matriz(matriz.ADdatoexp, indice);
593: IniciarVectorDependencias();
594: }
595: if(configuracion.implicitos == SI)
596: {
597: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WR, DATOSIMP);
598: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
599: {
600: Vector2Matriz(matriz.ADdatoimp, indice);
601: IniciarVectorDependencias();
602: }
603: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WR, DIRIMP);
604: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
605: {
606: Vector2Matriz(matriz.ADdir_imp, indice);
607: IniciarVectorDependencias();
608: }
609: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WR, PILAIMP);
610: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
611: {
612: Vector2Matriz(matriz.ADpilaimp, indice);
613: IniciarVectorDependencias();
614: }
615: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WR, CCIMP);
616: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
617: {
618: Vector2Matriz(matriz.ADestadoimp, indice);
619: IniciarVectorDependencias();
620: }
621: }
622: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
623: {
624: Vector2Matriz(matriz.ADdatoimp, indice);
625: IniciarVectorDependencias();
626: }
627: }
628: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
629: {
630: Vector2Matriz(matriz.ADdatoexp, indice);
631: IniciarVectorDependencias();
632: }
633:
634:
635: /* SALIDA */
636: if(configuracion.salida == SI)
637: {
638: if(configuracion.explicitos == SI)
639: {
640: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WW, DATOSEXP);
641: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
642: {
643: Vector2Matriz(matriz.Sdatoexp, indice);
644: IniciarVectorDependencias();
645: }
646: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WW, DIREXP);
647: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
648: {
649: Vector2Matriz(matriz.Sdir_exp, indice);
650: IniciarVectorDependencias();
651: }
652: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WW, PILAEXP);
653: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
654: {
655: Vector2Matriz(matriz.Spilaexp, indice);
656: IniciarVectorDependencias();
657: }
658: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WW, CCEXP);
659: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
660: {
661: Vector2Matriz(matriz.Sestadoexp, indice);
662: IniciarVectorDependencias();
663: }
664: }
665: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
666: {
667: Vector2Matriz(matriz.Sdatoexp, indice);
668: IniciarVectorDependencias();
669: }
670: if(configuracion.implicitos == SI)
671: {
672: if(configuracion.datos == SI) GenerarVector(tarjetaoperandos, WW, DATOSIMP);
673: if(configuracion.desacoplartipos == SI && configuracion.datos == SI)
674: {
675: Vector2Matriz(matriz.Sdatoimp, indice);
676: IniciarVectorDependencias();
677: }
678: if(configuracion.direcciones == SI) GenerarVector(tarjetaoperandos, WW, DIRIMP);
679: if(configuracion.desacoplartipos == SI && configuracion.direcciones == SI)
680: {
681: Vector2Matriz(matriz.Sdir_imp, indice);
682: IniciarVectorDependencias();
683: }
684: if(configuracion.pila == SI) GenerarVector(tarjetaoperandos, WW, PILAIMP);
685: if(configuracion.desacoplartipos == SI && configuracion.pila == SI)
686: {
687: Vector2Matriz(matriz.Spilaimp, indice);
688: IniciarVectorDependencias();
689: }
690: if(configuracion.cc == SI) GenerarVector(tarjetaoperandos, WW, CCIMP);
691: if(configuracion.desacoplartipos == SI && configuracion.cc == SI)
692: {
693: Vector2Matriz(matriz.Sestadoimp, indice);
694: IniciarVectorDependencias();
695: }
696: }
697: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == SI)
698: {
699: Vector2Matriz(matriz.Sdatoimp, indice);
700: IniciarVectorDependencias();
701: }
702: }
703: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == SI)
704: {
705: Vector2Matriz(matriz.Sdatoexp, indice);
706: IniciarVectorDependencias();
707: }
708:
709: /* si no desacoplo por ningún concepto todo va a la matriz D */
710: if(configuracion.desacoplartipos == NO && configuracion.desacoplarorigen == NO && configuracion.desacoplarfuentes == NO)
711: {
712: Vector2Matriz(matriz.D, indice);
713: IniciarVectorDependencias();
714: }
715: }
716:
717:
718:
719: /* genera la matriz D a partir de las desacopladas */
720:
721: void GenerarMatrizD()
722: {
723: unsigned int i, j, dim;
724: unsigned char suma;
725:
726: dim = configuracion.ventana;
727:
728: /* si no desacoplo por ningún concepto ya tengo la matriz D */
729: /* en caso de que haya desacoplos debo SUMAR las matrices parciales para generar D */
730: if(configuracion.desacoplartipos != NO || configuracion.desacoplarorigen != NO || configuracion.desacoplarfuentes != NO)
731: {
732: for(i=0; i<dim; i++)
733: {
734: for(j=0; j<dim; j++)
735: {
736: suma = 0;
737: if(matriz.Ddatoexp != NULL) suma = suma + matriz.Ddatoexp[i][j];
738: if(matriz.Ddir_exp != NULL) suma = suma + matriz.Ddir_exp[i][j];
739: if(matriz.Dpilaexp != NULL) suma = suma + matriz.Dpilaexp[i][j];
740: if(matriz.Destadoexp != NULL) suma = suma + matriz.Destadoexp[i][j];
741:
742: if(matriz.Ddatoimp != NULL) suma = suma + matriz.Ddatoimp[i][j];
743: if(matriz.Ddir_imp != NULL) suma = suma + matriz.Ddir_imp[i][j];
744: if(matriz.Dpilaimp != NULL) suma = suma + matriz.Dpilaimp[i][j];
745: if(matriz.Destadoimp != NULL) suma = suma + matriz.Destadoimp[i][j];
746:
747: if(matriz.ADdatoexp != NULL) suma = suma + matriz.ADdatoexp[i][j];
748: if(matriz.ADdir_exp != NULL) suma = suma + matriz.ADdir_exp[i][j];
749: if(matriz.ADpilaexp != NULL) suma = suma + matriz.ADpilaexp[i][j];
750: if(matriz.ADestadoexp != NULL) suma = suma + matriz.ADestadoexp[i][j];
751:
752: if(matriz.ADdatoimp != NULL) suma = suma + matriz.ADdatoimp[i][j];
753: if(matriz.ADdir_imp != NULL) suma = suma + matriz.ADdir_imp[i][j];
754: if(matriz.ADpilaimp != NULL) suma = suma + matriz.ADpilaimp[i][j];
755: if(matriz.ADestadoimp != NULL) suma = suma + matriz.ADestadoimp[i][j];
756:
757: if(matriz.Sdatoexp != NULL) suma = suma + matriz.Sdatoexp[i][j];
758: if(matriz.Sdir_exp != NULL) suma = suma + matriz.Sdir_exp[i][j];
759: if(matriz.Spilaexp != NULL) suma = suma + matriz.Spilaexp[i][j];
760: if(matriz.Sestadoexp != NULL) suma = suma + matriz.Sestadoexp[i][j];
761:
762: if(matriz.Sdatoimp != NULL) suma = suma + matriz.Sdatoimp[i][j];
763: if(matriz.Sdir_imp != NULL) suma = suma + matriz.Sdir_imp[i][j];
764: if(matriz.Spilaimp != NULL) suma = suma + matriz.Spilaimp[i][j];
765: if(matriz.Sestadoimp != NULL) suma = suma + matriz.Sestadoimp[i][j];
766:
767: matriz.D[i][j] = suma;
768: }
769: }
770: }
771: }
772:
773:
774: /* anota en la pizarra de escrituras las que realiza una instrucción */
775: /* en una lista de ubicaciones */
776:
777: void AnotarListaEscrituras(char *listado, unsigned int indice)
778: {
779: char mensaje[MAX_LINE];
780: char *elemento;
781: int indice_ubi;
782:
783: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
784: while(elemento != NULL)
785: {
786: indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);
787:
788: if(indice_ubi == -1)
789: {
790: /* emito un error al fichero de log */
791: sprintf(mensaje, "[AnotarListaEscrituras] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
792: Notificar(mensaje, ERROR_SALIR, ECO_NO);
793: }
794:
795: pizarra_escrituras[indice_ubi] = indice;
796:
797: /* capturo el siguiente campo */
798: elemento = strtok(NULL, ":");
799: }
800: }
801:
802: /* anota en la pizarra de escrituras aquellas que realiza */
803: /* la instrucción, de todos los tipos y de todos los orígenes */
804:
805: void AnotarEscrituras(fichainstruccion *tarjetaoperandos, unsigned int indice)
806: {
807: char listado[MAX_LISTA];
808:
809: strcpy(listado, tarjetaoperandos->escritoexpldatos);
810: AnotarListaEscrituras(listado, indice);
811:
812: strcpy(listado, tarjetaoperandos->escritoimpldatos);
813: AnotarListaEscrituras(listado, indice);
814:
815: strcpy(listado, tarjetaoperandos->escritoexpldir);
816: AnotarListaEscrituras(listado, indice);
817:
818: strcpy(listado, tarjetaoperandos->escritoimpldir);
819: AnotarListaEscrituras(listado, indice);
820:
821: strcpy(listado, tarjetaoperandos->escritoexplpila);
822: AnotarListaEscrituras(listado, indice);
823:
824: strcpy(listado, tarjetaoperandos->escritoimplpila);
825: AnotarListaEscrituras(listado, indice);
826:
827: strcpy(listado, tarjetaoperandos->escritoexplestado);
828: AnotarListaEscrituras(listado, indice);
829:
830: strcpy(listado, tarjetaoperandos->escritoimplestado);
831: AnotarListaEscrituras(listado, indice);
832: }
833:
834:
835: /* anota en la pizarra de lecturas las que realiza una instrucción */
836: /* en una lista de ubicaciones */
837:
838: void AnotarListaLecturas(char *listado, unsigned int indice)
839: {
840: char mensaje[MAX_LINE];
841: char *elemento;
842: int indice_ubi;
843:
844: elemento = strtok(listado, ":"); /* el separador de elementos de la lista es ':' */
845: while(elemento != NULL)
846: {
847: indice_ubi = BDBuscarCadena(TABLA_UBICACIONES, CAMPO_NOMBRE, elemento);
848:
849: if(indice_ubi == -1)
850: {
851: /* emito un error al fichero de log */
852: sprintf(mensaje, "[AnotarListaLecturas] La cadena '%s' no se ha encontrado en Tabla Ubicaciones", elemento);
853: Notificar(mensaje, ERROR_SALIR, ECO_NO);
854: }
855:
856: pizarra_lecturas[indice_ubi][indice] = 1;
857:
858: /* capturo el siguiente campo */
859: elemento = strtok(NULL, ":");
860: }
861: }
862:
863: /* anota en la pizarra de lecturas aquellas que realiza */
864: /* la instrucción, de todos los tipos y de todos los orígenes */
865:
866: void AnotarLecturas(fichainstruccion *tarjetaoperandos, unsigned int indice)
867: {
868: char listado[MAX_LISTA];
869:
870: strcpy(listado, tarjetaoperandos->leidoexpldatos);
871: AnotarListaLecturas(listado, indice);
872:
873: strcpy(listado, tarjetaoperandos->leidoimpldatos);
874: AnotarListaLecturas(listado, indice);
875:
876: strcpy(listado, tarjetaoperandos->leidoexpldir);
877: AnotarListaLecturas(listado, indice);
878:
879: strcpy(listado, tarjetaoperandos->leidoimpldir);
880: AnotarListaLecturas(listado, indice);
881:
882: strcpy(listado, tarjetaoperandos->leidoexplpila);
883: AnotarListaLecturas(listado, indice);
884:
885: strcpy(listado, tarjetaoperandos->leidoimplpila);
886: AnotarListaLecturas(listado, indice);
887:
888: strcpy(listado, tarjetaoperandos->leidoexplestado);
889: AnotarListaLecturas(listado, indice);
890:
891: strcpy(listado, tarjetaoperandos->leidoimplestado);
892: AnotarListaLecturas(listado, indice);
893: }
894:
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