QBasic & Borland Pascal & C/Delphi5.iso/C/Samples/CM100TXT.ARJ/CM100TXT.ZIP/CMAKE.TXT

Text File | 1991-11-17 | 316.7 KB | 9,224 lines

                          CMAKE 1.00 MANUAL


─────CMAKE 1.00 Contents────────────────────────────────────────────────────

     Introduction                     Samples

     Getting Started                  Errors

     The Command Line

     The Make File

     The Configuration File

     Using CMAKE with Your Editor

     Optimizing Performance

     Exit Codes

     Technical Support                Copyright and Trademarks

─────Introduction to CMAKE──────────────────────────────────────────────────

     CMAKE is a program maintenance utility designed especially for the
     Microsoft(R) C and Microsoft Windows(TM) programmer.  CMAKE is
     like a generic make facility in that it processes a make file in
     order to determine which commands need to be executed to renew a
     given program that is under development.  However, the make file
     for CMAKE is much simpler than that of a generic make utility.
     For most cases, user-supplied dependencies are not required.
     CMAKE will automatically determine which commands are required by
     deducing all dependencies directly from the commands themselves.

     Despite the fact that CMAKE must determine all dependencies for
     you, CMAKE executes faster than most generic make utilities
     running on a make file in which all dependencies have been
     explicitly specified.

     CMAKE currently supports the following commands: CL, LIB, LINK,
     MASM, RC, COPY, SET and REM.  The user may expand this list by
     defining additional commands in the CMAKE configuration file.

     CMAKE is a shareware program, written and maintained by John
     Greschak.  To become a registered user of CMAKE, send $25 to:

          John Greschak
          50 West 34th St. Apt. 14B8
          NY, NY 10001

     CMAKE was designed to run under MS-DOS(R).

─────Getting Started with CMAKE─────────────────────────────────────────────

     Creating a Make File

     Running CMAKE

     Interpreting the Output of CMAKE

     Error Messages

     How CMAKE Works

─────Creating a Make File for CMAKE─────────────────────────────────────────

     Study the samples that have been included with CMAKE.  Hopefully,
     one of these sample programs may serve as a template for your make
     file.

     See: Samples

     If you stray from the style of the samples, you might have some
     difficulty because CMAKE does not recognize all possible command-
     line formats for each command.  For example, CMAKE requires that
     you use a response file with the commands, LIB and LINK.  To
     guarantee success, you should become familiar with the
     restrictions that CMAKE imposes on the commands that you will be
     using in your make files.

     See: Command-Line Restrictions

          CL
          COPY
          LIB
          LINK
          MASM
          RC/A
          RC/C
          RC/W

─────Running CMAKE──────────────────────────────────────────────────────────

     Once you have created a make file, you will be ready to execute
     CMAKE.  To do this, enter the command:

     CMAKE /n make_file_name

     Alternatively, if your make file is named "makefile" and you
     are in your make-file's directory, you may omit the make-file
     name and enter the command:

     CMAKE /n

     The /n option will prevent CMAKE from executing any commands
     from the make file.  You should continue to use the /n option
     until CMAKE does not generate any error messages.

     See: Error Messages

     Once you have eliminated all CMAKE error messages, remove the /n
     option and execute CMAKE again.  This time CMAKE will execute all
     of the commands that are necessary to update your application.

     See: Interpreting the Output of CMAKE

     At this point, you should perform some simple tests to ensure that
     CMAKE will generate the correct list of required commands when you
     modify one of your source files.  (There are utility programs
     available that may be used to modify the time stamp of a given
     file.  A program such as this, which is usually called "touch",
     provides an efficient way to modify your source files.)  Modify
     one of your source files, execute CMAKE, and check to be sure that
     your application has been properly updated.  Repeat this process
     for different source files.

     If you are having difficulty in understanding why CMAKE is not
     updating your application properly, you might gain more insight
     into the cause of the problem by adding the /v option to the
     CMAKE command line.  For example, you could use the command:

     CMAKE /n /v make_file_name

     The use of the /v option will cause CMAKE to generate a verbose
     description of its activity.  This description contains detailed
     information concerning the processing of the make file and the
     configuration file (if you are using one).  With the /v option,
     CMAKE will list all of the time stamp comparisons that it performs
     in route to determining which commands in the make file are
     required.

     While you are debugging your make file, you might find it helpful
     to review the batch program, "makefile.bat", that CMAKE creates
     and executes.  (Note that when the /n option is used,
     "makefile.bat" is created but not executed.)

     Finally, you may wish to collect the output of CMAKE in a file and
     then review that file in you editor.  To do this, you may use the
     MS-DOS redirection character, '>'.  For example, the following
     command could be used to redirect the output of CMAKE to the file,
     "cmake.log":

     CMAKE >cmake.log

     See: Using CMAKE with Your Editor

─────Interpreting the Output of CMAKE───────────────────────────────────────

     As CMAKE processes a given make file, it sends information
     concerning its activity to standard output.  CMAKE supports both
     a concise and verbose format for this output.  The default format
     is concise.  The verbose format may be requested through the use
     of the /v CMAKE command-line option.  This topic describes the
     data that is contained in the concise/default format for CMAKE
     output.

     The first two lines of output give the current date and time, the
     CMAKE version number, and the copyright notice for CMAKE.

     The next line has the form:

     make_file_name >-CMAKE-> batch_file_name

     where make_file_name is the name of the make file (input file)
     that CMAKE is processing and batch_file_name is the full name of
     the batch program (output file), "makefile.bat", that CMAKE
     creates and executes after processing the given make file.

     This is followed by a list of all of the commands in the make file
     that must be executed.  Each line of this list has the following
     form:

     command_name make_file_line_number reason_why_command_is_required

     For example, the list might consist of the following four lines:

     cl           2  INC w.h > OBJ x.obj
     lib         41  OBJ x.obj > LIB y.lib
     link        51  LIB y.lib > EXE z.exe

     The first line shows that the CL command on line 2 of the make
     file is required because the include file, "w.h", is newer than
     the object file, "x.obj".  The second line shows that the LIB
     command on line 41 of the make file is required because the object
     file, "x.obj" is newer than the library file, "y.lib".  Finally,
     the third line of the list indicates that the LINK command on line
     51 of the make file is required because the library file, "y.lib"
     is newer than the executable file, "z.exe".

     This list is followed by a line that gives the amount of time used
     by CMAKE to create the batch program, "makefile.bat".

     A line is drawn after the execution time to separate the output of
     CMAKE from the output of the commands that CMAKE executes.

     One of the following messages is provided at the end of the output
     that is generated:

     ALL TARGETS ARE UP TO DATE

     This message indicates that CMAKE has determined that none of the
     commands in the make file need to be executed.

     ALL TARGETS WERE SUCCESSFULLY RENEWED

     This message indicates that CMAKE has determined that some of the
     commands in the make file were required and that all of these
     required commands were executed and returned zero (indicating
     success).

     FAILURE - SOME TARGETS WERE NOT RENEWED

     This indicates that some commands in the make file were required
     and executed.  However, one of the commands returned a nonzero
     value (indicating an error).  In this case, all of the required
     commands that follow the command that failed are not executed and
     CMAKE returns a nonzero value.

─────CMAKE Error Messages───────────────────────────────────────────────────

     The following two formats are used for CMAKE error messages:

     fatal error Mnnnn: message
     file_name(line_number) : error Mnnnn: message

     Most of the error messages use the second format.  Many popular
     programmer's editors (e.g. BRIEF(R), Epsilon(TM), and the
     Microsoft Editor) are able to parse error messages in this form
     in order to place you in <file_name> at line 'line_number'.

     See: Using CMAKE with Your Editor
          CMAKE Errors

─────How CMAKE Works────────────────────────────────────────────────────────

     While CMAKE processes a given make file, it builds a batch program
     called, "makefile.bat".  When it is completed, "makefile.bat"
     consists of all of the commands from the make file that were
     determined (by CMAKE) to be "required".  After the make file has
     been fully processed, CMAKE executes "makefile.bat".

     CMAKE views a command in the make file as an entity that uses
     source files to create target files.  Generally speaking, a
     command will be required when one of the following conditions is
     true:

     1. At least one of the target files for the command does not
        exist.
     2. There is some source file for the command that is newer than
        some target file for the command.

     A command that is determined to be required, is appended to the
     batch program "makefile.bat".  Note that a required command will
     not be executed until CMAKE has processed the entire make file.

     It is often the case that the target file of a given command will
     serve as a source file for another command that occurs later in
     the make file.  For example, the target file of a CL command is an
     object file.  Usually, this object file will serve as a source
     file for a LINK command that occurs after the CL command in the
     make file.  If the CL command is required, then the LINK command
     that depends upon the object generated by the CL command, should
     also be required.  This overlapping of the target files of one
     command with the source files of another command causes a "chain
     reaction" of required commands.

     Since the required commands are not executed as they are found,
     but accumulated into the file, "makefile.bat" (for later use),
     CMAKE must keep track of all of the target files of each required
     command to ensure that the correct "chain reactions" occur.  In
     some sense, CMAKE simulates the execution of each required
     command.  It does this by creating a fresh "pseudofile" for every
     target file of a required command.  Whenever CMAKE attempts to
     find the time stamp of a particular file, it first searches the
     set of pseudofiles.  If the given file is not found among the
     pseudofiles, then CMAKE searches for the real/original version of
     the file.

─────The CMAKE Command Line─────────────────────────────────────────────────

     Syntax

     CMAKE [Options]

     Options

     /?        Displays Command-Line Help
     /a        Displays Information about CMAKE
     /help     Displays Help on CMAKE
     /n        Suppresses Command Execution
     /o        Specifies the Path of "makefile.bat"
     /v        Select Verbose Diagnostic Output
     filename  Specifies the Make-File Name

     Example

     CMAKE /v /n /oc:\test c:\test\test.mak

─────Examples───────────────────────────────────────────────────────────────

     CMAKE

     This command will cause CMAKE to attempt to process a make file
     called, "makefile".  CMAKE will assume that "makefile" is located
     in the current directory.  A batch program called, "makefile.bat",
     will be created in the current directory and CMAKE will execute
     this program (provided the statement, "run_output_file = no", has
     not been given in the CMAKE configuration file).  CMAKE will
     use its concise output format to display information as it
     processes the make file.

     CMAKE /od:\temp

     This command will cause CMAKE to attempt to process a make file
     called, "makefile".  CMAKE will assume that "makefile" is located
     in the current directory.  A batch program called, "makefile.bat",
     will be created in the directory, "d:\temp", which has been
     supplied with the /o option.  This program will be executed
     (provided the statement, "run_output_file = no", has not been
     given in the CMAKE configuration file).  CMAKE will use its
     concise output format to display information as it processes the
     make file.

     CMAKE /n /v >d:\temp\cmake.log

     This command will cause CMAKE to attempt to process a make file
     called, "makefile".  CMAKE will assume that "makefile" is located
     in the current directory.  A batch program called, "makefile.bat",
     will be created in the current directory.  Since the /n has been
     specified, CMAKE will not execute "makefile.bat".  Since the /v
     has been specified, CMAKE will use its verbose output format to
     display information as it processes the make file.  The output
     from CMAKE will be directed to the file, "d:\temp\cmake.log".
     The combination of options given in this example might be used to
     debug a make file.

     CMAKE c:\mak\test.mak

     This command will cause CMAKE to attempt to process a make file
     called, "c:\mak\test.mak".  A batch program called,
     "makefile.bat", will be created in the current directory and CMAKE
     will execute this program (provided the statement,
     "run_output_file = no", has not been given in the CMAKE
     configuration file).  CMAKE will use its concise output format to
     display information as it processes the make file.

─────CMAKE Options──────────────────────────────────────────────────────────

     Command-line options may be given in upper or lowercase.

     With the exception of the make-file name, options must be prefixed
     by a '/' or '-' character.

─────Display Command-Line Help for CMAKE (/?)───────────────────────────────

     Syntax:  /?

     The /? option is used to display command-line help.

─────Display Information about CMAKE (/a)───────────────────────────────────

     Syntax:  /a

     The /a option is used to display information on how to contact the
     author of CMAKE and on how to become a registered user of CMAKE.

─────Display Help on CMAKE (/help)──────────────────────────────────────────

     Syntax:  /help or /h

     The /help option is used to display the CMAKE help file you are
     reading.  If you would like to use this option, place the
     QuickHelp program, QH.EXE, in your current directory or PATH.

─────Suppress Command Execution by CMAKE (/n)───────────────────────────────

     Syntax:  /n

     The /n option suppresses the execution of commands.  This switch
     takes precedence over the Boolean variable, run_output_file, which
     may be used in the configuration file.  With this switch, the
     batch program, "makefile.bat", is created but not executed.  You
     might wish to use this option to help you debug your make file.

─────Specify the Path of "makefile.bat" (/o)────────────────────────────────

     Syntax:  /o

     The /o option is used to specify the path of "makefile.bat" (the
     batch program that CMAKE creates and executes).  When the /o
     option is omitted, "makefile.bat" is placed in the current
     directory.

─────Select Verbose Diagnostic Output from CMAKE (/v)───────────────────────

     Syntax:  /v

     The /v option is used to request the verbose format for CMAKE
     output.  When this option is used, CMAKE provides detailed
     information concerning the processing of the configuration file
     and make file.  You might wish to use this option to help you
     debug your make file.

─────Specify the Make-File Name (filename)──────────────────────────────────

     Syntax:  filename

     The filename option is used to specify the make-file name.  If
     this option is omitted, CMAKE assumes that the make file is
     called, "makefile", and is located in the current directory.

─────The Make File for CMAKE────────────────────────────────────────────────

     Description

     Commands

          Intrinsic Commands

               CL    LIB   MASM  REM
               COPY  LINK  RC    SET

          User-Defined Commands

          Equivalent Commands

          Unrecognized Commands

     The if Statement

     Comments

─────Description of the Make File───────────────────────────────────────────

     A make file lists the operations that are required to build a
     particular program.

     CMAKE processes a given make file to determine which commands must
     be executed in order to update a program that is under
     development.

     A make file for CMAKE consists of a mixture of commands, if
     statements, and comments.

─────Example────────────────────────────────────────────────────────────────

     /* Make File */

     cl /c /W4 hello.c
     cl /c /W4 world.c
     lib @message.lrf
     cl /c /W4 greeting.c
     link @greeting.lnk

     In the sample make file given above, "message.lrf" is a LIB
     response file that consists of the following lines:

     message.lib
     y
     -+hello.obj &
     -+world.obj ;

     and "greeting.lnk" is a LINK response file that consists of the
     following lines:

     greeting.obj
     greeting.exe /stack:2048
     NUL
     message.lib ;

─────Make-File Commands─────────────────────────────────────────────────────

     Make file commands may be divided into the following four classes:

          Intrinsic Commands
          User-Defined Commands
          Equivalent Commands
          Unrecognized Commands

     The method that CMAKE uses to determine if a given command is
     required is dictated by the class of the command.

─────Intrinsic Commands─────────────────────────────────────────────────────

     A make-file command is said to be "intrinsic" if CMAKE has some
     "built-in" knowledge of the how to determine whether or not the
     command is required.

     The intrinsic commands are: CL, LIB, LINK, MASM, RC, COPY, SET,
     and REM.

─────CL─────────────────────────────────────────────────────────────────────

     Description

     When is a CL Command Required?

     The CL Command Line

     How CMAKE Processes a C-Source File

     Switches

     Some Restrictions

     Error Handling

     Output from CMAKE

     Verbose Output from CMAKE

─────Description of CL──────────────────────────────────────────────────────

     CL is a program that is distributed with the Microsoft C
     Optimizing Compiler.  It provides a command-line interface to the
     compiler programs.

─────When is a CL Command Required?─────────────────────────────────────────

     A given CL command will be required if any of the following
     conditions is true:

     1. The object file does not exist.
     2. The source file is newer than the object file.
     3. There is an include file that is newer than the object file.

     These conditions are checked in order.  If any condition is found
     to be true, the remaining conditions are not checked.

─────The CL Command Line────────────────────────────────────────────────────

     Source-File Name

     Only one source-file name may be specified.  No global characters
     are allowed in the given source-file name.  The source-file name
     must be placed at the end of the command line.  No default
     extension is assumed for the source file.  If a path is not
     specified, it is assumed that the source file is located in the
     current directory.

     Object-File Name

     The base name of the object file is assumed to be the same as the
     base name of the source file and the object-file extension is
     assumed to be '.obj'.  The /Fo (or equivalently, -Fo) option may
     be used to specify the path of the object file.  If the /Fo option
     is used, the path that is given with this option must be
     terminated with a backslash.  If the /Fo option is not used, it is
     assumed that the object file is located in the current directory.

     Options

     Options may appear anywhere between the CL command name and the
     source-file name.  The /c option (compile but do not link) must be
     used.

─────Examples───────────────────────────────────────────────────────────────

     command:     cl /c /W3 test.c
     source file: current_directory\test.c
     object file: current_directory\test.obj

     command:     cl /c /W3 /Fo..\obj\ ..\c\test.c
     source file: ..\c\test.c
     object file: ..\obj\test.obj

─────How CMAKE Processes a C-Source File────────────────────────────────────

     When the object file of a CL command exists, and it is newer than
     the source file, CMAKE will process the C-source file in order to
     determine whether or not there is an include file that is newer
     than the object file.  CMAKE will extract include-file names from
     the include statements that are given in the C-source file.

     CMAKE recognizes two forms of the include statement: local and
     system.

     Local-Include Statements

     The term "local-include statement" is used to refer to an include
     statement that has the form:

          #include "filename"

     and the file associated with such an include statement is said to
     be a "local-include file".

     System-Include Statements

     The term "system-include statement" is used to refer to an include
     statement that has the form:

          #include <filename>

     and the file associated with such an include statement is said to
     be a "system-include file".

     Sensitivity to Local- and System-Include Statements

     The "sensitivity to local-include statements" and the "sensitivity
     to system-include statements" may be thought of as Boolean state
     variables for CMAKE.  If the sensitivity to local-include
     statements is "on", and CMAKE encounters a local-include
     statement, CMAKE will check to see if the include file associated
     with the include statement is newer than the object file.
     Otherwise, if the sensitivity to local-include statements is
     "off", CMAKE will ignore the local-include statement.  Likewise,
     if the sensitivity to system-include statements is "on", and CMAKE
     encounters a system-include statement, CMAKE will check to see if
     the include file associated with the include statement is newer
     than the object file.  Otherwise, if the sensitivity to system-
     include statements is "off", CMAKE will ignore the system-include
     statement.

     By default, the sensitivity to local-include statements is "on",
     and the sensitivity to system-include statements is "off".

     The sensitivity to local-include statements and the sensitivity
     to system-include statements may be altered through the use of a
     variety of switches.

     For each source file, CMAKE uses the Boolean variables,
     c_include_""_on and c_include_<>_on, to initialize the sensitivity
     to local- and system-include statements, respectively.

     Within a given C-source file, any of the following C comments may
     be used to modify the sensitivity to local- or system-include
     statements:

     /* CMAKE - INCLUDE "" OFF */
     /* CMAKE - INCLUDE "" ON */
     /* CMAKE - INCLUDE <> OFF */
     /* CMAKE - INCLUDE <> ON */

     Locating Include Files

     If CMAKE does obtain an include-file name from an include
     statement, it will attempt to determine the directory in which
     the file is located.  If the file is a local-include file, CMAKE
     will look for the file in the directory in which the source file
     for the given CL command is located.  If the include file is not
     found in the source-file's directory, CMAKE will search the
     directories specified by the INCLUDE environment variable (if it
     is defined), one by one, from left to right.  On the other hand,
     if the file is a system-include file, CMAKE will only look for the
     file in the directories given by the INCLUDE environment variable.

     To prevent CMAKE from searching for local-include files in the
     source-file's directory, use the following statement in the
     configuration file:

     search_source_dir_for_includes = no

     Scanning Include Files for Include Statements

     By default, CMAKE does not scan include files for include
     statements.  To force CMAKE to scan include files for include
     statements, place the following statement in your configuration
     file:

     scan_include_files_for_includes = yes

     Alternatively, you may place the following commands anywhere
     within your make file (except within the body of an if statement)
     to achieve a "local" effect:

     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES ON
     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES OFF

     When a REM statement of this type is used, all of the CL commands
     that follow the statement will be affected.

     The End-of-Includes Comment

     If CMAKE encounters the comment:

     /* CMAKE - INCLUDE END */

     while scanning a C-source file, it will stop processing the file,
     i.e. CMAKE will not read any lines in the source file that occur
     after this comment.

     Although it is not required, you should place this comment after
     the last include statement in any C-source files that will be
     scanned by CMAKE.  If you do this, you will reduce the amount of
     time that CMAKE takes to execute.

     The Procedure Used to Examine a C-Source File

     For a given CL command, CMAKE uses the following process to
     scan the C-source file in order to determine whether or not there
     is an include file that is newer than the object file:

     A. Initialize the sensitivity to local-include statements
        and system-include statements.

     B. Read a line from the source file.

     C. If we are at the end of the source file

           Go to step G - there are no include files in this source
           file that are newer than the object file.

     D. Skip leading white space on the line.

     E. If the line begins with the comment
                /* CMAKE - INCLUDE "" ON */

                Enable the sensitivity to local-include statements.

        Else if the line begins with the comment
                /* CMAKE - INCLUDE "" OFF */

                Disable the sensitivity to local-include statements.

        Else if the line begins with the comment
                /* CMAKE - INCLUDE <> ON */

                Enable the sensitivity to system-include statements.

        Else if the line begins with the comment
                /* CMAKE - INCLUDE <> OFF */

                Disable the sensitivity to system-include statements.

        Else if the line begins with the comment
                /* CMAKE - INCLUDE END */

                Go to step G - there are no include files in this
                source file that are newer than the object file.

        Else if the line begins with the character, '#'

                1. Skip white space following the '#' character.

                2. If the next token is 'include'

                      a. Skip white space following the 'include'
                         token.

                      b. If (the next character is '"' and the
                         sensitivity to local includes is on) or (the
                         next character is '<' and the sensitivity to
                         system includes is on)

                            i.    Copy the include-file name.

                            ii.   If the include file is local and the
                                  configuration data specifies that we
                                  must search for include files in the
                                  source-file directory

                                     Search for the include file in the
                                     source-file directory (the full
                                     include-file name is obtained by
                                     prefixing the source-file path to
                                     the include-file name derived from
                                     the source file).

                             iii. If the include file has not yet been
                                  found

                                     Search for the include file in the
                                     paths given by the INCLUDE
                                     environment variable.

                             iv.  If the include file is newer than the
                                  object file

                                          Go to step G - there is an
                                          include file that is newer
                                          than the object file.

                                  Else if the configuration data
                                  specifies that we must scan include
                                  files for include statements

                                          Save the include-file name

     F. Go to step B

     G. If we must scan include files for include statements and an
        include file that is newer than the object file has not yet
        been found

           For each saved include file, repeat the process given above
           (beginning with step A) with the include file playing the
           role of the source file.  Continue until all saved include
           files have been examined or an include file that is newer
           than the object file is found.

─────Switches for CL────────────────────────────────────────────────────────

     The following switches may be used to affect the way in which
     CMAKE processes a CL command:

     /* CMAKE - INCLUDE END */

     C comment statement in C-source or -include files.  Used to
     indicate that there are no include statements after the comment.

     scan_include_files_for_includes

     Boolean variable set in the configuration file.  Used to indicate
     whether or not CMAKE should scan include files for include
     statements.  (Default: no).

     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES ON
     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES OFF

     Make file commands.  Used to indicate whether or not CMAKE should
     scan include files for include statements.  These commands take
     precedence over the Boolean variable,
     scan_include_files_for_includes, which may be set in the
     configuration file.

     search_source_dir_for_includes

     Boolean variable set in the configuration file.  Used to indicate
     whether or not CMAKE should look for local-include files in the
     source-file's directory before using the INCLUDE environment
     variable.  (Default: yes).

     c_include_""_on
     c_include_<>_on

     Boolean variables set in the configuration file.  Used to control
     the initial sensitivity for each source file to local- and system-
     include statements.  c_include_""_on (Default: yes).
     c_include_<>_on (Default: no)

     /* CMAKE - INCLUDE "" OFF */
     /* CMAKE - INCLUDE "" ON */
     /* CMAKE - INCLUDE <> OFF */
     /* CMAKE - INCLUDE <> ON */

     C comment statements in C-source or -include files.  Used to
     modify the sensitivity to local- and system-include statements.
     The effect of these switches is local.  They only affect the
     processing of the source file in which they are contained.  These
     switches take precedence over the Boolean variables,
     c_include_""_on and c_include_<>_on, which may be set in the
     configuration file.

─────Some Restrictions on CL────────────────────────────────────────────────

     Preprocessor Directives

     #include is the only preprocessor directive that CMAKE recognizes.
     One of the implications of this is that CMAKE will not ignore
     conditionally compiled include statements based upon whether or
     not a particular identifier has been defined (either with a
     #define statement or through the use of the /D CL command-line
     option).  For example, in the following section of source code, if
     the sensitivity to local-include statements is on, CMAKE will not
     skip the include statement - regardless of whether or not the
     identifier, INCLUDE_TEST_H, has been defined:

     #ifdef INCLUDE_TEST_H
        #include "test.h"
     #endif

     Any of the following approaches could be taken to instruct CMAKE
     to ignore this include statement:

     #ifdef INCLUDE_TEST_H
        /* CMAKE - INCLUDE "" OFF */
        #include "test.h"
        /* CMAKE - INCLUDE "" ON */
     #endif

     or

     #ifdef INCLUDE_TEST_H
     // #include "test.h"
     #endif

     or

     #ifdef INCLUDE_TEST_H
     /* #include "test.h" */
     #endif

     Include-File Names

     The full path of an include file may not be given in an include
     statement (i.e. the include-file name must not begin with a drive
     or a '\' character).  However, relative paths may be used (i.e.
     the include-file name may begin with dots (..) or a directory
     name).

─────Error Handling with CL─────────────────────────────────────────────────

     If a CL command is required, CMAKE will add the CL command to the
     batch file, "makefile.bat".  In addition, CMAKE will insert the
     following command after the CL command:

     if errorlevel 1 goto failed

     This will ensure that if the CL command fails (i.e. returns a
     nonzero value), "makefile.bat" will terminate.

─────Output from CMAKE for CL───────────────────────────────────────────────

     Normally, CMAKE provides no information on the processing of a
     given CL command unless the command is required.  If the command
     is required, one of the following messages will appear:

     OBJ object_file Does Not Exist

     This indicates that <object_file> does not exist.

     SRC source_file > OBJ

     This indicates that <source_file> is newer than the object file.

     INC include_file > OBJ object_file

     This indicates that <include_file> is newer than <object_file>.

─────Examples───────────────────────────────────────────────────────────────

     cl          35  OBJ test.obj Does Not Exist
     cl          35  SRC test.c > OBJ
     cl          35  INC test.h > OBJ test.obj

─────Verbose Output from CMAKE for CL───────────────────────────────────────

     When the verbose output format is selected, CMAKE lists all of the
     time stamp comparisons that it makes in route to determining if a
     given CL command is required.

     Examples: CL Not Required
               CL Required

─────Example: CL Not Required───────────────────────────────────────────────

     cl /c /W3 test.c

           Command:      cl
           Parameters:   /c /W3 test.c
           Command Type: intrinsic
           Command ID:   0

           Source File: test.c
           Object File: test.obj

           Source File is older than Object File
           Include File test1.h is older than Object File
           Include File test2.h is older than Object File
           Include File test3.h is older than Object File

           * not required *

─────Example: CL Required───────────────────────────────────────────────────

     cl /c /W3 test.c

           Command:      cl
           Parameters:   /c /W3 test.c
           Command Type: intrinsic
           Command ID:   0

           Source File: test.c
           Object File: test.obj

           Source File is older than Object File
           Include File test1.h is older than Object File
     ***** Include File test2.h is NEWER than Object File

           Modified Command Line:

     cl /c /W3 test.c
     if errorlevel 1 goto failed

           * REQUIRED *

─────COPY───────────────────────────────────────────────────────────────────

     Description

     The COPY Command Line

     When is a COPY Command Required?

     Some Restrictions

     Error Handling

     Output from CMAKE

     Verbose Output from CMAKE

