Have a canonical way to declare preprocessor defines

[marti4d]

Hey there! I brought this up yesterday on Reddit, and I wanted to follow up here.

Perhaps this ticket is a good place to discuss whether or not it's worth adding a canonical "define" abstraction in Meson. Here are the reasons that I think such a thing should exist:

1. Much like include dirs, defines are usually a property of the source code and the host/target machine, and are often needed independently of the mechanism used to pass them
2. Different compilers may have different argument syntaxes for specifying defines. Even MSVC uses "/D" and GCC uses "-D". (And yes, I know that technically MSVC "tolerates" the -D syntax, but that's not its native syntax, and as a thought exercise one could imagine some compiler that doesn't)
3. This is already done for other things like include dirs and libraries, where Meson will use the correct compiler argument syntax for whatever compiler is being used
4. Other build systems already do it. CMake has this command and Visual Studio has a separate section altogether for preprocessor defines. In general, if there are higher-level semantics for something then isn't it a Good Thing(TM) to capture them rather than having them degrade to compiler flags?

Also - I'm willing to put my time where my mouth is here. With a perhaps a little help I'd be willing to be the one to add whatever feature to Meson - I'd just want to know what you folks think before I go trying to implement something.

[jpakkane]

and as a thought exercise one could imagine some compiler that doesn't

In Meson we have a strict design guideline that we only deal with problems that actually manifest in the real world, and we do not try to come up with solutions to hypothetical problems that no-one has actually encountered. If someone can prove such a compiler exists and that we should support it then things would be different. However such a thing does not exist and is unlikely to ever exist, because no-one is going to write a C (or especially a C++) compiler from scratch and not have it take -D arguments. It would be insane and also incompatible with absolutely every existing development tool.

[scivision]

When I first came to Meson, I looked for the equivalent of CMake's target_compile_definitions before realizing Meson just uses strings into c_args, cpp_args, fortran_args.
I quickly realized that I could do with Meson what I did with CMake with regard to compiler definitions.

So the original question can be viewed like: extra -D are not elided with Meson, but does that rise to the level of needing its own target parameter? like

exectuable(..., c_args: ..., c_defines: ['foo', 'bar', 'baz'])

that's automatically elided and selects /D or -D?

CMake example

Even with CMake 3.16.0, -Dfoo is put into Visual Studio if Ninja is used.

Results with CMake 3.16.0, Windows 10 and either Visual Studio 2019 or Intel compiler 19.0.
The compiler definitions depend on the generator, not the compiler

Here is a toy CMakeLists.txt to demonstrate:

cmake_minimum_required(VERSION 3.0)
project(blah C)

file(WRITE foo.c "int main(void) { return 0; }")

add_executable(foo foo.c)
target_compile_definitions(foo PRIVATE bar)

Visual Studio

cmake -B build -G "Visual Studio 16 2019"

compiler commands include:

/D bar

Ninja

cmake -B build -G "Ninja"

compiler commands include:

-Dbar

[marti4d]

we do not try to come up with solutions to hypothetical problems that no-one has actually encountered

Okay, fair enough. I was probably off the rails with that a bit.

So then the question probably ultimately comes down to the point of whether-or-not you think that capturing the higher-level semantics of defines being "something that's a bit different" than a regular old compiler flag is worthwhile? For example, when generating Visual Studio files it may produce better project files (Although there's definitely an argument that you could just parse the command line for "-D" arguments and add them to the "defines" column for the project.)

[jpakkane]

IIRC the solution generator already does that. And if not, patches are welcome to make it do that.

There is not much point in trying to come up with new syntax for defines that work on all platforms and compilers since -DFOO is already exactly that.

[marti4d]

Fair enough. Now that I look at the history, I can see that this topic has been brought up several times now and @jpakkane and others have already disagreed with it. I don't want to beat a dead horse here - Sorry!

[emilmelnikov]

Sorry for posting to an old issue, but would you consider adding a section about this to Meson's FAQ? I don't have a lot of experience with MSVC, but it seems that their docs use /DFOO syntax, and people like me might spend unnecessary time looking for a portable way to pass preprocessor defines in Meson.

[eli-schwartz]

Sure, why not.