On Tue, Aug 27, 2024, at 15:36, Ville Voutilainen via Std-Proposals wrote:
> On Tue, 27 Aug 2024 at 23:29, Tiago Freire via Std-Proposals
> <std-proposals@lists.isocpp.org> wrote:
>>
>> It's a clear-cut case of a feature that industry pretty much converged on, and the standard lagged behind.
>
> The industry refuses to use it because it doesn't work.
>
> Depending on the definition of "the industry" through a particular lens.
Large portions of the industry uses it and find it works great in practice. Large portions of the industry refuse to use it, because there are significant edge cases where it doesn't work.
I take the above facts as evidence that we should put something like #pragma once in the standard, but only if we either make it work in all cases; or understand and mitigate the edge cases. There are many options with trade offs. Some of the proposed mitigations I'm fine with, but others I'm not. [...]
Here's a thought.
My experience matches Tiago's: #pragma once Just Works, in every environment I have access to.
But Gašper has said that his experience, in his environment, is different: #pragma once doesn't Just Work there. That is, to be precise, GCC handles the `#pragma once` syntax differently from how customers on that particular environment want it to be handled.
It might be actually, practically useful, if someone with access to an environment like Gašper's, and GCC-hacking experience, would combine these to produce a compiler switch — something like `gcc -fpragma-once-hash-based`, or `-fpragma-once-timestamp-based`, or `-fpragma-once-something-else` — so that we could see what they are actually asking for. And then the GCC maintainers could consider whether to adopt an opt-in command-line switch like that. Then the few people in environments that require it, would put the switch into their build scripts, and then they could switch over to using `#pragma once` even in their environment.
Right now I'm just seeing (a few) people saying "GCC's handling of #pragma once Doesn't Work for my environment," but with no concrete suggestions for how GCC ought to handle `#pragma once` in their environment.
(Of course it's possible that their answer is "Nothing works in my environment, period; I will never ever switch from #ifndef to #pragma once." In that case, the problem is solved, because we don't need to make GCC handle #pragma once in their environment — they'll never use it, so they'll never notice that it's missing.)
–Arthur