Boolean OR (double pipe) and ISO C99

[Ian Zimmerman]

Hello, I hate to make a fool of myself, but:
in C99, is

var = ((exp1) || (exp2));

necessarily equivalent to

int temp = (exp1); var = (temp != 0 ? temp : (exp2));

as I believe it was in pre-99 C? gcc seems to compile it rather as

var = ((exp1) != 0 || (exp2) != 0)

ie. the final value of var is always 0 or 1.

If this latter translation is indeed correct, can anyone think of
a way to achieve the old effect without a temporary variable?
This code needs to go into a macro, and exp1 and exp2 are potentially
complex expressions involving function calls and side effects.

--
"It's not true or not." A reality show producer (real quote)

[Michael Mair]

Ian Zimmerman wrote:

Hello, I hate to make a fool of myself, but:
in C99, is

var = ((exp1) || (exp2));

necessarily equivalent to

int temp = (exp1); var = (temp != 0 ? temp : (exp2));

as I believe it was in pre-99 C?
It was not. || gives you 1 if one of its operands is
not equal to 0.
gcc seems to compile it rather as

var = ((exp1) != 0 || (exp2) != 0)

ie. the final value of var is always 0 or 1.
This is correct behaviour.
The standard did not change in that respect.

If this latter translation is indeed correct, can anyone think of
a way to achieve the old effect without a temporary variable?
This code needs to go into a macro, and exp1 and exp2 are potentially
complex expressions involving function calls and side effects.

Umh, I fear you will need some sort of "var" as above if you
do not want the whole thing too complicated.
I would either go for
(var=(exp1)) || (var=(exp2))
or
(var=(exp1)) ? (var) : (var=(exp2))
and pass var, calling the macro SET_VAR_....(var, ....)
or "return"
(var=(exp1)) ? (var) : (exp2)

<OT>
BTW: Within the last couple of months, there was a discussion
of a GNU extension which would have permitted you solving
your problem by (exp1)?:(exp2). Maybe you can find other
interesting arguments/alternatives there.

http://groups.google.de/groups?selm=....cs.purdue.edu
</OT>
Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.

[Jack Klein]

On 11 Dec 2004 23:11:06 -0800, Ian Zimmerman <it*@buug.org> wrote in
comp.lang.c:

Hello, I hate to make a fool of myself, but:
in C99, is

var = ((exp1) || (exp2));

necessarily equivalent to

int temp = (exp1); var = (temp != 0 ? temp : (exp2));
No, the result of both the || and && operators has always been an int
with the value of 0 or 1.
as I believe it was in pre-99 C? gcc seems to compile it rather as
Where did you come up with this belief? It has never been correct.
var = ((exp1) != 0 || (exp2) != 0)

ie. the final value of var is always 0 or 1.
Yes, the final value must always be 0 or 1. From the day that these
operators were added to the language, before the publication of the
first edition of the C Programming Language in 1978.
If this latter translation is indeed correct, can anyone think of
a way to achieve the old effect without a temporary variable?
This code needs to go into a macro, and exp1 and exp2 are potentially
complex expressions involving function calls and side effects.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Ian Zimmerman]

int temp = (exp1); var = (temp != 0 ? temp : (exp2));

Jack> No, the result of both the || and && operators has always been an
Jack> int with the value of 0 or 1.

Ian> as I believe it was in pre-99 C? gcc seems to compile it rather as

Jack> Where did you come up with this belief? It has never been
Jack> correct.

From reading and writing too much Lisp/Scheme, no doubt.
;-)

Anyway, I found a workaround with a bit of refactoring; the function call
in exp2 now takes the value of exp1 as an argument, and does nothing if
the latter is nonzero.

--
"It's not true or not." A reality show producer (real quote)