Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
MAKEPPREPLAY(1)			    Makepp		       MAKEPPREPLAY(1)

       makeppreplay -- Fast repeater of	selected makepp	actions

       ?: -?,  A: -A,
	 --arguments-file,  C: -C,
	 -c,  D: --directory,
	 --dry-run,  H:	-h,
	 --help,  I: -I,
	 --include-dir,	 J: --just-print,  K: -k,
	 --keep-going,	M: -M,
	 --module,  N: -n,
	 --no-warn,  R:	--recon,
	 --root-directory,  T: -t,
	 --temporary,  V: -V,

       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).

       This is still experimental and imperfect.

       o   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

       o   After implementing the previous bullet item,	accept more makepp
	   opts, like "-j" or "--dont-build".

       o   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.

       o   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

       Options include some of the makepp options, plus	two new	ones, for
       loading modules that would normally be loaded from a makefile.

       -A filename
	   Read	the file and parse it as possibly quoted whitespace- and/or
	   newline-separated options.

       -C 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.

	   Cd up to the	directory containing a RootMakeppfile.

       -I directory
	   Add directory to Perl load path @INC.

	   Print out a brief summary of	the options.

	   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,...]
	   Load	module and import any functions	it exports.

	   Print out commands without actually executing them.

	   Turn	off the	entering or leaving directory messages.

	   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

	   Print out the version number.

	   Don't print any warning messages.

       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/

       Makeppreplay looks at the following environment variable:

	   Any options you may want to always pass.

       Daniel Pfeiffer (

perl v5.32.0			  2012-02-07		       MAKEPPREPLAY(1)


Want to link to this manual page? Use this URL:

home | help