How do I build a file with redo?

To build a file target, you have to create a dofile target.do with shell commands that write the intended result of the build either to standard output or to its parameter \$3. Then run redo target.

The default target is all: redo without arguments executes commands from all.do.

What do the redo parameters \$1, \$2, \$3 mean?

When redo runs a dofile, it gives it three parameters:

How does the extension removal in parameter \$2 work?

Redo removes the extension that it gets from the default dofile filename:

How do I declare dependencies with redo?

Use the redo-ifchange command in a dofile: redo-ifchange dependency inside target.do means: If the target is built, the dependency is built if it does not exist and recorded as a dependency. On subsequent builds, if dependency does not exist or has changed since the last build, both dependency and target are rebuilt.

How does this redo implementation check dependencies?

For dependency checking, this implementation of redo checks the dependencies' ctime against the stored ctime. If the ctime differs, it checks the dependencies' md5sum against the stored md5sum. This is arguably more useful than just using ctime.

How do I declare non-existence dependencies with redo?

Use the redo-ifcreate command in a dofile: redo-ifcreate ne_dependency inside target.do means: If target is built, the non-existing file ne_dependency is recorded as a non-existence dependency. If ne_dependency exists on subsequent builds, target is rebuilt.

What are command line options for this redo implementation?

How can I use this redo implementation to build in parallel?

If the -j or --jobs option is given followed by an integer, an invocation of redo or redo-ifchange with multiple arguments builds targets in parallel. The integer argument specifies the maximum number of targets allowed to be built in parallel. Targets are locked, so if targets built in parallel share a dependency, redo only builds it once, unless the dependency dofile uses redo-always to rebuild every time, or the dependency becomes out of date during a build in some other way.

How can I make redo build everything in a different directory?

You can use union mounts to combine multiple directories. For example, on Linux with unionfs-fuse, the command unionfs -o cow 'output=RW:source=RO' /tmp/build combines the output and source directories so that /tmp/build contains all files from the source directory, but any newly created file will show up only in the output directory.

Why can a target be built twice during a run?

Some build processes require several builds of the same target. Naïve implementors of build systems disregard this possibility and do not check the validity of a target again if it was built during a run.

• A target that has a dofile that invokes redo-always will be rebuilt several more times, if several targets invoke redo-ifchange for it.
• A dofile can use a loop involving inotifywait to wait for changes to dependencies and immediately rebuild targets if a dependency changes.
• TeX documents can contain internal references. Page and equation numbers are written to an external file needed for a second build.
• TemplateHaskell with profiling needs an executable compiled twice.
• The technique detailed in David A. Wheeler's Fully Countering Trusting Trust through Diverse Double-Compiling requires two builds of a target.

Why does redo-ifchange not add a dependency if the invoked dofile does not generate a target?

redo rebuilds target files when source files have changed. Files that do not exist can never change – therefore, a non-existent file is always up to date.

Did you write tests for your redo implementation?

Yes.

How does this implementation of redo compare with other implementations?

The following table compares redo implementations. Differences from the DJB redo design and incompatibilities with existing dofiles are emphasized.