Saludos, tengo problemas con unos fseeks que tengo dentro de un ciclo while que me lee un archivo, pero a la hora de imprimir el archivo no lo hace correctamente

este es el codigo:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 8
 
typedef enum {INS,OP,DIR,MAQ,CALCULADO,CALCULAR,TOTAL} tabla;
 
void buscarFinLinea(FILE *hc12);
void listaTABOP();
char *Tabla_Operandos(FILE *hc12,int tabla);
void ignorarEspacios(FILE *hc12);
void quitarSaltosLinea(char *cadena);
 
int main()
{
    listaTABOP();
    return 0;
}
 
void buscarFinLinea(FILE *hc12)
{
    int car;
    while((car = fgetc(hc12))!= '\n')
        ;
}
 
void quitarSaltosLinea(char *c)
{
    char *ptr;
    if(((ptr = strchr(c,'\n'))!= NULL)||((ptr = strchr(c,'\t'))!= NULL)||((ptr = strchr(c,' '))!= NULL))
       *ptr = '\0';
}
 
void listaTABOP()
{
    int car,i,pos,n;
    FILE *hc12;
    COD *ultimo = NULL;
    char *ins,*op,**dir,**maq,**cal,**x_cal,**sum;
    if((hc12 = fopen("Tabla_OP.txt","r"))!= NULL)
    {
        while((car = fgetc(hc12))!= EOF)
        {
            i = 0;
            fseek(hc12,-1,SEEK_CUR);
            ins = Tabla_Operandos(hc12,INS);
            printf("[%s]\t",ins);
            ignorarEspacios(hc12);
            op = Tabla_Operandos(hc12,OP);
            printf("[%s]",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);
                printf("\t[%s]\t",dir[i]);
                ignorarEspacios(hc12);
                maq = (char**)malloc(sizeof(char*));
                maq[i] = Tabla_Operandos(hc12,MAQ);
                printf("[%s]\t",maq[i]);
                ignorarEspacios(hc12);
                cal = (char**)malloc(sizeof(char*));
                cal[i] = Tabla_Operandos(hc12,CALCULADO);
                printf("[%s]\t",cal[i]);
                ignorarEspacios(hc12);
                x_cal = (char**)malloc(sizeof(char*));
                x_cal[i] = Tabla_Operandos(hc12,CALCULAR);
                printf("[%s]\t",x_cal[i]);
                ignorarEspacios(hc12);
                sum = (char**)malloc(sizeof(char*));
                sum[i] = Tabla_Operandos(hc12,TOTAL);
                printf("[%s]\n",sum[i]);
                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);
                    printf("\t[%s]\t",dir[i]);
                    ignorarEspacios(hc12);
                    maq[i] = Tabla_Operandos(hc12,MAQ);
                    printf("[%s]\t",maq[i]);
                    ignorarEspacios(hc12);
                    cal[i] = Tabla_Operandos(hc12,CALCULADO);
                    printf("[%s]\t",cal[i]);
                    ignorarEspacios(hc12);
                    x_cal[i] = Tabla_Operandos(hc12,CALCULAR);
                    printf("[%s]\t",x_cal[i]);
                    ignorarEspacios(hc12);
                    sum[i] = Tabla_Operandos(hc12,TOTAL);
                    printf("[%s]\n",sum[i]);
                    buscarFinLinea(hc12);
                    i++;
                    printf("\t");
                }while((car = fgetc(hc12)) == '\t');
            }
        }
    }
    else
       printf("No se pudo abrir el archivo");
}
 
void ignorarEspacios(FILE *hc12)
{
    int car;
    do
    {
        car = fgetc(hc12);
    }while(car == '\t' || car == ' ');
}
 
char *Tabla_Operandos(FILE *hc12,int tabla)
{
    int car,lon = 0,pos;
    char *c;
    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);
    c = (char*)calloc((lon+1),sizeof(char));
    fgets(c,lon+1,hc12);
    quitarSaltosLinea(c);
    return c;
}
 

[
y el archivo es
quote]ABA         NO   INH      1806      2   0   2
          ADCA   SI   IMM      89ii      1   1   2
                            DIR      99dd      1   1   2
                            EXT      B9hhll   1   2   3
                            IDX      A9xb      1   1   2
                            IDX1      A9xbff   1   2   3
                            IDX2      A9xbeeff   1   3   4
                            [D,IDX]   A9xb      1   1   2
                            [IDX2]   A9xbeeff   1   3   4[/quote]
el problema es que  cuando llega al codop ADCA no me imprime toda la linea solo me imprime

