problema con archivo de texto

[m@o_614]

Saludos tengo el siguiente archivo de texto que dice:

;ejemplo con errores
Et12_xyz123     ADCA      1,PC
%ET3        LDAA      #$90
Netq%23        RMB      556
etv1
XYZ        Ldaaxyz   4
        %XYZ
        a.c.      %1111000
Abc        SWI%

y el codigo me tiene que imprimir esto

COMENTARIO

ETIQUETA = Et12_xyz123
CODOP =ADCA
OPERANDO = 1,PC
.....
....
....

y asi con todas las lineas, pero me imprime

COMENTARIO

NO SE ENCONTRO CODOP

y no entiendo por que imprime esto ultimo si solo en las lineas que no son comentarios me tiene que verificar si se encontro el codop o no

el codigo es este:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define LONG_ETIQUETA 8
#define LONG_CODOP 5
#define COMENTARIO ';'
#define TABULADOR '\t'
#define ESPACIOS_ ' '
#define MAX 8
#define MAXIMO 40

typedef enum {FALSO,VERDADERO} booleano;
typedef enum {ETIQUETA,CODOP,OPERANDO} linea;
typedef enum {INS,OP,DIR,MAQ,CALCULADO,CALCULAR,TOTAL} tabla;

typedef struct nodo
{
   char *instruccion;
   char *operando;
   char **modo_direccionamiento;
   char **codigo_maquina;
   char **bytes_calculados;
   char **bytes_x_calcular;
   char **suma_bytes;
   int tipo_linea;
   struct nodo *sig;
}COD;

void imprimirInfo(COD *p);
int verificarCombinacion(FILE *fd);
booleano esComentario(FILE *fd);
char *Etiqueta_Codop_Operando(FILE *fd,int linea);
char *_Codop_Operando(FILE *fd,int linea);
void ultimaLinea(char *codop);
void erroresEtiqueta(char *etiqueta);
void erroresCodop(char *codop);
void buscarFinLinea(FILE *fd);
void ignorarEspacios(FILE *fd);
void listaTABOP(COD **cabeza);
COD *ultimoElemento(COD **cabeza);
COD *crearNodo(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,int n);
void insertarFinal(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,COD *ultimo,int n);
char *Tabla_Operandos(FILE *hc12,int tabla);
COD *buscarCodop(COD *cabeza,char *codop);
void quitarSaltosLinea(char *cadena);
booleano esNumero(char caracter);
booleano esLetra(char caracter);
void verificarOperando(COD *encontrado,char *operando);

