Question

I would like to pass some options to a compiler.
The option would have to be calculated at compile time – everytime when ‘make’ is invoked, not when ‘cmake’, so execute_process command does not cut it. (does it?)

For instance passing a date to a g++ compiler like that:

g++ prog.cpp -o prog -DDATETIME="17:09:2009,14:25"

But with DATETIME calculated at compile time.

Any idea how to do it in CMake?

Bounty edit:

A least hackish solution will be accepted.

Please note that I want to be able to exectue an arbitrary command at compile time, not only ‘date’.

Edit 2:

It have to work on Linux, Windows (VS), Mingw, Cygwin and OS X.
You can’t assume Ruby, Perl or Python as they are non standard on Windows.
You can assume BOOST, but I guess it’s no use.

The goal is to force cmake to generate Makefile (in case of Linux) that when make is executed, will do the job.

Creating custom *.h file is ok, but it has to be initiated by a Makefile (or equivalent on other OS) by make. The creation of *.h doesn’t have to (and shouldn’t have to) use cmake.

Answer 1

You’re leaving out some information, such as which platforms you need
to run this on and if there are any additional tools you can use. If
you can use Ruby, Perl, of Python, things become much simpler. I’ll
assume that you want to run on both Unix and Windows pqlatform and
that there are no extra tools available.

If you want the output from the command in a preprocessor symbol, the
easiest way is to generate a header file instead of fiddling around
with command line parameters. Remember that CMake has a script-mode
(-P) where it only processes script commands in the file, so you can
do something like this:

CMakeLists.txt:

project(foo)  
cmake_minimum_required(VERSION 2.6)
add_executable(foo main.c custom.h)
include_directories(${CMAKE_CURRENT_BINARY_DIR})  
add_custom_command(OUTPUT custom.h 
    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/custom.cmake)

The file “custom.h” is generated at compile time by the command “cmake
-P custom.cmake”. custom.cmake looks like this:

execute_process(COMMAND uname -a 
    OUTPUT_VARIABLE _output OUTPUT_STRIP_TRAILING_WHITESPACE)
file(WRITE custom.h "#define COMPILE_TIME_VALUE \"${_output}\"")

It executes the command (in this case “uname -a”, you’ll replace it
with whatever command you wish), and puts the output in the variable
_output, which it then writes to custom.h. Note that this will only
work if the command outputs a single line. (If you need multiline
output, you’ll have to write a more complex custom.cmake, depending on
how you want the multiline data into your program.)

The main program looks like this:

#include <stdio.h>
#include "custom.h"
int main()
{
  printf("COMPILE_TIME_VALUE: %s\n", COMPILE_TIME_VALUE);
  return 0;
}

If you actually want to to calculate compiler options at compile time,
things become much trickier. For Bourne-shell generators you can just
insert the command inside backticks. If you get mad while figuring out
quoting, move all the logic of your command inside a shell-script so
you only need to put mycommand.sh in your add_definitions():

if(UNIX)
  add_definitions(`${CMAKE_CURRENT_SOURCE_DIR}/custom-options.sh`)
endif()

For Windows batch file based generators things are much tricker, and I
don’t have a good solution. The problem is that the PRE_BUILD commands
are not executed as part of the same batch file as the actual compiler
invocation (study the BuildLog.htm for details), so my initial idea
did not work (generating a custom.bat in a PRE_BUILD step and then do
“call custom.bat” on it to get a variable set which can later be
referenced in the compiler command line). If there is an equivalent of
backticks in batch files, that would solve the problem.

Hope this gives some ideas and starting points.

(Now to the inevitable counter-question: what are you really
trying to do?)

EDIT: I’m not sure why you don’t want to let CMake be used to generate the header-file. Using ${CMAKE_COMMAND} will expand to the CMake used to generate the Makefiles/.vcproj-files, and since CMake doesn’t really support portable Makefiles/.vcproj-files you will need to rerun CMake on the target machines.

CMake also has a bunch of utility commands (Run “cmake -E” for a list) for this explicit reason. You can for example do

add_custom_command(OUTPUT custom.h COMMAND ${CMAKE_COMMAND} -E copy file1.h file2.h)

to copy file1.h to file2.h.

Anyway, if you don’t want to generate the header-files using CMake, you will either need to invoke separate .bat/.sh scripts to generate the header file, or do it using echo:

add_custom_command(OUTPUT custom.h COMMAND echo #define SOMETHING 1 > custom.h)

Adjust quoting as needed.