[]....[ADCA]...[SI]...[IMM]...[89ii]....[1]...[1]

 esto se arregla si le quito el primer fseek() que aparece en el while() de la funcion listaTABOP, pero si se lo quito ahora los codops siguientes al ADCA los imprime sin la primer letra, se la come,entonces como puedo arreglar este problema

gracias

Saludos x64Core el problema es que no se usar el depurador de codeblocks :S lo intente con un tutorial pero no pude

Bueno x64Core particularmente no soy partidario de usar depuradores o cosas por es estilo, prefiero ir "a manita limpia", y me ha funcionado bien porque así ejercitas más el cerebro, jeje

El problema al parecer es que te mueves para adelante y para atrás en el archivo, abusando de fseek. Un buen programador debe ser cauto, debe simplemente evitar andar por terrenos peligrosos, y el estilo de tu programación está siendo definitivamente muy vulnerable. Cualquier error o descuido y tienes un comportamiento completamente impredecible.

Usa el principio de "divide y vencerás". Ve, hazlo así. Coje una línea del archivo txt, y la pasas a una función que analice sintácticamente para detectar sus divisiones en columnas con el carácter tabulador, es decir, lo que hace tablaOperandos. Pero que tablaOperandos y listaTABOP NO SE MUEVAN juntas por el mismo archivo. Eso NUNCA se hace, cada función debe tener su espacio de trabajo "privado". ¿Entiendes la filosofía subyacente?

Entonces, vamos a hacer una función que vaya cogiendo una línea del archivo, y la copie a un arreglo tipo búfer, y se la pase a tablaOperandos, así esta última lee del búfer y no se mete para nada con el archivo original (reduciendo el riesgo de conflictos).

