Annotation of ADD_ver_10/Source Code/Source Files/Configuracion.c, revision 1.2
1.2 ! rico 1: /********************************************************************/
! 2: /* Configuracion.c */
! 3: /* */
! 4: /* */
! 5: /* Copyright (c) 1997-2006 Rafael Rico (rafael.rico@uah.es) */
! 6: /* */
! 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. */
! 28: /* */
! 29: /* -------------------------- Historia --------------------------- */
! 30: /* */
! 31: /* $Id$ */
! 32: /* */
! 33: /* Revisión 1.2. 01/2006 */
! 34: /* Se añade la licencia GPL y documentación en estilo Javadoc */
! 35: /* */
! 36: /* Revisión 1.1. 09/2005 */
! 37: /* Versión inicial */
! 38: /* */
! 39: /********************************************************************/
! 40:
1.1 rico 41: /******************************************************************************/
42: /* MÓDULO: Configuracion.c */
43: /* */
44: /* Este módulo contiene las funciones relacionadas con la configuración. */
45: /******************************************************************************/
46: /* Fecha: 28 de septiembre de 2005 */
47: /******************************************************************************/
48:
49: #include <stdio.h>
50: #include <stdlib.h>
51: #include <string.h>
52:
53: #include "defines.h"
54: #include "tipos.h"
55: #include "ayuda.h"
56: #include "configuracion.h"
57:
58: /* configuración */
59: extern struct argumentos configuracion;
60:
61:
62:
63: /* función que realiza la validación de los parámetros de configuración */
64: /* introducidos por cualquiera de los medios previstos */
65:
66: void ValidarConfiguracion()
67: {
68: char mensaje[MAX_LINE];
69:
70: /* si necesito fichero de configuración y no lo tengo */
71: /* capturo el nombre del fichero de configuración */
72: if(strcmp(configuracion.captura, "Por fichero") == 0 && strcmp(configuracion.ficheroconfig, "") == 0)
73: {
74: printf("Introduzca el nombre del fichero de configuración\n\n->\t");
75: scanf("%s", configuracion.ficheroconfig);
76:
77: sprintf(mensaje, "[ValidarConfiguracion] Se solicita fichero de configuración");
78: Notificar(mensaje, NO_ERROR, ECO_NO);
79: }
80:
81: /* si no tengo fichero de nemónicos */
82: if(strcmp(configuracion.ficheronemos, "") == 0)
83: {
84: printf("Introduzca el nombre del fichero de operaciones\n\n->\t");
85: scanf("%s", configuracion.ficheronemos);
86:
87: sprintf(mensaje, "[ValidarConfiguracion] Se solicita fichero de operaciones");
88: Notificar(mensaje, NO_ERROR, ECO_NO);
89: }
90:
91: /* si no tengo fichero de operandos */
92: if(strcmp(configuracion.ficheroubis, "") == 0)
93: {
94: printf("Introduzca el nombre del fichero de operandos\n\n->\t");
95: scanf("%s", configuracion.ficheroubis);
96:
97: sprintf(mensaje, "[ValidarConfiguracion] Se solicita fichero de operandos");
98: Notificar(mensaje, NO_ERROR, ECO_NO);
99: }
100:
101: /* si necesito el fichero de ciclos del procesador */
102: /* y no lo tengo */
103: if(configuracion.cpi == SI && strcmp(configuracion.ficherociclos, "") == 0)
104: {
105: printf("Introduzca el nombre del fichero de procesador\n\n->\t");
106: scanf("%s", configuracion.ficherociclos);
107:
108: sprintf(mensaje, "[ValidarConfiguracion] Se solicita fichero de procesador");
109: Notificar(mensaje, NO_ERROR, ECO_NO);
110: }
111:
112: /* si no tengo fichero de datos */
113: if(configuracion.origen != CADENAHEX && strcmp(configuracion.ficherodatos, "") == 0)
114: {
115: printf("Introduzca el nombre del fichero de datos\n\n->\t");
116: scanf("%s", configuracion.ficherodatos);
117:
118: sprintf(mensaje, "[ValidarConfiguracion] Se solicita fichero de datos");
119: Notificar(mensaje, NO_ERROR, ECO_NO);
120: }
121:
122: /* si el origen de datos es una única instrucción */
123: /* anulo el análisis de dependencias de datos */
124: if(configuracion.origen == CADENAHEX) configuracion.dependencias = NO;
125:
126: /* validación del rango */
127: if(configuracion.rango > 100.00) configuracion.rango = 100.00;
128: else if(configuracion.rango < 1.00) configuracion.rango = 1.00;
129:
130: /* validación del comienzo */
131: if(configuracion.comienzo > 100.00) configuracion.comienzo = 100.00;
132: /* el porcentaje de comienzo puede ser 0 */
133:
134: /* si doy instrucción final se supone que tengo una inicial */
135: if(configuracion.ultima != 0)
136: {
137: if(configuracion.primera == 0) configuracion.primera = 1;
138: /* la cuenta de instrucciones comienza en '1' */
139: }
140:
141: /* si el tamaño de ventana de instrucciones es nulo pido un valor */
142: if(configuracion.ventana == 0)
143: {
144: /* capturo el tamaño de la ventana de instrucciones */
145: printf("Introduzca el tamaño de la ventana de instrucciones[1 - %d]\n\n->\t", MAX_VENTANA);
146: scanf("%d", &configuracion.ventana);
147: }
148:
149: /* si la ventana es mayor que el máximo permitido pongo el máximo */
150: if(configuracion.ventana > MAX_VENTANA) configuracion.ventana = MAX_VENTANA;
151: /* si la ventana es de 1 instrucción anulo el análisis de dependencias de datos */
152: if(configuracion.ventana == 1) configuracion.dependencias = NO;
153: /* si la ventana es mayor de 32 instrucciones no construyo ficheros */
154: /* para volcar información de las ventanas ya que no caben */
155: if(configuracion.ventana > 32) strcpy(configuracion.volcarventana, "");
156:
157: /* si no considero ningún tipo no hago análisis de dependencias */
158: if(configuracion.verdaderas == NO &&
159: configuracion.antidependencias == NO &&
160: configuracion.verdaderas == NO) configuracion.dependencias = NO;
161:
162: if(configuracion.explicitos == NO &&
163: configuracion.implicitos == NO) configuracion.dependencias = NO;
164:
165: if(configuracion.datos == NO &&
166: configuracion.direcciones == NO &&
167: configuracion.pila == NO &&
168: configuracion.cc == NO) configuracion.dependencias = NO;
169:
170: /* los desacoplos y sus matrices llevan un orden */
171: /* mapa de posibles matrices */
172: /* tipo origen fuente */
173: /* SI SI SI */
174: /* SI SI NO */
175: /* SI NO NO */
176: /* NO NO NO */ /* -> por defecto no se desacopla nada */
177:
178: if(configuracion.desacoplarorigen == SI)
179: {
180: configuracion.desacoplartipos = SI;
181: }
182: if(configuracion.desacoplarfuentes == SI)
183: {
184: configuracion.desacoplarorigen = SI;
185: configuracion.desacoplartipos = SI;
186: }
187:
188: /* calcular CPI medio implica asignar CPI a cada instrucción */
189: if(configuracion.CPImedio == SI) configuracion.cpi = SI;
190: /* calcular tiempo de ejecución implica asignar CPI a cada */
191: /* y calcular las dependencias de datos entre instrucción */
192: if(configuracion.tiempo == SI)
193: {
194: configuracion.cpi = SI;
195: configuracion.dependencias = SI;
196: }
197: /* calculos relativos al análisis de dependencias */
198: if(configuracion.ordenparcial == SI) configuracion.dependencias = SI;
199: if(configuracion.matrizcaminos == SI) configuracion.dependencias = SI;
200: if(configuracion.pasoscomputacion == SI) configuracion.dependencias = SI;
201: if(configuracion.gradoparalelismo == SI)
202: {
203: configuracion.pasoscomputacion = SI;
204: configuracion.dependencias = SI;
205: }
206: if(configuracion.acoplamiento == SI) configuracion.dependencias = SI;
207: if(configuracion.distribucionpasos == SI)
208: {
209: configuracion.pasoscomputacion = SI;
210: configuracion.dependencias = SI;
211: }
212:
213: /* si no quiero calcular nada anulo el análisis de dependencias */
214: if(configuracion.tiempo == NO &&
215: configuracion.ordenparcial == NO &&
216: configuracion.matrizcaminos == NO &&
217: configuracion.pasoscomputacion == NO &&
218: configuracion.gradoparalelismo == NO &&
219: configuracion.acoplamiento == NO &&
220: configuracion.distribucionpasos == NO) configuracion.dependencias = NO;
221:
222: /* si he de crear un fichero de configuración nuevo */
223: /* y no tengo nombre solicito uno nuevo */
224: if(configuracion.crearficheroconfig == SI && strcmp(configuracion.nuevoficheroconfig, "") == 0)
225: {
226: printf("Introduzca el nombre del nuevo fichero de configuración\n\n->\t");
227: scanf("%s", configuracion.nuevoficheroconfig);
228:
229: sprintf(mensaje, "[ValidarConfiguracion] Se solicita nuevo fichero de configuración");
230: Notificar(mensaje, NO_ERROR, ECO_NO);
231: }
232: }
233:
234:
235:
236: /* función que carga la configuración por defecto de la aplicación */
237:
238: void CargarConfiguracionInicial()
239: {
240: /* OBSERVACIONES (tipo de captura de configuración) */
241: strcpy(configuracion.captura, "Por defecto");
242:
243: /* FICHERO DE CONFIGURACIÓN POR DEFECTO */
244: /* ruta del fichero de configuración (si se usa sin indicar ruta) */
245: strcpy(configuracion.ficheroconfig, "configuracion.cfg");
246:
247: /* FICHEROS DE BASE DE DATOS */
248: /* ARQUITECTURA: fichero de operaciones */
249: strcpy(configuracion.ficheronemos, "IA16-nemos.isa");
250: /* ARQUITECTURA: fichero de símbolos */
251: strcpy(configuracion.ficheroubis, "IA16-ubis.isa");
252: /* PROCESADOR: fichero de ciclos */
253: strcpy(configuracion.ficherociclos, "uP-8086-01.pro");
254:
255: /* ORIGEN DE DATOS */
256: /* código de origen de datos */
257: /* 0: TRAZA; 1: SECUENCIA; 2: CADENAHEX */
258: /* si es CADENAHEX no se hace análisis de dependencias) */
259: configuracion.origen = TRAZA;
260: /* fichero de origen de datos -si existe- */
261: strcpy(configuracion.ficherodatos, "comp.trz");
262: /* instrucción en hexadecimal */
263: strcpy(configuracion.cadenahex, "");
264: /* porcentaje a analizar -sólo TRAZA- */
265: configuracion.rango = 100.00;
266: /* comienzo en porcentaje -sólo TRAZA- */
267: configuracion.comienzo = 0.00;
268: /* instrucción de comienzo */
269: configuracion.primera = 0;
270: /* instrucción de final */
271: configuracion.ultima = 0;
272:
273: /* EVALUAR */
274: /* ¿hacer recuentos? */
275: configuracion.recuentos = NO;
276: /* ¿asignar ciclos a cada instrucción? */
277: configuracion.cpi = NO;
278: /* ¿hacer análisis de dependencias de datos? */
279: configuracion.dependencias = SI;
280:
281: /* PARÁMETROS DE ANÁLISIS DE DEPENDENCIAS DE DATOS */
282: /* tamaño de la ventana de instrucciones (si es 1 no se hace análisis de dependencias) */
283: configuracion.ventana = 32;
284: /* tipos de ubicaciones a incluir en la pizarra de dependencias */
285: strcpy(configuracion.listaubis, "0:1:2:3");
286: /* ¿desacoplar tipos de dependencias? */
287: configuracion.desacoplartipos = NO;
288: /* ¿considerar dependencias verdaderas? */
289: configuracion.verdaderas = SI;
290: /* ¿considerar antidependencias? */
291: configuracion.antidependencias = SI;
292: /* ¿considerar dependencias de salida? */
293: configuracion.salida = SI;
294: /* ¿desacoplar implìcitas-explícitas? */
295: configuracion.desacoplarorigen = NO;
296: /* ¿considerar explícitas? */
297: configuracion.explicitos = SI;
298: /* ¿considerar implícitas? */
299: configuracion.implicitos = SI;
300: /* ¿desacoplar fuentes de dependencias? */
301: configuracion.desacoplarfuentes = NO;
302: /* ¿origen de dependencias de datos? */
303: configuracion.datos = SI;
304: /* ¿origen de dependencias de direcciones? */
305: configuracion.direcciones = SI;
306: /* ¿origen de dependencias de pila? */
307: configuracion.pila = SI;
308: /* ¿origen de dependencias de códigos de condición? */
309: configuracion.cc = SI;
310:
311: /* CALCULAR */
312: /* ¿calcular CPI medio? (requiere asignación de CPI) */
313: configuracion.CPImedio = NO;
314: /* ¿calcular tiempo de ejecución? (requiere asignación de CPI) */
315: configuracion.tiempo = NO;
316: /* ¿obtener orden parcial? (requiere evaluación de dependencias) */
317: configuracion.ordenparcial = NO;
318: /* ¿calcular la matriz de caminos? (requiere evaluación de dependencias) */
319: /*(tarea gran consumidora de tiempo) */
320: configuracion.matrizcaminos = NO;
321: /* ¿determinar pasos de computación? (requiere evaluación de dependencias) */
322: configuracion.pasoscomputacion = SI;
323: /* ¿determinar grado de paralelismo? (requiere evaluación de dependencias y pasos de computación) */
324: configuracion.gradoparalelismo = NO;
325: /* ¿determinar acoplamiento? (requiere evaluación de dependencias) */
326: configuracion.acoplamiento = NO;
327: /* ¿salvar el histograma de pasos de computación para la matriz D? */
328: configuracion.distribucionpasos = NO;
329:
330: /* CONFIGURACIÓN DEL INFORME */
331: /* salvar bases de datos en ficheros EXCEL */
332: configuracion.volcarBD = NO;
333: /* volcar configuracion en un fichero nuevo */
334: configuracion.crearficheroconfig = NO;
335: /* nombre del nuevo fichero de configuración */
336: strcpy(configuracion.nuevoficheroconfig, "nuevoconfig");
337: /* salvar listado de ventanas en formato EXCEL */
338: strcpy(configuracion.volcarventana, "");
339: /* fichero de resultados en formato EXCEL */
340: strcpy(configuracion.ficheroresultados, "resultados");
341: /* nivel de gravedad de los mensajes volcados en el log */
342: configuracion.nivelnotificaciones = ALL;
343: /* (el nivel inicial es el de mayor notificación) */
344:
345: /* INTERFASE GRÁFICA */
346: /* ver instrucción en pantalla */
347: configuracion.verinstruccion = NO;
348: /* ver ventana en pantalla */
349: configuracion.verventana = NO;
350:
351: ValidarConfiguracion();
352: }
353:
354:
355: /* función que carga la configuración desde un fichero */
356: /* el fichero de configuración no tiene que tener todas las claves */
357:
358: void CargarConfiguracionFichero()
359: {
360: FILE *handle;
361: char fichero[MAX_LINE];
362: char linea[MAX_LINE];
363: char mensaje[MAX_LINE];
364: char *campo;
365: int i;
366: char encontrado;
367: char *inicio, *final;
368:
369: /* nombre del fichero de configuración */
370: strcpy(fichero, configuracion.ficheroconfig);
371:
372: /* abro el fichero de configuración*/
373: if((handle = fopen(fichero, "r")) != NULL)
374: {
375: sprintf(mensaje, "[CargarConfiguracionFichero] El fichero '%s' se ha abierto con éxito", fichero);
376: Notificar(mensaje, NO_ERROR, ECO_NO);
377:
378: while(!feof(handle))
379: {
380: fgets (linea, MAX_LINE, handle);
381: /* quito el caracter '\n' (0x0a) final de la línea */
382: /* OJO: si abro en modo binario me encuentro "\r\n" (0x0d 0x0a) */
383: *(linea+strlen(linea)-1)='\0';
384: /* si no es ni comentario ni línea en blanco */
385: if(linea[0]!='[' && linea[0]!='\0')
386: {
387: campo = strtok(linea, "=");
388: /* limpio de espacios en blanco por delante y por detrás */
389: inicio = campo; while(*inicio++==' '); campo = inicio - 1;
390: final = campo + strlen(campo); while(*--final==' '); *(final+1)='\0';
391:
392: i = 0;
393: encontrado = NO;
394: while(i<NUM_CLAVES && encontrado == NO)
395: {
396: /* solución si 'campo' tiene espacios en blanco */
397: /* if (strncmp(campo, claves[i], strlen(claves[i]))) i++; */
398: /* solución si 'campo' no tiene espacios en blanco */
399: if (strcmp(campo, claves[i])) i++; /* no encontrado */
400: else encontrado = SI; /* encontrado */
401: }
402: if(encontrado == NO)
403: {
404: sprintf(mensaje, "No se ha encontrado la clave del fichero de configuración");
405: Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
406: }
407: else
408: {
409: campo = strtok(NULL, "=");
410: /* limpio de espacios en blanco por delante y por detrás */
411: inicio = campo; while(*inicio++==' '); campo = inicio - 1;
412: final = campo + strlen(campo); while(*--final==' '); *(final+1)='\0';
413: /* limpio las comillas simples si están */
414: inicio = strchr(campo, '\'');
415: if(inicio!=NULL) {campo = inicio + 1; final = strrchr(campo, '\''); if(final!=NULL) *final = '\0';}
416:
417: switch(i)
418: {
419: case 0: /* CAPTURA DE CONFIGURACIÓN */
420: strcpy(configuracion.captura, campo);
421: break;
422:
423: case 1: /* FICHERO DE CONFIGURACIÓN */
424: strcpy(configuracion.ficheroconfig, campo);
425: break;
426:
427: case 2: /* FICHERO DE OPERACIONES */
428: strcpy(configuracion.ficheronemos, campo);
429: break;
430:
431: case 3: /* FICHERO DE SÍMBOLOS */
432: strcpy(configuracion.ficheroubis, campo);
433: break;
434:
435: case 4: /* FICHERO DE CICLOS */
436: strcpy(configuracion.ficherociclos, campo);
437: break;
438:
439: case 5: /* ORIGEN DE DATOS */
440: /* if(strcmp(campo, "TRAZA")==0) */
441: /* opción por defecto */
442: configuracion.origen = TRAZA;
443: if(strcmp(campo, "SECUENCIA")==0) configuracion.origen = SECUENCIA;
444: else if(strcmp(campo, "CADENAHEX")==0) configuracion.origen = CADENAHEX;
445: break;
446:
447: case 6: /* FICHERO DE DATOS */
448: strcpy(configuracion.ficherodatos, campo);
449: break;
450:
451: case 7: /* SECUENCIA DE INSTRUCCIÓN */
452: strcpy(configuracion.cadenahex, campo);
453: break;
454:
455: case 8: /* RANGO */
456: /* quito el signo '%' si está */
457: *(campo+strlen(campo)-1)='\0';
458: configuracion.rango = atof(campo);
459: break;
460:
461: case 9: /* COMIENZO */
462: /* quito el signo '%' si está */
463: *(campo+strlen(campo)-1)='\0';
464: configuracion.comienzo = atof(campo);
465: break;
466:
467: case 10: /* PRIMERA */
468: configuracion.primera = atoi(campo);
469: break;
470:
471: case 11: /* ULTIMA */
472: configuracion.ultima = atoi(campo);
473: break;
474:
475: case 12: /* RECUENTOS */
476: configuracion.recuentos = SI;
477: if(strcmp(campo, "NO")==0) configuracion.recuentos = NO;
478: break;
479:
480: case 13: /* ASIGNAR CPI */
481: configuracion.cpi = SI;
482: if(strcmp(campo, "NO")==0) configuracion.cpi = NO;
483: break;
484:
485: case 14: /* ANALIZAR DEPENDENCIAS */
486: configuracion.dependencias = SI;
487: if(strcmp(campo, "NO")==0) configuracion.dependencias = NO;
488: break;
489:
490: case 15: /* TAMAÑO VENTANA INSTRUCCIONES */
491: configuracion.ventana = atoi(campo);
492: break;
493:
494: case 16: /* LISTADO DE UBICACIONES */
495: strcpy(configuracion.listaubis, campo);
496: break;
497:
498: case 17: /* DESACOPLAR TIPOS DE DEPENDENCIAS */
499: configuracion.desacoplartipos = SI;
500: if(strcmp(campo, "NO")==0) configuracion.desacoplartipos = NO;
501: break;
502:
503: case 18: /* DEPENDENCIAS VERDADERAS */
504: configuracion.verdaderas = SI;
505: if(strcmp(campo, "NO")==0) configuracion.verdaderas = NO;
506: break;
507:
508: case 19: /* ANTIDEPENDENCIAS */
509: configuracion.antidependencias = SI;
510: if(strcmp(campo, "NO")==0) configuracion.antidependencias = NO;
511: break;
512:
513: case 20: /* DEPENDENCIAS DE SALIDA */
514: configuracion.salida = SI;
515: if(strcmp(campo, "NO")==0) configuracion.salida = NO;
516: break;
517:
518: case 21: /* DESACOPLAR ORIGEN */
519: configuracion.desacoplarorigen = SI;
520: if(strcmp(campo, "NO")==0) configuracion.desacoplarorigen = NO;
521: break;
522:
523: case 22: /* OPERANDOS EXPLÍCITOS */
524: configuracion.explicitos = SI;
525: if(strcmp(campo, "NO")==0) configuracion.explicitos = NO;
526: break;
527:
528: case 23: /* OPERANDOS IMPLÍCITOS */
529: configuracion.implicitos = SI;
530: if(strcmp(campo, "NO")==0) configuracion.implicitos = NO;
531: break;
532:
533: case 24: /* DESACOPLAR FUENTES DE DEPENDENCIAS */
534: configuracion.desacoplarfuentes = SI;
535: if(strcmp(campo, "NO")==0) configuracion.desacoplarfuentes = NO;
536: break;
537:
538: case 25: /* DEPENDENCIAS DE DATOS */
539: configuracion.datos = SI;
540: if(strcmp(campo, "NO")==0) configuracion.datos = NO;
541: break;
542:
543: case 26: /* DEPENDENCIAS DE DIRECCIONES */
544: configuracion.direcciones = SI;
545: if(strcmp(campo, "NO")==0) configuracion.direcciones = NO;
546: break;
547:
548: case 27: /* DEPENDENCIAS DE PILA */
549: configuracion.pila = SI;
550: if(strcmp(campo, "NO")==0) configuracion.pila = NO;
551: break;
552:
553: case 28: /* DEPENDENCIAS DE CÓDIGOS DE CONDICIÓN */
554: configuracion.cc = SI;
555: if(strcmp(campo, "NO")==0) configuracion.cc = NO;
556: break;
557:
558: case 29: /* CALCULAR CPI PROMEDIO */
559: configuracion.CPImedio = SI;
560: if(strcmp(campo, "NO")==0) configuracion.CPImedio = NO;
561: break;
562:
563: case 30: /* TIEMPO DE EJECUCIÓN */
564: configuracion.tiempo = SI;
565: if(strcmp(campo, "NO")==0) configuracion.tiempo = NO;
566: break;
567:
568: case 31: /* GENERAR LISTADO ORDEN PARCIAL */
569: configuracion.ordenparcial = SI;
570: if(strcmp(campo, "NO")==0) configuracion.ordenparcial = NO;
571: break;
572:
573: case 32: /* GENERAR MATRIZ DE CAMINOS */
574: configuracion.matrizcaminos = SI;
575: if(strcmp(campo, "NO")==0) configuracion.matrizcaminos = NO;
576: break;
577:
578: case 33: /* PASOS DE COMPUTACIÓN */
579: configuracion.pasoscomputacion = SI;
580: if(strcmp(campo, "NO")==0) configuracion.pasoscomputacion = NO;
581: break;
582:
583: case 34: /* GRADO DE PARALELISMO */
584: configuracion.gradoparalelismo = SI;
585: if(strcmp(campo, "NO")==0) configuracion.gradoparalelismo = NO;
586: break;
587:
588: case 35: /* ACOPLAMIENTO */
589: configuracion.acoplamiento = SI;
590: if(strcmp(campo, "NO")==0) configuracion.acoplamiento = NO;
591: break;
592:
593: case 36: /* HISTOGRAMA PASOS DE COMPUTACIÓN */
594: configuracion.distribucionpasos = SI;
595: if(strcmp(campo, "NO")==0) configuracion.distribucionpasos = NO;
596: break;
597:
598: case 37: /* VOLCAR BD EN FICHEROS */
599: configuracion.volcarBD = SI;
600: if(strcmp(campo, "NO")==0) configuracion.volcarBD = NO;
601: break;
602:
603: case 38: /* CREAR FICHERO DE CONFIGURACIÓN */
604: configuracion.crearficheroconfig = SI;
605: if(strcmp(campo, "NO")==0) configuracion.crearficheroconfig = NO;
606: break;
607:
608: case 39: /* NOMBRE DEL NUEVO FICHERO DE CONFIGURACIÓN */
609: strcpy(configuracion.nuevoficheroconfig, campo);
610: break;
611:
612: case 40: /* LISTADO DE VENTANAS A SALVAR */
613: strcpy(configuracion.volcarventana, campo);
614: break;
615:
616: case 41: /* FICHERO DE RESULTADOS */
617: strcpy(configuracion.ficheroresultados, campo);
618: break;
619:
620: case 42: /* NIVEL DE NOTIFICACIÓN EN EL LOG */
621: /* opción por defecto */
622: configuracion.nivelnotificaciones = ALL;
623: if(strcmp(campo, "EX_CFG")==0) configuracion.nivelnotificaciones = EX_CFG;
624: else if(strcmp(campo, "ERRORS")==0) configuracion.nivelnotificaciones = ERRORS;
625: break;
626:
627: case 43: /* VER INSTRUCCIÓN EN CURSO EN LA PANTALLA */
628: configuracion.verinstruccion = SI;
629: if(strcmp(campo, "NO")==0) configuracion.verinstruccion = NO;
630: break;
631:
632: case 44: /* VER VENTANA EN CURSO EN LA PANTALLA */
633: configuracion.verventana = SI;
634: if(strcmp(campo, "NO")==0) configuracion.verventana = NO;
635: break;
636: }
637: }
638: }
639: }
640:
641: /* hago validación de datos de entrada */
642: ValidarConfiguracion();
643:
644:
645: if(fclose(handle))
646: {
647: sprintf(mensaje, "[CargarConfiguracionFichero] El fichero '%s' no se ha podido cerrar", fichero);
648: Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
649: }
650: else
651: {
652: sprintf(mensaje, "[CargarConfiguracionFichero] El fichero '%s' ha sido cerrado con éxito", fichero);
653: Notificar(mensaje, NO_ERROR, ECO_NO);
654: }
655: }
656: else
657: {
658: sprintf(mensaje, "[CargarConfiguracionFichero] El fichero '%s' no se ha podido abrir", fichero);
659: Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
660: }
661: }
662:
663:
664: /* función que carga la configuración desde los argumentos del 'main' */
665:
666: /* también realiza una pequeña validación de las entradas */
667: /* si se requiere asignación de CPI lo fuerza */
668: /* si se anula el análisis de dependencias de datos lo fuerza */
669: /* si se requiere un cálculo previo lo fuerza */
670:
671: void CapturarArgumentos(int argc, char *argv[])
672: {
673: char mensaje[MAX_LINE];
674: char cadena[10];
675: char arg_leido = NO;
676:
677: /*
678: int i;
679:
680: printf("%d\n", argc);
681: for(i=0; i<argc; i++)
682: {
683: printf("%s\n", argv[i]);
684: }
685:
686: _getch();
687: */
688:
689: while(--argc > 0 && (*++argv)[0]=='-')
690: {
691: switch((*argv)[1])
692: {
693: case 'h': /* mostrar texto de ayuda */
694: printf("%s", *textoayuda);
695: exit(1);
696: break;
697:
698: case 'f': /* cargar la configuración desde fichero */
699: /* si queda al menos un argumento y es una ruta y no otra opción */
700: if(--argc!=0 && (*++argv)[0]!='-') strcpy(configuracion.ficheroconfig, argv[0]);
701: /* cargo la configuración desde fichero (el indicado por defecto o el nuevo) */
702: /* haciendo caso omiso del resto de argumentos (capturados o por capturar) */
703: strcpy(configuracion.captura, "Por fichero");
704: /* el fichero de configuración no lleva la clave del tipo de captura ni el */
705: /* nombre del fichero de configuración */
706: CargarConfiguracionFichero();
707: argc = 0; /* dejo de leer el resto de argumentos */
708: break;
709:
710: case 'n': /* fichero de arquitectura del repertorio (nemónicos) */
711: /* si queda al menos un argumento y es una ruta y no otra opción */
712: if(--argc!=0 && (*++argv)[0]!='-')
713: {
714: strcpy(configuracion.ficheronemos, argv[0]);
715: arg_leido = SI;
716: }
717: else
718: {
719: sprintf(mensaje, "[CapturarArgumentos] La opción -n no especifica ruta y no se tendrá en cuenta");
720: Notificar(mensaje, NO_ERROR, ECO_NO);
721: ++argc; *--argv; /* recupero la situación */
722: }
723: break;
724:
725: case 'u': /* fichero de arquitectura del repertorio (ubicaciones) */
726: /* si queda al menos un argumento y es una ruta y no otra opción */
727: if(--argc!=0 && (*++argv)[0]!='-')
728: {
729: strcpy(configuracion.ficheroubis, argv[0]);
730: arg_leido = SI;
731: }
732: else
733: {
734: sprintf(mensaje, "[CapturarArgumentos] La opción -u no especifica ruta y no se tendrá en cuenta");
735: Notificar(mensaje, NO_ERROR, ECO_NO);
736: ++argc; *--argv; /* recupero la situación */
737: }
738: break;
739:
740: case 'O': /* origen de datos */
741: /* el siguiente caracter indica situaciones excluyentes */
742: switch((*argv)[2])
743: {
744: case 't':
745: /* si queda al menos un argumento y es una ruta y no otra opción */
746: if(--argc!=0 && (*++argv)[0]!='-')
747: {
748: configuracion.origen = TRAZA;
749: strcpy(configuracion.ficherodatos, argv[0]);
750: arg_leido = SI;
751: }
752: else
753: {
754: sprintf(mensaje, "[CapturarArgumentos] La opción -Ot no especifica ruta y no se tendrá en cuenta");
755: Notificar(mensaje, NO_ERROR, ECO_NO);
756: ++argc; *--argv; /* recupero la situación */
757: }
758: break;
759:
760: case 's':
761: /* si queda al menos un argumento y es una ruta y no otra opción */
762: if(--argc!=0 && (*++argv)[0]!='-')
763: {
764: configuracion.origen = SECUENCIA;
765: strcpy(configuracion.ficherodatos, argv[0]);
766: arg_leido = SI;
767: }
768: else
769: {
770: sprintf(mensaje, "[CapturarArgumentos] La opción -Os no especifica ruta y no se tendrá en cuenta");
771: Notificar(mensaje, NO_ERROR, ECO_NO);
772: ++argc; *--argv; /* recupero la situación */
773: }
774: break;
775:
776: case 'i':
777: /* si queda al menos un argumento y es una ruta y no otra opción */
778: if(--argc!=0 && (*++argv)[0]!='-')
779: {
780: configuracion.origen = CADENAHEX;
781: strcpy(configuracion.cadenahex, argv[0]);
782: arg_leido = SI;
783: }
784: else
785: {
786: sprintf(mensaje, "[CapturarArgumentos] La opción -Oi no especifica instrucción y no se tendrá en cuenta");
787: Notificar(mensaje, NO_ERROR, ECO_NO);
788: ++argc; *--argv; /* recupero la situación */
789: }
790: break;
791:
792: default:
793: sprintf(mensaje, "[CapturarArgumentos] La opción -O%c no se reconoce", (*argv)[2]);
794: Notificar(mensaje, NO_ERROR, ECO_NO);
795: break;
796: }
797: break;
798:
799: case 'p': /* porcentaje de datos a analizar (sólo para trazas) */
800: /* estos argumentos se cargan en los parámetros de configuración */
801: /* pero si se procesa una traza no se tienen en cuenta */
802: switch((*argv)[2])
803: {
804: case 'r': /* rango total en porcentaje */
805: /* si queda al menos un argumento y es una ruta y no otra opción */
806: if(--argc!=0 && (*++argv)[0]!='-')
807: {
808: strcpy(cadena, argv[0]);
809: cadena[strlen(cadena)-1]='\0'; /* quito el caracter '%' */
810: configuracion.rango = atof(argv[0]);
811: arg_leido = SI;
812: }
813: else
814: {
815: sprintf(mensaje, "[CapturarArgumentos] La opción -pr no especifica valor y no se tendrá en cuenta");
816: Notificar(mensaje, NO_ERROR, ECO_NO);
817: ++argc; *--argv; /* recupero la situación */
818: }
819: break;
820:
821: case 'c': /* comienzo en porcentaje */
822: /* si queda al menos un argumento y es una ruta y no otra opción */
823: if(--argc!=0 && (*++argv)[0]!='-')
824: {
825: strcpy(cadena, argv[0]);
826: cadena[strlen(cadena)-1]='\0'; /* quito el caracter '%' */
827: configuracion.comienzo = atof(argv[0]);
828: arg_leido = SI;
829: }
830: else
831: {
832: sprintf(mensaje, "[CapturarArgumentos] La opción -pc no especifica valor y no se tendrá en cuenta");
833: Notificar(mensaje, NO_ERROR, ECO_NO);
834: ++argc; *--argv; /* recupero la situación */
835: }
836: break;
837:
838: default:
839: sprintf(mensaje, "[CapturarArgumentos] La opción -p%c no se reconoce", (*argv)[2]);
840: Notificar(mensaje, NO_ERROR, ECO_NO);
841: break;
842: }
843: break;
844:
845: case 'i': /* primera y última instrucción del análisis (sólo para trazas) */
846: /* estos argumentos se cargan en los parámetros de configuración */
847: /* pero si se procesa una traza no se tienen en cuenta */
848: switch((*argv)[2])
849: {
850: case 'p':
851: /* si queda al menos un argumento y es una ruta y no otra opción */
852: if(--argc!=0 && (*++argv)[0]!='-')
853: {
854: configuracion.primera = atoi(argv[0]);
855: arg_leido = SI;
856: }
857: else
858: {
859: sprintf(mensaje, "[CapturarArgumentos] La opción -ip no especifica valor y no se tendrá en cuenta");
860: Notificar(mensaje, NO_ERROR, ECO_NO);
861: ++argc; *--argv; /* recupero la situación */
862: }
863: break;
864:
865: case 'u':
866: /* si queda al menos un argumento y es una ruta y no otra opción */
867: if(--argc!=0 && (*++argv)[0]!='-')
868: {
869: configuracion.ultima = atoi(argv[0]);
870: arg_leido = SI;
871: }
872: else
873: {
874: sprintf(mensaje, "[CapturarArgumentos] La opción -iu no especifica valor y no se tendrá en cuenta");
875: Notificar(mensaje, NO_ERROR, ECO_NO);
876: ++argc; *--argv; /* recupero la situación */
877: }
878: break;
879:
880: default:
881: sprintf(mensaje, "[CapturarArgumentos] La opción -i%c no se reconoce", (*argv)[2]);
882: Notificar(mensaje, NO_ERROR, ECO_NO);
883: break;
884: }
885: break;
886:
887: case 'r': /* hacer recuentos */
888: configuracion.recuentos = SI;
889: arg_leido = SI;
890: break;
891:
892: case 'c': /* asignar CPI a cada instrucción */
893: configuracion.cpi = SI;
894: arg_leido = SI;
895: /* si queda al menos un argumento y es una ruta y no otra opción */
896: if(--argc!=0 && (*++argv)[0]!='-') strcpy(configuracion.ficherociclos , argv[0]);
897: else {++argc; *--argv;} /* recupero la situación */
898: break;
899:
900: case 'D': /* analizar dependencias de datos */
901: configuracion.dependencias = NO;
902: arg_leido = SI;
903: break;
904:
905: case 'v': /* tamaño de la ventana de instrucciones */
906: /* si queda al menos un argumento y es una ruta y no otra opción */
907: if(--argc!=0 && (*++argv)[0]!='-')
908: {
909: configuracion.ventana = atoi(argv[0]);
910: arg_leido = SI;
911: }
912: else
913: {
914: sprintf(mensaje, "[CapturarArgumentos] La opción -v no especifica tamaño y no se tendrá en cuenta");
915: Notificar(mensaje, NO_ERROR, ECO_NO);
916: ++argc; *--argv; /* recupero la situación */
917: }
918: break;
919:
920: case 'L': /* listado de ubicaciones de la pizarra de análisis de dependencias */
921: /* si queda al menos un argumento y es una lista y no otra opción */
922: if(--argc!=0 && (*++argv)[0]!='-')
923: {
924: strcpy(configuracion.listaubis, argv[0]);
925: arg_leido = SI;
926: }
927: else
928: {
929: sprintf(mensaje, "[CapturarArgumentos] La opción -L no especifica lista y no se tendrá en cuenta");
930: Notificar(mensaje, NO_ERROR, ECO_NO);
931: ++argc; *--argv; /* recupero la situación */
932: }
933: break;
934:
935: case 'k': /* desacoplar tipos de dependencias */
936: configuracion.desacoplartipos = SI;
937: arg_leido = SI;
938: break;
939:
940: case 'd': /* no considerar tipos de dependencias */
941: switch((*argv)[2])
942: {
943: case 'v': /* evitar las dependencias verdaderas */
944: configuracion.verdaderas = NO;
945: arg_leido = SI;
946: break;
947:
948: case 'a': /* evitar las antidependencias */
949: configuracion.antidependencias = NO;
950: arg_leido = SI;
951: break;
952:
953: case 's': /* evitar las dependencias de salida */
954: configuracion.salida = NO;
955: arg_leido = SI;
956: break;
957:
958: default:
959: sprintf(mensaje, "[CapturarArgumentos] La opción -d%c no se reconoce", (*argv)[2]);
960: Notificar(mensaje, NO_ERROR, ECO_NO);
961: break;
962: }
963: break;
964:
965: case 'o': /* desacoplar origen de dependencias */
966: configuracion.desacoplarorigen = SI;
967: arg_leido = SI;
968: break;
969:
970: case 't': /* no considerar origen de dependencias */
971: switch((*argv)[2])
972: {
973: case 'e': /* evitar los operandos explícitos */
974: configuracion.explicitos = NO;
975: arg_leido = SI;
976: break;
977:
978: case 'i': /* evitar los operandos implicitos */
979: configuracion.implicitos = NO;
980: arg_leido = SI;
981: break;
982:
983: default:
984: sprintf(mensaje, "[CapturarArgumentos] La opción -t%c no se reconoce", (*argv)[2]);
985: Notificar(mensaje, NO_ERROR, ECO_NO);
986: break;
987: }
988: break;
989:
990: case 's': /* desacoplar fuentes de dependencias */
991: configuracion.desacoplarfuentes = SI;
992: arg_leido = SI;
993: break;
994:
995: case 'q': /* no considerar fuentes de dependencias */
996: switch((*argv)[2])
997: {
998: case 'd': /* evitar las dependencias debidas a datos */
999: configuracion.datos = NO;
1000: arg_leido = SI;
1001: break;
1002:
1003: case 'a': /* evitar las dependencias debidas a cómputo de direcciones */
1004: configuracion.direcciones = NO;
1005: arg_leido = SI;
1006: break;
1007:
1008: case 's': /* evitar las dependencias debidas a tráfico con la pila */
1009: configuracion.pila = NO;
1010: arg_leido = SI;
1011: break;
1012:
1013: case 'c': /* evitar las dependencias debidas a códigos de condición */
1014: configuracion.cc = NO;
1015: arg_leido = SI;
1016: break;
1017:
1018: default:
1019: sprintf(mensaje, "[CapturarArgumentos] La opción -q%c no se reconoce", (*argv)[2]);
1020: Notificar(mensaje, NO_ERROR, ECO_NO);
1021: break;
1022: }
1023: break;
1024:
1025: case 'C': /* cálculos a realizar */
1026: /* detrás de la 'C' podemos colocar seguidos todos los argumentos del grupo */
1027: *++(*argv); /* avanzo hasta el primer caracter después de la 'C' */
1028: while((char)*++(*argv)) /* barro todos los caracteres hasta el final de la cadena */
1029: {
1030: switch((char)*(*argv))
1031: {
1032: case 'm': /* calcular el CPI promedio */
1033: configuracion.CPImedio = SI;
1034: arg_leido = SI;
1035: break;
1036:
1037: case 't': /* calcular tiempo de ejecución */
1038: configuracion.tiempo = SI;
1039: arg_leido = SI;
1040: break;
1041:
1042: case 'o': /* obtener lista de orden parcial */
1043: configuracion.ordenparcial = SI;
1044: arg_leido = SI;
1045: break;
1046:
1047: case 'c': /* generar matriz de caminos */
1048: configuracion.matrizcaminos = SI;
1049: arg_leido = SI;
1050: break;
1051:
1052: case 'p': /* calcular pasos de computación */
1053: configuracion.pasoscomputacion = NO;
1054: arg_leido = SI;
1055: break;
1056:
1057: case 'g': /* calcular grado de paralelismo */
1058: configuracion.gradoparalelismo = SI;
1059: arg_leido = SI;
1060: break;
1061:
1062: case 'a': /* calcular acoplamiento */
1063: configuracion.acoplamiento = SI;
1064: arg_leido = SI;
1065: break;
1066:
1067: case 'h': /* construir histograma */
1068: configuracion.distribucionpasos = SI;
1069: arg_leido = SI;
1070: break;
1071:
1072: default:
1073: sprintf(mensaje, "[CapturarArgumentos] La opción -C%c no se reconoce", (char)*(*argv));
1074: Notificar(mensaje, NO_ERROR, ECO_NO);
1075: break;
1076: }
1077: }
1078: break;
1079:
1080: case 'V': /* informes: volcar datos en ficheros */
1081: switch((*argv)[2])
1082: {
1083: case 'd': /* volcar bases de datos */
1084: configuracion.volcarBD = NO;
1085: arg_leido = SI;
1086: break;
1087:
1088: case 'c': /* crear nuevo fichero de configuración */
1089: configuracion.crearficheroconfig = SI;
1090: arg_leido = SI;
1091: /* si queda al menos un argumento y es una ruta y no otra opción */
1092: if(--argc!=0 && (*++argv)[0]!='-') strcpy(configuracion.nuevoficheroconfig, argv[0]);
1093: else {++argc; *--argv;} /* recupero la situación */
1094: break;
1095:
1096: case 'v': /* listado de ventanas a salvar */
1097: /* si queda al menos un argumento y es una lista y no otra opción */
1098: if(--argc!=0 && (*++argv)[0]!='-')
1099: {
1100: strcpy(configuracion.volcarventana, argv[0]);
1101: arg_leido = SI;
1102: }
1103: else
1104: {
1105: sprintf(mensaje, "[CapturarArgumentos] La opción -Vv no especifica lista y no se tendrá en cuenta");
1106: Notificar(mensaje, NO_ERROR, ECO_NO);
1107: ++argc; *--argv; /* recupero la situación */
1108: }
1109: break;
1110:
1111: default:
1112: sprintf(mensaje, "[CapturarArgumentos] La opción -V%c no se reconoce", (*argv)[2]);
1113: Notificar(mensaje, NO_ERROR, ECO_NO);
1114: break;
1115: }
1116: break;
1117:
1118: case 'R': /* fichero de resultados */
1119: /* si queda al menos un argumento y es una ruta y no otra opción */
1120: if(--argc!=0 && (*++argv)[0]!='-')
1121: {
1122: strcpy(configuracion.ficheroresultados, argv[0]);
1123: arg_leido = SI;
1124: }
1125: else
1126: {
1127: sprintf(mensaje, "[CapturarArgumentos] La opción -R no especifica ruta y no se tendrá en cuenta");
1128: Notificar(mensaje, NO_ERROR, ECO_NO);
1129: ++argc; *--argv; /* recupero la situación */
1130: }
1131: break;
1132:
1133: case 'N': /* nivel de notificaciones en el fichero de log */
1134: /* si queda al menos un argumento y es una ruta y no otra opción */
1135: if(--argc!=0 && (*++argv)[0]!='-')
1136: {
1137: configuracion.nivelnotificaciones = atoi(argv[0]);
1138: arg_leido = SI;
1139: }
1140: else
1141: {
1142: sprintf(mensaje, "[CapturarArgumentos] La opción -N no especifica nivel y no se tendrá en cuenta");
1143: Notificar(mensaje, NO_ERROR, ECO_NO);
1144: ++argc; *--argv; /* recupero la situación */
1145: }
1146: break;
1147:
1148: case 'M': /* mostrar en pantalla */
1149: /* detrás de la 'M' podemos colocar seguidos todos los argumentos del grupo */
1150: *++(*argv); /* avanzo hasta el primer caracter después de la 'M' */
1151: while((char)*++(*argv)) /* barro todos los caracteres hasta el final de la cadena */
1152: {
1153: switch((char)*(*argv))
1154: {
1155: case 'i': /* mostrar instrucción en curso en la pantalla */
1156: configuracion.verinstruccion = SI;
1157: arg_leido = SI;
1158: break;
1159:
1160: #if 0 /* no se ha incluido el parámetro aún */
1161: case 'e': /* mostrar estado */
1162: configuracion.XXXXXX = SI;
1163: arg_leido = SI;
1164: break;
1165: #endif
1166:
1167: case 'v': /* mostrar ventana */
1168: configuracion.verventana = SI;
1169: arg_leido = SI;
1170: break;
1171:
1172: default:
1173: sprintf(mensaje, "[CapturarArgumentos] La opción -M%c no se reconoce", (char)*(*argv));
1174: Notificar(mensaje, NO_ERROR, ECO_NO);
1175: break;
1176: }
1177: }
1178: break;
1179:
1180: default:
1181: sprintf(mensaje, "[CapturarArgumentos] La opción -%c no se reconoce", (*argv)[1]);
1182: Notificar(mensaje, NO_ERROR, ECO_NO);
1183: break;
1184: }
1185: }
1186:
1187: if(arg_leido == SI) strcpy(configuracion.captura, "Paso de argumentos");
1188:
1189: ValidarConfiguracion();
1190: }
1191:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Configuracion.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