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