int main()
{
   FILE *fd;
   int car,combinacion;
   COD *cabeza = NULL,*encontrado = NULL;
   char nombre[MAXIMO],archivo[MAXIMO],respuesta,*etiqueta,*codop,*operando;
   listaTABOP(&cabeza);
   do
   {
       printf("\nQue archivo quieres abrir: ");
       fgets(nombre,sizeof(nombre),stdin);
       quitarSaltosLinea(nombre);
       sprintf(archivo,"%s.txt",nombre);
       if((fd = fopen(archivo,"r"))!= NULL)
       {
           while((car = fgetc(fd))!= EOF)
           {
               switch(car)
               {
                   case COMENTARIO:
                      if(esComentario(fd))
                         printf("COMENTARIO\n\n");
                      else
                         buscarFinLinea(fd);
                      break;
                   case ESPACIOS_:
                   case TABULADOR:
                      etiqueta = "null";
                      printf("ETIQUETA = %s\n",etiqueta);
                      ignorarEspacios(fd);
                      codop = Etiqueta_Codop_Operando(fd,CODOP);
                      printf("CODOP = %s\n",codop);
                      erroresCodop(codop);
                      combinacion = verificarCombinacion(fd);
                      if(combinacion == 2)
                      {
                          operando = "null";
                          printf("OPERANDO = %s\n\n",operando);
                      }
                      else
                      {
                          ignorarEspacios(fd);
                          operando = Etiqueta_Codop_Operando(fd,OPERANDO);
                          printf("OPERANDO = %s\n\n",operando);
                      }
                      break;
                   default:
                      etiqueta = Etiqueta_Codop_Operando(fd,ETIQUETA);
                      printf("ETIQUETA = %s\n",etiqueta);
                      erroresEtiqueta(etiqueta);
                      combinacion = verificarCombinacion(fd);
                      if(combinacion == 2)
                      {
                          codop = "null";
                          printf("CODOP = %s\n",codop);
                          erroresCodop(codop);
                          operando = "null";
                          printf("OPERANDO = %s\n\n",operando);
                      }
                      else
                      {
                          ignorarEspacios(fd);
                          codop = Etiqueta_Codop_Operando(fd,CODOP);
                          printf("CODOP = %s\n",codop);
                          erroresCodop(codop);
                          combinacion = verificarCombinacion(fd);
                          if(combinacion == 2)
                          {
                              operando = "null";
                              printf("OPERANDO = %s\n\n",operando);
                          }
                          else
                          {
                              ignorarEspacios(fd);
                              operando = Etiqueta_Codop_Operando(fd,OPERANDO);
                              printf("OPERANDO = %s\n\n",operando);
                          }
                      }
                      break;
               }
               if((strcmp(codop,"null"))!= 0)
               {
                   if((encontrado = buscarCodop(cabeza,codop)) == NULL)
                      printf("NO SE ENCONTRO EL CODOP DE OPERACION\n\n");
                   else
                   {
                       verificarOperando(encontrado,operando);
                       imprimirInfo(encontrado);
                   }
               }

           }
           ultimaLinea(codop);
       }
       else
          printf("No se pudo abrir el archivo");
       printf("Quieres abrir otro archivo S/N: ");
       fgets(nombre,MAX,stdin);
       sscanf(nombre,"%c",&respuesta);
       system("cls");
   }while(respuesta == 'S' || respuesta == 's');
   return 0;
}

booleano esComentario(FILE *fd)
{
   int car;
   while((car = fgetc(fd))!= '\n')
   {
       if(car == ';')
          return 0;
   }
   return 1;
}

void buscarFinLinea(FILE *fd)
{
   int car;
   while((car = fgetc(fd))!= '\n')
       ;
}

void ignorarEspacios(FILE *fd)
{
   int car;
   do
   {
       car = fgetc(fd);
   }while(car == '\t' || car == ' ');
}

int verificarCombinacion(FILE *fd)
{
   int car,combinacion;
   fseek(fd,-1,SEEK_CUR);
   if((car = fgetc(fd))== '\n')
      combinacion = 2;
   else
      combinacion = 1;
   return combinacion;
}

booleano esLetra(char caracter)
{
   if((caracter >= 'A' && caracter <= 'Z')||(caracter >= 'a' && caracter <= 'z'))
      return 1;
   else
      return 0;
}

booleano esNumero(char caracter)
{
   if(caracter >= '0' && caracter <= '9')
      return 1;
   else
      return 0;
}

char *Etiqueta_Codop_Operando(FILE *fd,int linea)
{
   int car,lon = 0,pos;
   char *cadena;
   fseek(fd,-1,SEEK_CUR);
   pos = ftell(fd);
   if((linea == ETIQUETA)||(linea == CODOP))
   {
       do
       {
           car = fgetc(fd);
           lon++;
       }while(car != '\t' && car != ' ' && car != '\n');
   }
   else
   {
       do
       {
           car = fgetc(fd);
           lon++;
       }while(car != '\n');
   }
   cadena = (char*)calloc((lon+1),sizeof(char));
   fseek(fd,pos,SEEK_SET);
   fgets(cadena,lon+1,fd);
   quitarSaltosLinea(cadena);
   return cadena;
}

