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

FreeBSD Manual Pages

  
 
  

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

NAME
       makeppreplay -- 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.36.3			  2012-02-07		       MAKEPPREPLAY(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=makeppreplay&sektion=1&manpath=FreeBSD+Ports+14.3.quarterly>

home | help