MAKEPP_COMMAND(1) Makepp MAKEPP_COMMAND(1)NAME
makepp -- Command line syntax for makepp
DESCRIPTION
?: -?, A: -A,
--args-file,
--arguments-file,
--assume-new,
--assume-old, B: -b,
--build-cache,
--build-check,
--build-check-method, C: -C,
-c, D: --defer-include,
--directory,
--do-build,
--dont-build,
--dont-read,
--do-read,
--dry-run,
--dump-makefile,
--dump-makeppfile, E: -e,
--environment-overrides,
--env-overrides, F: -F,
-f,
--file,
--final-rules-only,
--force-copy-from-bc,
--force-rescan, G: --gullible, H: -h,
--help,
--hybrid,
--hybrid-recursion,
--hybrid-recursive-make, I: -I,
--implicit-load-makeppfile-only,
--include,
--include-dir,
--in-sandbox,
--inside-sandbox, J: -j,
--jobs,
--just-print, K: -k,
--keep-going, L: --last-chance-rules,
--load-makefile,
--load-makeppfile,
--log,
--log-file, M: -m,
--makefile,
$MAKEFLAGS,
$MAKEPP_CASE_SENSITIVE_FILENAMES,
--makeppfile,
$MAKEPPFLAGS,
--md5-bc,
--md5-check-bc, N: -n,
--new-file,
--no-builtin-rules,
--no-cache-scaninfos,
--no-implicit-load,
--no-log,
--no-path-executable-dependencies,
--no-path-exe-dep,
--no-populate-bc,
--no-print-directory,
--no-remake-makefiles,
--no-warn, O: -o,
--old-file,
--out-of-sandbox,
--override-signature,
--override-signature-method, P: --populate-bc-only,
--profile, Q: --quiet, R: -R,
-r,
--recon,
--remove-stale,
--remove-stale-files,
--repository,
--rm-stale,
--root-dir,
--root-directory, S: -s,
--sandbox,
--sandbox-warn,
--sandbox-warning,
--signature,
--signature-method,
--silent,
--stop,
--stop-after-loading,
--stop-on-race,
--stop-race,
--symlink-in-rep-as-file,
--symlink-in-repository-as-file, T: --traditional,
--traditional-recursion,
--traditional-recursive-make, V: -V,
-v,
--verbose,
--version,
--virtual-sandbox, W: -W,
--what-if
makepp [ option ... ] [ VAR=value ] [ target ... ]
mpp [ option ... ] [ VAR=value ] [ target ... ]
Makepp supports most of the command line options and syntax that other
makes support. The hyphens between the words are always optional, and
can also be replaced by an underscore. You specify a list of targets
to build on the command line. If you do not specify any targets, the
first explicit target in the makefile is built.
You can assign variables on the command line which will override any
assignment or environment variable in every Makefile loaded, e.g.,
makepp CFLAGS=-O2
Valid options are most of the standard make options, plus a few new
ones:
-A filename
--args-file=filename
--arguments-file=filename
Read the file and parse it as possibly quoted whitespace- and/or
newline-separated options.
-b directory
--build-cache=directory
Specifies the path to a build cache. See makepp_build_cache for
details. The build cache must already exist; see "How to manage a
build cache" in makepp_build_cache for how to make it in the first
place. Build caches defined on the command line may be overridden
by a build_cache statement in a makefile or a :build_cache rule
modifier . If you work with several different builds, it may be
useful to set the environment variable "MAKEPPFLAGS" to contain
"--buil""d-cache=/path/to/build/cache" so that all of your builds
will take advantage of the build cache by default.
--build-check=method
--build-check-method=method
The name of a build check method to use to decide whether files
need to be rebuilt. Possible values are "target_newer",
"exact_match", See makepp_build_check for information on build
check methods.
-C directory
--directory=directory
Cd to the given directory before loading the makefile and trying to
build the targets. This is similar 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.
--defer-include
Workaround for include statement before the rule that builds the
include file. This happens by pretending the include statements
come last in the makefile. That way the include statement is
performable, but variable overrides or modifications may still
fail, in which case you should set the problematic ones on the
command line (whereas gmake ignores any variable setting from the
include file that might influence how that file itself gets built).
--dont-build=filename
--do-build=filename
Do not build the specified file, or, if it is a directory,
everything thereunder, even though makepp thinks it should -- or do
build, overriding the opposite specification from a higher
directory. This is useful if you built a specific file by hand
using different compilation options. Without this option, if you
compile a module by hand and then run makepp to compile the rest of
the program, makepp will also recompile the module you compiled by
hand, because makepp cannot guarantee that the build is correct if
any of the files were not built under its control. With this
option, you tell makepp that you really know what you are doing in
the case of this particular file and you promise that it's ok not
to rebuild it.
For example,
% cc -g -DSPECIAL_DEBUG -c x.c -o x.o # Special compilation by hand
% makepp
cc -g -O2 -c x.c -o x.o # Makepp just overrode your compilation here!
cc x.o y.o -o my_program # Relinks.
% cc -g -DSPECIAL_DEBUG -c x.c -o x.o # Do it again.
% makepp --dont-build x.o # Tell makepp not to rebuild x.o even if it wants to.
cc x.o y.o -o my_program # Now it relinks without recompiling.
If you want special compilation options for just one module, it's
often easier to edit the makefile than to compile by hand as in
this example; see "Target-specific assignments" in makepp_variables
for an easy way of doing this.
If you put a RootMakeppfile(.mk) at the root of your build system,
that directory and everything under it defaults to "--do-build",
while the overall root of your file system defaults to
"--dont-build". That way, everything inside your build system is
built (if necessary) but nothing outside is attempted. If, in this
scenario, you want external parts to always be built as needed, you
must explicitly pick them up with "load_makefile" statements in one
of the makefiles within your tree.
You may have one RootMakeppfile(.mk) each, in separate build trees,
and they will be loaded if one tree has dependencies in another
one. But you are not allowed to have RootMakeppfile(.mk) in nested
directories, avoiding funny effects that tend to arise when you
accidentally call "makepp --repository" again in a subdirectory.
These effects include duplicate rules through duplicate sources, or
eternal build cache reimports because cached files have the right
signatures but the wrong relative pathes.
Override "--dont-build" for the specified file or directory. If
you have a RootMakeppfile(.mk) at the root of your build system,
but you want makepp to build something outside of your build system
just this once, you must explicitly mark it as "--do-build". If
you specify "--do-build" for a file or directory under a
RootMakeppfile(.mk), without "--dont-build" for a higher directory,
then the root (and all else under it) of your build system defaults
to "--dont-build".
To resolve conflicts between "--dont-build" and "--do-build", the
one with the most specific path takes precedence regardless of
order. If the same path is specified with both "--dont-build" and
"--do-build", then the rightmost one wins.
The options "--dont-build" and "--do-build" can be dangerous if you
give the wrong hints to makepp, since you are asking makepp not to
do checks it needs, to guarantee a correct build. But since they
allow greatly reducing the number of checks, they can speed up your
builds dramatically, as explained in potentially unsafe speedup
methods.
--dont-read=filename
--do-read=filename
Do not read the specified file, or, if it is a directory,
everything thereunder -- or do read, overriding the opposite
specification from a higher directory. Generate an error rather
than read files marked for "--dont-read". See --sandbox. The
filesystem root always defaults to readable.
--dump-makefile=filename
--dump-makeppfile=filename
Dump the raw contents of the makefile(s) for the current directory
(as determined by the position of this option relative to any "-C"
options) to filename. Include files are interpolated, comments are
stripped out and "ifdef"'s are resolved. "# line "file"" markers
are inserted as necessary. The final value of any non-reference
scalars in the makefile's package are printed following the
makefile.
This is useful for debugging, but (currently) you won't necessarily
be able use the dump file as an equivalent makefile, for example
because it contains both the include statement and the interpolated
file.
-e
--env-overrides
--environment-overrides
Causes variables from the environment to override definitions in
the makefile. By default, assignments within the makefile override
variable values which are imported from the environment.
-F Makeppfile
--makeppfile=Makeppfile
Loads the specified Makefile or, if you specify a directory, the
Makefile therein, instead of the one in the current directory --
any target specified to the right of this option is interpreted
relative to the directory containing the Makefile. For the details
of the directory case and RootMakeppfile see the explanation at the
next option.
This option can be useful if you execute makepp from unpredictable
directories. For example, if you compile from within emacs and you
have sources scattered all over your directory tree, the current
working directory for the compilation command will be the directory
the last source file you edited was in, which may or may not be the
top level directory for your compilation. However, you can specify
your compilation command as
makepp -F /your/source/dir/top
and this will work no matter what your current directory is.
Because this option doesn't affect the directory relative to which
subsequent "-C", "-f", "-F", "-I" and "-R" options are specified,
you can make targets relative to the current directory like this:
makepp -F /foo/bar -C . mytarget
-f Makefile
--file=Makefile
--makefile=Makefile
Loads the specified Makefile or, if you specify a directory, the
Makefile therein, instead of the one in the current directory. If
you do not specify the "-f" option or the "-F" option, makepp looks
first for a file in the current directory (or the directory
specified by the rightmost "-C" option, if any) called, then
RootMakeppfile.mk, Makeppfile, then Makeppfile.mk, then makefile,
then Makefile. Multiple "-F" and "-f" options may be specified.
The first two (RootMakeppfile) are special (whether given
explicitly or found implicitly). There must be at most one of
those two in any given build tree on which makepp is to operate.
But there may be several if you build several disjoint trees in one
go. Those two are looked for not only in the aforementioned
directory, but also upwards from there. If one is found, it is
loaded before any other.
--final-rules-only
Ignore the dependencies and implicit targets of the rule unless the
target is phony.
--force-copy-from-bc
When using build caches, always copy files in and out of the cache,
even if the source and target are on the same filesystem. This is
mainly useful for testing (emulating) the case in which they are
not.
--force-rescan
Don't use cached scanner results from previous runs.
--gullible
Believe that the rules create what they declare, rather than
checking. This is faster, but doesn't catch bugs in rules.
-?
-h
--help
Print out a brief summary of the options.
--hybrid
--hybrid-recursion
--hybrid-recursive-make
This option is present to allow makepp to work with old makefiles
that use recursive make extensively, especially multiply into the
same dir. By default, recursive make is implemented by a
subprocess that communicates with the parent process; the build is
actually done by the parent process. This allows some of makepp's
nice features like repositories to work with recursive make
invocations. However, this technique will not work if you load
more than one makefile from the same directory. In that case this
option says to fall back to starting another independent instance
of makepp. If this fails, try "--traditional-recursive-make".
If you do use this option, you will get log files in the each
directory the fall back occurred in. To get rid of only them use
"makeppclean --logs --recurse" or "mppc -lr".
-I directory
--include=directory
--include-dir=directory
Search the given directory for included makefiles.
--implicit-load-makeppfile-only
If implicit loading of makefiles is enabled, then automatically
load only a file called RootMakeppfile, RootMakeppfile.mk,
Makeppfile, or Makeppfile.mk, and not makefile or Makefile. This
is useful if makepp has dependencies that are generated by some
other flavor of make, and makepp can't read that flavor's makefiles
in general. (You want to avoid this situation if possible, but it
tends to arise while you're in the process of porting a legacy
build system to makepp.) This has no effect if implicit loading is
disabled.
-j n
--jobs=n
Interprets the argument n as the number of shell commands that can
be executed in parallel. By default, makepp does not execute
commands in parallel.
Unlike some other versions of make, when jobs are executed in
parallel, makepp directs their output to a file and only displays
the output when the commands have finished. This prevents output
from several different commands from being mixed together on the
display, but it does mean that you might have to wait a little
longer to see the output, and stderr messages will usually appear
before stdout stuff, differing from terminal output.
Native Windows Perls (i.e. Strawberry and ActiveState), because
they do not support the Unix fork/exec paradigm, do not allow this
option (Cygwin works fine!). As a partial replacement, you can use
the --sandbox option there, though this is far less comfortable.
-k
--keep-going
Build as many files as safely possible, even if some commands 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.
--last-chance-rules
Activate limited special handling for pattern rules with '%' only
on the target side. This is needed because normally, unlike
traditional makes, makepp instantiates all rules with all available
files from the bottom up, allowing it to find all creatable
dependencies.
--load-makefile=Makefile
--load-makeppfile=Makefile
Loads the specified makefile before any other makefiles, except for
RootMakeppfile, or RootMakeppfile.mk above it, but do not consider
this option for the purposes of determining the default target. If
no other makefile is specified, then one is sought using the usual
rules. If the specified makefile is the same makefile that is
found using the usual rules, then this option has no effect.
--log=logfilename
--log-file=logfilename
Changes the name of the log file to the indicated name. By
default, the log file is called .makepp/log.
-m method
--signature=method
--signature-method=method
Specifies the default signature method to use for rules which do
not have the ":signature" modifier in makefiles which do not have a
"signature" statement. Does not override the choice made by
command parsers, e.g. C/C++ compilers. Possible values are "md5",
"C" or "c_compilation_md5", "xml" and "xml-space". For more
details, see makepp_signatures.
--md5-bc
--md5-check-bc
When importing from a build cache, reject cached targets unless the
MD5_SUM is present and matches the imported target. When
populating a build cache, calculate and store the MD5_SUM in the
build info if it isn't there already. This is slower and leads to
more rebuilds, but it guarantees that imported targets and build
info files correspond exactly.
-n
--dry-run
--just-print
--recon
Print out commands without actually executing them -- unreliably
where commands depend on previous results. This allows you to see
what makepp will do, without actually changing any files.
More precisely, makepp executes all recursive make commands as
normal (but hopefully you're not using recursive make anywhere!).
Other commands are simply printed without being executed. Even
commands which are prefixed with "@" or "noecho" are printed after
the "@" or "noecho" is stripped off. However commands prefixed
with "+" should be executed, but currently are not.
Warning: The commands that makepp executes with "-n" are not
necessarily the same thing it will do without "-n". File
signatures do not change at all with "-n", which means that makepp
cannot perform exactly the same build tests that it does when the
signatures are changing. This will occasionally make a difference
if you are using MD5 signatures (which is the default for
compilation commands) or if you have shell commands that might or
might not change the date.
For example, suppose that you generate a .h file via some sort of
preprocessor. This can happen in a lot of different ways. For
concreteness, suppose you automatically generate a list of
prototypes for functions defined in each C module (see
<http://cproto.sourceforge.net/> for how the "cproto" application
works or <http://www.lemoda.net/c/cfunctions/> for the similar
cfunctions).
prototypes.h : *.c
cproto $(CPPFLAGS) $(inputs) > $(output)
Then each .c file will include prototypes.h. The purpose of this
is to maintain the forward declarations for all functions
automatically, so if you change a function's signature or add a new
function, you don't ever have to put in forward or extern
declarations anywhere. You don't even have to declare the
dependency of your .o files on this one -- makepp will see the
include statement and automatically see if it needs to (re)run
cproto.
Now suppose you change just one .c file. What happens when you run
makepp with "-n" in this case is that it realizes that prototypes.h
needs to be remade. In all probability, remaking prototypes.h
won't affect its signature--the file contents will probably be
identical because no function arguments have been changed--so most
of the time, nothing that depends on prototypes.h actually has to
be recompiled. But makepp doesn't know that unless it's actually
allowed to execute the commands. So it assumes that anything that
depends on prototypes.h will also have to be recompiled. Thus in
this example, changing one .c file will cause "makepp -n" to think
that every single .c file needs to be recompiled, even though most
likely the regular makepp command will actually not run all those
commands.
This situation isn't all that common, and can only occur if (a) you
use a signature method that depends on file contents rather than
date, as the default compilation signature method does, or (b) if
you have shell commands that don't always change the date. E.g.,
with a traditional implementation of make that only looks at dates
instead of file signatures, sometimes people will write commands
like this:
prototypes.h : $(wildcard *.c) # Hacked technique not necessary for makepp
cproto $(CPPFLAGS) $(inputs) > junk.h
if cmp -s junk.h prototypes.h; then \
rm junk.h; \
else \
mv junk.h prototypes.h; \
fi
Thus if rerunning cproto on all the files produces exactly the same
file contents, the file date is not updated. This will have
exactly the same problem as the above example with "makepp -n": it
is not known whether the date on prototypes.h changes unless the
command is actually run, so "makepp -n" cannot possibly be 100%
accurate. (Note that using the traditional "make -n" will also
have exactly the same problem on this example.)
"makepp -n" should always print out more commands than a regular
invocation of makepp, not fewer. If it prints out fewer commands,
it means that makepp does not know about some dependency; some file
is changing that it is not expecting to change on the basis of what
it knows about what files each rule affects. This means that your
makefile has a bug.
--no-cache-scaninfos
Do not record the results of scanning, forcing it to be reperformed
next time makepp runs.
--no-implicit-load
Don't automatically load makefiles from directories referenced (see
"Implicit loading" in makepp_build_algorithm). By default, makepp
automatically loads a makefile from any directory that contains a
dependency of some target it needs to build, and from any directory
that is scanned by a wildcard. Sometimes, however, this causes a
problem, since makefiles need to be loaded with different command
line variables or options, and if they are implicitly loaded before
they are explicitly loaded by a recursive make invocation or the
"load_makefile" statement, makepp aborts with an error. You can
also turn off makefile loading on a directory-by-directory basis by
using the "no_implicit_load" statement in one of your makefiles.
--no-log
Don't bother writing a detailed description of what was done to the
log file. By default, makepp writes out an explanation of every
file that it tried to build, and why it built it or did not build
it, to a file called .makepp/log. This can be extremely valuable
for debugging a makefile--makepp tells you what it thought all of
the dependencies were, and which one(s) it thought changed.
However, it does take some extra CPU time, and you might not want
to bother.
--no-path-exe-dep
--no-path-executable-dependencies
Do not add implicit dependencies on executables picked up from the
command search path. If this option is specified, then makepp
assumes that any executable whose behavior might change with a new
version will be specified with a name containing a slash.
This is useful for programs such as grep and diff, which always do
basically the same thing even if their implementation changes,
though you're better off using the builtin commands for grep. You
may also need this for repositories on NFS clusters, where the same
commands might not have the same timestamp everywhere, causing
unnecessary rebuilds depending what machine somebody works on.
--no-populate-bc
Don't populate the build cache, but still import from it when
possible. This is useful when the environment might cause targets
to be generated differently, but makepp doesn't know about such
dependencies. It's also useful to avoid thrashing the build cache
with a huge number of concurrent writers that might interfere with
one another.
--no-print-directory
Turn off the entering or leaving directory messages.
--no-remake-makefiles
Ordinarily, makepp loads each makefile in, then looks to see
whether there is a rule that specifies how to update the makefile.
If there is, and the makefile needs to be rebuilt, the command is
executed, and the makefile is reread. This often causes problems
with makefiles produced for the standard Unix make utility, because
(in my experience) often the make rules for updating makefiles are
inaccurate--they frequently omit targets which are modified. This
can cause makepp to remake a lot of files unnecessarily. You can
often solve this problem by simply preventing makepp from updating
the makefile automatically (but you have to remember to update it
by hand).
--no-warn
Don't print any warning messages to stderr, only to log file. Most
warning messages are about constructs that you might see in legacy
makefiles that makepp considers dangerous, but a few of them
concern possible errors in your makefile.
-o filename
--assume-old=filename
--old-file=filename
Pretends that the specified file has not changed, even if it has.
Any targets that depend on this file will not be rebuilt because of
this file, though they might be rebuilt if some other dependency
has also changed. The file itself might or might not be rebuilt,
depending on whether it is out of date with respect to its
dependencies. (To prevent that, use "--dont-build".)
--override-signature=method
--override-signature-method=method
Same as "--signature-method", but even overrides the choice made by
command parsers.
--out-of-sandbox=filename
Generate an error rather than write files outside the "sandbox".
Like --dont-build, more specific paths override less specific
paths. The filesystem root defaults to out-of-sandbox if there are
any "--sandbox" options.
The purpose of the sandbox is to enable multiple concurrent makepp
processes to safely operate on disjoint parts of the filesystem.
In order for this to work reliably, concurrent sandboxes must not
overlap, and each process must mark the sandbox of every other
concurrent makepp process for --dont-read. See partitioning into
sandboxes.
--populate-bc-only
Don't import for the build cache. This is useful when you want to
donate targets to the cache, but you don't want to rely on the
contents of the cache (e.g. for mission-critical builds).
--profile
Output timestamps before and after each action.
-R directory
--repository=directory
Specify the given directory as a repository (see
makepp_repositories for details). Repositories are added in the
order specified on the command line, so the first one you specify
has precedence. All files in the directory (and all its
subdirectories) are automatically linked to the current directory
(and subdirectories) if they are needed.
If you just specify a directory after "-R", its contents are linked
into the current directory. You can link its contents into any
arbitrary place in the file system by specifying the location
before an equals sign, e.g,
"-R subdir1/subdir2=/users/joe/joes_nifty_library".
-r
--no-builtin-rules
Don't load the default rule sets. If this option is not specified,
and the variable "makepp_no_builtin" is not defined in the
makefile, then a set of rules for compiling C, C++, and Fortran
code is loaded for each directory.
--rm-stale
--remove-stale
--remove-stale-files
Ignore stale files rather then treating them as new source files,
removing them if necessary in order to prevent them from being read
by a build command. This is not the default because it deletes
things, but it is often required in order for incremental building
to work properly.
For example, assume that there is an x.c file that looks like this:
#include "x.h"
int main() { return X; }
Consider this makefile:
$(phony default): x
x.h:
&echo "#define X 1" -o $@
At some point, you change the makefile to look like this:
CFLAGS := -Idir
$(phony default): x
dir/x.h:
&mkdir -p $(dir $@)
&echo "#define X 2" -o $@
Now if you build from clean, x exits with status 2, but if you
build while the old ./x.h file still exists and you don't specify
"--rm-stale", then x exits with status 1, because the include
directive picks up the stale generated header file.
If you build with "--rm-stale", then ./x.h is removed, and the
result is the same as that of a clean build, which is almost always
a good thing.
-s
--quiet
--silent
Don't echo commands and don't print informational messages like
"Scanning" or "Loading makefile".
--sandbox=directory
--in-sandbox=directory
--inside-sandbox=directory
Restrain this instance of makepp to a subtree of a normally bigger
build tree. See partitioning into sandboxes.
--sandbox-warn
--sandbox-warning
Downgrade violations of "in-sandbox" and "dont-read" to warnings
instead of errors. See partitioning into sandboxes.
--stop
--stop-after-loading
After loading the top level Makeppfile, and any others explicitly
or implicitly (through dependencies from other directories) loaded
from there, makepp will stop itself (go to sleep). This happens
before it analyzes anything else. It will tell you the command
needed to wake it up again. If you do it in a Shell, you get the
prompt and can then fore- or background it. If you do it within an
IDE, it'll just sleep, and you can awaken it from another Shell.
The intention is that you can start makepp this way before you're
finished editing some files. Depending on your project structure
and size, this can allow makepp to get a headstart of many seconds
worth of work by the time you're done.
If you use "prebuild" or "$(make)" it will stop when it gets to
that point, so it might not be so useful. Nor will it consider
regeneration of Makeppfiles, but this is not expected to happen
frequently.
--stop-race
--stop-on-race
Exit in error rather than only warning about a sandbox access
collision that could be fixed.
--symlink-in-rep-as-file
--symlink-in-repository-as-file
If a repository contains a symbolic link, then by default that
symbolic link is imported as a link, which is to say that the
target of the imported link need not be identical to the target of
the symbolic link in the repository. If the
"--symlink-in-repository-as-file" option is specified, then the
symbolic link is imported as its target file, which is to say that
the imported link points to the same target file as the symbolic
link in the repository. This is useful if the symbolic link in the
repository was intended to have the build-time semantics of a copy.
--traditional
--traditional-recursion
--traditional-recursive-make
This option is present to allow makepp to work with old makefiles
that use recursive make extensively, especially with varying
options. By default, recursive make is implemented by a subprocess
that communicates with the parent process; the build is actually
done by the parent process. This allows some of makepp's nice
features like repositories to work with recursive make invocations.
However, this technique will not work if you use different command
line options on different invocations of recursive make. Before
you use this, try "--hybrid-recursive-make".
"--traditional-recursive-make" option makes makepp do recursive
makes the same way as the traditional make, allowing more makefiles
to work, but then repositories and parallel builds do not work
properly. This option is rarely needed any more, and makepp will
tell you if it runs into a construct that requires it.
If you do use this option, you will get log files piling up in the
various directories this changes to. To get rid of only them use
"makeppclean --logs --recurse" or "mppc -lr".
-v
--verbose
Verbose mode. Explains what it is trying to build, and why each
file is being built. This can be useful if you think a file is
being rebuilt too often.
This option actually takes what would be written to the log file
and displays it on the screen. It's usually easier to run makepp
and then look at the output of makepplog, which allows various
selections and some rewriting.
-V
--version
Print out the version number.
--virtual-sandbox
Don't rewrite build infos of files that were not created by this
makepp process. See partitioning into sandboxes.
-W filename
--assume-new=filename
--new-file=filename
--what-if=filename
Pretends the specified file has changed, so that any targets that
depend on that file will be rebuilt. The file itself is not
necessarily changed (it might or might not be rebuilt, depending on
whether it is up to date with respect to its dependencies), but
everything that depends on it thinks that it has changed. This can
be useful for debugging a makefile.
ENVIRONMENT
Makepp searches upwards for a file called .makepprc when starting and
again after every "-C" or "-c" option. Each time it finds such a file,
but only once per file, it will read the file and parse it as possibly
quoted options on one or several lines. Unlike the option "-A", the
options will be parsed relative to the directory where the file
resides.
Makepp looks at the following environment variables:
$MAKEFLAGS
Any flags in this environment variable are interpreted as command
line options before any explicit options. All command line
arguments are put into this variable
Note that the traditional make also uses this variable, so if you
have to use both make and makepp, you might want to consider using
"MAKEPPFLAGS".
$MAKEPPFLAGS
Same as "MAKEFLAGS" as far as makepp is concerned. If this
variable is not blank, then "MAKEFLAGS" is ignored. Sometimes this
is useful instead of "MAKEFLAGS" if you have to use both make and
makepp, and you need to keep the options separate.
$MAKEPP_CASE_SENSITIVE_FILENAMES
Makepp will attempt to determine whether its default directory is
case sensitive by creating a file and then accessing it with a
different case. Usually this works fine, as long as all the files
you're accessing are on the same file system as your default
directory, so you should rarely need to use this option.
If this variable is present in the environment, its value (0 or
empty string for false, anything else for true) will override
makepp's choice. This variable is mostly useful on Windows, if you
want to override makepp's default setting. If you don't treat
filenames as case sensitive, then makepp converts all filenames to
lowercase, which causes occasional difficulties. (E.g., emacs may
will open several buffers to the same file.)
Makepp does not currently support a build across several file
systems, one of which is case sensitive and the other case
insensitive.
perl v5.20.3 2012-02-07 MAKEPP_COMMAND(1)
