typedef struct nodo
{
    char *codigo;
    int indice = 0;
    struct nodo *sig;
}NODO;

    int encontrado = 0;
   for(ptr = cabeza;(ptr != NULL)&&(encontrado);ptr = ptr->sig)
 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LONG_ETIQUETA 8
#define LONG_CODOP 5
#define COMENTARIO ';'
#define TABULADOR '\t'
#define ESPACIOS_ ' '
 
typedef enum {FALSO,VERDADERO} booleano;
typedef enum {ETIQUETA,CODOP,OPERANDO} linea;
typedef enum {INS,OPE} tabla;
 
typedef struct nodo
{
    char *codigo;
    char *Operando;
    struct nodo *sig;
}COD;
 
COD *crearNodo(char *instruccion,char *op);
void insertarFinal(char *instruccion,char *op,COD *ultimo);
COD *ultimoElemento(COD *cabeza);
void quitarSaltosLinea(char *cadena);
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);
booleano esNumero(char caracter);
booleano esLetra(char caracter);
void listaCodops(COD *cabeza);
char *Tabla_Operandos(FILE *hc12,int tabla);
COD *buscarCodop(COD *cabeza,char *codop);
void imprimirLista(COD *cabeza);
 
int main()
{
    FILE *fd;
    int car,combinacion;
    COD *cabeza = NULL,*encontrado;
    char *etiqueta,*codop,*operando;
    //listaCodops(cabeza);
    if((fd = fopen("P2ASM.txt","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);
                   if((encontrado = buscarCodop(cabeza,codop)) == NULL)
                      printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
                   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);
                       if((encontrado = buscarCodop(cabeza,codop)) == NULL)
                          printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
                       operando = "null";
                       printf("OPERANDO = %s\n\n",operando);
                   }
                   else
                   {
                       ignorarEspacios(fd);
                       codop = Etiqueta_Codop_Operando(fd,CODOP);
                       printf("CODOP = %s\n",codop);
                       erroresCodop(codop);
                       if((encontrado = buscarCodop(cabeza,codop)) == NULL)
                          printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
                       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;
            }
        }
        ultimaLinea(codop);
    }
    else
       printf("No se pudo abrir el archivo");
    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 = calloc(lon+1);
    fseek(fd,pos,SEEK_SET);
    fgets(cadena,lon+1,fd);
    quitarSaltosLinea(cadena);
    return cadena;
}
 
void quitarSaltosLinea(char *cadena)
{
    char *ptr;
    if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
       *ptr = '\0';
}
 
void erroresEtiqueta(char *etiqueta)
{
    int tam,i = 0,esEtiqueta = 1;
    tam = strlen(etiqueta);
    if(tam-1 > 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)
{
    if((strcmp(codop,"END")) != 0)
       printf("Error:No se encontro el END.\n");
}
 
void listaCodops(COD *cabeza)
{
    int car;
    FILE *hc12;
    char *instruccion,*op;
    COD *ultimo;
    if((hc12 = fopen("TABOP.txt","r"))!= NULL)
    {
        while((car = fgetc(hc12))!= EOF)
        {
            if(car != '\t')
            {
                instruccion = Tabla_Operandos(hc12,INS);
                op = Tabla_Operandos(hc12,OPE);
                if(cabeza == NULL)
                   cabeza = crearNodo(instruccion,op);
                else
                {
                    ultimo = ultimoElemento(cabeza);
                    insertarFinal(instruccion,op,ultimo);
                }
            }
            else
               buscarFinLinea(hc12);
        }
        imprimirLista(cabeza);
    }
    else
       printf("No se pudo abrir el archivo\n");
}
 
char *Tabla_Operandos(FILE *hc12,int tabla)
{
    int car,lon = 0,pos;
    char *cadena;
    fseek(hc12,-1,SEEK_CUR);
    pos = ftell(hc12);
    do
    {
        car = fgetc(hc12);
        lon++;
    }while(car != '\t');
    fseek(hc12,pos,SEEK_SET);
    cadena = malloc(lon+1);
    fgets(cadena,lon+1,hc12);
    quitarSaltosLinea(cadena);
    if(tabla == INS)
       ignorarEspacios(hc12);
    else
       buscarFinLinea(hc12);
    return cadena;
}
 
void insertarFinal(char *instruccion,char *op,COD *ultimo)
{
    ultimo->sig = crearNodo(instruccion,op);
    ultimo->sig->sig = NULL;
    ultimo = ultimo->sig;
}
 
COD *ultimoElemento(COD *cabeza)
{
    COD *ptr;
    ptr = cabeza;
    while(ptr->sig != NULL)
       ptr = ptr->sig;
    return ptr;
}
 
COD *crearNodo(char *instruccion,char *op)
{
    COD *x;
    int tam,tam2;
    tam = strlen(instruccion);
    tam2 = strlen(op);
    x = malloc(sizeof(COD));
    x->codigo = malloc((tam+1));
    x->Operando = malloc((tam2+1));
    strcpy(x->codigo,instruccion);
    strcpy(x->Operando,op);
    x->sig = NULL;
    return x;
}
 
COD *buscarCodop(COD *cabeza,char *codop)
{
    COD *ptr;
    for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
    {
        if((strcmp(ptr->codigo,codop)) == 0)
           return ptr;
    }
    return NULL;
}
 
void imprimirLista(COD *cabeza)
{
    COD *ptr;
    for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
    {
        printf("%s\t",ptr->codigo);
        printf("%s\n",ptr->Operando);
    }
}