Annotation of ADD_ver_10/BasesDatos.c, revision 1.2
1.1 rico 1: /******************************************************************************/
2: /* MÓDULO: BasesDatos.c */
3: /* */
4: /* Este módulo carga en memoria la base de datos que modela la arquitectura */
5: /* del repertorio IA16 (tabla de nemónicos y tabla de ubicaciones de datos) */
6: /* y la tabla de tiempos de un procesador en ciclos (tiempo de ejecución de */
7: /* operaciones, tiempo de acceso a operandos y tiempo de cómputo de */
8: /* direcciones de memoria. */
9: /******************************************************************************/
10: /* Fecha: 19 de septiembre de 2005 */
11: /******************************************************************************/
12:
13: #include <stdio.h>
14: #include <stdlib.h>
15: #include <string.h>
16:
17: #include "defines.h"
18: #include "tipos.h"
19: #include "basesdatos.h"
20:
21:
22: /* configuración */
23: extern struct argumentos configuracion;
24:
25: /* bases de datos */
26: extern unsigned int num_nemonicos;
27: extern operacion *nemonicos;
28: extern unsigned int num_simbolos;
29: extern operando *simbolos;
30: extern unsigned int num_tiempos;
31: extern tiempo *ciclos;
32:
33:
34: void CargarArquitecturaIA16Nemonicos(FILE *f_ia16_nemos)
35: {
36: unsigned int i;
37: char linea[MAX_LINE];
38: char *registro, *campo;
1.2 ! rico 39: char mensaje[MAX_LINE];
1.1 rico 40:
41:
42: sprintf(mensaje, "[CargarArquitecturaIA16Nemonicos] Cargando base de datos del repertorio IA16...");
1.2 ! rico 43: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 44:
45: /* salto los comentarios */
46: do fgets (linea, MAX_LINE, f_ia16_nemos); while (linea[0]=='#');
47:
48: /* leo el número de registros (primera línea con información) */
49: num_nemonicos = atoi(linea);
50:
51: sprintf(mensaje, "[CargarArquitecturaIA16Nemonicos] Reservo memoria para %d registros", num_nemonicos);
1.2 ! rico 52: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 53:
54: /* malloc reserva memoria; calloc reserva memoria y rellena con 0's */
55: /* calloc es más lenta pero me asegura que los valores numéricos van */
56: /* a ser 0 y las cadenas van a ser vacías */
57: nemonicos = calloc(num_nemonicos, sizeof(operacion));
58: if (nemonicos == NULL)
59: {
60: sprintf(mensaje, "[CargarArquitecturaIA16Nemonicos] Memoria insuficiente");
1.2 ! rico 61: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 62: /* el programa finaliza si no hay memoria suficiente */
1.1 rico 63: }
64:
65: sprintf(mensaje, "[CargarArquitecturaIA16Nemonicos] Cargando datos de nemónicos...");
1.2 ! rico 66: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 67:
68: i = 0;
69: while(i<num_nemonicos)
70: {
71: /* salto los comentarios */
72: do fgets (linea, MAX_LINE, f_ia16_nemos); while(linea[0]=='#');
73:
74: /* hago un barrido de la línea hasta encontrar el final de línea */
75: /* cada ocurrencia de '\t' la cambio por '\0' para convertirlo */
76: /* en una cadena separada (campo) */
77:
78: /* el puntero 'registro' me permite moverme por la línea */
79: /* el puntero 'campo' se encarga se señalar el comienzo de los campos */
80: registro = linea;
81: campo = linea;
82: while(*++registro!='\0')
83: {
84: if(*registro=='\t')
85: {
86: *registro = '\0'; /* finalizo un campo */
87: /* campo nemonico */
88: if(campo[0]!='-') strcpy(nemonicos[i].nemonico, campo);
89: else
90: {
91: switch(campo[1])
92: {
93: case 't': /* tipo de nemonico */
94: nemonicos[i].tipo = atoi(campo+3);
95: break;
96:
97: case '1': /* modo del operando 1 (destino) explícito */
98: nemonicos[i].modo_op1 = atoi(campo+3);
99: break;
100:
101: case '2': /* modo del operando 2 (fuente) explícito */
102: nemonicos[i].modo_op2 = atoi(campo+3);
103: break;
104:
105: case 'e': /* implícitos escritos */
106: strcpy(nemonicos[i].implicitos_escritos, campo+3);
107: break;
108:
109: case 'l': /* implícitos leidos */
110: strcpy(nemonicos[i].implicitos_leidos, campo+3);
111: break;
112:
113: default:
114: /* mandar un error a un fichero de log */
115: break;
116: }
117: }
118: campo = registro+1; /* hago que apunte al siguiente */
119: }
120: }
121:
122: /* echo */
123: /* printf("%3d %10s %d %d\t%15s\t%30s\n", i, operaciones[i].nemonico,
124: operaciones[i].modo_fuente, operaciones[i].modo_destino,
125: operaciones[i].implicitos_leidos,
126: operaciones[i].implicitos_escritos); */
127: /* _getch(); */
128:
129: i++; /* índice del siguiente registro */
130: }
131:
132: sprintf(mensaje, "[CargarArquitecturaIA16Nemonicos] La tabla de nemónicos se ha cargado con éxito");
1.2 ! rico 133: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 134: }
135:
136:
137: void CargarArquitecturaIA16Simbolos(FILE *f_ia16_ubis)
138: {
139: unsigned int i;
140: char linea[MAX_LINE];
141: char *campo;
1.2 ! rico 142: char mensaje[MAX_LINE];
1.1 rico 143:
144: sprintf(mensaje, "[CargarArquitecturaIA16Simbolos] Cargando base de datos del repertorio IA16...");
1.2 ! rico 145: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 146:
147: /* salto los comentarios */
148: do fgets (linea, MAX_LINE, f_ia16_ubis); while (linea[0]=='#');
149:
150: /* leo el número de registros (primera línea con información) */
151: num_simbolos = atoi(linea);
152:
153: sprintf(mensaje, "[CargarArquitecturaIA16Simbolos] Reservo memoria para %d registros", num_simbolos);
1.2 ! rico 154: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 155:
156: /* malloc reserva memoria; calloc reserva memoria y rellena con 0's */
157: /* calloc es más lenta pero me asegura que los valores numéricos van */
158: /* a ser 0 y las cadenas van a ser vacías */
159: simbolos = calloc(num_simbolos, sizeof(operando));
160: if (simbolos == NULL)
161: {
162: sprintf(mensaje, "[CargarArquitecturaIA16Simbolos] Memoria insuficiente");
1.2 ! rico 163: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 164: /* el programa finaliza si no hay memoria suficiente */
1.1 rico 165: }
166:
167: sprintf(mensaje, "[CargarArquitecturaIA16Simbolos] Cargando datos de símbolos...");
1.2 ! rico 168: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 169:
170: i = 0;
171: while(i<num_simbolos)
172: {
173: /* salto los comentarios */
174: do fgets (linea, MAX_LINE, f_ia16_ubis); while(linea[0]=='#');
175:
176: campo = strtok(linea, "\t\n"); /* el separador de campos es '\t' */
177: /* añado '\n' porque al final de linea */
178: /* tengo ese caracter y lo toma por un campo */
179: while(campo != NULL)
180: {
181: /* trato el campo capturado por la función strtok */
182: /* campo símbolo */
183: if(campo[0]!='-') strcpy(simbolos[i].simbolo, campo);
184: else
185: {
186: switch(campo[1])
187: {
188: case 'd': /* dependencias */
189: strcpy(simbolos[i].dependencias, campo+3);
190: break;
191:
192: case 's': /* segmento por defecto */
193: simbolos[i].segmento = atoi (campo+3);
194: break;
195:
196: case 't': /* tipo de ubicación */
197: simbolos[i].tipo = atoi (campo+3);
198: break;
199:
200: default:
201: /* mandar un error a un fichero de log */
202: break;
203: }
204: }
205: /* capturo el siguiente campo */
206: campo = strtok(NULL, "\t\n");
207: }
1.2 ! rico 208:
! 209: /* echo */
! 210: /* printf(); */
! 211: /* _getch(); */
1.1 rico 212:
1.2 ! rico 213: i++; /* índice del siguiente registro */
1.1 rico 214: }
215:
216: sprintf(mensaje, "[CargarArquitecturaIA16Simbolos] La tabla de símbolos se ha cargado con éxito");
1.2 ! rico 217: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 218: }
219:
220:
221: void CargarTiemposProcesador(FILE *f_procesador)
222: {
223: unsigned int i;
224: char linea[MAX_LINE];
225: char *campo;
1.2 ! rico 226: char mensaje[MAX_LINE];
1.1 rico 227:
228: sprintf(mensaje, "[CargarTiemposProcesador] Cargando base de datos del procesador...");
1.2 ! rico 229: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 230:
231: /* salto los comentarios */
232: do fgets (linea, MAX_LINE, f_procesador); while (linea[0]=='#');
233:
234: /* leo el número de registros (primera línea con información) */
235: num_tiempos = atoi(linea);
236:
237: sprintf(mensaje, "[CargarTiemposProcesador] Reservo memoria para %d registros", num_tiempos);
1.2 ! rico 238: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 239:
240: /* malloc reserva memoria; calloc reserva memoria y rellena con 0's */
241: /* calloc es más lenta pero me asegura que los valores numéricos van */
242: /* a ser 0 y las cadenas van a ser vacías */
243: ciclos = calloc(num_tiempos, sizeof(tiempo));
244: if (ciclos == NULL)
245: {
246: sprintf(mensaje, "[CargarTiemposProcesador] Memoria insuficiente");
1.2 ! rico 247: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 248: /* el programa finaliza si no hay memoria suficiente */
1.1 rico 249: }
250:
251: sprintf(mensaje, "[CargarTiemposProcesador] Cargando datos de tiempos...");
1.2 ! rico 252: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 253:
254: i = 0;
255: while(i<num_tiempos)
256: {
257: /* salto los comentarios */
258: do fgets (linea, MAX_LINE, f_procesador); while(linea[0]=='#');
259:
260: campo = strtok(linea, "\t\n"); /* el separador de campos es '\t' */
261: /* añado '\n' porque al final de linea */
262: /* tengo ese caracter y lo toma por un campo */
263: while(campo != NULL)
264: {
265: /* trato el campo capturado por la función strtok */
266: /* campo identificador */
267: if(campo[0]!='-') strcpy(ciclos[i].identificador, campo);
268: else
269: {
270: switch(campo[1])
271: {
272: case 'c': /* dependencias */
273: ciclos[i].ciclos = atoi (campo+3);
274: break;
275:
276: default:
277: /* mandar un error a un fichero de log */
278: break;
279: }
280: }
281: /* capturo el siguiente campo */
282: campo = strtok(NULL, "\t\n");
283: }
284:
285: /* echo */
286: /* printf(); */
287: /* _getch(); */
1.2 ! rico 288:
! 289: i++; /* índice del siguiente registro */
1.1 rico 290: }
291:
292: sprintf(mensaje, "[CargarTiemposProcesador] La tabla de tiempos se ha cargado con éxito");
1.2 ! rico 293: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 294: }
295:
296:
297: void CargarArquitecturaIA16()
298: {
1.2 ! rico 299: FILE *f_ia16_nemos, *f_ia16_ubis;
! 300: char mensaje[MAX_LINE];
1.1 rico 301:
302:
1.2 ! rico 303: /* abro el fichero de nemónicos de la arquitectura del repertorio */
1.1 rico 304: if((f_ia16_nemos = fopen(configuracion.ficheronemos, "r")) != NULL)
305: {
306: sprintf(mensaje, "[CargarArquitecturaIA16] El fichero '%s' se ha abierto con éxito", configuracion.ficheronemos);
1.2 ! rico 307: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 308:
309: CargarArquitecturaIA16Nemonicos(f_ia16_nemos);
310:
311: /* cierro el fichero de nemónicos */
312: if(fclose(f_ia16_nemos))
1.2 ! rico 313: {
! 314: sprintf(mensaje, "[CargarArquitecturaIA16] El fichero '%s' no se ha podido cerrar", configuracion.ficheronemos);
! 315: Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
! 316: }
1.1 rico 317: }
318: else
1.2 ! rico 319: {
! 320: sprintf(mensaje, "[CargarArquitecturaIA16] El fichero '%s' no se ha podido abrir", configuracion.ficheronemos);
! 321: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 322: }
1.1 rico 323:
324:
325: /* abro el fichero de ubicaciones de la arquitectura del repertorio */
326: if((f_ia16_ubis = fopen(configuracion.ficheroubis, "r")) != NULL)
327: {
328: sprintf(mensaje, "[CargarArquitecturaIA16] El fichero '%s' se ha abierto con éxito", configuracion.ficheroubis);
1.2 ! rico 329: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 330:
331: CargarArquitecturaIA16Simbolos(f_ia16_ubis);
332:
333: /* cierro el fichero de ubicaciones */
334: if(fclose(f_ia16_ubis))
1.2 ! rico 335: {
! 336: sprintf(mensaje, "[CargarArquitecturaIA16] El fichero '%s' no se ha podido cerrar", configuracion.ficheroubis);
! 337: Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
! 338: }
1.1 rico 339: }
340: else
1.2 ! rico 341: {
! 342: sprintf(mensaje, "[CargarArquitecturaIA16] El fichero '%s' no se ha podido abrir", configuracion.ficheroubis);
! 343: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 344: }
1.1 rico 345: }
346:
347:
348: void CargarProcesador()
349: {
1.2 ! rico 350: FILE *f_procesador;
! 351: char mensaje[MAX_LINE];
1.1 rico 352:
353:
1.2 ! rico 354: /* abro el fichero con la tabla de tiempos del procesador */
1.1 rico 355: if((f_procesador = fopen(configuracion.ficherociclos, "r")) != NULL)
356: {
357: sprintf(mensaje, "[CargarProcesador] El fichero '%s' se ha abierto con éxito", configuracion.ficherociclos);
1.2 ! rico 358: Notificar(mensaje, NO_ERROR, ECO_NO);
1.1 rico 359:
360: CargarTiemposProcesador(f_procesador);
361:
362: /* cierro el fichero del procesador */
363: if(fclose(f_procesador))
1.2 ! rico 364: {
! 365: sprintf(mensaje, "[CargarProcesador] El fichero '%s' no se ha podido cerrar", configuracion.ficherociclos);
! 366: Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
! 367: }
1.1 rico 368: }
369: else
1.2 ! rico 370: {
! 371: sprintf(mensaje, "[CargarProcesador] El fichero '%s' no se ha podido abrir", configuracion.ficherociclos);
! 372: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 373: }
1.1 rico 374: }
375:
376:
377: /* carga de las bases de datos */
378:
379: void CargarBasesDatos()
380: {
1.2 ! rico 381: CargarArquitecturaIA16();
! 382: if(configuracion.cpi == SI) CargarProcesador();
1.1 rico 383: }
384:
385:
386: /* libera memoria bases de datos */
387:
388: void LiberarMemoriaBasesDatos()
389: {
390: free(nemonicos);
391: free(simbolos);
1.2 ! rico 392: if(configuracion.cpi == SI) free(ciclos);
1.1 rico 393: }
394:
395:
396:
397: #if 0
398:
399: /* la función strtok de <string.h> descompone la línea en campos */
1.2 ! rico 400: /* OJO: modifica la cadena de caracteres de la línea que se le pasa */
1.1 rico 401:
402: /* capturo el primer campo */
403: campo = strtok(linea, "\t");
404: while(campo != NULL)
405: {
406: /* trato el campo */
407:
408: /* capturo el siguiente campo */
409: campo = strtok( NULL, seps );
410: /* seps son los separadores, en este caso '\t' */
411: }
412:
413: /* la función getopt del POSIX hace algo parecido */
414: #endif
415:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to BasesDatos.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository ATC2] / ADD_ver_10