Desire gcc option to skip warnings in standard headers

Desire gcc option to skip warnings in standard headers

[Frederick W. Wheeler]

It would be very convenient for me to have a gcc command-line option
or #pragma to prevent the printing of warnings in the standard
headers.  Warnings could begin to be issued at the first line that is
not #include <something.h>.  It seems to me that this would be
relatively easy to implement.

For example, in the following code I would like to have an option to
print no warnings until line 3 (which is blank).

1   #include <stream.h>
2   #include <math.h>
3
4   #include "myheader.h"

Of course, once warning begin to be printed, references back to lines
in the standard headers should be printed.

I use almost all of the gcc -W* options to lintify my code.  I have to
resort to a clumsy grep command to get rid of the deluge of warnings
occuring in the standard headers.

I am grateful to the people who have developed gcc and egcs.  These
are great systems.  Thanks for your hard work.

Regards,
Fred Wheeler

Re: Desire gcc option to skip warnings in standard headers

[Branko Cibej]

Frederick W. Wheeler wrote:

> It would be very convenient for me to have a gcc command-line option
> or #pragma to prevent the printing of warnings in the standard
> headers.  Warnings could begin to be issued at the first line that is
> not #include <something.h>.  It seems to me that this would be
> relatively easy to implement.

Here's a simple patch that inhibits warnings generated in system headers
unless '-Wsystem-headers' is specified. It doesn't attempt to handle
warnings generated by cccp or cpplib yet.

Comments, anybody? Is this the right way to do it?

--
Branko Cibej   <branko.cibej@hermes.si>
HERMES SoftLab, Litijska 51, 1000 Ljubljana, Slovenia
phone: (++386 61) 186 53 49  fax: (++386 61) 186 52 70

Re: Desire gcc option to skip warnings in standard headers

[Carlo Wood]

| Here's a simple patch that inhibits warnings generated in system headers
| unless '-Wsystem-headers' is specified. It doesn't attempt to handle
| warnings generated by cccp or cpplib yet.
| 
| Comments, anybody? Is this the right way to do it?

I don't like this, I think the new option should turn
warning off if used, but by default give warnings for
system headers too.

-- 
 Carlo Wood  <carlo@runaway.xs4all.nl>

Re: Desire gcc option to skip warnings in standard headers

[Branko Cibej]

Carlo Wood wrote:

> | Comments, anybody? Is this the right way to do it?
>
> I don't like this, I think the new option should turn
> warning off if used, but by default give warnings for
> system headers too.

That's trivial to do, of course -- most probably I should just invert the
meaning of the option. What about the name of the option, though? I don't like
-W(no-)system-headers, even though I thought it up myself...

--
Branko Cibej   <branko.cibej@hermes.si>
HERMES SoftLab, Litijska 51, 1000 Ljubljana, Slovenia
phone: (++386 61) 186 53 49  fax: (++386 61) 186 52 70

Re: Desire gcc option to skip warnings in standard headers

[Carlo Wood]

| > I don't like this, I think the new option should turn
| > warning off if used, but by default give warnings for
| > system headers too.
| 
| That's trivial to do, of course -- most probably I should just invert the
| meaning of the option. What about the name of the option, though? I don't like
| -W(no-)system-headers, even though I thought it up myself...

Hmm, it appears to be not logical...
Looking at most other -W options.

A #pragma seems more logical, and more flexible too.

Other compilers allow to turn off each type of
warning seperately with a #pragma, which would be
the ideal.  It would introduce a boolean for each type
of warning, and I imagine we need an array for that:
An array that contains these variables, and the warnings
and some code that is used.

struct warning {
  short warn_code;
  const char *format;
  unsigned int flags;	// Contains flag to turn it on/off with a #pragma
};

enum {
  warnFoo
  ...
};

struct warning warnings[] = {
  { warnFoo, "You're not allowed to foo around: %s", pendanticWarning },
  ...

...

  print_warning(warnFoo, error);

...


Doesn't that look nice? :)

-- 
 Carlo Wood  <carlo@runaway.xs4all.nl>

Re: Desire gcc option to skip warnings in standard headers

[Jeffrey A Law]

