Click above to get retro games delivered to your door ever month!

 Program Maintenance--RMAKE.EXE
 Automates the maintenance of multi-file program systems by keeping files up-
 to-date by comparing the date and time stamps of files related to one
 another and performing a series of actions if they do not match.
------------------------------------------------------------------------------

     RMAKE [<makeFile list>] [<macroDef list>] [<option list>]

 Arguments

     <makeFile list> is a list (separated by spaces) of one or more make
     files to process.  The default extension for make files is (.RMK).  Each
     filename can optionally include a drive designator and a path reference.
     You can specify a maximum of 16 files in the <makeFile list>.

     <macroDef list> is a list (separated by spaces) of one or more macro
     definitions of the form <macroName>=[<value>].  If you specify more than
     one macro definition, separate them with a space.  If you define a macro
     on the command line, you cannot redefine it in the make file without
     first undefining it.  In this way, command line macros take precedence
     over make file macros of the same name.

     <option list> is a list of one or more options to control the course
     of the make, all of which are described below.  To get a list of options,
     specify the RMAKE command line with no arguments.

 RMAKE Options

     All options are shown in uppercase preceded by a slash (/).  Note,
     however, that options are not case-sensitive and that you can replace
     the slash with a dash (-) if you prefer.

     Some compiler options have arguments.  If an option has arguments,
     specify them after the option, with no space between the option and
     its first argument.

     /B

     Displays debugging information.

     /D<macroName>[:<value>]

     Defines a macro and an optional value.  If the value is not supplied,
     the macro is defined with a null value.

     /F

     Forces RMAKE to perform all actions defined in the make file(s) without
     regard to the date and time stamps of the files in the dependency and
     inference rules.  In other words, the application will be rebuilt,
     regardless of whether any files have been updated since the last build.

     /I

     Ignores execution errors.

     /N

     Performs a null make displaying the commands that would be executed
     without actually executing them.

     /Q

     Suppresses the RMAKE copyright message.

     /U

     Enables the # character as a comment indicator and suppresses its use as
     a directive indicator.

     /W

     Displays certain warning messages.

     /XS<numSymbols>

     Sets the size of the internal symbol table.  If not specified, the
     default is 500 symbols.

     /XW<numBytes>

     Sets the size of the internal workspace.  If not specified, the default
     is 2048 bytes.

 Comments

     Comments can be specified using C-style inline comments (e.g. /* .. */ )
     or C-style line comments (//) or, if the /U option is used, Unix make-
     style comments (#).  Comments cannot be nested.

 Dependency Rules

     A dependency rule causes certain actions to be performed if any of the
     dependent files have a newer date and time stamp than the target file:

     <targetFile>: <dependentFile list>
        [<action>]
        [<action>]...

 Inference Rules

     An inference rule is used to complete a dependency rule specified with
     no actions.  It defines the actions to take for any incomplete
     dependency rule that satisfies certain filename extensions:

     .<dependentExtension>.<targetExtension>:
        [<action>]
        [<action>]...

 Macro Definitions

     Macros are defined in make files using the following syntax:

     <macroName> = [<value>]

     Once defined, a macro can be referred to using the following syntax:

     $(<macroName>)

     To assign the contents of a macro to another macro, use the following
     syntax:

     <macroName> := $(<macroName>)

 Makepath Macros

     Makepath macros are special macros that define where RMAKE searches and
     creates classes of files as defined by extension.  Makepath macros are
     defined using the following syntax:

     makepath[.<extension>] = <pathSpec>

 Predefined Macros

     In addition to user-defined macros, there are several predefined macros
     that can be used to access dependency and target filenames.

     $*

     Expands to the target filename without a path or extension.

     $@

     Expands to the target filename, including path and extension.

     $**

     Expands to the complete list of full dependency filenames.

     $<

     Expands to the full name of the first file in the dependent file list.

     $?

     Expands to a list of dependencies that have a more recent date and time
     stamp than the target file.

 Directives

     RMAKE provides directives to control the operation of the make process.
     Directives cannot be used as action lines.  Macros encountered in a
     directive are expanded immediately.  By default, either the # character
     or the ! character can be used to specify a directive. If the /U option
     is used, the # character is interpreted as a comment indicator and
     cannot be used to specify directives.

     #! <action>

     Executes a DOS command.

     #ifdef <macroName>
        <statements>...
     #else
        <statements>...
     #endif

     Executes statements between the #ifdef directive and the corresponding
     #else or #endif directives if the specified <macroName> exists.

     #ifeq <word1> <word2>
        <statements>...
     #else
        <statements>...
     #endif

     Executes statements between the #ifeq directive and the corresponding
     #else or #endif directives if <word1> and <word2> are identical.  A word
     consists of one or more characters up to the next white space character.
     To include a white space character within a word, enclose the word in
     double quote (") marks.  Note that the comparison is not case-sensitive.

     #iffile <fileSpec>
        <statements>...
     #else
        <statements>...
     #endif

     Executes statements between the #iffile directive and the corresponding
     #else or #endif directives if any files match the specified <fileSpec>.

     #ifndef <macroName>
        <statements>...
     #else
        <statements>...
     #endif

     Executes statements between the #ifndef directive and the corresponding
     #else or #endif directives if the specified <macroName> does not exist.

     #include "<fileName>"

     Inserts and processes the contents of <fileName> before continuing with
     the current make file.

     #stderr "<text>"

     Writes the <text> to the standard error file or device.

     #stdout "<text>"

     Writes the <text> to the standard output file or device.

     #undef <macroName>

     Removes any previous definition of the specified <macroName>.