--- ADD_ver_10/Attic/AnalizadorOperandos16bits.c 2006/01/19 17:24:03 1.2 +++ ADD_ver_10/Attic/AnalizadorOperandos16bits.c 2006/02/15 15:07:53 1.3 @@ -30,27 +30,16 @@ /* */ /********************************************************************/ - /******************************************************************************/ -/** MÓDULO: AnalizadorOperandos16bits.c */ -/** */ -/** Este módulo analiza el uso de los operandos y construye una ficha de la */ -/** instrucción clasificando los operandos por su uso. */ -/** También calcula el número total de ciclos. */ +/* MÓDULO: AnalizadorOperandos16bits.c */ +/* */ +/* Este módulo analiza el uso de los operandos y construye una ficha de la */ +/* instrucción clasificando los operandos por su uso. */ +/* También calcula el número total de ciclos. */ /******************************************************************************/ -/** Fecha: 13 de junio de 2005 */ +/* Fecha: 13 de junio de 2005 */ /******************************************************************************/ - - -/**@file AnalizadorOperandos16bits.c - Este módulo contiene las funciones que permiten analizar dependencias - de datos entre instrucciones -*/ - -/**@author Sergio Alvarez Moreno -*/ - #include #include #include @@ -68,12 +57,8 @@ extern operando *simbolos; -/** -@brief Esta función convierte una cadena de operandos a una cadena normalizada - de posibles ubicaciones (sin desplazamientos ni valores inmediatos) - -@param *cadena: Cadena de caracteres que contienen operandos. -*/ +/* esta función convierte una cadena de operandos a una cadena normalizada */ +/* de posibles ubicaciones (sin desplazamientos ni valores inmediatos) */ void NormalizarUbicacion(char *cadena) { @@ -86,10 +71,10 @@ void NormalizarUbicacion(char *cadena) if(isxdigit(cadena[2])) strcpy(cadena, "[XXXX]"); /* es un desplazamiento absoluto */ else { - if(cadena[3]==']') cadena[4]='\0'; /* termino la cadena justo después aunque */ - else cadena[6]='\0'; /* pueda haber desplazamiento adicional */ + if(cadena[3]==']') cadena[4]='\0'; /* termino la cadena justo después aunque */ + else cadena[6]='\0'; /* pueda haber desplazamiento adicional */ } - break; + break; default: /* registros o valores (inmediatos o direcciones físicas) */ if(isxdigit(cadena[1])) /* es un número hexadecimal */ @@ -114,25 +99,19 @@ void NormalizarUbicacion(char *cadena) } -/** -@brief Esta función clasifica un operando explícito según su funcionalidad . - Las funciones de los operandos se dan en la base de datos de símbolos - se consideran independientes de la operación (lo cual no es cierto siempre) - -@param *operando: Operando el cual se va a clasificar -@param modo: Modo de funcionamiento del operando (LEIDOYESCRITO,LEIDO,NO_EXISTE) -@param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion -*/ +/* esta función clasifica un operando explícito según su funcionalidad */ +/* las funciones de los operandos se dan en la base de datos de símbolos */ +/* se consideran independientes de la operación (lo cual no es cierto siempre) */ void ClasificarOperandoExplicito(char *operando, char modo, fichainstruccion *tarjetaoperandos) { - int id_simb; - char cadena[MAX_LINE]; - char mensaje[MAX_LINE]; + int id_simb; + char cadena[MAX_LINE]; + char mensaje[MAX_LINE]; - strcpy(cadena, operando); + strcpy(cadena, operando); - if(cadena[0]!= '\0') + if(cadena[0]!= '\0') { NormalizarUbicacion(cadena); id_simb = BDBuscarCadena(TABLA_SIMBOLOS, CAMPO_SIMBOLO, cadena); @@ -140,12 +119,12 @@ void ClasificarOperandoExplicito(char *o if(id_simb == -1) { /* emito un error al fichero de log */ - sprintf(mensaje, "[ClasificarOperandoExplicito] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena); - Notificar(mensaje, ERROR_SALIR, ECO_NO); + sprintf(mensaje, "[ClasificarOperandoExplicito] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena); + Notificar(mensaje, ERROR_SALIR, ECO_NO); } /* relleno la tarjeta de operandos explícitos para el operando (cadena) */ - /* según la funcionalidad dada por el campo tipo */ + /* según la funcionalidad dada por el campo tipo */ switch(simbolos[id_simb].tipo) { @@ -166,8 +145,8 @@ void ClasificarOperandoExplicito(char *o break; case NO_EXISTE: /* no existe: emitir un error al fichero de log */ - sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe"); - Notificar(mensaje, ERROR_SALIR, ECO_NO); + sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe"); + Notificar(mensaje, ERROR_SALIR, ECO_NO); break; } break; @@ -186,8 +165,8 @@ void ClasificarOperandoExplicito(char *o break; case NO_EXISTE: /* no existe: emitir un error al fichero de log */ - sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe"); - Notificar(mensaje, ERROR_SALIR, ECO_NO); + sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe"); + Notificar(mensaje, ERROR_SALIR, ECO_NO); break; } break; @@ -206,28 +185,28 @@ void ClasificarOperandoExplicito(char *o break; case NO_EXISTE: /* no existe: emitir un error al fichero de log */ - sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe"); - Notificar(mensaje, ERROR_SALIR, ECO_NO); + sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe"); + Notificar(mensaje, ERROR_SALIR, ECO_NO); break; } break; case BANDERAS: /* nunca se dan explícitamente pero pueden ser considerados explícitos a través del nemónico */ - /* así se hará en la clasificación de implícitos */ + /* así se hará en la clasificación de implícitos */ break; - /* los 2 siguientes no representan realmente funciones */ + /* los 2 siguientes no representan realmente funciones */ case ACCESOS_MEM: /* accesos a memoria */ /* CÓMPUTO DE DIRECCIONES */ /* BASE: registro de segmento */ /* si hay prefijo de registro de segmento (longitud 2), ese es el leído */ if(strlen(tarjetaoperandos->prefijo)==2) - { - if(strcmp(tarjetaoperandos->prefijo, "SS") == 0) AgregarElementoLista(tarjetaoperandos->leidoexplpila, tarjetaoperandos->prefijo); - else AgregarElementoLista(tarjetaoperandos->leidoexpldir, tarjetaoperandos->prefijo); - } + { + if(strcmp(tarjetaoperandos->prefijo, "SS") == 0) AgregarElementoLista(tarjetaoperandos->leidoexplpila, tarjetaoperandos->prefijo); + else AgregarElementoLista(tarjetaoperandos->leidoexpldir, tarjetaoperandos->prefijo); + } /* si no lo hay, agrego el indicado por defecto */ else { @@ -252,97 +231,91 @@ void ClasificarOperandoExplicito(char *o } /* OFFSET: los registros involucrados en el cómputo de direcciones */ - /* siempre son leídos; la función depende de la BASE */ - if(strcmp(tarjetaoperandos->prefijo, "SS") == 0 || - simbolos[id_simb].segmento == SS) - AgregarElementoLista(tarjetaoperandos->leidoexplpila, simbolos[id_simb].dependencias); - else AgregarElementoLista(tarjetaoperandos->leidoexpldir, simbolos[id_simb].dependencias); + /* siempre son leídos; la función depende de la BASE */ + if(strcmp(tarjetaoperandos->prefijo, "SS") == 0 || + simbolos[id_simb].segmento == SS) + AgregarElementoLista(tarjetaoperandos->leidoexplpila, simbolos[id_simb].dependencias); + else AgregarElementoLista(tarjetaoperandos->leidoexpldir, simbolos[id_simb].dependencias); /* DATO */ - if(strcmp(tarjetaoperandos->prefijo, "SS") == 0 || simbolos[id_simb].segmento == SS) + if(strcmp(tarjetaoperandos->prefijo, "SS") == 0 || simbolos[id_simb].segmento == SS) + { + switch(modo) + { + case LEIDOYESCRITO: /* leido y escrito */ + AgregarElementoLista(tarjetaoperandos->leidoexplpila, "PILA"); + case ESCRITO: /* escrito */ + AgregarElementoLista(tarjetaoperandos->escritoexplpila, "PILA"); + break; + + case LEIDO: /* leido */ + AgregarElementoLista(tarjetaoperandos->leidoexplpila, "PILA"); + break; + + case NO_EXISTE: /* no existe: emitir un error al fichero de log */ + sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe"); + Notificar(mensaje, ERROR_SALIR, ECO_NO); + break; + } + } + else { - switch(modo) - { - case LEIDOYESCRITO: /* leido y escrito */ - AgregarElementoLista(tarjetaoperandos->leidoexplpila, "PILA"); - case ESCRITO: /* escrito */ - AgregarElementoLista(tarjetaoperandos->escritoexplpila, "PILA"); - break; - - case LEIDO: /* leido */ - AgregarElementoLista(tarjetaoperandos->leidoexplpila, "PILA"); - break; - - case NO_EXISTE: /* no existe: emitir un error al fichero de log */ - sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe"); - Notificar(mensaje, ERROR_SALIR, ECO_NO); - break; - } - } - else - { - switch(modo) - { - case LEIDOYESCRITO: /* leido y escrito */ - AgregarElementoLista(tarjetaoperandos->leidoexpldatos, "MEM"); - case ESCRITO: /* escrito */ - AgregarElementoLista(tarjetaoperandos->escritoexpldatos, "MEM"); - break; - - case LEIDO: /* leido */ - AgregarElementoLista(tarjetaoperandos->leidoexpldatos, "MEM"); - break; - - case NO_EXISTE: /* no existe: emitir un error al fichero de log */ - sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe"); - Notificar(mensaje, ERROR_SALIR, ECO_NO); - break; - } - break; + switch(modo) + { + case LEIDOYESCRITO: /* leido y escrito */ + AgregarElementoLista(tarjetaoperandos->leidoexpldatos, "MEM"); + case ESCRITO: /* escrito */ + AgregarElementoLista(tarjetaoperandos->escritoexpldatos, "MEM"); + break; + + case LEIDO: /* leido */ + AgregarElementoLista(tarjetaoperandos->leidoexpldatos, "MEM"); + break; + + case NO_EXISTE: /* no existe: emitir un error al fichero de log */ + sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe"); + Notificar(mensaje, ERROR_SALIR, ECO_NO); + break; + } + break; } break; case OTROS: - AgregarElementoLista(tarjetaoperandos->leidoexpldir, simbolos[id_simb].dependencias); + AgregarElementoLista(tarjetaoperandos->leidoexpldir, simbolos[id_simb].dependencias); break; default: - /* emitir un error al fichero de log */ - sprintf(mensaje, "[ClasificarOperandoExplicito] El tipo de símbolo no existe"); - Notificar(mensaje, ERROR_SALIR, ECO_NO); + /* emitir un error al fichero de log */ + sprintf(mensaje, "[ClasificarOperandoExplicito] El tipo de símbolo no existe"); + Notificar(mensaje, ERROR_SALIR, ECO_NO); break; } } } -/** -@brief Esta función clasifica un operando implícito leído según su funcionalidad - Las funciones de los operandos se dan en la base de datos de símbolos - se consideran independientes de la operación (lo cual no es cierto siempre) - -@param *cadena: Cadena de caracteres que contiene los operandos que se van a clasificar -@param tipo: tipo de operación que se va a realizar (SALTO_CONDICIONAL,CONTROL) -@param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion -*/ +/* esta función clasifica un operando implícito leído según su funcionalidad */ +/* las funciones de los operandos se dan en la base de datos de símbolos */ +/* se consideran independientes de la operación (lo cual no es cierto siempre) */ void ClasificarOperandoImplicitoLeido(char *cadena, char tipo, fichainstruccion *tarjetaoperandos) { - int id_simb; - char mensaje[MAX_LINE]; + int id_simb; + char mensaje[MAX_LINE]; - id_simb = BDBuscarCadena(TABLA_SIMBOLOS, CAMPO_SIMBOLO, cadena); + id_simb = BDBuscarCadena(TABLA_SIMBOLOS, CAMPO_SIMBOLO, cadena); - if(id_simb == -1) + if(id_simb == -1) { - /* emito un error al fichero de log */ - sprintf(mensaje, "[ClasificarOperandoImplicitoLeido] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena); - Notificar(mensaje, ERROR_SALIR, ECO_NO); + /* emito un error al fichero de log */ + sprintf(mensaje, "[ClasificarOperandoImplicitoLeido] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena); + Notificar(mensaje, ERROR_SALIR, ECO_NO); } switch(simbolos[id_simb].tipo) { - case DATOS: + case DATOS: AgregarElementoLista(tarjetaoperandos->leidoimpldatos, simbolos[id_simb].simbolo); AgregarElementoLista(tarjetaoperandos->leidoimpldatos, simbolos[id_simb].dependencias); break; @@ -357,52 +330,46 @@ void ClasificarOperandoImplicitoLeido(ch case BANDERAS: if(tipo == SALTO_CONDICIONAL || tipo == CONTROL) - /* los saltos condicionales y las operaciones sobre banderas */ - /* pueden ser considerados explícitos a través del nemónico */ - AgregarElementoLista(tarjetaoperandos->leidoexplestado, simbolos[id_simb].simbolo); + /* los saltos condicionales y las operaciones sobre banderas */ + /* pueden ser considerados explícitos a través del nemónico */ + AgregarElementoLista(tarjetaoperandos->leidoexplestado, simbolos[id_simb].simbolo); else AgregarElementoLista(tarjetaoperandos->leidoimplestado, simbolos[id_simb].simbolo); break; - default: /* emitir un error al fichero de log */ - sprintf(mensaje, "[ClasificarOperandoImplicitoLeido] El tipo de símbolo no existe"); - Notificar(mensaje, ERROR_SALIR, ECO_NO); - break; - } + default: /* emitir un error al fichero de log */ + sprintf(mensaje, "[ClasificarOperandoImplicitoLeido] El tipo de símbolo no existe"); + Notificar(mensaje, ERROR_SALIR, ECO_NO); + break; + } } -/** -@brief Esta función clasifica un operando implícito escrito según su funcionalidad - Las funciones de los operandos se dan en la base de datos de símbolos - se consideran independientes de la operación (lo cual no es cierto siempre) - -@param *cadena: Cadena de caracteres que contiene los operandos que se van a clasificar -@param tipo: tipo de operación que se va a realizar (SALTO_CONDICIONAL,CONTROL) -@param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion -*/ +/* esta función clasifica un operando implícito escrito según su funcionalidad */ +/* las funciones de los operandos se dan en la base de datos de símbolos */ +/* se consideran independientes de la operación (lo cual no es cierto siempre) */ void ClasificarOperandoImplicitoEscrito(char *cadena, char tipo, fichainstruccion *tarjetaoperandos) { - int id_simb; - char mensaje[MAX_LINE]; + int id_simb; + char mensaje[MAX_LINE]; - id_simb = BDBuscarCadena(TABLA_SIMBOLOS, CAMPO_SIMBOLO, cadena); + id_simb = BDBuscarCadena(TABLA_SIMBOLOS, CAMPO_SIMBOLO, cadena); if(id_simb == -1) { - /* emito un error al fichero de log */ - sprintf(mensaje, "[ClasificarOperandoImplicitoEscrito] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena); - Notificar(mensaje, ERROR_SALIR, ECO_NO); + /* emito un error al fichero de log */ + sprintf(mensaje, "[ClasificarOperandoImplicitoEscrito] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena); + Notificar(mensaje, ERROR_SALIR, ECO_NO); } switch(simbolos[id_simb].tipo) { - case DATOS: + case DATOS: AgregarElementoLista(tarjetaoperandos->escritoimpldatos, simbolos[id_simb].simbolo); AgregarElementoLista(tarjetaoperandos->escritoimpldatos, simbolos[id_simb].dependencias); break; - case PTR_MEM: + case PTR_MEM: AgregarElementoLista(tarjetaoperandos->escritoimpldir, simbolos[id_simb].simbolo); break; @@ -410,31 +377,26 @@ void ClasificarOperandoImplicitoEscrito( AgregarElementoLista(tarjetaoperandos->escritoimplpila, simbolos[id_simb].simbolo); break; - case BANDERAS: + case BANDERAS: if(tipo == SALTO_CONDICIONAL || tipo == CONTROL) - /* los saltos condicionales y las operaciones sobre banderas */ - /* pueden ser considerados explícitos a través del nemónico */ + /* los saltos condicionales y las operaciones sobre banderas */ + /* pueden ser considerados explícitos a través del nemónico */ AgregarElementoLista(tarjetaoperandos->escritoexplestado, simbolos[id_simb].simbolo); else AgregarElementoLista(tarjetaoperandos->escritoimplestado, simbolos[id_simb].simbolo); break; - default: /* emitir un error al fichero de log */ - sprintf(mensaje, "[ClasificarOperandoImplicitoEscrito] El tipo de símbolo no existe"); - Notificar(mensaje, ERROR_SALIR, ECO_NO); - break; - } + default: /* emitir un error al fichero de log */ + sprintf(mensaje, "[ClasificarOperandoImplicitoEscrito] El tipo de símbolo no existe"); + Notificar(mensaje, ERROR_SALIR, ECO_NO); + break; + } } -/** -@brief Esta función desensambla una instrucción a partir de una secuencia de bytes - Extrae información a partir del nemónico. - Clasifica el uso de los operandos explícitos según su función - Clasifica el uso de los operandos implícitos según su función - -@param secuencia: Array con 2 posibles ormatos de instrucción: la que hay que desensamblar. ¡OJO! En realidad cada formato debería tener 7 bytes para prevenir el uso de prefijos -@param *tarjetaoperandos: Puntero a una estructura del tipo fichainstruccion -*/ +/* esta función desensambla una instrucción a partir de una secuencia de bytes */ +/* extrae información a partir del nemónico */ +/* clasifica el uso de los operandos explícitos según su función */ +/* clasifica el uso de los operandos implícitos según su función */ void AnalizarOperandosIA16(unsigned char secuencia[12], fichainstruccion *tarjetaoperandos) { @@ -450,10 +412,10 @@ void AnalizarOperandosIA16(unsigned char int id_nemo; char cadena[MAX_LINE]; /* esto es un array de caracteres; cadena[x] es un puntero */ char *elemento; /* es un puntero a char; no es igual a cadena[x] para la función strtok */ - char mensaje[MAX_LINE]; + char mensaje[MAX_LINE]; /* inicio la tarjeta de operandos */ - IniciarTarjeta(tarjetaoperandos); + IniciarTarjeta(tarjetaoperandos); /* cargo la primera instrucción desde la secuencia */ @@ -470,8 +432,8 @@ void AnalizarOperandosIA16(unsigned char if(id_nemo == -1) { /* emito un error al fichero de log */ - sprintf(mensaje, "[AnalizarOperandosIA16] La cadena '%s' no se ha encontrado en Tabla Nemónicos", instruccion.nemonico); - Notificar(mensaje, ERROR_SALIR, ECO_NO); + sprintf(mensaje, "[AnalizarOperandosIA16] La cadena '%s' no se ha encontrado en Tabla Nemónicos", instruccion.nemonico); + Notificar(mensaje, ERROR_SALIR, ECO_NO); } /* salvo la información en la estructura de la ficha de instrucción */ @@ -554,8 +516,8 @@ void AnalizarOperandosIA16(unsigned char if(id_nemo == -1) { /* emito un error al fichero de log */ - sprintf(mensaje, "[AnalizarOperandosIA16] La cadena '%s' no se ha encontrado en Tabla Nemónicos", instruccion.nemonico); - Notificar(mensaje, ERROR_SALIR, ECO_NO); + sprintf(mensaje, "[AnalizarOperandosIA16] La cadena '%s' no se ha encontrado en Tabla Nemónicos", instruccion.nemonico); + Notificar(mensaje, ERROR_SALIR, ECO_NO); } break; @@ -575,34 +537,34 @@ void AnalizarOperandosIA16(unsigned char /* SEGUNDO: operandos explícitos */ /* operando fuente (op2) */ - ClasificarOperandoExplicito(tarjetaoperandos->op2, nemonicos[id_nemo].modo_op2, tarjetaoperandos); + ClasificarOperandoExplicito(tarjetaoperandos->op2, nemonicos[id_nemo].modo_op2, tarjetaoperandos); - /* operando destino (op1) */ - ClasificarOperandoExplicito(tarjetaoperandos->op1, nemonicos[id_nemo].modo_op1, tarjetaoperandos); + /* operando destino (op1) */ + ClasificarOperandoExplicito(tarjetaoperandos->op1, nemonicos[id_nemo].modo_op1, tarjetaoperandos); /* TERCERO: operandos implícitos */ /* analizo la lista de implícitos leídos */ /* copio la información de la BD para no modificarla */ - strcpy(cadena, nemonicos[id_nemo].implicitos_leidos); + strcpy(cadena, nemonicos[id_nemo].implicitos_leidos); - elemento = strtok(cadena, ":"); /* el separador de elementos de la lista es ':' */ + elemento = strtok(cadena, ":"); /* el separador de elementos de la lista es ':' */ while(elemento != NULL) { - ClasificarOperandoImplicitoLeido(elemento, nemonicos[id_nemo].tipo, tarjetaoperandos); - + ClasificarOperandoImplicitoLeido(elemento, nemonicos[id_nemo].tipo, tarjetaoperandos); + /* capturo el siguiente campo */ elemento = strtok(NULL, ":"); } /* analizo la lista de implícitos escritos */ /* copio la información de la BD para no modificarla */ - strcpy(cadena, nemonicos[id_nemo].implicitos_escritos); + strcpy(cadena, nemonicos[id_nemo].implicitos_escritos); - elemento = strtok(cadena, ":"); /* el separador de elementos de la lista es ':' */ + elemento = strtok(cadena, ":"); /* el separador de elementos de la lista es ':' */ while(elemento != NULL) { - ClasificarOperandoImplicitoEscrito(elemento, nemonicos[id_nemo].tipo, tarjetaoperandos); + ClasificarOperandoImplicitoEscrito(elemento, nemonicos[id_nemo].tipo, tarjetaoperandos); /* capturo el siguiente campo */ elemento = strtok(NULL, ":");