─────Description of COPY────────────────────────────────────────────────────

     COPY is an internal MS-DOS command.  It is used to copy one or
     more files from one location to another.

─────The COPY Command Line──────────────────────────────────────────────────

     The COPY command must be of the following form:

     copy source target

     Both <source> and <target> are required.  <source> and <target>
     may be a file or directory (but not a root directory).  If
     <source> (or <target>) is a file, and the path of the file is not
     specified, it is assumed that the file is located in the current
     directory.

─────When is a COPY Command Required?───────────────────────────────────────

     The conditions under which a given COPY command (of the form:
     copy source target) will be required, depend upon the "type" of
     the COPY command.  There are four possible types:

                 ┌─────────┬───────────┬───────────┐
                 │  Type   │ <source>  │ <target>  │
                 ├─────────┼───────────┼───────────┤
                 │ Type ff │ file      │ file      │
                 │ Type fd │ file      │ directory │
                 │ Type df │ directory │ file      │
                 │ Type dd │ directory │ directory │
                 └─────────┴───────────┴───────────┘

     Regardless of the "type" of the COPY command, if <target> does not
     exist, the COPY command will be required.  Otherwise, the
     conditions are as follows:

     Type ff: copy source_file target_file

     If the source file is newer than the target file, the COPY command
     will be required

     Type fd: copy source_file target_directory

     The target-file name is constructed from the target directory name
     and the source-file name.  If the target file does not exist, or
     if the source file is newer than the target file, the COPY command
     will be required.

     Type df: copy source_directory target_file

     The COPY command will always be required in this case.

     Type dd: copy source_directory target_directory

     If the source directory is empty, the COPY command will not be
     required.  Otherwise, for each file, <source_file>, in the source
     directory, the corresponding target-file name is constructed from
     <target_directory> and <source_file>.  If <target_file> does not
     exist, or if <source_file> is newer than <target_file>, the
     following COPY command will be required:

     copy source_file target_file

─────Some Restrictions on COPY──────────────────────────────────────────────

     Global Characters

     The source and target names may not contain the global characters,
     '*' and '?'.

     Concatenation

     CMAKE does not support the concatenation operator, '+', for the
     COPY command.

     Options

     Options (e.g. /A, /B, and /V) may only be placed after the target
     name.  White space must be placed between the target name and the
     first option.  The options, /A and /B, may not be used after the
     source name.

     Reserved Device Names

     The reserved device names: PRN, LPT1, LPT2, LPT3, CON, COM1, COM2,
     COM3, COM4, and AUX, may be used for source and target names.
     However, the results will be predictable.  Regardless of whether
     or not the source name is a reserved device name, if the target
     name is a reserved device name, the COPY command will not be
     required.  If the source name is a reserved device name, and the
     target name is not a reserved device name, the COPY command will
     be required.

─────Error Handling with COPY───────────────────────────────────────────────

     CMAKE will usually insert the following command into the batch
     file, "makefile.bat", after a required command:

     if errorlevel 1 goto failed

     However, this is not done in the case of the COPY command because
     the COPY command does not return a nonzero value when it fails.

─────Output from CMAKE for COPY─────────────────────────────────────────────

     Normally, CMAKE provides no information on the processing of a
     given COPY command unless the command is required.  If the command
     is required, one of the following messages will appear:

     TRG target_file Does Not Exist

     This indicates that <target_file> does not exist.

     SRC source_file > TRG target_file

     This indicates that <source_file> is newer than <target_file>.

     SRC source_dir is a Directory and TRG target_file is a File

     This indicates that the source of the COPY command is a directory
     and the target is a file.  (This form of the COPY command is
     always required.)

─────Examples───────────────────────────────────────────────────────────────

     copy        12  TRG test.trg Does Not Exist
     copy        12  SRC test.src > TRG test.trg
     copy        12  SRC \s is a Directory and test.trg is a File

─────Verbose Output from CMAKE for COPY─────────────────────────────────────

     When the verbose output format is selected, CMAKE lists all of the
     time stamp comparisons that it makes in route to determining if a
     given COPY command is required.

     In the following two examples, "\s" and "\t" are directories, and
     the files in the directory, "\s", are: "1.txt", "2.txt", "3.txt",
     "4.txt", and "5.txt".

     Examples: COPY Not Required
               COPY Required

─────Example: COPY Not Required─────────────────────────────────────────────

     copy \s \t

           Command:      copy
           Parameters:   \s \t
           Command Type: intrinsic
           Command ID:   4

           Source: \s
           Target: \t

           Source File \s\1.txt is older or equal to Target File \t\1.txt
           Source File \s\2.txt is older or equal to Target File \t\2.txt
           Source File \s\3.txt is older or equal to Target File \t\3.txt
           Source File \s\4.txt is older or equal to Target File \t\4.txt
           Source File \s\5.txt is older or equal to Target File \t\5.txt

           * not required *

─────Example: COPY Required─────────────────────────────────────────────────

     copy \s \t

           Command:      copy
           Parameters:   \s \t
           Command Type: intrinsic
           Command ID:   4

           Source: \s
           Target: \t

     ***** Source File \s\1.txt is NEWER than Target File \t\1.txt
           Source File \s\2.txt is older or equal to Target File \t\2.txt
     ***** Target File \t\3.txt Does Not Exist
           Source File \s\4.txt is older or equal to Target File \t\4.txt
     ***** Source File \s\5.txt is NEWER than Target File \t\5.txt

           * REQUIRED *

     Note:

     In this example, the following commands would be written to the
     batch file, "makefile.bat":

     copy \s\1.txt \t\1.txt
     copy \s\3.txt \t\3.txt
     copy \s\5.txt \t\5.txt

─────LIB────────────────────────────────────────────────────────────────────

     Description

     When is a LIB Command Required?

     The LIB Command Line

     Modified Command Line

     Error Handling

     Some Restrictions

     Output from CMAKE

     Verbose Output from CMAKE

─────Description of LIB─────────────────────────────────────────────────────

     LIB is a program that is distributed with the Microsoft C
     Optimizing Compiler and the Microsoft Macro Assembler.  It is used
     to create and maintain library files.

─────When is a LIB Command Required?────────────────────────────────────────

     A given LIB command will be required if any of the following
     conditions is true:

     1. The library file does not exist.
     2. A component file (object or library) is newer than the library
        file.

     These conditions are checked in order.  If any condition is found
     to be true, the remaining conditions are not checked.

─────The LIB Command Line───────────────────────────────────────────────────

     Examples: A Library of Objects
               A Library of Libraries

     Command Line

     The library-file name, component files (objects or libraries), and
     options must be specified in a LIB response file.  The first non-
     white-space character that follows the LIB command name must be
     '@'.  This character must be followed by a response-file name.
     White space is allowed between the character, '@', and the
     response-file name.  The response-file name may be followed by
     white space or a semicolon.  If the path of the response file is
     not specified, it is assumed that the response file is located in
     the current directory.

     Response File

     The library-file name must be placed at the beginning of the first
     line of the response file.  White space may precede the library-
     file name.  No default extension is assumed for the library file.
     If the path of the library is not specified, it is assumed that
     the library is located in the current directory.  All LIB options
     must be placed after the library-file name.  White space must be
     used to separate the library-file name and the first option.

     The letter, 'y', must be placed on the second line of the
     response file.  This is used as the answer to the LIB prompt:
     "Library does not exist.  Create? (y/n)", in the case where the
     library does not exist.  White space may precede and follow the
     character, 'y'.

     The last section of the response file consists of the set of
     component-file names.  CMAKE accepts two formats for this list.
     The list may contain either a set of object files or a set of
     library files.  Regardless of the format used, each line in this
     section may contain only one file name.  Each file name must be
     preceded by an operation.  If the list contains a set of objects,
     each object-file name must be preceded by the "replace" command
     symbol, '-+'.  If the list contains a set of libraries, each
     library-file name must be preceded by the "add" command symbol,
     '+'.  White space may be placed before the command symbols,
     between the '-' and '+' characters of the '-+' command symbol, and
     between the command symbol and the component-file name.  No
     default extension is assumed for the component files.  If the path
     of a component file is not specified, it is assumed that the
     component file is located in the current directory.  Except for
     the last component in the list, each component-file name must be
     followed by the character, '&'.  White space is allowed between a
     component-file name and the character, '&'.  The last component-
     file name in the list of components should not be followed by the
     character, '&'.

     CMAKE ignores all lines in the response file that occur after the
     line that contains the last component-file name.

─────Example: A Library of Objects──────────────────────────────────────────

     command: lib @test.lrf

     where "test.lrf" is a LIB response file with the following lines:

     test.lib /I
     y
     -+test1.obj &
     -+test2.obj ;

─────Example: A Library of Libraries────────────────────────────────────────

     command: lib @test.lrf

     where "test.lrf" is a LIB response file with the following lines:

     test.lib /I
     y
     +test1.lib &
     +test2.lib ;

─────Modified Command Line for LIB──────────────────────────────────────────

     If a LIB command is required, CMAKE will add the LIB command to
     the batch file, "makefile.bat".

     If the library consists of a set of objects, CMAKE will create a
     new LIB response file that contains only those object files that
     are newer than the library.  The new LIB response file will have
     the same name as the original, except that the extension, '.clb',
     will be used in place of the original response-file extension.

     If the library consists of a set of component libraries,
     and the library (into which the components are to be placed)
     exists, CMAKE will insert the following command into the batch
     file, "makefile.bat", before the LIB command:

     erase library_file

     Note that in this case, since the library is a conglomerate of
     component libraries that are added (+) together, the library must
     be erased, and rebuilt from scratch.

─────Error Handling with LIB────────────────────────────────────────────────

     If a LIB command is required, CMAKE will insert the following
     command into the batch file, "makefile.bat", after the LIB
     command:

     if errorlevel 1 goto failed

     This will ensure that if the LIB command fails (i.e. returns a
     nonzero value), "makefile.bat" will terminate.

─────Some Restrictions on LIB───────────────────────────────────────────────

     Response-File Name

     If the response file consists of a list of objects, the extension
     of the LIB response-file name may not be '.clb'

     Cross-Reference-Listing File and Output Library

     If a cross-reference-listing file and output library file are
     specified in the LIB response file, they will not be included in
     the new response file that CMAKE creates in the case where the
     response file consists of a list of objects.

─────Output from CMAKE for LIB──────────────────────────────────────────────

     Normally, CMAKE provides no information on the processing of a
     given LIB command unless the command is required.  If the command
     is required, one of the following messages will appear:

     LIB library_file Does Not Exist

     This indicates that <library_file> does not exist.

     OBJ component_object_file > LIB library_file

     This indicates that <component_object_file> is newer than
     <library_file>.

     LIB component_library_file > LIB library_file

     This indicates that <component_library_file> is newer than
     <library_file>.

─────Examples───────────────────────────────────────────────────────────────

     lib         36  LIB test.lib Does Not Exist
     lib         36  OBJ test1.obj > LIB test.lib
     lib         36  LIB test1.lib > LIB test.lib

─────Verbose Output from CMAKE for LIB──────────────────────────────────────

     When the verbose output format is selected, CMAKE lists all of the
     time stamp comparisons that it makes in route to determining if a
     given LIB command is required.

     The next two examples illustrate the verbose output generated for
     cases where the LIB response file consists of a set of objects.
     For these examples, the LIB response file, "test.lrf", consists of
     the following lines:

     test.lib
     y
     -+test1.obj &
     -+test2.obj ;

     Examples: A Library of Objects: LIB Not Required
               A Library of Objects: LIB Required

     The next two examples illustrate the verbose output generated for
     cases where the LIB response file consists of a set of libraries.
     For these examples, the LIB response file, "test.lrf", consists of
     the following lines:

     test.lib
     y
     +test1.lib &
     +test2.lib ;

     Examples: A Library of Libraries: LIB Not Required
               A Library of Libraries: LIB Required

─────Example: A Library of Objects: LIB Not Required────────────────────────

     lib @test.lrf

           Command:      lib
           Parameters:   @test.lrf
           Command Type: intrinsic
           Command ID:   1

           Response File: test.lrf
           Library File:  test.lib

           Response-File Format: Update Object Modules

           Object File test1.obj is older than Library File
           Object File test2.obj is older than Library File

           * not required *

─────Example: A Library of Objects: LIB Required────────────────────────────

     lib @test.lrf

           Command:      lib
           Parameters:   @test.lrf
           Command Type: intrinsic
           Command ID:   1

           Response File: test.lrf
           Library File:  test.lib

           Response-File Format: Update Object Modules

           Object File test1.obj is older than Library File
     ***** Object File test2.obj is NEWER than Library File

           New Response File test.clb Created

           Modified Command Line:

     lib @test.clb
     if errorlevel 1 goto failed

           * REQUIRED *

─────Example: A Library of Libraries: LIB Not Required──────────────────────

     lib @test.lrf

           Command:      lib
           Parameters:   @test.lrf
           Command Type: intrinsic
           Command ID:   1

           Response File: test.lrf
           Library File:  test.lib

           Response-File Format: Merge Libraries

           Component-Library File test1.lib is older than Library File
           Component-Library File test2.lib is older than Library File

           * not required *

─────Example: A Library of Libraries: LIB Required──────────────────────────

     lib @test.lrf

           Command:      lib
           Parameters:   @test.lrf
           Command Type: intrinsic
           Command ID:   1

           Response File: test.lrf
           Library File:  test.lib

           Response-File Format: Merge Libraries

           Component-Library File test1.lib is older than Library File
     ***** Component-Library File test2.lib is NEWER than Library File

           Modified Command Line:

     erase test.lib
     lib @test.lrf
     if errorlevel 1 goto failed

           * REQUIRED *

─────LINK───────────────────────────────────────────────────────────────────

     Description

     When is a LINK Command Required?

     The LINK Command Line

     Error Handling

     Output from CMAKE

     Verbose Output from CMAKE

─────Description of LINK────────────────────────────────────────────────────

     LINK is a program that is distributed with the Microsoft C
     Optimizing Compiler and the Microsoft Macro Assembler.  It is used
     to build executable files and dynamic-link libraries.

─────When is a LINK Command Required?───────────────────────────────────────

     A given LINK command will be required if any of the following
     conditions is true:

     1. The executable file does not exist.
     2. A component-object file is newer than the executable file.
     3. A component-library file is newer than the executable file.
     4. The module-definition file is newer than the executable file.

     These conditions are checked in order.  If any condition is found
     to be true, the remaining conditions are not checked.

─────The LINK Command Line──────────────────────────────────────────────────

     Examples: Linking Objects
               Linking with Libraries
               Using a Module-Definition File

     Command Line

     The executable-file name, component-object files, component-
     library files, module-definition file, and options must be
     specified in a LINK response file.  The first non-white-space
     character that follows the LINK command name must be '@'.  This
     character must be followed by a response-file name.  White space
     is allowed between the character, '@', and the response-file name.
     The response-file name may be followed by white space or a
     semicolon.  If the path of the response file is not specified, it
     is assumed that the response file is located in the current
     directory.

     Response File

     Each line of the response file may contain only one file name.
     White space may precede the file name given on any line.

     The first section of the response file must consist of a list of
     object files.  No default extension is assumed for the object
     files.  If the path of an object is not specified, it is assumed
     that the object is located in the current directory.  Except for
     the last object in the list, each object-file name must be
     followed by the character, '+'.  White space is allowed between an
     object-file name and the character, '+'.  The last object-file
     name in the list of objects must not be followed by the character,
     '+'.

     The line that follows the last object must begin with the name of
     the executable file.  LINK options may be placed on this line,
     after the executable-file name.  White space must be used to
     separate the executable-file name and the first option.  If a map
     file is not desired, there are no component libraries, and there
     is no module-definition file, a semicolon must be placed at the
     end of the line that contains the executable-file name.

     If a semicolon has not been used at the end of the executable-file
     line, the line that follows the executable name must contain the
     map-file name.  If there are no component libraries and there is
     no module-definition file, a semicolon must be placed at the end
     of the line that contains the map-file name.  If a map file is not
     desired, and there are component libraries or there is a module-
     definition file, either use NUL for the map-file name or leave the
     map-file line blank.

     If there are component libraries, they must be listed after the
     line that contains the map-file name.  No default extension is
     assumed for library files.  If the path of a library is not
     specified, it is assumed that the library is located in the
     current directory.  (CMAKE does not use the LIB environment
     variable to search for libraries.)  Except for the last library in
     the list, each library-file name must be followed by the
     character, '+'.  White space is allowed between the library-file
     name and the character,  '+'.  The last library-file name in the
     list of must not be followed by the character, '+'.  If there is
     no module-definition file, a semicolon must be placed at the end
     of the line that contains the last library-file name.

     If there is a module-definition file, the line that follows the
     last library must contain the module-definition-file name.  A
     semicolon may be placed at the end of the module-definition-file
     line.  However, the semicolon is not required in this case.

     CMAKE ignores all lines in the response file that occur after the
     line that contains the semicolon or the line that contains the
     module-definition-file name, whichever comes first.

─────Example: Linking Objects───────────────────────────────────────────────

     command: link @test.lnk

     where "test.lnk" is a LINK response file with the following lines:

     test1.obj +
     test2.obj +
     test3.obj
     test.exe /stack:8192 ;

     or, if a map file is desired:

     test1.obj +
     test2.obj +
     test3.obj
     test.exe /stack:8192
     test.map ;

─────Example: Linking with Libraries────────────────────────────────────────

     command: link @test.lnk

     where "test.lnk" is a LINK response file with the following lines:

     test1.obj +
     test2.obj +
     test3.obj
     test.exe /stack:8192
     NUL
     test1.lib +
     test2.lib ;

     or, if a map file is desired:

     test1.obj +
     test2.obj +
     test3.obj
     test.exe /stack:8192
     test.map
     test1.lib +
     test2.lib ;

─────Example: Using a Module-Definition File────────────────────────────────

     command: link @test.lnk

     where "test.lnk" is a LINK response file with the following lines:

     test1.obj +
     test2.obj +
     test3.obj
     test.exe /stack:8192
     NUL
     test1.lib +
     test2.lib
     test.def  ;

     or, if a map file is desired:

     test1.obj +
     test2.obj +
     test3.obj
     test.exe /stack:8192
     test.map
     test1.lib +
     test2.lib
     test.def  ;

─────Error Handling with LINK───────────────────────────────────────────────

     If a LINK command is required, CMAKE will add the LINK command to
     the batch file, "makefile.bat".  In addition, CMAKE will insert
     the following commands after the LINK command:

     if errorlevel 1 goto n_link_failed
     goto n_link_ok
     if exist executable_file erase executable_file
     goto failed

     This will ensure that if the LINK command fails (i.e. returns a
     nonzero value), the faulty executable that LINK may have created
     will be erased, and "makefile.bat" will terminate.  (Actually, in
     place of the prefix, 'n_', used in the batch file labels given
     above, CMAKE will use a numeric prefix (e.g. 2_link_failed) that
     is ensured to be unique across all required LINK commands.)

─────Output from CMAKE for LINK─────────────────────────────────────────────

     Normally, CMAKE provides no information on the processing of a
     given LINK command unless the command is required.  If the command
     is required, one of the following messages will appear:

     EXE executable_file Does Not Exist

     This indicates that <executable_file> does not exist.

     OBJ object_file > EXE executable_file

     This indicates that <object_file> is newer than <executable_file>.

     LIB library_file > EXE executable_file

     This indicates that <library_file> is newer than
     <executable_file>.

     DEF module_definition_file > EXE executable_file

     This indicates that <module_definition_file> is newer than
     <executable_file>.

─────Examples───────────────────────────────────────────────────────────────

     link        38  EXE test.exe Does Not Exist
     link        38  OBJ test.obj > EXE test.exe
     link        38  LIB test.lib > EXE test.exe
     link        38  DEF test.def > EXE test.exe

─────Verbose Output from CMAKE for LINK─────────────────────────────────────

     When the verbose output format is selected, CMAKE lists all of the
     time stamp comparisons that it makes in route to determining if a
     given LINK command is required.

     For both of the examples given below, the LINK response file,
     "test.lnk", is as follows:

     test.obj
     test.exe /stack:16384
     test.map
     test.lib
     test.def ;

     Examples: LINK Not Required
               LINK Required

─────Example: LINK Not Required─────────────────────────────────────────────

     link @test.lnk

           Command:      link
           Parameters:   @test.lnk
           Command Type: intrinsic
           Command ID:   2

           Response File:   test.lnk
           Executable File: test.exe

           Object File test.obj is older than Executable File
           Library File test.lib is older than Executable File
           Module-Definition File test.def is older than Executable File

           * not required *

─────Example: LINK Required─────────────────────────────────────────────────

     link @test.lnk

           Command:      link
           Parameters:   @test.lnk
           Command Type: intrinsic
           Command ID:   2

           Response File:   test.lnk
           Executable File: test.exe

     ***** Object File test.obj is NEWER than Executable File

           Modified Command Line:

     link @test.lnk
     if errorlevel 1 goto 0_link_failed
     goto 0_link_ok
     :0_link_failed
     if exist test.exe erase test.exe
     goto failed
     :0_link_ok

           * REQUIRED *

─────MASM───────────────────────────────────────────────────────────────────

     Description

     When is a MASM Command Required?

     The MASM Command Line

     How CMAKE Processes an Assembly-Language-Source File

     Switches

     Some Restrictions

     Error Handling

     Output from CMAKE

     Verbose Output from CMAKE

─────Description of MASM────────────────────────────────────────────────────

     MASM is a program that is distributed with the Microsoft Macro
     Assembler.  In Macro Assembler versions prior to 6.00, MASM is the
     assembler itself.  In version 6.00 of the Macro Assemble, MASM
     provides a command-line interface to the assembler program,
     ML.EXE.

─────When is a MASM Command Required?───────────────────────────────────────

     A given MASM command will be required if any of the following
     conditions is true:

     1. The object file does not exist.
     2. The source file is newer than the object file.
     3. There is an include file that is newer than the object file.

     These conditions are checked in order.  If any condition is found
     to be true, the remaining conditions are not checked.

─────The MASM Command Line──────────────────────────────────────────────────

     Source-File Name

     The source-file name must be placed before the first comma on the
     command line.  Only white space may be present between the source-
     file name and the comma that follows it.  No default extension is
     assumed for the source file.  If a path is not specified, it is
     assumed that the source file is located in the current directory.

     Object-File Name

     The object-file name must be specified.  It must be placed after
     the first comma on the command line.  Only white space may be
     present between the object-file name and the comma that precedes
     it.  No default extension is assumed for the object file.  If a
     path is not specified, it is assumed that the object file is
     located in the current directory.  The object-file name may be
     followed by a comma, semicolon, or white space.

     Options

     Options may not be placed between the source-file name and the
     first comma or between the first comma and the object-file name.

─────Examples───────────────────────────────────────────────────────────────

     command:     masm /W2 /V /Z test.asm,test.obj;
     source file: current_directory\test.asm
     object file: current_directory\test.obj

     command:     masm /W2 /V /Z ..\asm\test.asm,..\obj\test.obj;
     source file: ..\asm\test.asm
     object file: ..\obj\test.obj

─────How CMAKE Processes an Assembly-Language-Source File───────────────────

     When the object file of a MASM command exists, and it is newer
     than the source file, CMAKE will process the assembly-language-
     source file in order to determine whether or not there is an
     include file that is newer than the object file.  CMAKE will
     extract include-file names from the include statements that are
     given in the assembly-language-source file.

     Sensitivity to Include Statements

     The "sensitivity to include statements" may be thought of as a
     Boolean state variable for CMAKE.  If the sensitivity to include
     statements is "on" and CMAKE encounters an include statement,
     CMAKE will check to see if the include file associated with the
     include statement is newer than the object file.  Otherwise, if
     the sensitivity to include statements is "off", CMAKE will ignore
     the include statement.

     By default, the sensitivity to include statements is "on".

     The sensitivity to include statements may be altered through the
     use of a variety of switches.

     For each source file, CMAKE uses the Boolean variable,
     asm_include_on, to initialize the sensitivity to include
     statements.

     Within a given assembly-language-source file, the following
     comments may be used to modify the sensitivity to include
     statements:

     ; CMAKE - INCLUDE OFF
     ; CMAKE - INCLUDE ON

     Locating Include Files

     If CMAKE does obtain an include-file name from an include
     statement, it will attempt to determine the directory in which
     the file is located.  First, CMAKE will look for the file in the
     current directory.  If the include file is not found in the
     current directory, CMAKE will look for the file in the directory
     in which the source file for the given MASM command is located.
     If the include file is not found in the source-file's directory,
     CMAKE will search the directories specified by the INCLUDE
     environment variable (if it is defined), one by one, from left to
     right.

     To prevent CMAKE from searching for include files in the current
     directory, use the following statement in the configuration file:

     search_current_dir_for_includes = no

     To prevent CMAKE from searching for include files in the source-
     file's directory, use the following statement in the configuration
     file:

     search_source_dir_for_includes = no

     Scanning Include Files for Include Statements

     By default, CMAKE does not scan include files for include
     statements.  To force CMAKE to scan include files for include
     statements, place the following statement in your configuration
     file:

     scan_include_files_for_includes = yes

     Alternatively, you may place the following commands anywhere
     within your make file (except within the body of an if statement)
     to achieve a "local" effect:

     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES ON
     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES OFF

     When a REM statement of this type is used, all of the MASM
     commands that follow the statement will be affected.

     The End-of-Includes Comment

     If CMAKE encounters the comment:

     ; CMAKE - INCLUDE END

     while scanning an assembly-language-source file, it will stop
     processing the file, i.e. CMAKE will not read any lines in the
     source file that occur after this comment.

     Although it is not required, you should place this comment after
     the last include statement in any assembly-language-source file
     that will be scanned by CMAKE.  If you do this, you will reduce
     the amount of time that CMAKE takes to execute.

     The Procedure Used to Examine an Assembly-Language-Source File

     For a given MASM command, CMAKE uses the following process to
     scan the assembly-language-source file in order to determine
     whether or not there is an include file that is newer than the
     object file:

     A. Initialize the sensitivity to include statements.

     B. Read a line from the source file.

     C. If we are at the end of the source file

           Goto step G - there are no include files in this source file
           that are newer than the object file.

     D. Skip leading white space on the line.

     E. If the line begins with the comment
                ; CMAKE - INCLUDE ON

                Enable the sensitivity to include statements.

        Else if the line begins with the comment
                ; CMAKE - INCLUDE OFF

                Disable the sensitivity to include statements.

        Else if the line begins with the comment
                ; CMAKE - INCLUDE END

                Go to step G - there are no include files in this
                source file that are newer than the object file.

        Else if the line begins with the token, 'include' (or
                'INCLUDE'), and the sensitivity to include statements
                is on

                1. Skip white space following the 'include' token.

                2. Copy the include-file name.

                3. If the configuration data specifies that we must
                   search for include files in the current directory

                      Search for the include file in the current
                      directory (the full include-file name is obtained
                      by prefixing the current directory to the
                      include-file name derived from the source file).

                4. If the include file has not yet been found and
                   the configuration data specifies that we must search
                   for include files in the source-file directory

                      Search for the include file in the source-file
                      directory (the full include-file name is obtained
                      by prefixing the source-file path to the include-
                      file name derived from the source file).

                5. If the include file has not yet been found

                      Search for the include file in the paths given by
                      the INCLUDE environment variable.

                6. If the include file is newer than the object file

                           Go to step G - there is an include file that
                           is newer than the object file.

                   Else if the configuration data specifies that we
                   must scan include files for include statements

                           Save the include-file name

     F. Go to step B

     G. If we must scan include files for include statements and an
        include file that is newer than the object file has not yet
        been found

           For each saved include file, repeat the process given above
           (beginning with step A) with the include file playing the
           role of the source file.  Continue until all saved include
           files have been examined or an include file that is newer
           than the object file is found.