En tu código original tenías un problema porque tablaOperandos al leer la línea avanzaba el indicador de posición de archivo, luego tenías que devolverlo a su posición original con [ttfseek[/tt], etc ....  muy engorroso. Con esta solución no tienes que hacer nada de eso:


y listo, agarras ese buffer y se lo pasas a tablaOperandos. Claro, antes debes haber definido el buffer como un arreglo con la suficiente longitud para contener cualquier posible línea del archivo (no se, 100 caracteres quizás). Ahora acomoda tablaOperandos para que trabaje sobre un arreglo y no sobre un fichero.

Te explico la última parte del código antes mostrado. En ficheros de texto el fin de línea se hace con una sucesión de dos caracteres, generalmente el <i>carriage return</i> CR seguido de <i>linefeed</i> LF. Entonces, si alcanzas digamos el CR, pues cierras el búfer. Pero al invocar el nuevo la función, leerá el LF y cerrará el búfer ... ¡vacío! O sea, que después de una llamada exitosa a readLinea la próxima llamada que ejecutes devolverá un búfer vacío. Para evitar eso, se bede avanzar el indicador de posición de archivo hasta no encontrar ni CR ni LF, luego de cerrar el búfer de línea. Es lo que hace el:


Te voy a explicar algo, el uso de ungetc(). Supón que tienes un fichero así:


entonces empieza a leer la línea Pedro, hasta que haya la secuencia CR + LF. Primero lee CR, entonces sabe que debe continuar hasta que no haya ni CR ni LF. Así leee CR, luego LF, luego la M inicial de "Maria". Ahí sabe que se terminó la primera línea. Pero hemos agarrado la 'M', luego tenemos que "devolverla" al fichero, por eso usamos ungetc. Es algo parecido a lo que hacías con fseek( hc12, -1, SEEK_CUR ).
    

Ok, ahora vamos a poner todo junto, a mí me salió en apenas 89 líneas de código. Y creé un fichero de texto de prueba con el mismo contenido que tú dices, y me imprimió la tabla perfecta

Es cuestión de ser hábil combinando las cosas, así puedes lograr mucho con poco ... Bueno, espero te sirva, aquí tienes el fuente completo con el main() y todo, sólo de copiar, pegar, compilar y probar.

#include <stdlib.h>
#include <stdio.h>
 
#define CR 10
#define LF 13
 
typedef enum {INS, OP, DIR, MAQ, CALCULADO, CALCULAR, TOTAL} tabla;
 
void readLine ( FILE *, char * );
char * readField( char ** );
 
int main()
{
	char * buffer, * old_buffer;
	char * field;
	FILE * hc12;
 
	if ( ( buffer = (char *) malloc( 101 * sizeof(char) ) ) == NULL ) return -1;
	if ( ( field = (char *) malloc( 101 * sizeof(char) ) ) == NULL ) return -1;
 
	if ( ( hc12 = fopen( "file1.txt", "r") ) == NULL ) return -1;
 
	while ( !feof( hc12) ) {
		readLine( hc12, buffer);
		old_buffer = buffer;
		while ( ( field = readField( &buffer ) ) != NULL ) {
			printf("%s\t", field);
		}
		printf("\n");
		buffer = old_buffer;
	}
 
	fclose( hc12 );
 
	return 0;
}
 
void readLine ( FILE *hc12, char *buffer ) {
 
	char c;
	int i;
 
	i = 0;
	while ( !feof(hc12) && (c = fgetc(hc12)) != CR && c != LF )  
		buffer[i++] = c;
 
	buffer[i] = '\0';
 
	/* avanzamos hasta que no haya CR ni LF */
	while ( ( c = fgetc(hc12) ) == CR || c == LF ) 
		;
	/* devolvemos el último carácter leído */
	if ( !feof(hc12) ) ungetc(c, hc12);
}
 
/* Lee un campo del búfer, considerando un campo como toda sucesión de
   caracteres de no espacio. Devuelve NULL si no hay más campos que leer */
char * readField( char ** buffer_ptr ) {
 
	int i;
	char c;
	char * buffer = *buffer_ptr;
 
	if ( *buffer == '\0' ) return NULL;
 
	/* elimina los espacios iniciales */
	while ( *buffer == ' ' || *buffer == '\t' )
		buffer++;
 
	/* ahora toma la porción inicial de la cadena hasta encontrar 
	   espacio o tabulador */
	i = 0;
	while ( (c = buffer[i]) != '\0' && c != ' ' && c != '\t' ) 
		i++;
 
	/* finaliza la sub-cadena donde halló el carácter espacio o tabulador */
	buffer[i] = '\0';
 
	/* y si hay más sub-cadenas que leer, avanza el búfer */
	if ( c != '\0' ) 
		*buffer_ptr = buffer + i + 1;
	else
		*buffer_ptr = buffer + i;
 
	if ( i > 0 ) 	
		return buffer;		/* leyó al menos un carácter */
	else
		return NULL;		/* no leyó nada */
}
 

Pruébalo y me dices!!

==========================================
Por cierto y aparte, noté que tienes en el código original una sentencia que no entiendo bien:

dir = (char**)malloc(sizeof(char*));
dir[i] = Tabla_Operandos(hc12,DIR);
 

Ok, ve. Con el malloc defines un arreglo dir de UN único elemento del tipo puntero a char, que luego rellenas con el string que produce la función Tabla_Operandos. Ahora, dos preguntas: ¿Dónde reservas el espacio de la memoria para los restantes elementos del arreglo dir, aparte del primero?
Además, si dir contendrá un string, ¿dónde reservas la memoria para dicho arreglo de caracteres? Eso tiene que hacerse de la siguiente manera:

/* Reservando el arreglo dir como arreglo de cadenas */
/ *  (dir_length es la longitud que esperas para dir ) */
dir = (char **) malloc( dir_length * sizeof (char *) );
 
/* ahora se reserva memoria para cada string dentro del arreglo */
for ( i = 0; i < dir_length; i++ ) 
    dir[i] = (char *) malloc( s_length * sizeof(char) );
/* donde s_length es la longitud deseada para cada string */
 

De hecho, no se cómo el programa no te produjo un error de "violación de segmento" en tiempo de ejecución ...

De, hecho, cada vez que se usa malloc uno tiene que comprobar si la asignación de memoria se produjo con éxito (casi siempre así sucede, pero no se puede dar por sentado). Si no se pudo asignar memoria, se debe salir del programa:

/* Reservando el arreglo dir como arreglo de cadenas */
/ *  (dir_length es la longitud que esperas para dir ) */
dir = (char **) malloc( dir_length * sizeof (char *) );
if ( dir == NULL ) return -1;
 
/* ahora se reserva memoria para cada string dentro del arreglo */
for ( i = 0; i < dir_length; i++ ) {
    dir[i] = (char *) malloc( s_length * sizeof(char) );
    if ( dir[i] == NULL ) return -1;
}
 

y esto te evitará cualquier "comportamiento inesperado" del programa, para que no te pase como a Windows que se cuelga a cada rato jeje.

Saludos, y quedo a la orden para cualquier cosa .... Yoel

@yoel_alejandro:
En proyectos simples es facil, pero en proyectos considerablemente grandes no podes esperar que has manipulado todos los posibles errores.
Pero con ese comentario luces de las personas que tiene poca experiencia en eso. de todos modos espero verte
más seguido por aquí ya vamos a ver si realmente sabes como dices.