Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (SunOS-5.10)
Apropos / Subsearch:
optional field

sysV-make(1)                     User Commands                    sysV-make(1)

       sysV-make - maintain, update, and regenerate groups of programs

       /usr/lib/svr4.make [-f makefile] [-eiknpqrst] [names]

       This  is  the  "vanilla"  System  V version of make. If the environment
       variable USE_SVR4_MAKE is set, then the command make will  invoke  this
       version of  make. (See also the ENVIRONMENT section.)

       make  allows  the programmer to maintain, update, and regenerate groups
       of computer programs. make executes commands in makefile to update  one
       or  more target names (names are typically programs).  If the -f option
       is not present, then makefile, Makefile, and the  Source  Code  Control
       System  (SCCS)  files  s.makefile and s.Makefile are tried in order. If
       makefile is `-' the standard input is taken. More than one -f  makefile
       argument pair may appear.

       make updates a target only if its dependents are newer than the target.
       All prerequisite files of a target are added recursively to the list of
       targets. Missing files are deemed to be outdated.

       The  following  list  of four directives can be included in makefile to
       extend the options provided by make.  They are used in makefile  as  if
       they were targets:

       .DEFAULT:       If  a  file must be made but there are no explicit com-
                       mands or relevant built-in rules, the commands  associ-
                       ated with the name .DEFAULT are used if it exists.

       .IGNORE:        Same effect as the -i option.

       .PRECIOUS:      Dependents  of  the .PRECIOUS entry will not be removed
                       when quit or interrupt are hit.

       .SILENT:        Same effect as the -s option.

       The options for make are listed below:

       -e              Environment variables override assignments within make-

       -f makefile     Description  filename  (makefile  is  assumed to be the
                       name of a description file).

       -i              Ignore error codes returned by invoked commands.

       -k              Abandon work on the current entry if it fails, but con-
                       tinue  on  other  branches  that  do not depend on that

       -n              No execute mode. Print commands,  but  do  not  execute
                       them.  Even  command  lines  beginning  with an `@' are

       -p              Print out the complete set  of  macro  definitions  and
                       target descriptions.

       -q              Question.  make  returns a zero or non-zero status code
                       depending on whether or not the target  file  has  been

       -r              Do not use the built-in rules.

       -s              Silent mode.  Do not print command lines before execut-

       -t              Touch the target files (causing  them  to  be  updated)
                       rather than issue the usual commands.

   Creating the makefile
       The  makefile invoked with the -f option is a carefully structured file
       of explicit instructions for updating and  regenerating  programs,  and
       contains  a  sequence  of entries that specify dependencies.  The first
       line of an entry is a blank-separated, non-null list of targets, then a
       `:', then a (possibly null) list of prerequisite files or dependencies.
       Text following a `;' and all following lines that begin with a tab  are
       shell commands to be executed to update the target. The first non-empty
       line that does not begin with a tab or `#' begins a new  dependency  or
       macro  definition.  Shell commands may be continued across lines with a
       backslash-new-line (\-NEWLINE) sequence.  Everything  printed  by  make
       (except the initial TAB) is passed directly to the shell as is. Thus,

              echo a\

       will produce


       exactly the same as the shell would.

       Number-sign  (#)  and  NEWLINE  surround  comments  including contained
       `\-NEWLINE' sequences.

       The following makefile says that pgm depends on two files a.o and  b.o,
       and  that  they in turn depend on their corresponding source files (a.c
       and b.c) and a common file incl.h:

              pgm: a.o b.o
                      cc a.o b.o -o pgm
              a.o: incl.h a.c
                      cc -c a.c
              b.o: incl.h b.c
                      cc -c b.c

       Command lines are executed one at a time, each by its  own  shell.  The
       SHELL  environment  variable  can  be  used to specify which shell make
       should use to execute commands. The default is /usr/bin/sh.  The  first
       one  or  two  characters  in  a command can be the following: `@', `-',
       `@-', or `-@'. If `@' is present,  printing  of  the  command  is  sup-
       pressed.  If  `-' is present, make ignores an error.  A line is printed
       when it is executed unless the -s  option  is  present,  or  the  entry
       .SILENT:  is  included  in  makefile,  or  unless the initial character
       sequence contains a @. The -n option specifies printing without  execu-
       tion;  however,  if  the command line has the string $(MAKE) in it, the
       line is always executed (see the discussion of the MAKEFLAGS  macro  in
       the  make Environment sub-section below). The -t (touch) option updates
       the modified date of a file without executing any commands.

       Commands returning non-zero status normally terminate make. If  the  -i
       option is present, if the entry .IGNORE: is included in makefile, or if
       the initial character sequence of the command contains `-',  the  error
       is  ignored. If the -k option is present, work is abandoned on the cur-
       rent entry, but continues on other branches that do not depend on  that

       Interrupt  and quit cause the target to be deleted unless the target is
       a dependent of the directive .PRECIOUS.

   make Environment
       The environment is read by make. All variables are assumed to be  macro
       definitions  and  are  processed as such. The environment variables are
       processed before any makefile and after the internal rules; thus, macro
       assignments in a makefile override environment variables. The -e option
       causes the environment to override the macro assignments in a makefile.
       Suffixes  and  their associated rules in the makefile will override any
       identical suffixes in the built-in rules.

       The MAKEFLAGS environment variable is processed by make  as  containing
       any legal input option (except -f and -p) defined for the command line.
       Further, upon invocation, make "invents" the variable if it is  not  in
       the  environment, puts the current options into it, and passes it on to
       invocations of commands. Thus, MAKEFLAGS always  contains  the  current
       input  options.  This feature proves very useful for "super-makes".  In
       fact, as noted above, when the -n option is used, the  command  $(MAKE)
       is  executed  anyway; hence, one can perform a make -n recursively on a
       whole software system to see what would have been executed. This result
       is  possible  because  the -n is put in MAKEFLAGS and passed to further
       invocations of $(MAKE). This usage is one way of debugging all  of  the
       makefiles for a software project without actually doing anything.

   Include Files
       If the string include appears as the first seven letters of a line in a
       makefile, and is followed by a blank or a tab, the rest of the line  is
       assumed  to  be a filename and will be read by  the current invocation,
       after substituting for any macros.

       Entries of the form string1 = string2 are macro definitions. string2 is
       defined  as  all  characters  up to a comment character or an unescaped
       NEWLINE. Subsequent  appearances  of  $(string1[:subst1=[subst2]])  are
       replaced by string2. The parentheses are optional if a single-character
       macro name is used and there is no substitute  sequence.  The  optional
       :subst1=subst2  is a substitute sequence.  If it is specified, all non-
       overlapping occurrences of subst1 in the named macro  are  replaced  by
       subst2.   Strings  (for  the purposes of this type of substitution) are
       delimited by BLANKs, TABs, NEWLINE characters, and beginnings of lines.
       An  example  of  the  use  of  the  substitute sequence is shown in the
       Libraries sub-section below.

   Internal Macros
       There are five internally maintained macros that are useful for writing
       rules for building targets.

       $*       The  macro  $*  stands  for  the  filename part of the current
                dependent with the suffix deleted.  It is evaluated  only  for
                inference rules.

       $@       The  $@  macro  stands for the full target name of the current
                target.  It is evaluated only for explicitly  named  dependen-

       $<&lt;       The  $<&lt;  macro  is  only  evaluated for inference rules or the
                .DEFAULT rule. It is the module that is outdated with  respect
                to  the target (the "manufactured" dependent file name). Thus,
                in the .c.o rule, the $<&lt; macro would evaluate to the .c  file.
                An example for making optimized .o files from .c files is:

                        cc -c -O $*.c


                        cc -c -O $<

       $?       The  $?  macro is evaluated when explicit rules from the make-
                file are evaluated. It is the list of prerequisites  that  are
                outdated  with  respect  to  the target, and essentially those
                modules that must be rebuilt.

       $%       The $% macro is only evaluated when the target is  an  archive
                library member of the form lib(file.o). In this case, $@ eval-
                uates to lib and $% evaluates to the library member, file.o.

       Four of the five macros can have alternative forms. When an upper  case
       D or F is appended to any of the four macros, the meaning is changed to
       "directory part" for D and "file part" for F.  Thus,  $(@D)  refers  to
       the  directory part of the string $@. If there is no directory part, ./
       is generated.  The only macro excluded from this  alternative  form  is

       Certain  names (for instance, those ending with .o) have inferable pre-
       requisites such as .c, .s, etc. If no update commands for such  a  file
       appear  in makefile, and if an inferable prerequisite exists, that pre-
       requisite is compiled to make the target. In this case, make has infer-
       ence  rules that allow building files from other files by examining the
       suffixes and determining an appropriate inference rule to use. The cur-
       rent default inference rules are:

       tab();    lw(0.550000i)   lw(0.550000i)   lw(0.550000i)   lw(0.550000i)
       lw(0.550000i) lw(0.550000i) lw(0.550000i)  lw(0.550000i)  lw(0.550000i)
       lw(0.550000i).                              .c.c~.f.f~.s.s~.sh.sh~.C.C~
       .C~.C.C~.o.L.C.L.o.L~.C.L~.L.L~.o.Y.C.Y.o.Y~.C .Y~.o.Y~.Y

       The internal rules for make are contained in the source file make.rules
       for the make program. These rules can be locally modified. To print out
       the  rules compiled into the make on any machine in a form suitable for
       recompilation, the following command is used:

              make -pf - 2>/dev/null </dev/null

       A tilde in the above rules refers to an SCCS  file  (see  sccsfile(4)).
       Thus,  the  rule  .c~.o  would  transform an SCCS C source file into an
       object file (.o). Because the s. of the SCCS files is a prefix,  it  is
       incompatible  with the make suffix point of view. Hence, the tilde is a
       way of changing any file reference into an SCCS file reference.

       A rule with only one suffix (for example, .c:) is the definition of how
       to build x from x.c. In effect, the other suffix is null.  This feature
       is useful for building targets from only one source file, for  example,
       shell procedures and simple C programs.

       Additional  suffixes  are  given  as the dependency list for .SUFFIXES.
       Order is significant: the first possible name for which both a file and
       a rule exist is inferred as a prerequisite. The default list is:

       .SUFFIXES: .o .c .c~ .y .y~ .l .l~ .s .s~ .sh .sh~ .h .h~ .f .f~ .C .C~
       .Y .Y~ .L .L~

       Here again, the above command for printing the internal rules will dis-
       play  the list of suffixes implemented on the current machine. Multiple
       suffix lists accumulate; .SUFFIXES: with  no  dependencies  clears  the
       list of suffixes.

   Inference Rules
       The first example can be done more briefly.

              pgm: a.o b.o
                      cc a.o b.o -o pgm
              a.o b.o: incl.h

       This  abbreviation is possible because make has a set of internal rules
       for building files. The user may add  rules  to  this  list  by  simply
       putting them in the makefile.

       Certain  macros  are  used by the default inference rules to permit the
       inclusion of optional matter in any resulting  commands.  For  example,
       CFLAGS,  LFLAGS,  and  YFLAGS  are used for compiler options to cc(1B).
       Again, the previous method for examining the current  rules  is  recom-

       The  inference of prerequisites can be controlled. The rule to create a
       file with suffix .o from a file with suffix .c is specified as an entry
       with  .c.o:  as the target and no dependents. Shell commands associated
       with the target define the rule for making a .o file from  a  .c  file.
       Any  target  that has no slashes in it and starts with a dot is identi-
       fied as a rule and not a true target.

       If a target or dependency name contains parentheses, it is  assumed  to
       be  an  archive  library,  the string within parentheses referring to a
       member within the library. Thus, lib(file.o)  and  $(LIB)(file.o)  both
       refer to an archive library that contains file.o. (This example assumes
       the  LIB  macro  has  been   previously   defined.)    The   expression
       $(LIB)(file1.o  file2.o)  is  not  legal.  Rules  pertaining to archive
       libraries have the form .XX.a where the XX  is the  suffix  from  which
       the archive member is to be made. An unfortunate by-product of the cur-
       rent implementation requires the XX to be different from the suffix  of
       the  archive  member.  Thus,  one  cannot  have lib(file.o) depend upon
       file.o explicitly. The most common use of the  archive  interface  fol-
       lows. Here, we assume the source files are all C type source:

              lib: lib(file1.o) lib(file2.o) lib(file3.o)
                   @echo lib is now up-to-date
                      $(CC) -c $(CFLAGS) $<
                   $(AR) $(ARFLAGS) $@ $*.o
                      rm -f $*.o

       In  fact, the .c.a rule listed above is built into make and is unneces-
       sary in this example. A more interesting, but more limited  example  of
       an archive library maintenance construction follows:

              lib: lib(file1.o) lib(file2.o) lib(file3.o)
                      $(CC) -c $(CFLAGS) $(?:.o=.c)
                   $(AR) $(ARFLAGS) lib $?
                   rm $?
                   @echo lib is now up-to-date

       Here the substitution mode of the macro expansions is used. The $? list
       is defined to be the set of  object  filenames  (inside  lib)  whose  C
       source  files  are outdated. The substitution mode translates the .o to
       .c. (Unfortunately, one cannot as yet transform to .c~;  however,  this
       transformation  may become possible in the future.)  Also note the dis-
       abling of the .c.a: rule, which would have created  each  object  file,
       one by one. This particular construct speeds up archive library mainte-
       nance considerably.  This type of construct becomes very cumbersome  if
       the archive library contains a mix of assembly programs and C programs.

       USE_SVR4_MAKE   If this environment variable is set, then the make com-
                       mand will invoke this System V  version  of   make.  If
                       this  variable  is not set, then the default version of
                       make(1S) is invoked.

                       USE_SVR4_MAKE can be set as follows (Bourne shell):

                       $ USE_SVR4_MAKE=``''; export USE_SVR4_MAKE

                       or (C shell):

                       % setenv USE_SVR4_MAKE

       [Mm]akefile                             default makefiles

       /usr/bin/sh                             default shell for make

       /usr/share/lib/make/make.rules          default rules for make

       See attributes(5) for descriptions of the following attributes:

       tab()    allbox;    cw(2.750000i)|     cw(2.750000i)     lw(2.750000i)|
       lw(2.750000i).  ATTRIBUTE TYPEATTRIBUTE VALUE AvailabilitySUNWsprot

       cc(1B), cd(1), make(1S), sh(1), printf(3C), sccsfile(4), attributes(5)

       Some commands return non-zero status inappropriately; use -i or the `-'
       command line prefix to overcome the difficulty.

       Filenames containing the characters `=', `:', and `@'  will  not  work.
       Commands  that  are  directly executed by the shell, notably cd(1), are
       ineffectual across NEWLINEs in make.  The  syntax  lib(file1.o  file2.o
       file3.o) is illegal. You cannot build lib(file.o) from file.o.

SunOS 5.10                        1 Nov 1999                      sysV-make(1)