─────Switches for MASM──────────────────────────────────────────────────────

     The following switches may be used to affect the way in which
     CMAKE processes a MASM command:

     ; CMAKE - INCLUDE END

     Assembly-language-comment statement in source or include files.
     Used to indicate that there are no include statements after the
     comment.

     scan_include_files_for_includes

     Boolean variable set in the configuration file.  Used to indicate
     whether or not CMAKE should scan include files for include
     statements.  (Default: no).

     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES ON
     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES OFF

     Make file commands.  Used to indicate whether or not CMAKE should
     scan include files for include statements.  These commands take
     precedence over the Boolean variable,
     scan_include_files_for_includes, which may be set in the
     configuration file.

     search_source_dir_for_includes

     Boolean variable set in the configuration file.  Used to indicate
     whether or not CMAKE should look for include files in the source-
     file's directory before using the INCLUDE environment variable.
     (Default: yes).

     search_current_dir_for_includes

     Boolean variable set in the configuration file.  Used to indicate
     whether or not CMAKE should look for include files in the current
     directory before using the INCLUDE environment variable.
     (Default: yes).

     asm_include_on

     Boolean variable set in the configuration file.  Used to control
     the initial sensitivity for each source file to include
     statements.  (Default: yes)

     ; CMAKE - INCLUDE OFF
     ; CMAKE - INCLUDE ON

     Assembly-language-comment statements in source or include files.
     Used to modify the sensitivity to include statements.  The effect
     of this switch is local.  It only affects the processing of the
     source file in which it is are contained.  This switch takes
     precedence over the Boolean variable, asm_include_on which may be
     set in the configuration file.

─────Some Restrictions on MASM──────────────────────────────────────────────

     Include Statements

     The full path of an include file may not be given in an include
     statement (i.e. the include-file name must not begin with a drive
     or a '\' character).  However, relative paths may be used (i.e.
     the include-file name may begin with dots (..) or a directory
     name).

─────Error Handling with MASM───────────────────────────────────────────────

     If a MASM command is required, CMAKE will add the MASM command to
     the batch file, "makefile.bat".  In addition, CMAKE will insert
     the following command after the MASM command:

     if errorlevel 1 goto failed

     This will ensure that if the MASM command fails (i.e. returns a
     nonzero value), "makefile.bat" will terminate.

─────Output from CMAKE for MASM─────────────────────────────────────────────

     Normally, CMAKE provides no information on the processing of a
     given MASM command unless the command is required.  If the command
     is required, one of the following messages will appear:

     OBJ object_file Does Not Exist

     This indicates that <object_file> does not exist.

     SRC source_file > OBJ

     This indicates that <source_file> is newer than the object file.

     INC include_file > OBJ object_file

     This indicates that <include_file> is newer than <object_file>.

─────Examples───────────────────────────────────────────────────────────────

     masm        37  OBJ test.obj Does Not Exist
     masm        37  SRC test.asm > OBJ
     masm        37  INC test.h > OBJ test.obj

─────Verbose Output from CMAKE for MASM─────────────────────────────────────

     When the verbose output format is selected, CMAKE lists all of the
     time stamp comparisons that it makes in route to determining if a
     given MASM command is required.

     Examples: MASM Not Required
               MASM Required

─────Example: MASM Not Required─────────────────────────────────────────────

     masm /W2 /V /Z test.asm,test.obj;

           Command:      masm
           Parameters:   /W2 /V /Z test.asm,test.obj;
           Command Type: intrinsic
           Command ID:   3

           Source File: test.asm
           Object File: test.obj

           Source File is older than Object File
           Include File test1.inc is older than Object File
           Include File test2.inc is older than Object File
           Include File test3.inc is older than Object File

           * not required *

─────Example: MASM Required─────────────────────────────────────────────────

     masm /W2 /V /Z test.asm,test.obj;

           Command:      masm
           Parameters:   /W2 /V /Z test.asm,test.obj;
           Command Type: intrinsic
           Command ID:   3

           Source File: test.asm
           Object File: test.obj

           Source File is older than Object File
           Include File test1.inc is older than Object File
     ***** Include File test2.inc is NEWER than Object File

           Modified Command Line:

     masm /W2 /V /Z test.asm,test.obj;
     if errorlevel 1 goto failed

           * REQUIRED *

─────RC─────────────────────────────────────────────────────────────────────

     Description

     Operations

          RC/C - Compile a Resource-Script File

          RC/A - Add a Resource File to an Executable File

          RC/W - Add the Windows Version Stamp to a File

          RC/CA - Compile and Add a Resource File to an Executable File

─────Description of RC──────────────────────────────────────────────────────

     RC is a program that is distributed with the Microsoft Windows
     Software Development Kit.  It is known as the "Resource Compiler".

─────RC Operations──────────────────────────────────────────────────────────

     The Resource Compiler may be used to perform any of the following
     four operations:

     Compile a Resource-Script File

     Compile a resource-script file to create a resource file.  We
     use the symbol, "RC/C", to represent an RC command that is used
     for this purpose.  (The suffix, '/C', stands for "Compile".)

     Add a Resource File to an Executable File

     Add a resource file to an executable file.  We use the symbol,
     "RC/A", to represent an RC command that is used for this purpose.
     (The suffix, '/A', stands for "Add".)

     Add the Windows Version Stamp to a File

     Add the Windows version stamp to a file generated by the linker.
     We use the symbol, "RC/W", to represent an RC command that is used
     for this purpose.  (The suffix, '/W', stands for "Windows".)

     Compile and Add a Resource File to an Executable File

     Compile a resource-script file to create a resource file, and add
     the resulting resource file to an executable file.  We use the
     symbol, "RC/CA", to represent an RC command that is used for this
     purpose.  (The suffix, '/CA', stands for "Compile and Add".)

     CMAKE supports the first three of these four operations.

─────RC/C───────────────────────────────────────────────────────────────────

     Description                                 Helpful Hints

     The RC/C Command Line

     When is an RC/C Command Required?

     How CMAKE Processes a Resource-Script File

     Switches

     Some Restrictions

     Error Handling

     Output from CMAKE

     Verbose Output from CMAKE

─────Description of RC/C────────────────────────────────────────────────────

     We use the symbol, "RC/C", to represent an RC command that is used
     to compile a resource-script file in order to create a resource
     file.  The suffix, '/C', stands for "Compile".

