Annotation of ADD_ver_10/Source Code/Source Files/BasesDatos.c, revision 1.1
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;
! 39: char mensaje[MAX_LINE];
! 40:
! 41:
! 42: sprintf(mensaje, "[CargarArquitecturaIA16Nemonicos] Cargando base de datos del repertorio IA16...");
! 43: Notificar(mensaje, NO_ERROR, ECO_NO);
! 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);
! 52: Notificar(mensaje, NO_ERROR, ECO_NO);
! 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");
! 61: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 62: /* el programa finaliza si no hay memoria suficiente */
! 63: }
! 64:
! 65: sprintf(mensaje, "[CargarArquitecturaIA16Nemonicos] Cargando datos de nemónicos...");
! 66: Notificar(mensaje, NO_ERROR, ECO_NO);
! 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");
! 133: Notificar(mensaje, NO_ERROR, ECO_NO);
! 134: }
! 135:
! 136:
! 137: void CargarArquitecturaIA16Simbolos(FILE *f_ia16_ubis)
! 138: {
! 139: unsigned int i;
! 140: char linea[MAX_LINE];
! 141: char *campo;
! 142: char mensaje[MAX_LINE];
! 143:
! 144: sprintf(mensaje, "[CargarArquitecturaIA16Simbolos] Cargando base de datos del repertorio IA16...");
! 145: Notificar(mensaje, NO_ERROR, ECO_NO);
! 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);
! 154: Notificar(mensaje, NO_ERROR, ECO_NO);
! 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");
! 163: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 164: /* el programa finaliza si no hay memoria suficiente */
! 165: }
! 166:
! 167: sprintf(mensaje, "[CargarArquitecturaIA16Simbolos] Cargando datos de símbolos...");
! 168: Notificar(mensaje, NO_ERROR, ECO_NO);
! 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: }
! 208:
! 209: /* echo */
! 210: /* printf(); */
! 211: /* _getch(); */
! 212:
! 213: i++; /* índice del siguiente registro */
! 214: }
! 215:
! 216: sprintf(mensaje, "[CargarArquitecturaIA16Simbolos] La tabla de símbolos se ha cargado con éxito");
! 217: Notificar(mensaje, NO_ERROR, ECO_NO);
! 218: }
! 219:
! 220:
! 221: void CargarTiemposProcesador(FILE *f_procesador)
! 222: {
! 223: unsigned int i;
! 224: char linea[MAX_LINE];
! 225: char *campo;
! 226: char mensaje[MAX_LINE];
! 227:
! 228: sprintf(mensaje, "[CargarTiemposProcesador] Cargando base de datos del procesador...");
! 229: Notificar(mensaje, NO_ERROR, ECO_NO);
! 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);
! 238: Notificar(mensaje, NO_ERROR, ECO_NO);
! 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");
! 247: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 248: /* el programa finaliza si no hay memoria suficiente */
! 249: }
! 250:
! 251: sprintf(mensaje, "[CargarTiemposProcesador] Cargando datos de tiempos...");
! 252: Notificar(mensaje, NO_ERROR, ECO_NO);
! 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(); */
! 288:
! 289: i++; /* índice del siguiente registro */
! 290: }
! 291:
! 292: sprintf(mensaje, "[CargarTiemposProcesador] La tabla de tiempos se ha cargado con éxito");
! 293: Notificar(mensaje, NO_ERROR, ECO_NO);
! 294: }
! 295:
! 296:
! 297: void CargarArquitecturaIA16()
! 298: {
! 299: FILE *f_ia16_nemos, *f_ia16_ubis;
! 300: char mensaje[MAX_LINE];
! 301:
! 302:
! 303: /* abro el fichero de nemónicos de la arquitectura del repertorio */
! 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);
! 307: Notificar(mensaje, NO_ERROR, ECO_NO);
! 308:
! 309: CargarArquitecturaIA16Nemonicos(f_ia16_nemos);
! 310:
! 311: /* cierro el fichero de nemónicos */
! 312: if(fclose(f_ia16_nemos))
! 313: {
! 314: sprintf(mensaje, "[CargarArquitecturaIA16] El fichero '%s' no se ha podido cerrar", configuracion.ficheronemos);
! 315: Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
! 316: }
! 317: }
! 318: else
! 319: {
! 320: sprintf(mensaje, "[CargarArquitecturaIA16] El fichero '%s' no se ha podido abrir", configuracion.ficheronemos);
! 321: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 322: }
! 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);
! 329: Notificar(mensaje, NO_ERROR, ECO_NO);
! 330:
! 331: CargarArquitecturaIA16Simbolos(f_ia16_ubis);
! 332:
! 333: /* cierro el fichero de ubicaciones */
! 334: if(fclose(f_ia16_ubis))
! 335: {
! 336: sprintf(mensaje, "[CargarArquitecturaIA16] El fichero '%s' no se ha podido cerrar", configuracion.ficheroubis);
! 337: Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
! 338: }
! 339: }
! 340: else
! 341: {
! 342: sprintf(mensaje, "[CargarArquitecturaIA16] El fichero '%s' no se ha podido abrir", configuracion.ficheroubis);
! 343: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 344: }
! 345: }
! 346:
! 347:
! 348: void CargarProcesador()
! 349: {
! 350: FILE *f_procesador;
! 351: char mensaje[MAX_LINE];
! 352:
! 353:
! 354: /* abro el fichero con la tabla de tiempos del procesador */
! 355: if((f_procesador = fopen(configuracion.ficherociclos, "r")) != NULL)
! 356: {
! 357: sprintf(mensaje, "[CargarProcesador] El fichero '%s' se ha abierto con éxito", configuracion.ficherociclos);
! 358: Notificar(mensaje, NO_ERROR, ECO_NO);
! 359:
! 360: CargarTiemposProcesador(f_procesador);
! 361:
! 362: /* cierro el fichero del procesador */
! 363: if(fclose(f_procesador))
! 364: {
! 365: sprintf(mensaje, "[CargarProcesador] El fichero '%s' no se ha podido cerrar", configuracion.ficherociclos);
! 366: Notificar(mensaje, ERROR_SEGUIR, ECO_NO);
! 367: }
! 368: }
! 369: else
! 370: {
! 371: sprintf(mensaje, "[CargarProcesador] El fichero '%s' no se ha podido abrir", configuracion.ficherociclos);
! 372: Notificar(mensaje, ERROR_SALIR, ECO_NO);
! 373: }
! 374: }
! 375:
! 376:
! 377: /* carga de las bases de datos */
! 378:
! 379: void CargarBasesDatos()
! 380: {
! 381: CargarArquitecturaIA16();
! 382: if(configuracion.cpi == SI) CargarProcesador();
! 383: }
! 384:
! 385:
! 386: /* libera memoria bases de datos */
! 387:
! 388: void LiberarMemoriaBasesDatos()
! 389: {
! 390: free(nemonicos);
! 391: free(simbolos);
! 392: if(configuracion.cpi == SI) free(ciclos);
! 393: }
! 394:
! 395:
! 396:
! 397: #if 0
! 398:
! 399: /* la función strtok de <string.h> descompone la línea en campos */
! 400: /* OJO: modifica la cadena de caracteres de la línea que se le pasa */
! 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 / Source Code / Source Files