Autor Tema: Problema de Byte NULL con archivos (Leído 2282 veces)

Rombus · « **en:** Martes 16 de Septiembre de 2008, 03:13 »

Hola gente!

tengo un problema al intentar practicamente duplicar un archivo donde se cumpla una condicion, si la line del archivo es una directiva, y mas especificamente si es un include <...>.

Intento hacer un programa que posea un preset para acomodar todos los codigos fuente que me pasen o que baje de internet a mi gusto, indentados, posicion de llaves, orden, etc...

pero mi problema es que en la "duplicacion" cuando intento abrir el archivo duplicado me tira un error diciendome que en el archivo hay un byte NULL y que se abrio solo lectura.

abro el archivo en un editor Hexadecimal y efectivamente hay un byte null. (totalmente involuntario)

este es mi codigo:

Código: Text

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
 
#define PATH "/home/rombus/Escritorio/sample.c"
#define TERMINADO "/home/rombus/Escritorio/prueba.c"
 
#define FALSE 0
#define TRUE !FALSE
 
#define INCLUDE 1
#define DEFINE  2
#define UNKNOWN -1
 
#define STD     3
#define LOCAL   4
 
#define hastaEOL(a)             while((fgetc(a)!= 'n') && (fgetc(a)  != EOF))
#define unoParaAtraz(a)         fseek(a,(long)-1,SEEK_CUR)
#define dosParaAtraz(a)         fseek(a,(long)-2,SEEK_CUR)
#define unoParaAdelante(a)      fseek(a,(long)1,SEEK_CUR)
#define dosParaAdelnate(a)      fseek(a,(long)2,SEEK_CUR)
 
typedef char boolean;
typedef char macroType;
 
///-Prototypes-///
char *getLine(FILE *a);
macroType define_o_include(FILE *a);
macroType std_o_local(FILE *a);
boolean esMacro(FILE *a);
void comeBlancos(FILE *a);
boolean saltoMacros(FILE *a);
 
void pasaIncludesStd(FILE *a, FILE *b, boolean *flagLocal){
    long pos, inicio = ftell(a),len;
    char c; //Variable de control
    char *cadena = (char *)malloc(sizeof(char)*255);
    macroType control;
    
    while(esMacro(a)){
        pos = (ftell(a));       
        control = define_o_include(a);
        if(control == INCLUDE){
            c = std_o_local(a);
            if(c == STD){
                hastaEOL(a);        //Me paro al final de la linea
                len = ftell(a)-pos; //Me da la cantidad de bytes q se corrio del principio
                fseek(a,(long)pos,SEEK_SET);
                cadena = getLine(a);
                fwrite(cadena,sizeof(char),len,b);  //Tener cuidado con esto, posible nido de bugs
                printf("escribio: %s - n",cadena);
            }
            else if(c == LOCAL)
                (*flagLocal) = TRUE;
        }
        else if(control == DEFINE)  //Si es un define salto toda la linea
            hastaEOL(a);        
    }
    fseek(a,inicio*-1,SEEK_CUR);    //Voy a donde estaba cuando me lo pasaron
}
 
int main(void){
    FILE *a = fopen(PATH,"rb");
    FILE *b = fopen(TERMINADO,"wt");
    boolean flagLocal = FALSE;
    
    pasaIncludesStd(a,b,&flagLocal);    //pasar los includes <> 
    
    fclose(a);
    fclose(b);
    return 0;
}
 
