isystem | my systems bible

After playing around with it for some time it turned out that the problem comes down to both spaces and arguments deduplication. Partially it can be handled by removing space between option (e.g. -systemi) and its argument (path). However some flags just cannot avoid duplication (like -Xclang option). In order to suppress deduplication the prefix SHELL: was introduced in CMake 3.12. It keeps spaces, parses arguments properly and can be used like this:

my bet is that you need to use "Preprocessor directives" in your code and indicate platforms

How do I check OS with a preprocessor directive?

https://www.cplusplus.com/doc/tutorial/preprocessor/

You can use -o /dev/null to discard the output altogether, or you could send it to a temporary file which you then delete. If you're concerned with compile times, you can add -E in order to only run the preprocessor, which is the minimum in order for -H to work. That works because if you tell gcc to stop after preprocessing (-H), it doesn't matter if you also tell it to stop after creating an object file (-c). (That's an exception to the general rule that gcc uses the last of a set of conflicting options, which is designed to let you override options by adding to the end of a command-line.)

However, I can't help thinking that this is not really the best solution to your problem. It seems like you've hand-crafted a compiler invocation with a number of options, and then put it somewhere where it's difficult to modify. A better solution would be to use a makefile and set the value of the various standard makefile variables -- such as CFLAGS, CPPFLAGS, LDFLAGS, LDLIBS -- which are documented in the Gnu make manual. In simple cases, your Makefile might consist only of lines which set these variables, since Gnu make has built-in rules for common targets.

Update, the explicit property injection is working fine. It occurs after construction. I imagine there are design reasons for this, although somehow it was contrary to my mental model that the property injection would be performed on-demand/on first use.

Planning on experimenting a bit more to see what control is available over the timing to resolve property dependencies. If anyone who is more experienced has any advice on that or can point me to additional documentation I would welcome it. The decorator sounds like the more elegant way to make sure the logger is available as expected and allow independent lazy loading of decoratee concerns. Some discussion here:

SimpleInjector - "Lazy" Instantiate a singleton that has dependencies on first use

I found a solution. You need to find all files called as "toolchain.prf" in qt instalation directory and change this code:

That's not because of -isystem src. The problem happens because clang++ contains the path /usr/local/include in its list of standard include directories, and g++ doesn't.

You can check the list of standard include directories with the following commands:

clang++ -nostdlib -Wp,-v -E -

g++-10 -Wp,-v -E -

To avoid including /usr/local/include/google/protobuf/any.h by clang++ you can either remove the file or use -nostdinc and -nostdinc++ flags and pass old the include directories manually.

Direct access to the Tcl_Interp struct has for long been deprecated. Given that this is a single source file (psim.c), you might want to patch it to properly use:

• Tcl_SetResult(), for example: Change interp->result = "No arguments allowed"; to Tcl_SetResult(interp, "No arguments allowed", TCL_STATIC);
• Tcl_GetStringResult(), for example: Change fprintf(stderr, "Error Message was '%s'\n", sim_interp->result); to fprintf(stderr, "Error Message was '%s'\n", Tcl_GetStringResult(sim_interp));

This is backwards compatible.

Not recommended, but doable: Set the macro

I would rather suggest to use Python 3.8.X, I think it is too early for 3.9.X, let them fix smth or because it is not yet supported, I need to check that. I usually move to next Python after 3-6 months only.

I cannot answer why clang 11.0.1 does not like this code, though one can see the effect in Compiler Explorer (https://godbolt.org/z/qTTcGf.

However, one can also see there why adding the perverse flag which you think is enabling use of libgomp makes the code compile. The reason is that that flag is disabling OpenMP completely. You can see that there are no calls to OpenMP runtime routines in https://godbolt.org/z/o3TaGz . I have no idea why that flag is not rejected, since it makes absolutely no sense to ask Clang to link against libgomp, as Clang cannot generate the calls into the GCC OpenMP RTL (these interfaces are different). It is also not documented as a reasonable thing to do (see https://clang.llvm.org/docs/UsersManual.html#openmp-features ) which does not show -fopenmp taking any argument.

You can also see (at https://godbolt.org/z/7hcdrr) that the mainline Clang now accepts your code (without disabling OpenMP) and generates code that includes calls into the OpenMP runtime.

So, overall

1. Clang 11 has a bug which has been fixed in mainline.
2. You are passing an unsupported argument to clang and it is then turning off OpenMP compilation.