Qt – Adding custom commands to existing targets in qmake

makefileqmakeqttarget

Is there a way to specify, in a .pro file, extra commands to be added to a standard target in the Makefile that qmake generates? For example, consider distclean, extra commands might be desired to:

Remove *~ files.
Clean out runtime-generated output files from the source tree.
Etc.

I want to use the normal target and not a custom target because I want this to be completely transparent in my workflow. That is (again using distclean as an example), I don't want to…

… require knowledge in a multi-project setup that certain Makefiles use a custom rule instead of distclean.
… document custom rules, even for stand-alone projects, as distclean is already well-known and intuitive^†.

I found How to add custom targets in a qmake generated Makefile?, but this describes adding custom targets (which is already documented, even back in 4.6) rather than adding rules to existing targets. While it does contain some hints, all of them require adding new custom targets, as specifying the same target more than once in a Makefile replaces (not adds) commands from the previous target.

The only thing I could really think of to try was to add target.commands += new commands to the .pro file as a wild guess (e.g distclean.commands += rm \"*~\"). This has no effect.

How can I transparently add custom commands to existing targets with qmake?

_{^† For the distclean example: While maintainer-clean is also on that "standard target" list, in practice I have found it to be rarely used, and in any case qmake doesn't generate it by default; I consider it to be unsuitable.}

Best Answer

There are two straightforward ways to accomplish this, depending on how self-contained / portable you want your solution to be and how lenient you want to be with the order of command execution.

Option 1

The first option is to create a custom target in the .pro file for the new commands, then add that target as a prerequisite to the standard target that you are modifying. Going back to the distclean example, let's say you want to add a command to remove all *~ files:

Create a custom target in your .pro file. Note that you have to escape quotes and slashes in .pro files. For example, add:
```
extraclean.commands = find . -name \"*~\" -exec rm -v {} \\;
```
Add this target as a dependency of the target you are modifying:
```
distclean.depends = extraclean
```
This won't actually modify the distclean rule just yet, as this method can't be used to modify existing rules. However...
Add both your new target and the target you are modifying as extra targets:
```
QMAKE_EXTRA_TARGETS += distclean extraclean
```
This will add a second specification of distclean to the Makefile, but this works because you can add dependencies to existing targets in make in separate rules, even though you can't add commands that way. If you were to also specify distclean.commands in your .pro file, you would break the existing distclean by replacing its default recipe.

So, putting that all together, in the .pro file:

extraclean.commands = find . -name \"*~\" -exec rm -v {} \\;
distclean.depends = extraclean
QMAKE_EXTRA_TARGETS += distclean extraclean

Where extraclean is some custom target with the commands you want to add, and distclean is the existing target that you wish to modify.

Pros:

Completely self-contained in a .pro file.
As portable as you can get, leaves the actual Makefile syntax and generation up to qmake.

Cons:

Your new commands aren't appended to the existing recipe. Rather, they happen after all prerequisite targets are satisfied but before the existing recipe. In the distclean example, with the version of qmake that I'm using, this places the commands after the source tree clean but before Makefile itself is deleted (which is the only action the default recipe takes). This is not an issue for this example, but may be an issue for you.

Option 2

The second option is to change the name of the Makefile that qmake generates, and create your own custom Makefile that defers to the generated one, rather than includes + overrides it. This is also a straightforward option; while not as self-contained as option 1, it gives you the ability to execute commands both before and after the default generated recipe.

You don't want to include + override the existing Makefile, because you don't want to replace the default recipes. If you do, you have to re-implement the default, but this can be an issue as that default may change (and you have to keep up with the changes). It's best to let qmake do as much work as possible, and not repeat its work.

To do this:

First, change the name of the file that qmake generates. This can be accomplished by adding a line such as this to the .pro file:
```
MAKEFILE = RealMakefile
```
That will cause qmake to output RealMakefile instead of Makefile.
The next step is to create your own Makefile with your custom commands. However, there are some caveats here. First, a full example, again using distclean. In a file named Makefile:
```
.DEFAULT_GOAL := all

%:
    @$(MAKE) -f RealMakefile $@

distclean:
    @$(MAKE) -f RealMakefile $@ 
    @find . -name "*~" -exec rm -v {} \;
```
Some notes about this:
- We set .DEFAULT_GOAL because otherwise distclean would be the default. An alternative to this, if you're not comfortable with .DEFAULT_GOAL, is to specify an all rule using @$(MAKE) -f RealMakefile $@ as the recipe.
- The % target matches any target that isn't otherwise defined in this Makefile. It simply delegates processing to RealMakefile.
- The distclean target is where we add our commands. We still need to delegate to RealMakefile, but additional commands can be added both before and after that happens.

Pros:

More control over command order. Commands can be added both before and after the default recipe.

Cons:

Not self-contained in a .pro.
Not as portable: It doesn't leave all Makefile generation up to qmake, and also I'm not actually sure what parts are specific to GNU make here (comments welcome).

So, while this answer may be a little long, both of these methods are very straightforward. I would prefer option 1 unless the command execution order is an issue.

Related Solutions

Qt qmake – how to stop it adding rules to delete the target

I would look into the custom target capabilities for your script. Maybe something like this:

check.commands = <scriptname>
check.depends = <any dependencies>
QMAKE_EXTRA_TARGETS += check

Doing things this way will run the check command when the dependencies change, but as long as you don't specify check.target then it shouldn't remove anything. (If your script does produce output, then perhaps that should be in check.target.) Also, since it is specified as an "extra" command, qmake shouldn't create commands to delete your script in a distclean.

This is assuming that your script is in its own subdirectory (which you state), and is the only "check" command that needs run in that subdirectory (kind of implied by the question, but not directly stated).

Qt – qmake rules for generated code

You may need to do this in two passes.

In your qmake file, add the following line:

include( generated/generated.pri )

Then, at the end of your code_generator script, add the sources to the generated.pri file (using bash for the example, but the idea is the same for almost all languages):

rm generated/generated.pri
for file in $( ls generated/*.cpp ); do
    echo "SOURCES += ${file}" >> generated/generated.pri
done

The first time you run the qmake file, generated/generated.pri will presumably be empty. When you run make, it will populate the generated.pri file. The second time, it will recreate the make file (as a source .pri file changed), then compile again. You might be able to fiddle around with other commands which would do the second stage for you.