I like Make. Make is best
ponbuild tool. If you don’t know it already, it expresses dependencies as a DAG (directed acyclic graph), so a node lists it’s dependencies and has a rule about how to generate the file(s) from the dependencies. If a file is older than its dependencies, then it’s stale and needs to be rebuilt.
If the DAG is specified correctly, then if you change one source file, you’ll rebuild the minimum necessary with the maximum possible parallelism…
…I meant GNU Make by the way, of course.
In Make, dependencies are generally specified statically, like this:
target: dependency1 dependency2
The problem with this is that in many cases dependencies are not static. That is, the dependencies are a function of the dependencies. What? OK, let me illustrate. Suppose you have a dependency:
OK, so the object file foo.o depends on foo.cc. So far, so good. But it’s almost certainly incomplete. If foo.cc #include’s anything then foo.o also relly depends on that too. In other words with the incomplete dependencies, if you modify that header and type “make”, foo.o won’t rebuild because make doesn’t know it ought to. This has the annoying problem that when you’re modifying headers, you keep having to “make clean” and rebuild everything.
Fortunatley, make provides a solution for you in typical make fashion: it provides the mechanism to deal with dynamic dependencies and you provide the language specific tools. You can just do:
Naturally, morestuff is going to be dynamically generated. GCC is nice and since it knows about the dependencies (it has to when it actually does the compile), and will emit them in make format while it does the build, ready to be included next time. So if a source file changes, the .o is rebuilt and new dependencies are generated. Next time we come to build, it checks those fresh new dependencies.
.PHONY: all clean all: prog clean: rm -f *.o *.d prog .deps prog: a.o b.o $(CXX) -o prog $^ #We can't use the built in rule for compiling c++. # #Let's say a header changed to include a new header. #That change would cause a rebuild of the .cc file #but not the .d file. # # Arguments mean: # -MMD output #include dependencies, but ignore system headers, while # the build continues # -MF output dependencies to a file, so other crud goes to the screen # -MP make a blank target for dependencies. That way if a dependency is # deleted, make won't fail to build stuff %.o %d: %.cc $(CXX) -c $< $(CXXFLAGS) -MMD -MP -MF $*.d #Search for all .d files and add them #Note that .d files are built in with .o files. If there's no .o yet, #then there's no .d. But that's OK; there are no precise dependencies, #but we know we have to rebuild it anyway because the .o is not there. #So, it's OK to only pick up .d files that have alredy been generted. include $(wildcard *.d)
And the full set of files.
Now try creating an empty “c.h” and make b.h include it. Type make (you’ll see a.o rebuild). Now touch “c.h”. Make will rebuild a.o again as it should. Revert b.h and remove c.h. Make again builds it correctly. Touch c.h again and type make and nothing (correctly) gets rebuilt.
Actually, the mechanism is is subtle and interesting. It looks like a simple include directive, but the key is that if morestuff doesn’t exist, make will build it first, include it and then process the rest of the build. You cn do cool stuff there, but fortunately it’s not needed here.