for(;;) or while(1)?

[Rick]

Hi,

For portability, can an issue arise if we use while(1) for an infinite
loop in C? If so, should we then use for(;;)? Thanks,

Rick

[CBFalconer]

goose wrote:

.... snip ...
if you need to *handle* the error at some point, then just
add in an integer to keep track of it

int error = 0;
x = y = z = NULL;
if (x = malloc (a)) {
...
if (y = malloc (b)) {
...
if (z = malloc (c)) {
...
} else error = 1;
} else error = 2;
} else error = 3;

if (x) free (x);
if (y) free (y);
if (z) free (z);

switch (error) {
case 1: printf ("no mem for z occurred\n"); break;
case 2: printf ("no mem for y occurred\n"); break;
case 3: printf ("no mem for x occurred\n"); break;
default: printf ("no error\n");
}

Complications not needed. The equivalent is:

....
x = y = z = NULL
if (!(x = malloc(a))) printf("...");
else if (!(y = malloc(b))) printf("...");
else if (!(z = malloc(c))) printf("...");
else {
....
}
free(z); free(y); free(x);

( If you don't like the "!(" replace with "NULL != (" )

and you can always factor "malloc(b)" etc. into a routine:

T *routine(b, others)
{
....
return malloc(b);
}

if you must have independent operations between the mallocs.
routine may even include the printf and be common to all three
cases, for net code reduction.

I think I said all this earlier. Maybe that was another thread.

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

[Larry Doolittle]

In article <3F*************@yahoo.com>, CBFalconer wrote:

Complications not needed. The equivalent is:
....
x = y = z = NULL
if (!(x = malloc(a))) printf("...");
else if (!(y = malloc(b))) printf("...");
else if (!(z = malloc(c))) printf("...");
else {
....
}
free(z); free(y); free(x);
and you can always factor "malloc(b)" etc. into a routine:
T *routine(b, others)
{
....
return malloc(b);
}
if you must have independent operations between the mallocs.

This is also an interesting place for a "," (comma) operator.
x = y = z = NULL
if ( !(x = malloc(a))) printf("...");
else if (setup1(x), !(y = malloc(b))) printf("...");
else if (setup2(x,y),!(z = malloc(c))) printf("...");
else {
....
}
where setup1() and setup2() can be either true functions,
or just some simple in-line code.

It doesn't use malloc(), but you can see a similar interaction
of the comma operator and a chain of else-if's in busybox's
date.c:date_conv_ftime() routine. While a bit unusual,
it doesn't take long to grasp, and the code path is greatly
simplified compared to other constructs. This is the author
speaking, so you can take this as a totally unbiased assessment.

- Larry

[goose]

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

goose wrote:

... snip ...

if you need to *handle* the error at some point, then just
add in an integer to keep track of it

int error = 0;
x = y = z = NULL;
if (x = malloc (a)) {
...
if (y = malloc (b)) {
...
if (z = malloc (c)) {
...
} else error = 1;
} else error = 2;
} else error = 3;

if (x) free (x);
if (y) free (y);
if (z) free (z);

switch (error) {
case 1: printf ("no mem for z occurred\n"); break;
case 2: printf ("no mem for y occurred\n"); break;
case 3: printf ("no mem for x occurred\n"); break;
default: printf ("no error\n");
}

Complications not needed. The equivalent is:

....
x = y = z = NULL
if (!(x = malloc(a))) printf("...");
else if (!(y = malloc(b))) printf("...");
else if (!(z = malloc(c))) printf("...");
else {
....
}
free(z); free(y); free(x);

but what if my "error handler" needs to do more than
print a diagnostic ? changing it to the following:

x = y = z = NULL
if (!(x = malloc(a))) {
/* close files */
/* restore signals */
/* print a message */
}
else if (!(y = malloc(b))) {
/* close files */
/* restore signals */
/* print a message */
}
else if (!(z = malloc(c))) {
/* close files */
/* restore signals */
/* print a message */
}

else {
....
}
free(z); free(y); free(x);

and now /that/ does look complicated. with switch
statement, you can at least add tons of error handling
cpode without it getting in the way of readability of
the logic.

( If you don't like the "!(" replace with "NULL != (" )

and you can always factor "malloc(b)" etc. into a routine:

T *routine(b, others)
{
....
return malloc(b);
}
this is best, really.

if you must have independent operations between the mallocs.
routine may even include the printf and be common to all three
cases, for net code reduction.

I think I said all this earlier. Maybe that was another thread.

no, i came into the thread late, i think :-)

goose,
latecomer