Return to make.ms CVS log

Up to [CSRG BSD Unix] / 43BSDReno / share / doc / ps1 / 12.make

Annotation of 43BSDReno/share/doc/ps1/12.make/make.ms, revision 1.1

1.1     ! root        1: .\"    @(#)make        6.1 (Berkeley) 5/4/86
        !             2: .\"
        !             3: .EH 'PS1:12-%''Make \(em A Program for Maintaining Computer Programs'
        !             4: .OH 'Make \(em A Program for Maintaining Computer Programs''PS1:12-%'
        !             5: .....TR 57
        !             6: .\".RP
        !             7: .de IT
        !             8: .if n .ul
        !             9: \&\\$3\f2\\$1\fR\^\&\\$2
        !            10: ..
        !            11: .TL
        !            12: Make \(em A Program for Maintaining Computer Programs
        !            13: .AU
        !            14: S. I. Feldman
        !            15: .AI
        !            16: .MH
        !            17: .AB
        !            18: .PP
        !            19: In a programming project, it is easy to lose track of which files need
        !            20: to be reprocessed or recompiled after a change is made in some part of the source.
        !            21: .I Make
        !            22: provides a simple mechanism for maintaining up-to-date versions of programs that result
        !            23: from many operations on a number of files.
        !            24: It is possible to tell
        !            25: .I Make
        !            26: the sequence of commands that create certain files,
        !            27: and the list of files that require other files to be current before the operations can be done.
        !            28: Whenever a change is made in any part of the program,
        !            29: the
        !            30: .I Make
        !            31: command will create the proper files simply, correctly,
        !            32: and with a minimum amount of effort.
        !            33: .PP
        !            34: The basic operation of
        !            35: .I Make
        !            36: is to find the name of a needed target in the description, ensure that all of the files on which it depends exist and
        !            37: are up to date, and then create the target if it has not been modified since its generators were.
        !            38: The description file really defines the graph of dependencies;
        !            39: .I Make
        !            40: does a depth-first search of this graph
        !            41: to determine what work is really necessary.
        !            42: .PP
        !            43: .I Make
        !            44: also provides a simple macro substitution facility
        !            45: and the ability to encapsulate commands in a single file
        !            46: for convenient administration.
        !            47: .sp 2
        !            48: Revised April, 1986
        !            49: .AE
        !            50: .SH
        !            51: Introduction
        !            52: .PP
        !            53: It is common practice to divide large programs into smaller, more manageable pieces.
        !            54: The pieces may require quite different treatments:
        !            55: some may need to be run through a macro processor, some may need to be processed by
        !            56: a sophisticated program generator (e.g., Yacc[1] or Lex[2]).
        !            57: The outputs of these generators may then have to be compiled with special options and with
        !            58: certain definitions and declarations.
        !            59: The code resulting from these transformations may then need to be loaded together with
        !            60: certain libraries under the control of special options.
        !            61: Related maintenance activities involve running complicated test scripts
        !            62: and installing validated modules.
        !            63: Unfortunately, it is very easy for a programmer to forget which files depend on which others,
        !            64: which files have been modified recently, and the exact sequence of operations
        !            65: needed to make or exercise a new version of the program.
        !            66: After a long editing session, one may easily lose track of which files have been changed
        !            67: and which object modules are still valid,
        !            68: since a change to a declaration can obsolete a dozen other files.
        !            69: Forgetting to compile a routine that has been changed or that uses changed declarations will result in
        !            70: a program that will not work, and a bug that can be very hard to track down.
        !            71: On the other hand, recompiling everything in sight just to be safe is very wasteful.
        !            72: .PP
        !            73: The program described in this report mechanizes many of the activities of program development
        !            74: and maintenance.
        !            75: If the information on inter-file dependences and command sequences is stored in a file, the simple command
        !            76: .DS
        !            77: make
        !            78: .DE
        !            79: is frequently sufficient to update the interesting files,
        !            80: regardless of the number that have been edited since the last ``make''.
        !            81: In most cases, the description file is easy to write and changes infrequently.
        !            82: It is usually easier to type the
        !            83: .IT make
        !            84: command than to issue even one of the needed operations, so the typical cycle of program development operations becomes
        !            85: .DS
        !            86: think \(em edit \(em \fImake\fR \(em test  . . .
        !            87: .DE
        !            88: .PP
        !            89: .IT Make
        !            90: is most useful for medium-sized programming projects;
        !            91: it does not solve the problems of maintaining multiple source versions
        !            92: or of describing huge programs.
        !            93: .IT Make
        !            94: was designed for use on Unix, but a version runs on GCOS.
        !            95: .SH
        !            96: Basic Features
        !            97: .PP
        !            98: The basic operation of
        !            99: .IT make
        !           100: is to update a target file by ensuring
        !           101: that all of the files on which it depends exist and are up to date,
        !           102: then creating the target if it has not been modified since its dependents were.
        !           103: .IT Make
        !           104: does a depth-first search of the graph of dependences.
        !           105: The operation of the command depends on the ability to find the date and time
        !           106: that a file was last modified.
        !           107: .PP
        !           108: To illustrate, let us consider a simple example:
        !           109: A program named
        !           110: .IT prog
        !           111: is made by compiling and loading three C-language files
        !           112: .IT x.c ,
        !           113: .IT y.c ,
        !           114: and
        !           115: .IT z.c
        !           116: with the
        !           117: .IT lS
        !           118: library.
        !           119: By convention, the output of the C compilations will be found in files named
        !           120: .IT x.o ,
        !           121: .IT y.o ,
        !           122: and
        !           123: .IT z.o .
        !           124: Assume that the files
        !           125: .IT x.c
        !           126: and
        !           127: .IT y.c
        !           128: share some declarations in a file named
        !           129: .IT defs ,
        !           130: but that
        !           131: .IT z.c
        !           132: does not.
        !           133: That is,
        !           134: .IT x.c
        !           135: and
        !           136: .IT y.c
        !           137: have the line
        !           138: .DS
        !           139: #include "defs"
        !           140: .DE
        !           141: The following text describes the relationships and operations:
        !           142: .DS
        !           143: prog :  x.o  y.o  z.o
        !           144:        cc  x.o  y.o  z.o   \-lS  \-o  prog
        !           145: .sp .5
        !           146: x.o  y.o :   defs
        !           147: .DE
        !           148: If this information were stored in a file named
        !           149: .IT makefile ,
        !           150: the command
        !           151: .DS
        !           152: make
        !           153: .DE
        !           154: would perform the operations needed to recreate
        !           155: .IT prog
        !           156: after any changes had been made to any of the four source files
        !           157: .IT x.c ,
        !           158: .IT y.c ,
        !           159: .IT z.c ,
        !           160: or
        !           161: .IT defs .
        !           162: .PP
        !           163: .IT Make
        !           164: operates using three sources of information:
        !           165: a user-supplied description file (as above),
        !           166: file names and ``last-modified'' times from the file system,
        !           167: and built-in rules to bridge some of the gaps.
        !           168: In our example, the first line says that
        !           169: .IT prog
        !           170: depends on three ``\fI.o\fR'' files.
        !           171: Once these object files are current, the second line describes how to load them to create
        !           172: .IT prog .
        !           173: The third line says that
        !           174: .IT x.o
        !           175: and
        !           176: .IT y.o
        !           177: depend on the file
        !           178: .IT defs .
        !           179: From the file system,
        !           180: .IT make
        !           181: discovers that there are three ``\fI.c\fR'' files corresponding to the needed ``\fI.o\fR'' files,
        !           182: and uses built-in information on how to generate an object from a source file
        !           183: (\fIi.e.,\fR issue a ``cc\ \-c'' command).
        !           184: .PP
        !           185: The following long-winded description file is equivalent to the one above, but
        !           186: takes no advantage of
        !           187: .IT make 's
        !           188: innate knowledge:
        !           189: .DS
        !           190: prog :  x.o  y.o  z.o
        !           191:        cc  x.o  y.o  z.o  \-lS  \-o  prog
        !           192: .sp .3
        !           193: x.o :  x.c  defs
        !           194:        cc  \-c  x.c
        !           195: y.o :  y.c  defs
        !           196:        cc  \-c  y.c
        !           197: z.o :  z.c
        !           198:        cc  \-c  z.c
        !           199: .DE
        !           200: .PP
        !           201: If none of the source or object files had changed since the last time
        !           202: .IT prog
        !           203: was made, all of the files would be current, and
        !           204: the command
        !           205: .DS
        !           206: make
        !           207: .DE
        !           208: would just announce this fact and stop.
        !           209: If, however, the
        !           210: .IT defs
        !           211: file had been edited,
        !           212: .IT x.c
        !           213: and
        !           214: .IT y.c
        !           215: (but not
        !           216: .IT z.c )
        !           217: would be recompiled, and then
        !           218: .IT prog
        !           219: would be created from the new ``\fI.o\fR'' files.
        !           220: If only the file
        !           221: .IT y.c
        !           222: had changed, only it would be recompiled, but it would still be necessary to reload
        !           223: .IT prog .
        !           224: .PP
        !           225: If no target name is given on the
        !           226: .IT make
        !           227: command line, the first target mentioned in the description is created;
        !           228: otherwise the specified targets are made.
        !           229: The command
        !           230: .DS
        !           231: make x.o
        !           232: .DE
        !           233: would recompile
        !           234: .IT x.o
        !           235: if
        !           236: .IT x.c
        !           237: or
        !           238: .IT defs
        !           239: had changed.
        !           240: .PP
        !           241: If the file exists after the commands are executed,
        !           242: its time of last modification is used in further decisions;
        !           243: otherwise the current time is used.
        !           244: It is often quite useful to include rules with mnemonic names and commands that do not
        !           245: actually produce a file with that name.
        !           246: These entries can take advantage of
        !           247: .IT make 's
        !           248: ability to generate files and substitute macros.
        !           249: Thus, an entry
        !           250: ``save''
        !           251: might be included to copy a certain set of files, or an entry
        !           252: ``cleanup''
        !           253: might be used to throw away unneeded intermediate files.
        !           254: In other cases one may maintain a zero-length file purely to keep track
        !           255: of the time at which certain actions were performed.
        !           256: This technique is useful for maintaining remote archives and listings.
        !           257: .PP
        !           258: .IT Make
        !           259: has a simple macro mechanism for substituting in dependency lines and command strings.
        !           260: Macros are defined by command arguments or description file lines with embedded equal signs.
        !           261: A macro is invoked by preceding the name by a dollar sign;
        !           262: macro names longer than one character must be parenthesized.
        !           263: The name of the macro is either the single character after the dollar sign or a name inside parentheses.
        !           264: The following are valid macro invocations:
        !           265: .DS
        !           266: $(CFLAGS)
        !           267: $2
        !           268: $(xy)
        !           269: $Z
        !           270: $(Z)
        !           271: .DE
        !           272: The last two invocations are identical.
        !           273: $$ is a dollar sign.
        !           274: All of these macros are assigned values during input, as shown below.
        !           275: Four special macros change values during the execution of the command:
        !           276: $\(**, $@, $?, and $<.
        !           277: They will be discussed later.
        !           278: The following fragment shows the use:
        !           279: .DS
        !           280: OBJECTS = x.o y.o z.o
        !           281: LIBES = \-lS
        !           282: prog: $(OBJECTS)
        !           283:        cc $(OBJECTS)  $(LIBES)  \-o prog
        !           284:   . . .
        !           285: .DE
        !           286: The command
        !           287: .DS
        !           288: make
        !           289: .DE
        !           290: loads the three object files with the
        !           291: .IT lS
        !           292: library.  The command
        !           293: .DS
        !           294: make  "LIBES= \-ll \-lS"
        !           295: .DE
        !           296: loads them with both the Lex (``\-ll'') and the Standard (``\-lS'') libraries,
        !           297: since macro definitions on the command line override definitions in the description.
        !           298: (It is necessary to quote arguments with embedded blanks in
        !           299: .UX
        !           300: commands.)
        !           301: .PP
        !           302: The following sections detail the form of description files and the command line,
        !           303: and discuss options and built-in rules in more detail.
        !           304: .SH
        !           305: Description Files and Substitutions
        !           306: .PP
        !           307: A description file contains three types of information:
        !           308: macro definitions,
        !           309: dependency information,
        !           310: and executable commands.
        !           311: There is also a comment convention:
        !           312: all characters after a sharp (#) are ignored, as is the sharp itself.
        !           313: Blank lines and lines beginning with a sharp are totally ignored.
        !           314: If a non-comment line is too long, it can be continued using a backslash.
        !           315: If the last character of a line is a backslash, the backslash, newline,
        !           316: and following blanks and tabs are replaced by a single blank.
        !           317: .PP
        !           318: A macro definition is a line containing an equal sign not preceded by a colon or a tab.
        !           319: The name (string of letters and digits) to the left of the equal sign
        !           320: (trailing blanks and tabs are stripped) is assigned the string of characters following the equal sign
        !           321: (leading blanks and tabs are stripped.)
        !           322: The following are valid macro definitions:
        !           323: .DS
        !           324: 2 = xyz
        !           325: abc = \-ll \-ly \-lS
        !           326: LIBES =
        !           327: .DE
        !           328: The last definition assigns LIBES the null string.
        !           329: A macro that is never explicitly defined has the null string as value.
        !           330: Macro definitions may also appear on the
        !           331: .IT make
        !           332: command line (see below).
        !           333: .PP
        !           334: Other lines give information about target files.
        !           335: The general form of an entry is:
        !           336: .DS
        !           337: target1 [target2 . . .] :[:] [dependent1 . . .] [; commands] [# . . .]
        !           338: [\fI(tab)\fR commands] [# . . .]
        !           339:  . . .
        !           340: .DE
        !           341: Items inside brackets may be omitted.
        !           342: Targets and dependents are strings of letters, digits, periods, and slashes.
        !           343: (Shell metacharacters ``\(**'' and ``?'' are expanded.)
        !           344: A command is any string of characters not including a sharp (except in quotes)
        !           345: or newline.
        !           346: Commands may appear either after a semicolon on a dependency line
        !           347: or on lines beginning with a tab immediately following a dependency line.
        !           348: .PP
        !           349: A dependency line may have either a single or a double colon.
        !           350: A target name may appear on more than one dependency line, but all of those lines must be of the
        !           351: same (single or double colon) type.
        !           352: .IP 1.
        !           353: For the usual single-colon case,
        !           354: at most one of these dependency lines may have a command sequence associated with it.
        !           355: If the target is out of date with any of the dependents on any of the lines,
        !           356: and a command sequence is specified (even a null one following a semicolon or tab),
        !           357: it is executed; otherwise a default creation rule may be invoked.
        !           358: .IP 2.
        !           359: In the double-colon case, a command sequence may be associated with each dependency line;
        !           360: if the target is out of date with any of the files on a particular line, the associated
        !           361: commands are executed.
        !           362: A built-in rule may also be executed.
        !           363: This detailed form is of particular value in updating archive-type files.
        !           364: .PP
        !           365: If a target must be created, the sequence of commands is executed.
        !           366: Normally, each command line is printed and then
        !           367: passed to a separate invocation of the Shell after substituting for macros.
        !           368: (The printing is suppressed in silent mode or if the command line begins with an @ sign).
        !           369: .IT Make
        !           370: normally stops if any command signals an error by returning a non-zero error code.
        !           371: (Errors are ignored if the ``\-i'' flags has been specified on the
        !           372: .IT make
        !           373: command line,
        !           374: if the fake target name ``.IGNORE'' appears in the description file,
        !           375: or if the command string in the description file begins with a hyphen.
        !           376: Some
        !           377: .UX
        !           378: commands return meaningless status).
        !           379: Because each command line is passed to a separate invocation of the Shell,
        !           380: care must be taken with certain commands (e.g., \fIcd\fR and Shell control commands) that have meaning only
        !           381: within a single Shell process;
        !           382: the results are forgotten before the next line is executed.
        !           383: .PP
        !           384: Before issuing any command, certain macros are set.
        !           385: $@ is set to the name of the file to be ``made''.
        !           386: $? is set to the string of names that were found to be younger than the target.
        !           387: If the command was generated by an implicit rule (see below),
        !           388: $< is the name of the related file that caused the action, and
        !           389: $\(** is the prefix shared by the current and the dependent file names.
        !           390: .PP
        !           391: If a file must be made but there are no explicit commands or relevant
        !           392: built-in rules,
        !           393: the commands associated with the name ``.DEFAULT'' are used.
        !           394: If there is no such name,
        !           395: .IT make
        !           396: prints a message and stops.
        !           397: .SH
        !           398: Command Usage
        !           399: .PP
        !           400: The
        !           401: .IT make
        !           402: command takes four kinds of arguments:
        !           403: macro definitions, flags, description file names, and target file names.
        !           404: .DS
        !           405: make [ flags ]  [ macro definitions ]  [ targets ]
        !           406: .DE
        !           407: The following summary of the operation of the command explains how these arguments are interpreted.
        !           408: .PP
        !           409: First, all macro definition arguments (arguments with embedded equal signs) are analyzed
        !           410: and the assignments made.
        !           411: Command-line macros override corresponding definitions found in the description files.
        !           412: .PP
        !           413: Next, the flag arguments are examined.
        !           414: The permissible flags are
        !           415: .IP \-i
        !           416: Ignore error codes returned by invoked commands.
        !           417: This mode is entered if the fake target name ``.IGNORE'' appears in the description file.
        !           418: .IP \-s
        !           419: Silent mode.  Do not print command lines before executing.
        !           420: This mode is also entered if the fake target name ``.SILENT'' appears in the description file.
        !           421: .IP \-r
        !           422: Do not use the built-in rules.
        !           423: .IP \-n
        !           424: No execute mode.  Print commands, but do not execute them.
        !           425: Even lines beginning with an ``@'' sign are printed.
        !           426: .IP \-t
        !           427: Touch the target files (causing them to be up to date) rather than issue the usual commands.
        !           428: .IP \-q
        !           429: Question.
        !           430: The
        !           431: .IT make
        !           432: command returns a zero or non-zero status code depending on whether the target file
        !           433: is or is not up to date.
        !           434: .IP \-p
        !           435: Print out the complete set of macro definitions and target descriptions
        !           436: .IP \-d
        !           437: Debug mode.  Print out detailed information on files and times examined.
        !           438: .IP \-f
        !           439: Description file name.  The next argument is assumed to be the name of a description file.
        !           440: A file name of ``\-'' denotes the standard input.
        !           441: If there are no ``\-f\|'' arguments, the file named
        !           442: .IT makefile
        !           443: or
        !           444: .IT Makefile
        !           445: in the current directory is read.
        !           446: The contents of the description files override the built-in rules if they are present).
        !           447: .PP
        !           448: Finally, the remaining arguments are assumed to be the names of targets to be made;
        !           449: they are done in left to right order.
        !           450: If there are no such arguments, the first name in the description files that does not
        !           451: begin with a period is ``made''.
        !           452: .SH
        !           453: Implicit Rules
        !           454: .PP
        !           455: The
        !           456: .ul
        !           457: make
        !           458: program uses a table of interesting suffixes and a set
        !           459: of transformation rules to supply default dependency
        !           460: information and implied commands.
        !           461: (The Appendix describes these tables and means of overriding
        !           462: them.)
        !           463: The default suffix list is:
        !           464: .KS
        !           465: .sp
        !           466: .nf
        !           467: .ta 0.5i 1.5i
        !           468:        \fI.o\fR        Object file
        !           469:        \fI.c\fR        C source file
        !           470:        \fI.e\fR        Efl source file
        !           471:        \fI.r\fR        Ratfor source file
        !           472:        \fI.f\fR        Fortran source file
        !           473:        \fI.s\fR        Assembler source file
        !           474:        \fI.y\fR        Yacc-C source grammar
        !           475:        \fI.yr\fR       Yacc-Ratfor source grammar
        !           476:        \fI.ye\fR       Yacc-Efl source grammar
        !           477:        \fI.l\fR        Lex source grammar
        !           478: .fi
        !           479: .sp
        !           480: .KE
        !           481: The following diagram summarizes the default transformation paths.
        !           482: If there are two paths connecting a pair of suffixes, the longer
        !           483: one is used only if the intermediate file exists or is
        !           484: named in the description.
        !           485: .KS
        !           486: .sp
        !           487: .ft I
        !           488: .ta 2i
        !           489:        .o
        !           490: .sp 2
        !           491: .ta 0.75i 1.25i 1.6i 2.1i
        !           492:        .c      .r      .e      .f  .s  .y  .yr  .ye  .l  .d
        !           493: .sp 2
        !           494: .ta 0.6i 1.25i 1.6i
        !           495:        .y .l   .yr     .ye
        !           496: .ft R
        !           497: .sp
        !           498: .KE
        !           499: .PP
        !           500: If the file
        !           501: .ul
        !           502: x.o
        !           503: were needed and there were an
        !           504: .ul
        !           505: x.c
        !           506: in the description or directory, it would be compiled.
        !           507: If there were also an
        !           508: .IT x.l ,
        !           509: that grammar would be run through Lex before compiling the result.
        !           510: However, if there were no
        !           511: .ul
        !           512: x.c
        !           513: but there were an
        !           514: .IT x.l ,
        !           515: .IT make
        !           516: would discard the intermediate C-language file and use the
        !           517: direct link in the graph above.
        !           518: .PP
        !           519: It is possible to change the names of some of the compilers used in the
        !           520: default, or the flag arguments with which they are invoked by knowing
        !           521: the macro names used.
        !           522: The compiler names are the macros AS, CC, RC, EC, YACC, YACCR, YACCE, and LEX.
        !           523: The command
        !           524: .DS
        !           525: make CC=newcc
        !           526: .DE
        !           527: will cause the ``newcc'' command to be used instead of the
        !           528: usual C compiler.
        !           529: The macros CFLAGS, RFLAGS, EFLAGS, YFLAGS, and LFLAGS may be set to
        !           530: cause these commands to be issued with optional flags.
        !           531: Thus,
        !           532: .DS
        !           533: make "CFLAGS=\|\(miO"
        !           534: .DE
        !           535: causes the optimizing C compiler to be used.
        !           536: .PP
        !           537: Another special macro is `VPATH'.
        !           538: The ``VPATH'' macro should be set to a list of directories separated by colons.
        !           539: When
        !           540: .I make
        !           541: searches for a file as a result of a dependency relation, it will
        !           542: first search the current directory and then each of the directories on the
        !           543: ``VPATH'' list.
        !           544: If the file is found, the actual path to the file will be used, rather than
        !           545: just the filename.
        !           546: If ``VPATH'' is not defined, then only the current directory is searched.
        !           547: Note that ``VPATH'' is intended to act like the System V ``VPATH'' support,
        !           548: but there is no guarantee that it functions identically.
        !           549: .PP
        !           550: One use for ``VPATH'' is when one has several programs that compile from the
        !           551: same source.
        !           552: The source can be kept in one directory and each set of
        !           553: object files (along with a separate
        !           554: .IR makefile )
        !           555: would be in a separate subdirectory.
        !           556: The ``VPATH'' macro would point to the source directory in this case.
        !           557: .SH
        !           558: Example
        !           559: .PP
        !           560: As an example of the use of
        !           561: .ul
        !           562: make,
        !           563: we will present the description file used to maintain
        !           564: the
        !           565: .ul
        !           566: make
        !           567: command itself.
        !           568: The code for
        !           569: .ul
        !           570: make
        !           571: is spread over a number of C source files and a Yacc grammar.
        !           572: The description file contains:
        !           573: .DS
        !           574: # Description file for the Make command
        !           575: .sp .3
        !           576: P = und \-3 | opr \-r2       # send to GCOS to be printed
        !           577: FILES = Makefile version.c defs main.c doname.c misc.c files.c dosys.c\
        !           578:        gram.y lex.c gcos.c
        !           579: OBJECTS = version.o main.o doname.o misc.o files.o dosys.o gram.o
        !           580: LIBES= \-lS
        !           581: LINT = lint \-p
        !           582: CFLAGS = \-O
        !           583: .sp .3
        !           584: make:  $(OBJECTS)
        !           585:        cc $(CFLAGS) $(OBJECTS) $(LIBES) \-o make
        !           586:        size make
        !           587: .sp .3
        !           588: $(OBJECTS):  defs
        !           589: gram.o: lex.c
        !           590: .sp .3
        !           591: cleanup:
        !           592:        -rm *.o gram.c
        !           593:        -du
        !           594: .sp .3
        !           595: install:
        !           596:        @size make /usr/bin/make
        !           597:        cp make /usr/bin/make ; rm make
        !           598: .sp .3
        !           599: print:  $(FILES)       # print recently changed files
        !           600:        pr $? | $P
        !           601:        touch print
        !           602: .sp .3
        !           603: test:
        !           604:        make \-dp | grep \-v TIME >1zap
        !           605:        /usr/bin/make \-dp | grep \-v TIME >2zap
        !           606:        diff 1zap 2zap
        !           607:        rm 1zap 2zap
        !           608: .sp .3
        !           609: lint :  dosys.c doname.c files.c main.c misc.c version.c gram.c
        !           610:        $(LINT) dosys.c doname.c files.c main.c misc.c version.c gram.c
        !           611:        rm gram.c
        !           612: .sp .3
        !           613: arch:
        !           614:        ar uv /sys/source/s2/make.a $(FILES)
        !           615: .DE
        !           616: .IT Make
        !           617: usually prints out each command before issuing it.
        !           618: The following output results from typing the simple command
        !           619: .DS
        !           620: make
        !           621: .DE
        !           622: in a directory containing only the source and description file:
        !           623: .DS
        !           624:  cc  \-c version.c
        !           625:  cc  \-c main.c
        !           626:  cc  \-c doname.c
        !           627:  cc  \-c misc.c
        !           628:  cc  \-c files.c
        !           629:  cc  \-c dosys.c
        !           630:  yacc  gram.y
        !           631:  mv y.tab.c gram.c
        !           632:  cc  \-c gram.c
        !           633:  cc  version.o main.o doname.o misc.o files.o dosys.o gram.o \-lS \-o make
        !           634:  13188+3348+3044 = 19580b = 046174b
        !           635: .DE
        !           636: Although none of the source files or grammars were mentioned
        !           637: by name in the description file,
        !           638: .IT make
        !           639: found them using its suffix rules and issued the needed commands.
        !           640: The string of digits results from the ``size make''
        !           641: command; the printing of the command line itself was
        !           642: suppressed by an @ sign.
        !           643: The @ sign on the
        !           644: .IT size
        !           645: command in the description file suppressed the printing of the command,
        !           646: so only the sizes are written.
        !           647: .PP
        !           648: The last few entries in the description file are useful maintenance sequences.
        !           649: The ``print'' entry prints only the files that have been changed since the last
        !           650: ``make print'' command.
        !           651: A zero-length file
        !           652: .IT print
        !           653: is maintained to keep track of the time of the printing;
        !           654: the $? macro in the command line then picks up only the names of the files
        !           655: changed since
        !           656: .IT print
        !           657: was touched.
        !           658: The printed output can be sent to a different printer or to a file by changing the definition of the
        !           659: .IT P
        !           660: macro:
        !           661: .DS
        !           662: make print "P = opr \-sp"
        !           663:        \fIor\fR
        !           664: make print "P=  cat >zap"
        !           665: .DE
        !           666: .SH
        !           667: Suggestions and Warnings
        !           668: .PP
        !           669: The most common difficulties arise from
        !           670: .IT make 's
        !           671: specific meaning of dependency.
        !           672: If file
        !           673: .IT x.c
        !           674: has a ``#include "defs"''
        !           675: line, then the object file
        !           676: .IT x.o
        !           677: depends on
        !           678: .IT defs ;
        !           679: the source file
        !           680: .IT x.c
        !           681: does not.
        !           682: (If
        !           683: .IT defs
        !           684: is changed, it is not necessary to do anything
        !           685: to the file
        !           686: .IT x.c ,
        !           687: while it is necessary to recreate
        !           688: .IT x.o .)
        !           689: .PP
        !           690: To discover what
        !           691: .IT make
        !           692: would do, the ``\-n'' option is very useful.
        !           693: The command
        !           694: .DS
        !           695: make \-n
        !           696: .DE
        !           697: orders
        !           698: .IT make
        !           699: to print out the commands it would issue without actually taking the time to execute them.
        !           700: If a change to a file is absolutely certain to be benign
        !           701: (e.g., adding a new definition to an include file),
        !           702: the ``\-t'' (touch) option
        !           703: can save a lot of time:
        !           704: instead of issuing a large number of superfluous recompilations,
        !           705: .IT make
        !           706: updates the modification times on the affected file.
        !           707: Thus, the command
        !           708: .DS
        !           709: make \-ts
        !           710: .DE
        !           711: (``touch silently'') causes the relevant files to appear up to date.
        !           712: Obvious care is necessary, since this mode of operation subverts
        !           713: the intention of
        !           714: .IT make
        !           715: and destroys all memory of the previous relationships.
        !           716: .PP
        !           717: The debugging flag (``\-d'') causes
        !           718: .IT make
        !           719: to print out a very detailed description of what it is doing, including the
        !           720: file times.  The output is verbose, and recommended only as a last resort.
        !           721: .SH
        !           722: Acknowledgments
        !           723: .PP
        !           724: I would like to thank S. C. Johnson for suggesting this approach
        !           725: to program maintenance control.
        !           726: I would like to thank S. C. Johnson and H. Gajewska for being
        !           727: the prime guinea pigs during development of
        !           728: .IT make .
        !           729: .SH
        !           730: References
        !           731: .IP 1.
        !           732: S. C. Johnson,
        !           733: ``Yacc \(em Yet Another Compiler-Compiler'',
        !           734: Bell Laboratories
        !           735: Computing Science Technical Report #32,
        !           736: July 1978.
        !           737: .IP 2.
        !           738: M. E. Lesk,
        !           739: ``Lex \(em A Lexical Analyzer Generator'',
        !           740: Computing Science Technical Report #39,
        !           741: October 1975.
        !           742: .bp
        !           743: .SH
        !           744: Appendix.  Suffixes and Transformation Rules
        !           745: .PP
        !           746: The
        !           747: .ul
        !           748: make
        !           749: program itself does not know what file name suffixes are interesting
        !           750: or how to transform a file with one suffix into a file with another
        !           751: suffix.
        !           752: This information is stored in an internal table that has the form of a description file.
        !           753: If the ``\-r'' flag is used, this table is not used.
        !           754: .PP
        !           755: The list of suffixes is actually the dependency list for the name
        !           756: ``.SUFFIXES'';
        !           757: .ul
        !           758: make
        !           759: looks for a file with any of the suffixes on the list.
        !           760: If such a file exists, and if there is a transformation
        !           761: rule for that combination,
        !           762: .ul
        !           763: make
        !           764: acts as described earlier.
        !           765: The transformation rule names are the concatenation of the
        !           766: two suffixes.
        !           767: The name of the rule to transform a ``\fI.r\fR'' file to a ``\fI.o\fR'' file
        !           768: is thus ``\fI.r.o\fR''.
        !           769: If the rule is present and no explicit command sequence
        !           770: has been given in the user's description files, the command
        !           771: sequence for the rule ``.r.o'' is used.
        !           772: If a command is generated by using one of these suffixing rules,
        !           773: the macro $\(** is given the value of the stem
        !           774: (everything but the suffix) of the name of the file to be made,
        !           775: and the macro $< is the name of the dependent that caused the action.
        !           776: .PP
        !           777: The order of the suffix list is significant, since it is scanned from
        !           778: left to right, and the first name that is formed that has both a file
        !           779: and a rule associated with it is used.
        !           780: If new names are to be appended, the user can just add an entry for
        !           781: ``.SUFFIXES'' in his own description file; the dependents will be added to the usual list.
        !           782: A ``.SUFFIXES'' line without any dependents deletes the current list.
        !           783: (It is necessary to clear the current list if the order of names is to be changed).
        !           784: .PP
        !           785: The following is an excerpt from the default rules file:
        !           786: .DS
        !           787: .ta .5i 1i
        !           788:  .SUFFIXES : .o .c .e .r .f .y .yr .ye .l .s
        !           789:  YACC=yacc
        !           790:  YACCR=yacc \-r
        !           791:  YACCE=yacc \-e
        !           792:  YFLAGS=
        !           793:  LEX=lex
        !           794:  LFLAGS=
        !           795:  CC=cc
        !           796:  AS=as \-
        !           797:  CFLAGS=
        !           798:  RC=ec
        !           799:  RFLAGS=
        !           800:  EC=ec
        !           801:  EFLAGS=
        !           802:  FFLAGS=
        !           803:  .c.o :
        !           804:        $(CC) $(CFLAGS) \-c $<
        !           805:  .e.o .r.o .f.o :
        !           806:        $(EC) $(RFLAGS) $(EFLAGS) $(FFLAGS) \-c $<
        !           807:  .s.o :
        !           808:        $(AS) \-o $@ $<
        !           809:  .y.o :
        !           810:        $(YACC) $(YFLAGS) $<
        !           811:        $(CC) $(CFLAGS) \-c y.tab.c
        !           812:        rm y.tab.c
        !           813:        mv y.tab.o $@
        !           814:  .y.c :
        !           815:        $(YACC) $(YFLAGS) $<
        !           816:        mv y.tab.c $@
        !           817: .DE

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.