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:

#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