                                       '           Guide to MadGoat Make Utility                  December, 1998      ?           This manual describes the MadGoat Make Utility (MMK), +           a "make" utility for VMS systems.         A           Revision/Update Information:  This is a revised manual.   >           Operating System and Version: VAX/VMS V5.2 or later;=                                         OpenVMS Alpha V1.5 or @                                         later; OpenVMS IA64 V8.20                                         or later  3           Software Version:             MMK V3.9-10                Matthew Madison            MadGoat Software                                                 "           ________________________           21 February 2005  =           Permission is granted to copy and redistribute this *           document for no commercial gain.  ?           The information in this document is subject to change 9           without notice and should not be construed as a 9           commitment by the author. The author assumes no ?           responsibility for any errors that may appear in this            document.   =           DISCLAIMER: The author and MadGoat Software make no ;           representations or warranties with respect to the ?           contents hereof and specifically disclaim any implied :           warranties of merchantability or fitness for any           particular purpose.   9           The following are trademarks of Hewlett-Packard "           Development Company, LP:  8           AXP                DEC                 OpenVMS            VAX                VMS  5           UNIX is a registered trademark of USL, Inc.              __________>           Copyright 1993-1998,2004,2005 MadGoat Software. All           Rights Reserved.                       A           _______________________________________________________              Contents  A                 _________________________________________________ A                 PREFACE                                       vii   A           _______________________________________________________ A           CHAPTER 1  INTRODUCTION                             1-1   A                 _________________________________________________ A                 1.1   OVERVIEW                                1-1   A                 _________________________________________________ A                 1.2   INVOKING MMK                            1-2     A           _______________________________________________________ A           CHAPTER 2  DESCRIPTION FILES                        2-1   A                 _________________________________________________ A                 2.1   DESCRIPTION FILE COMPONENTS             2-1   A                 _________________________________________________ A                 2.2   USING INFERENCE RULES                   2-2   A                 _________________________________________________ A                 2.3   DEFINING INFERENCE RULES                2-3   A                 _________________________________________________ 6                 2.4   FORCED SETUP/TEARDOWN ACTIONS INA                       INFERENCE RULES                         2-5   A                 _________________________________________________ A                 2.5   MODIFYING THE SUFFIX LIST               2-5   A                 _________________________________________________ A                 2.6   USING CONDITIONALS                      2-6         A                                                               iii                     Contents          A                 _________________________________________________ A                 2.7   DEFERRING MACRO SUBSTITUTION            2-7   A                 _________________________________________________ A                 2.8   MACRO STRING SUBSTITUTION               2-8   A                 2.8.1     Suffix Substitution  ___________    2-8   A                 2.8.2     General String Substitution  ___    2-8   A           _______________________________________________________ A           CHAPTER 3  USING DEC/CMS WITH MMK                   3-1   A                 _________________________________________________ A                 3.1   THE /CMS QUALIFIER                      3-1   A                 _________________________________________________ A                 3.2   EXPLICIT CMS ELEMENT REFERENCES         3-1   0                 3.2.1     Specifying the ElementA                           Generation  ____________________    3-2   A                 _________________________________________________ A                 3.3   INFERENCE RULES FOR CMS FILES           3-2   4                 3.3.1     CMS and Prefixed InferenceA                           Rules  _________________________    3-3 :                 MMK                                    3-4  A           _______________________________________________________ A           APPENDIX A  DIFFERENCES BETWEEN MMK AND DEC/MMS     A-1   A                 _________________________________________________ 7                 A.1   DEC/MMS FEATURES NOT SUPPORTED IN A                       MMK                                     A-1   A                 _________________________________________________ A                 A.2   MMK EXTENDED FEATURES                   A-2                iv         A                                                          Contents           A                 _________________________________________________ A                 A.3   OTHER DIFFERENCES                       A-4     A           _______________________________________________________ A           APPENDIX B  BUILT-IN DEPENDENCY RULES               B-1     A           _______________________________________________________            FIGURES   8                 B-1       MMK default dependency rules -A                           VAX  ___________________________    B-1   8                 B-2       MMK default dependency rules -A                           Alpha  _________________________    B-9   8                 B-3       MMK default dependency rules -A                           IA64  __________________________   B-17                                           A                                                                 v                    A           _______________________________________________________              Preface   @           This guide explains how to install and use the MadGoat           Make Utility (MMK).   L           __________________________________________________________________             Intended Audience   >           This manual is intended for all MMK users, primarily9           programmers who need to build software systems.   :           MMK is patterned after VAX DEC/Module Management>           System (DEC/MMS), which is in turn based on the UNIX>           make utility. The reader is assumed to have at least/           cursory knowledge of make or DEC/MMS.   A           Note: This document does not provide a general tutorial ;           on make utilities. New users are advised to learn ?           more about description files (makefiles) by reviewing @           either DEC/MMS documentation or books on the UNIX make           utility.  L           __________________________________________________________________             Document Structure  
           tbs   L           __________________________________________________________________             Related Documents   
           tbs   L           __________________________________________________________________             Conventions   <           In this document, the following convention will be<           used for the names of the three similar utilities:  A           o  MMK refers to MadGoat Make, the package described in               this document.   >           o  DEC/MMS refers to DEC/Module Management System, a6              product of Digital Equipment Corporation.  A                                                               vii                     Preface           2           o  make refers to the UNIX make utility.                                                                                         viii                     A           _______________________________________________________       1      Introduction      @           This chapter describes MadGoat Make (MMK). It includes>           an overview of MMK and basic information on its use.  L           __________________________________________________________________      1.1    Overview  >           MMK is a tool for building a "software system;" that>           is, a collection of one or more executable images or?           other types of files that are related to a particular ;           project. Building a complex system by hand can be <           a difficult and time-consuming task; using command?           procedures can make the task easier, but it may still            be time-consuming.  >           With MMK, you create a file called a Makefile or MMS@           description file to describe your software system: the?           objects (i.e., source files, object files, etc.) that =           comprise the system, the dependencies between those =           objects, and the commands used to build the system. ?           When you invoke MMK, it performs the following steps:   7           1  MMK reads and parses the description file, 5              constructing a tree from the objects and -              dependencies listed in the file.   >           2  It then identifies the object to be built (called              the target).   @           3  The tree of dependencies is traced from the target,>              and the revision dates for the files in that path;              are compared. If an object doesn't exist or is A              older than the object it depends on, the commands to @              build the object are executed in a subprocess. This=              continues until all objects along the dependency ;              path have been checked and the target has been +              brought completely up-to-date.   A                                                               1-1                     Introduction          >           In this way, MMK can execute the commands to rebuild=           only those pieces of your software system that need 8           rebuilding due to a change that you have made.<           This can drastically reduce development time for a           project.  L           __________________________________________________________________      1.2    Invoking MMK  >           Provided that MMK has been installed using the steps9           laid out in the installation instructions (file @           AAAREADME.INSTALL in the kit), you can invoke MMK from#           DCL as a foreign command:                               $MMK   >           Full command syntax is given in MMK. By default, MMK<           looks for a description file called DESCRIP.MMS in=           the current directory; if that file does not exist, @           it then looks for a file called MAKEFILE. If it cannot?           find that file, an error is signaled. You can use the @           /DESCRIPTION qualifier to specify a different name for+           your description file, if needed.   8           MMK starts by reading the description file and<           constructing a tree from the objects listed in the>           description file (e.g., source files, include files,@           object files, etc.) and a tree of dependencies between=           those objects. It then identifies the target object ;           to be built, and traverses the dependency tree to >           identify those objects that need to be built (called=           intermediate targets) in order to build the target.   ?           MMK compares each target's revision date/time against :           the objects on which it depends and executes the>           actions for that building the target only if needed.>           You can force a complete rebuild by using the /FROM_/           SOURCES qualifier on the MMK command.   
           1-2                      A           _______________________________________________________       2      Description Files       ?           The key to successfully building your software system =           with MMK is the creation of a complete and accurate =           description file. This chapter describes the format 4           for a description file and its components.  L           __________________________________________________________________  %    2.1    Description File Components   =           A description file is a collection of the following            components:   @           o  Dependencies, which describe how one object depends*              on one or more other objects.  ?           o  Actions, which are commands to be executed when an &              object needs to be built.  @           o  Macro definitions, for defining symbols that may be&              used in rules or actions.  >           o  Inference rule definitions, which are rules basedA              on suffixes (and possibly directories as well), from A              which MMK can infer dependencies and actions without A              you having to list them explicitly in your makefile.   =           o  MMK directives, which provide a means for adding 8              commands to be executed before or after all>              other actions, provide a simple conditional-build@              mechanism, and other directives for modifying MMK's              behavior.      A                                                               2-1                     Description Files           :           Here is an example of a simple description file:  A                            PROGRAM.EXE : MAIN.OBJ,SUBROUTINES.OBJ M                                LINK/EXEC=PROGRAM.EXE MAIN.OBJ,SUBROUTINES.OBJ .                            MAIN.OBJ : MAIN.FOR+                                FORTRAN MAIN <                            SUBROUTINES.OBJ : SUBROUTINES.MAR0                                MACRO SUBROUTINES  9           This is a simple collection of dependencies and ;           actions for building an image called PROGRAM.EXE. 9           PROGRAM.EXE depends on two object files, called @           MAIN.OBJ and SUBROUTINES.OBJ; MAIN is a FORTRAN module,           and SUBROUTINES is a MACRO module.  >           MMK accepts either a colon or the DEC/MMS DEPENDS_ON?           keyword to separate a target object from its sources. =           In either case, the separator must be surrounded by ?           blanks-this differs from make, but is consistent with            DEC/MMS syntax.   L           __________________________________________________________________      2.2    Using Inference Rules   ?           MMK includes a collection of built-in inference rules =           and actions for most VMS programming languages. The >           rules are driven by the file type suffix attached to>           the object name; you must use the default file types4           in order to make use of the default rules.  ?           For example, the description file in the last section &           could be simplified to just:  A                            PROGRAM.EXE : MAIN.OBJ,SUBROUTINES.OBJ M                                LINK/EXEC=PROGRAM.EXE MAIN.OBJ,SUBROUTINES.OBJ .                            MAIN.OBJ : MAIN.FOR<                            SUBROUTINES.OBJ : SUBROUTINES.MAR  =           MMK's built-in inference rules automatically define :           the actions for building a .OBJ file from a .FOR=           (using the FORTRAN command) and for building a .OBJ :           file from a .MAR file (using the MACRO command).  
           2-2          A                                                 Description Files           @           The description file could even be simplified further,           to just:  A                            PROGRAM.EXE : MAIN.OBJ,SUBROUTINES.OBJ M                                LINK/EXEC=PROGRAM.EXE MAIN.OBJ,SUBROUTINES.OBJ   ;           MMK automatically searches the suffixes list when 6           constructing the dependency tree and locates;           inference rules for the .OBJ files automatically. >           This illustrates the second use for inference rules::           they are used not only for inferring actions for<           a dependency that omits them, but they may also be?           used for inferring dependencies themselves based on a @           combination of source and target suffixes. This second@           purpose can greatly simplify your makefiles, and makes+           the build process more automatic.   L           __________________________________________________________________  "    2.3    Defining Inference Rules  <           You can define your own inference rules, either to<           extend or replace the ones built into MMK. You may@           include these rule definitions in your makefile, or in>           a separate file called a rules file. Rules files can=           be included by the use of a logical name or through >           the /RULES qualifier on the MMK command; see the MMK"           for further information.  @           MMK supports two types of inference rules: generic and>           prefixed. Generic rules are based solely on suffixes           (file types), as in:  #                            .C.OBJ : D                                CC/OBJECT=$(MMS$TARGET) $(MMS$SOURCE)  =           which says, "to build filename.OBJ from an existing 9           file called filename.C, use the CC command." In >           general, generic rules work best when the source and4           target files reside in the same directory.  A                                                               2-3                     Description Files           =           Prefixed inference rules are based on both suffixes =           and "prefixes"-device and directory specifications. =           This provides a way to have MMK automatically infer =           dependenices between files that reside in different =           directories. For example: For example, the prefixed            rule:   1                            {SRC$:}.C{OBJ$:}.OBJ : D                                CC/OBJECT=$(MMS$TARGET) $(MMS$SOURCE)  8           tells MMK, "to build OBJ$:filename.OBJ from an:           existing file called SRC$:filename.C, use the CC?           command." This works like the generic rule above, but @           with the additional provision of having the source and/           target reside in different locations.   8           You can have more than one prefixed rule for a?           particular pair of suffixes; you may also mix generic ?           rules and prefixed rules for a pair of suffixes. When :           attempting to infer a dependency, MMK will first=           use the prefixed rules, then fall back to using the            generic rule.   ?           In prefixed rules, the curly braces ("{" and "}") are <           required. One of the two prefixes may be null, but@           specifying two null prefixes is equivalent to defining           a generic rule.   ?           In order to match a prefixed rule, file specification 9           as it exists in the description file must match 9           the prefix in the rule; MMK performs no logical ;           name translation on prefixes, nor can it identify ?           equivalencies between two prefixes that reference the 0           same directory using different syntax.  :           The first inference rule for a pair of suffixes,<           whether it is generic or prefixed, must specify an<           action list; subsequent rules for the same pair of@           suffixes (with different prefixes) may have the action=           list omitted, in which case MMK will use the action @           list from the first rule. For example, MMK already has7           a built-in generic rule for .C.OBJ, which is:   
           2-4          A                                                 Description Files           #                            .C.OBJ : ;                                $(CC)$(CFLAGS) $(MMS$SOURCE)   >           If you are simply adding a set of prefixed rules for?           the .C.OBJ suffix pair, you do not need to specify an =           action list on those rules; MMK will use the action .           list from the built-in generic rule.  L           __________________________________________________________________  :    2.4    Forced Setup/Teardown Actions in Inference Rules  >           MMK recognizes two special modifiers on action lines<           specified for inference rules. The setup modifier,=           "<", forces the execution of an action prior to any ?           unmodified action. The teardown modifier, ">", forces =           the execution of an action after all other actions. :           Setup and teardown actions are performed for all=           dependencies matching the inference rule, even if a /           dependency includes explicit actions.   )           For example, the inference rule   #                            .C.OBJ : N                                < DEFINE/USER DECC$SHR V6_ROOT:[SYSLIB]DECC$SHR=                                  $(CC)$(CFLAGS) $(MMS$SOURCE)   =           would cause the logical name DECC$SHR to be defined ;           prior to the invocation of the C compiler for all @           compilations into .OBJ files. This would apply even on;           dependencies containing explicit actions, such as   ,                            FRED.OBJ : FRED.CE                              $(CC)$(CFLAGS)/DEFINE=FRED $(MMS$SOURCE)   L           __________________________________________________________________  #    2.5    Modifying the Suffix List   ;           MMK uses a suffix list to determine the inference @           rules it should search for inferring a dependency. MMK=           has a built-in suffix list which goes with its list >           of built-in inference rules; see Appendix B for more<           information on the built-in rules and suffix list.  A                                                               2-5                     Description Files           8           You can augment or replace the built-in suffix<           list with your own suffixes by using the .SUFFIXES2           directive in a rules file or a makefile.  =           For example, let's say you have a Modula-2 compiler =           on your system, whose source files have a file type 9           (suffix) of .MOD. MMK has no built-in inference >           rules for this file type; you could add one with the           following sequence:   +                            .SUFFIXES : .MOD   %                            .MOD.OBJ : I                                MODULA2/OBJECT=$(MMS$TARGET) $(MMS$SOURCE)   <           The .SUFFIXES directive above adds the .MOD suffix<           to the end of the suffix list. This is followed by?           the inference rule for creating an object file from a            Modula-2 source file.   @           Specifying the .SUFFIXES directive with nothing to the@           right of the colon clears the current suffix list. You=           can do this to prevent MMK from using any inference ;           rules for the current build, or to follow it with ?           another .SUFFIXES directive that specifies only those ;           suffixes for which you want inference rules to be            enabled.  L           __________________________________________________________________      2.6    Using Conditionals  :           MMK provides several directives that can be used;           to modify the build sequence based on conditions. ?           These directives are .IF, .IFDEF, .IFNDEF, .ELSE, and ?           .ENDIF. The .IFDEF, .ELSE, and .ENDIF directives work =           the same as for MMS; the .IF and .IFNDEF directives <           are MMK extensions. The .IFNDEF directive provides>           the logical inverse to .IFDEF; the check succeeds if?           the specified macro is not defined. The .IF directive :           supports more general comparisons. Its syntax is  
           2-6          A                                                 Description Files           E                            .IF "expression1" comparison "expression2"   =           where expression1 and expression2 can be any string 6           that does not contain quotation marks. Macro;           references may be used in the expressions as long =           as the macro values do not contain quotation marks. ;           The comparison operator is either EQL (equals) or >           NEQ (not equals). The quotation marks around the two=           expressions are required. Comparisons are performed -           without regard to upper/lower case.   L           __________________________________________________________________  &    2.7    Deferring Macro Substitution  9           MMK provides a way to defer the resolution of a <           macro that is referenced in the right-hand side of<           a macro definition, as an extension to MMS. Macros;           are normally referenced using the $(name) syntax, ?           which causes the value of the macro to be substituted =           immediately when a line is parsed (except for MMK's ?           "special" macros, such as MMS$SOURCE and MMS$TARGET).   =           You can defer this substitution in MMK by using the 9           syntax ${name} instead. However, this syntax is ;           only recognized on the right-hand side of a macro =           definition. This can be useful when defining macros =           in a rules file that rely on macros that do not get ;           defined until another rules file or a description >           file gets processed. For example, you might have the/           following definition in a rules file:   b                            CFLAGS = /OBJECT=$(MMS$TARGET)/NOLIST/DEFINE=(VMS_BUILD,${MOREDEFINES})  ;           then in your description file, you can define the            MOREDEFINES macro:  9                            MOREDEFINES = ANOTHER_C_DEFINE   >           This will complete the CFLAGS macro value when it is3           referenced later in the description file.   A                                                               2-7                     Description Files         L           __________________________________________________________________  #    2.8    Macro String Substitution   8           MMK provides two mechanisms for causing string6           substitution to occur when resolving a macro;           reference: suffix substitution and general string            substitution.   %           ___________________________       2.8.1  Suffix Substitution   ?           When a string contains a list of file specifications, =           you can replace the file type suffixes on each file <           specification with a different suffix. The general/           form of this type of substitution is:   8                            $(macro-name:old-sfx=new-sfx)  ?           which causes the replacement of all occurences of the >           file type suffix old-sfx with new-sfx. Both suffixes            must begin with a dot.  2           For example, in these macro definitions:  ?                            SOURCES = FIRST.C, SECOND.C, THIRD.C 7                            OBJECTS = $(SOURCES:.C=.OBJ)   <           the OBJECTS macro would have the value "FIRST.OBJ,;           SECOND.OBJ, THIRD.OBJ". This form of substitution :           works with file specification lists separated by?           either blanks, commas, or both. The substitution rule @           following the colon may also contain blanks, which are6           ignored. Substitutions are case-insensitive.  %           ___________________________   %    2.8.2  General String Substitution   <           General string substitution in macro references is>           an extended feature of MMK. It looks very similar to=           suffix substitution, but uses a double colon ("::") ?           instead of a single colon and allows the substitution =           to occur anywhere within the string. The syntax is:   
           2-8          A                                                 Description Files           9                            $(macro-name::old-str=new-str)   ?           which causes the replacement of all occurences of the >           string old-str with new-str. You may use a backslash@           "\" as a "literal-next" escape when one of the strings=           contains an equals sign. Neither string may contain ?           a right parenthesis character (")"), even quoted with ?           a backslash, although this restriction will be lifted @           in a future release of MMK. For example, the following           macro definitions:  =                            SOURCES = FIRST.C,SECOND.C,THIRD.C 7                            SOURCEPLUS = $(SOURCES::,=+)   7           would cause SOURCEPLUS to contain the list of ?           filenames separated with plus signs ("+") rather than            commas.   >           General string substitutions in macro references are;           case-insensitive, but do not ignore blanks in the ?           macro value or in the substitution rule. For example, '           in the following definitions:   2                            TEST      = Xyz xYz xyZ7                            REPLACED  = $(TEST::YZ =YZ,)   @           the REPLACED macro would have the value "XYZ,xYZ,xyZ",@           due to the case-blind comparisons and the inclusion of1           the space in the old-str specification.                       A                                                               2-9                      A           _______________________________________________________        3      Using DEC/CMS with MMK      >           This chapter describes the use of Digital's DEC/Code/           Management System (DEC/CMS) with MMK.   L           __________________________________________________________________      3.1    The /CMS Qualifier  :           The MMK command supports a /CMS qualifier, which:           activates the automatic use of the currently set:           DEC/CMS library, or another DEC/CMS library that9           you specify, for the current build. This causes ?           source files to be fetched out of the DEC/CMS library 8           automatically, if needed. In addition, the MMK<           description file will automatically be fetched out6           of the DEC/CMS library if it does not exist.  :           The built-in suffix list and dependency rules in=           MMK include default rules for fetching source files >           out of DEC/CMS libraries. Suffixes ending in a tilde?           character ("~") signify DEC/CMS library elements. The >           built-in DEC/CMS element rules are used only if /CMS*           is specified on the MMK command.  L           __________________________________________________________________  )    3.2    Explicit CMS Element References   ?           You can explicitly reference a CMS library element in @           your MMK description file by adding a tilde to the end1           of the file specification. For example:   1                            MAIN.FOR  :  MAIN.FOR~   ;           You can also explicitly name the CMS library from >           which the element should be fetched, by specifying a'           device and/or directory name:   I                            MAIN.FOR  :  SOURCE_DISK:[CMS_SOURCE]MAIN.FOR~   A                                                               3-1                      Using DEC/CMS with MMK          <           If you do not explicitly name the CMS library, the>           currently set CMS library (set with CMS SET LIBRARY)           will be used.   %           ___________________________   +    3.2.1  Specifying the Element Generation   >           By default, MMK uses the qualifier /GENERATION=1+ on?           all CMS FETCH operations, to get the highest-numbered :           generation of a particular element, or whichever7           generation you specify on the MMK /GENERATION ;           qualifier. If you need to build a dependency on a =           specific generation of an element, you may do so by @           specifying the /GENERATION qualifier on the file name:  ?                            MAIN.FOR  :  MAIN.FOR~/GENERATION=37   <           The above example would cause generation 37 of the=           MAIN.FOR file in the current CMS library to be used            for the build.  L           __________________________________________________________________  '    3.3    Inference Rules for CMS Filesa  >           MMK comes with built-in inference rules for fetching<           source files from a CMS library. Like DEC/MMS, MMK9           uses these rules only when you specify the /CMSi?           qualifier on the MMK command. This allows you to have (           a makefile like the following:  .                            TEST.EXE : TEST.OBJ@                                $(LINK)$(LINKFLAGS) $(MMS$SOURCE)  .                            TEST.OBJ : TEST.FOR  @           If you have a CMS library set and you specify the /CMS>           qualifier on the MMK command, MMK will automatically=           check to see if TEST.FOR resides in the CMS libraryn9           and will fetch it out of the library if needed.n  9           However, MMK also allows you to omit the seconde<           dependency in the makefile, and will automatically@           "double-infer" the existence the .FOR file, even if it:           has not yet been fetched out of the CMS library.  
           3-2t         A                                            Using DEC/CMS with MMKw        %           ___________________________a  *    3.3.1  CMS and Prefixed Inference Rules  <           You can have MMK automatically search specific CMS@           libraries for source files by using prefixed inference=           rules. For example, if you were working on a cross-a9           platform development project which used two CMS 9           libraries - one for OS-specific source code and <           another for common source code - you might use the#           following prefixed rules:   ?                            {CMSSRC:[VMS_SPECIFIC]}.FOR~{}.FOR : 9                            {CMSSRC:[COMMON]}.FOR~{}.FOR :   ?           This sequence would cause MMK to automatically search =           the CMSSRC:[VMS_SPECIFIC] CMS library for a FORTRAN_?           source file, then search the CMSSRC:[COMMON] library. 9           If the file were not located in either library,_<           MMK would fall back to using the currently set CMS<           library. You must still have a CMS library set and>           you must specify the /CMS qualifier for prefixed CMS&           inference rules to be tried.                                    A                                                               3-3O G  K    
           MMK           A           ________________________________________________________  
           MMK   =           Invokes the MMK utility to build a software system.   A           _______________________________________________________              FORMAT              MMK  [target-name ...]  A           ________________________________________________________)           Command Qualifiers     DefaultsU  (           /[NO]ACTION            /ACTION0           /[NO]CHECK_STATUS      /NOCHECK_STATUS'           /[NO]CMS               /NOCMSN$           /CMS_LIBRARY=(dir-spec...)            /DESCRIPTION=file-spec           /DUMP_)           /[NO]FORCE             /NOFORCEP0           /[NO]FROM_SOURCES      /NOFROM_SOURCES1           /GENERATION=string     /GENERATION="1+"            /IDENTIFICATION_*           /[NO]IGNORE[=level]    /NOIGNORE-           /[NO]LOCAL_RULES       /LOCAL_RULES '           /[NO]LOG               /NOLOG_*           /MACRO=file-spec | definition...           /OUTPUT=file-specS,           /[NO]OVERRIDE          /NOOVERRIDE&           /[NO]RULES_FILE=file-spec...5           /[NO]SKIP_INTERMEDIATE/NOSKIP_INTERMEDIATES (           /[NO]VERIFY            /VERIFY%           /WORKING_DIRECTORY=dir-spec   A           _______________________________________________________              PARAMETERS           target-name_>           Name of the target to be built. The target name must>           be listed in the description file. If no target name<           is specified, MMK builds the first target it finds  
           3-4_         A                                                               MMK           :           in the description file. Multiple targets may be.           specified as a comma-separated list.  A           _______________________________________________________              DESCRIPTION ;           The MMK utility builds a software system from the @           objects and dependencies listed in a description file.;           See the documentation for additional information.   A           _______________________________________________________              QUALIFIERS           /[NO]ACTION_>           Determines whether action lines are executed or just?           displayed. Specifying /NOACTION causes MMK to displayr>           the action lines that would be executed to build the2           target, without actually executing them.             /[NO]CHECK_STATUS_=           Directs MMK to determine whether a target is up-to- @           date, without executing any action lines to do so. MMK>           sets the global symbol MMS$STATUS to 0 if the target>           requires updating, or 1 if the target is up-to-date.9           This qualifier overrides the /ACTION qualifier.              /[NO]CMS9           Determines whether a DEC/Code Management System =           (CMS) library is automatically searched for the MMK @           description file and for any source files. The default0           is /NOCMS, which omits any CMS checks.  $           /CMS_LIBRARY=(dir-spec...)@           Specifies one or more DEC/Code Management System (CMS)?           libraries to be searched for the MMK description file_@           and for any source files that do not have explicit CMS=           library specifications. Effective only when /CMS is_=           also specified. If omitted, the default CMS library @           or libraries (from the logical name CMS$LIB or the CMS(           SET LIBRARY command) are used.  A                                                               3-5          
           MMKh                      /DESCRIPTION=file-spec?           Specifies an alternative name for the MMK description @           file. The default description file name is DESCRIP.MMS<           (in the current default directory), with MAKEFILE.3           being used if DESCRIP.MMS does not exist.              /DUMP_;           Causes MMK to dump the suffix list, all currently 6           defined macros, all inference rules, and all@           dependencies to the current output before starting the?           build. This qualifier is useful in debugging problems_'           in rules files and makefiles.              /[NO]FORCE:           Specifying /FORCE causes MMK to execute only the?           action lines from the dependency rule for the target,d9           without performing any revision date checks and)4           without building any intermediate targets.             /[NO]FROM_SOURCESo:           Specifying /FROM_SOURCES causes MMK to perform a@           complete build of the target, ignoring revision dates.;           All actions to build all intermediate targets aret           executed.o             /GENERATION=string>           Specifies the default generation to be used when MMK<           fetches elements out of a CMS library. If omitted,;           the default generation is "1+", which fetches the <           highest-numbered generation of an element. You can<           use this qualifier in combination with CMS classes?           to have MMK build a specific version of your software >           system, provided that all source code for the system/           is fetched from CMS during the build.i             /IDENTIFICATIONv>           Specifying /IDENTIFICATION causes MMK to display its?           revision information and a copyright message, withouta&           performing any other action.  
           3-6     C    A                                                               MMK                      /[NO]IGNORE[=level] <           By default, MMK stops when an executed action line=           results in a warning, error, or fatal error status.s<           You can override this by specifying /IGNORE. Using:           /IGNORE or /IGNORE=FATAL causes all errors to be=           ignored; specifying /IGNORE=ERROR causes errors and_<           warnings to be ignored; specifying /IGNORE=WARNING-           causes only warnings to be ignored.K             /[NO]LOCAL_RULES7           Controls whether site-specific inference rule >           definitions are read in. By default, they are if the?           logical name MMK_LOCAL_RULES is defined and points toi@           a readable description file. Specifying /NOLOCAL_RULES'           prevents this from occurring.e             /[NO]LOG=           Controls whether MMK logs a detailed description ofp0           its activity. By default, it does not.  +           /MACRO=file-spec | definintion... >           Defines one or more macros that can be referenced by>           the description file. If a name is specified with no=           equals sign ("="), it is first assumed to be a filee>           specification; if the file exists, macro definitions@           are read from the file. A file type of .MMS is assumed=           if no file type is specified. If the file cannot be ?           found, the name is treated as macro definition, and af9           value of 1 is assigned to the macro by default.r  ?           If an equals sign is present, the macro definition ish/           taken directly from the command line.i  ?           Macro definitions contained in a file should have thei@           same syntax as macro definitions in description files,<           with the added restrictions that comments and line(           continuations are not allowed.             /OUTPUT=file-spec 9           Directs MMK output to a location other than the            default, SYS$OUTPUT.  A                                                               3-7h         
           MMKu                     /[NO]OVERRIDEc<           Determines the order in which macro references are?           resolved. The default order is to resolve macros from >           command-line definitions, followed by definitions in?           the description file and any rules files, followed byn?           MMK built-ins. If a macro cannot be resolved from anyy<           of these sources, a check is made for a DCL symbol>           with the same name as the macro, and if present, the!           symbol's value is used.   >           When /OVERRIDE is specified, DCL symbols are checked=           before the macro definitions in the description andr:           rules files, and before the MMK built-in macros.  (           /[NO]RULES_FILE[=file-spec...]7           Specifies the name of one or more descriptioni:           files containing inference rules. If /RULES_FILE;           is specified with no file specification, the name =           MMS$RULES is used by default (this can be a logicalt>           name or can reference a file called MMS$RULES.MMS in!           the current directory).   @           If /NORULES_FILE is specified, the compiled-in default>           rules are not loaded when MMK is started, nor is any=           personal rules file (pointed to by the logical name =           MMK_PERSONAL_RULES). /NORULES_FILE does not preventr;           the loading of local rules; you must also specifyg:           /NOLOCAL_RULES to prevent local rules from being           loaded.e  !           /[NO]SKIP_INTERMEDIATESe:           By default, MMK attempts to build missing source<           files if they can be built through the application=           of dependency or inference rules. Specifying /SKIP_ 9           INTERMEDIATES causes MMK to treat these missing =           sources as if they exist and have the same revision =           date/time stamp as the target that depends on them.       
           3-8  w  h    A                                                               MMKa          9           For example, if the target is a .EXE file whichs<           depends on a .OBJ file, and that .OBJ file in turn=           depends on a .C file, by default MMK will build the_@           .OBJ file if it is missing, and then in turn build the@           .EXE. If /SKIP_INTERMEDIATES is specified, the missing<           .OBJ file will not trigger a build; the build will@           only occur if the .C file is newer than the .EXE file.             /[NO]VERIFY 5           Controls whether MMK echoes action lines to )           SYS$OUTPUT. Enabled by default._  %           /WORKING_DIRECTORY=dir-spec >           Causes MMK to SET DEFAULT to the specified directory:           before processing the description file. This can:           be useful when using the /NOACTION qualifier for:           a build in a directory containing subdirectories>           with their own description files, since only actions>           invoking $(MMS) get executed when /NOACTION is used.#           By replacing the actions:   8                              SET DEFAULT [.subdirectory]4                              $(MMS) $(MMSQUALIFIERS)             with the actiond  V                              $(MMS) $(MMSQUALIFIERS)/WORKING_DIRECTORY=[.subdirectory]  =           the entire multi-directory build can be tested withe!           /NOACTION successfully.e                    A                                                               3-9t a                   A           _______________________________________________________i  -    A      Differences between MMK and DEC/MMS       <           MMK is patterned after DEC/MMS, but does not fully@           implement all DEC/MMS functionality and provides other=           extended functionality. This appendix lists some ofn2           the differences between MMK and DEC/MMS.  =           Besides the differences in features, there are someC;           differences in processing between MMK and DEC/MMS >           which may lead to different results or syntax errors=           in MMK for description files which operate properlyS<           under DEC/MMS. If possible, please report any such>           differences to the author so that they can be fixed.  L           __________________________________________________________________  /    A.1    DEC/MMS Features Not Supported in MMKJ  >           MMK does not support the following DEC/MMS features:  8           o  MMK does not support FMS forms libraries or&              CDD/Repository libraries.  8           o  MMK does not honor the "; action" syntax onA              dependency rule lines that can be used with DEC/MMS. 9              Make sure all actions are on separate lines.   9           o  MMK requires the leading dot on the .INCLUDE_              directive._  ;           o  MMK does not handle wildcard dependency rules.   ?           o  MMK does not support all of the command qualifiers 9              supported by DEC/MMS. In addition, the MMK's ?              /GENERATION qualifier is completely different from +              DEC/MMS's /GENERATE qualifier.l  6           o  MMK does not have a DECwindows interface.  A                                                               A-1e o       -           Differences between MMK and DEC/MMS           ?           o  MMK does not automatically load the MMS$RULES file @              if that logical name is defined or that file exists>              in the current directory; you must specify /RULES?              on the MMK command to have it loaded. Use the MMK_-?              LOCAL_RULES or MMK_PERSONAL_RULES logical names too4              have rules automatically loaded by MMK.  L           __________________________________________________________________      A.2    MMK Extended Features   :           MMK includes the following features not found in           DEC/MMS:  ?           o  MMK gives you more options for rules files, and isf@              set up to allow multiple rules files to be present.8              Rule file processing follows this sequence:  =             1  The default rules compiled into MMK are loaded >                automatically unless /NORULES_FILE is specified"                on the MMK command.  8             2  A site-defined local rules file is loaded@                automatically if the logical name MMK_LOCAL_RULES;                is defined (use /NOLOCAL_RULES to override).a  =             3  If the /RULES_FILE qualifier is specified, anya;                rules files listed there are loaded; if noneb:                are listed, the default is to load the file;                MMS$RULES.MMS (or the file pointed to by the '                logical name MMS$RULES).   9                If the /RULES_FILE qualifier is omitted, a_;                personal rules file is loaded if the logicali?                name MMK_PERSONAL_RULES is defined. MMS$RULES is '                not loaded in this case.l  ?                If /NORULES_FILE is specified, neither MMS$RULESd5                nor the personal rules file is loaded.e  >              These rules-processing features, coupled with the?              ability to redefine macros defined in rules files,a<              make it easier to customize MMK's behavior when              needed.  
           A-2t t  s    A                               Differences between MMK and DEC/MMS           8           o  MMK trims blanks out of $(MMS$SOURCE_LIST).  A           o  MMK includes support for the following special localT              macros:  ;             o  $(MMS$SOURCE_LIST_SPACES) - source list withe6                spaces as separators instead of commas.  ;             o  $(MMS$CHANGED_LIST_SPACES) - list of changedh;                sources with spaces as separators instead oft                commas.  @             o  $(MMS$SOURCE_NAME) - like $(MMS$TARGET_NAME), but!                for $(MMS$SOURCE).   =             o  $(MMS$TARGET_FNAME) - like $(MMS$TARGET_NAME), 8                but does not include the device/directory0                specification, just the filename.  >             o  $(MMS$TARGET_MODULE) - name of the module being9                replaced in a text, help, macro, or objectm                library.   >           o  MMK will display activity in the subprocess while;              action lines are being executed when you pressS              CTRL/T.  /           o  MMK allows you to redefine macros.   ?           o  MMK, in most cases, has more flexible syntax rulesmA              for its description files, allowing blanks where MMSt?              does not (e.g., in library module specifications).t  >           o  MMK pre-defines the macros __VAX__  for builds on?              VAX systems, __AXP__  for builds on Alpha systems,;5              and __I64__  for builds on IA64 systems.d  @           o  MMK supports prefixed inference rules (described in              Section 2.3).  >           o  When used with DEC/CMS, MMK will "double-infer" a>              dependency on a non-existent source file, if that5              file currently resides in a CMS library.f  9           o  MMK includes a /DUMP qualifier for debuggingn%              problems with makefiles.   A                                                               A-3r ,  l    -           Differences between MMK and DEC/MMSc          <           o  MMK provides a /GENERATION qualifier on the MMKA              command for specifying the default CMS generation toe@              be used when elements are checked for revisions and               fetched out of CMS.  ;           o  MMK provides the /WORKING_DIRECTORY qualifier.r  <           o  MMK allows "generic" targets (those that do not@              refer to an actual file) to have null action lists.=              MMS requires all targets to have an action list.y  A           o  MMK adds the ${name} syntax for deferring resolutiont8              of macros on the right-hand side of a macro              definition.  A           o  MMK adds a generic string-susbstitution function for               macro references.  ?           o  MMK adds the .IFNDEF and .IF directives to make it -              easier to conditionalize builds.   ?           You should avoid using these extended features if youm6           need to maintain compatibility with DEC/MMS.  L           __________________________________________________________________      A.3    Other Differences   ?           Besides the feature differences alrady mentioned, MMK_?           operates somewhat differently from DEC/MMS in some of >           its processing. In most cases, these differences are@           not significant, but they are worth remembering if you@           need to port DEC/MMS description files to or from MMK.  >           o  MMK allows any rule, including built-in rules, toA              override the .DEFAULT actions. DEC/MMS lets .DEFAULT -              actions override built-in rules.   :           o  When a build action does not update a target,>              MMK will issue an information message, except for?              generic targets. DEC/MMS only issues such messages               in certain cases.  
           A-4          A                               Differences between MMK and DEC/MMSO          @           o  MMK explicitly builds dependency rules for files on>              which library modules depend, even if those files<              are not mentioned in the description file. This?              may lead to MMK behaving differently from DEC/MMS,yA              although if the description file is correct, the enda%              result will be the same.B  7           o  MMK parses comments and continuation linesI:              differently, so that a hyphen at the end of a<              comment is not considered a continuation of the              comment.   @           o  MMK is more lenient about applying inference rules.=              It only checks for a match on the suffix and, if ?              present, the prefix. If you have a dependency with ?              an explicit target and source that match by suffix =              (and possibly prefix), even if the base names do >              not match, the inference rule can be applied. MMSA              requires that base names match to apply an inferenceu?              rule. Note that MMK's behavior may change to matchn%              MMS in a future release.   :           As other differences are brought to the author's=           attention, they will either be fixed or noted here.y                                A                                                               A-5n e                   A           _______________________________________________________n  #    B      Built-in Dependency Rules       =           The dependency rules built into MMK for VAX systems >           are shown in Figure B-1; those for Alpha systems are=           shown in Figure B-2; and those for IA64 systems areu           show in Figure B-3.h  8           Figure B-1  MMK default dependency rules - VAXA           _______________________________________________________   !           ! MMK_DEFAULT_RULES.MMSU           !iS           !   COPYRIGHT  1993, 1994, 1997  MADGOAT SOFTWARE.  ALL RIGHTS RESERVED.Y           ! E           !  Default build rules for use with MMK.  (for VAX systems)o           ! "           !  Modification history:           !S:           !   23-DEC-1992 V1.0 Madison     Initial coding.P           !   17-OCT-1993 V1.1 Madison     Elimination of intermediate libfiles.F           !   11-APR-1994 V1.2 Madison     Make rules more like MMS's.;           !   01-JUL-1994 V2.0 Madison     Add CMS support.r;           !   16-JUL-1994 V2.1 Madison     Update for V3.2.nL           !   22-AUG-1994 V2.1-1 Madison     Eliminate DELETE_SOURCE checks.;           !   14-OCT-1994 V2.2 Madison     Add CXX support. C           !   28-DEC-1994 V2.3 Madison     Make IF commands silent.dI           !   20-JUN-1997 V2.3-1 Madison     Add .MAR.MLB inference rule.            !o  A           _______________________________________________________e(           Figure B-1 Cont'd on next page          A                                                               B-1          #           Built-in Dependency Rules         @           Figure B-1 (Cont.)  MMK default dependency rules - VAXA           _______________________________________________________n             !nS           ! These symbols can be used to distinguish MMK from DEC's DEC/MMS product $           ! using .IFDEF directives.           ! '           __MATTS_MMS__ = __MATTS_MMS__n           __MMK__ = __MMK__            __MMK_V32__ = 1              !eL           ! This symbol can be used to distinguish a VAX-based build from anE           ! AXP-based build. (or use .IFDEF __AXP__ .ELSE ... .ENDIF)            !d           __VAX__ = 1              EXE = .EXE           OLB = .OLB           OBJ = .OBJ           OPT = .OPT           L32 = .L32  7           .SUFFIXES :     ! clear the suffix list firstu^           .SUFFIXES : $(EXE) $(OLB) $(OBJ) .TLB .HLB .MLB $(L32) .C .CXX .BAS .B32 .BLI .FOR -U                    .COB .COR .DBL .RPG .SCN .PLI .PEN .PAS .MAC .MAR .MSG .CLD .R32 -aO                    .REQ .TXT .H .MEM .HLP .RNH .RNO .MMS .DAT .OPT .SDML .COM - T                    .C~ .CXX~ .BAS~ .B32~ .BLI~ .FOR~ .COB~ .COR~ .DBL~ .RPG~ .SCN~ -J                    .PLI~ .PAS~ .MAC~ .MAR~ .MSG~ .CLD~ .R32~ .REQ~ .TXT~ -G                    .H~ .HLP~ .RNH~ .RNO~ .MMS~ .DAT~ .OPT~ .SDML~ .COM~,             LINK     = LINKn+           LINKFLAGS   = /EXEC=$(MMS$TARGET)r             $(OBJ)$(OLB) :W               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE $(MMS$TARGET)t=               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)e             .TXT.TLB :\               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/TEXT $(MMS$TARGET)Y               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)/MODULE=$(MMS$TARGET_MODULE)D  A           _______________________________________________________d(           Figure B-1 Cont'd on next page  
           B-2          A                                         Built-in Dependency RulesC        @           Figure B-1 (Cont.)  MMK default dependency rules - VAXA           _______________________________________________________              .HLP.HLB :\               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/HELP $(MMS$TARGET)=               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)              .MAC.MLB :]               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/MACRO $(MMS$TARGET) =               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)              .MAR.MLB :]               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/MACRO $(MMS$TARGET) =               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)l             LIBR     = LIBRARY            LIBRFLAGS   = /REPLACE             .BAS$(OBJ) :/               $(BASIC)$(BASFLAGS) $(MMS$SOURCE)t           BASIC     = BASIC ?           BASFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)s             .BLI$(OBJ) :-               $(BLISS)$(BFLAGS) $(MMS$SOURCE)d           .B32$(OBJ) :-               $(BLISS)$(BFLAGS) $(MMS$SOURCE) >           BFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)             .C$(OBJ) :*               $(CC)$(CFLAGS) $(MMS$SOURCE)           CC       = CCS>           CFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)             .COB$(OBJ) :/               $(COBOL)$(COBFLAGS) $(MMS$SOURCE)o           COBOL     = COBOL ?           COBFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ),  A           _______________________________________________________l(           Figure B-1 Cont'd on next page  A                                                               B-3_ _  _    #           Built-in Dependency Rulest        @           Figure B-1 (Cont.)  MMK default dependency rules - VAXA           _______________________________________________________              .COR$(OBJ) :/               $(CORAL)$(CORFLAGS) $(MMS$SOURCE)            CORAL     = CORALt?           CORFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)T             .CXX$(OBJ) :-               $(CXX)$(CXXFLAGS) $(MMS$SOURCE)            CXX      = CXX?           CXXFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)o             .DBL$(OBJ) :/               $(DIBOL)$(DBLFLAGS) $(MMS$SOURCE)s           DIBOL     = DIBOLd?           DBLFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)i             .CLD$(OBJ) :3               $(SETCMD)$(SETCMDFLAGS) $(MMS$SOURCE)N"           SETCMD     = SET COMMAND?           SETCMDFLAGS = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)              .FOR$(OBJ) :,               $(FORT)$(FFLAGS) $(MMS$SOURCE)           FORT        = FORTRANl?           FFLAGS      = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)              .MAR$(OBJ) :-               $(MACRO)$(MFLAGS) $(MMS$SOURCE)            MACRO     = MACRO >           MFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)             .MSG$(OBJ) :1               $(MESSAGE)$(MSGFLAGS) $(MMS$SOURCE)m           MESSAGE     = MESSAGEs?           MSGFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)   A           _______________________________________________________s(           Figure B-1 Cont'd on next page  
           B-4f t  s    A                                         Built-in Dependency Rules         @           Figure B-1 (Cont.)  MMK default dependency rules - VAXA           _______________________________________________________n             .PAS$(OBJ) :.               $(PASCAL)$(PFLAGS) $(MMS$SOURCE)           .PAS.PEN   :1               $(PASCAL)$(PENVFLAGS) $(MMS$SOURCE)            PASCAL     = PASCAL >           PFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)B           PENVFLAGS   = /ENVIRONMENT=$(MMS$TARGET_NAME).PEN/NOLIST             .PLI$(OBJ) :-               $(PLI)$(PLIFLAGS) $(MMS$SOURCE)a           PLI      = PLI?           PLIFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)_             .REQ$(L32) :N               $(BLISS)/LIBR=$(MMS$TARGET_NAME)$(L32)$(BLIBFLAGS) $(MMS$SOURCE)           .R32$(L32) :N               $(BLISS)/LIBR=$(MMS$TARGET_NAME)$(L32)$(BLIBFLAGS) $(MMS$SOURCE)           BLISS     = BLISS            BLIBFLAGS   = /NOLISTr             .RPG$(OBJ) :-               $(RPG)$(RPGFLAGS) $(MMS$SOURCE)            RPG      = RPG?           RPGFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)i             .RNH.HLP :.               $(RUNOFF)$(RFLAGS) $(MMS$SOURCE)           .RNO.MEM :.               $(RUNOFF)$(RFLAGS) $(MMS$SOURCE)           RUNOFF     = RUNOFF ,           RFLAGS     = /OUTPUT=$(MMS$TARGET)  A           _______________________________________________________e(           Figure B-1 Cont'd on next page        A                                                               B-5  y       #           Built-in Dependency Ruleso        @           Figure B-1 (Cont.)  MMK default dependency rules - VAXA           _______________________________________________________              .SCN$(OBJ) :/               $(SCAN)$(SCANFLAGS) $(MMS$SOURCE)M           SCAN     = SCANn?           SCANFLAGS   = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)a             CMS      = CMS           CMSCOMMENT  = ""2           CMSFLAGS    = /GENERATION=$(MMS$CMS_GEN)             .B32~.B32 : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)ac            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).B32 $(CMSFLAGS) $(CMSCOMMENT)              .BAS~.BAS : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).BAS $(CMSFLAGS) $(CMSCOMMENT)              .BLI~.BLI :iY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Gc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).BLI $(CMSFLAGS) $(CMSCOMMENT)              .C~.C :eY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)ea            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).C $(CMSFLAGS) $(CMSCOMMENT)y             .CLD~.CLD :cY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)rc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).CLD $(CMSFLAGS) $(CMSCOMMENT)h             .COB~.COB :sY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).COB $(CMSFLAGS) $(CMSCOMMENT)              .COR~.COR :eY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).COR $(CMSFLAGS) $(CMSCOMMENT)y             .COM~.COM :lY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY):c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).COM $(CMSFLAGS) $(CMSCOMMENT))  A           _______________________________________________________ (           Figure B-1 Cont'd on next page  
           B-6C         A                                         Built-in Dependency Rulesh        @           Figure B-1 (Cont.)  MMK default dependency rules - VAXA           _______________________________________________________              .CXX~.CXX :cY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)"c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).CXX $(CMSFLAGS) $(CMSCOMMENT)              .DAT~.DAT : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)_c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).DAT $(CMSFLAGS) $(CMSCOMMENT)K             .DBL~.DBL :cY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY).c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).DBL $(CMSFLAGS) $(CMSCOMMENT)              .FOR~.FOR : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)tc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).FOR $(CMSFLAGS) $(CMSCOMMENT)F             .H~.H : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Ma            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).H $(CMSFLAGS) $(CMSCOMMENT)              .HLP~.HLP :hY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).HLP $(CMSFLAGS) $(CMSCOMMENT)a             .MAC~.MAC : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MAC $(CMSFLAGS) $(CMSCOMMENT)              .MAR~.MAR : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MAR $(CMSFLAGS) $(CMSCOMMENT)_             .MMS~.MMS :_Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MMS $(CMSFLAGS) $(CMSCOMMENT)              .MSG~.MSG : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MSG $(CMSFLAGS) $(CMSCOMMENT)D  A           ________________________________________________________(           Figure B-1 Cont'd on next page  A                                                               B-7          #           Built-in Dependency Rules         @           Figure B-1 (Cont.)  MMK default dependency rules - VAXA           _______________________________________________________U             .OPT~.OPT :[Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Ic            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).OPT $(CMSFLAGS) $(CMSCOMMENT)R             .PAS~.PAS : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).PAS $(CMSFLAGS) $(CMSCOMMENT)              .PLI~.PLI :IY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).PLI $(CMSFLAGS) $(CMSCOMMENT)              .R32~.R32 :lY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)_c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).R32 $(CMSFLAGS) $(CMSCOMMENT)l             .REQ~.REQ :tY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)ec            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).REQ $(CMSFLAGS) $(CMSCOMMENT)_             .RNH~.RNH : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)tc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).RNH $(CMSFLAGS) $(CMSCOMMENT)n             .RNO~.RNO : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Ac            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).RNO $(CMSFLAGS) $(CMSCOMMENT)n             .SCN~.SCN :sY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)uc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).SCN $(CMSFLAGS) $(CMSCOMMENT)              .SDML~.SDML : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)cd            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).SDML $(CMSFLAGS) $(CMSCOMMENT)             .TXT~.TXT :aY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)/c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).TXT $(CMSFLAGS) $(CMSCOMMENT)   A           _______________________________________________________ (           Figure B-1 Cont'd on next page  
           B-8     o    A                                         Built-in Dependency Ruless        @           Figure B-1 (Cont.)  MMK default dependency rules - VAXA           _______________________________________________________ A           _______________________________________________________R  :           Figure B-2  MMK default dependency rules - AlphaA           _______________________________________________________n  %           ! MMK_DEFAULT_RULES_AXP.MMSr           !iM           !   COPYRIGHT  1993, 1997  MADGOAT SOFTWARE.  ALL RIGHTS RESERVED.            !DE           !  Default build rules for use with MMK.  (for OpenVMS AXP)            ! "           !  Modification history:           !e:           !   23-DEC-1992 V1.0 Madison     Initial coding.H           !   17-OCT-1993 V1.1 Madison     Delete intermediate libfiles.F           !   11-APR-1994 V1.2 Madison     Make rules more like MMS's.;           !   05-JUL-1994 V2.0 Madison     Add CMS support.s;           !   16-JUL-1994 V2.1 Madison     Update for V3.2. L           !   22-AUG-1994 V2.1-1 Madison     Eliminate DELETE_SOURCE checks.;           !   14-OCT-1994 V2.2 Madison     Add CXX support.pC           !   28-DEC-1994 V2.3 Madison     Make IF commands silent.iI           !   20-JUN-1997 V2.3-1 Madison     Add .MAR.MLB inference rule.a           !t  A           _______________________________________________________ (           Figure B-2 Cont'd on next page                          A                                                               B-9     a    #           Built-in Dependency Rules         <           Figure B-2 (Cont.)  MMK default dependency rules -#                               Alpha A           _______________________________________________________              ! Q           ! This symbol can be used to distinguish MMK from DEC's DEC/MMS productd$           ! using .IFDEF directives.           !C'           __MATTS_MMS__ = __MATTS_MMS__I           __MMK__ = __MMK__            __MMK_V32__ = 1i           !rN           ! These symbols can be used to distinguish an AXP-based build from a           ! VAX-based build.           !            __ALPHA__ = 1            __AXP__   = 1              EXE = .EXE           OLB = .OLB           OBJ = .OBJ           OPT = .OPT           L32 = .L32  7           .SUFFIXES :     ! clear the suffix list first ^           .SUFFIXES : $(EXE) $(OLB) $(OBJ) .TLB .HLB .MLB $(L32) .C .CXX .BAS .B32 .BLI .FOR -U                    .COB .COR .DBL .RPG .SCN .PLI .PEN .PAS .MAC .MAR .M64 .MSG .CLD -nT                    .R32 .REQ .TXT .H .MEM .HLP .RNH .RNO .MMS .DAT .OPT .SDML .COM -T                    .C~ .CXX~ .BAS~ .B32~ .BLI~ .FOR~ .COB~ .COR~ .DBL~ .RPG~ .SCN~ -P                    .PLI~ .PAS~ .MAC~ .MAR~ .M64~ .MSG~ .CLD~ .R32~ .REQ~ .TXT~ -G                    .H~ .HLP~ .RNH~ .RNO~ .MMS~ .DAT~ .OPT~ .SDML~ .COM~d             LINK     = LINKy+           LINKFLAGS   = /EXEC=$(MMS$TARGET)r             $(OBJ)$(OLB) :W               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE $(MMS$TARGET)c=               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)|  A           _______________________________________________________f(           Figure B-2 Cont'd on next page             B-10 i  w    A                                         Built-in Dependency Rules         <           Figure B-2 (Cont.)  MMK default dependency rules -#                               AlphapA           _______________________________________________________e             .TXT.TLB :\               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/TEXT $(MMS$TARGET)Y               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)/MODULE=$(MMS$TARGET_MODULE)h             .HLP.HLB :\               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/HELP $(MMS$TARGET)=               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)e             .MAC.MLB :]               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/MACRO $(MMS$TARGET) =               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)o             .MAR.MLB :]               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/MACRO $(MMS$TARGET) =               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)              LIBR     = LIBRARY            LIBRFLAGS   = /REPLACE             .BAS$(OBJ) :/               $(BASIC)$(BASFLAGS) $(MMS$SOURCE)n           BASIC     = BASICb?           BASFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)l             .BLI$(OBJ) :-               $(BLISS)$(BFLAGS) $(MMS$SOURCE)f           .B32$(OBJ) :-               $(BLISS)$(BFLAGS) $(MMS$SOURCE) >           BFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)             .C$(OBJ) :*               $(CC)$(CFLAGS) $(MMS$SOURCE)           CC       = CCc>           CFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)  A           _______________________________________________________ (           Figure B-2 Cont'd on next page  A                                                              B-11i    t    #           Built-in Dependency Rules         <           Figure B-2 (Cont.)  MMK default dependency rules -#                               AlphanA           _______________________________________________________U             .COB$(OBJ) :/               $(COBOL)$(COBFLAGS) $(MMS$SOURCE)E           COBOL     = COBOLn?           COBFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)              .COR$(OBJ) :/               $(CORAL)$(CORFLAGS) $(MMS$SOURCE)            CORAL     = CORALO?           CORFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)s             .CXX$(OBJ) :-               $(CXX)$(CXXFLAGS) $(MMS$SOURCE)            CXX      = CXX?           CXXFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)              .DBL$(OBJ) :/               $(DIBOL)$(DBLFLAGS) $(MMS$SOURCE)t           DIBOL     = DIBOL ?           DBLFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)              .CLD$(OBJ) :3               $(SETCMD)$(SETCMDFLAGS) $(MMS$SOURCE)y"           SETCMD     = SET COMMAND?           SETCMDFLAGS = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)              .FOR$(OBJ) :,               $(FORT)$(FFLAGS) $(MMS$SOURCE)           FORT        = FORTRAN ?           FFLAGS      = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)              .MAR$(OBJ) :-               $(MACRO)$(MFLAGS) $(MMS$SOURCE)e%           MACRO     = MACRO/MIGRATIONu>           MFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)  A           _______________________________________________________m(           Figure B-2 Cont'd on next page             B-12    l    A                                         Built-in Dependency Rules         <           Figure B-2 (Cont.)  MMK default dependency rules -#                               Alpha A           _______________________________________________________a             .M64$(OBJ) :/               $(TASM)$(TASMFLAGS) $(MMS$SOURCE)s           TASM     = MACRO?           TASMFLAGS   = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)r             .MSG$(OBJ) :1               $(MESSAGE)$(MSGFLAGS) $(MMS$SOURCE)t           MESSAGE     = MESSAGE ?           MSGFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)O             .PAS$(OBJ) :.               $(PASCAL)$(PFLAGS) $(MMS$SOURCE)           .PAS.PEN   :1               $(PASCAL)$(PENVFLAGS) $(MMS$SOURCE)M           PASCAL     = PASCALt>           PFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)B           PENVFLAGS   = /ENVIRONMENT=$(MMS$TARGET_NAME).ENV/NOLIST             .PLI$(OBJ) :-               $(PLI)$(PLIFLAGS) $(MMS$SOURCE)            PLI      = PLI?           PLIFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)              .REQ$(L32) :N               $(BLISS)/LIBR=$(MMS$TARGET_NAME)$(L32)$(BLIBFLAGS) $(MMS$SOURCE)           .R32$(L32) :N               $(BLISS)/LIBR=$(MMS$TARGET_NAME)$(L32)$(BLIBFLAGS) $(MMS$SOURCE)           BLISS     = BLISSc           BLIBFLAGS   = /NOLIST              .RPG$(OBJ) :-               $(RPG)$(RPGFLAGS) $(MMS$SOURCE)            RPG      = RPG?           RPGFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)e  A           _______________________________________________________M(           Figure B-2 Cont'd on next page  A                                                              B-13h e  e    #           Built-in Dependency Ruleso        <           Figure B-2 (Cont.)  MMK default dependency rules -#                               Alpha A           _______________________________________________________              .RNH.HLP :.               $(RUNOFF)$(RFLAGS) $(MMS$SOURCE)           .RNO.MEM :.               $(RUNOFF)$(RFLAGS) $(MMS$SOURCE)           RUNOFF     = RUNOFF ,           RFLAGS     = /OUTPUT=$(MMS$TARGET)             .SCN$(OBJ) :/               $(SCAN)$(SCANFLAGS) $(MMS$SOURCE)n           SCAN     = SCANe?           SCANFLAGS   = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)e             CMS      = CMS           CMSCOMMENT  = ""2           CMSFLAGS    = /GENERATION=$(MMS$CMS_GEN)             .B32~.B32 :aY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)ac            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).B32 $(CMSFLAGS) $(CMSCOMMENT)i             .BAS~.BAS :tY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Cc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).BAS $(CMSFLAGS) $(CMSCOMMENT)              .BLI~.BLI :wY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)fc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).BLI $(CMSFLAGS) $(CMSCOMMENT)i             .C~.C :cY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)La            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).C $(CMSFLAGS) $(CMSCOMMENT)              .CLD~.CLD :_Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)ec            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).CLD $(CMSFLAGS) $(CMSCOMMENT)M  A           _______________________________________________________u(           Figure B-2 Cont'd on next page             B-14 l  i    A                                         Built-in Dependency Ruless        <           Figure B-2 (Cont.)  MMK default dependency rules -#                               Alpha A           _______________________________________________________              .COB~.COB : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Oc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).COB $(CMSFLAGS) $(CMSCOMMENT)              .COR~.COR :hY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).COR $(CMSFLAGS) $(CMSCOMMENT)              .COM~.COM :SY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)ic            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).COM $(CMSFLAGS) $(CMSCOMMENT)              .CXX~.CXX :IY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)ec            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).CXX $(CMSFLAGS) $(CMSCOMMENT)t             .DAT~.DAT : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).DAT $(CMSFLAGS) $(CMSCOMMENT)/             .DBL~.DBL : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).DBL $(CMSFLAGS) $(CMSCOMMENT)i             .FOR~.FOR :sY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)oc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).FOR $(CMSFLAGS) $(CMSCOMMENT)              .H~.H :UY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) a            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).H $(CMSFLAGS) $(CMSCOMMENT)d             .HLP~.HLP :sY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)ec            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).HLP $(CMSFLAGS) $(CMSCOMMENT)              .MAC~.MAC :cY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Sc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MAC $(CMSFLAGS) $(CMSCOMMENT)s  A           _______________________________________________________p(           Figure B-2 Cont'd on next page  A                                                              B-15          #           Built-in Dependency Rulesb        <           Figure B-2 (Cont.)  MMK default dependency rules -#                               AlphauA           _______________________________________________________n             .MAR~.MAR : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MAR $(CMSFLAGS) $(CMSCOMMENT)n             .M64~.M64 : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).M64 $(CMSFLAGS) $(CMSCOMMENT)n             .MMS~.MMS :MY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)mc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MMS $(CMSFLAGS) $(CMSCOMMENT)r             .MSG~.MSG : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MSG $(CMSFLAGS) $(CMSCOMMENT)h             .OPT~.OPT : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY){c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).OPT $(CMSFLAGS) $(CMSCOMMENT)              .PAS~.PAS : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)nc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).PAS $(CMSFLAGS) $(CMSCOMMENT)i             .PLI~.PLI : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)mc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).PLI $(CMSFLAGS) $(CMSCOMMENT)_             .R32~.R32 :fY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)rc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).R32 $(CMSFLAGS) $(CMSCOMMENT)f             .REQ~.REQ :oY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)pc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).REQ $(CMSFLAGS) $(CMSCOMMENT)              .RNH~.RNH :TY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).RNH $(CMSFLAGS) $(CMSCOMMENT)e  A           _______________________________________________________m(           Figure B-2 Cont'd on next page             B-16         A                                         Built-in Dependency Rules         <           Figure B-2 (Cont.)  MMK default dependency rules -#                               AlphalA           _______________________________________________________h             .RNO~.RNO : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)tc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).RNO $(CMSFLAGS) $(CMSCOMMENT)p             .SCN~.SCN :uY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)ec            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).SCN $(CMSFLAGS) $(CMSCOMMENT)t             .SDML~.SDML :uY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) d            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).SDML $(CMSFLAGS) $(CMSCOMMENT)             .TXT~.TXT : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)nc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).TXT $(CMSFLAGS) $(CMSCOMMENT)l  A           _______________________________________________________   9           Figure B-3  MMK default dependency rules - IA64gA           _______________________________________________________o  %           ! MMK_DEFAULT_RULES_I64.MMS            ! G           !   COPYRIGHT  2004  MADGOAT SOFTWARE.  ALL RIGHTS RESERVED.            ! F           !  Default build rules for use with MMK.  (for OpenVMS IA64)           !D"           !  Modification history:           !rD           !   03-MAY-2004 V1.0 Madison     Initial coding (from ACP)           !A  A           _______________________________________________________y(           Figure B-3 Cont'd on next page      A                                                              B-17_ _  _    #           Built-in Dependency Rules_        A           Figure B-3 (Cont.)  MMK default dependency rules - IA64YA           _______________________________________________________              ! Q           ! This symbol can be used to distinguish MMK from DEC's DEC/MMS product $           ! using .IFDEF directives.           ! '           __MATTS_MMS__ = __MATTS_MMS__I           __MMK__ = __MMK__            __MMK_V32__ = 1            !oO           ! These symbols can be used to distinguish an IA64-based build from ao           ! VAX or Alpha one.1           !0           __IA64__ = 1           __I64__   = 1J             EXE = .EXE           OLB = .OLB           OBJ = .OBJ           OPT = .OPT           L32 = .L32  7           .SUFFIXES :     ! clear the suffix list firstX^           .SUFFIXES : $(EXE) $(OLB) $(OBJ) .TLB .HLB .MLB $(L32) .C .CXX .BAS .B32 .BLI .FOR -U                    .COB .COR .DBL .RPG .SCN .PLI .PEN .PAS .MAC .MAR .M64 .MSG .CLD - T                    .R32 .REQ .TXT .H .MEM .HLP .RNH .RNO .MMS .DAT .OPT .SDML .COM -T                    .C~ .CXX~ .BAS~ .B32~ .BLI~ .FOR~ .COB~ .COR~ .DBL~ .RPG~ .SCN~ -P                    .PLI~ .PAS~ .MAC~ .MAR~ .M64~ .MSG~ .CLD~ .R32~ .REQ~ .TXT~ -G                    .H~ .HLP~ .RNH~ .RNO~ .MMS~ .DAT~ .OPT~ .SDML~ .COM~_             LINK     = LINK_+           LINKFLAGS   = /EXEC=$(MMS$TARGET)              $(OBJ)$(OLB) :W               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE $(MMS$TARGET) =               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)              .TXT.TLB :\               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/TEXT $(MMS$TARGET)Y               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)/MODULE=$(MMS$TARGET_MODULE)   A           _______________________________________________________ (           Figure B-3 Cont'd on next page             B-18 3       A                                         Built-in Dependency Rules         A           Figure B-3 (Cont.)  MMK default dependency rules - IA642A           _______________________________________________________              .HLP.HLB :\               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/HELP $(MMS$TARGET)=               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE).             .MAC.MLB :]               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/MACRO $(MMS$TARGET).=               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)I             .MAR.MLB :]               @ IF F$SEARCH("$(MMS$TARGET)") .EQS. "" THEN $(LIBR)/CREATE/MACRO $(MMS$TARGET)$=               $(LIBR)$(LIBRFLAGS) $(MMS$TARGET) $(MMS$SOURCE)              LIBR     = LIBRARY            LIBRFLAGS   = /REPLACE             .BAS$(OBJ) :/               $(BASIC)$(BASFLAGS) $(MMS$SOURCE)N           BASIC     = BASICR?           BASFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)E             .BLI$(OBJ) :-               $(BLISS)$(BFLAGS) $(MMS$SOURCE)_           .B32$(OBJ) :-               $(BLISS)$(BFLAGS) $(MMS$SOURCE) >           BFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)             .C$(OBJ) :*               $(CC)$(CFLAGS) $(MMS$SOURCE)           CC       = CCr>           CFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)             .COB$(OBJ) :/               $(COBOL)$(COBFLAGS) $(MMS$SOURCE)T           COBOL     = COBOL)?           COBFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)M  A           _______________________________________________________F(           Figure B-3 Cont'd on next page  A                                                              B-19( $  G    #           Built-in Dependency Rules:        A           Figure B-3 (Cont.)  MMK default dependency rules - IA64/A           _______________________________________________________T             .COR$(OBJ) :/               $(CORAL)$(CORFLAGS) $(MMS$SOURCE)R           CORAL     = CORAL)?           CORFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)A             .CXX$(OBJ) :-               $(CXX)$(CXXFLAGS) $(MMS$SOURCE)E           CXX      = CXX?           CXXFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)              .DBL$(OBJ) :/               $(DIBOL)$(DBLFLAGS) $(MMS$SOURCE)F           DIBOL     = DIBOLM?           DBLFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)$             .CLD$(OBJ) :3               $(SETCMD)$(SETCMDFLAGS) $(MMS$SOURCE)T"           SETCMD     = SET COMMAND?           SETCMDFLAGS = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)O             .FOR$(OBJ) :,               $(FORT)$(FFLAGS) $(MMS$SOURCE)           FORT        = FORTRAN ?           FFLAGS      = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)l             .MAR$(OBJ) :-               $(MACRO)$(MFLAGS) $(MMS$SOURCE) %           MACRO     = MACRO/MIGRATION >           MFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)             .M64$(OBJ) :/               $(TASM)$(TASMFLAGS) $(MMS$SOURCE)_           TASM     = MACRO?           TASMFLAGS   = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)(  A           _______________________________________________________ (           Figure B-3 Cont'd on next page             B-20         A                                         Built-in Dependency Rules         A           Figure B-3 (Cont.)  MMK default dependency rules - IA64EA           _______________________________________________________S             .MSG$(OBJ) :1               $(MESSAGE)$(MSGFLAGS) $(MMS$SOURCE)S           MESSAGE     = MESSAGEi?           MSGFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)              .PAS$(OBJ) :.               $(PASCAL)$(PFLAGS) $(MMS$SOURCE)           .PAS.PEN   :1               $(PASCAL)$(PENVFLAGS) $(MMS$SOURCE)            PASCAL     = PASCALS>           PFLAGS     = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)B           PENVFLAGS   = /ENVIRONMENT=$(MMS$TARGET_NAME).ENV/NOLIST             .PLI$(OBJ) :-               $(PLI)$(PLIFLAGS) $(MMS$SOURCE)A           PLI      = PLI?           PLIFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ))             .REQ$(L32) :N               $(BLISS)/LIBR=$(MMS$TARGET_NAME)$(L32)$(BLIBFLAGS) $(MMS$SOURCE)           .R32$(L32) :N               $(BLISS)/LIBR=$(MMS$TARGET_NAME)$(L32)$(BLIBFLAGS) $(MMS$SOURCE)           BLISS     = BLISSu           BLIBFLAGS   = /NOLIST              .RPG$(OBJ) :-               $(RPG)$(RPGFLAGS) $(MMS$SOURCE)D           RPG      = RPG?           RPGFLAGS    = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)   A           _______________________________________________________ (           Figure B-3 Cont'd on next page            A                                                              B-21P F  S    #           Built-in Dependency RulesP        A           Figure B-3 (Cont.)  MMK default dependency rules - IA64 A           _______________________________________________________              .RNH.HLP :.               $(RUNOFF)$(RFLAGS) $(MMS$SOURCE)           .RNO.MEM :.               $(RUNOFF)$(RFLAGS) $(MMS$SOURCE)           RUNOFF     = RUNOFF ,           RFLAGS     = /OUTPUT=$(MMS$TARGET)             .SCN$(OBJ) :/               $(SCAN)$(SCANFLAGS) $(MMS$SOURCE)            SCAN     = SCANM?           SCANFLAGS   = /NOLIST/OBJECT=$(MMS$TARGET_NAME)$(OBJ)              CMS      = CMS           CMSCOMMENT  = ""2           CMSFLAGS    = /GENERATION=$(MMS$CMS_GEN)             .B32~.B32 : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Rc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).B32 $(CMSFLAGS) $(CMSCOMMENT)F             .BAS~.BAS : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)_c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).BAS $(CMSFLAGS) $(CMSCOMMENT)              .BLI~.BLI : Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)ec            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).BLI $(CMSFLAGS) $(CMSCOMMENT)_             .C~.C :_Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Ra            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).C $(CMSFLAGS) $(CMSCOMMENT)              .CLD~.CLD :SY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).CLD $(CMSFLAGS) $(CMSCOMMENT)A             .COB~.COB :EY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).COB $(CMSFLAGS) $(CMSCOMMENT)A  A           ________________________________________________________(           Figure B-3 Cont'd on next page             B-22         A                                         Built-in Dependency RulesS        A           Figure B-3 (Cont.)  MMK default dependency rules - IA64RA           _______________________________________________________              .COR~.COR :BY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)$c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).COR $(CMSFLAGS) $(CMSCOMMENT)              .COM~.COM :AY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Mc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).COM $(CMSFLAGS) $(CMSCOMMENT)              .CXX~.CXX :AY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Mc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).CXX $(CMSFLAGS) $(CMSCOMMENT)              .DAT~.DAT :AY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Mc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).DAT $(CMSFLAGS) $(CMSCOMMENT)              .DBL~.DBL :AY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Mc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).DBL $(CMSFLAGS) $(CMSCOMMENT)_             .FOR~.FOR :_Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).FOR $(CMSFLAGS) $(CMSCOMMENT)              .H~.H :lY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Ca            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).H $(CMSFLAGS) $(CMSCOMMENT)Y             .HLP~.HLP :CY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).HLP $(CMSFLAGS) $(CMSCOMMENT)Y             .MAC~.MAC :CY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MAC $(CMSFLAGS) $(CMSCOMMENT)Y             .MAR~.MAR :CY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MAR $(CMSFLAGS) $(CMSCOMMENT)Y  A           _______________________________________________________A(           Figure B-3 Cont'd on next page  A                                                              B-23F /  R    #           Built-in Dependency Rules$        A           Figure B-3 (Cont.)  MMK default dependency rules - IA64MA           _______________________________________________________B             .M64~.M64 :NY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Sc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).M64 $(CMSFLAGS) $(CMSCOMMENT)B             .MMS~.MMS :NY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Sc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MMS $(CMSFLAGS) $(CMSCOMMENT)B             .MSG~.MSG :NY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Sc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).MSG $(CMSFLAGS) $(CMSCOMMENT)B             .OPT~.OPT :NY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Sc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).OPT $(CMSFLAGS) $(CMSCOMMENT)B             .PAS~.PAS :NY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Sc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).PAS $(CMSFLAGS) $(CMSCOMMENT)_             .PLI~.PLI :iY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY) c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).PLI $(CMSFLAGS) $(CMSCOMMENT)e             .R32~.R32 :VY            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Pc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).R32 $(CMSFLAGS) $(CMSCOMMENT)              .REQ~.REQ :$Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Ac            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).REQ $(CMSFLAGS) $(CMSCOMMENT)              .RNH~.RNH :$Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Lc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).RNH $(CMSFLAGS) $(CMSCOMMENT)              .RNO~.RNO :$Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)3c            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).RNO $(CMSFLAGS) $(CMSCOMMENT)   A           _______________________________________________________ (           Figure B-3 Cont'd on next page             B-24    I    A                                         Built-in Dependency RulesA        A           Figure B-3 (Cont.)  MMK default dependency rules - IA64.A           _______________________________________________________              .SCN~.SCN :"Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Lc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).SCN $(CMSFLAGS) $(CMSCOMMENT)              .SDML~.SDML :.Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Md            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).SDML $(CMSFLAGS) $(CMSCOMMENT)             .TXT~.TXT :.Y            @ IF "$(MMS$CMS_LIBRARY)" .NES. "" THEN DEFINE/USER CMS$LIB $(MMS$CMS_LIBRARY)Mc            $(CMS) FETCH $(MMS$CMS_ELEMENT) /OUTPUT=$(MMS$TARGET_NAME).TXT $(CMSFLAGS) $(CMSCOMMENT)   A           _______________________________________________________S                                                  A                                                              B-25 