Annotation of ADD_ver_10/Recuentos.c, revision 1.1

1.1     ! rico        1: /********************************************************************/
        !             2: /*  Recuentos.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: /******************************************************************************/
        !            35: /* MÓDULO: Recuentos.c                                                        */
        !            36: /*                                                                            */
        !            37: /* Este módulo se encarga de contabilizar las operaciones y los diferentes    */
        !            38: /* accesos a operandos.                                                       */
        !            39: /******************************************************************************/
        !            40: /* Fecha: 23 de septiembre de 2005                                            */
        !            41: /******************************************************************************/
        !            42: 
        !            43: #include <stdio.h>
        !            44: #include <string.h>
        !            45: #include <malloc.h>
        !            46: 
        !            47: #include "defines.h"
        !            48: #include "tipos.h"
        !            49: #include "recuentos.h"
        !            50: 
        !            51: 
        !            52: /* bases de datos */
        !            53: extern unsigned int num_nemonicos;
        !            54: extern operacion *nemonicos;
        !            55: extern unsigned int num_simbolos;
        !            56: extern operando *simbolos;
        !            57: extern unsigned int num_tiempos;
        !            58: extern tiempo *ciclos;
        !            59: 
        !            60: /* recuentos */
        !            61: extern unsigned long int *contadornemonicos;
        !            62: extern unsigned long int *contadorlecturas;
        !            63: extern unsigned long int *contadorescrituras;
        !            64: 
        !            65: 
        !            66: /* esta función hace una reserva de memoria para los contadores */
        !            67: /* de recuentos de nemónicos y de accesos a operandos */
        !            68: 
        !            69: void CrearContadores()
        !            70: {
        !            71:        char mensaje[MAX_LINE];
        !            72: 
        !            73:     /* reservo memoria para los contadores de nemónicos */
        !            74:        contadornemonicos = calloc(num_nemonicos, sizeof(unsigned long int));
        !            75:     if (contadornemonicos == NULL)
        !            76:     {
        !            77:         sprintf(mensaje, "[CrearContadores] Memoria insuficiente");
        !            78:                Notificar(mensaje, ERROR_SALIR, ECO_NO);
        !            79:                /* el programa finaliza si no hay memoria suficiente */
        !            80:     }
        !            81: 
        !            82: 
        !            83:     /* reservo memoria para los contadores de accesos a operandos */
        !            84:        /* lecturas */
        !            85:     contadorlecturas = calloc(num_simbolos, sizeof(unsigned long int));
        !            86:     if (contadorlecturas == NULL)
        !            87:     {
        !            88:         sprintf(mensaje, "[CrearContadores] Memoria insuficiente");
        !            89:                Notificar(mensaje, ERROR_SALIR, ECO_NO);
        !            90:                /* el programa finaliza si no hay memoria suficiente */
        !            91:     }
        !            92:        /* escrituras */
        !            93:     contadorescrituras = calloc(num_simbolos, sizeof(unsigned long int));
        !            94:     if (contadorlecturas == NULL)
        !            95:     {
        !            96:         sprintf(mensaje, "[CrearContadores] Memoria insuficiente");
        !            97:                Notificar(mensaje, ERROR_SALIR, ECO_NO);
        !            98:                /* el programa finaliza si no hay memoria suficiente */
        !            99:     }
        !           100: }
        !           101: 
        !           102: 
        !           103: /* esta función actualiza los recuentos de operaciones y acceso a */
        !           104: /* operandos explícitos; la contabilidad de los implícitos se puede */
        !           105: /* obtener posteriormente a partir del recuento de nemónicos */
        !           106: 
        !           107: void ActualizarRecuentos(fichainstruccion *tarjetaoperandos)
        !           108: {
        !           109:     int id_nemo, id_simb;
        !           110:        char mensaje[MAX_LINE], cadena[MAX_LINE];
        !           111:        
        !           112:        /* PREFIJO (si lo hay) */
        !           113:        if(tarjetaoperandos->prefijo[0]!='\0')
        !           114:        {
        !           115:                id_nemo = BDBuscarCadena(TABLA_NEMONICOS, CAMPO_NEMONICO, tarjetaoperandos->prefijo);
        !           116: 
        !           117:                if(id_nemo == -1)
        !           118:                {
        !           119:                        /* emito un error al fichero de log */ 
        !           120:                        sprintf(mensaje, "[ActualizarRecuentos] La cadena '%s' no se ha encontrado en Tabla Nemónicos", tarjetaoperandos->prefijo);
        !           121:                        Notificar(mensaje, ERROR_SALIR, ECO_NO);
        !           122:                }
        !           123: 
        !           124:                /* incremento el contador para el nemónico en cuestión */
        !           125:                contadornemonicos[id_nemo]++;
        !           126:        }
        !           127: 
        !           128:        /* NEMÓNICO */
        !           129:        id_nemo = BDBuscarCadena(TABLA_NEMONICOS, CAMPO_NEMONICO, tarjetaoperandos->nemonico);
        !           130: 
        !           131:     if(id_nemo == -1)
        !           132:     {
        !           133:         /* emito un error al fichero de log */ 
        !           134:                sprintf(mensaje, "[ActualizarRecuentos] La cadena '%s' no se ha encontrado en Tabla Nemónicos", tarjetaoperandos->nemonico);
        !           135:                Notificar(mensaje, ERROR_SALIR, ECO_NO);
        !           136:     }
        !           137: 
        !           138:        /* incremento el contador para el nemónico en cuestión */
        !           139:        contadornemonicos[id_nemo]++;
        !           140: 
        !           141: 
        !           142:        /* OP2 (FUENTE) si lo hay */
        !           143:        if(tarjetaoperandos->op2[0]!='\0')
        !           144:        {
        !           145:         strcpy(cadena, tarjetaoperandos->op2);
        !           146:         NormalizarUbicacion(cadena);
        !           147: 
        !           148:                id_simb = BDBuscarCadena(TABLA_SIMBOLOS, CAMPO_SIMBOLO, cadena);
        !           149: 
        !           150:                if(id_simb == -1)
        !           151:                {
        !           152:                        /* emito un error al fichero de log */ 
        !           153:                        sprintf(mensaje, "[ActualizarRecuentos] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena);
        !           154:                        Notificar(mensaje, ERROR_SALIR, ECO_NO);
        !           155:                }
        !           156: 
        !           157:                /* incremento el contador para el símbolo en cuestión según el tipo de acceso */
        !           158:         switch(nemonicos[id_nemo].modo_op2)
        !           159:         {
        !           160:                        case LEIDOYESCRITO:             /* leido y escrito */
        !           161:                        contadorlecturas[id_simb]++;
        !           162:             case ESCRITO:                      /* escrito */
        !           163:                        contadorescrituras[id_simb]++;
        !           164:             break;
        !           165: 
        !           166:             case LEIDO:                                /* leido */
        !           167:                        contadorlecturas[id_simb]++;
        !           168:             break;
        !           169: 
        !           170:                        case NO_EXISTE:    /* no existe */
        !           171:                        /* emitir un error al fichero de log */
        !           172:                        sprintf(mensaje, "[ActualizarRecuentos] El operando no existe");
        !           173:                        Notificar(mensaje, ERROR_SALIR, ECO_NO);
        !           174:             break;
        !           175:         }
        !           176:        }
        !           177: 
        !           178:        /* aquí se puede hacer una función ya que el código es igual al anterior */
        !           179:        /* OP1 (DESTINO) si lo hay */
        !           180:        if(tarjetaoperandos->op1[0]!='\0')
        !           181:        {
        !           182:         strcpy(cadena, tarjetaoperandos->op1);
        !           183:         NormalizarUbicacion(cadena);
        !           184: 
        !           185:                id_simb = BDBuscarCadena(TABLA_SIMBOLOS, CAMPO_SIMBOLO, cadena);
        !           186: 
        !           187:                if(id_simb == -1)
        !           188:                {
        !           189:                        /* emito un error al fichero de log */ 
        !           190:                        sprintf(mensaje, "[ActualizarRecuentos] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena);
        !           191:                        Notificar(mensaje, ERROR_SALIR, ECO_NO);
        !           192:                }
        !           193: 
        !           194:                /* incremento el contador para el símbolo en cuestión según el tipo de acceso */
        !           195:         switch(nemonicos[id_nemo].modo_op1)
        !           196:         {
        !           197:                        case LEIDOYESCRITO:             /* leido y escrito */
        !           198:                        contadorlecturas[id_simb]++;
        !           199:             case ESCRITO:                      /* escrito */
        !           200:                        contadorescrituras[id_simb]++;
        !           201:             break;
        !           202: 
        !           203:             case LEIDO:                                /* leido */
        !           204:                        contadorlecturas[id_simb]++;
        !           205:             break;
        !           206: 
        !           207:                        case NO_EXISTE:    /* no existe */
        !           208:                        /* emitir un error al fichero de log */
        !           209:                        sprintf(mensaje, "[ActualizarRecuentos] El operando no existe");
        !           210:                        Notificar(mensaje, ERROR_SALIR, ECO_NO);
        !           211:             break;
        !           212:         }
        !           213:        }
        !           214:        /* los accesos a memoria se pueden contabilizar también bajo el nombre 'MEM' */
        !           215: }
        !           216: 
        !           217: 
        !           218: /* esta función libera la memoria reservada para los contadores */
        !           219: 
        !           220: void LiberarMemoriaContadores()
        !           221: {
        !           222:        free(contadornemonicos);
        !           223:        free(contadorlecturas);
        !           224:        free(contadorescrituras);
        !           225: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>