  In message < 199806291617.SAA24744@jolan.ppro >you write:
  > A #pragma seems more logical, and more flexible too.
pragmas are generally frowned upon in gcc.  You'll have a hard time
convincing anyone to accept new ones.

jeff

Re: Desire gcc option to skip warnings in standard headers

[Andi Kleen]

In message < 15759.899189718@hurl.cygnus.com >you write:
>
>  In message < 199806291617.SAA24744@jolan.ppro >you write:
>  > A #pragma seems more logical, and more flexible too.
>pragmas are generally frowned upon in gcc.  You'll have a hard time
>convincing anyone to accept new ones.

Many of the reasons why pragmas are disliked (not usable in macros
etc.) are gone with the ISO C9x _Pragma() construct. Of course there
could be still name collisions of pragma names with other compilers, 
but that can be easily fixed which a #ifdef (and __attribute__ needs 
#ifdef magic too)


-Andi

Re: Desire gcc option to skip warnings in standard headers

[Carlo Wood]

| >  > A #pragma seems more logical, and more flexible too.
| >pragmas are generally frowned upon in gcc.  You'll have a hard time
| >convincing anyone to accept new ones.
| 
| Many of the reasons why pragmas are disliked (not usable in macros
| etc.) are gone with the ISO C9x _Pragma() construct. Of course there
| could be still name collisions of pragma names with other compilers, 
| but that can be easily fixed which a #ifdef (and __attribute__ needs 
| #ifdef magic too)

The reason I thought about #pragma's is because it is more flexible:
allows to turn on and off particular warnings at any line number.
The use of -Woptions are effective for every file and line number.

I don't really care to have the possibility to turn warnings on and off
though, except when it is impossible to write good code that doesn't
cause the warning.  I always use -Wall -Woverloaded-virtual
-Wpointer-arith -Winline -Werror anyway.
There are only a few cases sometimes a bit annoying, like the
"might be used uninitialized".

Having broken system headers is of course a whole different story:
Not everyone is sys admin and able to fix them.

The -Wno-system-headers is actually very good solution to real
problem as originally posted :).

-- 
 Carlo Wood  <carlo@runaway.xs4all.nl>

Re: Desire gcc option to skip warnings in standard headers

[Mumit Khan]

On Tue, 30 Jun 1998, Jeffrey A Law wrote:

> 
> pragmas are generally frowned upon in gcc.  You'll have a hard time
> convincing anyone to accept new ones.
> 

And for good reasons in most cases. However, what if the native API
requires it (especially if the native headers are unusable w/out it)?

Now I'm having second thoughts submitting patches for Win32 specific
pragmas (sysv like #pragma pack with a slight twist, and also push/pop 
of packing stack) ... these are all necessary thanks to you know who.

Mumit

Re: Desire gcc option to skip warnings in standard headers

[Raja R Harinath]

Mumit Khan <khan@xraylith.wisc.edu> writes:
> On Tue, 30 Jun 1998, Jeffrey A Law wrote:
> > pragmas are generally frowned upon in gcc.  You'll have a hard time
> > convincing anyone to accept new ones.
> 
> And for good reasons in most cases. However, what if the native API
> requires it (especially if the native headers are unusable w/out it)?

Isn't that what `fixincludes' is meant for.

- Hari
-- 
Raja R Harinath ------------------------------ harinath@cs.umn.edu
"When all else fails, read the instructions."      -- Cahn's Axiom
"Our policy is, when in doubt, do the right thing."   -- Roy L Ash

Re: Desire gcc option to skip warnings in standard headers

[Branko Cibej]

Carlo Wood wrote:

> A #pragma seems more logical, and more flexible too.
>
> Other compilers allow to turn off each type of
> warning seperately with a #pragma, which would be
> the ideal.  It would introduce a boolean for each type
> of warning, and I imagine we need an array for that:
> An array that contains these variables, and the warnings
> and some code that is used.

Och aye, I know a certain compiler that does that. The feature is used widely in the
rather broken libraries shipped with said compiler...

Anyway, I agree with Jeff that #pragmas are not the way to go. One does want to
write portable code once in a while.[skip some very non-egcs-ish example code]

> ...
>
> Doesn't that look nice? :)

Beautiful, and I'm sure you'd be willing to spend some time to modify egcs in this
manner :->

--
Branko Cibej   <branko.cibej@hermes.si>
HERMES SoftLab, Litijska 51, 1000 Ljubljana, Slovenia
phone: (++386 61) 186 53 49  fax: (++386 61) 186 52 70

Re: Desire gcc option to skip warnings in standard headers

