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

FreeBSD Manual Pages

  
 
  

home | help
MAKEPPBUILTIN(1)		    Makepp		      MAKEPPBUILTIN(1)

NAME
       makeppbuiltin --	Stand-alone access to builtin commands in makepp

DESCRIPTION
       ?: -?,  A: -A,
	 --args-file,
	 --arguments-file,  D: $DIRECTNAMEFLAGS,  H: -h,
	 --help,  I: -I,
	 --include,
	 --include-dir,	 M: -M,
	 $MAKEPPBUILTINFLAGS,
	 --module,  V: -V,
	 --version

       makeppbuiltin [ metaoption ... ]	command	-?|--help

       mppb [ metaoption ... ] command -?|--help

       makeppbuiltin [ metaoption ... ]	command	[ option ... ]
       [ argument ... ]

       mppb [ metaoption ... ] command [ option	... ] [	argument ... ]

       or

       ln makeppbuiltin	command

       command -?|--help

       command [ option	... ] [	argument ... ]

       This command allows you to call the builtin commands makepp provides,
       from outside makepp as well.  This could	be necessary if	you've
       installed things	with Makeppfile	targets	that use &install, but there
       is no corresponding &uninstall target.  Or you need a feature not
       usually found in	the Unix counterparts like "ln -r".  That's what this
       command is for.

       The commands get	a simple additional "--help" option, which their
       builtin counterparts lack.  This	works by parsing the command's option
       declaration.  It	cannot however find out, what other arguments the
       command expects.

       The metaoptions allow loading your own command or helper	functions, but
       only if it comes	from a module.	Valid options are:

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

       -?
       -h
       --help
	   Print out a brief summary of	the options.

       -I directory
       --include=directory
       --include-dir=directory
	   Add directory to Perl load path @INC.

       -M module[=arg,...]
       --module=module[=arg,...]
	   Load	module and import any functions	it exports.

       -V
       --version
	   Print out the version number.

DIRECT CALL
       If you like to call such	a command more frequently, you can call	it
       directly, by linking "makeppbuiltin" to the name	of that	command.  The
       name of the builtin can occur anywhere within the file-name without
       directory.  So any of the following links would invoke the builtin
       "template" command (but the last	would need to be escaped from the
       Shell):

       template
       template.pl
       makepptemplate
       templatepp
       &template

DIFFERENCES
       There are a few notable differences between the usual call within a
       Makeppfile rule,	and a stand-alone call:

       Syntax
	   Builtin commands are	not parsed by the Shell	within makepp.	There
	   are subtle differences in how makepp	quotes work, e.g. dollar signs
	   are expanded	by makepp even within single quotes, and need to be
	   doubled to escape them.  Various characters,	like "*", "&" or "|"
	   are not special to makepp and need not be escaped.

	   Difference: To start	the command stand-alone	you are	probably using
	   a Shell.  Here you must adapt such special cases to the syntactical
	   requirements	of the Shell.

       Variables and Functions
	   Before makepp executes the rule actions, they will already have
	   undergone expression	expansion of makepp variables and functions.

	   Difference: When called from	the Shell, you will instead get
	   unprotected Shell variables and expressions expanded, before	the
	   comand is called.

       Perl Code
	   Each	Makeppfile lives in its	own (anonymous)	Perl package.
	   Anything you	do therein is available	when running builtin commands.
	   For example,	you can	set variables or define	functions, and use
	   them	within the Perl	code of	those commands that accept it.

	   Difference: In stand-alone usage there is no	such context.
	   Everything you need,	must be	in the Perl code you pass the command,
	   or in modules you use.

ENVIRONMENT
       Makeppbuiltin looks at the following environment	variables:

       $MAKEPPBUILTINFLAGS
	   Any flags in	this environment variable are interpreted as command
	   line	options	before any explicit options.  Quotes are interpreted
	   like	in makefiles.

       $DIRECTNAMEFLAGS
	   This	variable is used instead of $MAKEPPBUILTINFLAGS	when
	   makeppbuiltin is linked to directname as explained under "DIRECT
	   CALL".

AUTHOR
       Daniel Pfeiffer (occitan@esperanto.org)

perl v5.24.1			  2012-02-05		      MAKEPPBUILTIN(1)

NAME | DESCRIPTION | DIRECT CALL | DIFFERENCES | ENVIRONMENT | AUTHOR

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=makeppbuiltin&sektion=1&manpath=FreeBSD+12.0-RELEASE+and+Ports>

home | help