GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  MAKEPPREPLAY (1)

.ds Aq ’

NAME

makeppreplay -- Fast repeater of selected makepp actions

CONTENTS

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.
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 info.
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
        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)
Search for    or go to Top of page |  Section 1 |  Main Index


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

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.