Thread: Reading a file

Since you seem to be parsing XML, how about using a pre-existing XML parser library?
The Expat XML Parser

It's a bit of extra work up front, but at least you won't have to worry too much about feature creep or minor changes in the text file which might otherwise break a simpler parser.

3 quick hacks for reading files

Code:

// Good - file is stored as a linked list of lines
struct linelist {
  struct linelist *next;
  char    buff[BUFSIZ];
};

struct linelist *head = NULL, *tail = NULL;
char buff[BUFSIZ];

while ( fgets ( buff, sizeof buff, fp ) != NULL ) {
  struct linelist *temp = malloc( sizeof *temp );
  if ( temp ) {
    strcpy( temp->buff, buff );
    temp->next = NULL;
    if ( !head ) {
      head = tail = temp;
    } else {
      buff->next = tail;
      tail = temp;
    }
  }
}


// Bad - file is all in a single buffer, but expensive to create for long files
char *file = malloc(1);
*file = '\0';
char buff[BUFSIZ];

while ( fgets ( buff, sizeof buff, fp ) != NULL ) {
  size_t  newlen = strlen(file) + strlen(buff) + 1;
  void *temp = realloc( file, newlen );
  if ( temp ) {
    file = temp;
    strcat( file, buff );
  }
}

// Ugly - cheap hack to store the whole file at once
// Makes some assumptions about how text files are read (see "rt" mode)
// Probably best not to use this one...
fseek( fp, 0, SEEK_END );
long len = ftell( fp );
rewind( fp );
char *file = malloc( len + 1 );
fread( file, 1, len, fp );
file[len] = '\0';

Code:

      buff->next = tail;
      tail = temp;

Hmmm. buff has no next

more like

Code:

tail->next = temp;
tail = temp;

i suppose?

Yeah something like that (probably).
It's just an idea code

Originally Posted by c99

7.19.9.2 The fseek function
Synopsis
1 #include <stdio.h>
int fseek(FILE *stream, long int offset, int whence);
Description
2 The fseek function sets the file position indicator for the stream pointed to by stream.
If a read or write error occurs, the error indicator for the stream is set and fseek fails.

3 For a binary stream, the new position, measured in characters from the beginning of the
file, is obtained by adding offset to the position specified by whence. The specified
position is the beginning of the file if whence is SEEK_SET, the current value of the file
position indicator if SEEK_CUR, or end-of-file if SEEK_END. A binary stream need not
meaningfully support fseek calls with a whence value of SEEK_END.

4 For a text stream, either offset shall be zero, or offset shall be a value returned by
an earlier successful call to the ftell function on a stream associated with the same file
and whence shall be SEEK_SET.

Seeking the end of a file can be problematic. The only sure way is to read the whole file until you get EOF, then use ftell().

If you're on a modern POSIX system like say Linux, then "r" and "rb" are the same thing. There is no difference in taste between the two.

The most obvious difference is seen on DOS/Windows platforms where the end of line marker is "\r\n" (two characters) is read by your program as just "\n" (one character) when you read the file in text mode. The seek may tell you the number of bytes, whereas the read would perform the character mapping. In this case, it would not be an issue as the read would deliver fewer characters than bytes (because all \r's are effectively stripped).

Other still rarer systems could conceivably deliver MORE characters than bytes, so a simple seek-malloc strategy would fail horribly.

The other downside is the stream may not be seekable at all (say stdin, a pipe or a socket), so a "read and allocate as you go" is the only way to deal with the problem.