///-FUNCIONES-///
char *getLine(FILE *a){
    char *l = (char*)malloc(255*sizeof(char));
    int i = 0;
    
    do{
        l[i] = fgetc(a);
    }while((l[i] != 'n') && (l[i++] != EOF));
    return l;
}
macroType define_o_include(FILE *a){
    char c =fgetc(a);
    
    if(c == '#')        //Por si cuando invocan la funcion no saben si es macro
        c = fgetc(a);
        
    if(c == 'i')
        return INCLUDE;
    if(c == 'd')
        return DEFINE;
    return UNKNOWN;
}
macroType std_o_local(FILE *a){
#define LEN_INCLUDE 8   //Largo de la palabra "#include "
    int i=0;
    char c = fgetc(a);
        
    if(c == '#')            //Si llamo a la funcion sin antes haber leido el '#'
        unoParaAtraz(a);
    else                    //Si llamo a la funcion antes habiendo leido el '#'
        dosParaAtraz(a);
        
    while(i++<LEN_INCLUDE)  //Salto el "#include "
        fgetc(a);
        
    c = fgetc(a);   //Leo el "" o el <>
    printf("el caracter es: %cn",c);
    
    if(c == '"')
        return LOCAL;
    else if(c == '<')
        return STD;
    return UNKNOWN;
}
boolean esMacro(FILE *a){
    char c; 
    
    comeBlancos(a);
    c = fgetc(a);
    unoParaAtraz(a);
    if(c == '#')
        return TRUE;    
    return FALSE;
}
void comeBlancos(FILE *a){
    char b;
    
    while( (b = fgetc(a)) == ' ' || b == 'n' || b == 't');
    printf("salio del comeBlancos con un %cn",b);
    unoParaAtraz(a);
}
boolean saltoMacros(FILE *a){
    char c;
    boolean flag = FALSE;
    
    do{
        if(flag)            //Leo toda la linea una vez que leyo el primer caracter
            hastaEOL(a);
        else
            flag = TRUE;    //Cuando es la primera vez habilito la bandera
            
        comeBlancos(a);
        c = fgetc(a);
    }while(c =='#');
    unoParaAtraz(a);
    return FALSE;   //Terminaron los macros
}
 

si alguien me puede dar alguna pista, se lo agradesco.

saludos!

EI: Juntando mensajes.

nadie sabe en que momento es que estoy escribiendo el byte NULL?

me di cuenta que donde el archivo se corta a la mitad debido a este byte NULL es cuando en el archivo fuente, osea el archivo que estoy duplicando hay un "n", un enter.

m0skit0

¿Te sustituye un 'n' en el fichero origen por un NULL (0x00) en la copia que haces? ¿En el primer 'n' que encuentra?

Rombus

hola m0skit0!
gracias por responder.

el byte null, se escribe en la copia, el original queda como estaba.
pero igual, es medio raro, porque lo estoy probando con estos archivos:

como original:

Código: Text

    
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#define aksjdklfj
#include <sempor.h>
void  main(void){
    
}

