Re: suggested addition to -Wparentheses: warn about ` ! x & 1 '

Re: suggested addition to -Wparentheses: warn about ` ! x & 1 '

[Jim Meyering]

Joern Rennecke <amylaar@cygnus.co.uk> writes:
| > I was a little surprised to see that gcc -Wparentheses doesn't
| > warn about this mix of `!' and `&':
| >
| >   int foo (int x) { return ! x&1; }
| >
| > Can anyone think of a reason not to add this functionality?
|
| Yes.  It's easy to remember that the unary operators have a high
| priority.  There are some useful constructs that would be warned about,
| and adding superflous parantheses often makes the code harder to read.

But first you have to know that.
Some people don't.

Would you give an example or two of such useful constructs?

Re: egcs release

[Jim Wilson]

	Thanks. I can use egcs compile glibc now. It passed "make check".
	BTW, how about the long long bug in cpp? I have a patch for it.

I have lots of bug reports and patches from you.  It would be helpful if
you could prioritize them, so I know which ones to work on first.

Jim

Re: suggested addition to -Wparentheses: warn about ` ! x & 1 '

[Michael R Cook]

>>>>> "PS" == Peter Seebach  writes:

 >> Hmm, maybe you could make an option -Wall-parentheses, which warns if
 >> any construct is ambigous if operator precedence is not taken into account.
 >> That would cover this case, and all the related ones...

 PS> Yeah, but I don't want warnings on
 PS> 	2 * 3 + 5;

Ideally, all warnings would be very specific, and would be given a
unique identifier, and we'd be able to enable and disable them
individually.  Even better would be if we could enable/disable them
on a sub-file basis; for example:

  __warning(+4701); /* Enable the "Misaligned frobnicator" warning */
  x = 2 * 3 + 5;
  __warning(-4701); /* Disable */

or

  x = __warning(+4701, 2 * 3 + 5);
    /* Evaluate the expression `e' with warning 4701 enabled. */

For macros and headers, we'd want to be able to maintain a kind of
stack for enabling and disabling warnings.  For example, if a
warning is disabled N times, it would have to be enabled N times
before it really became enabled.  Perhaps something like:
__warning(++4701) and __warning(--4701).

Warning identifiers could be assigned so that similar warnings were
consecutive, so you could maybe enable and disable sets of similar
warnings all at once:

 __warning(+3201..3299) /* gimme all of the parentheses warnings */

This functionality would subsume probably all of the existing -W
options.

Re: suggested addition to -Wparentheses: warn about ` ! x & 1 '

[Peter Seebach]

>> | > I was a little surprised to see that gcc -Wparentheses doesn't
>> | > warn about this mix of `!' and `&':
>> | >
>> | >   int foo (int x) { return ! x&1; }
>> | >
>> | > Can anyone think of a reason not to add this functionality?

>Hmm, maybe you could make an option -Wall-parentheses, which warns if
>any construct is ambigous if operator precedence is not taken into account.
>That would cover this case, and all the related ones...

Yeah, but I don't want warnings on
	2 * 3 + 5;

>> Would you give an example or two of such useful constructs?

>!x & y , where y is a variable.

That could be spelled as
	y & !x;

unambiguously.  (And, IMHO, more idiomatically, as I always try to leave
the thing masked on the left, and the mask on the right.)

>!x & (y) , where y is a macro argument that may or may not be constant...

I'd probably do that as
	(!x) & (y)

I will admit to occasionally being bitten by things like the '!x & y', just
because I do enough sh to think of '!' as working on everything in sight.

-s

Re: suggested addition to -Wparentheses: warn about ` ! x & 1 '

[Joern Rennecke]

> I was a little surprised to see that gcc -Wparentheses doesn't
> warn about this mix of `!' and `&':
> 
>   int foo (int x) { return ! x&1; }
> 
> Can anyone think of a reason not to add this functionality?

Yes.  It's easy to remember that the unary operators have a high
priority.  There are some useful constructs that would be warned about,
and adding superflous parantheses often makes the code harder to read.

suggested addition to -Wparentheses: warn about ` ! x & 1 '

[Jim Meyering]

I think it would be worthwhile to add at least one more case in which
-Wparentheses gives a warning.  I just saw someone fix a bug that
such an addition would have highlighted.

I was a little surprised to see that gcc -Wparentheses doesn't
warn about this mix of `!' and `&':

  int foo (int x) { return ! x&1; }

Can anyone think of a reason not to add this functionality?