Home Explore Help
Sign In
RISCI_ATOM
/
harvey
mirror of https://github.com/Harvey-OS/harvey.git
1
0
Fork 0
Files Issues 0 Wiki
Tree: 6728d42205
Branches Tags
harvey
/
sys
/
doc
/
mkfiles.html

mkfiles.html 17 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666 
  1. <html>
    2. 

  2. <title>
    3. 

  3. data
    4. 

  4. </title>
    5. 

  5. <body BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#330088" ALINK="#FF0044">
    6. 

  6. <H1>Plan 9 Mkfiles
    7. 

  7. </H1>
    8. 

  8. <DL><DD><I>Bob Flandrena<br>
    9. 

  9. bobf@plan9.bell-labs.com<br>
    10. 

  10. </I></DL>
    11. 

  11. <H4>Introduction
    12. 

  12. </H4>
    13. 

  13. <br>&#32;<br>
    14. 

  14. Every Plan 9 source directory contains a file, called
    15. 

  15. <TT>mkfile</TT>,
    16. 

  16. specifying the rules for building the executable or
    17. 

  17. library that is the product of the directory.
    18. 

  18. <A href="/magic/man2html/1/mk"><I>mk</I>(1)
    19. 

  19. </A>interprets the rules in the file, calculates
    20. 

  20. the dependencies, and executes an
    21. 

  21. <A href="/magic/man2html/1/rc"><I>rc</I>(1)
    22. 

  22. </A>script to construct the product.
    23. 

  23. If necessary components are supplied by
    24. 

  24. neighboring directories or sub-directories, the mkfiles in those
    25. 

  25. directories are first executed to build the components
    26. 

  26. before the local construction proceeds.
    27. 

  27. <br>&#32;<br>
    28. 

  28. Most application source directories produce one of
    29. 

  29. four types of product:
    30. 

  30. a single executable, several
    31. 

  31. executables, a local library, or
    32. 

  32. a system library.
    33. 

  33. Four generic
    34. 

  34. mkfiles
    35. 

  35. define the normal rules
    36. 

  36. for building each type of product.  The simplest
    37. 

  37. mkfiles need only
    38. 

  38. list the components
    39. 

  39. and include the appropriate
    40. 

  40. generic
    41. 

  41. mkfile 
    42. 

  42. to do the work.
    43. 

  43. More complex 
    44. 

  44. mkfiles
    45. 

  45. may supply additional rules
    46. 

  46. to augment, modify, or override the generic rules.
    47. 

  47. <H4>Using a Mkfile
    48. 

  48. </H4>
    49. 

  49. <br>&#32;<br>
    50. 

  50. To build a product, change to the directory containing
    51. 

  51. its source and invoke
    52. 

  52. <I>mk</I>
    53. 

  53. with the appropriate target as an argument.
    54. 

  54. All mkfiles provide the following standard targets:
    55. 

  55. <br><img src="data.19114400.gif"><br>
    56. 

  56. <br>&#32;<br>
    57. 

  57. If no target is specified on the
    58. 

  58. <TT>mk</TT>
    59. 

  59. command line, the
    60. 

  60. <TT>all</TT>
    61. 

  61. target is built by default.  In a directory
    62. 

  62. producing multiple executables, there is
    63. 

  63. no default target.
    64. 

  64. <br>&#32;<br>
    65. 

  65. In addition to the five standard targets,
    66. 

  66. additional targets may be supplied by each
    67. 

  67. generic mkfile or by the directory's mkfile.
    68. 

  68. <br>&#32;<br>
    69. 

  69. The environment variable
    70. 

  70. <TT>NPROC</TT>
    71. 

  71. is set by the system to the number of
    72. 

  72. available processors.
    73. 

  73. Setting
    74. 

  74. this variable, either in the environment or in
    75. 

  75. a mkfile, controls the amount of parallelism in
    76. 

  76. the build.  For example, the command
    77. 

  77. <DL><DT><DD><TT><PRE>
    78. 

  78. 	NPROC=1 mk
    79. 

  79. </PRE></TT></DL>
    80. 

  80. restricts a build to a single thread of execution.
    81. 

  81. <H4>Creating a Mkfile
    82. 

  82. </H4>
    83. 

  83. <br>&#32;<br>
    84. 

  84. The easiest way to build a new mkfile is to copy and modify
    85. 

  85. an existing mkfile of the same type.
    86. 

  86. Failing that, it is usually possible to create a new
    87. 

  87. mkfile with minimal effort, since the appropriate
    88. 

  88. generic mkfile predefines the rules that do all the work.
    89. 

  89. In the simplest and most common cases, the new mkfile
    90. 

  90. need only define a couple of variables and include the appropriate
    91. 

  91. architecture-specific
    92. 

  92. and generic mkfiles.
    93. 

  93. <H4></H4>
    94. 

  94. <br>&#32;<br>
    95. 

  95. There are four generic mkfiles containing commonly
    96. 

  96. used rules for building a product:
    97. 

  97. <TT>mkone</TT>,
    98. 

  98. <TT>mkmany</TT>,
    99. 

  99. <TT>mklib</TT>,
    100. 

  100. and
    101. 

  101. <TT>mksyslib</TT>.
    102. 

  102. These rules
    103. 

  103. perform such actions as compiling C source files,
    104. 

  104. loading object files, archiving libraries, and
    105. 

  105. installing executables in the
    106. 

  106. <TT>bin</TT>
    107. 

  107. directory of the appropriate architecture.
    108. 

  108. The generic mkfiles are stored in directory
    109. 

  109. <TT>/sys/src/cmd</TT>.
    110. 

  110. Mkfile
    111. 

  111. <TT>mkone</TT>
    112. 

  112. builds a single executable,
    113. 

  113. <TT>mkmany</TT>
    114. 

  114. builds several executables from the source in a single
    115. 

  115. directory, and
    116. 

  116. <TT>mklib</TT>
    117. 

  117. and
    118. 

  118. <TT>mksyslib</TT>,
    119. 

  119. maintain local and system libraries, respectively.
    120. 

  120. The rules in the generic mkfiles are driven by
    121. 

  121. the values of variables, some of which must be
    122. 

  122. set by the product mkfile and some of which are
    123. 

  123. supplied by the generic mkfile.  Variables in the
    124. 

  124. latter class include:
    125. 

  125. <br><img src="data.19114401.gif"><br>
    126. 

  126. <br>&#32;<br>
    127. 

  127. The following variables are set by the product mkfile
    128. 

  128. and used by the generic mkfile.
    129. 

  129. Any may be empty depending on the specific product being
    130. 

  130. made.
    131. 

  131. <br><img src="data.19114402.gif"><br>
    132. 

  132. <H4>Mkfile Organization
    133. 

  133. </H4>
    134. 

  134. <br>&#32;<br>
    135. 

  135. All
    136. 

  136. mkfiles
    137. 

  137. share the following common structure:
    138. 

  138. <DL><DT><DD><TT><PRE>
    139. 

  139. &lt;/<I>objtype/mkfile	# </I>architecture-dependent definitions<I>
    140. 

  140. <br>&#32;<br>
    141. 

  141. </I><I>variable definitions</I><I>		# TARG</I>, <I>OFILES</I>, <I>HFILES</I>, etc.<I>
    142. 

  142. <br>&#32;<br>
    143. 

  143. &lt;/sys/src/cmd/</I><I>generic</I><I>	# mkone</I>, <I>mkmany</I>, <I>mklib</I>, or <I>mksyslib
    144. 

  144. <br>&#32;<br>
    145. 

  145. </I><I>variable overrides</I><I>		# CFLAGS</I>, <I>objtype</I>, etc.<I>
    146. 

  146. <br>&#32;<br>
    147. 

  147. </I><I>extra rules</I><I>			# </I>overrides, augmented rules, additional targets<I>
    148. 

  148. </PRE></TT></DL>
    149. 

  149. Note that the architecture-dependent mkfiles include file
    150. 

  150. </I><TT>/sys/src/mkfile.proto</TT><I>
    151. 

  151. for system-wide variables that are common to all architectures.
    152. 

  152. </I><br>&#32;<br>
    153. 

  153. The variables driving the expansion of the generic mkfile
    154. 

  154. may be specified in any order as long as they are defined
    155. 

  155. before the inclusion of the generic mkfile.  The value
    156. 

  156. of a variable may be changed by assigning a new value
    157. 

  157. following the inclusion of the generic mkfile, but the
    158. 

  158. effects are sometimes counter-intuitive.
    159. 

  159. Such variable assignments do not apply to the target and
    160. 

  160. prerequisite portions of any previously defined rules;
    161. 

  161. the new values only apply to the recipes of rules preceding
    162. 

  162. the assignment statement and
    163. 

  163. to all parts of any rules following it.
    164. 

  164. <br>&#32;<br>
    165. 

  165. The rules supplied by the generic mkfile may
    166. 

  166. be overridden or augmented.  The new rules must
    167. 

  167. be specified after the inclusion of the generic
    168. 

  168. mkfile.  If the target and prerequisite portion
    169. 

  169. of the rule exactly match the target and prerequisite
    170. 

  170. portion of a previously defined rule and the new rule contains
    171. 

  171. a recipe, the new rule replaces the old one.
    172. 

  172. If the target of a new rule exactly matches the
    173. 

  173. target of a previous rule and one or more new
    174. 

  174. prerequisites are specified and the new rule contains
    175. 

  175. no recipe, the new prerequisites are added to the prerequisites
    176. 

  176. of the old rule.
    177. 

  177. <br>&#32;<br>
    178. 

  178. Following sections discuss
    179. 

  179. each generic mkfile in detail.
    180. 

  180. <H4>Mkone
    181. 

  181. </H4>
    182. 

  182. <br>&#32;<br>
    183. 

  183. The
    184. 

  184. <TT>mkone</TT>
    185. 

  185. generic mkfile contains rules for building
    186. 

  186. a single executable from one or more files
    187. 

  187. in a directory.
    188. 

  188. The variable
    189. 

  189. <TT>TARG</TT>
    190. 

  190. specifies the name of the executable and
    191. 

  191. variables
    192. 

  192. <TT>OFILES</TT>
    193. 

  193. and
    194. 

  194. <TT>YFILES</TT>
    195. 

  195. specify the object files and
    196. 

  196. <TT>yacc</TT>
    197. 

  197. source files used to build it.
    198. 

  198. <TT>HFILES</TT>
    199. 

  199. contains the names of the local header files
    200. 

  200. included in all source files.
    201. 

  201. <TT>BIN</TT>
    202. 

  202. is the name of the directory where the executable
    203. 

  203. is installed.
    204. 

  204. <TT>LIB</TT>
    205. 

  205. contains the names of local libraries used by the
    206. 

  206. linker.  This variable is rarely needed
    207. 

  207. as libraries referenced by a
    208. 

  208. <TT>#pragma</TT>
    209. 

  209. directive in an associated header file, including
    210. 

  210. all system libraries, are automatically
    211. 

  211. searched by the loader.
    212. 

  212. <br>&#32;<br>
    213. 

  213. If
    214. 

  214. <TT>mk</TT>
    215. 

  215. is executed without a target, the
    216. 

  216. <TT>all</TT>
    217. 

  217. target is built; it
    218. 

  218. produces an executable in
    219. 

  219. <TT></TT>O.out<TT>.
    220. 

  220. Variable
    221. 

  221. </TT><TT>HFILES</TT><TT>
    222. 

  222. identifies the header files that
    223. 

  223. are included in all or most or
    224. 

  224. the C source files.  Occasionally,
    225. 

  225. a program has other header files
    226. 

  226. that are only used in some
    227. 

  227. source files.  A
    228. 

  228. header can be added to the prerequisites for
    229. 

  229. those object files by adding a rule of
    230. 

  230. the following form following the inclusion of generic mkfile
    231. 

  231. </TT><TT>mkone</TT><TT>:
    232. 

  232. <DL><DT><DD><TT><PRE>
    233. 

  233. file.</TT><I>O:	header.h
    234. 

  234. </PRE></TT></DL>
    235. 

  235. </I><br>&#32;<br>
    236. 

  236. The mkfile for a directory producing a single
    237. 

  237. executable using the normal set of rules is
    238. 

  238. trivial: a list of some files followed by the
    239. 

  239. inclusion of
    240. 

  240. <I>mkone.</I>
    241. 

  241. For example, 
    242. 

  242. <TT>/sys/src/cmd/diff/mkfile</TT>
    243. 

  243. contains:
    244. 

  244. <DL><DT><DD><TT><PRE>
    245. 

  245. &lt; /objtype/mkfile
    246. 

  246. 

  247. TARG=diff
    248. 

  248. OFILES=\
    249. 

  249. 	diffdir.<I>O\
    250. 

  250. 	diffio.</I>O\
    251. 

  251. 	diffreg.<I>O\
    252. 

  252. 	main.</I>O\
    253. 

  253. 

  254. HFILES=diff.h
    255. 

  255. 

  256. BIN=/<I>objtype/bin
    257. 

  257. &lt;/sys/src/cmd/mkone
    258. 

  258. </PRE></TT></DL>
    259. 

  259. The more complex mkfile in
    260. 

  260. </I><TT>/sys/src/cmd/awk</TT><I>
    261. 

  261. overrides compiler and loader variables to
    262. 

  262. select the ANSI/POSIX Computing Environment with appropriately
    263. 

  263. defined command line variables.  It also overrides
    264. 

  264. the default
    265. 

  265. </I><TT>yacc</TT><I>
    266. 

  266. rule to place the output soure in file
    267. 

  267. </I><TT>awkgram.c</TT><I>
    268. 

  268. and the
    269. 

  269. </I><TT>clean</TT><I>
    270. 

  270. and
    271. 

  271. </I><TT>nuke</TT><I>
    272. 

  272. rules, so it can remove the non-standard intermediate
    273. 

  273. files.  Finally, the last three rules build a version of
    274. 

  274. </I><TT>maketab</TT><I>
    275. 

  275. appropriate for the architecture where the
    276. 

  276. </I><TT>mk</TT><I>
    277. 

  277. is being
    278. 

  278. run and then executes it to create source file
    279. 

  279. </I><TT>proctab.c</TT><I>:
    280. 

  280. <DL><DT><DD><TT><PRE>
    281. 

  281. &lt;/</I>objtype/mkfile
    282. 

  282. 

  283. TARG=awk
    284. 

  284. OFILES=re.<I>O\
    285. 

  285. 	lex.</I>O\
    286. 

  286. 	main.<I>O\
    287. 

  287. 	parse.</I>O\
    288. 

  288. 	proctab.<I>O\
    289. 

  289. 	tran.</I>O\
    290. 

  290. 	lib.<I>O\
    291. 

  291. 	run.</I>O\
    292. 

  292. 	awkgram.<I>O\
    293. 

  293. 

  294. HFILES=awk.h\
    295. 

  295. 	y.tab.h\
    296. 

  296. 	proto.h\
    297. 

  297. 

  298. YFILES=awkgram.y
    299. 

  299. 

  300. BIN=/</I>objtype/bin
    301. 

  301. &lt;/sys/src/cmd/mkone
    302. 

  302. CFLAGS=-c -D_REGEXP_EXTENSION -D_RESEARCH_SOURCE \
    303. 

  303. 	-D_BSD_EXTENSION -DUTF
    304. 

  304. YFLAGS=-S -d -v
    305. 

  305. CC=pcc
    306. 

  306. LD=pcc
    307. 

  307. cpuobjtype=`{sed -n 's/^O=//p' /<I>cputype/mkfile}
    308. 

  308. 

  309. y.tab.h awkgram.c:	</I>YFILES
    310. 

  310. 	<I>YACC -o awkgram.c </I>YFLAGS <I>prereq
    311. 

  311. 

  312. clean:V:
    313. 

  313. 	rm -f *.[</I>OS] [<I>OS].out [</I>OS].maketab y.tab.? y.debug\
    314. 

  314. 		 y.output <I>TARG
    315. 

  315. 

  316. nuke:V:
    317. 

  317. 	rm -f *.[</I>OS] [<I>OS].out [</I>OS].maketab y.tab.? y.debug\
    318. 

  318. 		 y.output awkgram.c <I>TARG
    319. 

  319. 

  320. proctab.c:	</I>cpuobjtype.maketab
    321. 

  321. 	./<I>cpuobjtype.maketab &gt;proctab.c
    322. 

  322. 

  323. </I>cpuobjtype.maketab:	y.tab.h maketab.c
    324. 

  324. 	objtype=<I>cputype
    325. 

  325. 	mk maketab.</I>cputype
    326. 

  326. 

  327. maketab.<I>cputype:V:	y.tab.h maketab.</I>O
    328. 

  328. 	<I>LD -o </I>O.maketab maketab.<I>O
    329. 

  329. </PRE></TT></DL>
    330. 

  330. </I><H4>Mkmany
    331. 

  331. </H4>
    332. 

  332. <br>&#32;<br>
    333. 

  333. The
    334. 

  334. <TT>mkmany</TT>
    335. 

  335. generic mkfile builds several
    336. 

  336. executables from the files in a
    337. 

  337. directory.  It differs from the operation of
    338. 

  338. <TT>mkone</TT>
    339. 

  339. in three respects:
    340. 

  340. <TT>TARG</TT>
    341. 

  341. specifies the names of all executables,
    342. 

  342. there is no default command-line target,
    343. 

  343. and additional rules allow a single executable to
    344. 

  344. be built or installed.
    345. 

  345. <br>&#32;<br>
    346. 

  346. The
    347. 

  347. <TT>TARG</TT>
    348. 

  348. variable specifies the names of all
    349. 

  349. executables produced by the mkfile.  The
    350. 

  350. rules assume the name of each executable is also
    351. 

  351. the name of the file containing its
    352. 

  352. <TT>main</TT>
    353. 

  353. function.
    354. 

  354. <TT>OFILES</TT>
    355. 

  355. specifies files containing
    356. 

  356. common subroutines loaded with all executables.
    357. 

  357. Consider the mkfile:
    358. 

  358. <DL><DT><DD><TT><PRE>
    359. 

  359. &lt;/objtype/mkfile
    360. 

  360. 

  361. TARG=alpha beta
    362. 

  362. OFILES=common.<I>O
    363. 

  363. BIN=/</I>objtype/bin
    364. 

  364. &lt;/sys/src/cmd/mkmany
    365. 

  365. </PRE></TT></DL>
    366. 

  366. It assumes the main functions for executables
    367. 

  367. <TT>alpha</TT>
    368. 

  368. and
    369. 

  369. <TT>beta</TT>
    370. 

  370. are in files
    371. 

  371. <TT>alpha.</TT><I>O</I><TT>
    372. 

  372. and
    373. 

  373. </TT><TT>beta.</TT><TT>O</TT><TT>
    374. 

  374. and that both programs use the subroutines
    375. 

  375. in file
    376. 

  376. </TT><TT>common.</TT><I>O</I><TT>.
    377. 

  377. The
    378. 

  378. </TT><TT>all</TT><TT>
    379. 

  379. target builds all executables, leaving each in
    380. 

  380. a file with a name of the form
    381. 

  381. </TT><TT></TT><TT>O.</TT><I>progname</I><TT></TT><I>
    382. 

  382. where
    383. 

  383. </I><I>progname</I><I>
    384. 

  384. is the name of the executable.  In this
    385. 

  385. example the
    386. 

  386. </I><TT>all</TT><I>
    387. 

  387. target produces executables
    388. 

  388. </I><TT></TT><I>O.alpha</I><TT>
    389. 

  389. and 
    390. 

  390. </TT><TT></TT><TT>O.beta</TT><TT>.
    391. 

  391. </TT><br>&#32;<br>
    392. 

  392. The
    393. 

  393. <TT>mkmany</TT>
    394. 

  394. rules provide additional
    395. 

  395. targets for building a single
    396. 

  396. executable:
    397. 

  397. <br><img src="data.19114403.gif"><br>
    398. 

  398. <H4>Mklib
    399. 

  399. </H4>
    400. 

  400. <br>&#32;<br>
    401. 

  401. The
    402. 

  402. <TT>mklib</TT>
    403. 

  403. generic mkfile builds a local library.
    404. 

  404. Since this form of mkfile constructs no
    405. 

  405. executable, the
    406. 

  406. <TT>TARG</TT>
    407. 

  407. and
    408. 

  408. <TT>BIN</TT>
    409. 

  409. variables are not needed.  Instead, the
    410. 

  410. <TT>LIB</TT>
    411. 

  411. variable specifies the library
    412. 

  412. to be built or updated.  Variable
    413. 

  413. <TT>OFILES</TT>
    414. 

  414. contains the names of the object files to be archived
    415. 

  415. in the library.  The use of variables
    416. 

  416. <TT>YFILES</TT>
    417. 

  417. and
    418. 

  418. <TT>HFILES</TT>
    419. 

  419. does not change.  When possible, only the
    420. 

  420. out-of-date members of the library are updated.
    421. 

  421. <br>&#32;<br>
    422. 

  422. The variable
    423. 

  423. <TT>LIBDIR</TT>
    424. 

  424. contains the name of the directory where the
    425. 

  425. library is installed; by default it selects
    426. 

  426. the current directory.  It can be overridden
    427. 

  427. by assigning the new directory name after the
    428. 

  428. point where
    429. 

  429. <TT>mklib</TT>
    430. 

  430. is included.
    431. 

  431. <br>&#32;<br>
    432. 

  432. The
    433. 

  433. <TT>clean</TT>
    434. 

  434. target removes object files and
    435. 

  435. <TT>yacc</TT>
    436. 

  436. intermediate files but does not touch the
    437. 

  437. library.  The
    438. 

  438. <TT>nuke</TT>
    439. 

  439. target removes the library as well as the
    440. 

  440. files removed by the
    441. 

  441. <TT>clean</TT>
    442. 

  442. target.  The command
    443. 

  443. <DL><DD>
    444. 

  444. <TT>mk -s clean all</TT>
    445. 

  445. </DL>
    446. 

  446. causes the existing library to be updated, or
    447. 

  447. created if it doesn't already exist.  The command
    448. 

  448. <DL><DD>
    449. 

  449. <TT>mk -s nuke all</TT>
    450. 

  450. </DL>
    451. 

  451. forces the library to be rebuilt from scratch.
    452. 

  452. <br>&#32;<br>
    453. 

  453. The mkfile from
    454. 

  454. <TT>/sys/src/cmd/upas/libString</TT>
    455. 

  455. contains the following specifications to
    456. 

  456. build the local library
    457. 

  457. <TT>libString.a</TT><I>O</I><TT>
    458. 

  458. for the object architecture referenced by
    459. 

  459. </TT><TT></TT><TT>O</TT>:<TT></TT>
    460. 

  460. <DL><DT><DD><TT><PRE>
    461. 

  461. &lt;/<I>objtype/mkfile
    462. 

  462. 

  463. LIB=libString.a</I>O
    464. 

  464. OFILES=	s_alloc.<I>O\
    465. 

  465. 	s_append.</I>O\
    466. 

  466. 	s_array.<I>O\
    467. 

  467. 	s_copy.</I>O\
    468. 

  468. 	s_getline.<I>O\
    469. 

  469. 	s_grow.</I>O\
    470. 

  470. 	s_nappend.<I>O\
    471. 

  471. 	s_parse.</I>O\
    472. 

  472. 	s_read.<I>O\
    473. 

  473. 	s_read_line.</I>O\
    474. 

  474. 	s_tolower.<I>O\
    475. 

  475. 

  476. &lt;/sys/src/cmd/mklib
    477. 

  477. 

  478. nuke:V:
    479. 

  479. 	mk clean
    480. 

  480. 	rm -f libString.a[</I>OS]
    481. 

  481. </PRE></TT></DL>
    482. 

  482. The override of the rule for target
    483. 

  483. <TT>nuke</TT>
    484. 

  484. removes the libraries for all architectures as
    485. 

  485. opposed to the default recipe for this target
    486. 

  486. which removes the library for the current architecture.
    487. 

  487. <H4>Mksyslib
    488. 

  488. </H4>
    489. 

  489. <br>&#32;<br>
    490. 

  490. The
    491. 

  491. <TT>mksyslib</TT>
    492. 

  492. generic mkfile is similar to the
    493. 

  493. <TT>mklib</TT>
    494. 

  494. mkfile except that it operates on a system library
    495. 

  495. instead of a local library.
    496. 

  496. The
    497. 

  497. <TT>install</TT>
    498. 

  498. and
    499. 

  499. <TT>all</TT>
    500. 

  500. targets are the same; since there is no local copy of
    501. 

  501. the library, all updates are performed on the
    502. 

  502. installed library.
    503. 

  503. The rule for the
    504. 

  504. <TT>nuke</TT>
    505. 

  505. target is identical to that of the
    506. 

  506. <TT>clean</TT>
    507. 

  507. target; unlike the
    508. 

  508. <TT>nuke</TT>
    509. 

  509. target for local libraries,
    510. 

  510. the library is never removed.
    511. 

  511. <br>&#32;<br>
    512. 

  512. No attempt is made to determine if individual library
    513. 

  513. members are up-to-date; all members of a
    514. 

  514. library are always updated.
    515. 

  515. Special targets support manipulation of a single
    516. 

  516. object file; the target
    517. 

  517. <TT>objfile</TT>
    518. 

  518. updates file
    519. 

  519. <TT>objfile</TT><TT>.</TT><I>O</I><TT></TT><I>
    520. 

  520. in the library of the current architecture and the target
    521. 

  521. </I><TT>objfile.all</TT><I>
    522. 

  522. updates
    523. 

  523. </I><TT>objfile</TT><TT>.</TT><TT>O</TT><TT></TT><TT>
    524. 

  524. in the libraries of all architectures.
    525. 

  525. </TT><H4>Overrides
    526. 

  526. </H4>
    527. 

  527. <br>&#32;<br>
    528. 

  528. The rules provided by a generic mkfile or
    529. 

  529. the variables used to control the evaluation
    530. 

  530. of those rules may be overridden in most
    531. 

  531. circumstances.  Overrides
    532. 

  532. must be specified in the product mkfile
    533. 

  533. after the point where the generic
    534. 

  534. mkfile is included; in general, variable
    535. 

  535. and rule overrides occupy the end of a
    536. 

  536. product mkfile.
    537. 

  537. <br>&#32;<br>
    538. 

  538. The value of a variable is overridden by
    539. 

  539. assigning a new value to the variable.
    540. 

  540. Most variable overrides modify the
    541. 

  541. values of flags or the names of commands executed
    542. 

  542. in recipes.  For example, the default value of
    543. 

  543. <TT>CFLAGS</TT>
    544. 

  544. is often overridden or augmented and
    545. 

  545. the ANSI/POSIX Computing Environment is selected by
    546. 

  546. setting the
    547. 

  547. <TT>CC</TT>
    548. 

  548. and
    549. 

  549. <TT>LD</TT>
    550. 

  550. variables to
    551. 

  551. <TT>pcc.</TT>
    552. 

  552. <br>&#32;<br>
    553. 

  553. Modifying rules is trickier than modifying
    554. 

  554. variables.  Additional constraints can be added
    555. 

  555. to a rule by specifying the target and
    556. 

  556. the new prerequisite.  For example,
    557. 

  557. <DL><DT><DD><TT><PRE>
    558. 

  558. %.<I>O:	header.h
    559. 

  559. </PRE></TT></DL>
    560. 

  560. adds file
    561. 

  561. </I><TT>header.h</TT><I>
    562. 

  562. the set of prerequisites for all object files.
    563. 

  563. There is no mechanism for adding additional
    564. 

  564. commands to an existing recipe; if a
    565. 

  565. recipe is unsatisfactory, the rule and its recipe
    566. 

  566. must be completely overridden.
    567. 

  567. A rule is overridden only when the replacement rule
    568. 

  568. matches the target and prerequisite portions
    569. 

  569. of the original rule exactly.  The recipe
    570. 

  570. associated with the new rule
    571. 

  571. then replaces the recipe of the original rule.
    572. 

  572. For example,
    573. 

  573. </I><TT>/sys/src/cmd/lex/mkfile</TT><I>
    574. 

  574. overrides the default
    575. 

  575. </I><TT>installall</TT><I>
    576. 

  576. rule to perform the normal loop on all
    577. 

  577. architectures and then copy a prototype file
    578. 

  578. to the system library directory.
    579. 

  579. <DL><DT><DD><TT><PRE>
    580. 

  580. &lt;/</I>objtype/mkfile
    581. 

  581. 

  582. TARG=lex
    583. 

  583. OFILES=lmain.<I>O\
    584. 

  584. 	y.tab.</I>O\
    585. 

  585. 	sub1.<I>O\
    586. 

  586. 	sub2.</I>O\
    587. 

  587. 	header.<I>O\
    588. 

  588. 

  589. HFILES=ldefs.h\
    590. 

  590. 

  591. YFILES=parser.y\
    592. 

  592. 

  593. BIN=/</I>objtype/bin
    594. 

  594. &lt;/sys/src/cmd/mkone
    595. 

  595. 

  596. installall:V:
    597. 

  597. 	for(objtype in <I>CPUS)
    598. 

  598. 		mk install
    599. 

  599. 	cp ncform /sys/lib/lex
    600. 

  600. </PRE></TT></DL>
    601. 

  601. Another way to perform the same override is to
    602. 

  602. add a dependency to the default
    603. 

  603. </I><TT>installall</TT><I>
    604. 

  604. rule that executes an additional rule to
    605. 

  605. install the prototype file:
    606. 

  606. <DL><DT><DD><TT><PRE>
    607. 

  607. installall:V:	ncform.install
    608. 

  608. 

  609. ncform.install:V:
    610. 

  610. 	cp ncform /sys/lib/lex
    611. 

  611. </PRE></TT></DL>
    612. 

  612. </I><H4>Special Tricks
    613. 

  613. </H4>
    614. 

  614. <br>&#32;<br>
    615. 

  615. Two special cases
    616. 

  616. require extra deviousness.
    617. 

  617. <br>&#32;<br>
    618. 

  618. In the first, a file needed to build an
    619. 

  619. executable is generated by a program that,
    620. 

  620. in turn, is built from a source file that
    621. 

  621. is not part of the product.  In this case,
    622. 

  622. the
    623. 

  623. executable must be built for the
    624. 

  624. target architecture, but the intermediate
    625. 

  625. executable must be built for the architecture
    626. 

  626. <TT>mk</TT>
    627. 

  627. is executing on.  The intermediate executable
    628. 

  628. is built by recursively invoking
    629. 

  629. <TT>mk</TT>
    630. 

  630. with the appropriate target and the
    631. 

  631. executing architecture as the target
    632. 

  632. architecture.  When that
    633. 

  633. <TT>mk</TT>
    634. 

  634. completes, the intermediate is
    635. 

  635. executed to generate the source file to
    636. 

  636. complete the build for the target architecture.
    637. 

  637. The earlier example of
    638. 

  638. <TT>/sys/src/cmd/awk/mkfile</TT>
    639. 

  639. illustrates this technique.
    640. 

  640. <br>&#32;<br>
    641. 

  641. Another awkward situation
    642. 

  642. occurs when a directory contains
    643. 

  643. source to build an executable as
    644. 

  644. well as source for auxiliary executables
    645. 

  645. that are not to be installed.  In this case
    646. 

  646. the
    647. 

  647. <TT>mkmany</TT>
    648. 

  648. generic rules are inappropriate, because
    649. 

  649. all executables would be built and installed.
    650. 

  650. Instead, use the
    651. 

  651. <TT>mkone</TT>
    652. 

  652. generic file to build the primary executable
    653. 

  653. and provide extra targets to
    654. 

  654. build the auxiliary files.  This
    655. 

  655. approach is also useful when the auxiliary
    656. 

  656. files are not executables;
    657. 

  657. <TT>/sys/src/cmd/spell/mkfile</TT>
    658. 

  658. augments the default rules to build and install the
    659. 

  659. <TT>spell</TT>
    660. 

  660. executable with
    661. 

  661. elaborate rules to generate
    662. 

  662. and maintain the auxiliary spelling lists.
    663. 

  663. <br>&#32;<br>
    664. 

  664. <A href=http://www.lucent.com/copyright.html>
    665. 

  665. Copyright</A> &#169; 2004 Lucent Technologies Inc.  All rights reserved.
    666. 

  666. </body></html>
    667.