SUBDIRS - handling dependencies
Introduction
It is common for larger software projects to separate its components into different topics. There might be components the are relevant to the GUI of a software, other might be in the topic of handling geometrical processing, others are in the topic of generating a report.
Typically the software components belonging to a topic are combined into a software library (Wikipedia). In Windows these libraries are often found as .lib or .dll files; under Linux there are .a and .so files; under MacOS X they are called .a or .dylib files.
Finally these libraries are linked to an executable application.
The following text uses a small example, consisting of an application: app and two libraries: lib and lib2. The application app uses features of the libraries lib and lib2 while the libraries are in no direct relation. So, to have a running application the toolchain must create the lib.lib and lib2.lib files and finally create the app.exe by linking the lib.lib and lib2.lib to the object files of the app components. (The following Text uses the Windows file name notations of the objects)
When the software project is in an early design and implementation phase, the libraries might change as often as the application using the libraries. In the Qt domain, each of the three topics: lib, lib2 and app will be handled bye one project each. Typically there will be three folders: lib, lib2 and app, each containing a specific .pro file, describing how to handle each project (which source files, compile parameters, ...). The profiles typically will be named after the folders they live in: lib.pro, lib2.pro and app.pro. For this example all three projects will live in one folder: src.
On the file system this can be seen as following hierarchy:
/src
|--- app
| |--- app.pro
| `--- ... (source files of app)
|--- lib
| |--- lib.pro
| `--- ... (source files of lib)
`--- lib2
|--- lib2.pro
`--- ... (source files of lib2)
Each of this projects could for example be edited separately in three Microsoft Visual Studio 2010 IDEs (MSVS2010) or handled as three separate projects in one QtCreator. But this handling of the projects would mean to compile each by hand separately. It gets tedious when taking into account the dependencies between the three projects: the libs must be compiled before the app can be created!
template: subdirs
To handle this relation automatically qmake has a template type: subdirs (template).
The basic idea of this template type is, to list all projects that belong to a kind of meta project. A new .pro file is created for that meta project, that simply consists of the qmake system variable SUBDIRS. This variable is filled with the names of the project folders by giving the relative path to where the meta .pro file lies. In the following text this meta profile is names subdirs.pro. For a better overview in the file hierarchy a new parent folder is introduced, named after the software project that is created: FooApp.
/FooApp
|--- subdirs.pro
`--- src
|
|--- app
| |--- app.pro
| `--- ... (source files of app)
|--- lib
| |--- lib.pro
| `--- ... (source files of lib)
`--- lib2
|--- lib2.pro
`--- ... (source files of lib2)
The meta profile subdirs.pro is on the same level as the src folder.
The content of the subdirs.pro is
template = subdirs
SUBDIRS = \
src/app \ # relative paths
src/lib \
src/lib2
The subdirs.pro file can be opened by QtCreator. In QtCreator there will be just one project with child elements, the sub-project. The advantage is now that when compiling this meta project the sub-projects are compiled automatically. Asking for a qmake run within QtCreator on this meta project will also recurse into the sub-projects calling qmake for each.
To make this meta project available for MSVC2010, qmake must be called on the command line in the folder FooApp:
qmake -tp vc -r
This will generate a solution file with the name subdirs.sln. When opening this file in MSVC2010 a solution will be opened that contain the three project: app, lib, and lib2. A compile on the solution will call compile for each of the contained projects.
Attention: The order in with the subproject are compiled is not defined by the SUBDIRS content. One could assume that the build order is given by the order of the entities in the SUBDIRS variable, but many modern compile tools offer parallel compilation. If the order of the entity would be forcing the build order, then parallel compilation on the projects level would not be possible. Per default the sub-projects are compiled in any order the used build-systems logic prefers.
Background on Windows Build Systems
There are different ways to compile a project (or meta project) under windows.
nmake
nmake reads a Windows Makefile that was generated by qmake.
For a meta-project qmake must be called with the recursive flag in the FooApp folder, the one with the subdirs.pro file:
qmake -r
This will generate a Makefile in the same directory. In addition qmake will process all the subdirs given in the SUBDIRS variable and create Makefiles in each of the sub-project folders, containing rules to create the sub-project.
/FooApp
|--- subdirs.pro
`--- src
|
|--- app
| |--- app.pro
| |--- Makefile
| |--- Makefile.Debug
| |--- Makefile.Release
| `--- ... (source files of app)
|--- lib
| |--- lib.pro
| |--- Makefile
| |--- Makefile.Debug
| |--- Makefile.Release
| `--- ... (source files of lib)
`--- lib2
|--- lib2.pro
|--- Makefile
|--- Makefile.Debug
|--- Makefile.Release
`--- ... (source files of lib2)
Calling nmake in the meta project folder FooApp via
nmake
will find the Makefile and will process it. As this Makefile is one for a meta-project, it contains rules to process