─────The RC/C Command Line──────────────────────────────────────────────────

     Resource-Script-File Name

     The resource-script-file name must be the last command-line
     parameter.  No default extension is assumed for the resource-
     script file.  If the path of the resource-script file is not
     specified, it is assumed that the file is located in the current
     directory.

     If your editor has the capability to allow you to review compiler
     error message, and you use this feature, you should use the path
     separator, '/' (or '\\') (in place of the usual, '\'), in the
     resource-script-file name.  If this is not done, RC will drop the
     path separators from the resource-script-file name that it
     provides in error messages that pertain to that file.  The end
     result will be that your editor will be unable to open the
     resource-script file when an error occurs in that file.  CMAKE
     supports the use of, '/' and '\\', in place of the usual, '\', in
     this case.  However, the path separator, '\', should be used in
     all other paths that are specified in the make file.  (The problem
     described above is present in the "Microsoft Windows Resource
     Compiler Version 3.00 (dated 6/1/90)".  More recent versions of
     the Resource Compiler may or may not have this problem.)

     Resource-File Name

     The /fo option may be used to specify the name of the resource
     file.  If this option is used, the resource-file-name extension
     must be specified; and the path of the resource file must be
     specified, if the file is not located in the current directory.

     If the /fo option is not used, the resource-file name is derived
     from the resource-script-file name by replacing the resource-
     script-file-name extension with '.res'.

     Options

     Options may appear anywhere between the RC command name and the
     resource-script-file name.  The /r option (compile) must be used.
     The /r option may not be combined with another single letter
     option.  The options, /r and /fo, are not case sensitive, and '-'
     may be used in place of '/'.

─────Examples───────────────────────────────────────────────────────────────

     command:              rc /v /r test.rc
     resource-script file: current_directory\test.rc
     resource file:        current_directory\test.res

     command:              rc /r /fo..\res\test.res ..\\rc\\test.rc
     resource-script file: ..\rc\test.rc
     resource file:        ..\res\test.res

─────When is an RC/C Command Required?──────────────────────────────────────

     A given RC/C command will be required if any of the following
     conditions is true:

     1. The resource file does not exist.
     2. The resource-script file is newer than the resource file.
     3. There is an include file or included resource (e.g. an icon,
        bitmap, cursor, font, or user-defined resource) that is newer
        than the resource file.

─────How CMAKE Processes a Resource-Script File─────────────────────────────

     When the resource file of an RC/C command exists, and it is newer
     than the resource-script file, CMAKE will process the resource-
     script file in order to determine whether or not there is an
     include file or an included resource (e.g. an icon, bitmap,
     cursor, font, or user-defined resource) that is newer than the
     resource file.  CMAKE will extract include-file names from
     the include statements and resource-include statements that are
     given in the resource-script file.

     CMAKE recognizes two forms of the include statement: local and
     system.  CMAKE also recognizes resource-include statements.

     Local-Include Statements

     The term "local-include statement" is used to refer to an include
     statement that has the form:

          #include "filename"

     and the file associated with such an include statement is said to
     be a "local-include file".

     System-Include Statements

     The term "system-include statement" is used to refer to an include
     statement that has the form:

          #include <filename>

     and the file associated with such an include statement is said to
     be a "system-include file".

     Resource-Include Statements

     The term "resource-include statement" is used to refer to a
     statement that has the form:

          resource_name_id resource_type_id [options] filename

     and the file associated with such a statement is said to be a
     "resource-include file" or an "included resource".  (Note that
     the documentation for the Microsoft Windows Software Development
     Kit refers to these statements as "single-line" statements.)  Some
     examples of resource-include statements are:

          myicon ICON myicon.ico
          mybitmap BITMAP mybmap.bmp
          myfont FONT myfont.fnt
          mycursor CURSOR mycur.cur
          10 400 mytext.txt

     Sensitivity to Local-, System-, and Resource-Include Statements

     The "sensitivity to local-include statements", the "sensitivity to
     system-include statements", and the "sensitivity to resource-
     include statements" may be thought of as Boolean state variables
     for CMAKE.

     If the sensitivity to local-include statements is "on", and CMAKE
     encounters a local-include statement, CMAKE will check to see if
     the include file associated with the include statement is newer
     than the object file.  Otherwise, if the sensitivity to local-
     include statements is "off", CMAKE will ignore the local-include
     statement.  Similar statements may be made to describe the role of
     the sensitivity to "system-" include statements and the
     sensitivity to "resource-" include statements.

     By default, the sensitivity to local-include statements is "on",
     the sensitivity to system-include statements is "off", and the
     sensitivity to resource-include statements is "on".

     The sensitivity to local-, system-, and resource-include
     statements may be altered through the use of a variety of
     switches.

     For each source file, CMAKE uses the Boolean variables,
     rc_include_""_on, rc_include_<>_on, and rc_include_resource_on to
     initialize the sensitivity to local-, system-, and resource-
     include statements, respectively.

     Within a given resource-script file, any of the following C-style
     comments may be used to modify the sensitivity to local-, system-,
     or resource-include statements:

     /* CMAKE - INCLUDE "" OFF */
     /* CMAKE - INCLUDE "" ON */
     /* CMAKE - INCLUDE <> OFF */
     /* CMAKE - INCLUDE <> ON */
     /* CMAKE - INCLUDE RESOURCE OFF */
     /* CMAKE - INCLUDE RESOURCE ON */

     Locating Include Files

     If CMAKE does obtain an include-file name from an include
     statement, it will attempt to determine the directory in which
     the file is located.  If the file is a local-include file or a
     resource-include file, CMAKE will look for the file in the current
     directory.  If the include file is not found in the current
     directory, CMAKE will search the directories specified by the
     INCLUDE environment variable (if it is defined), one by one, from
     left to right.  On the other hand, if the file is a system-include
     file, CMAKE will only look for the file in the directories given
     by the INCLUDE environment variable.

     To prevent CMAKE from searching for local-include files and
     resource-include files in the current directory, use the following
     statement in the configuration file:

     search_current_dir_for_includes = no

     Scanning Include Files for Include Statements

     By default, CMAKE does not scan include files for include
     statements.  To force CMAKE to scan local-include files and
     system-include files for include statements, place the following
     statement in your configuration file:

     scan_include_files_for_includes = yes

     Alternatively, you may place the following commands anywhere
     within your make file (except within the body of an if statement)
     to achieve a "local" effect:

     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES ON
     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES OFF

     When a REM statement of this type is used, all of the RC/C
     commands that follow the statement will be affected.

     The End-of-Includes Comment

     If CMAKE encounters the comment:

     /* CMAKE - INCLUDE END */

     while scanning a resource-script file, it will stop processing the
     file, i.e. CMAKE will not read any lines in the file, that occur
     after this comment.  To learn how this switch may be used to
     affect the way in which CMAKE processes the resource-script file,

     See: Helpful Hints for RC/C

     The Procedure Used to Examine a Resource-Script File

     For a given RC/C command, CMAKE uses the following process to
     scan the resource-script file in order to determine whether or not
     there is an include file that is newer than the resource file:

     A. Initialize the sensitivity to local-include statements,
        system-include statements, and resource-include statements.

     B. Read a line from the resource-script file.

     C. If we are at the end of the resource-script file

           Goto step G - there are no include files or included
           resources in this resource-script file that are newer than
           the resource file.

     D. Skip leading white space on the line.

     E. If the line begins with the character, '/'

                If the line begins with the comment
                        /* CMAKE - INCLUDE "" ON */

                        Enable the sensitivity to local-include
                        statements.

                Else if the line begins with the comment
                        /* CMAKE - INCLUDE "" OFF */

                        Disable the sensitivity to local-include
                        statements.

                Else if the line begins with the comment
                        /* CMAKE - INCLUDE <> ON */

                        Enable the sensitivity to system-include
                        statements.

                Else if the line begins with the comment
                        /* CMAKE - INCLUDE <> OFF */

                        Disable the sensitivity to system-include
                        statements.

                Else if the line begins with the comment
                        /* CMAKE - INCLUDE RESOURCE ON */

                        Enable the sensitivity to resource-include
                        statements.

                Else if the line begins with the comment
                        /* CMAKE - INCLUDE RESOURCE OFF */

                        Disable the sensitivity to resource-include
                        statements.

                Else if the line begins with the comment
                        /* CMAKE - INCLUDE END */

                        Go to step G - there are no include files or
                        included resources in this resource-script file
                        that are newer than the resource file.

        Else if the line begins with the character, '#'

                1. Skip white space following the '#' character.

                2. If the next token is 'include'

                      a. Skip white space following the 'include'
                         token.

                      b. If (the next character is '"' and the
                         sensitivity to local includes is on) or (the
                         next character is '<' and the sensitivity to
                         system includes is on)

                            i.   Copy the include-file name.

                            ii.  If the include file is local and the
                                 configuration data specifies that we
                                 must search for include files in the
                                 current directory

                                    Search for the include file in the
                                    current directory (the full
                                    include-file name is obtained by
                                    prefixing the current directory to
                                    the include-file name derived from
                                    the resource-script file).

                            iii. If the include file has not yet been
                                 found

                                    Search for the include file in the
                                    paths given by the INCLUDE
                                    environment variable.

                            iv.  If the include file is newer than the
                                 resource file

                                         Go to step G - there is an
                                         include file that is newer
                                         than the resource-script file.

                                 Else if the configuration data
                                 specifies that we must scan include
                                 files for include statements

                                         Save the include-file name.

        Else if the sensitivity to resource includes is on

                1. Skip to the end of the line or to the first '
                   occurrence of, '//' or '/*', whichever comes first.

                2. Copy the file name of the included resource from the
                   previous token (convert any occurrences of, '\\' and
                   '/', in the file name, to '\').

                3. If the configuration data specifies that we must
                   search for include files in the current directory

                      Search for the included resource in the current
                      directory (the full file name for the included
                      resource is obtained by prefixing the current
                      directory to the resource-include-file name
                      derived from the resource-script file).

                4. If the included resource has not yet been found

                      Search for the included resource in the paths
                      given by the INCLUDE environment variable.

                5. If the included resource is newer than the
                   resource file

                      Go to step G - there is an included resource that
                      is newer than the resource file.

     F. Go to step B

     G. If we must scan include files for include statements and an
        include file or included resource that is newer than the
        resource file has not yet been found

           For each saved (local- or system-) include file, repeat the
           process given above (beginning with step A) with the include
           file playing the role of the resource-script file.  Continue
           until all saved include files have been examined, or an
           include file is found that is newer than the resource file.

─────Switches for RC/C──────────────────────────────────────────────────────

     The following switches may be used to affect the way in which
     CMAKE processes an RC/C command:

     /* CMAKE - INCLUDE END */

     C-style comment statement in resource-script file or (local- or
     system-) include files.  Used to indicate that there are no
     local-, system-, or resource-include statements after the comment.

     scan_include_files_for_includes

     Boolean variable set in the configuration file.  Used to indicate
     whether or not CMAKE should scan include files for include
     statements.  (Default: no).

     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES ON
     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES OFF

     Make file commands.  Used to indicate whether or not CMAKE should
     scan include files for include statements.  These commands take
     precedence over the Boolean variable,
     scan_include_files_for_includes, which may be set in the
     configuration file.

     search_current_dir_for_includes

     Boolean variable set in the configuration file.  Used to indicate
     whether or not CMAKE should look for local- and resource-include
     files in the current directory, before using the INCLUDE
     environment variable.
     (Default: yes).

     rc_include_""_on
     rc_include_<>_on
     rc_include_resource_on

     Boolean variables set in the configuration file.  Used to control
     the initial sensitivity for each resource-script file to local-,
     system-, and resource-include statements.  rc_include_""_on
     (Default: yes).  rc_include_<>_on (Default: no).
     rc_include_resource_on (Default: yes).

     /* CMAKE - INCLUDE "" OFF */
     /* CMAKE - INCLUDE "" ON */
     /* CMAKE - INCLUDE <> OFF */
     /* CMAKE - INCLUDE <> ON */
     /* CMAKE - INCLUDE RESOURCE OFF */
     /* CMAKE - INCLUDE RESOURCE ON */

     C-style comment statements in resource-script file or (local- or
     system-) include files.  Used to modify the sensitivity to local-,
     system-, and resource-include statements.  The effect of these
     switches is local.  They only affect the processing of the file
     in which they are contained.  These switches take precedence over
     the Boolean variables, rc_include_""_on, rc_include_<>_on, and
     rc_include_resource_on, which may be set in the configuration
     file.

─────Some Restrictions on RC/C──────────────────────────────────────────────

     Preprocessor Directives

     #include is the only preprocessor directive that CMAKE recognizes.
     One of the implications of this is that CMAKE will not ignore
     conditionally compiled include statements based upon whether or
     not a particular identifier has been defined (either with a
     #define statement or through the use of the /D RC command-line
     option).  For example, in the following section of source code, if
     the sensitivity to local-include statements is on, CMAKE will not
     skip the include statement - regardless of whether or not the
     identifier, INCLUDE_TEST_H, has been defined:

     #ifdef INCLUDE_TEST_H
        #include "test.h"
     #endif

     Any of the following approaches could be taken to instruct CMAKE
     to ignore this include statement:

     #ifdef INCLUDE_TEST_H
        /* CMAKE - INCLUDE "" OFF */
        #include "test.h"
        /* CMAKE - INCLUDE "" ON */
     #endif

     or

     #ifdef INCLUDE_TEST_H
     // #include "test.h"
     #endif

     or

     #ifdef INCLUDE_TEST_H
     /* #include "test.h" */
     #endif

     Include-File Names

     The full path of a local-, system-, or resource-include file may
     not be given in an include statement (i.e. the include-file name
     must not begin with a drive or a '\' character).  However,
     relative paths may be used (i.e.  the include-file name may begin
     with dots (..) or a directory name).

     Note that if a path is used in the file name of an included
     resource, '/' or '\\' must be used in place of the usual path
     separator, '\'.  For example, you would use

     myicon ICON "..\\ico\\myicon.ico"

     or

     myicon ICON "../ico/myicon.ico"

     in place of

     myicon ICON "..\ico\myicon.ico"

     This restriction is imposed by the Resource Compiler, itself.
     (The behavior described above was observed in the "Microsoft
     Windows Resource Compiler Version 3.00 (dated 6/1/90)".  More
     recent versions of the Resource Compiler may or may not behave
     this way.)

─────Error Handling with RC/C───────────────────────────────────────────────

     If an RC/C command is required, CMAKE will add the RC/C command to
     the batch file, "makefile.bat".  In addition, CMAKE will insert
     the following command after the RC/C command:

     if errorlevel 1 goto failed

     This will ensure that if the RC/C command fails (i.e. returns a
     nonzero value), "makefile.bat" will terminate.

─────Output from CMAKE for RC/C─────────────────────────────────────────────

     Normally, CMAKE provides no information on the processing of a
     given RC/C command unless the command is required.  If the command
     is required, one of the following messages will appear:

     RES resource_file Does Not Exist

     This indicates that <resource_file> does not exist.

     SRC resource_script_file > RES

     This indicates that <resource_script_file> is newer than the
     resource file.

     INC include_file > RES resource_file

     This indicates that <include_file> is newer than <resource_file>.

─────Examples───────────────────────────────────────────────────────────────

     rc          35  RES test.res Does Not Exist
     rc          35  SRC test.rc > RES
     rc          35  INC test.h > RES test.res
     rc          35  INC test.ico > RES test.res

─────Verbose Output from CMAKE for RC/C─────────────────────────────────────

     When the verbose output format is selected, CMAKE lists all of the
     time stamp comparisons that it makes in route to determining if a
     given RC/C command is required.

     Examples: RC/C Not Required
               RC/C Required

─────Example: RC/C Not Required─────────────────────────────────────────────

     rc /v /r test.rc

           Command:      rc
           Parameters:   /v /r test.rc
           Command Type: intrinsic
           Command ID:   6

           Operation: Compile

           Resource-Script File: test.rc
           Resource File:        test.res

           Resource-Script File is older than Resource File
           Include File test1.h is older than Resource File
           Include File test2.h is older than Resource File
           Include File test.ico is older than Resource File

           * not required *

─────Example: RC/C Required─────────────────────────────────────────────────

     rc /v /r test.rc

           Command:      rc
           Parameters:   /v /r test.rc
           Command Type: intrinsic
           Command ID:   6

           Operation: Compile

           Resource-Script File: test.rc
           Resource File:        test.res

           Resource-Script File is older than Resource File
           Include File test1.h is older than Resource File
           Include File test2.h is older than Resource File
     ***** Include File test.ico is NEWER than Resource File

           Modified Command Line:

     rc /v /r test.rc
     if errorlevel 1 goto failed

           * REQUIRED *

─────Helpful Hints for RC/C─────────────────────────────────────────────────

     Controlling Resource-Script File Processing

     When the sensitivity to resource-include statements is "on", CMAKE
     assumes that each line that it reads from the resource-script
     file, that does not begin with, '/' or '#' (and is not blank), is
     a resource-include statement.

     But generally, not every line in a resource-script file, that does
     not begin with, '#' or '/', will be a resource-include statement
     (there will usually be some multiple-line statements such as MENU
     or DIALOG statements present in the resource-script file as well).

     To prevent CMAKE from misinterpreting a line in the resource-
     script file as a resource-include statement, you could place all
     of your include statements at the top of the resource-script file,
     and place the following comment in your script file after the
     section that contains the include statements:

     /* CMAKE - INCLUDE END */

     More specifically, you could take the following approach:

     1. If a heading (consisting of comments) is desired in the
        resource-script file, begin each comment line with, '//'
        or '/*'.
     2. Place all #include statements and statements that include
        resources (such as icons, bitmaps, cursors, fonts, and user-
        defined resources) after any comments placed at the top of
        the resource-script file.
     3. Place the comment, "/* CMAKE - INCLUDE END */", after the
        section of the resource-script file that contains the #include
        statements and statements that are used to include resources.

     When the sensitivity to resource-include statements is "off",
     CMAKE ignores all lines in the resource-script file that do not
     begin with, "#include" or "/* CMAKE -".  Thus, CMAKE will not
     misinterpret any lines in the resource-script file as resource-
     include statements, when the sensitivity to resource-include
     statements is "off".  To take advantage of this fact, you could
     use the following switches in your resource-script file:

     /* CMAKE - INCLUDE RESOURCE OFF */
     /* CMAKE - INCLUDE RESOURCE ON */

     These switches may be used to turn the sensitivity to resource-
     include statements, "off" and "on", respectively.

─────RC/A───────────────────────────────────────────────────────────────────

     Description

     The RC/A Command Line

     When is an RC/A Command Required?

     Error Handling

     Output from CMAKE

     Verbose Output from CMAKE

─────Description of RC/A────────────────────────────────────────────────────

     We use the symbol, "RC/A", to represent an RC command that is used
     to add a resource file to an executable file.  The suffix, '/A',
     stands for "Add".

─────The RC/A Command Line──────────────────────────────────────────────────

     Resource-File Name

     The resource-file name must be the last or second-to-last command
     -line parameter.  The resource-file name must have the extension,
     '.res'.  If the path of the resource file is not specified, it is
     assumed that the resource file is located in the current
     directory.

     Executable-File Name

     If the resource-file name is the last command-line parameter,
     the executable-file name is derived from the resource-file name
     by replacing the file extension, '.res', with '.exe'.

     If the resource-file name is the second to last command-line
     parameter, the executable-file name must be the last command-line
     parameter.  In this case, no default extension will be assumed for
     the executable file.  If the path of the executable file is not
     specified, it will be assumed that the executable file is located
     in the current directory.

     CMAKE does not recognize the /fe option which may be used to
     rename the executable file.

─────Examples───────────────────────────────────────────────────────────────

     command:         rc /v test.res
     resource file:   current_directory\test.res
     executable file: current_directory\test.exe

     command:         rc /v ..\res\test.res ..\exe\test.exe
     resource file:   ..\res\test.res
     executable file: ..\exe\test.exe

─────When is an RC/A Command Required?──────────────────────────────────────

     A given RC/A command will be required if any of the following
     conditions is true:

     1. A previous make-file command for which the executable file is a
        target (e.g. LINK), is required.
     2. A previous make-file command for which the resource file is a
        target (e.g. RC/C), is required.

     These conditions are checked in order.  If any condition is found
     to be true, the remaining conditions are not checked.

─────Error Handling with RC/A───────────────────────────────────────────────

     If an RC/A command is required, CMAKE will add the RC/A command to
     the batch file, "makefile.bat".  In addition, CMAKE will insert
     the following commands after the RC/A command:

     if errorlevel 1 goto n_rc_failed
     goto n_rc_ok
     if exist executable_file erase executable_file
     goto failed

     This will ensure that if the RC/A command fails (i.e. returns a
     nonzero value), the faulty executable file will be erased, and
     "makefile.bat" will terminate.  (Actually, in place of the prefix,
     'n_', used in the batch file labels given above, CMAKE will use a
     numeric prefix (e.g. 2_rc_failed) that is ensured to be unique
     across all required RC commands.)

─────Output from CMAKE for RC/A─────────────────────────────────────────────

     Normally, CMAKE provides no information on the processing
     of a given RC/A command unless the command is required.  If the
     command is required, one of the following messages will appear:

     EXE executable_file Has Been Updated

     This indicates that a previous make-file command for which
     <executable_file> is a target file (e.g. LINK), is required.

     RES resource_file Has Been Updated

     This indicates that a previous make-file command for which
     <resource_file> is a target file (e.g. RC/C), is required.

─────Examples───────────────────────────────────────────────────────────────

     rc          37  EXE test.exe Has Been Updated
     rc          37  RES test.res Has Been Updated

─────Verbose Output from CMAKE for RC/A─────────────────────────────────────

     When the verbose output format is selected, CMAKE lists all of the
     time stamp comparisons that it makes in route to determining if a
     given RC/A command is required.

     Examples: RC/A Not Required
               RC/A Required

─────Example: RC/A Not Required─────────────────────────────────────────────

     rc /v test.res test.exe

           Command:      rc
           Parameters:   /v test.res test.exe
           Command Type: intrinsic
           Command ID:   6

           Operation: Add Resource To Executable

           Resource File:   test.res
           Executable File: test.exe

           Executable File Has Not Been Updated
           Resource File Has Not Been Updated

           * not required *

─────Example: RC/A Required─────────────────────────────────────────────────

     rc /v test.res test.exe

           Command:      rc
           Parameters:   /v test.res test.exe
           Command Type: intrinsic
           Command ID:   6

           Operation: Add Resource To Executable

           Resource File:   test.res
           Executable File: test.exe

           Executable File Has Not Been Updated
     ***** Resource File Has Been Updated

           Modified Command Line:

     rc /v test.res test.exe
     if errorlevel 1 goto 0_rc_failed
     goto 0_rc_ok
     :0_rc_failed
     if exist test.exe erase test.exe
     goto failed
     :0_rc_ok

           * REQUIRED *

─────RC/W───────────────────────────────────────────────────────────────────

     Description

     The RC/W Command Line

     When is an RC/W Command Required?

     Error Handling

     Output from CMAKE

     Verbose Output from CMAKE

─────Description of RC/W────────────────────────────────────────────────────

     We use the symbol, "RC/W", to represent an RC command that is used
     to add the Windows version stamp to a file.  The suffix, '/W',
     stands for "Windows".

─────The RC/W Command Line──────────────────────────────────────────────────

     We refer the file to which we would like to add the Windows
     version stamp, as the "target file".

     Target-File Name

     The target-file name must be the last command-line parameter.  If
     there are two or more command-line parameters, the second to last
     command-line parameter must be an option.  No default extension is
     assumed for the target file.  The target file may not have the
     extension, '.res'.  If the path of the target file is not
     specified, it is assumed that the target file is located in the
     current directory.

─────Examples───────────────────────────────────────────────────────────────

     command:     rc /v test.exe
     target file: current_directory\test.exe

     command:     rc /v ..\dll\test.dll
     target file: ..\dll\test.dll

     command:     rc /v ..\drv\test.drv
     target file: ..\drv\test.drv

─────When is an RC/W Command Required?──────────────────────────────────────

     A given RC/W command will be required if the target file of the
     RC/W command is also the target of a previous make-file command
     that is required.

─────Error Handling with RC/W───────────────────────────────────────────────

     If an RC/W command is required, CMAKE will add the RC/W command to
     the batch file, "makefile.bat".  In addition, CMAKE will insert
     the following commands after the RC/W command:

     if errorlevel 1 goto n_rc_failed
     goto n_rc_ok
     if exist target_file_name erase target_file_name
     goto failed

     This will ensure that if the RC/W command fails (i.e. returns a
     nonzero value), the faulty target file of RC/W will be erased, and
     "makefile.bat" will terminate.  (Actually, in place of the prefix,
     'n_', used in the batch file labels given above, CMAKE will use a
     numeric prefix (e.g. 2_rc_failed) that is ensured to be unique
     across all required RC commands.)

─────Output from CMAKE for RC/W─────────────────────────────────────────────

     Normally, CMAKE provides no information on the processing of a
     given RC/W command unless the command is required.  If the command
     is required, the following message will appear:

     TRG target_file Has Been Updated

     This indicates that a previous make-file command for which
     <target_file> is a target file (e.g. LINK), is required.

─────Examples───────────────────────────────────────────────────────────────

     rc          39  TRG test.dll Has Been Updated

─────Verbose Output from CMAKE for RC/W─────────────────────────────────────

     When the verbose output format is selected, CMAKE lists all of the
     time stamp comparisons that it makes in route to determining if a
     given RC/W command is required.

     Examples: RC/W Not Required
               RC/W Required

─────Example: RC/W Not Required─────────────────────────────────────────────

     rc /v test.dll

           Command:      rc
           Parameters:   /v test.dll
           Command Type: intrinsic
           Command ID:   6

           Operation: Add Windows Version Stamp

           Target File: test.dll

           Target File Has Not Been Updated

           * not required *

─────Example: RC/W Required─────────────────────────────────────────────────

     rc /v test.dll

           Command:      rc
           Parameters:   /v test.dll
           Command Type: intrinsic
           Command ID:   6

           Operation: Add Windows Version Stamp

           Target File: test.dll

     ***** Target File Has Been Updated

           Modified Command Line:

     rc /v test.dll
     if errorlevel 1 goto 1_rc_failed
     goto 1_rc_ok
     :1_rc_failed
     if exist test.dll erase test.dll
     goto failed
     :1_rc_ok

           * REQUIRED *

─────RC/CA──────────────────────────────────────────────────────────────────

     CMAKE does not support this operation.

─────REM────────────────────────────────────────────────────────────────────

     Description

     REM is an MS-DOS command.  It is used to add comments to DOS batch
     programs.

     When is a REM Command Required?

     REM commands are never required.

     The REM Command Line

     CMAKE imposes no restrictions on the REM command.

     Switches

     The following two REM commands have a special meaning to CMAKE:

     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES ON
     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES OFF

     These commands may be used to indicate whether or not CMAKE should
     scan C, assembly-language, and resource-script include files for
     include statements.  These switches remain in effect until the end
     of the make file or until another such REM switch is encountered.
     These commands take precedence over the Boolean variable,
     scan_include_files_for_includes, which may be set in the
     configuration file.

     Output from CMAKE

     Normally, CMAKE provides no information on the processing of REM
     commands.

     Verbose Output from CMAKE

     When the verbose output format is selected, CMAKE will list each
     REM command and indicate that the command is not required.

     For example, if the command, "rem TEST.EXE", is used in the make
     file, CMAKE will generate the following output:

     rem TEST.EXE

           Command:      rem
           Parameters:   TEST.EXE
           Command Type: intrinsic (comment)

           * not required *

─────SET────────────────────────────────────────────────────────────────────

     Description

     SET is an internal MS-DOS command.  It is used to display, set, or
     remove MS-DOS environment variables.

     When is a SET Command Required?

     SET commands are always required.

     The SET Command Line

     CMAKE supports the following two forms of the SET command:

     set
     set environment_variable_name=environment_variable_value

     Error Handling

     Ordinarily, CMAKE will insert the following command into the batch
     file, "makefile.bat", after a command that is required:

     if errorlevel 1 goto failed

     However, this is not done for the SET command because the SET
     command does not return a nonzero value when it fails.

     Output from CMAKE

     Normally, CMAKE provides the following information for every SET
     command:

     always required

     For example, if there is a SET command on line 10 of the make
     file, CMAKE will generate the following output:

     set         10  always required

     Verbose Output from CMAKE

     When the verbose output format is selected, CMAKE will list each
     SET command and indicate that the command is required.

     For example, if the command, "set include=..\h;c:\c\include",
     is used in the make file, CMAKE will generate the following
     output:

     set include=..\h;c:\c\include

           Command:      set
           Parameters:   include=..\h;c:\c\include
           Command Type: intrinsic
           Command ID:   5

           Environment Variable Name:  INCLUDE
           Environment Variable Value: ..\h;c:\c\include

           * REQUIRED *

─────User-Defined Commands──────────────────────────────────────────────────

     Description

     When is a User-Defined Command Required?

     The Command Line for a User-Defined Command

     How CMAKE Processes the Command Line of a User-Defined Command

     Predefined Pseudofiles

     Error Handling

     Output from CMAKE

     Verbose Output from CMAKE

─────Description of User-Defined Commands───────────────────────────────────

     User-defined commands are commands that the user has added to
     CMAKE's vocabulary through the use of command-definition
     statements in the configuration file.  A command-definition
     statement instructs CMAKE on how to determine if a given user-
     defined command is required.

     See: Command-Definition Statements

─────When is a User-Defined Command Required?───────────────────────────────

     A given user-defined command will be required if one of the
     following conditions is true:

     1. At least one target file does not exist.
     2. There is a source file that is newer than some target file.

─────The Command Line for a User-Defined Command────────────────────────────

     White space must follow all source and target-file names.

─────How CMAKE Processes the Command Line of a User-Defined Command─────────

     The source and target files for a given user-defined command are
     extracted from the command line by using the command-definition
     configuration statement for the user-defined command.  In a way,
     the command-definition statement serves as a "prototype" for the
     user-defined command (similar to the way in which a function
     declaration can serve as a "prototype" for a given C language
     function).  The command-definition statement provides a list of
     stationary parameters and a list of floating parameters.
     Usually, each stationary and floating parameter is used to specify
     the format for a particular source or target file will be given on
     the command line for the user-defined command.  Each stationary
     and floating parameter will be of the form

                 parameter_prefix%file_type_code

     where file_type_code indicates whether the file is a source file
     or target file (note that the file may also be specified as
     neutral), and parameter_prefix is the prefix that will precede the
     file name on the command line (note that the parameter prefix may
     be null).

     For each command-line parameter, CMAKE scans the list of floating
     parameters (from left to right) until a floating parameter is
     found that has a prefix that matches the beginning of the current
     command-line parameter.  If a matching floating parameter is not
     found, the prefix of the current stationary parameter is compared
     with the beginning of the current command-line parameter.  (The
     current stationary parameter is the first stationary parameter in
     the list of stationary parameters that has not yet been used to
     obtain a file name from the command line.)  (CMAKE considers a
     null prefix to be a match for anything.)

     If a matching floating or stationary parameter is not found, the
     command-line parameter is skipped.  Otherwise, the file type
     (source, target, or neutral) is obtained from the file type code
     ('s', 't', or 'n') at the end of the matching stationary or
     floating parameter.  If the file is a neutral file, the command-
     line parameter is skipped.  If the file is a source or target
     file, CMAKE obtains the time stamp for the file.  (Actually, if it
     has already been established that the user-defined command is
     required (i.e. there is a target file that does not exist, or
     there is a source file that is newer that some target file), CMAKE
     will not obtain the time stamp of the file.)

     The process described above is carried out for each command-line
     parameter, until either

     1. all command-line parameters have been examined, or
     2. the list of floating parameters is empty and all stationary
        parameters have been used to obtain a file name from the
        command line.

─────Predefined Pseudofiles for User-Defined Commands───────────────────────

     "start.psf"

     The file name, "start.psf", may be used as a source or target file
     within any user-defined command.  You may think of "start.psf" as
     a file that is created just before CMAKE begins processing the
     make file.  The sole purpose of "start.psf" is to mark this point
     in time.  (We refer to "start.psf" as a pseudofile because this
     file is never actually created.)

─────Examples───────────────────────────────────────────────────────────────

     For each example given below, it is assumed that the following
     command-definition statement has been provided in the
     configuration file:

     command_definition : newcmd sp[%s %t]

     Using "start.psf" as a Source File

     The following command:

     newcmd start.psf test.trg

     will be required only if there are no required commands that occur
     before it for which "test.trg" is a target file.

     Using "start.psf" as a Target File

     The following command:

     newcmd test.src start.psf

     will be required only if there is a required command that occurs
     before it for which "test.src" is a target file.

─────Error Handling with User-Defined Commands──────────────────────────────

     If a user-defined command is required, CMAKE will add the user-
     defined command to the batch file, "makefile.bat".  In addition,
     CMAKE will insert the following command after the user-defined
     command:

     if errorlevel 1 goto failed

     This will ensure that if the user-defined command fails (i.e.
     returns a nonzero value), "makefile.bat" will terminate.

─────Output from CMAKE for User-Defined Commands────────────────────────────

     Normally, CMAKE provides no information on the processing of a
     given user-defined command unless the command is required.  If the
     command is required, one of the following messages will appear:

     TRG target_file Does Not Exist

     This indicates that <target_file> does not exist.

     SRC source_file > TRG target_file

     This indicates that <source_file> is newer than <target_file>.

─────Examples───────────────────────────────────────────────────────────────

     cmd1        21  TRG test.trg Does Not Exist
     cmd2        22  SRC test.src > TRG test.trg

─────Verbose Output from CMAKE for User-Defined Commands────────────────────

     For a user-defined command, if the verbose output format is
     selected, CMAKE will list all of the source, target, and neutral
     files that are derived from the command line.  For each file
     listed, CMAKE will indicate which stationary or floating parameter
     was used to obtain the file.

     For each example given below, it is assumed that the following
     command-definition statement has been provided in the
     configuration file:

     command_definition : newcmd sp[%s %s] fp[/o%t]

     Examples: User-Defined Command Not Required
               User-Defined Command Required

─────Example: User-Defined Command Not Required─────────────────────────────

     newcmd /otest.trg test1.src test2.src

           Command:      newcmd
           Parameters:   /otest.trg test1.src test2.src
           Command Type: user defined
           Command ID:   2

           Target File:  test.trg (floating parameter 1)
           Source File:  test1.src (stationary parameter 1)
           Source File:  test2.src (stationary parameter 2)

           Source Files are older than Target Files

           * not required *

─────Example: User-Defined Command Required─────────────────────────────────

     newcmd /otest.trg test1.src test2.src

           Command:      newcmd
           Parameters:   /otest.trg test1.src test2.src
           Command Type: user defined
           Command ID:   2

           Target File:  test.trg (floating parameter 1)
           Source File:  test1.src (stationary parameter 1)
           Source File:  test2.src (stationary parameter 2)

     ***** Source File test2.src is NEWER than Target File test.trg

           Modified Command Line:

     newcmd /otest.trg test1.src test2.src
     if errorlevel 1 goto failed

           * REQUIRED *

─────Equivalent Commands────────────────────────────────────────────────────

     Description

     How CMAKE Processes an Equivalent Command

     Output from CMAKE

     Verbose Output from CMAKE

─────Description of Equivalent Commands─────────────────────────────────────

     Equivalent commands are commands that the user has added to
     CMAKE's vocabulary through the use of command-equivalence
     statements in the configuration file.  A command-equivalence
     statement specifies that a given command should be treated exactly
     like another given intrinsic or user-defined command.

     See: Command-Equivalence Statements

─────How CMAKE Processes an Equivalent Command──────────────────────────────

     A given command that has been defined to be equivalent to some
     intrinsic or user-defined command (referred to here as the
     equivalent command) is treated exactly like the equivalent
     command.  That is to say:

     1. The command will be required if and only if the equivalent
        command is required.
     2. Any restrictions that apply to the equivalent command will also
        apply to the given command.
     3. Any error handling (e.g. "if errorlevel 1 goto failed") that is
        used with the equivalent command, will also be used with the
        given command.

─────Output from CMAKE for Equivalent Commands──────────────────────────────

     Normally, the output for CMAKE for the given command will be
     identical to that of the equivalent command, except that the given
     command name will appear in place of the equivalent-command name.

─────Verbose Output from CMAKE for Equivalent Commands──────────────────────

     The verbose output format for a given command will be identical to
     that of the equivalent command, except that the name and type
     (intrinsic or user-defined) of the equivalent command will be
     provided.

     For each example given below, it is assumed that the following
     command-equivalence statement has been provided in the
     configuration file:

     command_equivalence : spasm = masm

     Examples: Equivalent Command Not Required
               Equivalent Command Required

─────Example: Equivalent Command Not Required───────────────────────────────

     spasm /W2 /V /Z test.asm,test.obj;

           Command:      spasm
           Parameters:   /W2 /V /Z test.asm,test.obj;
           Command Type: equivalent (equivalent to intrinsic command: masm)
           Command ID:   7

           Source File: test.asm
           Object File: test.obj

           Source File is older than Object File

           * not required *

─────Example: Equivalent Command Required───────────────────────────────────

     spasm /W2 /V /Z test.asm,test.obj;

           Command:      spasm
           Parameters:   /W2 /V /Z test.asm,test.obj;
           Command Type: equivalent (equivalent to intrinsic command: masm)
           Command ID:   7

           Source File: test.asm
           Object File: test.obj

     ***** Source File is NEWER than Object File

           Modified Command Line:

     spasm /W2 /V /Z test.asm,test.obj;
     if errorlevel 1 goto failed

           * REQUIRED *

─────Unrecognized Commands in the Make File─────────────────────────────────

     Description

     Unrecognized commands are the commands that are not intrinsic,
     user-defined, or equivalent.

     When is an Unrecognized Command Required?

     Unrecognized commands are always required.

     The Command Line for an Unrecognized Command

     CMAKE imposes no restrictions on the command line of an
     unrecognized command.

     Error Handling

     Since unrecognized commands are required (unconditionally), CMAKE
     will add each unrecognized command to the batch file,
     "makefile.bat".  CMAKE does not insert any error handling commands
     (e.g. "if errorlevel 1 goto failed") after an unrecognized
     command.  Thus, "makefile.bat" will not terminate when an
     unrecognized command fails.

     Output from CMAKE

     Normally, CMAKE provides the following information for every
     unrecognized command:

     unrecognized

     For example, if an unrecognized command called, "whatcmd", is used
     in the make file, CMAKE will provide the following output:

     whatcmd     21  unrecognized

     Verbose Output from CMAKE

     When the verbose output format is selected, CMAKE will list each
     unrecognized command and indicate that the command is required.

     For example, if the command, "whatcmd test.src test.trg", is used
     in the make file, and "whatcmd" is an unrecognized command, CMAKE
     will generate the following output:

     whatcmd test.src test.trg

           Command:      whatcmd
           Parameters:   test.src test.trg
           Command Type: unrecognized

           * REQUIRED *

─────The if Statement───────────────────────────────────────────────────────

     Description

     Syntax

     When are the Commands in the Body of an if Statement Required?

     Predefined Pseudofiles

     Error Handling

     Output from CMAKE

     Verbose Output from CMAKE

─────Description of the if Statement────────────────────────────────────────

     The if statement is used in a make file to explicitly specify
     source/target file dependencies.  It is an extension of the
     target/dependent description blocks which are used with most
     generic make utilities.

─────Syntax of the if Statement─────────────────────────────────────────────

     An if statement has one of the following general forms:

     if (   target_file_1          │   if (   target_file_1
            target_file_2          │          target_file_2
            ...                    │          ...
            target_file_m          │          target_file_m
          < source_file_1          │        < source_file_1
            source_file_2          │          source_file_2
            ...                    │          ...
            source_file_n )        │          source_file_n )
                                   │
        command                    │      {
                                   │      command_1
                                   │      command_2
                                   │      ...
                                   │      command_r
                                   │      }

     Within the if statement, white space is ignored (except between
     file names, where it is required).  The target-file names must be
     listed before the source-file names, and the character, '<', must
     be used to separate the set of target-file names from the set of
     source-file names.  Each command within the body of an if
     statement must appear on a separate line.  The brackets ({}) are
     required only in the case where the body of the if statement
     consists of more than one command.

─────Examples───────────────────────────────────────────────────────────────

     /*****************************************************************
     *  The brackets, '{' and '}', are optional when the body of an
     *  if statement consists of only one command:
     *****************************************************************/

     if ( 1.trg < 1.src 2.src )
        echo  hello

     /*****************************************************************
     *  The brackets, '{' and '}', are required when the body of an
     *  if statement consists of more than one command:
     *****************************************************************/

     if ( 1.trg 2.trg < 1.src 2.src )
        {
        echo  hello
        echo  world
        }

     /*****************************************************************
     *  Since white space is ignored, the lists of source- and target-
     *  file names may be given in a variety of formats:
     *****************************************************************/

     if
        (
          1.trg
                2.trg
                      < 1.src
                              2.src
                                    )
                                      {
                                      echo  hello
                                      echo  world
     }

     /*****************************************************************
     *  You may not place the closing bracket, '}', at the end of the
     *  last command in the body of an if statement.  The following
     *  example shows an unacceptable location for the closing bracket:
     *****************************************************************/

     if ( 1.trg < 1.src )
        {
        echo  hello }

     /*****************************************************************
     *  In this last example, CMAKE would assume that the closing
     *  bracket, '}', is part of the ECHO command line.
     *****************************************************************/

─────When are the Commands in the Body of an if Statement Required?─────────

     The commands within the body of a given if statement will be
     required if one of the following conditions is true:

     1. At least one target file does not exist.
     2. There is a source file that is newer than some target file.

─────Examples───────────────────────────────────────────────────────────────

     if ( 1.trg < 1.src 2.src )
        {
        echo  These echo commands will be required if the target file,
        echo  "1.trg", does not exist, or at least one of the source
        echo  files, "1.src" and "2.src", is newer than the target
        echo  file, "1.trg".
        }

     if ( 1.trg 2.trg < 1.src 2.src )
        {
        echo  These echo commands will be required if any of the
        echo  following conditions is true:
        echo.
        echo  1. The target file, "1.trg", does not exist.
        echo  2. The target file, "2.trg", does not exist.
        echo  3. The source file, "1.src", is newer than "1.trg".
        echo  4. The source file, "1.src", is newer than "2.trg".
        echo  5. The source file, "2.src", is newer than "1.trg".
        echo  6. The source file, "2.src", is newer than "2.trg".
        }

─────Predefined Pseudofiles for the if Statement────────────────────────────

     "start.psf"

     The file name, "start.psf", may be used as a source or target file
     within any if statement.  You may think of "start.psf" as a file
     that is created just before CMAKE begins processing the make file.
     The sole purpose of "start.psf" is to mark this point in time.
     (We refer to "start.psf" as a pseudofile because this file is
     never actually created.)

─────Examples───────────────────────────────────────────────────────────────

     Using "start.psf" as a Source File

     if (   test.trg
          < start.psf )

        {
        echo  These echo commands will be required only if there are no
        echo  required commands that occur before this if statement for
        echo  which "test.trg" is a target file.
        }

     Using "start.psf" as a Target File

     if (   start.psf
          < test.src  )

        {
        echo  These echo commands will be required only if there is a
        echo  required command that occurs before this if statement for
        echo  which "test.src" is a target file.
        }

─────Error Handling with the if Statement───────────────────────────────────

     If the commands within the body of a given if statement are
     required, CMAKE will add all of the commands to the batch file,
     "makefile.bat".  In addition, CMAKE will insert the following
     command after each required command:

     if errorlevel 1 goto failed

     This will ensure that if any command within the body of the if
     statement fails (i.e. returns a nonzero value), "makefile.bat"
     will terminate.

─────Output from CMAKE for the if Statement─────────────────────────────────

     Normally, CMAKE provides no information on the processing of a
     given if statement unless the commands within the body of the if
     statement are required.  If the commands are required, each of the
     commands within the body of the if statement will be listed with
     one of the following messages:

     TRG target_file Does Not Exist

     This indicates that <target_file> does not exist.

     SRC source_file > TRG target_file

     This indicates that <source_file> is newer than <target_file>.

─────Examples───────────────────────────────────────────────────────────────

     cmd         21  TRG test.trg Does Not Exist
     cmd         21  SRC test.src > TRG test.trg

─────Verbose Output from CMAKE for the if Statement─────────────────────────

     For each example given below, it is assumed that the following
     if statement has been given in the make file:

     if (   test1.trg test2.trg
          < test1.src test2.src test3.src )

        {
        echo hello
        echo good bye
        }

     Examples: Commands Not Required
               Commands Required

─────Example: Commands Not Required─────────────────────────────────────────

     if (...)

           Target File: test1.trg
           Target File: test2.trg
           Source File: test1.src
           Source File: test2.src
           Source File: test3.src

           Source Files are older than Target Files

           * not required *

─────Example: Commands Required─────────────────────────────────────────────

     if (...)

           Target File: test1.trg
           Target File: test2.trg
           Source File: test1.src
           Source File: test2.src
           Source File: test3.src

     ***** Source File test3.src is NEWER than Target File test1.trg

           Modified Command Line(s):

     echo hello
     if errorlevel 1 goto failed
     echo good bye
     if errorlevel 1 goto failed

           * REQUIRED *

─────Comments in the Make File──────────────────────────────────────────────

     C-style comments (/* */) and C++-style comments (//) may be used
     to annotate a make file.  A comment is treated as a single white-
     space character, but is otherwise ignored.

     The comment delimiters, /* and //, are not permitted after the
     command name on a command line.

─────Examples───────────────────────────────────────────────────────────────

     Suppose that we have a make file that consists of the following
     two commands:

     cl /c /W4 hello.c
     cl /c /W4 world.c

     We could "comment out" the command, "cl /c /W4 world.c", by adding
     comment delimiters around the command:

     cl /c /W4 hello.c
     /*cl /c /W4 world.c*/

     Another acceptable approach would be:

     cl /c /W4 hello.c
     /*
     cl /c /W4 world.c
     */

     We could also use a C++-style comment to obtain the same result:

     cl /c /W4 hello.c
     // cl /c /W4 world.c

     An unacceptable way to "comment out" the command,
     "cl /c /W4 world.c", would be:

     cl /c /W4 hello.c /*
     cl /c /W4 world.c
     */

     In this case, CMAKE would assume that the comment delimiter, '/*',
     is part of the command, "cl /c /W4 hello.c".  In fact, since '/*'
     is the last token on the command line, '/*' would be taken to be
     the source-file name for the CL command!

     Another unacceptable comment would be:

     cl /c /W4 hello.c  // This is an unacceptable comment
     cl /c /W4 world.c

     In this case, CMAKE would take the word, "comment", to be the
     source-file name of the command, "cl /c /W4 hello.c".

─────The CMAKE Configuration File───────────────────────────────────────────

     Description

     How CMAKE Locates the Configuration File

     The Section Tag

     Statements

          Comments

          Assignment Statements

          Command-Definition Statements

          Command-Equivalence Statements

─────Description of the Configuration File──────────────────────────────────

     A configuration file may be used with CMAKE in order to alter
     default switch settings, define new commands, and set up command
     equivalences.  You may execute CMAKE without a configuration file
     if you are satisfied with the default settings and do not need to
     enlarge CMAKE's command table.

─────Example────────────────────────────────────────────────────────────────

     ; cmake.cfg - CMAKE configuration file

     [CMAKE]

     ; Assignment statements
     scan_include_files_for_includes = no
     search_source_dir_for_includes = yes
     search_current_dir_for_includes = yes
     c_include_""_on = yes
     c_include_<>_on = no
     asm_include_on = yes
     rc_include_""_on = yes
     rc_include_<>_on = no
     rc_include_resource_on = yes
     run_output_file = yes
     display_output_file_commands = no
     display_execution_time = yes

     ; Command-definition statements
     command_definition : sort sp[<%s >%t]

     ; Command-equivalence statements
     command_equivalence : find = sort

─────How CMAKE Locates the Configuration File───────────────────────────────

     When CMAKE begins, it attempts to locate and load its
     configuration file.  CMAKE uses the following process to locate
     the configuration file:

     1. If the environment variable, CMAKE_CFG, is defined, its value
        is used for the configuration-file name.
     2. If the environment variable, CMAKE_CFG, is not defined, or the
        configuration file given by, CMAKE_CFG, does not exist,
        CMAKE looks for the file, "cmake.cfg", in the current
        directory.
     3. If "cmake.cfg" is not found in the current directory, CMAKE
        looks for "cmake.cfg" in the directory in which CMAKE.EXE is
        located.
     4. If "cmake.cfg" is not found in the directory in which CMAKE.EXE
        is located, CMAKE assumes that there is no configuration file,
        and as a result, will use default settings for all Boolean
        variables.

     Note that the environment variable, CMAKE_CFG, should not be
     defined with a SET command in the make file because CMAKE loads
     the configuration file before it begins processing the make file.

     Verbose Output from CMAKE

     When the verbose output format is selected, CMAKE lists the
     locations where it attempts to find the configuration file.  It
     will also indicate whether or not the configuration file has been
     found.

     Example:

     CMAKE_CFG Environment Variable: CMAKE_CFG is undefined
     Current Directory:              c:\test\cmake.cfg does not exist
     CMAKE.EXE Directory:            configuration file c:\c\cmake.cfg found

─────The CMAKE Section Tag in the Configuration File────────────────────────

     CMAKE ignores all lines in the configuration until a line is found
     that begins with the section tag, [CMAKE].  CMAKE will process all
     lines that follow the section tag, until a line is found that
     begins with '[' (indicating the beginning of another section in
     the configuration file) or the end-of-file is reached.

     Because of the use of section tags, the configuration data for
     CMAKE may be placed in a file that contains initialization
     data for other applications.  For example, the configuration data
     for CMAKE could be placed in the file, "tools.ini", which is used
     with the Microsoft Editor or in the file, "win.ini", which is used
     with Microsoft Windows.  Bear in mind that if the configuration
     data for CMAKE is placed at the end of a long file, CMAKE will
     become sluggish.

─────Configuration-File Statements──────────────────────────────────────────

     The configuration data for CMAKE consists of single-line
     statements.

     Leading white space is ignored on every line of the configuration
     file.

─────Comments in the Configuration File─────────────────────────────────────

     CMAKE ignores any line in the configuration file that begins with
     the character, ';'.

─────Assignment Statements in the Configuration File────────────────────────

     Syntax

     Boolean Variables

     Verbose Output from CMAKE

─────Syntax of Assignment Statements────────────────────────────────────────

     Assignment statements have the following form:

     Boolean_variable_name = value

     where 'Boolean_variable_name' is the name of a Boolean variable
     and 'value' must be either yes or no.  White space is ignored
     between the variable name and the value.

─────Boolean Variables──────────────────────────────────────────────────────

     scan_include_files_for_includes

     search_source_dir_for_includes
     search_current_dir_for_includes

     c_include_""_on
     c_include_<>_on

     asm_include_on

     rc_include_""_on
     rc_include_<>_on
     rc_include_resource_on

     run_output_file

     display_output_file_commands
     display_execution_time

─────scan_include_files_for_includes────────────────────────────────────────

     Indicates whether or not CMAKE should scan include files for
     include statements.  The following commands, which may be used in
     the make file, take precedence over this Boolean variable:

     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES ON
     REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES OFF

     Default: no

─────search_source_dir_for_includes─────────────────────────────────────────

     Indicates whether or not CMAKE should look for include files in
     the source-file's directory before using the INCLUDE environment
     variable.

     Default: yes

─────search_current_dir_for_includes────────────────────────────────────────

     Indicates whether or not CMAKE should look for include files in
     the current directory before using the INCLUDE environment
     variable.

     Default: yes

─────c_include_""_on────────────────────────────────────────────────────────

     Controls the initial sensitivity to local-include statements, for
     each C-source file.  Within a given C-source file, the following
     comments may be used to override the value of this Boolean
     variable:

     /* CMAKE - INCLUDE "" OFF */
     /* CMAKE - INCLUDE "" ON */

     Default: yes

─────c_include_<>_on────────────────────────────────────────────────────────

     Controls the initial sensitivity to system-include statements, for
     each C-source file.  Within a given C-source file, the following
     comments may be used to override the value of this Boolean
     variable:

     /* CMAKE - INCLUDE <> OFF */
     /* CMAKE - INCLUDE <> ON */

     Default: no

─────asm_include_on─────────────────────────────────────────────────────────

     Controls the initial sensitivity to include statements, for each
     assembly-language-source file.  Within a given assembly-language-
     source file, the following comments may be used to override the
     value of this Boolean variable:

     ; CMAKE - INCLUDE OFF
     ; CMAKE - INCLUDE ON

     Default: yes

─────rc_include_""_on───────────────────────────────────────────────────────

     Controls the initial sensitivity to local-include statements, for
     each resource-script file.  Within a given resource-script file,
     the following comments may be used to override the value of this
     Boolean variable:

     /* CMAKE - INCLUDE "" OFF */
     /* CMAKE - INCLUDE "" ON */

     Default: yes

─────rc_include_<>_on───────────────────────────────────────────────────────

     Controls the initial sensitivity to system-include statements, for
     each resource-script file.  Within a given resource-script file,
     the following comments may be used to override the value of this
     Boolean variable:

     /* CMAKE - INCLUDE <> OFF */
     /* CMAKE - INCLUDE <> ON */

     Default: no

─────rc_include_resource_on─────────────────────────────────────────────────

     Controls the initial sensitivity to resource-include statements,
     for each resource-script file.  Within a given resource-script
     file, the following comments may be used to override the value of
     this Boolean variable:

     /* CMAKE - INCLUDE RESOURCE OFF */
     /* CMAKE - INCLUDE RESOURCE ON */

     Default: yes

─────run_output_file────────────────────────────────────────────────────────

     Determines whether or not the batch file, "makefile.bat", is to be
     executed.  The command-line option, /n, takes precedence over this
     Boolean variable.

     Default: yes

─────display_output_file_commands───────────────────────────────────────────

     Controls whether or not the commands in the batch file,
     "makefile.bat", are displayed as they are executed.  Note that the
     output from each executed command is always displayed.  This
     switch only determines whether or not the commands themselves are
     also displayed.  The value of this variable is irrelevant if the
     variable, run_output_file, is 'no'.

     Default: no

─────display_execution_time─────────────────────────────────────────────────

     Controls whether or not CMAKE reports its execution time.  This
     time is the number of seconds that it takes CMAKE to create the
     batch file, "makefile.bat".  It does not include the time required
     to execute this batch file.  This time is displayed in the both
     the concise and verbose CMAKE output formats.

     Default: yes

─────Verbose Output from CMAKE for Assignment Statements────────────────────

     When the verbose output format is selected, CMAKE will list each
     assignment statement that it finds in the configuration file.

     For example, if the assignment statement,
     "search_source_dir_for_includes = no", is used in the
     configuration file, CMAKE will generate the following output:

     search_source_dir_for_includes = no

           Command:      search_source_dir_for_includes
           Parameters:   no
           Command Type: assignment
           Command ID:   0

─────Command-Definition Statements──────────────────────────────────────────

     Command-definition statements may be used to expand CMAKE's
     command table.  Each command-definition statement provides
     information on how to determine when a particular command is
     required.  The command-definition statement tells CMAKE which
     files, listed in the command's parameters, are source files (i.e.
     files that the command uses), and which files are target files
     (i.e. files that the command creates)

     Syntax

     The general form of the command-definition configuration statement
     is:

     command_definition : command_name sp[...] fp[...]

     White space between 'command_definition' and the command name is
     ignored.

     The command name is required.  Command names may be up to 8
     characters long and should not include-file-name extensions such
     as '.bat', '.com', or '.exe'.  Command names are not case
     sensitive.  There must be space between the command name and 'sp'
     (or between the command name and 'fp', if 'sp' is omitted).

     sp[...] and fp[...] are used to specify stationary (sp) and
     floating (fp) command parameters, respectively.  The stationary
     parameters of a command are those that always appear in a certain
     position on the command line.  Generally, floating parameters are
     those parameters that are identified by a certain option prefix
     (e.g. -fo), and may appear anywhere on the command line.  sp[...]
     and fp[...] are both optional and may appear in any order.  Each
     may be used at most once in a command-definition statement.
     The brackets, '[' and ']', are required.  A space may not be
     placed between 'sp' or 'fp' and the opening bracket, '['.  White
     space is not required between the closing bracket, ']', and 'sp'
     or 'fp' that follows the bracket.

     The stationary and floating parameters are specified with a
     parameter description string of tokens, where each token must be
     of the form:

          parameter_prefix%file_type_code

     The parameter description string may be up to 20 characters long.
     White space placed before the first token and after the last token
     of the parameter description string is ignored.  Space must be
     placed between any two tokens.

     The parameter prefix is optional.  If a prefix is given, it must
     begin with a non-white-space character and cannot contain the
     character, '%'.  The parameter prefix may contain white space.

     The file type delimiter, '%', is required.

     The file type codes are single character codes used to indicate
     whether a file is a source file, target file, or neutral.  The
     valid file type codes are

          's' (source)
          't' (target)
          'n' (neutral)

     White space may not be placed between the file type delimiter,
     '%', and file type code.

     The subsection entitled, "User-Defined Commands", under "The Make
     File" section of this help file describes exactly how CMAKE uses a
     command-definition statement to determine if a given command is
     required.

     See: User-Defined Commands

─────Examples───────────────────────────────────────────────────────────────

     Example 1

     Consider the command, IMPLIB.  (IMPLIB is a utility that is
     distributed with the Microsoft C Optimizing Compiler.  It is used
     to create import libraries.)  The syntax of the IMPLIB command is:

     IMPLIB  import_library  module_definition_file

     Implib uses the module-definition file to create an import
     library.

     Without a command-definition statement for IMPLIB, CMAKE will not
     recognize the IMPLIB command.  In this case, since unrecognized
     commands are always required, IMPLIB would always be required.

     The following command-definition statement could be used to tell
     CMAKE that the IMPLIB command should only be required when the
     module-definition file is newer than the import library file.

     command_definition : implib sp[%t %s]

     This statement tells CMAKE that the IMPLIB command has two
     stationary parameters (sp), and that the first stationary
     parameter gives the name of the target file that IMPLIB creates
     (%t), and the second stationary parameter gives the name of the
     source file that IMPLIB uses (%s).

     Example 2

     Suppose the following command-definition statement is included
     in the configuration file:

     command_definition : cmd1 fp[/FI%s /FO%t]

     With this command definition in place, the following command
     (which would be placed in the make file):

     CMD1 /A /FOtest.obj /B /FItest.c /C

     will only be required when "test.obj" does not exist, or when
     "test.c" is newer than "test.obj".

     Example 3

     Not all programs allow us to specify the names of all their source
     and target files on the command line.

     For the sake of discussion, let REVERSE be a program that
     reverses a given text file.  Further, suppose that the output of
     the REVERSE is always called, "reversed.txt".  For example, the
     command:

     REVERSE test.txt

     would generate the file, "reversed.txt", which would be the
     reversed version of "test.txt".

     Since REVERSE is an unrecognized command, REVERSE will always be
     required.  We might wish to have the REVERSE command only be
     required when "test.txt" is newer than "reversed.txt".

     Since CMAKE cannot deduce the source and target files names from
     the REVERSE command line, we could not use a command-definition
     statement (for REVERSE) for this purpose.

     However, we could create a batch file called, "rev.bat", with the
     following command:

     REVERSE %1

     and supply the command-definition statement:

     command_definition : rev sp[%s %t]

     With this batch file and command definition in place, we could use
     the following command in place of reverse in our make file:

     REV test.txt reversed.txt

     This command will only be required when "reversed.txt" does not
     exist, or when "test.txt" is newer than "reversed.txt".

     Other Examples

     command_definition : sort sp[<%s >%t]
     command_definition : rp sp[%s %t %s]
     command_definition : compare sp[%s %s >%t]

─────Command-Equivalence Statements─────────────────────────────────────────

     Like command-definition statements, command-equivalence statements
     may be used to expand CMAKE's command table.  A command-
     equivalence statement tells CMAKE that a particular command should
     be processed as if it were another command.

     Syntax

     The general form of the command-equivalence configuration
     statement is:

     command_equivalence : command_name = equivalent_command_name

     White space between 'command_equivalence' and the command name is
     ignored.  Both the command and equivalent-command names are
     required.  The names may be up to 8 characters long and should not
     include-file-name extensions such as '.bat', '.com', or '.exe'.
     The command names are not case sensitive.  White space between
     the command name and equivalent-command name is ignored.

     The equivalent-command name must be either an intrinsic command
     (e.g.  CL, LINK, LIB, MASM,...), or a user-defined command that
     has been defined in a previous command-definition statement.

     See: Equivalent Commands

─────Example────────────────────────────────────────────────────────────────

     Suppose that for some reason you choose to use a linker called,
     NEWLINK, in place of LINK.  If NEWLINK's command-line interface is
     the same as LINK, you could use the following command-equivalence
     statement to tell CMAKE that the NEWLINK command should be handled
     as if it were a LINK command:

     command_equivalence : newlink = link

─────Using CMAKE with Your Editor───────────────────────────────────────────

     BRIEF  Epsilon  The Microsoft Editor

     After you execute CMAKE, you should review the output of CMAKE to
     determine if CMAKE (or one of the commands that CMAKE has
     executed), has failed or generated a warning message.  To perform
     this review, you may redirect the output of CMAKE to a log file,
     and load the log file into your editor.  Many programmer's editors
     (e.g. BRIEF, Epsilon, and the Microsoft Editor) provide a
     mechanism to efficiently view all compiler error messages.  These
     editors interpret the log file in order to place you at the
     location in a source file where an error has occurred.  Using this
     technique, you can view all errors messages and correct the
     problems as you go.

     CMAKE uses a standard format for its error messages.  Any editor
     that can interpret the error messages that are generated by the
     program, CL, will be able to interpret the error messages that are
     generated by CMAKE.

─────Using CMAKE with BRIEF─────────────────────────────────────────────────

     What is BRIEF?

     Running CMAKE from BRIEF

     Running CMAKE from DOS and Viewing Error Messages with BRIEF

     Running CMAKE in a Batch File from BRIEF

     Helpful Hints

─────What is BRIEF?─────────────────────────────────────────────────────────

     BRIEF is a programmer's editor that is available from Solution
     Systems.  It supports a C-like macro language and is distributed
     with many useful macros.

─────Running CMAKE from BRIEF───────────────────────────────────────────────

     First, you should create an appropriate set of environment
     variables of the form:

          BC[ext]="!CMAKE"

     If you would like to able to execute CMAKE while you are editing a
     file that has one of the extensions: '.c', '.h', '.mak', or
     '.lnk'; you could create the following set of environment
     variables:

          BCC="!CMAKE"
          BCH="!CMAKE"
          BCMAK="!CMAKE"
          BCLNK="!CMAKE"

     The character, '!', is used to indicate that we would like to see
     warning messages, even when CMAKE and all the commands that CMAKE
     executes, are successful (i.e. return zero).

     Run BRIEF and edit a file with an extension for which you have
     created an environment variable.

     To execute CMAKE, use the compile buffer command (Alt-F10).

     After CMAKE is done, you will be placed at the source-file
     location of the first error (if there are any errors).  The error
     message will be displayed in the message area at the bottom of the
     screen.

     Use the next_error command (Ctrl-n) to view additional error
     messages.

     Use the next_error 1 command (Ctrl-p) to pop up the error window.
     From this window, you may select any error that you would like to
     review.

     The Error-Log File

     If an error is found during compilation, BRIEF will create an
     error-log file.  The error-log-file name will be derived from the
     edited-file name by replacing the extension with '.err'.  For
     example, if you were editing a file called, "c:\h\test.h", when
     you initiated a compile, and there are errors, BRIEF will create an
     error-log file called, "c:\h\test.err".

     The error-log file is a system buffer that you may not edit.

     If you exit BRIEF and then restart BRIEF, you may edit the error-
     log file and use the next_error and next_error 1 commands to view
     the errors from the earlier session.

     If no errors are found, BRIEF will not create an error-log file.

─────Running CMAKE from DOS and Viewing Error Messages with BRIEF───────────

     Create a batch file with the following commands:

          CMAKE >log.err
          B log.err -mnext_error

     Run the batch file from DOS.

     If there are any errors, you will be placed at the source-file
     location of the first error.  The error message will be displayed
     in the message area at the bottom of the screen.

     Use the next_error command (Ctrl-n) to view additional error
     messages.

     Use the next_error 1 command (Ctrl-p) to pop up the error window.
     From this window, you may select any error that you would like to
     review.

─────Running CMAKE in a Batch File from BRIEF───────────────────────────────

     Create a batch file, "run.bat", of the form:

          <batch commands>
          CMAKE >log.err
          <batch commands>

     Record the following keystroke macro:

          F7                             Remember
          F10 dos "run.bat"              Execute Command
          <press any key>                To return from DOS
          Alt-e "log.err"                edit_file
          Ctrl-p                         next_error 1
          Enter                          enter
          F10                            Remember

     This macro will execute the batch file, "run.bat", and load the
     log file, "log.err", into BRIEF.

     You may use Alt-F8 and Alt-F7 to save and load the macro,
     respectively.

     Use F8 to playback the macro.

     Use the next_error command (Ctrl-n) to view each error message.

     If the next_error command is included in the macro, you will be
     placed at the location of the first error (if there are any
     errors).  However, the message area will not show the message of
     the first error.  The message, "Playback successful", will overlay
     the error message.

─────Helpful Hints for BRIEF Users──────────────────────────────────────────

     Disk Swapping

     Viewing Previous Errors

     Modifying BRIEF

     Viewing the Error-Log File

─────Disk Swapping with BRIEF───────────────────────────────────────────────

     If you will be executing CMAKE from within BRIEF, you should use
     the flag, M, to enable disk swapping.  This will provide more
     memory for CMAKE and the programs that CMAKE executes.  This flag
     may be added to the BFLAGS environment variable.  For example:

          BFLAGS=-bi120k7l256Mru100za -mJPG -mrestore
                             ^

─────Viewing Previous Errors with BRIEF─────────────────────────────────────

     A macro consisting of the key strokes, (Ctrl-p UpArrow Enter),
     could be used to view the previous error.

─────Modifying BRIEF────────────────────────────────────────────────────────

     The BRIEF macro file, "errorfix.cb", controls the way in which
     BRIEF handles the error-log file.  You may change this macro to
     suit your needs.

     For example see: Viewing the Error-Log File

─────Viewing the Error-Log File with BRIEF──────────────────────────────────

     Most of the error messages that are listed in the error-log file
     will be of the form:

          file_name(line_number) : message

     When the file name in the error message does not begin with a
     drive letter, '/', or '\', BRIEF prefixes the path of the error-
     log file to the file name.  Because of this, if you use relative
     paths or no paths (vs. absolute paths) on your file names, you
     will have to place the error-log file in the directory from which
     you execute CMAKE.  If you would prefer to place the error file
     into another directory, make the following changes to the routine,
     "_error_info", in the BRIEF macro file, "errorfix.cb":

     1. Replace
                string  error_text;
        With
                string  error_text, curdir_string;

     2. Replace
                file_name = add_to_path (substr (base_name, 1, rindex
                base_name, substr (base_name, 3, 1)) - 1), error_file);
        With
                getwd("", curdir_string);
                file_name = add_to_path ( curdir_string , error_file );

     With this change in place, when the file name in the error message
     does not begin with a drive letter, '/', or '\', BRIEF will
     prefix the current directory to the file name.

─────Using CMAKE with Epsilon───────────────────────────────────────────────

     What is Epsilon?

     Running CMAKE from Epsilon

     Running CMAKE from DOS and Viewing Error Messages with Epsilon

     Running CMAKE in a Batch File from Epsilon

     Helpful Hints

─────What is Epsilon?───────────────────────────────────────────────────────

     Epsilon is a powerful programmer's editor that is available from
     Lugaru Software, Ltd.

─────Running CMAKE from Epsilon─────────────────────────────────────────────

     Execute CMAKE with the make command:

          (C-U) (C-X m) CMAKE

     After CMAKE is done, you will be placed at the source-file
     location of the first error message (if there are any errors).
     The error message will be displayed on the dialog line at the
     bottom of the screen.

     Use next_error (C-X C-N) to view additional error messages.

     To execute CMAKE again, use the make command (C-X m) (without any
     arguments).

     To establish CMAKE as your default make command for future Epsilon
     sessions, use the write_state command (C-F-3).  If you do this,
     the next time you execute Epsilon, you will be able to use the
     make command (C-X m) (without any arguments) to invoke CMAKE.

─────Running CMAKE from DOS and Viewing Error Messages with Epsilon─────────

     Record the following macro:

          C-X (                          start_kbd_macro
          C-X C-B process                select_buffer
          C-X C-V error.log              visit_file
          F-2 process_mode               named_command
          C-X C-N                        next_error
          C-X )                          end_kbd_macro

          C-X A-N view_log               name_kbd_macro
          C-F-3                          write_state

     Create a batch file with the following commands:

          CMAKE >error.log
          Epsilon -rview_log

     Run the batch file from DOS.

     If there are any errors, you will be placed at the source-file
     location of the first error.  The error message will be displayed
     on the dialog line at the bottom of the screen.

     Use next_error (C-X C-N) to view additional error messages.

─────Running CMAKE in a Batch File from Epsilon─────────────────────────────

     Create a batch file, "run.bat", of the form:

          <batch commands>
          CMAKE
          <batch commands>

     Execute the batch file, "run.bat", with the following make
     command:

          (C-U) (C-X m) run.bat

     After "run.bat" is done, you will be placed at the source-file
     location of the first error (if there are any errors).  The error
     message will be displayed on the dialog line at the bottom of the
     screen.

     Use next_error (C-X C-N) to view additional error messages.

     To execute CMAKE again, use the make command (C-X m) (without any
     arguments).

     To establish "run.bat" as your default make command for future
     Epsilon sessions, use the write_state command (C-F-3).  If you do
     this, the next time you execute Epsilon, you will be able to use
     the make command (C-X m) (without any arguments) to invoke
     "run.bat".

─────Helpful Hints for Epsilon Users────────────────────────────────────────

     Increasing Speed

     Viewing Previous Errors

     Clearing the Process Buffer

     Viewing the Error-Log File

─────Increasing Speed with Epsilon──────────────────────────────────────────

     If you will be executing CMAKE from within Epsilon, you should use
     the -fs option to instruct Epsilon to use a RAM drive path for
     swap files.  This flag may be added to the EPSILON environment
     variable.  For example:

          SET EPSILON=-fsd:\temp

─────Viewing Previous Errors with Epsilon───────────────────────────────────

     To view the previous error quickly, you may record the following
     macro:

          C-X (                          start_kbd_macro
          C-U -1 C-X C-N                 next_error
          C-X )                          end_kbd_macro

          C-X A-N previous_error         name_kbd_macro
          F-4 previous_error C-X C-P     bind_to_key
          C-F-3                          write_state

     This macro should be recorded after you have invoked CMAKE with
     the make command, and generated some errors.

─────Clearing the Epsilon Process Buffer────────────────────────────────────

     The variable, clear_process_buffer, is 0 by default.  To purge
     the process buffer before each make call, set this variable to a
     nonzero value.  You may do this with the following commands:

          F-8 clear_process_buffer 1     set_variable
          C-F-3                          write_state

     If you do not set the variable, clear_process_buffer, to a nonzero
     value, all error messages from all make calls will accumulate in
     your error log.

─────Viewing the Error-Log File with Epsilon────────────────────────────────

     Most of the error messages that are listed in the error-log file
     will be of the form:

          file_name(line_number) : message

     When the file name in the error message does not begin with a
     drive letter, '/', or '\', Epsilon prefixes the current directory
     to the file name.  Because of this, if you use relative paths or no
     paths (vs. absolute paths) on your file names, you should view the
     error-log file from the directory from which you executed CMAKE.

─────Using CMAKE with The Microsoft Editor──────────────────────────────────

     What is the Microsoft Editor?

     The TMP Environment Variable

     Running CMAKE from the Microsoft Editor

     Running CMAKE from DOS and Viewing Errors with the Microsoft Editor

     Running CMAKE in a Batch File from the Microsoft Editor

     Helpful Hints

─────What is the Microsoft Editor?──────────────────────────────────────────

     The Microsoft Editor is a programmer's editor that was distributed
     with the Microsoft C Optimizing Compiler Version 5.1 and the
     Microsoft Macro Assembler Version 5.1.  It consists of a single
     executable, M.EXE (and a supporting initialization file called,
     "tools.ini").  The Microsoft Editor is a powerful (and fast) tool
     that supports macros and extensions which may be coded in C.

─────The TMP Environment Variable for the Microsoft Editor──────────────────

     You should set the environment variable, TMP, to establish the
     location of the error-log file "m.msg".  (The error-log file used
     by the Microsoft Editor is always called, "m.msg".)

─────Running CMAKE from the Microsoft Editor────────────────────────────────

     First, you should add an appropriate set of commands of the form:

          extmake:[ext] CMAKE

     to the file, "tools.ini".  If you would like to able to execute
     CMAKE while you are editing a file that has one of the extensions:
     '.c', '.h', '.mak', '.lnk', or '.msg'; you could use the following
     set of commands in the your "tools.ini" file:

          extmake:c   CMAKE
          extmake:h   CMAKE
          extmake:mak CMAKE
          extmake:lnk CMAKE
          extmake:msg CMAKE

     Run the Microsoft Editor and edit a file with an extension for
     which you have added an "extmake" command to your "tools.ini"
     file.

     To execute CMAKE, use Arg Compile (Alt+A Shift+F3) or Argcompile
     (F5).

     After CMAKE is done, you will be placed at the source-file
     location of the first error (if there are any errors).  The error
     message will be displayed on the dialog line at the bottom of the
     screen.

     Use Compile (Shift+F3) to view additional error messages.

─────Running CMAKE from DOS and Viewing Errors with the Microsoft Editor────

     Create a batch file with the following commands:

          CMAKE >%TMP%\m.msg
          M %TMP%\m.msg

     Run the batch file from DOS.

     Use Compile (Shift+F3) (repeatedly) to view each error message.

     Note that if "/e compile" is added to the Microsoft Editor command
     line, you will be placed at the location of the first error (if
     there are any errors), but the error message will not appear on
     the dialog line.  The Microsoft copyright message will overlay the
     error message.

─────Running CMAKE in a Batch File from the Microsoft Editor────────────────

     Create a batch file, "run.bat", with the following commands:

          <batch commands>
          CMAKE >m.msg
          <batch commands>

     Define the following macro in your "tools.ini" file:

          run:=Arg "run.bat" Shell Arg "$TMP:m.msg" Setfile
          run:Alt+R

     This macro will execute the batch file, "run.bat", and load the
     log file, "m.msg", into the Microsoft Editor.

     Use Alt+R to playback the macro.

     Use Compile (Shift+F3) (repeatedly) to view each error message.

     You may use the following alternative macro, if you would like to
     avoid having to manually execute the first Compile command after
     executing the macro:

          run:=Arg Arg "dummy" Compile
               Arg "run.bat" Shell
               Arg "$TMP:m.msg" Setfile Compile

     where "dummy" is a file that does not exist.  (Remember that when
     you add this macro to the file, "tools.ini", the entire macro
     definition must be specified on one line.)  If this macro is used,
     you will be placed at the location of the first error (if there
     are any errors).  The sequence, Arg Arg "dummy" Compile, is used
     to reset the Microsoft Editor error message pointer to the
     "bottom" of the list, so that the final Compile in the "run" macro
     will bring us to the "top" of the error list.

─────Helpful Hints for Users of the Microsoft Editor────────────────────────

     Increasing Speed

     A Macro to Select the Error-Log File

     Viewing the Error-Log File

─────Increasing Speed with the Microsoft Editor─────────────────────────────

     To increase speed, set the TMP environment variable to a path on
     a RAM drive.

─────A Macro to Select the Error-Log File with the Microsoft Editor─────────

     The following macro may be used to select the error-log file,
     "m.msg":

          select_msg:=Arg "$TMP:m.msg" Setfile
          select_msg:Shift+F2

─────Viewing the Error-Log File with the Microsoft Editor───────────────────

     Most of the error messages that are listed in the error-log file
     will be of the form:

          file_name(line_number) : message

     When the file name in the error message does not begin with a
     drive letter, '/', or '\', the Microsoft Editor prefixes the
     current directory to the file name.  Because of this, if you use
     relative paths or no paths (vs. absolute paths) on your file
     names, you should view the error-log file from the directory from
     which you executed CMAKE.

─────Optimizing Performance─────────────────────────────────────────────────

     Overview

     Use the End-of-Includes Comment in Your Source Files

     Help CMAKE Find Include Files Quickly

     Have CMAKE Put "makefile.bat" on a RAM Drive

     Avoid Using the Verbose Output Format for CMAKE

     Redirect CMAKE Output to a File on a RAM Drive

     Do Not Have CMAKE Scan Include Files for Includes Unnecessarily

     Do Not Have CMAKE Check System-Include Dependencies Unnecessarily

     Help CMAKE Find Configuration Data Quickly

─────Overview of Optimization Techniques for CMAKE──────────────────────────

     There are a number of techniques that may be used to increase the
     speed of CMAKE.  Most of these techniques involve setting switches
     to ensure that CMAKE does not do more work than is necessary.

     The execution time that is provided by CMAKE may be used to help
     you determine how to achieve the best performance in a given
     situation.

─────Use the End-of-Includes Comment in Your Source Files───────────────────

     Place all include statements at the top of your source files.  The
     following comments should be placed within each source file, after
     the section that contains the include statements:

                 ┌────────────┬───────────────────────────┐
                 │ File Types │         Comment           │
                 ├────────────┼───────────────────────────┤
                 │ .c .h .rc  │ /* CMAKE - INCLUDE END */ │
                 │ .asm       │ ; CMAKE - INCLUDE END     │
                 └────────────┴───────────────────────────┘

     CMAKE stops processing a given source file when an appropriate
     "end-of-includes" comment is reached.  Note that for resource-
     script files ('.rc'), the comment should be placed after all
     include statements and resource-include statements (i.e.  ICON,
     BITMAP, CURSOR, FONT, or user-defined resource statements).

     For many applications, if these comments are used, the execution
     time for CMAKE will be reduced by 50%.

─────Help CMAKE Find Include Files Quickly──────────────────────────────────

     If all of your application's source files and include files are
     located in the directory from which you execute CMAKE, the include
     files will be found quickly.

     On the other hand, if you use the INCLUDE environment variable to
     specify the location of your application's include files, there
     will be a danger that CMAKE will waste time by first looking in
     the wrong directories too often before finally locating each
     include file.

     If you do not keep your include files in the source directory or
     current directory, add the following statements to your
     configuration file to insure that CMAKE will not search these
     directories for include files:

          search_current_dir_for_includes = no
          search_source_dir_for_includes = no

     For many applications, if you eliminate unnecessary searches of
     the source directory and current directory, the execution time for
     CMAKE will be reduced by 15%.

     You could also place all of your include files in a single
     directory, and list this directory first in your INCLUDE
     environment variable.  For many applications, if this technique is
     used, the execution time for CMAKE will be reduced by 50%.

     If you do not wish to place all of your application's include
     files into a single directory, you should arrange the directories
     in you INCLUDE environment variable so that the directories that
     contain most of your application's include files are listed first.
     Depending upon your situation, you might be able to save even
     more time by adding "set INCLUDE" statements to your make file in
     order to rearrange the directories "on the fly" in a way that is
     optimal for each module.

─────Have CMAKE Put "makefile.bat" on a RAM Drive───────────────────────────

     After analyzing your make file, CMAKE creates and executes the
     batch program, "makefile.bat".  You might wish to use the CMAKE
     command-line option, /o,  to instruct CMAKE to place the file,
     "makefile.bat", on a RAM drive path.  For example, if "d:\temp"
     is a path on a RAM drive, you could execute CMAKE with the
     following command:

     CMAKE /od:\temp

     Alternatively, if the environment variable, TEMP, is set to
     "d:\temp", you could use the following command in a batch file to
     execute CMAKE:

     CMAKE /o%TEMP%

     (In these examples, we have assumed that the make file is located
     in the current directory and is called, "makefile").

─────Avoid Using the Verbose Output Format for CMAKE────────────────────────

     The verbose output format (which is enabled with the /v option)
     is a useful debugging tool.  However, since it is quite detailed,
     the execution time for CMAKE might double when the verbose output
     format is selected.

─────Redirect CMAKE Output to a File on a RAM Drive─────────────────────────

     If you will be redirecting the output from CMAKE to a file, place
     that file on a RAM drive.  For example, if "d:\temp" is a path on
     a RAM drive, you could execute CMAKE with the following command:

     CMAKE >d:\temp\cmake.log

     Alternatively, if the environment variable, TEMP, is set to
     "d:\temp", you could use the following command in a batch file to
     execute CMAKE:

     CMAKE >%TEMP%\cmake.log

     (In these examples, we have assumed that the make file is located
     in the current directory and is called, "makefile".)

─────Do Not Have CMAKE Scan Include Files for Includes Unnecessarily────────

     By default, CMAKE does not scan include files for include
     statements.  This default behavior may be altered by adding the
     following statement to your configuration file:

          scan_include_files_for_includes = yes

     If you enable this switch, the execution time for CMAKE could
     quadruple!  You could reduce the impact of enabling this switch by
     using "end-of-includes" comments within your include files, or, if
     the use of include statements within include files is limited to
     only a few files, you could enable this switch as needed, by using
     the following statements in your make file:

          REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES ON
          REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES OFF

─────Do Not Have CMAKE Check System-Include Dependencies Unnecessarily──────

     By default, CMAKE ignores system-include statements.  If you
     modify system-include files, you will not want CMAKE to ignore
     these statements (at least not all of them).  To instruct CMAKE to
     check system-include file dependencies, you could add the
     following statements to your configuration file:

          c_include_<>_on = yes
          rc_include_<>_on = yes

     If you enable these switches, the execution time for CMAKE could
     double.  A more efficient approach would be to use the following
     comments in your source files, as needed:

              ┌────────────┬─────────────────────────────────┐
              │ File Types │            Comment              │
              ├────────────┼─────────────────────────────────┤
              │ .c .h .rc  │ /* CMAKE - INCLUDE <> ON/OFF */ │
              └────────────┴─────────────────────────────────┘

─────Help CMAKE Find Configuration Data Quickly─────────────────────────────

     If you place the configuration data for CMAKE at the end of a long
     file that is shared by other applications (e.g. "win.ini"), CMAKE
     will have to scan the entire file until it reaches the section
     tag, [CMAKE].  This could add a few seconds to the execution time
     for CMAKE.  To eliminate the time it takes CMAKE to locate its
     configuration data, put the data at the top of a shared file, or
     in its own file (e.g. "cmake.cfg").

─────CMAKE Exit Codes───────────────────────────────────────────────────────

     If an error occurs before the batch program, "makefile.bat", is
     executed, CMAKE will terminate and return one of the following
     exit codes:

     EXIT CODE  MEANING
     ──────────────────────────────────────────────────────────────────
          0     Success
       9659     CMAKE Command-Line Error
       9660     Unable to Load Configuration Data
       9661     Make File Not Found
       9662     Unable to Create "makefile.bat"
       9663     Unable to Create Predefined Pseudofile "start.psf"
       9664     Unable to Process some Make-File Command or Statement
       9665     A Token in the Make File was Truncated
       9666     Nested Comments were Found in the Make File
       9667     Out of Memory
       9668     Unable to Flush Standard-Output-File Buffer
       9669     Unable to Run "makefile.bat"
       9670     Unable to Run QH.EXE

     If the batch program, "makefile.bat", is executed and one of the
     commands in "makefile.bat" fails (i.e. returns a nonzero value),
     CMAKE will return the value that was returned by the command
     that failed.

─────Technical Support for CMAKE────────────────────────────────────────────

     You may contact the author of CMAKE (John Greschak) at

          [70744,1417] (CompuServe(R))

          212-947-1327 (Work/Home)

          50 West 34th St. Apt. 14B8
          NY, NY 10001

─────Samples────────────────────────────────────────────────────────────────

     Microsoft C Optimizing Compiler

     Microsoft Windows Software Development Kit

     Microsoft Macro Assembler

     The MS-DOS COPY Command

     The if Statement

     Command-Definition Statements

     Command-Equivalence Statements

     The Configuration File

─────Microsoft C Optimizing Compiler Sample─────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     This sample demonstrates how to use CMAKE to maintain a DOS
     application that is built with the programs: CL, LIB, and LINK.

     Note the Following:

     1. The commands (and comments) in the make file.  CMAKE will
        deduce all dependencies from these commands.

        See: When is a CL Command Required?
             When is a LIB Command Required?
             When is a LINK Command Required?

     2. The format of the LIB response file, "message.lrf".  CMAKE
        requires that a response file (of a particular form) be used
        with the LIB command.

        See: The LIB Command Line

     3. The format of the LINK response file, "greeting.lnk".  CMAKE
        requires that a response file (of a particular form) be used
        with the LINK command.

        See: The LINK Command Line

     4. The use and placement of the comment

        /* CMAKE - INCLUDE END */

        in the files, "hello.c", "world.c", and "greeting.c".

        In these files, this comment is placed after all #include
        statements.  Although this comment is not required in C-source
        files, it serves as an end-of-file mark for CMAKE, and thus
        prevents CMAKE from searching the entire source file for
        #include statements.

        See: Use the End-of-Includes Comment in Your Source Files
             Switches for CL
             How CMAKE Processes a C-Source File

─────Microsoft C Optimizing Compiler Sample─────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /*****************************************************************
     *                           MAKEFILE
     *
     *  PURPOSE: Build the following modules:
     *
     *           "hello.obj"  "message.lib"   "greeting.exe"
     *           "world.obj"  "greeting.obj"
     *
     *  NOTE: None of the comments in this make file are required.
     *        They have been provided to help you understand how CMAKE
     *        handles each command.  In other words, this make file
     *        could be reduced down to the following five commands:
     *
     *        cl /c /W4 hello.c
     *        cl /c /W4 world.c
     *        lib @message.lrf
     *        cl /c /W4 greeting.c
     *        link @greeting.lnk
     *
     *****************************************************************/

     /*****************************************************************
     *                           HELLO.OBJ
     *
     *  The following CL command will be executed only when one of the
     *  following conditions is true:
     *
     *  1. "hello.obj" does not exist.
     *  2. "hello.c" is newer than "hello.obj".
     *  3. "hello.h" is newer than "hello.obj".
     *
     *****************************************************************/

     cl /c /W4 hello.c

     /*****************************************************************
     *                           WORLD.OBJ
     *
     *  The following CL command will be executed only when one of the
     *  following conditions is true:
     *
     *  1. "world.obj" does not exist.
     *  2. "world.c" is newer than "world.obj".
     *  3. "world.h" is newer than "world.obj".
     *
     *****************************************************************/

     cl /c /W4 world.c

     /*****************************************************************
     *                          MESSAGE.LIB
     *
     *  The following LIB command will be executed only when one of the
     *  following conditions is true:
     *
     *  1. "message.lib" does not exist.
     *  2. "hello.obj" is newer than "message.lib".
     *  3. "world.obj" is newer than "message.lib".
     *
     *  Actually, only those objects that are newer than the library,
     *  "message.lib", will be added to the library.  For example,
     *  suppose "message.lib" exists, "hello.obj" is newer than
     *  "message.lib", and "world.obj" is older than "message.lib".
     *  In this case, only "hello.obj" must be added to the library,
     *  "message.lib".  Thus, in this case, CMAKE would execute the
     *  following command:
     *
     *  lib @message.clb
     *
     *  where "message.clb" consists of the following lines:
     *
     *  message.lib
     *  -+hello.obj ;
     *
     *****************************************************************/

     lib @message.lrf

     /*****************************************************************
     *                         GREETING.OBJ
     *
     *  The following CL command will be executed only when one of the
     *  following conditions is true:
     *
     *  1. "greeting.obj" does not exist.
     *  2. "greeting.c" is newer than "greeting.obj".
     *  3. "hello.h" is newer than "greeting.obj".
     *  4. "world.h" is newer than "greeting.obj".
     *  5. "greeting.h" is newer than "greeting.obj".
     *
     *****************************************************************/

     cl /c /W4 greeting.c

     /*****************************************************************
     *                         GREETING.EXE
     *
     *  The following LINK command will be executed only when one of
     *  the following conditions is true:
     *
     *  1. "greeting.exe" does not exist.
     *  2. "greeting.obj" is newer than "greeting.exe".
     *  3. "message.lib" is newer than "greeting.exe".
     *
     *****************************************************************/

     link @greeting.lnk

─────Microsoft C Optimizing Compiler Sample─────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* greeting.c - Program to print "Hello World" */

     #include "hello.h"
     #include "world.h"
     #include "greeting.h"
     /* CMAKE - INCLUDE END */

     int main ( void )

     {
     print_hello ( ) ;

     print_world ( ) ;

     return ( 0 ) ;
     }

─────Microsoft C Optimizing Compiler Sample─────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* greeting.h - Header file for greeting.c */

     int main ( void ) ;

─────Microsoft C Optimizing Compiler Sample─────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* hello.c - Function to print "Hello" */

     #include <stdio.h>
     #include "hello.h"
     /* CMAKE - INCLUDE END */

     void print_hello ( void )

     {
     printf ( "Hello\n" ) ;
     }

─────Microsoft C Optimizing Compiler Sample─────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* hello.h - Header file for hello.c */

     void print_hello ( void ) ;

─────Microsoft C Optimizing Compiler Sample─────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* world.c - Function to print "World" */

     #include <stdio.h>
     #include "world.h"
     /* CMAKE - INCLUDE END */

     void print_world ( void )

     {
     printf ( "World\n" ) ;
     }

─────Microsoft C Optimizing Compiler Sample─────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* world.h - Header file for world.c */

     void print_world ( void ) ;

─────Microsoft C Optimizing Compiler Sample─────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     message.lib
     y
     -+hello.obj &
     -+world.obj ;

─────Microsoft C Optimizing Compiler Sample─────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     greeting.obj
     greeting.exe /stack:2048
     NUL
     message.lib ;

─────Microsoft Windows Software Development Kit Sample──────────────────────

     readme.txt  hw.c  hw.rc   hw.ico  hw.lnk
     makefile    hw.h  hw.dlg  hw.def

     This sample demonstrates how to use CMAKE to maintain a Microsoft
     Windows application that is built with the programs: CL, RC, and
     LINK.

     Note the Following:

     1. The commands (and comments) in the make file.  CMAKE will
        deduce all dependencies from these commands.

        See: When is a CL Command Required?
             When is an RC/C Command Required?
             When is an RC/A Command Required?
             When is a LINK Command Required?

     2. The format of the LINK response file, "hw.lnk".  CMAKE requires
        that a response file (of a particular form) be used with the
        LINK command.

        See: The LINK Command Line

        Since CMAKE does not use the LIB environment variable, the
        paths of the Windows libraries, "libw.lib" and "slibcew.lib"
        must be provided.

     3. The use and placement of the comment

        /* CMAKE - INCLUDE END */

        in the files, "hw.c" and "hw.rc".

        In the file, "hw.c", this comment is placed after all #include
        statements.  Although this comment is not required in C-source
        files, it serves as an end-of-file mark for CMAKE, and thus
        prevents CMAKE from searching the entire source file for
        #include statements.

        See: Use the End-of-Includes Comment in Your Source Files
             Switches for CL
             How CMAKE Processes a C-Source File

        In the file, "hw.rc", this comment is placed after all #include
        statements and resource-include statements (i.e. ICON, BITMAP,
        CURSOR, FONT, or user-defined resource statements).  This
        comment is required in this file.

        See: Helpful Hints for RC/C
             Switches for RC/C
             How CMAKE Processes a Resource-Script File
             Use the End-of-Includes Comment in Your Source Files

─────Microsoft Windows Software Development Kit Sample──────────────────────

     readme.txt  hw.c  hw.rc   hw.ico  hw.lnk
     makefile    hw.h  hw.dlg  hw.def

     /*****************************************************************
     *                           MAKEFILE
     *
     *  PURPOSE: Build the following modules:
     *
     *           "hw.res"  "hw.exe"
     *           "hw.obj"
     *
     *  NOTE: None of the comments in this make file are required.
     *        They have been provided to help you understand how CMAKE
     *        handles each command.  In other words, this make file
     *        could be reduced down to the following four commands:
     *
     *        rc /r hw.rc
     *        cl /c /AS /Gsw /Oas /Zpe hw.c
     *        link @hw.lnk
     *        rc hw.res
     *
     *****************************************************************/

     /*****************************************************************
     *                            HW.RES
     *
     *  The following RC compile command will be executed only when one
     *  of the following conditions is true:
     *
     *  1. "hw.res" does not exist.
     *  2. "hw.rc" is newer than "hw.res".
     *  3. "hw.h" is newer than "hw.res".
     *  4. "hw.ico" is newer than "hw.res".
     *  5. "hw.dlg" is newer than "hw.res".
     *
     *****************************************************************/

     rc /r hw.rc

     /*****************************************************************
     *                            HW.OBJ
     *
     *  The following CL command will be executed only when one of the
     *  following conditions is true:
     *
     *  1. "hw.obj" does not exist.
     *  2. "hw.c" is newer than "hw.obj".
     *  3. "hw.h" is newer than "hw.obj".
     *
     *****************************************************************/

     cl /c /AS /Gsw /Oas /Zpe hw.c

     /*****************************************************************
     *                            HW.EXE
     *
     *  The following LINK command will be executed only when one of
     *  the following conditions is true:
     *
     *  1. "hw.exe" does not exist.
     *  2. "hw.obj" is newer than "hw.exe".
     *  3. "c:\windev\lib\libw.lib" is newer than "hw.exe".
     *  4. "c:\windev\lib\slibcew.lib" is newer than "hw.exe".
     *  5. "hw.def" is newer than "hw.exe".
     *
     *****************************************************************/

     link @hw.lnk

     /*****************************************************************
     *                     ADD HW.RES TO HW.EXE
     *
     *  The following RC command (used to add the resource file,
     *  "hw.res", to the executable file, "hw.exe") will be executed
     *  only when one of the following conditions is true:
     *
     *  1. The previous RC command used to build, "hw.res", was
     *     executed.
     *  2. The previous LINK command used to build, "hw.exe", was
     *     executed.
     *
     *****************************************************************/

     rc hw.res

─────Microsoft Windows Software Development Kit Sample──────────────────────

     readme.txt  hw.c  hw.rc   hw.ico  hw.lnk
     makefile    hw.h  hw.dlg  hw.def

     /* hw.c - Microsoft Windows program with "Hello World" icon */

     #include <windows.h>
     #include "hw.h"
     /* CMAKE - INCLUDE END */

     HANDLE hInst ;

     int PASCAL WinMain ( HANDLE hInstance     ,
                          HANDLE hPrevInstance ,
                          LPSTR  lpCmdLine     ,
                          int    nCmdShow        )

     {
     WNDCLASS wc      ;
     HWND     hWnd    ;
     MSG      message ;

     if ( ! hPrevInstance )

        {
        wc.style = NULL ;

        wc.lpfnWndProc = MainWndProc ;

        wc.cbClsExtra = 0 ;

        wc.cbWndExtra = 0 ;

        wc.hInstance = hInstance ;

        wc.hIcon = LoadIcon ( hInstance    ,
                              "HelloWorld"   ) ;

        wc.hCursor = LoadCursor ( NULL      ,
                                  IDC_ARROW   ) ;

        wc.hbrBackground = GetStockObject ( WHITE_BRUSH ) ;

        wc.lpszMenuName =  "HWMenu" ;

        wc.lpszClassName = "HWWClass" ;

        if ( ! ( RegisterClass ( & wc ) ) )

           {
           return ( FALSE ) ;
           }
        }

     hInst = hInstance ;

     if ( ! ( hWnd = CreateWindow ( "HWWClass"           ,
                                    "Sample Program"     ,
                                    WS_OVERLAPPEDWINDOW  ,
                                    CW_USEDEFAULT        ,
                                    CW_USEDEFAULT        ,
                                    CW_USEDEFAULT        ,
                                    CW_USEDEFAULT        ,
                                    NULL                 ,
                                    NULL                 ,
                                    hInstance            ,
                                    NULL                   ) ) )

        {
        return ( FALSE ) ;
        }

     else

        {
        ShowWindow ( hWnd     ,
                     nCmdShow   ) ;

        UpdateWindow ( hWnd ) ;
        }

     while ( GetMessage ( & message ,
                          NULL      ,
                          NULL      ,
                          NULL        ) )
           {
           TranslateMessage ( & message ) ;

           DispatchMessage ( & message ) ;
           }

     return ( message
                .wParam ) ;
     }


     long FAR PASCAL MainWndProc ( HWND     hWnd    ,
                                   unsigned message ,
                                   WORD     wParam  ,
                                   LONG     lParam    )

     {
     FARPROC lpProcAbout ;

     switch ( message )

            {
            case WM_COMMAND :

                 if (    wParam
                      == IDM_ABOUT )

                    {
                    lpProcAbout = MakeProcInstance ( About ,
                                                     hInst   ) ;

                    DialogBox ( hInst       ,
                                "AboutBox"  ,
                                hWnd        ,
                                lpProcAbout   ) ;

                     FreeProcInstance ( lpProcAbout ) ;

                     break ;
                     }

                 else

                     {
                     return ( DefWindowProc ( hWnd    ,
                                              message ,
                                              wParam  ,
                                              lParam    ) ) ;
                     }

            case WM_DESTROY :

                 PostQuitMessage ( 0 ) ;

                 break ;

            default :

                 return ( DefWindowProc ( hWnd    ,
                                          message ,
                                          wParam  ,
                                          lParam    ) ) ;

                 break ;
            }

     return ( NULL ) ;
     }


     BOOL FAR PASCAL About ( HWND     hDlg    ,
                             unsigned message ,
                             WORD     wParam  ,
                             LONG     lParam    )

     {
     switch ( message )

            {
            case WM_INITDIALOG :

                 return ( TRUE ) ;

            case WM_COMMAND :

                 if (    (    wParam
                           == IDOK   )
                      || (    wParam
                           == IDCANCEL ) )

                    {
                    EndDialog ( hDlg ,
                                TRUE   ) ;

                    return ( TRUE ) ;
                    }

                 break ;
            }

     return ( FALSE ) ;
     }

─────Microsoft Windows Software Development Kit Sample──────────────────────

     readme.txt  hw.c  hw.rc   hw.ico  hw.lnk
     makefile    hw.h  hw.dlg  hw.def

     /* hw.h - Header file for hw.c */

     #define IDM_ABOUT 100

     int PASCAL WinMain ( HANDLE ,
                          HANDLE ,
                          LPSTR  ,
                          int      ) ;

     long FAR PASCAL MainWndProc ( HWND     ,
                                   unsigned ,
                                   WORD     ,
                                   LONG       ) ;

     BOOL FAR PASCAL About ( HWND     ,
                             unsigned ,
                             WORD     ,
                             LONG       ) ;

─────Microsoft Windows Software Development Kit Sample──────────────────────

     readme.txt  hw.c  hw.rc   hw.ico  hw.lnk
     makefile    hw.h  hw.dlg  hw.def

     /* hw.rc - Resource-script file for hw.exe */

     #include <windows.h>
     #include "hw.h"

     HelloWorld ICON hw.ico

     #include "hw.dlg"
     /* CMAKE - INCLUDE END */

     HWMenu MENU
     BEGIN
         POPUP        "&Help"
         BEGIN
             MENUITEM "&About...", IDM_ABOUT
         END
     END

─────Microsoft Windows Software Development Kit Sample──────────────────────

     readme.txt  hw.c  hw.rc   hw.ico  hw.lnk
     makefile    hw.h  hw.dlg  hw.def

     /* hw.dlg - "About" dialog box */

     ABOUTBOX DIALOG LOADONCALL
                     MOVEABLE
                     DISCARDABLE
                     23  ,
                     18  ,
                     144 ,
                     45

     CAPTION "About"

     STYLE   WS_BORDER
           | WS_CAPTION
           | WS_DLGFRAME
           | WS_SYSMENU
           | DS_MODALFRAME
           | WS_POPUP

     BEGIN

         CONTROL "Sample Program" ,
                 -1               ,
                 "static"         ,
                   SS_CENTER
                 | WS_GROUP
                 | WS_CHILD       ,
                 17               ,
                 7                ,
                 122              ,
                 8

         CONTROL "OK"               ,
                 1                  ,
                 "button"           ,
                   BS_DEFPUSHBUTTON
                 | WS_GROUP
                 | WS_TABSTOP
                 | WS_CHILD         ,
                 61                 ,
                 22                 ,
                 32                 ,
                 14

         CONTROL "HelloWorld" ,
                 -1           ,
                 "static"     ,
                   SS_ICON
                 | WS_CHILD   ,
                 19           ,
                 12           ,
                 16           ,
                 21

     END

─────Microsoft Windows Software Development Kit Sample──────────────────────

     readme.txt  hw.c  hw.rc   hw.ico  hw.lnk
     makefile    hw.h  hw.dlg  hw.def

     "hw.ico" is the icon file for the "Hello World" icon.

─────Microsoft Windows Software Development Kit Sample──────────────────────

     readme.txt  hw.c  hw.rc   hw.ico  hw.lnk
     makefile    hw.h  hw.dlg  hw.def

     ; hw.def - Module-definition file for hw.exe

     NAME         HelloWorld

     DESCRIPTION  'Sample Program'

     EXETYPE      WINDOWS

     STUB         'WINSTUB.EXE'

     CODE         PRELOAD MOVEABLE DISCARDABLE
     DATA         PRELOAD MOVEABLE MULTIPLE

     HEAPSIZE     1024
     STACKSIZE    5120

     EXPORTS
                  MainWndProc @1
                  About       @2

─────Microsoft Windows Software Development Kit Sample──────────────────────

     readme.txt  hw.c  hw.rc   hw.ico  hw.lnk
     makefile    hw.h  hw.dlg  hw.def

     hw.obj
     hw.exe /nod
     NUL
     c:\windev\lib\libw.lib    +
     c:\windev\lib\slibcew.lib
     hw.def ;

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     This sample demonstrates how to use CMAKE to maintain a DOS
     application that is built with the programs: MASM, CL, LIB, and
     LINK.

     Note the Following:

     1. The commands (and comments) in the make file.  CMAKE will
        deduce all dependencies from these commands.

        See: When is a MASM Command Required?
             When is a CL Command Required?
             When is a LIB Command Required?
             When is a LINK Command Required?

     2. The format of the LIB response file, "message.lrf".  CMAKE
        requires that a response file (of a particular form) be used
        with the LIB command.

        See: The LIB Command Line

     3. The format of the LINK response file, "greeting.lnk".  CMAKE
        requires that a response file (of a particular form) be used
        with the LINK command.

        See: The LINK Command Line

     4. The use and placement of the comment

        ; CMAKE - INCLUDE END

        in the files, "a_hello.asm" and "a_world.asm".

        In these files, this comment is placed after all include
        statements.  Although this comment is not required in assembly-
        language-source files, it serves as an end-of-file mark for
        CMAKE, and thus prevents CMAKE from searching the entire source
        file for include statements.

        See: Use the End-of-Includes Comment in Your Source Files
             Switches for MASM
             How CMAKE Processes an Assembly-Language-Source File

     5. The use and placement of the comment

        /* CMAKE - INCLUDE END */

        in the files, "hello.c", "world.c", and "greeting.c".

        In these files, this comment is placed after all #include
        statements.  Although this comment is not required in C-source
        files, it serves as an end-of-file mark for CMAKE, and thus
        prevents CMAKE from searching the entire source file for
        #include statements.

        See: Use the End-of-Includes Comment in Your Source Files
             Switches for CL
             How CMAKE Processes a C-Source File

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     /*****************************************************************
     *                           MAKEFILE
     *
     *  PURPOSE: Build the following modules:
     *
     *           "a_hello.obj" "hello.obj" "message.lib" "greeting.exe"
     *           "a_world.obj" "world.obj" "greeting.obj"
     *
     *  NOTE: None of the comments in this make file are required.
     *        They have been provided to help you understand how CMAKE
     *        handles each command.  In other words, this make file
     *        could be reduced down to the following seven commands:
     *
     *        masm /W2 /V /Z a_hello.asm,a_hello.obj;
     *        masm /W2 /V /Z a_world.asm,a_world.obj;
     *        cl /c /W4 hello.c
     *        cl /c /W4 world.c
     *        lib @message.lrf
     *        cl /c /W4 greeting.c
     *        link @greeting.lnk
     *
     *****************************************************************/

     /*****************************************************************
     *                          A_HELLO.OBJ
     *
     *  The following MASM command will be executed only when one of
     *  the following conditions is true:
     *
     *  1. "a_hello.obj" does not exist.
     *  2. "a_hello.asm" is newer than "a_hello.obj".
     *  3. "hello.inc" is newer than "a_hello.obj".
     *
     *****************************************************************/

     masm /W2 /V /Z a_hello.asm,a_hello.obj;

     /*****************************************************************
     *                          A_WORLD.OBJ
     *
     *  The following MASM command will be executed only when one of
     *  the following conditions is true:
     *
     *  1. "a_world.obj" does not exist.
     *  2. "a_world.asm" is newer than "a_world.obj".
     *  3. "world.inc" is newer than "a_world.obj".
     *
     *****************************************************************/

     masm /W2 /V /Z a_world.asm,a_world.obj;

     /*****************************************************************
     *                           HELLO.OBJ
     *
     *  The following CL command will be executed only when one of the
     *  following conditions is true:
     *
     *  1. "hello.obj" does not exist.
     *  2. "hello.c" is newer than "hello.obj".
     *  3. "hello.h" is newer than "hello.obj".
     *
     *****************************************************************/

     cl /c /W4 hello.c

     /*****************************************************************
     *                           WORLD.OBJ
     *
     *  The following CL command will be executed only when one of the
     *  following conditions is true:
     *
     *  1. "world.obj" does not exist.
     *  2. "world.c" is newer than "world.obj".
     *  3. "world.h" is newer than "world.obj".
     *
     *****************************************************************/

     cl /c /W4 world.c

     /*****************************************************************
     *                          MESSAGE.LIB
     *
     *  The following LIB command will be executed only when one of the
     *  following conditions is true:
     *
     *  1. "message.lib" does not exist.
     *  2. "a_hello.obj" is newer than "message.lib".
     *  3. "a_world.obj" is newer than "message.lib".
     *  4. "hello.obj" is newer than "message.lib".
     *  5. "world.obj" is newer than "message.lib".
     *
     *  Actually, only those objects that are newer than the library,
     *  "message.lib", will be added to the library.  For example,
     *  suppose "message.lib" exists, "a_hello.obj" is newer than
     *  "message.lib", and "message.lib" is newer than "a_world.obj",
     *  "hello.obj", and "world.obj".  In this case, only "a_hello.obj"
     *  must be added to the library, "message.lib".  Thus, in this
     *  case, CMAKE would execute the following command:
     *
     *  lib @message.clb
     *
     *  where "message.clb" consists of the following lines:
     *
     *  message.lib
     *  -+a_hello.obj ;
     *
     *****************************************************************/

     lib @message.lrf

     /*****************************************************************
     *                         GREETING.OBJ
     *
     *  The following CL command will be executed only when one of the
     *  following conditions is true:
     *
     *  1. "greeting.obj" does not exist.
     *  2. "greeting.c" is newer than "greeting.obj".
     *  3. "a_hello.h" is newer than "greeting.obj".
     *  4. "a_world.h" is newer than "greeting.obj".
     *  5. "greeting.h" is newer than "greeting.obj".
     *
     *****************************************************************/

     cl /c /W4 greeting.c

     /*****************************************************************
     *                         GREETING.EXE
     *
     *  The following LINK command will be executed only when one of
     *  the following conditions is true:
     *
     *  1. "greeting.exe" does not exist.
     *  2. "greeting.obj" is newer than "greeting.exe".
     *  3. "message.lib" is newer than "greeting.exe".
     *
     *****************************************************************/

     link @greeting.lnk

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     /* greeting.c - Program to print "Hello World" */

     #include "a_hello.h"
     #include "a_world.h"
     #include "greeting.h"
     /* CMAKE - INCLUDE END */

     int main ( void )

     {
     a_print_hello ( ) ;

     a_print_world ( ) ;

     return ( 0 ) ;
     }

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     /* greeting.h - Header file for greeting.c */

     int main ( void ) ;

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     ; a_hello.asm - Function to call C function to print "Hello"

     TITLE  hello.asm
     DOSSEG
     .MODEL SMALL,C

     .CODE

     include hello.inc
     ; CMAKE - INCLUDE END

     a_print_hello PROC
       call print_hello
       ret
     a_print_hello ENDP

     END

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     /* a_hello.h - Header file for a_hello.asm */

     void a_print_hello ( void ) ;

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     ; a_world.asm - Function to call C function to print "World"

     TITLE  world.asm
     DOSSEG
     .MODEL SMALL,C

     .CODE

     include world.inc
     ; CMAKE - INCLUDE END

     a_print_world PROC
       call print_world
       ret
     a_print_world ENDP

     END

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     /* a_world.h - Header file for a_world.asm */

     void a_print_world ( void ) ;

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     /* hello.c - Function to print "Hello" */

     #include <stdio.h>
     #include "hello.h"
     /* CMAKE - INCLUDE END */

     void print_hello ( void )

     {
     printf ( "Hello\n" ) ;
     }

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     /* hello.h - Header file for hello.c */

     void print_hello ( void ) ;

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     ; hello.inc - Include file for hello.c

     EXTRN C print_hello : PROC

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     /* world.c - Function to print "World" */

     #include <stdio.h>
     #include "world.h"
     /* CMAKE - INCLUDE END */

     void print_world ( void )

     {
     printf ( "World\n" ) ;
     }

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     /* world.h - Header file for world.c */

     void print_world ( void ) ;

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     ; world.inc - Include file for world.c

     EXTRN C print_world : PROC

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     message.lib
     y
     -+a_hello.obj &
     -+a_world.obj &
     -+hello.obj   &
     -+world.obj   ;

─────Microsoft Macro Assembler Sample───────────────────────────────────────

     readme.txt  a_hello.asm  hello.c    world.c    message.lrf
     makefile    a_hello.h    hello.h    world.h    greeting.lnk
     greeting.c  a_world.asm  hello.inc  world.inc
     greeting.h  a_world.h

     greeting.obj
     greeting.exe /stack:2048
     NUL
     message.lib ;

─────COPY Command Sample────────────────────────────────────────────────────

     readme.txt  src\1.src  src\more\3.src
     makefile    src\2.src

     This sample demonstrates how CMAKE handles the COPY command.

     Note the Following:

     1. The commands (and comments) in the make file.  CMAKE will
        deduce all dependencies from these commands.

        See: COPY

─────COPY Command Sample────────────────────────────────────────────────────

     readme.txt  src\1.src  src\more\3.src
     makefile    src\2.src

     /*****************************************************************
     *                           MAKEFILE
     *
     *  PURPOSE: Copy some files.
     *
     *  NOTE: None of the comments in this make file are required.
     *        They have been provided to help you understand how CMAKE
     *        handles each command.  In other words, this make file
     *        could be reduced down to the following four commands:
     *
     *        copy src\1.src trg\1.trg
     *        copy src\more\3.src trg
     *        copy src trg\12.trg
     *        copy src trg
     *
     *****************************************************************/

     /*****************************************************************
     *                       COPY FILE TO FILE
     *
     *  The following COPY command will be executed only when one of
     *  the following conditions is true:
     *
     *  1. "trg\1.trg" does not exist.
     *  2. "src\1.src" is newer than "trg\1.trg".
     *
     *****************************************************************/

     copy src\1.src trg\1.trg

     /*****************************************************************
     *                    COPY FILE TO DIRECTORY
     *
     *  The following COPY command will be executed only when one of
     *  the following conditions is true:
     *
     *  1. "trg\3.src" does not exist.
     *  2. "src\more\3.src" is newer than "trg\3.src".
     *
     *****************************************************************/

     copy src\more\3.src trg

     /*****************************************************************
     *                     COPY DIRECTORY TO FILE
     *
     *  The following COPY command will always be executed.
     *
     *****************************************************************/

     copy src trg\12.trg

     /*****************************************************************
     *                  COPY DIRECTORY TO DIRECTORY
     *
     *  The COPY command:
     *
     *       copy src\1.src trg\1.src
     *
     *  will be executed only when one of the following conditions is
     *  true:
     *
     *       1. "trg\1.src" does not exist.
     *       2. "src\1.src" is newer than "trg\1.src".
     *
     *  The COPY command:
     *
     *       copy src\2.src trg\2.src
     *
     *  will be executed only when one of the following conditions is
     *  true:
     *
     *       1. "trg\2.src" does not exist.
     *       2. "src\2.src" is newer than "trg\2.src".
     *
     *****************************************************************/

     copy src trg

─────COPY Command Sample────────────────────────────────────────────────────

     readme.txt  src\1.src  src\more\3.src
     makefile    src\2.src

     src\1.src - Sample source file number 1

─────COPY Command Sample────────────────────────────────────────────────────

     readme.txt  src\1.src  src\more\3.src
     makefile    src\2.src

     src\2.src - Sample source file number 2

─────COPY Command Sample────────────────────────────────────────────────────

     readme.txt  src\1.src  src\more\3.src
     makefile    src\2.src

     src\more\3.src - Sample source file number 3

─────if Statement Sample────────────────────────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     This sample demonstrates how to use if statements in a make file.

     Note the Following:

     1. The if statements (and comments) in the make file.

        See: The if Statement

─────if Statement Sample────────────────────────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /*****************************************************************
     *                           MAKEFILE
     *
     *  PURPOSE: Build the following modules:
     *
     *           "hello.obj"  "message.lib"   "greeting.exe"
     *           "world.obj"  "greeting.obj"
     *
     *  NOTE: Since CMAKE automatically determines the dependencies
     *        for CL, LIB, and LINK, you would not ordinarily use an
     *        if statement to explicitly specify dependencies for these
     *        commands.  The if statement has been used in this make
     *        file for demonstration purposes, only.
     *
     *        None of the comments in this make file are required.
     *        They have been provided to help you understand how CMAKE
     *        handles each command.
     *
     *****************************************************************/

     /*****************************************************************
     *                           HELLO.OBJ
     *
     *  The following CL and LIB commands will be executed only when
     *  one of the following conditions is true:
     *
     *  1. "hello.obj" does not exist.
     *  2. "message.lib" does not exist.
     *  3. "hello.c" is newer than "hello.obj".
     *  5. "hello.c" is newer than "message.lib".
     *  4. "hello.h" is newer than "hello.obj".
     *  6. "hello.h" is newer than "message.lib".
     *
     *****************************************************************/

     if ( hello.obj
          message.lib < hello.c
                        hello.h )

        {
        cl /c /W4 hello.c

        lib message.lib -+hello.obj;
        }

     /*****************************************************************
     *                           WORLD.OBJ
     *
     *  The following CL and LIB commands will be executed only when
     *  one of the following conditions is true:
     *
     *  1. "world.obj" does not exist.
     *  2. "message.lib" does not exist.
     *  3. "world.c" is newer than "world.obj".
     *  5. "world.c" is newer than "message.lib".
     *  4. "world.h" is newer than "world.obj".
     *  6. "world.h" is newer than "message.lib".
     *
     *****************************************************************/

     if ( world.obj message.lib < world.c world.h )

        {
        cl /c /W4 world.c

        lib message.lib -+world.obj;
        }

     /*****************************************************************
     *                         GREETING.OBJ
     *
     *  The following CL command will be executed only when one of the
     *  following conditions is true:
     *
     *  1. "greeting.obj" does not exist.
     *  2. "greeting.c" is newer than "greeting.obj".
     *  3. "hello.h" is newer than "greeting.obj".
     *  4. "world.h" is newer than "greeting.obj".
     *  5. "greeting.h" is newer than "greeting.obj".
     *
     *****************************************************************/

     if (   greeting.obj
          < greeting.c
            hello.h
            world.h
            greeting.h )

        cl /c /W4 greeting.c

     /*****************************************************************
     *                         GREETING.EXE
     *
     *  The following LINK command will be executed only when one of
     *  the following conditions is true:
     *
     *  1. "greeting.exe" does not exist.
     *  2. "greeting.obj" is newer than "greeting.exe".
     *  3. "message.lib" is newer than "greeting.exe".
     *
     *****************************************************************/

     if ( greeting.exe < greeting.obj message.lib )

        link @greeting.lnk

─────if Statement Sample────────────────────────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* greeting.c - Program to print "Hello World" */

     #include "hello.h"
     #include "world.h"
     #include "greeting.h"

     int main ( void )

     {
     print_hello ( ) ;

     print_world ( ) ;

     return ( 0 ) ;
     }

─────if Statement Sample────────────────────────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* greeting.h - Header file for greeting.c */

     int main ( void ) ;

─────if Statement Sample────────────────────────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* hello.c - Function to print "Hello" */

     #include <stdio.h>
     #include "hello.h"

     void print_hello ( void )

     {
     printf ( "Hello\n" ) ;
     }

─────if Statement Sample────────────────────────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* hello.h - Header file for hello.c */

     void print_hello ( void ) ;

─────if Statement Sample────────────────────────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* world.c - Function to print "World" */

     #include <stdio.h>
     #include "world.h"

     void print_world ( void )

     {
     printf ( "World\n" ) ;
     }

─────if Statement Sample────────────────────────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     /* world.h - Header file for world.c */

     void print_world ( void ) ;

─────if Statement Sample────────────────────────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     message.lib
     y
     -+hello.obj &
     -+world.obj ;

─────if Statement Sample────────────────────────────────────────────────────

     readme.txt  greeting.c  hello.c  world.c  message.lrf
     makefile    greeting.h  hello.h  world.h  greeting.lnk

     greeting.obj
     greeting.exe /stack:2048
     NUL
     message.lib ;

─────Command-Definition Statement Sample────────────────────────────────────

     readme.txt  sortsum.bat  source1.txt
     makefile    cmake.cfg    source2.txt

     This sample demonstrates how to add a new command to CMAKE's
     vocabulary through the use of a command-definition statement in
     the configuration file, "cmake.cfg".

     Note the Following:

     1. The commands (and comments) in the make file.  CMAKE will
        deduce all dependencies from these commands.

        See: When is a User-Defined Command Required?

     2. The command-definition statement and section tag, [CMAKE], in
        the configuration file, "cmake.cfg".

        See: Command-Definition Statements
             The CMAKE Section Tag in the Configuration File

─────Command-Definition Statement Sample────────────────────────────────────

     readme.txt  sortsum.bat  source1.txt
     makefile    cmake.cfg    source2.txt

     /*****************************************************************
     *                           MAKEFILE
     *
     *  PURPOSE: Concatenate the text files, "source1.txt" and
     *           "source2.txt", and sort the resulting file,
     *           "target.txt".
     *
     *  NOTE: None of the comments in this make file are required.
     *        They have been provided to help you understand how CMAKE
     *        handles each command.  In other words, this make file
     *        could be reduced down to the following command:
     *
     *        sortsum source1.txt source2.txt target.txt
     *
     *****************************************************************/

     /*****************************************************************
     *                          TARGET.TXT
     *
     *  The following SORTSUM command will be executed only when one of
     *  the following conditions is true:
     *
     *  1. "target.txt" does not exist.
     *  2. "source1.txt" is newer than "target.txt".
     *  3. "source2.txt" is newer than "target.txt".
     *
     *****************************************************************/

     sortsum source1.txt source2.txt target.txt

─────Command-Definition Statement Sample────────────────────────────────────

     readme.txt  sortsum.bat  source1.txt
     makefile    cmake.cfg    source2.txt

     rem sortsum.bat - Batch program to combine two text files and
     rem               sort the result
     type %1 >temp
     type %2 >>temp
     sort <temp >%3
     erase temp

─────Command-Definition Statement Sample────────────────────────────────────

     readme.txt  sortsum.bat  source1.txt
     makefile    cmake.cfg    source2.txt

     ; cmake.cfg - CMAKE configuration file

     [CMAKE]
     command_definition : sortsum sp[%s %s %t]

─────Command-Definition Statement Sample────────────────────────────────────

     readme.txt  sortsum.bat  source1.txt
     makefile    cmake.cfg    source2.txt

     a
     c
     e
     b
     d

─────Command-Definition Statement Sample────────────────────────────────────

     readme.txt  sortsum.bat  source1.txt
     makefile    cmake.cfg    source2.txt

     h
     f
     g
     i
     k
     j

─────Command-Equivalence Statement Sample───────────────────────────────────

     readme.txt  cmake.cfg
     makefile    1.txt

     This sample demonstrates how to add a new command to CMAKE's
     vocabulary through the use of a command-equivalence statement in
     the configuration file, "cmake.cfg".

     Note the Following:

     1. The commands (and comments) in the make file.  CMAKE will
        deduce all dependencies from these commands.

        See: When is a User-Defined Command Required?
             How CMAKE Processes an Equivalent Command

     2. The command-equivalence statement, command-definition
        statement, and section tag, [CMAKE], in the configuration file,
        "cmake.cfg".

        See: Command-Equivalence Statements
             Command-Definition Statements
             The CMAKE Section Tag in the Configuration File

─────Command-Equivalence Statement Sample───────────────────────────────────

     readme.txt  cmake.cfg
     makefile    1.txt

     /*****************************************************************
     *                           MAKEFILE
     *
     *  PURPOSE: Create the file, "2.txt", by sorting the file,
     *           "1.txt".  Create the file, "3.txt", by extracting all
     *           the lines from the file, "2.txt", that contain the
     *           word "toad".
     *
     *  NOTE: None of the comments in this make file are required.
     *        They have been provided to help you understand how CMAKE
     *        handles each command.  In other words, this make file
     *        could be reduced down to the following two commands:
     *
     *        sort <1.txt >2.txt
     *        find "toad" <2.txt >3.txt
     *
     *****************************************************************/

     /*****************************************************************
     *                             2.TXT
     *
     *  The following SORT command will be executed only when one of
     *  the following conditions is true:
     *
     *  1. "2.txt" does not exist.
     *  2. "1.txt" is newer than "2.txt".
     *
     *****************************************************************/

     sort <1.txt >2.txt

     /*****************************************************************
     *                             3.TXT
     *
     *  The following FIND command will be executed only when one of
     *  the following conditions is true:
     *
     *  1. "3.txt" does not exist.
     *  2. "2.txt" is newer than "3.txt".
     *
     *****************************************************************/

     find "toad" <2.txt >3.txt

─────Command-Equivalence Statement Sample───────────────────────────────────

     readme.txt  cmake.cfg
     makefile    1.txt

     ; cmake.cfg - CMAKE configuration file

     [CMAKE]
     command_definition : sort sp[<%s >%t]
     command_equivalence : find = sort

─────Command-Equivalence Statement Sample───────────────────────────────────

     readme.txt  cmake.cfg
     makefile    1.txt

     The toad.
     The hungry toad.
     The flea.
     The edible flea.
     The hungry toad chased the edible flea.

─────Configuration File Sample──────────────────────────────────────────────

     readme.txt
     cmake.cfg

     This sample demonstrates all the possible types of statements that
     may be used in a CMAKE configuration file.

     Note the Following in the File, "cmake.cfg":

     1. The comments.

        See: Comments in the Configuration File

     2. The section tag, [CMAKE].

        See: The CMAKE Section Tag in the Configuration File

     3. The assignment statements.  "cmake.cfg" gives a complete list
        of the Boolean variables that may be used in a configuration
        file.  In this sample, each Boolean variable is set to its
        default value.

        See: Assignment Statements in the Configuration File

     4. The command-definition statement.

        See: Command-Definition Statements

     5. The command-equivalence statement.

        See: Command-Equivalence Statements

─────Configuration File Sample──────────────────────────────────────────────

     readme.txt
     cmake.cfg

     ; cmake.cfg - CMAKE configuration file

     [CMAKE]

     ; Assignment statements
     scan_include_files_for_includes = no
     search_source_dir_for_includes = yes
     search_current_dir_for_includes = yes
     c_include_""_on = yes
     c_include_<>_on = no
     asm_include_on = yes
     rc_include_""_on = yes
     rc_include_<>_on = no
     rc_include_resource_on = yes
     run_output_file = yes
     display_output_file_commands = no
     display_execution_time = yes

     ; Command-definition statements
     command_definition : sort sp[<%s >%t]

     ; Command-equivalence statements
     command_equivalence : find = sort

────────────────────────────────────────────────────────────────────────────

     CMAKE Errors

     To find out about a specific error, do one of the following:

     1. Click on the error number below with the right mouse button.
     2. Enter S to search for an error code.
     3. Execute QuickHelp with the command, QH error_number.

     M0001     M0023     M0044     M0064     M0084     M0107     M0127
     M0002     M0024     M0045     M0065     M0085     M0108     M0128
     M0003     M0025     M0046     M0066     M0086     M0109     M0129
     M0004     M0026     M0047     M0067     M0087     M0110     M0130
     M0005     M0027     M0048     M0068     M0088     M0111     M0131
     M0007     M0028     M0049     M0069     M0089     M0112     M0132
     M0008     M0029     M0050     M0070     M0090     M0113     M0133
     M0009     M0030     M0051     M0071     M0091     M0114     M1000
     M0010     M0031     M0052     M0072     M0092     M0115     M1001
     M0011     M0032     M0053     M0073     M0093     M0116     M1002
     M0012     M0033     M0054     M0074     M0094     M0117     M1003
     M0013     M0034     M0055     M0075     M0095     M0118     M1004
     M0014     M0035     M0056     M0076     M0098     M0119     M1005
     M0015     M0036     M0057     M0077     M0100     M0120     M1006
     M0016     M0037     M0058     M0078     M0101     M0121     M1007
     M0017     M0038     M0059     M0079     M0102     M0122     M1008
     M0018     M0039     M0060     M0080     M0103     M0123     M1009
     M0019     M0040     M0061     M0081     M0104     M0124     M1010
     M0020     M0041     M0062     M0082     M0105     M0125     M1011
     M0021     M0042     M0063     M0083     M0106     M0126     M1012
     M0022     M0043

────────────────────────────────────────────────────────────────────────────

     Fatal CMAKE error M0001

     invalid command-line parameters

     The command line used to invoke CMAKE was invalid.

     This message is displayed only when the verbose output format is
     selected.

     See: The CMAKE Command Line

────────────────────────────────────────────────────────────────────────────

     Fatal CMAKE error M0002

     CMAKE aborted

     The command line used to invoke CMAKE was invalid.

     This message is displayed only when the verbose output format is
     selected.

     See: The CMAKE Command Line

────────────────────────────────────────────────────────────────────────────

     Fatal CMAKE error M0003

     unable to load configuration data

     There is an invalid statement in the CMAKE configuration file.

     This message is displayed only when the verbose output format is
     selected.

     See: The CMAKE Configuration File

────────────────────────────────────────────────────────────────────────────

     Fatal CMAKE error M0004

     make file 'filename' not found

     CMAKE could not find the given make file.

     See: The CMAKE Command Line

────────────────────────────────────────────────────────────────────────────

     Fatal CMAKE error M0007

     cannot process command

     One of the commands or statements in the make file could not be
     processed.

     This message is displayed only when the verbose output format is
     selected.

     See: The Make File

────────────────────────────────────────────────────────────────────────────

     Fatal CMAKE error M0008

     CMAKE aborted

     This message is displayed only when the verbose output format is
     selected and one of the following errors has occurred: M0003,
     M0004, M0005, M0007, or M0104.

────────────────────────────────────────────────────────────────────────────

     Fatal CMAKE error M0011

     CMAKE aborted

     This message is displayed only when the verbose output format is
     selected and one of the following errors has occurred: M0009 or
     M0010.

────────────────────────────────────────────────────────────────────────────

     Fatal CMAKE error M0012

     'character' is an invalid command-line option

     An invalid option was specified in the command line used to
     invoke CMAKE.

     See: The CMAKE Command Line

────────────────────────────────────────────────────────────────────────────

     Fatal CMAKE error M0071

     cannot process configuration statement

     One of the statements in the configuration file could not be
     processed.

     This message is displayed only when the verbose output format is
     selected.

     See: The CMAKE Configuration File

────────────────────────────────────────────────────────────────────────────

     Fatal CMAKE error M0126

     unable to run QH.EXE - must be in current directory or PATH

     The /h or /help option was specified in the command line used to
     invoke CMAKE.  However, CMAKE could not locate the QuickHelp
     program, QH.EXE.  QH.EXE must be in the current directory or in
     one of the directories specified in the PATH environment variable.

     See: Display Help on CMAKE

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0005

     output file 'filename' not created

     CMAKE could not create the file, "makefile.bat".

     If the /o option has been specified in the command line used to
     invoke CMAKE, check to be sure that the path given with this
     option is valid.

     See: The CMAKE Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0009

     unable to flush standard output prior to loading 'file1' to run 'file2'

     CMAKE was unable to flush the standard output buffer before
     loading "command.com" to execute the batch program,
     "makefile.bat".

     If you have chosen to redirect the output from CMAKE to a file,
     it is possible that the drive on which you have placed this file
     has no more free space.  This is more likely in the case where
     your make file and/or configuration file are large, and you have
     selected the verbose output format and redirected the output from
     CMAKE to a RAM drive.

     See: Select Verbose Diagnostic Output from CMAKE
          Avoid Using the Verbose Output Format for CMAKE
          Redirect CMAKE Output to a File on a RAM Drive

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0010

     unable to load 'file1' to run output file 'file2'

     CMAKE could not load "command.com" to execute the batch program,
     "makefile.bat".  CMAKE uses the COMSPEC environment variable to
     locate "command.com".

     If you cannot solve this problem, use the CMAKE command-line
     option, /n, or the configuration variable, run_output_file, to
     avoid executing "makefile.bat" from within CMAKE.  Then, after
     CMAKE creates "makefile.bat", you may execute this batch file from
     the command line.

     See: Suppress Command Execution by CMAKE
          run_output_file

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0013

     source-file name is null

     The source-file name for a CL command given in the make file is
     NULL.

     See: The CL Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0014

     object-file name is null

     The object-file name for a CL command given in the make file is
     NULL.

     See: The CL Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0015

     unable to open source file 'filename'

     CMAKE could not open the source file for a CL command given in the
     make file.  CMAKE opens source files in order to search for
     #include statements.

     See: The CL Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0016

     unable to get time stamp for source file 'filename'

     CMAKE could not obtain the time stamp for the source file of a CL
     command given in the make file.

     See: The CL Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0017

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing a CL command given in the
     make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0018

     include file 'filename' not found...
     in source directory 'sourcedirectoryname'  ...
     or INCLUDE environment variable paths...
     'includepaths'

     CMAKE could not find an include file while processing a CL command
     given in the make file.  In this case, the include-file name was
     appended to the source-file's directory and to the directories
     specified in the INCLUDE environment variable.

     See: How CMAKE Processes a C-Source File

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0019

     include file 'filename' not found...
     in INCLUDE environment variable paths...
     'includepaths'

     CMAKE could not find an include file while processing a CL command
     given in the make file.  In this case, the include-file name was
     appended to the directories specified in the INCLUDE environment
     variable.

     If your include file is located in the source-file's directory,
     you should check to be sure that you have not set the
     configuration variable, search_source_dir_for_includes, to 'no'
     in your configuration file.

     See: search_source_dir_for_includes
          Switches for CL
          How CMAKE Processes a C-Source File

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0020

     not enough memory to store include-file name 'filename'

     CMAKE ran out of memory while processing a CL command given in the
     make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0021

     include level exceeds 9

     Too many levels of nested include statements were used in the
     source file of a CL command given in the make file.  (The source
     file itself is level 0, a file that is included in the source file
     is level 1, etc.)

     This usually indicates the presence of circular include
     statements.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0022

     unable to open include file 'filename'

     CMAKE could not open an include file for a CL command given in the
     make file.  When the configuration variable,
     scan_include_files_for_includes, is 'yes', CMAKE opens include
     files in order to search for #include statements.

     If your include files do not have include statements, you should
     not set scan_include_files_for_includes to 'yes'.

     See: scan_include_files_for_includes
          Switches for CL
          How CMAKE Processes a C-Source File
          REM
          Avoid Scanning Include Files for Includes

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0023

     cannot determine response-file name (missing '@')

     The first character of the parameter string for a LIB command
     given in the make file is not '@'.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0024

     response-file name is null

     The response-file name for a LIB command given in the make file
     is NULL.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0025

     unable to open response file 'filename'

     CMAKE could not open the response file for a LIB command given in
     the make file.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0026

     not enough memory to load response file 'filename'

     CMAKE ran out of memory while processing a LIB command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0027

     no operations given in LIB response file

     There are less than three lines in the response file for a LIB
     command given in the make file.  CMAKE requires that the first
     line of the LIB response file must indicate the library name, the
     second line must be 'y', and the third line must indicate the
     first operation to be performed on the given library.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0028

     library-file name is null

     The library name provided in the response file for a LIB command
     given in the make file is NULL.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0029

     unrecognized LIB operation - must be '+', '-', '-+', '*', or '-*'

     One of the lines in the response file for a LIB command given in
     the make file begins with an invalid LIB operator.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0030

     LIB operation must be '-+'

     One of the lines in the response file for a LIB command given in
     the make file begins with an unexpected LIB operator.

     CMAKE requires that when the third line of a LIB response file
     does not use the add operator, '+', all the operations specified
     in the response file must be '-+'.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0031

     object file 'filename' does not exist

     CMAKE could not find one of the object files listed in the
     response file for a LIB command given in the make file.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0032

     response-file name 'filename' is too long - cannot add '.clb' extension

     CMAKE requires that when a LIB response file specifies replace
     operations (-+), the length of the response-file name must not
     exceed 62.

     See: Modified Command Line for LIB

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0033

     new response file 'filename' not created

     CMAKE could not create the LIB response file for a required LIB
     command given in the make file.

     See: Modified Command Line for LIB

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0034

     unable to delete new response file 'filename'

     CMAKE aborted and could not remove the LIB response file that it
     had created for a required LIB command given in the make file.

     See: Modified Command Line for LIB

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0035

     unrecognized LIB operation - must be '+', '-', '-+', '*', or '-*'

     One of the lines in the response file for a LIB command given in
     the make file begins with an invalid LIB operator.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0036

     LIB operation must be '+'

     One of the lines in the response file for a LIB command given in
     the make file begins with an unexpected LIB operator.

     CMAKE requires that when the third line of a LIB response file
     uses the add operator, '+', all the operations specified in the
     response file must be '+'.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0037

     component-library file 'filename' does not exist

     CMAKE could not find one of the component-library files listed in
     the response file for a LIB command given in the make file.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0038

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing a LIB command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0039

     cannot determine response-file name (missing '@')

     The first character of the parameter string for a LINK command
     given in the make file is not '@'.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0040

     response-file name is null

     The response-file name for a LINK command given in the make file
     is NULL.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0041

     unable to open response file 'filename'

     CMAKE could not open the response file for a LINK command given in
     the make file.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0042

     not enough memory to load response file 'filename'

     CMAKE ran out of memory while processing a LINK command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0043

     executable-file name is null

     The executable name provided in the response file for a LINK
     command given in the make file is NULL.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0044

     object file 'filename' does not exist

     CMAKE could not find one of the object files listed in the
     response file for a LINK command given in the make file.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0045

     library file 'filename' does not exist

     CMAKE could not find one of the library files listed in the
     response file for a LINK command given in the make file.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0046

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing a LINK command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0047

     source-file name is null

     The source-file name for a MASM command given in the make file is
     NULL.

     See: The MASM Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0048

     object-file name is null

     The object-file name for a MASM command given in the make file is
     NULL.

     See: The MASM Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0049

     unable to open source file 'filename'

     CMAKE could not open the source file for a MASM command given in
     the make file.  CMAKE opens source files in order to search for
     include statements.

     See: The MASM Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0050

     unable to get time stamp for source file 'filename'

     CMAKE could not obtain the time stamp for the source file of a
     MASM command given in the make file.

     See: The MASM Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0051

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing a MASM command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0052

     include file 'filename' not found...
     in source directory 'sourcedirectoryname'  ...
     or INCLUDE environment variable paths...
     'includepaths'

     CMAKE could not find an include file while processing a MASM
     command given in the make file.  In this case, the include-file
     name was appended to the source-file's directory and to the
     directories specified in the INCLUDE environment variable.

     If your include file is located in the current directory, you
     should check to be sure that you have not set the configuration
     variable, search_current_dir_for_includes, to 'no' in your
     configuration file.

     See: search_current_dir_for_includes
          Switches for MASM
          How CMAKE Processes an Assembly-Language-Source File

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0053

     not enough memory to store include-file name 'filename'

     CMAKE ran out of memory while processing a MASM command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0054

     include level exceeds 9

     Too many levels of nested include statements were used in the
     source file of a MASM command given in the make file.  (The source
     file itself is level 0, a file that is included in the source file
     is level 1, etc.)

     This usually indicates the presence of circular include
     statements.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0055

     unable to open include file 'filename'

     CMAKE could not open an include file for a MASM command given in
     the make file.  When the configuration variable,
     scan_include_files_for_includes, is 'yes', CMAKE opens include
     files in order to search for include statements.

     If your include files do not have include statements, you should
     not set scan_include_files_for_includes to 'yes'.

     See: scan_include_files_for_includes
          Switches for MASM
          How CMAKE Processes an Assembly-Language-Source File
          REM
          Avoid Scanning Include Files for Includes

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0056

     source name is null

     The source name for a COPY command given in the make file is NULL.

     See: The COPY Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0057

     target name is null

     The target name for a COPY command given in the make file is NULL.

     See: The COPY Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0058

     source 'name' does not exist

     CMAKE could not find the source of a COPY command given in the
     make file.

     See: The COPY Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0059

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing a COPY command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0060

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing a COPY command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0061

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing a COPY command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0062

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing a COPY command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0063

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing a COPY command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0064

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing a COPY command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0065

     source-file name is null

     A source-file name for a user-defined command given in the make
     file is NULL.

     See: How CMAKE Processes the Command Line of a User-Defined Command

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0066

     target-file name is null

     A target-file name for a user-defined command given in the make
     file is NULL.

     See: How CMAKE Processes the Command Line of a User-Defined Command

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0067

     unable to get time stamp for source file 'filename'

     CMAKE could not obtain the time stamp for a source file of a
     user-defined command given in the make file.

     See: How CMAKE Processes the Command Line of a User-Defined Command

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0068

     not enough memory to store target-file name 'filename'

     CMAKE ran out of memory while processing a user-defined command
     given in the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0069

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing a user-defined command
     given in the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0070

     line too long in configuration file - length must be less than 255

     A line in the configuration file exceeds the maximum length limit.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0072

     unrecognized configuration statement

     A configuration statement was not recognized to be comment,
     assignment statement, command-definition statement, or command-
     equivalence statement.

     See: The CMAKE Configuration File

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0073

     right hand side of assignment statement must be 'yes' or 'no'

     The right hand side of all assignment statements in the
     configuration file must be 'yes' or 'no'.

     See: Syntax of Assignment Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0074

     not enough memory to store command definition

     CMAKE ran out of memory while processing a command-definition
     statement in the configuration file.

     Try eliminating any unnecessary command-definition and command-
     equivalence statements from your configuration file.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0075

     command name is null

     The command name for a command-definition statement given in the
     configuration file is NULL.

     See: Command-Definition Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0076

     command name too long - length must be no more than 8

     The command name for a command-definition statement given in the
     configuration file is too long.

     See: Command-Definition Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0077

     invalid parameter type - type must be 'sp' or 'fp'

     An invalid parameter type was specified in a command-definition
     statement given in the configuration file.

     See: Command-Definition Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0078

     missing file type delimiter '%' in stationary parameters

     There is a missing file type delimiter in the stationary
     parameters for a command-definition statement given in the
     configuration file.

     See: Command-Definition Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0079

     missing file type delimiter '%' in floating parameters

     There is a missing file type delimiter in the floating parameters
     for a command-definition statement given in the configuration
     file.

     See: Command-Definition Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0080

     invalid file type in stationary parameters - must be 'n', 's', or 't'

     An invalid file type code was used in the stationary parameters
     for a command-definition statement given in the configuration
     file.

     See: Command-Definition Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0081

     invalid file type in floating parameters - must be 'n', 's', or 't'

     An invalid file type code was used in the floating parameters
     for a command-definition statement given in the configuration
     file.

     See: Command-Definition Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0082

     open delimiter '[' expected after parameter type

     An open delimiter, '[', was expected in a command-definition
     statement given in the configuration file.

     See: Command-Definition Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0083

     closing delimiter ']' missing

     A closing delimiter, ']', was expected in a command-definition
     statement given in the configuration file.

     See: Command-Definition Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0084

     stationary parameters too long - must be sp['up-to-20-characters']

     The stationary parameter string in a command-definition statement
     given in the configuration file is too long.

     See: Command-Definition Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0085

     floating parameters too long - must be fp['up-to-20-characters']

     The floating parameter string in a command-definition statement
     given in the configuration file is too long.

     See: Command-Definition Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0086

     not enough memory to store command equivalence

     CMAKE ran out of memory while processing a command-equivalence
     statement in the configuration file.

     Try eliminating any unnecessary command-definition and command-
     equivalence statements from your configuration file.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0087

     command name is null

     The command name for a command-equivalence statement given in the
     configuration file is NULL.

     See: Command-Equivalence Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0088

     command name too long - length must be no more than 8

     The command name for a command-equivalence statement given in the
     configuration file is too long.

     See: Command-Equivalence Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0089

     equivalent-command name is null

     The equivalent-command name (i.e. right hand side) for a command-
     equivalence statement given in the configuration file is NULL.

     See: Command-Equivalence Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0090

     equivalent-command name too long - length must be no more than 8

     The equivalent-command name (i.e. right hand side) for a command-
     equivalence statement given in the configuration file is too long.

     See: Command-Equivalence Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0091

     unrecognized equivalent command

     The equivalent-command name (i.e. right hand side) for a command-
     equivalence statement given in the configuration file is
     unrecognized.

     The equivalent-command name must be either an intrinsic command
     (e.g. CL, LINK, LIB, MASM,...) or a user-defined command that has
     been defined in a previous command-definition statement.

     See: Command-Equivalence Statements

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0092

     include file 'filename' not found...
     in INCLUDE environment variable paths...
     'includepaths'

     CMAKE could not find an include file while processing a MASM
     command given in the make file.  In this case, the include-file
     name was appended to the directories specified in the INCLUDE
     environment variable.

     If your include file is located in the current directory, you
     should check to be sure that you have not set the configuration
     variable, search_current_dir_for_includes, to 'no' in your
     configuration file.

     If your include file is located in the source-file's directory,
     you should check to be sure that you have not set the
     configuration variable, search_source_dir_for_includes, to 'no' in
     your configuration file.

     See: search_current_dir_for_includes
          search_source_dir_for_includes
          Switches for MASM
          How CMAKE Processes an Assembly-Language-Source File

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0093

     not enough memory to store environment string address

     CMAKE ran out of memory while processing a SET command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0094

     not enough memory to store environment string

     CMAKE ran out of memory while processing a SET command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0095

     environment variable name is null

     The environment variable name in a SET statement given in the make
     file is NULL.

     See: SET

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0098

     '(' expected after 'if'

     The character, '(', is missing in an if statement given in the make
     file.

     See: Syntax of the if Statement

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0100

     not enough memory to store target-file name 'filename'

     CMAKE ran out of memory while processing an if statement given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0101

     unable to get time stamp for source file 'filename'

     CMAKE could not obtain the time stamp for a source file of an
     if statement given in the make file.

     See: Syntax of the if Statement

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0102

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing an if statement given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0103

     line too long - length must be less than 255

     A command line given in the make file exceeds the maximum length
     limit.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0104

     not enough memory to create predefined pseudofile 'filename'

     CMAKE ran out of memory while attempting to create the predefined
     pseudofile, "start.psf".

     You do not have enough memory available to execute CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0105

     comments may not be nested

     Nested C-style comments (/* */) were detected in the make file.
     C-style comments may not be nested.

     See: Comments in the Make File

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0106

     module-definition file 'filename' does not exist

     CMAKE could not find the module-definition file listed in the
     response file for a LINK command given in the make file.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0107

     include file 'filename' not found in current directory...
     'currentdirectoryname', source directory 'sourcedirectoryname'  ...
     or INCLUDE environment variable paths...
     'includepaths'

     CMAKE could not find an include file while processing a MASM
     command given in the make file.  In this case, the include-file
     name was appended to the current directory, the source-file's
     directory and the directories specified in the INCLUDE
     environment variable.

     See: How CMAKE Processes an Assembly-Language-Source File

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0108

     include file 'filename' not found in current directory...
     'currentdirectoryname' or INCLUDE environment variable paths...
     'includepaths'

     CMAKE could not find an include file while processing a MASM
     command given in the make file.  In this case, the include-file
     name was appended to the current directory and to the directories
     specified in the INCLUDE environment variable.

     If your include file is located in the source-file's directory,
     you should check to be sure that you have not set the
     configuration variable, search_source_dir_for_includes, to 'no' in
     your configuration file.

     See: search_source_dir_for_includes
          Switches for MASM
          How CMAKE Processes an Assembly-Language-Source File

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0109

     resource-script-file name is null

     The resource-script-file name for an RC/C command given in the
     make file is NULL.

     See: The RC/C Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0110

     resource-file name is null

     The resource-file name for an RC/C command given in the make file
     is NULL.

     See: The RC/C Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0111

     unable to open resource-script file 'filename'

     CMAKE could not open the resource-script file for an RC/C command
     given in the make file.  CMAKE opens resource-script files in
     order to search for #include statements and resource-include
     statements.

     See: The RC/C Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0112

     unable to get time stamp for resource-script file 'filename'

     CMAKE could not obtain the time stamp for the resource-script file
     of an RC/C command given in the make file.

     See: The RC/C Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0113

     resource-file name is null

     The resource-file name for an RC/A command given in the make file
     is NULL.

     See: The RC/A Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0114

     executable-file name is null

     The executable-file name for an RC/A command given in the make
     file is NULL.

     See: The RC/A Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0115

     unable to get time stamp for executable file 'filename'

     CMAKE could not obtain the time stamp for the executable file of
     an RC/A command given in the make file.

     See: The RC/A Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0116

     unable to get time stamp for resource file 'filename'

     CMAKE could not obtain the time stamp for the resource file of an
     RC/A command given in the make file.

     See: The RC/A Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0117

     target-file name is null

     The target-file name for an RC/W command given in the make file is
     NULL.

     See: The RC/W Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0118

     unable to get time stamp for target file 'filename'

     CMAKE could not obtain the time stamp for the target file of an
     RC/W command given in the make file.

     See: The RC/W Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0119

     cannot determine RC operation

     CMAKE could not determine the operation type of an RC command
     given in the make file.

     See: RC Operations
          The RC/C Command Line
          The RC/A Command Line
          The RC/W Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0120

     not enough memory to create pseudofile 'filename'

     CMAKE ran out of memory while processing an RC command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0121

     include file 'filename' not found in current directory...
     'currentdirectoryname' or INCLUDE environment variable paths...
     'includepaths'

     CMAKE could not find an include file while processing an RC/C
     command given in the make file.  In this case, the include-file
     name was appended to the current directory and to the directories
     specified in the INCLUDE environment variable.

     See: How CMAKE Processes a Resource-Script File

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0122

     include file 'filename' not found...
     in INCLUDE environment variable paths...
     'includepaths'

     CMAKE could not find an include file while processing an RC/C
     command given in the make file.  In this case, the include-file
     name was appended to the directories specified in the INCLUDE
     environment variable.

     If your include file is located in the current directory, you
     should check to be sure that you have not set the configuration
     variable, search_current_dir_for_includes, to 'no' in your
     configuration file.

     See: search_current_dir_for_includes
          Switches for RC/C
          How CMAKE Processes a Resource-Script File

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0123

     not enough memory to store include-file name 'filename'

     CMAKE ran out of memory while processing an RC/C command given in
     the make file.

     Try splitting your make file into two smaller make files that are
     processed with two consecutive calls to CMAKE.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0124

     include level exceeds 9

     Too many levels of nested include statements were used in the
     resource-script file of an RC/C command given in the make file.
     (The resource-script file itself is level 0, a file that is
     included in the resource-script file is level 1, etc.)

     This usually indicates the presence of circular include
     statements.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0125

     unable to open include file 'filename'

     CMAKE could not open an include file for an RC/C command given in
     the make file.  When the configuration variable,
     scan_include_files_for_includes, is 'yes', CMAKE opens include
     files in order to search for #include statements and resource-
     include statements.

     If your include files do not have include statements, you should
     not set scan_include_files_for_includes to 'yes'.

     See: scan_include_files_for_includes
          Switches for RC/C
          How CMAKE Processes a Resource-Script File
          REM
          Avoid Scanning Include Files for Includes

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0127

     unexpected end-of-file

     An unexpected end-of-file was reached while processing the
     response file for a LIB command given in the make file.

     Check to be sure that the last line in the response file does not
     end with the character, '&'.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0128

     unexpected end-of-file

     An unexpected end-of-file was reached while processing the
     response file for a LIB command given in the make file.

     Check to be sure that the last line in the response file does not
     end with the character, '&'.

     See: The LIB Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0129

     unexpected end-of-file

     An unexpected end-of-file was reached while processing the
     response file for a LINK command given in the make file.

     Check to be sure that the executable-file name has not been
     omitted from the response file.

     Check to be sure that the last line in the response file does not
     end with the character, '+'.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0130

     unexpected end-of-file

     An unexpected end-of-file was reached while processing the
     response file for a LINK command given in the make file.

     Check to be sure that the last line in the response file is
     terminated with the character, ';'.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0131

     unexpected end-of-file

     An unexpected end-of-file was reached while processing the
     response file for a LINK command given in the make file.

     Check to be sure that the last line in the response file is
     terminated with the character, ';'.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0132

     unexpected end-of-file

     An unexpected end-of-file was reached while processing the
     response file for a LINK command given in the make file.

     Check to be sure that the last line in the response file is
     terminated with the character, ';'.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M0133

     unexpected end-of-file

     An unexpected end-of-file was reached while processing the
     response file for a LINK command given in the make file.

     Check to be sure that the last line in the response file does not
     end with the character, '+'.

     See: The LINK Command Line

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1000

     token truncated to 'token' - maximum token length is 67

     There is a token in the make file that is too long.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1001

     unexpected end-of-file

     An unexpected end-of-file was reached while processing an if
     statement given in the make file.

     See: Syntax of the if Statement

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1002

     token truncated to 'token' - maximum token length is 67

     There is a token in the make file that is too long.  This was
     discovered while processing an if statement in the make file.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1003

     unexpected end-of-file

     An unexpected end-of-file was reached while processing an if
     statement given in the make file.

     See: Syntax of the if Statement

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1004

     token truncated to 'token' - maximum token length is 67

     There is a token in the make file that is too long.  This was
     discovered while processing an if statement in the make file.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1005

     unexpected end-of-file

     An unexpected end-of-file was reached while processing an if
     statement given in the make file.

     See: Syntax of the if Statement

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1006

     token truncated to 'token' - maximum token length is 67

     There is a token in the make file that is too long.  This was
     discovered while processing an if statement in the make file.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1007

     unexpected end-of-file

     An unexpected end-of-file was reached while processing an if
     statement given in the make file.

     See: Syntax of the if Statement

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1008

     token truncated to 'token' - maximum token length is 67

     There is a token in the make file that is too long.  This was
     discovered while processing an if statement in the make file.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1009

     unexpected end-of-file

     An unexpected end-of-file was reached while processing an if
     statement given in the make file.

     See: Syntax of the if Statement

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1010

     token truncated to 'token' - maximum token length is 67

     There is a token in the make file that is too long.  This was
     discovered while processing an if statement in the make file.

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1011

     unexpected end-of-file

     An unexpected end-of-file was reached while processing an if
     statement given in the make file.

     Check to be sure that you have not omitted the terminating
     bracket, '}', from an if statement in your make file.  Check your
     last if statement first.

     See: Syntax of the if Statement

────────────────────────────────────────────────────────────────────────────

     CMAKE error M1012

     token truncated to 'token' - maximum token length is 67

     There is a token in the make file that is too long.  This was
     discovered while processing an if statement in the make file.

─────Copyright and Trademarks───────────────────────────────────────────────

     Copyright

     (c) Copyright John Greschak 1991.

     Registered Trademarks

     Microsoft and MS-DOS are registered trademarks of Microsoft
     Corporation.

     CompuServe is a registered trademark of CompuServe, Inc.

     BRIEF is a registered trademark of UnderWare, Inc.

     Trademarks

     Windows is a trademark of Microsoft Corporation.

     Epsilon is a trademark of Lugaru Software, Ltd.

──CMAKE Index───────────────────────────────────────────────────────────────

  /a option                Display Information about CMAKE

  asm_include_on           asm_include_on
                           Switches for MASM
                           How CMAKE Processes an ASM-Source File

  assignment statements    Assignment Statements in the Configuration File

  author                   Technical Support for CMAKE
                           Display Information about CMAKE

  Boolean variables        Boolean Variables

  BRIEF                    Error Messages (Viewing)
                           Using CMAKE with BRIEF

  c_include_""_on          c_include_""_on
                           Switches for CL
                           How CMAKE Processes a C-Source File

  c_include_<>_on          c_include_<>_on
                           Switches for CL
                           Avoid Checking System-Include Dependencies
                           How CMAKE Processes a C-Source File

  CL                       CL

  CMAKE_CFG environment variable
                           How CMAKE Locates the Configuration File

  /* CMAKE - INCLUDE END */
                           How CMAKE Processes a C-Source File
                           Switches for CL
                           How CMAKE Processes a Resource-Script File
                           Switches for RC/C
                           Helpful Hints for RC/C
                           Use the End-of-Includes Comment

  /* CMAKE - INCLUDE "" ON/OFF */
                           How CMAKE Processes a C-Source File
                           Switches for CL
                           Some Restrictions on CL
                           How CMAKE Processes a Resource-Script File
                           Switches for RC/C
                           Some Restrictions on RC/C
                           rc_include_""_on
                           c_include_""_on

  /* CMAKE - INCLUDE <> ON/OFF */
                           How CMAKE Processes a C-Source File
                           Switches for CL
                           How CMAKE Processes a Resource-Script File
                           Switches for RC/C
                           c_include_<>_on
                           rc_include_<>_on
                           Avoid Checking System-Include Dependencies

  /* CMAKE - INCLUDE RESOURCE ON/OFF */
                           How CMAKE Processes a Resource-Script File
                           Switches for RC/C
                           Helpful Hints for RC/C
                           rc_include_resource_on

  ; CMAKE - INCLUDE END    How CMAKE Processes an ASM-Source File
                           Switches for MASM
                           Use the End-of-Includes Comment

  ; CMAKE - INCLUDE ON/OFF How CMAKE Processes an ASM-Source File
                           Switches for MASM
                           asm_include_on

  "cmake.cfg"              How CMAKE Locates the Configuration File
                           Help CMAKE Find Configuration Data Quickly

  command-definition statements
                           Command-Definition Statements
                           Description of User-Defined Commands
                           Verbose Output - User-Defined Commands
                           User-Defined Commands: Pseudofiles: Examples

  command-equivalence statements
                           Command-Equivalence Statements
                           Description of Equivalent Commands
                           Verbose Output - Equivalent Commands

  command-line options     The CMAKE Command Line

  commands                 Make-File Commands

  comments                 Comments in the Make File
                           Comments in the Configuration File

  COMSPEC environment variable
                           CMAKE error M0010

  configuration file       The CMAKE Configuration File

  COPY                     COPY

  dependencies             Introduction
                           Description of the if Statement

  display_execution_time   display_execution_time

  display_output_file_commands
                           display_output_file_commands

  editors                  Error Messages
                           Using CMAKE with Your Editor
                           The RC/C Command Line

  environment variables    How CMAKE Locates the Configuration File

  Epsilon                  Error Messages
                           Using CMAKE with Epsilon

  equivalent commands      Equivalent Commands

  error messages           Error Messages
                           Using CMAKE with Your Editor
                           CMAKE Errors

  execution time           display_execution_time
                           Overview of Optimization Techniques for CMAKE
                           Interpreting the Output of CMAKE

  exit codes               CMAKE Exit Codes

  floating parameters      Command-Definition Statements
                           Processing User-Defined Commands
                           Verbose Output - User-Defined Commands

  Greschak                 Introduction
                           Technical Support for CMAKE

  /help option             Display Help on CMAKE

  if statements            The if Statement

  IMPLIB                   Command-Definition Statements: Examples

  INCLUDE environment variable
                           How CMAKE Processes a C-Source File
                           Switches for CL
                           How CMAKE Processes an ASM-Source File
                           Switches for MASM
                           How CMAKE Processes a Resource-Script File
                           Switches for RC/C
                           search_source_dir_for_includes
                           search_current_dir_for_includes

  include statements       How CMAKE Processes a C-Source File
                           How CMAKE Processes an ASM-Source File
                           How CMAKE Processes a Resource-Script File

  input file               Interpreting the Output of CMAKE

  intrinsic commands       Intrinsic Commands

  LIB                      LIB

  LIB environment variable The LINK Command Line
                           Samples: Microsoft Windows SDK

  LINK                     LINK

  local-include statements How CMAKE Processes a C-Source File
                           How CMAKE Processes a Resource-Script File

  "makefile"               Specify the Make-File Name

  "makefile.bat"           How CMAKE Works
                           Interpreting the Output of CMAKE
                           Suppress Command Execution by CMAKE
                           Specify the Path of "makefile.bat"
                           run_output_file
                           display_output_file_commands
                           Have CMAKE Put "makefile.bat" on a RAM Drive

  make file                Creating a Make File
                           Specify the Make-File Name
                           The Make File

  MASM                     MASM

  The Microsoft Editor     Error Messages
                           Using CMAKE with The Microsoft Editor

  /n option                Suppress Command Execution by CMAKE
                           run_output_file

  neutral files            Command-Definition Statements
                           Processing User-Defined Commands

  /o option                Specify the Path of "makefile.bat"
                           The CMAKE Command Line: Examples
                           Have CMAKE Put "makefile.bat" on a RAM Drive

  options                  The CMAKE Command Line

  output                   Interpreting the Output of CMAKE
                           Select Verbose Diagnostic Output from CMAKE
                           Avoid Using the Verbose Output Format for CMAKE
                           Redirect CMAKE Output to a File on a RAM Drive

  output file              Interpreting the Output of CMAKE

  PATH environment variable
                           Display Help on CMAKE

  predefined pseudofiles   Pseudofiles for User-Defined Commands
                           Pseudofiles for the if Statement

  pseudofiles              How CMAKE Works

  QH                       Display Help on CMAKE

  QuickHelp                Display Help on CMAKE

  RC                       RC

  RC/A                     RC/A

  RC/C                     RC/C

  RC/CA                    RC/CA

  RC/W                     RC/W

  rc_include_""_on         rc_include_""_on
                           Switches for RC/C
                           How CMAKE Processes a Resource-Script File

  rc_include_<>_on         rc_include_<>_on
                           Switches for RC/C
                           How CMAKE Processes a Resource-Script File

  rc_include_resource_on   rc_include_resource_on
                           Switches for RC/C
                           How CMAKE Processes a Resource-Script File

  registered users         Display Information about CMAKE

  REM                      REM

  REM CMAKE - SCAN INCLUDE FILES FOR INCLUDES ON/OFF
                           Switches for CL
                           How CMAKE Processes a C-Source File
                           Switches for MASM
                           How CMAKE Processes an ASM-Source File
                           Switches for RC/C
                           How CMAKE Processes a Resource-Script File
                           REM
                           scan_include_files_for_includes
                           Avoid Scanning Include Files for Includes

  resource-include statements
                           How CMAKE Processes a Resource-Script File

  response files           The LIB Command Line
                           The LINK Command Line

  run_output_file          run_output_file
                           Suppress Command Execution by CMAKE

  scan_include_files_for_includes
                           scan_include_files_for_includes
                           Switches for CL
                           How CMAKE Processes a C-Source File
                           Switches for MASM
                           How CMAKE Processes an ASM-Source File
                           Switches for RC/C
                           How CMAKE Processes a Resource-Script File
                           REM
                           Avoid Scanning Include Files for Includes

  search_current_dir_for_includes
                           search_current_dir_for_includes
                           Switches for MASM
                           How CMAKE Processes an ASM-Source File
                           Switches for RC/C
                           How CMAKE Processes a Resource-Script File
                           Help CMAKE Find Include Files Quickly

  search_source_dir_for_includes
                           search_source_dir_for_includes
                           Switches for CL
                           How CMAKE Processes a C-Source File
                           Switches for MASM
                           How CMAKE Processes an ASM-Source File
                           Help CMAKE Find Include Files Quickly

  sensitivity to include statements
                           How CMAKE Processes a C-Source File
                           How CMAKE Processes an ASM-Source File
                           How CMAKE Processes a Resource-Script File

  SET                      SET

  shareware                Display Information about CMAKE

  SORT                     Command-Definition Statements: Examples

  source files             How CMAKE Works

  "start.psf"              Pseudofiles for User-Defined Commands
                           Pseudofiles for the if Statement

  stationary parameters    Command-Definition Statements
                           Processing User-Defined Commands
                           Verbose Output - User-Defined Commands

  system-include statements
                           How CMAKE Processes a C-Source File
                           How CMAKE Processes a Resource-Script File

  target files             How CMAKE Works

  technical support        Technical Support for CMAKE

  time stamps              How CMAKE Works

  unrecognized commands    Unrecognized Commands in the Make File

  user-defined commands    User-Defined Commands

  /v option                Select Verbose Diagnostic Output from CMAKE
                           Avoid Using the Verbose Output Format for CMAKE

  variables                Boolean Variables

  %n                       Command-Definition Statements

  %s                       Command-Definition Statements
                           Command-Definition Statements: Examples
                           Verbose Output - User-Defined Commands
                           User-Defined Commands: Pseudofiles: Examples

  %t                       Command-Definition Statements
                           Command-Definition Statements: Examples
                           Verbose Output - User-Defined Commands
                           User-Defined Commands: Pseudofiles: Examples

  /? option                Display Command-Line Help for CMAKE

  " "                      How CMAKE Processes a C-Source File
                           How CMAKE Processes a Resource-Script File

  < >                      How CMAKE Processes a C-Source File
                           How CMAKE Processes a Resource-Script File

  <                        The if Statement

  >                        Interpreting the Output of CMAKE

  ;                        Comments in the Configuration File

  /                        CMAKE Options

  -                        CMAKE Options

  //                       Comments in the Make File

  /* */                    Comments in the Make File

  { }                      The if Statement

  ( )                      The if Statement