From Newsgroup: comp.lang.c

On 2025-08-05 23:08, Kaz Kylheku wrote:

On 2025-08-04, Michael S <already5chosen@yahoo.com> wrote:

On Mon, 04 Aug 2025 09:53:51 -0700
Keith Thompson <Keith.S.Thompson+u@gmail.com> wrote:

In C17 and earlier, _BitInt is a reserved identifier. Any attempt to
use it has undefined behavior. That's exactly why new keywords are
often defined with that ugly syntax.

That is language lawyer's type of reasoning. Normally gcc maintainers
are wiser than that because, well, by chance gcc happens to be widely
used production compiler. I don't know why this time they had chosen
less conservative road.

They invented an identifer which lands in the _[A-Z].* namespace
designated as reserved by the standard.

What would be an exmaple of a more conservative way to name the
identifier?

What is actually going on is GCC offering its users a gradual way to transition from C17 to C23, by applying the C23 meaning of any C23
construct that has no conflicting meaning in C17 . In particular, this
allows installed library headers to use the new types as part of
logically opaque (but compiler visible) implementation details, even
when those libraries are used by pure C17 programs. For example, the
ISO POSIX datatype struct stat could contain a _BitInt(128) type for
st_dev or st_ino if the kernel needs that, as was the case with the 1996
NT kernel . Or a _BitInt(512) for st_uid as used by that same kernel .

GCC --pedantic is an option to check if a program is a fully conforming portable C program, with the obvious exception of the contents of any
used "system" headers (including installed libc headers), as those are
allowed to implement standard or non-standard features in implementation specific ways, and might even include implementation specific logic to
report the use of non-standard extensions to the library standards when
the compiler is invoked with --pedantic and no contrary options .

I am unsure how GCC --pedantic deals with the standards-contrary
features in the GNUC89 language, such as the different type of (foo,
'C') (GNUC says char, C89 says int), maybe specifying standard C instead
of GNUC reverts those to the standard definition .

Enjoy

Jakob
--
Jakob Bohm, MSc.Eng., I speak only for myself, not my company
This public discussion message is non-binding and may contain errors
All trademarks and other things belong to their owners, if any.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

Jakob Bohm <egenagwemdimtapsar@jbohm.dk> writes:
[...]

I am unsure how GCC --pedantic deals with the standards-contrary
features in the GNUC89 language, such as the different type of (foo,
'C') (GNUC says char, C89 says int), maybe specifying standard C
instead of GNUC reverts those to the standard definition .

I'm not sure what you're referring to. You didn't say what foo is.

I believe that in all versions of C, the result of a comma operator has
the type and value of its right operand, and the type of an unprefixed character constant is int.

Can you show a complete example where `sizeof (foo, 'C')` yields
sizeof (int) in any version of GNUC?
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 18/08/2025 06:18, Keith Thompson wrote:

Jakob Bohm <egenagwemdimtapsar@jbohm.dk> writes:
[...]

I am unsure how GCC --pedantic deals with the standards-contrary
features in the GNUC89 language, such as the different type of (foo,
'C') (GNUC says char, C89 says int), maybe specifying standard C
instead of GNUC reverts those to the standard definition .

I'm not sure what you're referring to. You didn't say what foo is.

I believe that in all versions of C, the result of a comma operator has
the type and value of its right operand, and the type of an unprefixed character constant is int.

Can you show a complete example where `sizeof (foo, 'C')` yields
sizeof (int) in any version of GNUC?

$ cat so.c
#include <stdio.h>

int main(void)
{
int foo = 42;
size_t soa = sizeof (foo, 'C');
size_t sob = sizeof foo;
printf("%s.\n", (soa == sob) ? "Yes" : "No");
return 0;
}
$ gcc -o so so.c
$ ./so
Yes.
$ gcc --version
gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 18.08.2025 07:18, Keith Thompson wrote:

Jakob Bohm <egenagwemdimtapsar@jbohm.dk> writes:
[...]

I am unsure how GCC --pedantic deals with the standards-contrary
features in the GNUC89 language, such as the different type of (foo,
'C') (GNUC says char, C89 says int), maybe specifying standard C
instead of GNUC reverts those to the standard definition .

I'm not sure what you're referring to. You didn't say what foo is.

I believe that in all versions of C, the result of a comma operator has
the type and value of its right operand, and the type of an unprefixed character constant is int.

Can you show a complete example where `sizeof (foo, 'C')` yields
sizeof (int) in any version of GNUC?

Presumably that's a typo - you meant to ask when the size is /not/ the
size of "int" ? After all, you said yourself that "(foo, 'C')"
evaluates to 'C' which is of type "int". It would be very interesting
if Jakob can show an example where gcc treats the expression as any
other type than "int".


--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

David Brown <david.brown@hesbynett.no> writes:

On 18.08.2025 07:18, Keith Thompson wrote:

Jakob Bohm <egenagwemdimtapsar@jbohm.dk> writes:
[...]

I am unsure how GCC --pedantic deals with the standards-contrary
features in the GNUC89 language, such as the different type of (foo,
'C') (GNUC says char, C89 says int), maybe specifying standard C
instead of GNUC reverts those to the standard definition .

I'm not sure what you're referring to. You didn't say what foo is.
I believe that in all versions of C, the result of a comma operator
has
the type and value of its right operand, and the type of an unprefixed
character constant is int.
Can you show a complete example where `sizeof (foo, 'C')` yields
sizeof (int) in any version of GNUC?

Presumably that's a typo - you meant to ask when the size is /not/ the
size of "int" ? After all, you said yourself that "(foo, 'C')"
evaluates to 'C' which is of type "int". It would be very interesting
if Jakob can show an example where gcc treats the expression as any
other type than "int".

Yes (more of a thinko, actually).

I meant to ask about `sizeof (foo, 'C')` yielding a value *other than*
`sizeof (int)`. Jakob implies a difference in this area between GNU C
and ISO C. I'm not aware of any.
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */
--- Synchronet 3.21a-Linux NewsLink 1.2