[BACK]Return to AnalizadorOperandos16bits.c CVS log [TXT] [DIR] Up to [Repository ATC2] / ADD_ver_10

Diff for /ADD_ver_10/Attic/AnalizadorOperandos16bits.c between versions 1.2 and 1.3

version 1.2, 2006/01/19 17:24:03 version 1.3, 2006/02/15 15:07:53
Line 30 Line 30
 /*                                                                  */  /*                                                                  */
 /********************************************************************/  /********************************************************************/
   
   
 /******************************************************************************/  /******************************************************************************/
 /** MÓDULO: AnalizadorOperandos16bits.c                                        */  /* MÓDULO: AnalizadorOperandos16bits.c                                        */
 /**                                                                            */  /*                                                                            */
 /** Este módulo analiza el uso de los operandos y construye una ficha de la    */  /* Este módulo analiza el uso de los operandos y construye una ficha de la    */
 /** instrucción clasificando los operandos por su uso.                         */  /* instrucción clasificando los operandos por su uso.                         */
 /** También calcula el número total de ciclos.                                 */  /* 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 <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
Line 68  extern operando *simbolos; Line 57  extern operando *simbolos;
   
   
   
 /**   /* esta función convierte una cadena de operandos a una cadena normalizada */
 @brief Esta función convierte una cadena de operandos a una cadena normalizada   /* de posibles ubicaciones (sin desplazamientos ni valores inmediatos) */
        de posibles ubicaciones (sin desplazamientos ni valores inmediatos)   
          
 @param *cadena: Cadena de caracteres que contienen operandos.  
 */  
   
 void NormalizarUbicacion(char *cadena)  void NormalizarUbicacion(char *cadena)
 {  {
Line 86  void NormalizarUbicacion(char *cadena) Line 71  void NormalizarUbicacion(char *cadena)
         if(isxdigit(cadena[2])) strcpy(cadena, "[XXXX]");    /* es un desplazamiento absoluto */          if(isxdigit(cadena[2])) strcpy(cadena, "[XXXX]");    /* es un desplazamiento absoluto */
         else          else
         {          {
                         if(cadena[3]==']') cadena[4]='\0';      /* termino la cadena justo después aunque */              if(cadena[3]==']') cadena[4]='\0';    /* termino la cadena justo después aunque */
                         else cadena[6]='\0';                            /* pueda haber desplazamiento adicional */              else cadena[6]='\0';                /* pueda haber desplazamiento adicional */
         }          }
                 break;          break;
   
         default:    /* registros o valores (inmediatos o direcciones físicas) */          default:    /* registros o valores (inmediatos o direcciones físicas) */
         if(isxdigit(cadena[1]))    /* es un número hexadecimal */          if(isxdigit(cadena[1]))    /* es un número hexadecimal */
Line 114  void NormalizarUbicacion(char *cadena) Line 99  void NormalizarUbicacion(char *cadena)
 }  }
   
   
 /**   /* esta función clasifica un operando explícito según su funcionalidad */
 @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 */
        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) */
        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  
 */  
   
 void ClasificarOperandoExplicito(char *operando, char modo, fichainstruccion *tarjetaoperandos)  void ClasificarOperandoExplicito(char *operando, char modo, fichainstruccion *tarjetaoperandos)
 {  {
         int id_simb;      int id_simb;
         char cadena[MAX_LINE];      char cadena[MAX_LINE];
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
   
         strcpy(cadena, operando);      strcpy(cadena, operando);
   
         if(cadena[0]!= '\0')      if(cadena[0]!= '\0')
     {      {
         NormalizarUbicacion(cadena);          NormalizarUbicacion(cadena);
         id_simb = BDBuscarCadena(TABLA_SIMBOLOS, CAMPO_SIMBOLO, cadena);          id_simb = BDBuscarCadena(TABLA_SIMBOLOS, CAMPO_SIMBOLO, cadena);
Line 140  void ClasificarOperandoExplicito(char *o Line 119  void ClasificarOperandoExplicito(char *o
         if(id_simb == -1)          if(id_simb == -1)
         {          {
             /* emito un error al fichero de log */               /* emito un error al fichero de log */ 
                         sprintf(mensaje, "[ClasificarOperandoExplicito] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena);              sprintf(mensaje, "[ClasificarOperandoExplicito] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena);
                         Notificar(mensaje, ERROR_SALIR, ECO_NO);              Notificar(mensaje, ERROR_SALIR, ECO_NO);
         }          }
   
         /* relleno la tarjeta de operandos explícitos para el operando (cadena) */          /* 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)          switch(simbolos[id_simb].tipo)
         {          {
Line 166  void ClasificarOperandoExplicito(char *o Line 145  void ClasificarOperandoExplicito(char *o
                 break;                  break;
   
                 case NO_EXISTE:    /* no existe: emitir un error al fichero de log */                  case NO_EXISTE:    /* no existe: emitir un error al fichero de log */
                                 sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe");                  sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe");
                                 Notificar(mensaje, ERROR_SALIR, ECO_NO);                  Notificar(mensaje, ERROR_SALIR, ECO_NO);
                 break;                  break;
             }              }
             break;              break;
Line 186  void ClasificarOperandoExplicito(char *o Line 165  void ClasificarOperandoExplicito(char *o
                 break;                  break;
   
                 case NO_EXISTE:    /* no existe: emitir un error al fichero de log */                  case NO_EXISTE:    /* no existe: emitir un error al fichero de log */
                                 sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe");                  sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe");
                                 Notificar(mensaje, ERROR_SALIR, ECO_NO);                  Notificar(mensaje, ERROR_SALIR, ECO_NO);
                 break;                  break;
             }              }
             break;              break;
Line 206  void ClasificarOperandoExplicito(char *o Line 185  void ClasificarOperandoExplicito(char *o
                 break;                  break;
   
                 case NO_EXISTE:    /* no existe: emitir un error al fichero de log */                  case NO_EXISTE:    /* no existe: emitir un error al fichero de log */
                                 sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe");                  sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe");
                                 Notificar(mensaje, ERROR_SALIR, ECO_NO);                  Notificar(mensaje, ERROR_SALIR, ECO_NO);
                 break;                  break;
             }              }
             break;              break;
   
             case BANDERAS:              case BANDERAS:
             /* nunca se dan explícitamente pero pueden ser considerados explícitos a través del nemónico */              /* 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;              break;
   
                         /* los 2 siguientes no representan realmente funciones */              /* los 2 siguientes no representan realmente funciones */
   
             case ACCESOS_MEM:    /* accesos a memoria */              case ACCESOS_MEM:    /* accesos a memoria */
             /* CÓMPUTO DE DIRECCIONES */              /* CÓMPUTO DE DIRECCIONES */
             /* BASE: registro de segmento */              /* BASE: registro de segmento */
             /* si hay prefijo de registro de segmento (longitud 2), ese es el leído */              /* si hay prefijo de registro de segmento (longitud 2), ese es el leído */
             if(strlen(tarjetaoperandos->prefijo)==2)              if(strlen(tarjetaoperandos->prefijo)==2)
                         {              {
                                 if(strcmp(tarjetaoperandos->prefijo, "SS") == 0) AgregarElementoLista(tarjetaoperandos->leidoexplpila, tarjetaoperandos->prefijo);                  if(strcmp(tarjetaoperandos->prefijo, "SS") == 0) AgregarElementoLista(tarjetaoperandos->leidoexplpila, tarjetaoperandos->prefijo);
                                 else AgregarElementoLista(tarjetaoperandos->leidoexpldir, tarjetaoperandos->prefijo);                  else AgregarElementoLista(tarjetaoperandos->leidoexpldir, tarjetaoperandos->prefijo);
                         }              }
             /* si no lo hay, agrego el indicado por defecto */              /* si no lo hay, agrego el indicado por defecto */
             else              else
             {              {
Line 252  void ClasificarOperandoExplicito(char *o Line 231  void ClasificarOperandoExplicito(char *o
             }              }
   
             /* OFFSET: los registros involucrados en el cómputo de direcciones */              /* OFFSET: los registros involucrados en el cómputo de direcciones */
                         /* siempre son leídos; la función depende de la BASE */              /* siempre son leídos; la función depende de la BASE */
                         if(strcmp(tarjetaoperandos->prefijo, "SS") == 0 ||              if(strcmp(tarjetaoperandos->prefijo, "SS") == 0 ||
                                 simbolos[id_simb].segmento == SS)                  simbolos[id_simb].segmento == SS)
                                 AgregarElementoLista(tarjetaoperandos->leidoexplpila, simbolos[id_simb].dependencias);                  AgregarElementoLista(tarjetaoperandos->leidoexplpila, simbolos[id_simb].dependencias);
                         else AgregarElementoLista(tarjetaoperandos->leidoexpldir, simbolos[id_simb].dependencias);              else AgregarElementoLista(tarjetaoperandos->leidoexpldir, simbolos[id_simb].dependencias);
   
             /* DATO */              /* 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)                  switch(modo)
                                 {                  {
                                         case LEIDOYESCRITO:    /* leido y escrito */                      case LEIDOYESCRITO:    /* leido y escrito */
                             AgregarElementoLista(tarjetaoperandos->leidoexplpila, "PILA");                      AgregarElementoLista(tarjetaoperandos->leidoexpldatos, "MEM");
                                     case ESCRITO:    /* escrito */                      case ESCRITO:    /* escrito */
                                         AgregarElementoLista(tarjetaoperandos->escritoexplpila, "PILA");                      AgregarElementoLista(tarjetaoperandos->escritoexpldatos, "MEM");
                                         break;                      break;
   
                             case LEIDO:    /* leido */                      case LEIDO:    /* leido */
                                     AgregarElementoLista(tarjetaoperandos->leidoexplpila, "PILA");                      AgregarElementoLista(tarjetaoperandos->leidoexpldatos, "MEM");
                                         break;                      break;
   
                             case NO_EXISTE:    /* no existe: emitir un error al fichero de log */                      case NO_EXISTE:    /* no existe: emitir un error al fichero de log */
                                         sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe");                      sprintf(mensaje, "[ClasificarOperandoExplicito] El operando no existe");
                                         Notificar(mensaje, ERROR_SALIR, ECO_NO);                      Notificar(mensaje, ERROR_SALIR, ECO_NO);
                                     break;                      break;
                                 }                  }
                         }                  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;  
             }              }
             break;              break;
   
             case OTROS:              case OTROS:
                         AgregarElementoLista(tarjetaoperandos->leidoexpldir, simbolos[id_simb].dependencias);              AgregarElementoLista(tarjetaoperandos->leidoexpldir, simbolos[id_simb].dependencias);
             break;              break;
   
             default:              default:
                         /* emitir un error al fichero de log */              /* emitir un error al fichero de log */
                         sprintf(mensaje, "[ClasificarOperandoExplicito] El tipo de símbolo no existe");              sprintf(mensaje, "[ClasificarOperandoExplicito] El tipo de símbolo no existe");
                         Notificar(mensaje, ERROR_SALIR, ECO_NO);              Notificar(mensaje, ERROR_SALIR, ECO_NO);
             break;              break;
         }          }
     }      }
 }  }
   
   
 /**   /* esta función clasifica un operando implícito leído según su funcionalidad */
 @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 */
        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) */
        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   
 */  
   
 void ClasificarOperandoImplicitoLeido(char *cadena, char tipo, fichainstruccion *tarjetaoperandos)  void ClasificarOperandoImplicitoLeido(char *cadena, char tipo, fichainstruccion *tarjetaoperandos)
 {  {
         int id_simb;      int id_simb;
         char mensaje[MAX_LINE];      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 */           /* emito un error al fichero de log */ 
                 sprintf(mensaje, "[ClasificarOperandoImplicitoLeido] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena);          sprintf(mensaje, "[ClasificarOperandoImplicitoLeido] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena);
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
     }      }
   
     switch(simbolos[id_simb].tipo)      switch(simbolos[id_simb].tipo)
     {      {
                 case DATOS:          case DATOS:
         AgregarElementoLista(tarjetaoperandos->leidoimpldatos, simbolos[id_simb].simbolo);          AgregarElementoLista(tarjetaoperandos->leidoimpldatos, simbolos[id_simb].simbolo);
         AgregarElementoLista(tarjetaoperandos->leidoimpldatos, simbolos[id_simb].dependencias);          AgregarElementoLista(tarjetaoperandos->leidoimpldatos, simbolos[id_simb].dependencias);
         break;          break;
Line 357  void ClasificarOperandoImplicitoLeido(ch Line 330  void ClasificarOperandoImplicitoLeido(ch
   
         case BANDERAS:          case BANDERAS:
         if(tipo == SALTO_CONDICIONAL || tipo == CONTROL)          if(tipo == SALTO_CONDICIONAL || tipo == CONTROL)
                         /* los saltos condicionales y las operaciones sobre banderas */              /* los saltos condicionales y las operaciones sobre banderas */
                         /* pueden ser considerados explícitos a través del nemónico */              /* pueden ser considerados explícitos a través del nemónico */
                         AgregarElementoLista(tarjetaoperandos->leidoexplestado, simbolos[id_simb].simbolo);              AgregarElementoLista(tarjetaoperandos->leidoexplestado, simbolos[id_simb].simbolo);
         else AgregarElementoLista(tarjetaoperandos->leidoimplestado, simbolos[id_simb].simbolo);          else AgregarElementoLista(tarjetaoperandos->leidoimplestado, simbolos[id_simb].simbolo);
         break;          break;
   
         default:        /* emitir un error al fichero de log */          default:    /* emitir un error al fichero de log */
                 sprintf(mensaje, "[ClasificarOperandoImplicitoLeido] El tipo de símbolo no existe");          sprintf(mensaje, "[ClasificarOperandoImplicitoLeido] El tipo de símbolo no existe");
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
                 break;          break;
         }      }
 }  }
   
   
 /**   /* esta función clasifica un operando implícito escrito según su funcionalidad */
 @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 */
        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) */
        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   
 */  
   
 void ClasificarOperandoImplicitoEscrito(char *cadena, char tipo, fichainstruccion *tarjetaoperandos)  void ClasificarOperandoImplicitoEscrito(char *cadena, char tipo, fichainstruccion *tarjetaoperandos)
 {  {
         int id_simb;      int id_simb;
         char mensaje[MAX_LINE];      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 */           /* emito un error al fichero de log */ 
                 sprintf(mensaje, "[ClasificarOperandoImplicitoEscrito] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena);          sprintf(mensaje, "[ClasificarOperandoImplicitoEscrito] La cadena '%s' no se ha encontrado en Tabla Símbolos", cadena);
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
     }      }
   
     switch(simbolos[id_simb].tipo)      switch(simbolos[id_simb].tipo)
     {      {
                 case DATOS:          case DATOS:
         AgregarElementoLista(tarjetaoperandos->escritoimpldatos, simbolos[id_simb].simbolo);          AgregarElementoLista(tarjetaoperandos->escritoimpldatos, simbolos[id_simb].simbolo);
         AgregarElementoLista(tarjetaoperandos->escritoimpldatos, simbolos[id_simb].dependencias);          AgregarElementoLista(tarjetaoperandos->escritoimpldatos, simbolos[id_simb].dependencias);
         break;          break;
   
                 case PTR_MEM:          case PTR_MEM:
         AgregarElementoLista(tarjetaoperandos->escritoimpldir, simbolos[id_simb].simbolo);          AgregarElementoLista(tarjetaoperandos->escritoimpldir, simbolos[id_simb].simbolo);
         break;          break;
   
Line 410  void ClasificarOperandoImplicitoEscrito( Line 377  void ClasificarOperandoImplicitoEscrito(
         AgregarElementoLista(tarjetaoperandos->escritoimplpila, simbolos[id_simb].simbolo);          AgregarElementoLista(tarjetaoperandos->escritoimplpila, simbolos[id_simb].simbolo);
         break;          break;
   
                 case BANDERAS:          case BANDERAS:
         if(tipo == SALTO_CONDICIONAL || tipo == CONTROL)          if(tipo == SALTO_CONDICIONAL || tipo == CONTROL)
                         /* los saltos condicionales y las operaciones sobre banderas */              /* los saltos condicionales y las operaciones sobre banderas */
                         /* pueden ser considerados explícitos a través del nemónico */              /* pueden ser considerados explícitos a través del nemónico */
             AgregarElementoLista(tarjetaoperandos->escritoexplestado, simbolos[id_simb].simbolo);              AgregarElementoLista(tarjetaoperandos->escritoexplestado, simbolos[id_simb].simbolo);
         else AgregarElementoLista(tarjetaoperandos->escritoimplestado, simbolos[id_simb].simbolo);          else AgregarElementoLista(tarjetaoperandos->escritoimplestado, simbolos[id_simb].simbolo);
         break;          break;
   
         default:        /* emitir un error al fichero de log */          default:    /* emitir un error al fichero de log */
                 sprintf(mensaje, "[ClasificarOperandoImplicitoEscrito] El tipo de símbolo no existe");          sprintf(mensaje, "[ClasificarOperandoImplicitoEscrito] El tipo de símbolo no existe");
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
                 break;          break;
         }      }
 }  }
   
   
 /**   /* esta función desensambla una instrucción a partir de una secuencia de bytes */
 @brief Esta función desensambla una instrucción a partir de una secuencia de bytes   /* extrae información a partir del nemónico */
        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 explícitos según su función   /* clasifica el uso de los operandos implí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   
 */  
   
 void AnalizarOperandosIA16(unsigned char secuencia[12], fichainstruccion *tarjetaoperandos)  void AnalizarOperandosIA16(unsigned char secuencia[12], fichainstruccion *tarjetaoperandos)
 {  {
Line 450  void AnalizarOperandosIA16(unsigned char Line 412  void AnalizarOperandosIA16(unsigned char
     int id_nemo;      int id_nemo;
     char cadena[MAX_LINE];    /* esto es un array de caracteres; cadena[x] es un puntero */      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 *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 */      /* inicio la tarjeta de operandos */
         IniciarTarjeta(tarjetaoperandos);      IniciarTarjeta(tarjetaoperandos);
   
     /* cargo la primera instrucción desde la secuencia */      /* cargo la primera instrucción desde la secuencia */
   
Line 470  void AnalizarOperandosIA16(unsigned char Line 432  void AnalizarOperandosIA16(unsigned char
     if(id_nemo == -1)      if(id_nemo == -1)
     {      {
         /* emito un error al fichero de log */           /* emito un error al fichero de log */ 
                 sprintf(mensaje, "[AnalizarOperandosIA16] La cadena '%s' no se ha encontrado en Tabla Nemónicos", instruccion.nemonico);          sprintf(mensaje, "[AnalizarOperandosIA16] La cadena '%s' no se ha encontrado en Tabla Nemónicos", instruccion.nemonico);
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
     }      }
   
     /* salvo la información en la estructura de la ficha de instrucción */      /* salvo la información en la estructura de la ficha de instrucción */
Line 554  void AnalizarOperandosIA16(unsigned char Line 516  void AnalizarOperandosIA16(unsigned char
         if(id_nemo == -1)          if(id_nemo == -1)
         {          {
             /* emito un error al fichero de log */               /* emito un error al fichero de log */ 
                         sprintf(mensaje, "[AnalizarOperandosIA16] La cadena '%s' no se ha encontrado en Tabla Nemónicos", instruccion.nemonico);              sprintf(mensaje, "[AnalizarOperandosIA16] La cadena '%s' no se ha encontrado en Tabla Nemónicos", instruccion.nemonico);
                         Notificar(mensaje, ERROR_SALIR, ECO_NO);              Notificar(mensaje, ERROR_SALIR, ECO_NO);
         }          }
         break;          break;
   
Line 575  void AnalizarOperandosIA16(unsigned char Line 537  void AnalizarOperandosIA16(unsigned char
   
     /* SEGUNDO: operandos explícitos */      /* SEGUNDO: operandos explícitos */
     /* operando fuente (op2) */      /* operando fuente (op2) */
         ClasificarOperandoExplicito(tarjetaoperandos->op2, nemonicos[id_nemo].modo_op2, tarjetaoperandos);      ClasificarOperandoExplicito(tarjetaoperandos->op2, nemonicos[id_nemo].modo_op2, tarjetaoperandos);
           
         /* operando destino (op1) */      /* operando destino (op1) */
         ClasificarOperandoExplicito(tarjetaoperandos->op1, nemonicos[id_nemo].modo_op1, tarjetaoperandos);      ClasificarOperandoExplicito(tarjetaoperandos->op1, nemonicos[id_nemo].modo_op1, tarjetaoperandos);
           
   
     /* TERCERO: operandos implícitos */      /* TERCERO: operandos implícitos */
     /* analizo la lista de implícitos leídos */      /* analizo la lista de implícitos leídos */
     /* copio la información de la BD para no modificarla */      /* 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)      while(elemento != NULL)
     {      {
                 ClasificarOperandoImplicitoLeido(elemento, nemonicos[id_nemo].tipo, tarjetaoperandos);          ClasificarOperandoImplicitoLeido(elemento, nemonicos[id_nemo].tipo, tarjetaoperandos);
                           
         /* capturo el siguiente campo */          /* capturo el siguiente campo */
         elemento = strtok(NULL, ":");          elemento = strtok(NULL, ":");
     }      }
   
     /* analizo la lista de implícitos escritos */      /* analizo la lista de implícitos escritos */
     /* copio la información de la BD para no modificarla */      /* 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)      while(elemento != NULL)
     {      {
                 ClasificarOperandoImplicitoEscrito(elemento, nemonicos[id_nemo].tipo, tarjetaoperandos);          ClasificarOperandoImplicitoEscrito(elemento, nemonicos[id_nemo].tipo, tarjetaoperandos);
   
         /* capturo el siguiente campo */          /* capturo el siguiente campo */
         elemento = strtok(NULL, ":");          elemento = strtok(NULL, ":");
Removed from v.1.2  
changed lines
  Added in v.1.3

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