reading a file in reverse order (bootom-top)

[sahukar praveen]

Hello,

I have a question.

I try to print a ascii file in reverse order( bottom-top). Here is the logic.

1. Go to the botton of the file fseek(). move one character back to avoid the EOF.
2. From here read a character, print it, move the file pointer (FILE*) to 2 steps back (using fseek(fp, -2, SEEK_CUR)) to read the previous character.

This seems to be ok if the file has a single line (i.e. no new line character). The above logic fails if it encounters a new line character and gets into an infinite loop priting a series of new-line character.

To fix this I checked for the character read and if it is new-line character, I move the file pointer by 3 steps (fseek(fp, -3, SEEK_CUR)) and now the logic works fine.

Can anyone please explain me why a this special consideration for a new-line character.

Many Thanks in advance.

Thanks
Praveen

[CBFalconer]

sahukar praveen wrote:

Part 1.1 Type: Plain Text (text/plain)
Encoding: quoted-printable

Please do not post html or attachments in c.l.c.

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!

[John Bode]

"sahukar praveen" <sa************ @yahoo.co.in> wrote in message news:<3f******@ usenet01.boi.hp .com>...

Hello,

I have a question.

I try to print a ascii file in reverse order( bottom-top). Here is the
logic.

1. Go to the botton of the file fseek(). move one character back to
avoid the EOF.
2. From here read a character, print it, move the file pointer (FILE*)
to 2 steps back (using fseek(fp, -2, SEEK CUR)) to read the previous
character.

This seems to be ok if the file has a single line (i.e. no new line
character). The above logic fails if it encounters a new line character
and gets into an infinite loop priting a series of new-line character.

To fix this I checked for the character read and if it is new-line
character, I move the file pointer by 3 steps (fseek(fp, -3, SEEK CUR))
and now the logic works fine.

Can anyone please explain me why a this special consideration for a
new-line character.

Many Thanks in advance.

Thanks
Praveen
--

Some platforms represent a newline with a carriage return and line
feed pair, rather than a single newline character, which is why you
need to back up three characters instead of two.

Instead of reading a single character at a time, you might want to
grab a chunk of characters into a buffer, then print from that buffer.
For one thing, it reduces the number of calls to fseek() (which may
be a fairly expensive operation), and you can just skip over the
characters you don't want to print.

[Mark McIntyre]

On Tue, 25 Nov 2003 16:38:48 +0530, in comp.lang.c , "sahukar praveen"
<sa************ @yahoo.co.in> wrote:

Hello,

I have a question.

I try to print a ascii file in reverse order( bottom-top).

A quicker way if you have enugh memory would be to malloc a block of
memory you think is large enough for the entire file, fread() the file
into it, go to the last byte and walk backwards through the block.
PLatform specific extensions would help you find how much memory you
needed.
--
Mark McIntyre
CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
CLC readme: <http://www.angelfire.c om/ms3/bchambless0/welcome_to_clc. html>

[Debashish Chakravarty]

Mark McIntyre <ma**********@s pamcop.net> wrote in message :

A quicker way if you have enugh memory would be to malloc a block of
memory you think is large enough for the entire file, fread() the file
into it, go to the last byte and walk backwards through the block.
PLatform specific extensions would help you find how much memory you
needed.

The solution I could think of printing the file in reverse order
without attempting to know the size of the file was a recursive one.
But I think this solution might choke on large files. This recursive
solution is equivalent to pushing characters on a stack and then
popping them, I think reading more than one character at a time would
led to faster code.

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

/*print the characters of the file in reverse order*/
void rev_file_c(FILE *fp)
{
int c;
c=fgetc(fp);
if(c==EOF) return;
rev_file_c(fp);
putchar(c);
}

#define MAX_LINE_SIZE 4096
/*print the lines of the file in reverse order*/
void rev_file_lin(FI LE *fp)
{
char buf[MAX_LINE_SIZE];
char *s;
s=fgets(buf,siz eof buf,fp);
if(NULL==s)
{
if(ferror(fp))
{
perror(NULL);
exit(EXIT_FAILU RE);
}
else return;
}
rev_file_lin(fp );
fputs(buf,stdou t);
}

int
main(void)
{
FILE *fp;
fp=fopen("c:\\t emp\\rev_file.c ","r");
if(NULL == fp)
{
perror(NULL);
return 1;
}
rev_file_c(fp);
fclose(fp);
return 0;
}

--------
Jai Hind!
Vande Mataram.

[CBFalconer]

Debashish Chakravarty wrote:

Mark McIntyre <ma**********@s pamcop.net> wrote in message :

A quicker way if you have enugh memory would be to malloc a block of
memory you think is large enough for the entire file, fread() the file
into it, go to the last byte and walk backwards through the block.
PLatform specific extensions would help you find how much memory you
needed.

The solution I could think of printing the file in reverse order
without attempting to know the size of the file was a recursive one.
But I think this solution might choke on large files. This recursive
solution is equivalent to pushing characters on a stack and then
popping them, I think reading more than one character at a time would
led to faster code.

Try this one. I would write a few things differently today, and
there is an insect in revstring, which won't get triggered here.

/* Routines to reverse a file, char by char. */
/* by C.B. Falconer, 19 Dec. 2001 */
/* Released to public domain. Attribution appreciated */

/* Known bugs - A file without an initial empty line */
/* will have one added. */

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

#define MAXLN 256

typedef struct line {
char *ln;
struct line *next;
} line, *lineptr;

/* =============== =============== ========= */
/* reverse string in place. Return length */
size_t revstring(char *string)
{
char *last, temp;
size_t lgh;

lgh = strlen(string);
last = string + lgh; /* points to '\0' */
while (last-- > string) {
temp = *string; *string++ = *last; *last = temp;
}
return lgh;
} /* revstring */

