[cmake-developers] Automoc in cmake
Alexander Neundorf
neundorf at kde.org
Sat Jun 4 04:24:52 EDT 2011
Hi,
one feature which all KDE developers are used to and which is also used by
qmake when building Qt is "automoc".
This means that you don't have to write
qt4_wrap_cpp(srcs ${filesToBeMoced})
but instead you simply do
kde4_add_executable(hello ${srcs})
and everything including moc is handled automatically.
This is done so that in your foo.cpp file you include the moc-file e.g. at the
end:
-------------------
Foo::Foo()
:QObject()
{
}
...
void Foo::doSomething()
{
}
#include "foo.moc"
----------------
What needs to be done for this is to parse all source files for such include
lines at build time (because such a line may have been inserted without
changing anything in CMakeLists.txt) and if such a line is found, moc has to
be started and the file has to be generated.
Currently this is done by the tool automoc4 which is a separate package.
It consists of a binary automoc4 and a macro
automoc_add_executable().
What this macro basically does is to add for each target foo an additional
target foo_automoc, and make the target foo depend on foo_automoc. So
foo_automoc is always built before foo.
The custom target foo_automoc basically runs the automoc4 executable, which
checks for all source files whether they have changed, and whether they
contain moc-include statements, and if so, it runs moc.
So, we'd like to have that available in cmake.
I see two ways how to do it:
1) keep the mechanism as it is, but integrate the functionality of the automoc
executable into cmake, so that the custom target would do cmake --automoc or
something like this.
This would still need an additional macro, which would then probably be
qt_add_executable().
When doing automoc, the list of source files has to be known, the include
directories and the defines.
This is currently written into a file which is then loaded by automoc4.
When integrating it this way, this would probably stay more or less like this.
2) Integrate it fully into cmake, i.e. add arguments to add_executable() and
add_library(), so I can do
add_executable(foo AUTOMOC ${srcs} )
Advantages of this would be that it doesn't need an extra macro and extra
custom target to be set up, and that the information like the list of files
and include directories is directly available in cmAddExecutable, so it
doesn't have to be written in a separate file which is read later on.
So, we'd really like to have that integrated in cmake.
What do you think ? Which way would you prefer ? I think I'm favouring option
2).
I'll work in the next days on porting current automoc away from using Qt to
plain STL (and kwsys), so that it becomes ready for inclusion. It is also
already BSD licensed.
Alex
More information about the cmake-developers
mailing list