On 5/13/23 1:53 AM, Po Lu wrote:
> There are no ``errors'' in Standard C (with the possible exception of
> the #error preprocessing directive), only constraint and syntax rule
> violations. Such violations are required to generate diagnostic
> messages, after which the behavior of the translator ceases to be
> defined by the Standard, but GNU C defines it to mean that the type is
> int.
GNU C does not define any such thing. It may happen to turn out that
way, but that is not the same as defining its behavior.
> Nor does GCC conform to the Standard by default: while it is okay for a
> conforming implementation to translate programs relying on implicit int,
> as there is no way doing so will alter the behavior of any strictly
> conforming program, it is not okay to reserve keywords such as `asm'.
>
> The following strictly conforming program is thus not acceptable to GCC,
> unless GCC is operating in standards-conformance mode:
>
> int
> main (argc, argv)
> int argc;
> char **argv;
> {
> int asm;
> return asm = 0;
> }
>
> which shows that debating features based on the Standard is entirely
> pointless, as the Standard allows implementations to provide almost
> anything it prohibits.
Sure, all I have to do is tell GCC to act like a C compiler.
$ gcc -std=c2x /tmp/po.c -o /tmp/po; /tmp/po; echo $?
/tmp/po.c: In function ‘main’:
/tmp/po.c:2:3: warning: old-style function definition
[-Wold-style-definition]
2 | main (argc, argv)
| ^~~~
0
But I don't understand what point you are trying to make, anyway. The
Standard allows, but does not require, implementations to do many things
if it so chooses. GNUC takes advantage of this when operating in GNUC
mode, when also documenting GNUC features in the HTML docs.
What does this have to do with implicit-int, which is a constraint
violation? Where in the GNUC html documentation does it say that
constraint violations applied to Type specifiers have been carved out as
a GNUC extension?
It's not a GNUC extension, you cannot assume it will work. It might work
anyway, but that's a matter of luck.
> So I ask you again: what is unclear about declarations which are
> implicitly int, in a way that is likely to cause program errors?
It is unclear why you are overly focused on implicit-int, to be honest.
But your arguments in favor of implicit-int aren't very compelling either.
--
Eli Schwartz