/* =============== ========== */
/* Reverse file, end to end */
int main(void)
{
char buffer[MAXLN];
lineptr p, last;
size_t lgh;

p = last = NULL;
while (fgets(buffer, MAXLN, stdin)) {
lgh = revstring(buffe r);
if (p = malloc(sizeof (line))) {
p->next = last;
if (p->ln = malloc(lgh + 1)) {
strcpy(p->ln, buffer);
last = p;
}
else {
free(p);
break;
}
}
else break;
}
p = NULL;
while (last) {
free(p);
fputs(last->ln, stdout);
p = last;
last = last->next;
}
if (p && ('\n' != p->ln[strlen(p->ln) - 1]))
fputc('\n', stdout);
free(p);
return 0;
} /* main */

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!

[Mantorok Redgormor]

CBFalconer <cb********@yah oo.com> wrote in message news:<3F******* ********@yahoo. com>...

Debashish Chakravarty wrote:

Mark McIntyre <ma**********@s pamcop.net> wrote in message :

A quicker way if you have enugh memory would be to malloc a block of
memory you think is large enough for the entire file, fread() the file
into it, go to the last byte and walk backwards through the block.
PLatform specific extensions would help you find how much memory you
needed.

The solution I could think of printing the file in reverse order
without attempting to know the size of the file was a recursive one.
But I think this solution might choke on large files. This recursive
solution is equivalent to pushing characters on a stack and then
popping them, I think reading more than one character at a time would
led to faster code.

Try this one. I would write a few things differently today, and
there is an insect in revstring, which won't get triggered here.

/* Routines to reverse a file, char by char. */
/* by C.B. Falconer, 19 Dec. 2001 */
/* Released to public domain. Attribution appreciated */

/* Known bugs - A file without an initial empty line */
/* will have one added. */

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

#define MAXLN 256

typedef struct line {
char *ln;
struct line *next;
} line, *lineptr;

/* =============== =============== ========= */
/* reverse string in place. Return length */
size_t revstring(char *string)
{
char *last, temp;
size_t lgh;

lgh = strlen(string);
last = string + lgh; /* points to '\0' */
while (last-- > string) {
temp = *string; *string++ = *last; *last = temp;
}
return lgh;
} /* revstring */

/* =============== ========== */
/* Reverse file, end to end */
int main(void)
{
char buffer[MAXLN];
lineptr p, last;
size_t lgh;

p = last = NULL;
while (fgets(buffer, MAXLN, stdin)) {
lgh = revstring(buffe r);
if (p = malloc(sizeof (line))) {
p->next = last;
if (p->ln = malloc(lgh + 1)) {
strcpy(p->ln, buffer);
last = p;
}
else {
free(p);
break;
}
}
else break;
}
p = NULL;
while (last) {
free(p);
fputs(last->ln, stdout);
p = last;
last = last->next;
}
if (p && ('\n' != p->ln[strlen(p->ln) - 1]))
fputc('\n', stdout);
free(p);
return 0;
} /* main */

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

static unsigned int byte_count(FILE *);
static void reverse_file(ch ar *, unsigned int);

int main(int argc, char **argv)
{
char *ptr;
unsigned int size;
FILE *fp;

if(argc < 2)
printf("%s <file>\n", argv[0]);
if(!(fp = fopen(argv[1], "r")))
return EXIT_FAILURE;

size = byte_count(fp);

if(!(ptr = malloc(size+1)) )
return EXIT_FAILURE;

ptr[size] = '\0';

fread(ptr, size, sizeof(char), fp);

fclose(fp);

reverse_file(pt r, size);

return EXIT_SUCCESS;
}
static unsigned int byte_count(FILE *fp)
{
int c;
unsigned int count = 0;

while((c = fgetc(fp)) != EOF)
++count;

rewind(fp);

return count;
}

static void reverse_file(ch ar *base, unsigned int size)
{
char *end = &base[size-1];

if(*end == '\n') {
*end = '\0';
--end;
}

for( ; end >= base; --end)
if(*end == '\n') {
*end = '\0';
printf("%s\n", end+1);
}

printf("%s\n", base);

free(base);
}

I think my version might outperform yours.
fgets is kind of slow on large files.

--
nethlek

[CBFalconer]

Mantorok Redgormor wrote:

.... snip ...
I think my version might outperform yours.
fgets is kind of slow on large files.

I believe it doesn't do the same thing. In addition I doubt that
reading a file twice can be faster than reading it once.

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!

[Villy Kruse]

On Thu, 27 Nov 2003 08:07:47 GMT,
CBFalconer <cb********@yah oo.com> wrote:

Mantorok Redgormor wrote:

... snip ...

I think my version might outperform yours.
fgets is kind of slow on large files.

I believe it doesn't do the same thing. In addition I doubt that
reading a file twice can be faster than reading it once.

Not to mention that reading the entire contents of a huge file into memory
is not exactly the best thing to do. But of course having gigabytes of
real memory available will surely help.
Villy

[CBFalconer]

Villy Kruse wrote:

CBFalconer <cb********@yah oo.com> wrote:

Mantorok Redgormor wrote:

... snip ...

I think my version might outperform yours.
fgets is kind of slow on large files.

I believe it doesn't do the same thing. In addition I doubt
that reading a file twice can be faster than reading it once.

Not to mention that reading the entire contents of a huge file
into memory is not exactly the best thing to do. But of course
having gigabytes of real memory available will surely help.

Inasmuch as my version also reads everything into memory, I didn't
consider that a valid objection :-) However the response to
memory allocation failure is also different.

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!