void erroresEtiqueta(char *etiqueta)
{
   int tam,i = 0,esEtiqueta = 1;
   tam = strlen(etiqueta);
   if(tam > LONG_ETIQUETA)
      printf("\tError:la longitud maxima de una etiqueta es de 8 caracteres\n");
   if(!esLetra(etiqueta[i]))
      printf("\tError:la etiqueta debe iniciar con letra\n");
   else
   {
       for(i = 0;(i < tam)&&(esEtiqueta);i++)
       {
          if((!esLetra(etiqueta[i]))&&(!esNumero(etiqueta[i]))&&(etiqueta[i] != '_'))
             esEtiqueta = 0;
       }
       if(!esEtiqueta)
          printf("\tError:los caracteres validos en las etiquetas son letras, digitos(0..9) y el guion bajo\n");
   }
}

void erroresCodop(char *codop)
{
   int tam,i = 0,esCodop = 1,punto = 0;
   tam = strlen(codop);
   if(tam > LONG_CODOP)
      printf("\tError:la longitud maxima de un codigo de operacion es de 5 caracteres\n");
   if((strcmp(codop,"null"))== 0)
      printf("\tError:siempre debe de haber un codigo de operacion\n");
   else
   {
       if(!esLetra(codop[i]))
       printf("\tError:los codigos de operacion deben iniciar con letra\n");
       else
       {
           for(i = 1;(i < tam)&&(esCodop)&&(punto>=0&&punto<=1);i++)
           {
               if((!esLetra(codop[i]))&&(codop[i] != '.'))
                  esCodop = 0;
               else if(codop[i] == '.')
                  punto++;
           }
           if(!esCodop)
              printf("\tError:los caracteres validos en un codigo de operacion son letras y el caracter punto\n");
           if(punto > 1)
              printf("\tError:los codigos de operacion no pueden tener mas de un punto\n");
       }
   }
}

void ultimaLinea(char *codop)
{
   int lon1,lon2,i;
   lon1 = strlen(codop);
   lon2 = strlen("end");
   if(lon1 != lon2)
      printf("Error: No se encontro el END.\n");
   else
   {
       for(i = 0;codop[i];i++)
          codop[i] = tolower(codop[i]);
       if((strcmp(codop,"end")) != 0)
          printf("Error: No se encontro el END.\n");
   }
}

void quitarSaltosLinea(char *cadena)
{
   char *ptr;
   if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
      *ptr = '\0';
}

void listaTABOP(COD **cabeza)
{
   int car,i,pos,n;
   FILE *hc12;
   COD *ultimo = NULL;
   char *ins,*op,**dir,**maq,**cal,**x_cal,**sum;
   if((hc12 = fopen("TABOP.txt","r"))!= NULL)
   {
       while((car = fgetc(hc12))!= EOF)
       {
           i = 0;
           ins = Tabla_Operandos(hc12,INS);
           ignorarEspacios(hc12);
           op = Tabla_Operandos(hc12,OP);
           pos = ftell(hc12);
           buscarFinLinea(hc12);
           if((car = fgetc(hc12)) != '\t')
           {
               n = 0;
               fseek(hc12,pos,SEEK_SET);
               ignorarEspacios(hc12);
               dir = (char**)malloc(sizeof(char*));
               dir[i] = Tabla_Operandos(hc12,DIR);
               ignorarEspacios(hc12);
               maq = (char**)malloc(sizeof(char*));
               maq[i] = Tabla_Operandos(hc12,MAQ);
               ignorarEspacios(hc12);
               cal = (char**)malloc(sizeof(char*));
               cal[i] = Tabla_Operandos(hc12,CALCULADO);
               ignorarEspacios(hc12);
               x_cal = (char**)malloc(sizeof(char*));
               x_cal[i] = Tabla_Operandos(hc12,CALCULAR);
               ignorarEspacios(hc12);
               sum = (char**)malloc(sizeof(char*));
               sum[i] = Tabla_Operandos(hc12,TOTAL);
               buscarFinLinea(hc12);
           }
           else
           {
               n = 1;
               fseek(hc12,pos,SEEK_SET);
               dir = (char**)malloc(MAX*sizeof(char*));
               maq = (char**)malloc(MAX*sizeof(char*));
               cal = (char**)malloc(MAX*sizeof(char*));
               x_cal = (char**)malloc(MAX*sizeof(char*));
               sum = (char**)malloc(MAX*sizeof(char*));
               do
               {
                   ignorarEspacios(hc12);
                   dir[i] = Tabla_Operandos(hc12,DIR);
                   ignorarEspacios(hc12);
                   maq[i] = Tabla_Operandos(hc12,MAQ);
                   ignorarEspacios(hc12);
                   cal[i] = Tabla_Operandos(hc12,CALCULADO);
                   ignorarEspacios(hc12);
                   x_cal[i] = Tabla_Operandos(hc12,CALCULAR);
                   ignorarEspacios(hc12);
                   sum[i] = Tabla_Operandos(hc12,TOTAL);
                   buscarFinLinea(hc12);
                   i++;
               }while((car = fgetc(hc12)) == '\t');
               fseek(hc12,-1,SEEK_CUR);
           }
           if(*cabeza == NULL)
              *cabeza = crearNodo(ins,op,dir,maq,cal,x_cal,sum,n);
           else
           {
               ultimo = ultimoElemento(cabeza);
               insertarFinal(ins,op,dir,maq,cal,x_cal,sum,ultimo,n);
           }
       }
   }
   else
      printf("No se pudo abrir el archivo");
}

