home | help
MAKE(1) 		     General Commands Manual			 MAKE(1)

NAME
     make -- maintain program dependencies

SYNOPSIS
     make [-BPSXeiknqrstv] [-D variable] [-d flags] [-E variable] [-f makefile]
	  [-I directory] [-j max_jobs] [-m directory] [-V variable]
	  [variable=value] [target ...]

DESCRIPTION
     The make utility is a program designed to simplify the maintenance of other
     programs.	 Its input is a list of specifications describing dependency re-
     lationships between the generation of files and  programs.   The  first  of
     `makefile' and `Makefile' that can be found in either the current directory
     or a special object directory (see `.OBJDIR') will be read for this list of
     specifications.   If  the file `.depend' can be found, it is also read (see
     mkdep(1)).

     This manual page is intended as a reference  document  only.   For  a  more
     thorough introduction to make and makefiles, please refer to Make - A Tuto-
     rial.

     The options are as follows:

     -B      Try to be backwards compatible by executing a single shell per com-
	     mand  and by executing the commands to make the sources of a depen-
	     dency line in sequence.  This is turned on by default unless -j  is
	     used.

     -D variable
	     Define variable to be 1, in the global context.

     -d flags
	     Turn  on debugging, and specify which portions of make are to print
	     debugging information.  Argument flags is one or more of  the  fol-
	     lowing:

	     A	     Print  all  possible  debugging  information; equivalent to
		     specifying all of the debugging flags.

	     a	     Print debugging information  about  archive  searching  and
		     caching.

	     c	     Print debugging information about conditional evaluation.

	     d	     Print  debugging  information about directory searching and
		     caching.

	     f	     Print debugging information  about  the  execution  of  for
		     loops.  Currently a no-op.

	     g1      Print the input graph before making anything.

	     g2      Print  the  input	graph after making everything, or before
		     exiting on error.

	     j	     Print debugging information about running multiple shells.

	     l	     Print commands in Makefiles regardless of	whether  or  not
		     they  are prefixed by @ or other "quiet" flags.  Also known
		     as "loud" behavior.

	     m	     Print debugging information about making targets, including
		     modification dates.

	     s	     Print  debugging  information  about  suffix-transformation
		     rules.

	     t	     Print debugging information about target list maintenance.

	     v	     Print debugging information about variable assignment.

     -E variable
	     Specify  a  variable whose environment value (if any) will override
	     macro assignments within makefiles.

     -e      Specify that environment values override macro  assignments  within
	     makefiles for all variables.

     -f makefile
	     Specify  a  makefile  to read instead of the default `makefile' and
	     `Makefile'.  If makefile is `-', standard input is read.	Multiple
	     makefiles may be specified, and are read in the order specified.

     -I directory
	     Specify  a  directory in which to search for makefiles and included
	     makefiles.  The system makefile directory (or directories, see  the
	     -m option) is automatically included as part of this list.

     -i      Ignore non-zero exit of shell commands in the makefile.  Equivalent
	     to specifying `-' before each command line in the makefile.

     -j max_jobs
	     Specify  the  maximum  number of jobs that make may have running at
	     any one time.  Turns compatibility mode off, unless the B	flag  is
	     also specified.

     -k      Continue processing after errors are encountered, but only on those
	     targets  that do not depend on the target whose creation caused the
	     error.

     -m directory
	     Specify a directory in which to search for sys.mk and makefiles in-
	     cluded via the <...> style.  Multiple directories can be  added  to
	     form a search path.  This path will override the default system in-
	     clude  path:  /usr/share/mk.   Furthermore, the system include path
	     will be appended to the search path used for "..."-style inclusions
	     (see the -I option).

     -n      Display the commands that would have been executed, but do not  ac-
	     tually execute them.

     -P      Collate  the output of a given job and display it only when the job
	     finishes, instead of mixing the output of parallel  jobs  together.
	     This option has no effect unless -j is used too.

     -q      Do  not  execute  any commands, but exit 0 if the specified targets
	     are up-to-date and 1, otherwise.

     -r      Do not use the built-in rules specified in the system makefile.

     -S      Stop processing when an error is encountered.   Default  behaviour.
	     This is needed to negate the -k option during recursive builds.

     -s      Do not echo any commands as they are executed.  Equivalent to spec-
	     ifying `@' before each command line in the makefile.

     -t      Rather than re-building a target as specified in the makefile, cre-
	     ate  it  or  update  its modification time to make it appear up-to-
	     date.

     -V variable
	     Print make's idea of the value of variable, in the global	context.
	     Do not build any targets.	Multiple instances of this option may be
	     specified; the variables will be printed one per line, with a blank
	     line for each null or undefined variable.

     -v      Be  extra	verbose.  For multi-job makes, this will cause file ban-
	     ners to be generated.

     -X      When using the -V option to print the values of variables,  do  not
	     recursively expand the values.

     variable=value
	     Set the value of the variable variable to value.

     There  are  seven	different  types of lines in a makefile: file dependency
     specifications, shell commands, variable assignments,  include  statements,
     conditional directives, for loops, and comments.

     In general, lines may be continued from one line to the next by ending them
     with  a backslash (`\').  The trailing newline character and initial white-
     space on the following line are compressed into a single space.

FILE DEPENDENCY SPECIFICATIONS
     Dependency lines consist of one or more targets, an operator, and	zero  or
     more  sources.   This  creates a relationship where the targets "depend" on
     the sources and are usually created from them.  The exact relationship  be-
     tween  the  target  and the source is determined by the operator that sepa-
     rates them.  The three operators are as follows:

     :	   A target is considered out-of-date if its modification time	is  less
	   than  those	of  any of its sources.  Sources for a target accumulate
	   over dependency lines when this operator is used.  The target is  re-
	   moved if make is interrupted.

     !	   Targets  are  always  re-created, but not until all sources have been
	   examined and re-created as necessary.  Sources for a  target  accumu-
	   late over dependency lines when this operator is used.  The target is
	   removed if make is interrupted.

     ::    If no sources are specified, the target is always re-created.  Other-
	   wise,  a  target  is considered out-of-date if any of its sources has
	   been modified more recently than the target.  Sources for a target do
	   not accumulate over dependency lines when this operator is used.  The
	   target will not be removed if make is interrupted.

     Targets and sources may contain the shell wildcard  expressions  `?',  `*',
     `[]'  and `{}'.  The expressions `?', `*' and `[]' may only be used as part
     of the final component of the target or source, and must  be  used  to  de-
     scribe existing files.  The expression `{}' need not necessarily be used to
     describe  existing  files.  Expansion is in directory order, not alphabeti-
     cally as done in the shell.

SHELL COMMANDS
     Each target may have associated with it a series of  shell  commands,  nor-
     mally  used to create the target.	Each of the commands in this script must
     be preceded by a tab.  While any target may appear on  a  dependency  line,
     only one of these dependencies may be followed by a creation script, unless
     the `::' operator is used.

     If  the  first  or  first two characters of the command line are `@' and/or
     `-', the command is treated specially.  A `@' causes the command not to  be
     echoed before it is executed.  A `-' causes any non-zero exit status of the
     command line to be ignored.

VARIABLE ASSIGNMENTS
     Variables	in make are much like variables in the shell, and, by tradition,
     consist of all upper-case letters.  The five operators that can be used  to
     assign values to variables are as follows:

     =	     Assign  the  value to the variable.  Any previous value is overrid-
	     den.

     +=      Append the value to the current value of the variable.

     ?=      Assign the value to the variable if it is not already defined.

     :=      Assign with expansion, i.e. expand the value before assigning it to
	     the variable.  Normally, expansion is not done until  the	variable
	     is referenced.

     !=      Expand  the value and pass it to the shell for execution and assign
	     the result to the variable.  Any newlines in  the	result	are  re-
	     placed with spaces.

     Any  whitespace before the assigned value is removed; if the value is being
     appended, a single space is inserted between the previous contents  of  the
     variable and the appended value.

     Variables	are  expanded by surrounding the variable name with either curly
     braces (`{}') or parentheses (`()') and preceding it  with  a  dollar  sign
     (`$').  If the variable name contains only a single letter, the surrounding
     braces  or  parentheses  are not required.  This shorter form is not recom-
     mended.

     Variable substitution occurs at two distinct times, depending on where  the
     variable  is being used.  Variables in dependency lines are expanded as the
     line is read.  Variables in shell commands are expanded when the shell com-
     mand is executed.

     The four different classes of variables (in order of increasing precedence)
     are:

     Environment variables
	     Variables defined as part of make's environment.

     Global variables
	     Variables defined in the makefile or in included makefiles.

     Command line variables
	     Variables defined as part of the command line.

     Local variables
	     Variables that are defined specific to a certain target.  The seven
	     local variables are as follows:

	     .ALLSRC   The list of all sources for this target;  also  known  as
		       `>'.

	     .ARCHIVE  The name of the archive file; also known as `!'.

	     .IMPSRC   The  name/path  of the source from which the target is to
		       be transformed (the "implied" source); also known as `<'.

	     .MEMBER   The name of the archive member; also known as `%'.

	     .OODATE   The list of sources for this target that were deemed out-
		       of-date; also known as `?'.

	     .PREFIX   The file prefix of the file,  containing  only  the  file
		       portion,  no  suffix  or  preceding directory components;
		       also known as `*'.

	     .TARGET   The name of the target; also known as `@'.

	     The shorter forms `@', `!', `<', `%', `?', `>', and `*' are permit-
	     ted for backward compatibility and are not  recommended.	The  six
	     variables	`@F', `@D', `<F', `<D', `*F', and `*D' are permitted for
	     compatibility with AT&T System V UNIX makefiles and are not  recom-
	     mended.

	     Four  of  the  local variables may be used in sources on dependency
	     lines because they expand to the proper value for	each  target  on
	     the  line.   These  variables are `.TARGET', `.PREFIX', `.ARCHIVE',
	     and `.MEMBER'.

     In addition, make sets or knows about the following internal  variables  or
     environment variables:

     $		A  single  dollar sign `$', i.e. `$$' expands to a single dollar
		sign.

     MAKE	The name that make was executed with (argv[0]).

     .CURDIR	A path to the directory where make was executed.  The make util-
		ity sets .CURDIR to the canonical path given by getcwd(3).

     .OBJDIR	A path to  the	directory  where  the  targets	are  built.   At
		startup,  make searches for an alternate directory to place tar-
		get files.  It will attempt to change into this  special  direc-
		tory  and  will search this directory for makefiles not found in
		the current directory.	The following directories are  tried  in
		order:

		1.   ${MAKEOBJDIRPREFIX}/`pwd`
		2.   ${MAKEOBJDIR}
		3.   obj.${MACHINE}
		4.   obj
		5.   /usr/obj/`pwd`

		The first directory that make successfully changes into is used.
		If  either MAKEOBJDIRPREFIX or MAKEOBJDIR is set in the environ-
		ment but make is unable to change into the corresponding  direc-
		tory,  then  the  current directory is used without checking the
		remainder of the list.	If they are undefined and make is unable
		to change into any of the remaining three directories, then  the
		current directory is used.

     .MAKEFLAGS
		The environment variable MAKEFLAGS may contain anything that may
		be specified on make's command line.  Its contents are stored in
		make's	.MAKEFLAGS  variable.  Anything specified on make's com-
		mand line is appended to the .MAKEFLAGS variable which	is  then
		entered into the environment as MAKEFLAGS for all programs which
		make executes.

     MFLAGS	A synonym for .MAKEFLAGS provided for backward compatibility.

     PWD	Alternate  path  to  the  current directory.  Supported if built
		with WANT_ENV_PWD defined.  make normally sets `.CURDIR' to  the
		canonical  path given by getcwd(3).  However, if the environment
		variable PWD is set and gives a path to the  current  directory,
		then  make  sets  `.CURDIR' to the value of PWD instead.  PWD is
		always set to the value of `.OBJDIR' for all programs which make
		executes.

     .TARGETS	List of targets make is currently building.

     .INCLUDES	See .INCLUDES special target.

     .LIBS	See .LIBS special target.

     MACHINE	Name of the machine architecture make is  running  on,	obtained
		from  the  MACHINE  environment variable, or through uname(3) if
		not defined.

     MACHINE_ARCH
		Name of the machine architecture make was compiled for,  defined
		at compilation time.

     VPATH	Makefiles  may	assign	a colon-delimited list of directories to
		VPATH.	These directories will be searched for source  files  by
		make after make has finished parsing all input makefiles.

     Variable  expansion  may  be  modified to select or modify each word of the
     variable (where a "word" is whitespace-delimited sequence	of  characters).
     The general format of a variable expansion is as follows:

	   {variable[:modifier[:...]]}

     Each  modifier begins with a colon and one of the following special charac-
     ters.  The colon may be escaped with a backslash (`\').

     C/pattern/replacement/[1g]
		 The C modifier is just like the S modifier except that the  old
		 and  new  strings,  instead of being simple strings, are an ex-
		 tended regular expression (see re_format(7)) and an ed(1)-style
		 replacement string.  Normally, the first occurrence of the pat-
		 tern in each word of the value is changed.   The  `1'	modifier
		 causes  the  substitution to apply to at most one word; the `g'
		 modifier causes the substitution to apply to as many  instances
		 of the search pattern as occur in the word or words it is found
		 in.  Note that `1' and `g' are orthogonal; the former specifies
		 whether  multiple  words  are	potentially affected, the latter
		 whether multiple substitutions  can  potentially  occur  within
		 each affected word.

     E		 Replaces each word in the variable with its suffix.

     H		 Replaces each word in the variable with everything but the last
		 component.

     L		 Converts variable to lower-case letters.

     Mpattern	 Select  only  those  words that match the rest of the modifier.
		 The standard shell wildcard characters (`*', `?', and `[]') may
		 be used.  The wildcard characters may be escaped with	a  back-
		 slash (`\').

     Npattern	 This  is  identical  to  M,  but selects all words which do not
		 match the rest of the modifier.

     Q		 Quotes every shell meta-character in the variable, so	that  it
		 can be passed safely through recursive invocations of make.

     R		 Replaces each word in the variable with everything but its suf-
		 fix.

     S/old_string/new_string/[g]
		 Modify  the  first occurrence of old_string in each word of the
		 variable's value, replacing it with new_string.  If  a  `g'  is
		 appended  to  the last slash of the pattern, all occurrences in
		 each word are replaced.  If  old_string  begins  with	a  caret
		 (`^'),  old_string  is  anchored at the beginning of each word.
		 If old_string ends with a dollar sign (`$'), it is anchored  at
		 the end of each word.	Inside new_string, an ampersand (`&') is
		 replaced  by old_string.  Any character may be used as a delim-
		 iter for the parts of the modifier string.  The anchoring,  am-
		 persand,  and	delimiter characters may be escaped with a back-
		 slash (`\').

		 Variable expansion occurs in the  normal  fashion  inside  both
		 old_string  and  new_string  with  the  single exception that a
		 backslash is used to prevent the expansion  of  a  dollar  sign
		 (`$'), not a preceding dollar sign as is usual.

     T		 Replaces each word in the variable with its last component.

     old_string=new_string
		 This is the AT&T System V UNIX style variable substitution.  It
		 must	be  the  last  modifier  specified.   If  old_string  or
		 new_string do not contain the pattern matching character % then
		 it is assumed that they are anchored at the end of  each  word,
		 so  only suffixes or entire words may be replaced.  Otherwise %
		 is the substring of old_string to be replaced in new_string

     U		 Converts variable to upper-case letters.

DIRECTIVES, CONDITIONALS, AND FOR LOOPS
     Directives, conditionals, and for loops reminiscent of  the  C  programming
     language  are  provided  in  make.  All such structures are identified by a
     line beginning with a single dot (`.') character.	The following directives
     are supported:

     .include <file>

     .include "file"
	     Include the specified makefile.  Variables between the angle brack-
	     ets or double quotes are expanded to form the file name.  If  angle
	     brackets  are  used, the included makefile is expected to be in the
	     system makefile directory.  If double quotes are used, the  includ-
	     ing makefile's directory and any directories specified using the -I
	     option are searched before the system makefile directory.

     .undef variable
	     Un-define the specified global variable.  Only global variables may
	     be un-defined.

     .error message
	     Terminate	processing of the makefile immediately.  The filename of
	     the makefile, the line on which the error was encountered	and  the
	     specified	message  are  printed to standard output and make termi-
	     nates with exit code 1.  Variables in the message are expanded.

     Conditionals are used to determine which parts of the Makefile to	process.
     They  are used similarly to the conditionals supported by the C pre-proces-
     sor.  The following conditionals are supported:

     .if [!]expression [operator expression ...]
	     Test the value of an expression.

     .ifdef [!]variable [operator variable ...]
	     Test the value of a variable.

     .ifndef [!]variable [operator variable ...]
	     Test the value of a variable.

     .ifmake [!]target [operator target ...]
	     Test the target being built.

     .ifnmake [!]target [operator target ...]
	     Test the target being built.

     .else   Reverse the sense of the last conditional.

     .elif [!]expression [operator expression ...]
	     A combination of `.else' followed by `.if'.

     .elifdef [!]variable [operator variable ...]
	     A combination of `.else' followed by `.ifdef'.

     .elifndef [!]variable [operator variable ...]
	     A combination of `.else' followed by `.ifndef'.

     .elifmake [!]target [operator target ...]
	     A combination of `.else' followed by `.ifmake'.

     .elifnmake [!]target [operator target ...]
	     A combination of `.else' followed by `.ifnmake'.

     .endif  End the body of the conditional.

     The operator may be any one of the following:

     ||     logical OR

     &&     Logical AND; of higher precedence than `||'.

     As in C, make will only evaluate a conditional as far as  is  necessary  to
     determine its value.  Parentheses may be used to change the order of evalu-
     ation.   The boolean operator `!' may be used to logically negate an entire
     conditional.  It is of higher precedence than `&&'.

     The value of expression may be any of the following:

     defined	 Takes a variable name as an argument and evaluates to	true  if
		 the variable has been defined.

     make	 Takes a target name as an argument and evaluates to true if the
		 target  was specified as part of make's command line or was de-
		 clared the default target (either implicitly or explicitly, see
		 .MAIN) before the line containing the conditional.

     empty	 Takes a variable, with possible  modifiers,  and  evaluates  to
		 true  if the expansion of the variable would result in an empty
		 string.

     exists	 Takes a file name as an argument and evaluates to true  if  the
		 file  exists.	 The  file  is searched for on the system search
		 path (see .PATH).

     target	 Takes a target name as an argument and evaluates to true if the
		 target has been defined.

     An expression may also be an arithmetic or string comparison.  Variable ex-
     pansion is performed on both sides of the comparison, after which the inte-
     gral values are compared.	A value is interpreted as hexadecimal if  it  is
     preceded  by  0x, otherwise it is decimal; octal numbers are not supported.
     The standard C relational operators are all supported.  If  after	variable
     expansion, either the left or right hand side of a `==' or `!=' operator is
     not  an integral value, then string comparison is performed between the ex-
     panded variables.	If no relational operator is given, it is  assumed  that
     the expanded variable is being compared against 0.

     When  make  is  evaluating one of these conditional expressions, and it en-
     counters a word it doesn't recognize, either the "make"  or  "defined"  ex-
     pression  is  applied  to it, depending on the form of the conditional.  If
     the form is `.ifdef' or `.ifndef', the  "defined"	expression  is	applied.
     Similarly, if the form is `.ifmake' or `.ifnmake', the "make" expression is
     applied.

     If  the conditional evaluates to true the parsing of the makefile continues
     as before.  If it evaluates to false, the following lines are skipped.   In
     both cases this continues until a `.else' or `.endif' is found.

     For  loops  are  typically used to apply a set of rules to a list of files.
     The syntax of a for loop is:

     .for variable in expression
     <make-rules>
     .endfor

     After the for expression is evaluated, it is split into words.  The  itera-
     tion  variable  is  successively  set  to each word, and substituted in the
     make-rules inside the body of the for loop.

COMMENTS
     Comments begin with a hash (`#') character, anywhere but in a shell command
     line, and continue to the end of the line.

SPECIAL SOURCES
     .IGNORE	 Ignore any errors from the commands associated with  this  tar-
		 get, exactly as if they all were preceded by a dash (`-').

     .MAKE	 Execute the commands associated with this target even if the -n
		 or  -t options were specified.  Normally used to mark recursive
		 make's.

     .NOTMAIN	 Normally make selects the first target it encounters as the de-
		 fault target to be built if  no  target  was  specified.   This
		 source prevents this target from being selected.

     .OPTIONAL	 If a target is marked with this attribute and make can't figure
		 out  how  to create it, it will ignore this fact and assume the
		 file isn't needed or already exists.

     .PRECIOUS	 When make is interrupted, it removes any  partially  made  tar-
		 gets.	This source prevents the target from being removed.

     .SILENT	 Do  not  echo	any of the commands associated with this target,
		 exactly as if they all were preceded by an at sign (`@').

     .USE	 Turn the target into make's version of a macro.  When the  tar-
		 get  is  used	as a source for another target, the other target
		 acquires the commands,  sources,  and	attributes  (except  for
		 .USE)	of  the source.  If the target already has commands, the
		 .USE target's commands are appended to them.

     .WAIT	 If special .WAIT source is appears in a  dependency  line,  the
		 sources  that	precede it are made before the sources that suc-
		 ceed it in the line.  Loops are not being detected and  targets
		 that form loops will be silently ignored.

SPECIAL TARGETS
     Special  targets  may not be included with other targets, i.e. they must be
     the only target specified.

     .BEGIN	 Any command lines attached to this target are	executed  before
		 anything else is done.

     .DEFAULT	 This  is sort of a .USE rule for any target (that was used only
		 as a source) that make can't figure out any other way	to  cre-
		 ate.  Only the shell script is used.  The .IMPSRC variable of a
		 target that inherits .DEFAULT's commands is set to the target's
		 own name.

     .END	 Any  command  lines  attached to this target are executed after
		 everything else is done.

     .IGNORE	 Mark each of the sources with the  .IGNORE  attribute.   If  no
		 sources are specified, this is the equivalent of specifying the
		 -i option.

     .INCLUDES	 A  list of suffixes that indicate files that can be included in
		 a source file.  The suffix must have already been declared with
		 .SUFFIXES; any suffix so declared will have the directories  on
		 its  search  path  (see  .PATH) placed in the .INCLUDES special
		 variable, each preceded by a -I flag.

     .INTERRUPT  If make is interrupted, the commands for this	target	will  be
		 executed.

     .LIBS	 This  does for libraries what .INCLUDES does for include files,
		 except that the flag used is -L.

     .MAIN	 If no target is specified when make  is  invoked,  this  target
		 will  be  built.  This is always set, either explicitly, or im-
		 plicitly when make selects the default target, to give the user
		 a way to refer to the default target on the command line.

     .MAKEFLAGS  This target provides a way to specify flags for make  when  the
		 makefile  is  used.   The  flags  are as if typed to the shell,
		 though the -f option will have no effect.

     .NOTPARALLEL
		 Disable parallel mode.

     .NO_PARALLEL
		 Same as above, for compatibility with other pmake variants.

     .ORDER	 The named targets are made in sequence.

     .PATH	 The sources are directories which are to be searched for  files
		 not  found  in the current directory.	If no sources are speci-
		 fied, any previously specified directories are deleted.   Where
		 possible, use of .PATH is preferred over use of the VPATH vari-
		 able.

     .PATHsuffix
		 The  sources  are directories which are to be searched for suf-
		 fixed files not found in the current directory.  The make util-
		 ity first searches the suffixed search path,  before  reverting
		 to  the default path if the file is not found there.  This form
		 is required for .LIBS and .INCLUDES to work.

     .PHONY	 Apply the .PHONY attribute to any specified  sources.	 Targets
		 with this attribute are always considered to be out of date.

     .PRECIOUS	 Apply	the .PRECIOUS attribute to any specified sources.  If no
		 sources are specified, the .PRECIOUS attribute  is  applied  to
		 every target in the file.

     .SILENT	 Apply	the  .SILENT  attribute to any specified sources.  If no
		 sources are specified, the  .SILENT  attribute  is  applied  to
		 every command in the file.

     .SUFFIXES	 Each  source  specifies  a  suffix  to make.  If no sources are
		 specified, any previous specified suffices are deleted.

COMPATIBILITY
     Older versions of make used MAKE instead of MAKEFLAGS.   This  was  removed
     for  POSIX  compatibility.   The  internal variable MAKE is set to the same
     value as .MAKE; support for this may be removed in the future.

     Most of the more esoteric features of make should probably be  avoided  for
     greater compatibility.

ENVIRONMENT
     The  make	utility uses the following environment variables, if they exist:
     MACHINE, MAKE, MAKEFLAGS, MAKEOBJDIR, MAKEOBJDIRPREFIX, and PWD.

FILES
     .depend			 list of dependencies
     Makefile			 list of dependencies
     makefile			 list of dependencies
     obj			 object directory
     sys.mk			 system makefile  (processed  before  any  other
				 file, including makefile and Makefile)
     /usr/share/mk		 system makefile directory
     /usr/share/doc/psd/12.make  PMake tutorial
     /usr/obj			 default MAKEOBJDIRPREFIX directory.

BUGS
     The determination of .OBJDIR is contorted to the point of absurdity.

     In the presence of several .MAIN special targets, make silently ignores all
     but the first.

     .TARGETS  is  not	set to the default target when make is invoked without a
     target name and no .MAIN special target exists.

     The evaluation of expression in a test is very  simple-minded.   Currently,
     the  only	form  that  works is `.if ${VAR} op something' For instance, you
     should write tests as `.if ${VAR} = string' not the other way around, which
     doesn't work.

     For loops are expanded before tests, so a fragment such as:

     .for TMACHINE in ${SHARED_ARCHS}
     .if ${TMACHINE} = ${MACHINE}
	  ...
     .endif
     .endfor
     won't work, and should be rewritten the other way around.

SEE ALSO
     mkdep(1), make.conf(5)

     PMake - A Tutorial.  in /usr/share/doc/psd/12.make

HISTORY
     A make command appeared in Version 7 AT&T UNIX.

FreeBSD 4.7			 March 19, 1994 			 MAKE(1)

home | help