success! I think

[Bill Cunningham]

I began to think about some excercises I could with files after reading
turtorials today on arithmetic operators and confusing myself and decided to
do this.
Take the mv command from linux that moves and renames files read it as
binary and write it as text. After some compiler qipes it compiled and I
believe it did want I wanted it to.

#include <stdio.h>

int main(void) {
FILE *ifp, *ofp;
int a;
ifp=fopen("mv", "rb");
ofp=fopen("m"," wt");
a=fgetc(ifp);
if (a==EOF) {
fclose(ifp);
}
fputc(a,ofp);
if (a==EOF) {
fclose(ofp);
}
}

Because I didn't know how long the file would be I couldn't say exactly
how many bytes I should read so fread/fwrite were out and I decided on
fgetc/fputc. Is my code up to standards? And also can someone tell me what
the first int parameter of fputc is and does? My references that I look at
do not say. But I think I used it right. I guessed a 'container' for a char.

Bill

[Bill Cunningham]

your current problem seems almost identical to one I
gave a solution for. The only difference is the previous one
used fread/fwrite. I cannot comprehend how you can read my code

That's it right there. The ch you used I don't see all of what's going
on in your code. Basically I can't read it all.
Especially down around do.

and then post code that tries to copy a file ***without using a
loop construct***

***By Nick K.***

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