COD *ultimoElemento(COD **cabeza)
{
   COD *ptr;
   ptr = *cabeza;
   while(ptr->sig != NULL)
      ptr = ptr->sig;
   return ptr;
}

char *Tabla_Operandos(FILE *hc12,int tabla)
{
   int car,lon = 0,pos;
   char *cadena;
   fseek(hc12,-1,SEEK_CUR);
   pos = ftell(hc12);
   if((tabla==INS)||(tabla==OP)||(tabla==DIR)||(tabla==MAQ)||(tabla==CALCULADO)||(tabla==CALCULAR))
   {
       do
       {
           car = fgetc(hc12);
           lon++;
       }while(car != '\t' && car != EOF);
   }
   else
   {
       do
       {
           car = fgetc(hc12);
           lon++;
       }while(car != '\n' && car != EOF);
       lon--;
   }
   fseek(hc12,pos,SEEK_SET);
   cadena = (char*)calloc((lon+1),sizeof(char));
   fgets(cadena,lon+1,hc12);
   quitarSaltosLinea(cadena);
   return cadena;
}

COD *buscarCodop(COD *cabeza,char *codop)
{
   int i;
   COD *ptr;
   for(i = 0;codop[i];i++)
      codop[i] = toupper(codop[i]);
   for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
   {
       if((strcmp(ptr->instruccion,codop)) == 0)
          return ptr;
   }
   return NULL;
}

void insertarFinal(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,COD *ultimo,int n)
{
   ultimo->sig = crearNodo(ins,op,dir,maq,cal,x_cal,sum,n);
   ultimo->sig->sig = NULL;
   ultimo = ultimo->sig;
}

