PMAKE(1)                                                 PMAKE(1)

NAME
       pmake - create programs in parallel
SYNOPSIS
       pmake  [-d  what]  [-e]  [-f makefile] [-h] [-i] [-k] [-l]
            [-n] [-p #] [-q] [-r] [-s] [-t] [-x] [-v]  [-B]  [-C]
            [-D  variable] [-I directory] [-J #] [-L #] [-M] [-P]
            [-R when] [-S] [-V] [-W] [-X]  [-Z  c]  [VAR1=value1]
            [VAR2=value2...] [targ1] [targ2 ...]
       -d   what                  Specify   what  modules  should
                                  print  debugging   information.
                                  what  is  a  string  of letters
                                  from the following set:
                                  a - archive searching,
                                  c - conditional evaluation,
                                  d - directory searching,
                                  j - job scheduling,
                                  m - make dependencies,
                                  p - makefile parsing,
                                  q - job queue maintenance,
                                  r - remote execution
                                  s - suffix processing,
                                  t - target list maintenance,
                                  v - variable assignments,
                                  \* - all of the above.
       -e                         Specify that environment  vari-
                                  ables  override  macro  assign-
                                  ments within makefiles.
       -f   makefile              Specify a different makefile to
                                  read  than the standard ``Make-
                                  file''  or  ``makefile''.    If
                                  makefile  is  "-",  reads  from
                                  standard input.
       -h                         Prints out help information.
       -i                         ``Ignore  errors''  --   ignore
                                  non-zero  exit statuses of com-
                                  mands.
       -k                         ``Keepgoing'' -- if an error is
                                  encountered,  keep  working  on
                                  those parts of the input  graph
                                  that  are  not  affected by the
                                  error.
       -l                         PMake has the ability to lock a
                                  directory  against other people
                                  executing it in the same direc-
                                  tory (by means of a file called
                                  ``LOCK.make'' that  it  creates
                                  and  checks  for  in the direc-
                                  tory). This  is  a  Good  Thing
                                  because  two  people  doing the
                                  same thing in  the  same  place
                                  can be disastrous for the final
                                  product (too many cooks and all
                                  that).  Whether this locking is
                                  the default is up to your  sys-
                                  tem  administrator.  If locking
                                  is on, -l will turn it off, and
                                  vice   versa.  Note  that  this
                                  locking will  not  prevent  you
                                  from  invoking  PMake  twice in
                                  the same place --  if  you  own
                                  the  lock file, PMake will warn
                                  you about it  but  continue  to
                                  execute.
       -n                         ``No  execute''  -- do not exe-
                                  cute commands.  Just print  the
                                  ones that would be executed.
       -p   #                     Tell PMake if and when to print
                                  the input graph.  The number is
                                  the bitwise OR of the numbers 1
                                  and 2 with 1 meaning  to  print
                                  the  graph  before  making any-
                                  thing and 2  meaning  to  print
                                  the  graph  after making every-
                                  thing.
       -q                         ``Query'' -- do not execute any
                                  commands.   Just  exit 0 if the
                                  given target(s) is (are) up  to
                                  date  and  exit non-zero other-
                                  wise.
       -r                         ``Remove built-in rules'' -- do
                                  not  parse  the  built-in rules
                                  given in the system makefile.
       -s                         ``Silence'' -- do not echo com-
                                  mands as they are executed.
       -t                         ``Touch   targets''  --  rather
                                  than executing the commands  to
                                  create  a  target,  just change
                                  its  modification  time  so  it
                                  appears  up-to-date.   This  is
                                  dangerous.
       -x                         ``Export'' --  causes  commands
                                  to  be  exported  when in Make-
                                  compatibility    mode.    Since
                                  exporting commands in this mode
                                  will  often  take  longer  than
                                  running   them   on  the  local
                                  machine, exportation is off  by
                                  default  and  must be turned on
                                  using this flag.
       -v                         ``System V'' -- invokes compat-
                                  ibility  functions suitable for
                                  acting like the System  V  ver-
                                  sion  of Make. This implies -B,
                                  and -V and turns off  directory
                                  locking.  Locking may be turned
                                  back on again by giving the  -l
                                  flag after -v.
       -B                         ``Backwards-compatible''     --
                                  performs as much like  Make  as
                                  possible (including executing a
                                  single shell  per  command  and
                                  expanding   variables  as  Make
                                  did) while still performing  in
                                  parallel.
       -C                         ``Non-compatible'' -- turns off
                                  all compatibility specified  up
                                  to  the  point  at  which -C is
                                  encountered.
       -D   variable              Defines the given  variable  to
                                  be 1 in the global context.
       -I   directory             Specify  another  directory  in
                                  which to  look  for  #include'd
                                  makefiles.   This  flag  may be
                                  repeated as many times as  nec-
                                  essary.
       -J   #                     Specify  the  maximum number of
                                  jobs to  run  at  once  on  all
                                  machines.
       -L   #                     Specify  the  maximum number of
                                  jobs to run locally.   A  nega-
                                  tive  argument  sets  a  limits
                                  equal to  the  absolute  value,
                                  but  also  directs PMake to run
                                  jobs locally  as  long  as  the
                                  limit is not exceeded.  Usually
                                  PMake  tries  to  export   jobs
                                  before  resorting to local exe-
                                  cution.
       -M                         Be as much like Make as  possi-
                                  ble.   No  parallel  execution.
                                  Old-style  variable  expansion.
                                  One shell per command. Etc.
       -P                         ``Don't  use Pipes'' -- see the
                                  section on OUTPUT.
       -R   when                  ``Recheck targets'' -- possible
                                  values  are  always, never, and
                                  locals (default for  NFS  based
                                  systems   where  remote  target
                                  updates  are  not   immediately
                                  visible locally).
       -S                         ``Stop   on  error''  --  tells
                                  PMake to stop as soon as a com-
                                  mand  returns  a  non-zero exit
                                  status,   overriding   the   -k
                                  option.
       -V                         ``Do  old-style variable expan-
                                  sion'' --  expands  an  unknown
                                  variable to the empty string.
       -W                         Don't print warning messages.
       -X                         ``No   Export''   --  prohibits
                                  exportation. -x and  -X  should
                                  not  be  used  in the same com-
                                  mand.
       -Z   c                     Modifies  makefile  parsing  to
                                  use  c  as the character intro-
                                  ducing  #include,   conditional
                                  and other directives.  Could be
                                  set to `.' for 4.4BSD  compati-
                                  bility,  or  to  some  unlikely
                                  character to disable directives
                                  altogether.
       VAR=value                  Set  the  value of the variable
                                  VAR to the given  value.   This
                                  supersedes  any  value assigned
                                  to the variable  in  the  make-
                                  file.  See VARIABLES.
LOCAL NOTE