int main(void)
{
char buf [2048];
FILE *fp_in;
FILE *fp_out;
size_t ch_read;

if ((fp_in = fopen ("as.exe", "rb")) == NULL)
{
fprintf (stderr, "failed to open input file\n");
exit (EXIT_FAILURE);
}

if ((fp_out = fopen ("a.exe", "wb")) == NULL)
{
fprintf (stderr, "failed to open output file\n");
fclose (fp_in);
exit (EXIT_FAILURE);
}

do
{
if ((ch_read = fread (buf, 1, sizeof(buf), fp_in)) !=
sizeof(buf)
&& ferror(fp_in))
{
fprintf (stderr, "read error\n");
fclose (fp_in);
fclose (fp_out);
exit (EXIT_FAILURE);
}

if (fwrite (buf, 1, ch_read, fp_out) != ch_read)
{
fprintf (stderr, "write error\n");
fclose (fp_in);
fclose (fp_out);
exit (EXIT_FAILURE);
}
}
while (ch_read == sizeof(buf));

fclose (fp_in);
fclose (fp_out);

return 0;
}
----
do
{
if ((ch_read = fread (buf, 1, sizeof(buf), fp_in)) !=
sizeof(buf)
&& ferror(fp_in))
{

Here's where I get lost.

Bill

[Bartc]

Bill Cunningham wrote:

That's it right there. The ch you used I don't see all of what's
going on in your code. Basically I can't read it all.
Especially down around do.

do
{
if ((ch_read = fread (buf, 1, sizeof(buf), fp_in)) !=
sizeof(buf)
&& ferror(fp_in))
{

Here's where I get lost.

Same here. Most of this is error-checking code that is not so important when
learning.

Without that error code, the main loop comes down to this, where I've
substituted N for sizeof(BUF):

do
{ ch_read = fread (buf, 1, N, fp_in);
fwrite (buf, 1, ch_read, fp_out);
}
while (ch_read == N);

This will read and write blocks of N characters, until either 0 characters
have been read, indicating end-of-file, or 1..N-1 characters have been read,
indicating this was the last (partial) block.

-- Bartc

[Richard Heathfield]

Bartc said:

<snip>

Most of this is error-checking code that is not so important
when learning.

I can't agree with that. If you postpone learning about error-checking
until you've learned everything else, you'll end up never learning about
it at all - and this view is borne out by a huge amount of supposedly
professional code out there in the real world that completely ignores the
idea that anything might ever not quite work out the way the programmer
wants it to.

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Nick Keighley]

On 16 Apr, 12:00, "Bartc" <[e-mail] mwrote:

Bill Cunningham wrote:

* *That's it right there. The ch you used I don't see all of what's
going on in your code. Basically I can't read it all.
Especially down around do.
do
* *{
* * * *if ((ch_read = fread (buf, 1, sizeof(buf), fp_in)) !=
sizeof(buf)
* * * * * * && *ferror(fp_in))
* * * *{

Here's where I get lost.

Same here. Most of this is error-checking code that is not so important when
learning.

eek!

Without that error code, the main loop comes down to this, where I've
substituted N for sizeof(BUF):

* * do
* * { * ch_read = fread (buf, 1, N, fp_in);
* * * * fwrite (buf, 1, ch_read, fp_out);
* * }
* * while (ch_read == N);

the original post had a piece of p-code
almost identical to the above.

>
This will read and write blocks of N characters, until either 0 characters
have been read, indicating end-of-file, or 1..N-1 characters have been read,
indicating this was the last (partial) block.

--
Nick Keighley

[Nick Keighley]

On 16 Apr, 03:07, "Bill Cunningham" <nos...@nspam.c omwrote:

your current problem seems almost identical to one I
gave a solution for. The only difference is the previous one
used fread/fwrite. I cannot comprehend how you can read my code

* * That's it right there. The ch you used I don't see all of what's going
on in your code. Basically I can't read it all.
Especially down around do.

and then post code that tries to copy a file ***without using a
loop construct***

and I still don't understand why you tried to mange without a loop...
It doesn't have to be a do while (I'm not very fond of 'em)
but you do need a loop

***By Nick K.***

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

int main(void)
{
* * char buf [2048];
* * FILE *fp_in;
* * FILE *fp_out;
* * size_t ch_read;

* * if ((fp_in = fopen ("as.exe", "rb")) == NULL)
* * {
* * * * fprintf (stderr, "failed to open input file\n");
* * * * exit (EXIT_FAILURE);
* * }

* * if ((fp_out = fopen ("a.exe", "wb")) == NULL)
* * {
* * * * fprintf (stderr, "failed to open output file\n");
* * * * fclose (fp_in);
* * * * exit (EXIT_FAILURE);
* * }

* * do
* * {
* * * * if ((ch_read = fread (buf, 1, sizeof(buf), fp_in)) !=
sizeof(buf)
* * * * * * *&& *ferror(fp_in))
* * * * {
* * * * * * fprintf (stderr, "read error\n");
* * * * * * fclose (fp_in);
* * * * * * fclose (fp_out);
* * * * * * exit (EXIT_FAILURE);
* * * * }

* * * * if (fwrite (buf, 1, ch_read, fp_out) != ch_read)
* * * * {
* * * * * * fprintf (stderr, "write error\n");
* * * * * * fclose (fp_in);
* * * * * * fclose (fp_out);
* * * * * * exit (EXIT_FAILURE);
* * * * }
* * }
* * while (ch_read == sizeof(buf));

* * fclose (fp_in);
* * fclose (fp_out);

* * return 0;

}

----
*do
* * {
* * * * if ((ch_read = fread (buf, 1, sizeof(buf), fp_in)) !=
sizeof(buf)
* * * * * * *&& *ferror(fp_in))
* * * * {

Here's where I get lost.

ok. I suppose assigning and testing all in one statement
is a bit Cish (though I'm not the onlt perpetrator!).

My code with the write taken out

do
{
if ((ch_read = fread (buf, 1, sizeof(buf), fp_in)) != sizeof(buf)
&& ferror(fp_in))
{
TERMINATE;
}
}
while (ch_read == sizeof(buf))
simplify the if

do
{
ch_read = fread (buf, 1, sizeof(buf), fp_in);

/* terminate the program if too few characters were read
and an error occurred. Note a "short" read could be
simply caused by getting to the end of the file and
that shouldn't be treated as an error */
if ((ch_read != sizeof(buf) && ferror(fp_in))
{
TERMINATE;
}
}
while (ch_read == sizeof(buf)); /* read until we get a short non-
error read */

is that clearer?

or this (no do-while)

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

int main(void)
{
char buf [2048];
FILE *fp_in;
FILE *fp_out;
size_t ch_read;

if ((fp_in = fopen ("as.exe", "rb")) == NULL)
{
fprintf (stderr, "failed to open input file\n");
exit (EXIT_FAILURE);
}

if ((fp_out = fopen ("a.exe", "wb")) == NULL)
{
fprintf (stderr, "failed to open output file\n");
fclose (fp_in);
exit (EXIT_FAILURE);
}

ch_read = sizeof(buf);
while (ch_read == sizeof(buf))
{
ch_read = fread (buf, 1, sizeof(buf), fp_in);

if ((ch_read != sizeof(buf) && ferror(fp_in))
{
fprintf (stderr, "read error\n");
fclose (fp_in);
fclose (fp_out);
exit (EXIT_FAILURE);
}

if (fwrite (buf, 1, ch_read, fp_out) != ch_read)
{
fprintf (stderr, "write error\n");
fclose (fp_in);
fclose (fp_out);
exit (EXIT_FAILURE);
}
}

fclose (fp_in);
fclose (fp_out);

return 0;
}
this makes an extra test
--
Nick Keighley

GOD is REAL
unless a type declaration to the contrary is made

[Bartc]

"Richard Heathfield" <rj*@see.sig.in validwrote in message
news:5-*************** ******@bt.com.. .

Bartc said:

<snip>

>Most of this is error-checking code that is not so important
when learning.

I can't agree with that. If you postpone learning about error-checking
until you've learned everything else, you'll end up never learning about
it at all

OK, keep the extended checking for the next lesson then.

The essential checks are verifying the file handles, and checking for
end-of-file, and these are done here.

Other checks are for errors unlikely in a learning situation, but themselves
become essential if this code was put into a library function to be used in
many different circumstances.

Otherwise the code looks overwhelming.

Quote from K&R2 p.164: "Although output errors are rare, they do occur (for
example, if a disk fills up), so a production program should check this as
well". Note the word 'production'.
--
Bart

[Richard Heathfield]

Bartc said:

<snip>

>
Quote from K&R2 p.164: "Although output errors are rare, they do occur
(for example, if a disk fills up), so a production program should check
this as well". Note the word 'production'.

Yes. I have a great deal of respect for Brian Kernighan, but that doesn't
mean I agree with him about every single thing - and this is one of the
places where I disagree.

When illustrative (i.e. exegetic) code includes full error-checking, the
explanation can be in danger of getting a little lost, so there's a case
for giving two versions of such code: (a) here's the basic idea; (b)
here's how it looks when we do it properly. How else will the student
learn how to deal with the imperfect real world?

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Bill Cunningham]

"Richard Heathfield" <rj*@see.sig.in validwrote in message
news:5-*************** ******@bt.com.. .

I can't agree with that. If you postpone learning about error-checking
until you've learned everything else, you'll end up never learning about
it at all - and this view is borne out by a huge amount of supposedly
professional code out there in the real world that completely ignores the
idea that anything might ever not quite work out the way the programmer
wants it to.

I haven't got to do and certainly not switch yet. But I'm getting pretty
good with for and using while without braces. A continuous loop with
basically two decsions. I learned how to open and close a file and use fread
fwrite simply at first without error checking. I knew error checking was
good needed to be learned too so that was the next step. After I was opening
and closing files and writing both binary and text (with fprintf). I added
error checking. Then tried for fgetc and that's where I am now. I personally
would have to agree with Bart. A person just needs to realize at the outset
they will need error checking in real life.

I had to conquer the open /write/close beast then the error checking and
I also notice most people don't use feof() but EOF.

Bill

[Bill Cunningham]

[snip]

is that clearer?

or this (no do-while)

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

int main(void)
{
char buf [2048];
FILE *fp_in;
FILE *fp_out;
size_t ch_read;

if ((fp_in = fopen ("as.exe", "rb")) == NULL)
{
fprintf (stderr, "failed to open input file\n");
exit (EXIT_FAILURE);
}

if ((fp_out = fopen ("a.exe", "wb")) == NULL)
{
fprintf (stderr, "failed to open output file\n");
fclose (fp_in);
exit (EXIT_FAILURE);
}

ch_read = sizeof(buf);
while (ch_read == sizeof(buf))
{
ch_read = fread (buf, 1, sizeof(buf), fp_in);

if ((ch_read != sizeof(buf) && ferror(fp_in))
{
fprintf (stderr, "read error\n");
fclose (fp_in);
fclose (fp_out);
exit (EXIT_FAILURE);
}

if (fwrite (buf, 1, ch_read, fp_out) != ch_read)
{
fprintf (stderr, "write error\n");
fclose (fp_in);
fclose (fp_out);
exit (EXIT_FAILURE);
}
}

fclose (fp_in);
fclose (fp_out);

return 0;
}
this makes an extra test
That's the way I learned yes that's great! Except I didn't learn with the
while braces that seems to be an option and the sequential reading makes for
good error check I've found out. I use return -1 instead of the exit
macros.

Bill

[Bill Cunningham]

I put together this code that seems to work great by studying your code
and other code I have saved and been studying .

#include <stdio.h>

int main(int argc, char *argv[]) {
FILE *ifp,*ofp;
int a;
if(argc!=3) {
fprintf(stderr, "usage error\n");
return -1;
}
ifp=fopen(argv[1],"rb");
if (ifp==0) {
fprintf(stderr, "input error\n");
return -1;
}
ofp=fopen(argv[2],"wb");
if (ofp==0) {
fprintf(stderr, "output error\n");
return -1;
}
while((a=fgetc( ifp))!=EOF)
fputc(a,ofp);
fclose(ifp);
fclose(ofp);
printf("done\n" );
return 0;
}

A little less overhead without stdlib and using return -1 if that really
matters. It seems to work like cp.

Bill