1 MAKE
    MAKE is a program maintenance utility which automates the process
    of maintaining  high-level-language programs.  MAKE automatically
    carries out all of the tasks needed to update a program after one
    or more of its source files have been changed.

    Unlike command files, MAKE compares the last modification date of
    the files or  files that may need  updating with the modification
    dates of  files on which  these  target files  depend.  MAKE then
    carries out the given task only if a target file is  out of date.
    MAKE does not  compile and link all files  just because  one file
    has been updated.  This can save time when creating programs that
    have many source files or take several steps to complete.
2 Using_MAKE
    To use MAKE, you must create a MAKE description file that defines
    the tasks you wish to accomplish and specifies the files on which
    these tasks depend. Once the description file exists, invoke MAKE
    and  supply the file name as a  parameter.  MAKE then  reads  the
    contents of the file and performs the requested tasks.
3 Creating_a_MAKE_Description_File
    A MAKE  desription file consists  of one or more target/dependent
    descriptions. Each description has the following general form:

        <targetfile>:<dependentfiles> {#comment}
        {# comment}
            <command> {# comment}
            {<command> {# comment}}
            .
            .
            .

    In  this format, <targetfile> is the name of a file that may need
    updating,  <dependentfiles> are  the  names of any files on which
    the  target file depends,  and <command> is any  command which is
    valid in the context of your current process.

    The <targetfile> and <dependentfiles> must be valid file names. A
    device and directory specification  must be provided for any file
    that  is not on the same  device and  directory  as your  current
    default. If <targetfile> does not exist,  it is assumed to be out
    of date.

    Any  number of dependent files  may be given, but only one target
    name is  allowed.  Dependent-file  names  must be  separated by a
    comma. If you have more dependent files than can fit on one line,
    you can  continue the names on the next line by placing a hyphen,
    (-),  as the last character on the line.  Comments must be placed
    AFTER the continuation character because MAKE discards everything
    on a line beginning at the comment  character (#) before the line
    is analyzed.

    The <command> can be any command which is valid in the context of
    your current process. The only exception to this is modifications
    to  your  process  DCL  tables   that  are  made  by   using  the
    "SET COMMAND/TABLES"  command.  Any  number  of  commands  may be
    given,  but each must begin on a new line and must be preceded by
    a TAB,  or at least  one space.  Commands may span  more than one
    line by using the hyphen as described above. Commands are carried
    out only if one or more of the dependent files has been  modified
    since the target file was  created or if the target file does not
    exist.

    The  MAKE description file format is like an  "if-then" statement
    in  the following  format:  IF the  <targetfile> is older  than a
    <dependentfile>,  or the  <targetfile> does  not  exist,  THEN do
    <commands>.

    You  can give  any number of  target/dependent  descriptions in a
    description file. You must make sure, however, that the last line
    in one  description is separated from the first line  of the next
    description by at least one blank line.

    The number sign (#) is a comment character. All characters on the
    same  line that  follow the  comment character are ignored.  When
    comments  appear  in  a  <command>  lines  section,  the  comment
    character (#) must be the first character on the line (no leading
    white  space).  On any other lines,  the  comment  character  can
    appear anywhere.

    Note:   The  order  in  which  you  place  the   target/dependent
            descriptions is importent. MAKE examines each description
            in  turn and makes its decision to carry out a given task
            based on  the  file's  current  modification  date.  If a
            command in a later description modifies a file,  MAKE has
            no way to return to the description in which that file is
            a target.
3 Examples
    STARTUP.OBJ:STARTUP.FOR
        $ FORTRAN STARTUP

    PRINT.OBJ:PRINT.FOR #Comment allowed after dependent
    #Comment before command must start in first column
        FORTRAN/NOLIST PRINT #Comment allowed after command

    PRINT.EXE: STARTUP.OBJ,PRINT.OBJ
        $ LINK/NOMAP PRINT,-#Comment allowed after the continuation
                     STARTUP

    This  example  defines  the  actions to be carried  out to create
    three target files. Each file has at least one dependent file and
    one command.  The target  descriptions are  given in the order in
    which  the target  files  will be  created.  Thus STARTUP.OBJ and
    PRINT.OBJ  are   examined  and   created,  if  necessary,  before
    PRINT.EXE

    Note  that  a  comment  can  appear  on  the  same  line  as  the
    target/dependent  description line and the command line. However,
    when  the  comment  appears  on  a  separate  line,  the  comment
    character  (#)  must the first  character on the line.  Also note
    that  the comment  character (#)  appears after  the continuation
    character (-).
3 Using_Macro_Defintions
    Macro  definitions  let  you  associate  a symbolic name with a
    particular  value.  By using macro definitions,  you can change
    values  used in  the  description  file  without having to edit
    every line that uses a particular value.

    The form of a macro definition is:

        <name>=<value>

    The form for using a previously defined macro definition is:

        $(<name>)

    Occurences of the pattern $(<name>) in the description file are
    replaced with the specified <value>. The <name> is converted to
    uppercase;  flags and FLAGS are  equivalent.  If you  define  a
    macro  name but leave the <value> blank,  the <value> will be a
    null string.

    Macro definitions can be placed in the MAKE description file or
    given on the  MAKE command line  (via the  /MACROS= qualifier).
    A <name> is also considered  defined if it has a  definition in
    the current symbol tables. The search order is to first look in
    MAKE's internal tables, then check the local symbol table, then
    check the global symbol table. If <name> is not found in any of
    the above tables then the string "$(<name>)" is replaced with a
    null string ("").
2 Starting_MAKE
    MAKE must be started with a command line. You cannot use prompts.
    The MAKE command line has the following form:

        $ MAKE :==$SYS$UAB:MAKE.EXE  ! define the global symbol MAKE.
        $ MAKE {<filename>}          ! invoke SYS$UAB:MAKE.EXE

    where  <filename>  is  the  name of  a  MAKE  description   file.
    <filename> is an optional  parameter.  If <filename> is not given
    then MAKE tries to open MAKEFILE.; in your default directory.
3 Parameter
    <filename> is the only parameter accepted by MAKE. MAKE expects
    <filename> not  to have a type field so these  two commands are
    equivalent.

        $ MAKE FOO

        $ MAKE FOO.;

    <filename> can have a type field, but it is not required.
3 Qualifiers
/ECHO
 /NOECHO

    This qualifier causes MAKE to echo the commands which are being
    executed. /NOECHO specifies that MAKE should not display the
    commands that are executed. /ECHO is the default.

/MACROS=(<macrodef>){,(<macrodef),...}

    This qualifier causes  MAKE to override macro definitons in the
    description file. If this qualifier is used then it must be the
    last  item  on  the  command  line.  If  more  than  one  macro
    definition is specified then each defintion must be enclosed in
    parenthises. <macrodef> has the same form as a macro definition
    in the description file, e.g. <name>=<value>.