(con muchos n's al principio)

y lo que termina quedando como "salida", osea, mi "duplica" queda asi:

Código: Text

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>

y cuando lo abro al archivo de salida me dice que hay un byte null y que mi archivo fue cortado.

sin embargo, en la consola, me muestra todo como deberia ser :S

osea, el fin de este programa (q en realidad estoy intentando hacer andar la funcion pasaIncludesStd), es agarrar un codigo fuente, y ordenarle todos los #includes <..> al principio, si hay un codigo de la siguiente manera:

Código: Text

#include <stdlib.h>
#define TRUE 1
#include <ctype.h>
 

mi programa deberia organizar los includes para que quede asi:

Código: Text

#include <stdlib.h>
#include <ctype.h>
#define TRUE 1
 

el problema en mi codigo se ve (tomando el archivo de entrada que uso para probarlo) cuando despues
del include <stdlib.h> viene un define, enotnces hay un if bifurcador que si es define no lo pasa al archivo(eso lo va a hacer otra funcion)

pero no puedo corregirlo de ninguna manera :S

saludos!

m0skit0

Tienes mal la condición aquí:

Código: C

 
#define hastaEOL(a)             while((fgetc(a)!= 'n') && (fgetc(a)  != EOF))

Así te va a leer siempre hasta el final del fichero, puesto que se tiene que cumplir fgetc(a) != EOF.

Como habrás adivinado, tiene que ser:

Código: C

 
#define hastaEOL(a)             while((fgetc(a)!= 'n') || (fgetc(a)  != EOF))

Los errores de lógica como estos son muy comunes, así que cuando escribas condiciones con operadores logicos, haz un par de pruebas mentales o por escrito de la condición. ¡Saludos!

P.D: para los linuxeros, son ficheros. Archivo

es nomenclatura de MS, que se inventa los términos.

Rombus

pero no es al revez?

yo quiero leer hasta el fin de linea.

si hago

Código: Text

while((fgetc(a)!= 'n') || (fgetc(a)  != EOF));
 

y leo el primer enter, ahi terminaria mi linea, pero como no es eof la segunda parte de la condicion seria verdadera, y como es un or la expresion seria evaluada como verdadera.

y si hago:

Código: Text

while((fgetc(a)!= 'n') && (fgetc(a)  != EOF));
 

cuando encuentre el primer enter la primera condicion es falsa y la segunda verdadera pero como es un AND la expresion es falsa, y pasaria lo mismo si encuentro un EOF.

tiene sentido lo q digo?

a estas horas estoy muy quemado de la cabeza jaja

Cita de: "m0skit0"

P.D: para los linuxeros, son ficheros. Archivo es nomenclatura de MS, que se inventa los términos.

ficheros entonces

m0skit0

Me encantan estas discusiones

Primeramente, tanto una como otra están mal. Se me pasó que de esa manera se leen 2 caracteres diferentes, es decir, la primera fgetc() lee un carácter y la segunda lee el siguiente. Por lo tanto, deberías de hacer un solo fgetc(a) y asignarle el el valor devuelto a un variable y comparar.

Una vez aclarado esto, si utilizamos un AND, como tú dices, sería "lee caracter mientras no sea NI final de línea NI final de fichero", es decir, que leerías TODOS los caracteres del fichero, puesto que la condición se cumple sólo cuando sea tanto EOL como EOF, las 2 A LA VEZ, que sólo se cumple al final del fichero (por EOF).

Sin embargo, si es un OR, pararía de leer tanto si es EOL como si es EOF, es decir, basta que se cumpla una de las dos, no ambas simultáneamente, que es lo que tú quieres. De hecho, la condición de EOF no tiene razón de ser si el fichero termina con "enter".

Espero haberme explicado, que he dormido 4 horas y media

Rombus

me quiero matar

Cita de: "m0skit0"

la primera fgetc() lee un carácter y la segunda lee el siguiente

odio cuando me pasa eso!!

es verdad, ese problema lo tube en otras funciones anteriores y dije: "claro, tengo dos fgetc entonces estoy comparando
con dos valores diferentes"

y en este no me di cuenta.

excelente!

ya esta andando

el define se convirtio en funcion:

Código: Text

void hastaEOL(FILE *a){
    char c;
    do{
        c = fgetc(a);
    }while((c != 'n') && (c != EOF));
}
 

con respecto a lo del AND y OR.

no es que cuando yo tengo un OR, y la condicion A es falsa, pero la B es verdadera va a seguir siendo verdadera la expresion, y lo mismo en viceseversa?

en cambio si yo tengo un AND y la condicion A es falsa AND la B es verdadera, entonces es falso, osea, tengo un EOF no un enter, pero es el fin de linea al fin.

osea,

1 AND 0 = 0 //si es enter pero no EOF es falso, fin de linea

1 OR 0 = 1 //si es enter pero no EOF seria verdadero y yo quiero que sea falso, osea, estoy en el fin de linea

gracias m0skit0
un error estupido que no podia ver que me estaba volviendo loco

m0skit0

Me alegro de que funcione.

Efectivamente, tienes razón

. Mi confusión radica (aparte de haber dormido 5 horas...) en que yo no lo codificaría de esa manera. Me entero mejor así:

Código: C

 
while !(c=='n' || c==EOF)

Que es exactamente la misma condición que la tuya si aplicamos la Ley de De Morgan.

SoloCodigo

Autor Tema: Problema de Byte NULL con archivos (Leído 2282 veces)

Rombus

Problema de Byte NULL con archivos

m0skit0

Re: Problema de Byte NULL con archivos

Rombus

Re: Problema de Byte NULL con archivos

m0skit0

Re: Problema de Byte NULL con archivos

Rombus

Re: Problema de Byte NULL con archivos

m0skit0

Re: Problema de Byte NULL con archivos

Rombus

Re: Problema de Byte NULL con archivos

m0skit0

Re: Problema de Byte NULL con archivos