[Jeffrey A Law]

  In message < 3597B270.EC811EB4@hermes.si >you write:
  > Carlo Wood wrote:
  > 
  > > | Comments, anybody? Is this the right way to do it?
  > >
  > > I don't like this, I think the new option should turn
  > > warning off if used, but by default give warnings for
  > > system headers too.
  > 
  > That's trivial to do, of course -- most probably I should just invert the
  > meaning of the option. What about the name of the option, though? I don't like
  > -W(no-)system-headers, even though I thought it up myself...
Warnings should be enabled by -W<foo> and disabled by -Wno-<foo>.  I'm
not aware of any that do not follow that convention and I don't think we
should start making any now :-)

The default behavior can either be on or off, that's separate from 
making -W<foo> and -Wno-<foo> do the right thing.

jeff

Re: Desire gcc option to skip warnings in standard headers

[Branko Cibej]

Jeffrey A Law wrote:

>   > That's trivial to do, of course -- most probably I should just invert the
>   > meaning of the option. What about the name of the option, though? I don't like
>   > -W(no-)system-headers, even though I thought it up myself...
> Warnings should be enabled by -W<foo> and disabled by -Wno-<foo>.  I'm
> not aware of any that do not follow that convention and I don't think we
> should start making any now :-)
>
> The default behavior can either be on or off, that's separate from
> making -W<foo> and -Wno-<foo> do the right thing.

Right. The attached patches don't change the default behaviour, but inhibit warnings
from system headers if -Wno-system-headers. The patch for cpplib is separate because I
haven't really tested it -- I'd have to reconfigure the compiler. BTW, the patches are
against the latest snapshot.

--
Branko Cibej   <branko.cibej@hermes.si>
HERMES SoftLab, Litijska 51, 1000 Ljubljana, Slovenia
phone: (++386 61) 186 53 49  fax: (++386 61) 186 52 70

Re: Desire gcc option to skip warnings in standard headers

[Branko Cibej]

Branko Cibej wrote:

> Frederick W. Wheeler wrote:
>
> > It would be very convenient for me to have a gcc command-line option
> > or #pragma to prevent the printing of warnings in the standard
> > headers.  Warnings could begin to be issued at the first line that is
> > not #include <something.h>.  It seems to me that this would be
> > relatively easy to implement.
>
> Here's a simple patch that inhibits warnings generated in system headers
> unless '-Wsystem-headers' is specified. It doesn't attempt to handle
> warnings generated by cccp or cpplib yet.

Here's another patch, this one handles cccp.

> Comments, anybody? Is this the right way to do it?

(Yes, yes, cut-and-paste programming and no changelog entries, but I'm just
playing around for the moment).

--
Branko Cibej   <branko.cibej@hermes.si>
HERMES SoftLab, Litijska 51, 1000 Ljubljana, Slovenia
phone: (++386 61) 186 53 49  fax: (++386 61) 186 52 70

Re: Desire gcc option to skip warnings in standard headers

[Nathan Myers]

Frederick W. Wheeler wrote:
> 
> It would be very convenient for me to have a gcc command-line option
> or #pragma to prevent the printing of warnings in the standard
> headers.  Warnings could begin to be issued at the first line that is
> not #include <something.h>.  It seems to me that this would be
> relatively easy to implement.

Note that not all warnings are undesirable even from very bad headers.

In particular, a warning that a macro is being redefined helps protect
you when non-system-header code defines a macro that is (re)defined in
a system header.  System headers don't tend to do this to themselves,
so emitting the warning anyway would usually be a Good Thing.

Nathan Myers
ncm@cantrip.org

Re: Desire gcc option to skip warnings in standard headers

[Joseph H. Buehler]

> It would be very convenient for me to have a gcc command-line option
> or #pragma to prevent the printing of warnings in the standard
> headers.  Warnings could begin to be issued at the first line that is
> not #include <something.h>.  It seems to me that this would be
> relatively easy to implement.

If this gets implemented in gcc, I suggest a better way to define
"system header" than "presence of #include<> syntax".

Where I work, we *never* use

    #include "whatever.h"

because developers compile their files against a shared nightly build
area.  Consider having a .c file in the shared area and a .h file
being edited in your private work area.  Some vendors' compilers, when
compiling the .c file, will *always* look for the .h in the directory
containing the .c file: there is no way to override this.

So we always use the <> syntax so we have complete control over the
include file path.

Joe Buehler