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

FreeBSD Manual Pages

  
 
  

home | help
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.36.3			  2012-02-07		     MAKEPP_COMMAND(1)

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

home | help