MAKEPPREPLAY(1) Makepp MAKEPPREPLAY(1)NAMEmakeppreplay-- Fast repeater of selected makepp actions
DESCRIPTION
?: -?, A: -A,
--args-file,
--arguments-file, C: -C,
-c, D: --directory,
--dry-run, H: -h,
--help, I: -I,
--include,
--include-dir, J: --just-print, K: -k,
--keep-going, M: -M,
$MAKEPPREPLAYFLAGS,
--module, N: -n,
--no-print-directory,
--no-warn, R: --recon,
--root-dir,
--root-directory, T: -t,
--temporary, V: -V,
--version
makeppreplay [ option ... ] [ VAR=value ] [ target ... ]
mppr [ option ... ] [ VAR=value ] [ target ... ]
Makeppreplay tries to do the same things makepp did. It does this
solely based on the remembered build info, saving much time by not
reading makefiles, not parsing commands, not scanning files and not
looking at every repository file, to see whether it fits. But unlike
makepp it reuses all repository links it finds.
It does not know about phony or default targets, so you have to give it
real files or directories, as a shortcut for all files makepp has built
therein. By default it builds all files makepp built in the current or
chosen directory.
This approach is only correct when there are no structural changes,
i.e. no different modules to be linked, no moved files, no different
"#include" statements, which should possibly have caused those files to
be (re)built. After updating from version control, or when building
against a repository, where others may have caused such changes, you
should call makepp once after potential changes (e.g. in the morning
after an overnight repository update), to be sure your build infos are
up to date.
Not reading makefiles means, it will not know any subs (Perl functions)
defined in them. For this you should put all your functions into an
external module. It will also not know about any variable settings,
which is only a problem if your Perl code accesses them (because in
rule actions they have already been expanded).
TODO
This is still experimental and imperfect.
· Build up a complete dependency tree starting from the given targets
and decide which of them to build based on their build check
methods. That requires the method to be remembered in the build
info.
· After implementing the previous bullet item, accept more makepp
opts, like "-j" or "--dont-build".
· Allow build cache with implicit "--no-populate-bc" (because
makeppreplay doesn't guarantee a correct build). Makepp might
later publish to the build cache anything it retains.
· Have makepp remember build info for all failed commands and for
those it didn't attempt because their dependencies failed. This is
only partially possible, because dependencies may only be found out
after building the files that require them. What should happen
with (a has no build info):
a: b
b: c
cmd_producing_a_and_b
OPTIONS
Options include some of the makepp options, plus two new ones, for
loading modules that would normally be loaded from a makefile.
-A filename
--args-file=filename
--arguments-file=filename
Read the file and parse it as possibly quoted whitespace- and/or
newline-separated options.
-C directory
--directory=directory
Cd to the given directory before loading the makefile and trying to
build the targets. This is more or less equivalent to specifying a
directory with "-F", except that subsequent "-C", "-f", "-F", "-I"
and "-R" options are interpreted relative to the new directory,
rather than the old one.
-c
--root-dir
--root-directory
Cd up to the directory containing a RootMakeppfile.
-I directory
--include=directory
--include-dir=directory
Add directory to Perl load path @INC.
-?
-h
--help
Print out a brief summary of the options.
-k
--keep-going
Build as many files as possible, even if some of them have errors.
By default, makepp stops when it encounters the first error, even
if there are other files that need to be built that don't depend on
the erroneous file.
-M module[=arg,...]
--module=module[=arg,...]
Load module and import any functions it exports.
-n
--dry-run
--just-print
--recon
Print out commands without actually executing them.
--no-print-directory
Turn off the entering or leaving directory messages.
-t
--temporary
Makeppreplay modifies the build info of all files it touched and of
all dependencies it found modified. It marks them in such a way
that makepp nevertheless knows that it needs to rescan these files.
But with this option you can prevent these modifications, so that
makepp will simply consider all files makeppreplay created as
incorrect.
-V
--version
Print out the version number.
--no-warn
Don't print any warning messages.
EXAMPLES
Probably the most common use is relinking either a program or a library
after editing a source file:
makeppreplay subdir/foo.o bin/bar
mppr subdir/foo.o lib/libbar.so
ENVIRONMENT
Makeppreplay looks at the following environment variable:
$MAKEPPREPLAYFLAGS
Any options you may want to always pass.
AUTHOR
Daniel Pfeiffer (occitan@esperanto.org)
perl v5.20.3 2012-02-07 MAKEPPREPLAY(1)