COD *crearNodo(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,int n)
{
   int tam,tam1,tam2,tam3,i;
   COD *x;
   x = (COD*)malloc(sizeof(COD));
   tam = strlen(ins);
   tam1 = strlen(op);
   x->instruccion = (char*)malloc((tam+1)*sizeof(char));
   x->operando = (char*)malloc((tam1+1)*sizeof(char));
   strcpy(x->instruccion,ins);
   strcpy(x->operando,op);
   x->tipo_linea = n;
   if(n == 1)
   {
       x->modo_direccionamiento = (char**)malloc(MAX*sizeof(char*));
       x->codigo_maquina = (char**)malloc(MAX*sizeof(char*));
       x->bytes_calculados = (char**)malloc(MAX*sizeof(char*));
       x->bytes_x_calcular = (char**)malloc(MAX*sizeof(char*));
       x->suma_bytes = (char**)malloc(MAX*sizeof(char*));
       for(i = 0;i < MAX;i++)
       {
           tam2 = strlen(dir[i]);
           x->modo_direccionamiento[i] = (char*)malloc((tam2+1)*sizeof(char));
           strcpy(x->modo_direccionamiento[i],dir[i]);
           tam3 = strlen(maq[i]);
           x->codigo_maquina[i] = (char*)malloc((tam3+1)*sizeof(char));
           strcpy(x->codigo_maquina[i],maq[i]);
           x->bytes_calculados[i] = (char*)malloc(sizeof(char));
           strcpy(x->bytes_calculados[i],cal[i]);
           x->bytes_x_calcular[i] = (char*)malloc(sizeof(char));
           strcpy(x->bytes_x_calcular[i],x_cal[i]);
           x->suma_bytes[i] = (char*)malloc(sizeof(char));
           strcpy(x->suma_bytes[i],sum[i]);
       }
   }
   else
   {
       x->modo_direccionamiento = (char**)malloc(sizeof(char*));
       x->codigo_maquina = (char**)malloc(sizeof(char*));
       x->bytes_calculados = (char**)malloc(sizeof(char*));
       x->bytes_x_calcular = (char**)malloc(sizeof(char*));
       x->suma_bytes = (char**)malloc(sizeof(char*));
       tam2 = strlen(dir[0]);
       x->modo_direccionamiento[0] = (char*)malloc((tam2+1)*sizeof(char));
       strcpy(x->modo_direccionamiento[0],dir[0]);
       tam3 = strlen(maq[0]);
       x->codigo_maquina[0] = (char*)malloc((tam3+1)*sizeof(char));
       strcpy(x->codigo_maquina[0],maq[0]);
       x->bytes_calculados[0] = (char*)malloc(sizeof(char));
       strcpy(x->bytes_calculados[0],cal[0]);
       x->bytes_x_calcular[0] = (char*)malloc(sizeof(char));
       strcpy(x->bytes_x_calcular[0],x_cal[0]);
       x->suma_bytes[0] = (char*)malloc(sizeof(char));
       strcpy(x->suma_bytes[0],sum[0]);
   }
   x->sig = NULL;
   return x;
}

void verificarOperando(COD *encontrado,char *operando)
{
   if((strcmp(encontrado->operando,"SI")) == 0)
   {
       if((strcmp(operando,"null")) == 0)
          printf("EL CODOP DEBE TENER OPERANDO\n");
   }
   else if((strcmp(encontrado->operando,"NO")) == 0)
   {
       if(!(strcmp(operando,"null")) == 0)
          printf("EL CODOP NO DEBE TENER OPERANDO\n");
   }
}

void imprimirInfo(COD *p)
{
   int i,num_lineas;
   printf("\n%s ",p->instruccion);
   if(p->tipo_linea == 1)
      num_lineas = MAX;
   else
      num_lineas = 1;
   for(i = 0;i < num_lineas;i++)
   {
       printf("\t%s\t",p->modo_direccionamiento[i]);
       printf("%s\t",p->codigo_maquina[i]);
       printf("%s\t",p->bytes_calculados[i]);
       printf("%s\t",p->bytes_x_calcular[i]);
       printf("%s\n",p->suma_bytes[i]);
   }
}


gracias de antemano

[Yoel Alejandro]

Estoy viendo que el fichero de entrada tiene:

Et12_xyz123     ADCA      1,PC
%ET3        LDAA      #$90
Netq%23        RMB      556
etv1
XYZ        Ldaaxyz   4
        %XYZ
        a.c.      %1111000
Abc        SWI%

y sólo en la primera línea empieza con "Et" (por cierto, 'E' en mayúsculas, 't' en minúsculas, ¿no tendrá eso que ver?). Lo que pregunto es si sólo las líneas que comiencen con la frase clave "ET", o "Et" se descomponen en ETIQUETA, CODOP y OPERANDO.