make 与makefile(会不会写 makefile,从一个侧面说明了一我的是否具有完成大型工程的能力。)

   1          跟我一块儿写 Makefile
   2 /**/
   3 
   4 陈皓 (CSDN)
   5 
   6 概述
   7 ——
   8 
   9 什么是makefile？或许不少Winodws的程序员都不知道这个东西，由于那些Windows的IDE都为你作了这个工做，但我以为要做一个好的和professional的程序员，makefile仍是要懂。这就好像如今有这么多的HTML的编辑器，但若是你想成为一个专业人士，你仍是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不本身写makefile了，会不会写makefile，从一个侧面说明了一我的是否具有完成大型工程的能力。
  10 
  11 由于，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件须要先编译，哪些文件须要后编译，哪些文件须要从新编译，甚至于进行更复杂的功能操做，由于makefile就像一个Shell脚本同样，其中也能够执行操做系统的命令。
  12 
  13 makefile带来的好处就是——“自动化编译”，一旦写好，只须要一个make命令，整个工程彻底自动编译，极大的提升了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，通常来讲，大多数的IDE都有这个命令，好比：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。
  14 
  15 如今讲述如何写makefile的文章比较少，这是我想写这篇文章的缘由。固然，不一样产商的make各不相同，也有不一样的语法，但其本质都是在“文件依赖性”上作文章，这里，我仅对GNU的make进行讲述，个人环境是RedHat Linux 8.0，make的版本是3.80。必竟，这个make是应用最为普遍的，也是用得最多的。并且其仍是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。
  16 
  17 在这篇文档中，将以C/C++的源码做为咱们基础，因此必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX下的GCC和CC。
  18 
  19 
  20 
  21 关于程序的编译和连接
  22 ——————————
  23 
  24 在此，我想多说关于程序编译的一些规范和方法，通常来讲，不管是C、C++、仍是pas，首先要把源文件编译成中间代码文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，即 Object File，这个动做叫作编译（compile）。而后再把大量的Object File合成执行文件，这个动做叫做连接（link）。
  25 
  26 编译时，编译器须要的是语法的正确，函数与变量的声明的正确。对于后者，一般是你须要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要全部的语法正确，编译器就能够编译出中间目标文件。通常来讲，每一个源文件都应该对应于一个中间目标文件（O文件或是OBJ文件）。
  27 
  28 连接时，主要是连接函数和全局变量，因此，咱们能够使用这些中间目标文件（O文件或是OBJ文件）来连接咱们的应用程序。连接器并无论函数所在的源文件，只管函数的中间目标文件（Object File），在大多数时候，因为源文件太多，编译生成的中间目标文件太多，而在连接时须要明显地指出中间目标文件名，这对于编译很不方便，因此，咱们要给中间目标文件打个包，在Windows下这种包叫“库文件”（Library File)，也就是 .lib 文件，在UNIX下，是Archive File，也就是 .a 文件。
  29 
  30 总结一下，源文件首先会生成中间目标文件，再由中间目标文件生成执行文件。在编译时，编译器只检测程序语法，和函数、变量是否被声明。若是函数未被声明，编译器会给出一个警告，但能够生成Object File。而在连接程序时，连接器会在全部的Object File中找寻函数的实现，若是找不到，那到就会报连接错误码（Linker Error），在VC下，这种错误通常是：Link 2001错误，意思说是说，连接器未能找到函数的实现。你须要指定函数的Object File.
  31 
  32 好，言归正传，GNU的make有许多的内容，闲言少叙，仍是让咱们开始吧。
  33 
  34 
  35 
  36 Makefile 介绍
  37 ———————
  38 
  39 make命令执行时，须要一个 Makefile 文件，以告诉make命令须要怎么样的去编译和连接程序。
  40 
  41 首先，咱们用一个示例来讲明Makefile的书写规则。以便给你们一个感兴认识。这个示例来源于GNU的make使用手册，在这个示例中，咱们的工程有8个C文件，和3个头文件，咱们要写一个Makefile来告诉make命令如何编译和连接这几个文件。咱们的规则是：
  42 1）若是这个工程没有编译过，那么咱们的全部C文件都要编译并被连接。
  43 2）若是这个工程的某几个C文件被修改，那么咱们只编译被修改的C文件，并连接目标程序。
  44 3）若是这个工程的头文件被改变了，那么咱们须要编译引用了这几个头文件的C文件，并连接目标程序。
  45 
  46 只要咱们的Makefile写得够好，全部的这一切，咱们只用一个make命令就能够完成，make命令会自动智能地根据当前的文件修改的状况来肯定哪些文件须要重编译，从而本身编译所须要的文件和连接目标程序。
  47 
  48 
  49 1、Makefile的规则
  50 
  51 在讲述这个Makefile以前，仍是让咱们先来粗略地看一看Makefile的规则。
  52 
  53 target ... : prerequisites ...
  54 command
  55 ...
  56 ...
  57 
  58 target也就是一个目标文件，能够是Object File，也能够是执行文件。还能够是一个标签（Label），对于标签这种特性，在后续的“伪目标”章节中会有叙述。
  59 
  60 prerequisites就是，要生成那个target所须要的文件或是目标。
  61 
  62 command也就是make须要执行的命令。（任意的Shell命令）
  63 
  64 这是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖于prerequisites中的文件，其生成规则定义在command中。说白一点就是说，prerequisites中若是有一个以上的文件比target文件要新的话，command所定义的命令就会被执行。这就是Makefile的规则。也就是Makefile中最核心的内容。
  65 
  66 说到底，Makefile的东西就是这样一点，好像个人这篇文档也该结束了。呵呵。还不尽然，这是Makefile的主线和核心，但要写好一个Makefile还不够，我会之后面一点一点地结合个人工做经验给你慢慢到来。内容还多着呢。：）
  67 
  68 
  69 2、一个示例
  70 
  71 正如前面所说的，若是一个工程有3个头文件，和8个C文件，咱们为了完成前面所述的那三个规则，咱们的Makefile应该是下面的这个样子的。
  72 
  73 edit : main.o kbd.o command.o display.o /
  74 insert.o search.o files.o utils.o
  75 cc -o edit main.o kbd.o command.o display.o /
  76 insert.o search.o files.o utils.o
  77 
  78 main.o : main.c defs.h
  79 cc -c main.c
  80 kbd.o : kbd.c defs.h command.h
  81 cc -c kbd.c
  82 command.o : command.c defs.h command.h
  83 cc -c command.c
  84 display.o : display.c defs.h buffer.h
  85 cc -c display.c
  86 insert.o : insert.c defs.h buffer.h
  87 cc -c insert.c
  88 search.o : search.c defs.h buffer.h
  89 cc -c search.c
  90 files.o : files.c defs.h buffer.h command.h
  91 cc -c files.c
  92 utils.o : utils.c defs.h
  93 cc -c utils.c
  94 clean :
  95 rm edit main.o kbd.o command.o display.o /
  96 insert.o search.o files.o utils.o
  97 
  98 反斜杠（/）是换行符的意思。这样比较便于Makefile的易读。咱们能够把这个内容保存在文件为“Makefile”或“makefile”的文件中，而后在该目录下直接输入命令“make”就能够生成执行文件edit。若是要删除执行文件和全部的中间目标文件，那么，只要简单地执行一下“make clean”就能够了。
  99 
 100 在这个makefile中，目标文件（target）包含：执行文件edit和中间目标文件（*.o），依赖文件（prerequisites）就是冒号后面的那些 .c 文件和 .h文件。每个 .o 文件都有一组依赖文件，而这些 .o 文件又是执行文件 edit 的依赖文件。依赖关系的实质上就是说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。
 101 
 102 在定义好依赖关系后，后续的那一行定义了如何生成目标文件的操做系统命令，必定要以一个Tab键做为开头。记住，make并无论命令是怎么工做的，他只管执行所定义的命令。make会比较targets文件和prerequisites文件的修改日期，若是prerequisites文件的日期要比targets文件的日期要新，或者target不存在的话，那么，make就会执行后续定义的命令。
 103 
 104 这里要说明一点的是，clean不是一个文件，它只不过是一个动做名字，有点像C语言中的lable同样，其冒号后什么也没有，那么，make就不会自动去找文件的依赖性，也就不会自动执行其后所定义的命令。要执行其后的命令，就要在make命令后明显得指出这个lable的名字。这样的方法很是有用，咱们能够在一个makefile中定义不用的编译或是和编译无关的命令，好比程序的打包，程序的备份，等等。
 105 
 106 
 107 
 108 3、make是如何工做的
 109 
 110 在默认的方式下，也就是咱们只输入make命令。那么，
 111 
 112 1、make会在当前目录下找名字叫“Makefile”或“makefile”的文件。
 113 2、若是找到，它会找文件中的第一个目标文件（target），在上面的例子中，他会找到“edit”这个文件，并把这个文件做为最终的目标文件。
 114 3、若是edit文件不存在，或是edit所依赖的后面的 .o 文件的文件修改时间要比edit这个文件新，那么，他就会执行后面所定义的命令来生成edit这个文件。
 115 4、若是edit所依赖的.o文件也不存在，那么make会在当前文件中找目标为.o文件的依赖性，若是找到则再根据那一个规则生成.o文件。（这有点像一个堆栈的过程）
 116 5、固然，你的C文件和H文件是存在的啦，因而make会生成 .o 文件，而后再用 .o 文件生命make的终极任务，也就是执行文件edit了。
 117 
 118 这就是整个make的依赖性，make会一层又一层地去找文件的依赖关系，直到最终编译出第一个目标文件。在找寻的过程当中，若是出现错误，好比最后被依赖的文件找不到，那么make就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make根本不理。make只管文件的依赖性，即，若是在我找了依赖关系以后，冒号后面的文件仍是不在，那么对不起，我就不工做啦。
 119 
 120 经过上述分析，咱们知道，像clean这种，没有被第一个目标文件直接或间接关联，那么它后面所定义的命令将不会被自动执行，不过，咱们能够显示要make执行。即命令——“make clean”，以此来清除全部的目标文件，以便重编译。
 121 
 122 因而在咱们编程中，若是这个工程已被编译过了，当咱们修改了其中一个源文件，好比file.c，那么根据咱们的依赖性，咱们的目标file.o会被重编译（也就是在这个依性关系后面所定义的命令），因而file.o的文件也是最新的啦，因而file.o的文件修改时间要比edit要新，因此edit也会被从新连接了（详见edit目标文件后定义的命令）。
 123 
 124 而若是咱们改变了“command.h”，那么，kdb.o、command.o和files.o都会被重编译，而且，edit会被重连接。
 125 
 126 
 127 4、makefile中使用变量
 128 
 129 在上面的例子中，先让咱们看看edit的规则：
 130 
 131 edit : main.o kbd.o command.o display.o /
 132 insert.o search.o files.o utils.o
 133 cc -o edit main.o kbd.o command.o display.o /
 134 insert.o search.o files.o utils.o
 135 
 136 咱们能够看到[.o]文件的字符串被重复了两次，若是咱们的工程须要加入一个新的[.o]文件，那么咱们须要在两个地方加（应该是三个地方，还有一个地方在clean中）。固然，咱们的makefile并不复杂，因此在两个地方加也不累，但若是makefile变得复杂，那么咱们就有可能会忘掉一个须要加入的地方，而致使编译失败。因此，为了makefile的易维护，在makefile中咱们能够使用变量。makefile的变量也就是一个字符串，理解成C语言中的宏可能会更好。
 137 
 138 好比，咱们声明一个变量，叫objects, OBJECTS, objs, OBJS, obj, 或是 OBJ，反正无论什么啦，只要可以表示obj文件就好了。咱们在makefile一开始就这样定义：
 139 
 140 objects = main.o kbd.o command.o display.o /
 141 insert.o search.o files.o utils.o
 142 
 143 因而，咱们就能够很方便地在咱们的makefile中以“$(objects)”的方式来使用这个变量了，因而咱们的改良版makefile就变成下面这个样子：
 144 
 145 objects = main.o kbd.o command.o display.o /
 146 insert.o search.o files.o utils.o
 147 
 148 edit : $(objects)
 149 cc -o edit $(objects)
 150 main.o : main.c defs.h
 151 cc -c main.c
 152 kbd.o : kbd.c defs.h command.h
 153 cc -c kbd.c
 154 command.o : command.c defs.h command.h
 155 cc -c command.c
 156 display.o : display.c defs.h buffer.h
 157 cc -c display.c
 158 insert.o : insert.c defs.h buffer.h
 159 cc -c insert.c
 160 search.o : search.c defs.h buffer.h
 161 cc -c search.c
 162 files.o : files.c defs.h buffer.h command.h
 163 cc -c files.c
 164 utils.o : utils.c defs.h
 165 cc -c utils.c
 166 clean :
 167 rm edit $(objects)
 168 
 169 
 170 因而若是有新的 .o 文件加入，咱们只需简单地修改一下 objects 变量就能够了。
 171 
 172 关于变量更多的话题，我会在后续给你一一道来。
 173 
 174 
 175 5、让make自动推导
 176 
 177 GNU的make很强大，它能够自动推导文件以及文件依赖关系后面的命令，因而咱们就不必去在每个[.o]文件后都写上相似的命令，由于，咱们的make会自动识别，并本身推导命令。
 178 
 179 只要make看到一个[.o]文件，它就会自动的把[.c]文件加在依赖关系中，若是make找到一个whatever.o，那么whatever.c，就会是whatever.o的依赖文件。而且 cc -c whatever.c 也会被推导出来，因而，咱们的makefile不再用写得这么复杂。咱们的是新的makefile又出炉了。
 180 
 181 
 182 objects = main.o kbd.o command.o display.o /
 183 insert.o search.o files.o utils.o
 184 
 185 edit : $(objects)
 186 cc -o edit $(objects)
 187 
 188 main.o : defs.h
 189 kbd.o : defs.h command.h
 190 command.o : defs.h command.h
 191 display.o : defs.h buffer.h
 192 insert.o : defs.h buffer.h
 193 search.o : defs.h buffer.h
 194 files.o : defs.h buffer.h command.h
 195 utils.o : defs.h
 196 
 197 .PHONY : clean
 198 clean :
 199 rm edit $(objects)
 200 
 201 这种方法，也就是make的“隐晦规则”。上面文件内容中，“.PHONY”表示，clean是个伪目标文件。
 202 
 203 关于更为详细的“隐晦规则”和“伪目标文件”，我会在后续给你一一道来。
 204 
 205 
 206 6、另类风格的makefile
 207 
 208 即然咱们的make能够自动推导命令，那么我看到那堆[.o]和[.h]的依赖就有点不爽，那么多的重复的[.h]，能不能把其收拢起来，好吧，没有问题，这个对于make来讲很容易，谁叫它提供了自动推导命令和文件的功能呢？来看看最新风格的makefile吧。
 209 
 210 objects = main.o kbd.o command.o display.o /
 211 insert.o search.o files.o utils.o
 212 
 213 edit : $(objects)
 214 cc -o edit $(objects)
 215 
 216 $(objects) : defs.h
 217 kbd.o command.o files.o : command.h
 218 display.o insert.o search.o files.o : buffer.h
 219 
 220 .PHONY : clean
 221 clean :
 222 rm edit $(objects)
 223 
 224 这种风格，让咱们的makefile变得很简单，但咱们的文件依赖关系就显得有点凌乱了。鱼和熊掌不可兼得。还看你的喜爱了。我是不喜欢这种风格的，一是文件的依赖关系看不清楚，二是若是文件一多，要加入几个新的.o文件，那就理不清楚了。
 225 
 226 7、清空目标文件的规则
 227 
 228 每一个Makefile中都应该写一个清空目标文件（.o和执行文件）的规则，这不只便于重编译，也很利于保持文件的清洁。这是一个“修养”（呵呵，还记得个人《编程修养》吗）。通常的风格都是：
 229 
 230 clean:
 231 rm edit $(objects)
 232 
 233 更为稳健的作法是：
 234 
 235 .PHONY : clean
 236 clean :
 237 -rm edit $(objects)
 238 
 239 前面说过，.PHONY意思表示clean是一个“伪目标”，。而在rm命令前面加了一个小减号的意思就是，也许某些文件出现问题，但不要管，继续作后面的事。固然，clean的规则不要放在文件的开头，否则，这就会变成make的默认目标，相信谁也不肯意这样。不成文的规矩是——“clean历来都是放在文件的最后”。
 240 
 241 
 242 上面就是一个makefile的概貌，也是makefile的基础，下面还有不少makefile的相关细节，准备好了吗？准备好了就来。
 243 
 244 Makefile 总述
 245 ———————
 246 
 247 1、Makefile里有什么？
 248 
 249 Makefile里主要包含了五个东西：显式规则、隐晦规则、变量定义、文件指示和注释。
 250 
 251 1、显式规则。显式规则说明了，如何生成一个或多的的目标文件。这是由Makefile的书写者明显指出，要生成的文件，文件的依赖文件，生成的命令。
 252 
 253 2、隐晦规则。因为咱们的make有自动推导的功能，因此隐晦的规则可让咱们比较粗糙地简略地书写Makefile，这是由make所支持的。
 254 
 255 3、变量的定义。在Makefile中咱们要定义一系列的变量，变量通常都是字符串，这个有点你C语言中的宏，当Makefile被执行时，其中的变量都会被扩展到相应的引用位置上。
 256 
 257 4、文件指示。其包括了三个部分，一个是在一个Makefile中引用另外一个Makefile，就像C语言中的include同样；另外一个是指根据某些状况指定Makefile中的有效部分，就像C语言中的预编译#if同样；还有就是定义一个多行的命令。有关这一部分的内容，我会在后续的部分中讲述。
 258 
 259 5、注释。Makefile中只有行注释，和UNIX的Shell脚本同样，其注释是用“#”字符，这个就像C/C++中的“//”同样。若是你要在你的Makefile中使用“#”字符，能够用反斜框进行转义，如：“/#”。
 260 
 261 最后，还值得一提的是，在Makefile中的命令，必需要以[Tab]键开始。
 262 
 263 
 264 2、Makefile的文件名
 265 
 266 默认的状况下，make命令会在当前目录下按顺序找寻文件名为“GNUmakefile”、“makefile”、“Makefile”的文件，找到了解释这个文件。在这三个文件名中，最好使用“Makefile”这个文件名，由于，这个文件名第一个字符为大写，这样有一种显目的感受。最好不要用“GNUmakefile”，这个文件是GNU的make识别的。有另一些make只对全小写的“makefile”文件名敏感，可是基本上来讲，大多数的make都支持“makefile”和“Makefile”这两种默认文件名。
 267 
 268 固然，你能够使用别的文件名来书写Makefile，好比：“Make.Linux”，“Make.Solaris”，“Make.AIX”等，若是要指定特定的Makefile，你能够使用make的“-f”和“--file”参数，如：make -f Make.Linux或make --file Make.AIX。
 269 
 270 
 271 3、引用其它的Makefile
 272 
 273 在Makefile使用include关键字能够把别的Makefile包含进来，这很像C语言的#include，被包含的文件会原模原样的放在当前文件的包含位置。include的语法是：
 274 
 275 include <filename>
 276 
 277 filename能够是当前操做系统Shell的文件模式（能够保含路径和通配符）
 278 
 279 在include前面能够有一些空字符，可是毫不能是[Tab]键开始。include和<filename>能够用一个或多个空格隔开。举个例子，你有这样几个Makefile：a.mk、b.mk、c.mk，还有一个文件叫foo.make，以及一个变量$(bar)，其包含了e.mk和f.mk，那么，下面的语句：
 280 
 281 include foo.make *.mk $(bar)
 282 
 283 等价于：
 284 
 285 include foo.make a.mk b.mk c.mk e.mk f.mk
 286 
 287 make命令开始时，会把找寻include所指出的其它Makefile，并把其内容安置在当前的位置。就好像C/C++的#include指令同样。若是文件都没有指定绝对路径或是相对路径的话，make会在当前目录下首先寻找，若是当前目录下没有找到，那么，make还会在下面的几个目录下找：
 288 
 289 1、若是make执行时，有“-I”或“--include-dir”参数，那么make就会在这个参数所指定的目录下去寻找。
 290 2、若是目录<prefix>/include（通常是：/usr/local/bin或/usr/include）存在的话，make也会去找。
 291 
 292 若是有文件没有找到的话，make会生成一条警告信息，但不会立刻出现致命错误。它会继续载入其它的文件，一旦完成makefile的读取，make会再重试这些没有找到，或是不能读取的文件，若是仍是不行，make才会出现一条致命信息。若是你想让make不理那些没法读取的文件，而继续执行，你能够在include前加一个减号“-”。如：
 293 
 294 -include <filename>
 295 其表示，不管include过程当中出现什么错误，都不要报错继续执行。和其它版本make兼容的相关命令是sinclude，其做用和这一个是同样的。
 296 
 297 
 298 4、环境变量 MAKEFILES
 299 
 300 若是你的当前环境中定义了环境变量MAKEFILES，那么，make会把这个变量中的值作一个相似于include的动做。这个变量中的值是其它的Makefile，用空格分隔。只是，它和include不一样的是，从这个环境变中引入的Makefile的“目标”不会起做用，若是环境变量中定义的文件发现错误，make也会不理。
 301 
 302 可是在这里我仍是建议不要使用这个环境变量，由于只要这个变量一被定义，那么当你使用make时，全部的Makefile都会受到它的影响，这毫不是你想看到的。在这里提这个事，只是为了告诉你们，也许有时候你的Makefile出现了怪事，那么你能够看看当前环境中有没有定义这个变量。
 303 
 304 
 305 5、make的工做方式
 306 
 307 GNU的make工做时的执行步骤入下：（想来其它的make也是相似）
 308 
 309 1、读入全部的Makefile。
 310 2、读入被include的其它Makefile。
 311 3、初始化文件中的变量。
 312 4、推导隐晦规则，并分析全部规则。
 313 5、为全部的目标文件建立依赖关系链。
 314 6、根据依赖关系，决定哪些目标要从新生成。
 315 7、执行生成命令。
 316 
 317 1-5步为第一个阶段，6-7为第二个阶段。第一个阶段中，若是定义的变量被使用了，那么，make会把其展开在使用的位置。但make并不会彻底立刻展开，make使用的是拖延战术，若是变量出如今依赖关系的规则中，那么仅当这条依赖被决定要使用了，变量才会在其内部展开。
 318 
 319 固然，这个工做方式你不必定要清楚，可是知道这个方式你也会对make更为熟悉。有了这个基础，后续部分也就容易看懂了。
 320 
 321 
 322 
 323 书写规则
 324 ————
 325 
 326 规则包含两个部分，一个是依赖关系，一个是生成目标的方法。
 327 
 328 在Makefile中，规则的顺序是很重要的，由于，Makefile中只应该有一个最终目标，其它的目标都是被这个目标所连带出来的，因此必定要让make知道你的最终目标是什么。通常来讲，定义在Makefile中的目标可能会有不少，可是第一条规则中的目标将被确立为最终的目标。若是第一条规则中的目标有不少个，那么，第一个目标会成为最终的目标。make所完成的也就是这个目标。
 329 
 330 好了，仍是让咱们来看一看如何书写规则。
 331 
 332 
 333 1、规则举例
 334 
 335 foo.o : foo.c defs.h # foo模块
 336 cc -c -g foo.c
 337 
 338 看到这个例子，各位应该不是很陌生了，前面也已说过，foo.o是咱们的目标，foo.c和defs.h是目标所依赖的源文件，而只有一个命令“cc -c -g foo.c”（以Tab键开头）。这个规则告诉咱们两件事：
 339 
 340 1、文件的依赖关系，foo.o依赖于foo.c和defs.h的文件，若是foo.c和defs.h的文件日期要比foo.o文件日期要新，或是foo.o不存在，那么依赖关系发生。
 341 2、若是生成（或更新）foo.o文件。也就是那个cc命令，其说明了，如何生成foo.o这个文件。（固然foo.c文件include了defs.h文件）
 342 
 343 
 344 2、规则的语法
 345 
 346 targets : prerequisites
 347 command
 348 ...
 349 
 350 或是这样：
 351 
 352 targets : prerequisites ; command
 353 command
 354 ...
 355 
 356 targets是文件名，以空格分开，能够使用通配符。通常来讲，咱们的目标基本上是一个文件，但也有多是多个文件。
 357 
 358 command是命令行，若是其不与“target吐舌rerequisites”在一行，那么，必须以[Tab键]开头，若是和prerequisites在一行，那么能够用分号作为分隔。（见上）
 359 
 360 prerequisites也就是目标所依赖的文件（或依赖目标）。若是其中的某个文件要比目标文件要新，那么，目标就被认为是“过期的”，被认为是须要重生成的。这个在前面已经讲过了。
 361 
 362 若是命令太长，你能够使用反斜框（‘/’）做为换行符。make对一行上有多少个字符没有限制。规则告诉make两件事，文件的依赖关系和如何成成目标文件。
 363 
 364 通常来讲，make会以UNIX的标准Shell，也就是/bin/sh来执行命令。
 365 
 366 
 367 3、在规则中使用通配符
 368 
 369 若是咱们想定义一系列比较相似的文件，咱们很天然地就想起使用通配符。make支持三各通配符：“*”，“?”和“[...]”。这是和Unix的B-Shell是相同的。
 370 
 371 波浪号（“~”）字符在文件名中也有比较特殊的用途。若是是“~/test”，这就表示当前用户的$HOME目录下的test目录。而“~hchen/test”则表示用户hchen的宿主目录下的test目录。（这些都是Unix下的小知识了，make也支持）而在Windows或是MS-DOS下，用户没有宿主目录，那么波浪号所指的目录则根据环境变量“HOME”而定。
 372 
 373 通配符代替了你一系列的文件，如“*.c”表示因此后缀为c的文件。一个须要咱们注意的是，若是咱们的文件名中有通配符，如：“*”，那么能够用转义字符“/”，如“/*”来表示真实的“*”字符，而不是任意长度的字符串。
 374 
 375 好吧，仍是先来看几个例子吧：
 376 
 377 clean:
 378 rm -f *.o
 379 
 380 上面这个例子我不很少说了，这是操做系统Shell所支持的通配符。这是在命令中的通配符。
 381 
 382 print: *.c
 383 lpr -p $?
 384 touch print
 385 
 386 上面这个例子说明了通配符也能够在咱们的规则中，目标print依赖于全部的[.c]文件。其中的“$?”是一个自动化变量，我会在后面给你讲述。
 387 
 388 objects = *.o
 389 
 390 上面这个例子，表示了，通符一样能够用在变量中。并非说[*.o]会展开，不！objects的值就是“*.o”。Makefile中的变量其实就是C/C++中的宏。若是你要让通配符在变量中展开，也就是让objects的值是全部[.o]的文件名的集合，那么，你能够这样：
 391 
 392 objects := $(wildcard *.o)
 393 
 394 这种用法由关键字“wildcard”指出，关于Makefile的关键字，咱们将在后面讨论。
 395 
 396 
 397 4、文件搜寻
 398 
 399 在一些大的工程中，有大量的源文件，咱们一般的作法是把这许多的源文件分类，并存放在不一样的目录中。因此，当make须要去找寻文件的依赖关系时，你能够在文件前加上路径，但最好的方法是把一个路径告诉make，让make在自动去找。
 400 
 401 Makefile文件中的特殊变量“VPATH”就是完成这个功能的，若是没有指明这个变量，make只会在当前的目录中去找寻依赖文件和目标文件。若是定义了这个变量，那么，make就会在当当前目录找不到的状况下，到所指定的目录中去找寻文件了。
 402 
 403 VPATH = src:../headers
 404 
 405 上面的的定义指定两个目录，“src”和“../headers”，make会按照这个顺序进行搜索。目录由“冒号”分隔。（固然，当前目录永远是最高优先搜索的地方）
 406 
 407 另外一个设置文件搜索路径的方法是使用make的“vpath”关键字（注意，它是全小写的），这不是变量，这是一个make的关键字，这和上面提到的那个VPATH变量很相似，可是它更为灵活。它能够指定不一样的文件在不一样的搜索目录中。这是一个很灵活的功能。它的使用方法有三种：
 408 
 409 一、vpath <pattern> <directories>
 410 
 411 为符合模式<pattern>的文件指定搜索目录<directories>。
 412 
 413 二、vpath <pattern>
 414 
 415 清除符合模式<pattern>的文件的搜索目录。
 416 
 417 三、vpath
 418 
 419 清除全部已被设置好了的文件搜索目录。
 420 
 421 vapth使用方法中的<pattern>须要包含“%”字符。“%”的意思是匹配零或若干字符，例如，“%.h”表示全部以“.h”结尾的文件。<pattern>指定了要搜索的文件集，而<directories>则指定了<pattern>的文件集的搜索的目录。例如：
 422 
 423 vpath %.h ../headers
 424 
 425 该语句表示，要求make在“../headers”目录下搜索全部以“.h”结尾的文件。（若是某文件在当前目录没有找到的话）
 426 
 427 咱们能够连续地使用vpath语句，以指定不一样搜索策略。若是连续的vpath语句中出现了相同的<pattern>，或是被重复了的<pattern>，那么，make会按照vpath语句的前后顺序来执行搜索。如：
 428 
 429 vpath %.c foo
 430 vpath % blish
 431 vpath %.c bar
 432 
 433 其表示“.c”结尾的文件，先在“foo”目录，而后是“blish”，最后是“bar”目录。
 434 
 435 vpath %.c foo:bar
 436 vpath % blish
 437 
 438 而上面的语句则表示“.c”结尾的文件，先在“foo”目录，而后是“bar”目录，最后才是“blish”目录。
 439 
 440 
 441 5、伪目标
 442 
 443 最先先的一个例子中，咱们提到过一个“clean”的目标，这是一个“伪目标”，
 444 
 445 clean:
 446 rm *.o temp
 447 
 448 正像咱们前面例子中的“clean”同样，即然咱们生成了许多文件编译文件，咱们也应该提供一个清除它们的“目标”以备完整地重编译而用。 （以“make clean”来使用该目标）
 449 
 450 由于，咱们并不生成“clean”这个文件。“伪目标”并非一个文件，只是一个标签，因为“伪目标”不是文件，因此make没法生成它的依赖关系和决定它是否要执行。咱们只有经过显示地指明这个“目标”才能让其生效。固然，“伪目标”的取名不能和文件名重名，否则其就失去了“伪目标”的意义了。
 451 
 452 固然，为了不和文件重名的这种状况，咱们能够使用一个特殊的标记“.PHONY”来显示地指明一个目标是“伪目标”，向make说明，无论是否有这个文件，这个目标就是“伪目标”。
 453 
 454 .PHONY : clean
 455 
 456 只要有这个声明，无论是否有“clean”文件，要运行“clean”这个目标，只有“make clean”这样。因而整个过程能够这样写：
 457 
 458 .PHONY: clean
 459 clean:
 460 rm *.o temp
 461 
 462 伪目标通常没有依赖的文件。可是，咱们也能够为伪目标指定所依赖的文件。伪目标一样能够做为“默认目标”，只要将其放在第一个。一个示例就是，若是你的Makefile须要一口气生成若干个可执行文件，但你只想简单地敲一个make完事，而且，全部的目标文件都写在一个Makefile中，那么你能够使用“伪目标”这个特性：
 463 
 464 all : prog1 prog2 prog3
 465 .PHONY : all
 466 
 467 prog1 : prog1.o utils.o
 468 cc -o prog1 prog1.o utils.o
 469 
 470 prog2 : prog2.o
 471 cc -o prog2 prog2.o
 472 
 473 prog3 : prog3.o sort.o utils.o
 474 cc -o prog3 prog3.o sort.o utils.o
 475 
 476 咱们知道，Makefile中的第一个目标会被做为其默认目标。咱们声明了一个“all”的伪目标，其依赖于其它三个目标。因为伪目标的特性是，老是被执行的，因此其依赖的那三个目标就老是不如“all”这个目标新。因此，其它三个目标的规则老是会被决议。也就达到了咱们一口气生成多个目标的目的。“.PHONY : all”声明了“all”这个目标为“伪目标”。
 477 
 478 随便提一句，从上面的例子咱们能够看出，目标也能够成为依赖。因此，伪目标一样也可成为依赖。看下面的例子：
 479 
 480 .PHONY: cleanall cleanobj cleandiff
 481 
 482 cleanall : cleanobj cleandiff
 483 rm program
 484 
 485 cleanobj :
 486 rm *.o
 487 
 488 cleandiff :
 489 rm *.diff
 490 
 491 “make clean”将清除全部要被清除的文件。“cleanobj”和“cleandiff”这两个伪目标有点像“子程序”的意思。咱们能够输入“make cleanall”和“make cleanobj”和“make cleandiff”命令来达到清除不一样种类文件的目的。
 492 
 493 6、多目标
 494 
 495 Makefile的规则中的目标能够不止一个，其支持多目标，有可能咱们的多个目标同时依赖于一个文件，而且其生成的命令大致相似。因而咱们就能把其合并起来。固然，多个目标的生成规则的执行命令是同一个，这可能会可咱们带来麻烦，不过好在咱们的能够使用一个自动化变量“$@”（关于自动化变量，将在后面讲述），这个变量表示着目前规则中全部的目标的集合，这样说可能很抽象，仍是看一个例子吧。
 496 
 497 bigoutput littleoutput : text.g
 498 generate text.g -$(subst output,,$@) > $@
 499 
 500 上述规则等价于：
 501 
 502 bigoutput : text.g
 503 generate text.g -big > bigoutput
 504 littleoutput : text.g
 505 generate text.g -little > littleoutput
 506 
 507 其中，-$(subst output,,$@)中的“$”表示执行一个Makefile的函数，函数名为subst，后面的为参数。关于函数，将在后面讲述。这里的这个函数是截取字符串的意思，“$@”表示目标的集合，就像一个数组，“$@”依次取出目标，并执于命令。
 508 
 509 
 510 7、静态模式
 511 
 512 静态模式能够更加容易地定义多目标的规则，可让咱们的规则变得更加的有弹性和灵活。咱们仍是先来看一下语法：
 513 
 514 <targets ...>: <target-pattern>: <prereq-patterns ...>
 515 <commands>
 516 ...
 517 
 518 
 519 targets定义了一系列的目标文件，能够有通配符。是目标的一个集合。
 520 
 521 target-parrtern是指明了targets的模式，也就是的目标集模式。
 522 
 523 prereq-parrterns是目标的依赖模式，它对target-parrtern造成的模式再进行一次依赖目标的定义。
 524 
 525 这样描述这三个东西，可能仍是没有说清楚，仍是举个例子来讲明一下吧。若是咱们的<target-parrtern>定义成“%.o”，意思是咱们的<target>集合中都是以“.o”结尾的，而若是咱们的<prereq-parrterns>定义成“%.c”，意思是对<target-parrtern>所造成的目标集进行二次定义，其计算方法是，取<target-parrtern>模式中的“%”（也就是去掉了[.o]这个结尾），并为其加上[.c]这个结尾，造成的新集合。
 526 
 527 因此，咱们的“目标模式”或是“依赖模式”中都应该有“%”这个字符，若是你的文件名中有“%”那么你能够使用反斜杠“/”进行转义，来标明真实的“%”字符。
 528 
 529 看一个例子：
 530 
 531 objects = foo.o bar.o
 532 
 533 all: $(objects)
 534 
 535 $(objects): %.o: %.c
 536 $(CC) -c $(CFLAGS) $< -o $@
 537 
 538 
 539 上面的例子中，指明了咱们的目标从$object中获取，“%.o”代表要全部以“.o”结尾的目标，也就是“foo.o bar.o”，也就是变量$object集合的模式，而依赖模式“%.c”则取模式“%.o”的“%”，也就是“foo bar”，并为其加下“.c”的后缀，因而，咱们的依赖目标就是“foo.c bar.c”。而命令中的“$<”和“$@”则是自动化变量，“$<”表示全部的依赖目标集（也就是“foo.c bar.c”），“$@”表示目标集（也就是“foo.o bar.o”）。因而，上面的规则展开后等价于下面的规则：
 540 
 541 foo.o : foo.c
 542 $(CC) -c $(CFLAGS) foo.c -o foo.o
 543 bar.o : bar.c
 544 $(CC) -c $(CFLAGS) bar.c -o bar.o
 545 
 546 试想，若是咱们的“%.o”有几百个，那种咱们只要用这种很简单的“静态模式规则”就能够写完一堆规则，实在是太有效率了。“静态模式规则”的用法很灵活，若是用得好，那会一个很强大的功能。再看一个例子：
 547 
 548 
 549 files = foo.elc bar.o lose.o
 550 
 551 $(filter %.o,$(files)): %.o: %.c
 552 $(CC) -c $(CFLAGS) $< -o $@
 553 $(filter %.elc,$(files)): %.elc: %.el
 554 emacs -f batch-byte-compile $<
 555 
 556 
 557 $(filter %.o,$(files))表示调用Makefile的filter函数，过滤“$filter”集，只要其中模式为“%.o”的内容。其的它内容，我就不用多说了吧。这个例字展现了Makefile中更大的弹性。
 558 
 559 
 560 8、自动生成依赖性
 561 
 562 在Makefile中，咱们的依赖关系可能会须要包含一系列的头文件，好比，若是咱们的main.c中有一句“#include "defs.h"”，那么咱们的依赖关系应该是：
 563 
 564 main.o : main.c defs.h
 565 
 566 可是，若是是一个比较大型的工程，你必需清楚哪些C文件包含了哪些头文件，而且，你在加入或删除头文件时，也须要当心地修改Makefile，这是一个很没有维护性的工做。为了不这种繁重而又容易出错的事情，咱们能够使用C/C++编译的一个功能。大多数的C/C++编译器都支持一个“-M”的选项，即自动找寻源文件中包含的头文件，并生成一个依赖关系。例如，若是咱们执行下面的命令：
 567 
 568 cc -M main.c
 569 
 570 其输出是：
 571 
 572 main.o : main.c defs.h
 573 
 574 因而由编译器自动生成的依赖关系，这样一来，你就没必要再手动书写若干文件的依赖关系，而由编译器自动生成了。须要提醒一句的是，若是你使用GNU的C/C++编译器，你得用“-MM”参数，否则，“-M”参数会把一些标准库的头文件也包含进来。
 575 
 576 gcc -M main.c的输出是：
 577 
 578 main.o: main.c defs.h /usr/include/stdio.h /usr/include/features.h /
 579 /usr/include/sys/cdefs.h /usr/include/gnu/stubs.h /
 580 /usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stddef.h /
 581 /usr/include/bits/types.h /usr/include/bits/pthreadtypes.h /
 582 /usr/include/bits/sched.h /usr/include/libio.h /
 583 /usr/include/_G_config.h /usr/include/wchar.h /
 584 /usr/include/bits/wchar.h /usr/include/gconv.h /
 585 /usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stdarg.h /
 586 /usr/include/bits/stdio_lim.h
 587 
 588 
 589 gcc -MM main.c的输出则是：
 590 
 591 main.o: main.c defs.h
 592 
 593 那么，编译器的这个功能如何与咱们的Makefile联系在一块儿呢。由于这样一来，咱们的Makefile也要根据这些源文件从新生成，让Makefile自已依赖于源文件？这个功能并不现实，不过咱们能够有其它手段来迂回地实现这一功能。GNU组织建议把编译器为每个源文件的自动生成的依赖关系放到一个文件中，为每个“name.c”的文件都生成一个“name.d”的Makefile文件，[.d]文件中就存放对应[.c]文件的依赖关系。
 594 
 595 因而，咱们能够写出[.c]文件和[.d]文件的依赖关系，并让make自动更新或自成[.d]文件，并把其包含在咱们的主Makefile中，这样，咱们就能够自动化地生成每一个文件的依赖关系了。
 596 
 597 这里，咱们给出了一个模式规则来产生[.d]文件：
 598 
 599 %.d: %.c
 600 @set -e; rm -f $@; /
 601 $(CC) -M $(CPPFLAGS) $< > $@.$$$$; /
 602 sed 's,/($*/)/.o[ :]*,/1.o $@ : ,g' < $@.$$$$ > $@; /
 603 rm -f $@.$$$$
 604 
 605 
 606 这个规则的意思是，全部的[.d]文件依赖于[.c]文件，“rm -f $@”的意思是删除全部的目标，也就是[.d]文件，第二行的意思是，为每一个依赖文件“$<”，也就是[.c]文件生成依赖文件，“$@”表示模式“%.d”文件，若是有一个C文件是name.c，那么“%”就是“name”，“$$$$”意为一个随机编号，第二行生成的文件有多是“name.d.12345”，第三行使用sed命令作了一个替换，关于sed命令的用法请参看相关的使用文档。第四行就是删除临时文件。
 607 
 608 总而言之，这个模式要作的事就是在编译器生成的依赖关系中加入[.d]文件的依赖，即把依赖关系：
 609 
 610 main.o : main.c defs.h
 611 
 612 转成：
 613 
 614 main.o main.d : main.c defs.h
 615 
 616 因而，咱们的[.d]文件也会自动更新了，并会自动生成了，固然，你还能够在这个[.d]文件中加入的不仅是依赖关系，包括生成的命令也可一并加入，让每一个[.d]文件都包含一个完赖的规则。一旦咱们完成这个工做，接下来，咱们就要把这些自动生成的规则放进咱们的主Makefile中。咱们能够使用Makefile的“include”命令，来引入别的Makefile文件（前面讲过），例如：
 617 
 618 sources = foo.c bar.c
 619 
 620 include $(sources:.c=.d)
 621 
 622 上述语句中的“$(sources:.c=.d)”中的“.c=.d”的意思是作一个替换，把变量$(sources)全部[.c]的字串都替换成[.d]，关于这个“替换”的内容，在后面我会有更为详细的讲述。固然，你得注意次序，由于include是按次来载入文件，最早载入的[.d]文件中的目标会成为默认目标。
 623 
 624  
 625 
 626 书写命令
 627 ————
 628 
 629 每条规则中的命令和操做系统Shell的命令行是一致的。make会一按顺序一条一条的执行命令，每条命令的开头必须以[Tab]键开头，除非，命令是紧跟在依赖规则后面的分号后的。在命令行之间中的空格或是空行会被忽略，可是若是该空格或空行是以Tab键开头的，那么make会认为其是一个空命令。
 630 
 631 咱们在UNIX下可能会使用不一样的Shell，可是make的命令默认是被“/bin/sh”——UNIX的标准Shell解释执行的。除非你特别指定一个其它的Shell。Makefile中，“#”是注释符，很像C/C++中的“//”，其后的本行字符都被注释。
 632 
 633 1、显示命令
 634 
 635 一般，make会把其要执行的命令行在命令执行前输出到屏幕上。当咱们用“@”字符在命令行前，那么，这个命令将不被make显示出来，最具表明性的例子是，咱们用这个功能来像屏幕显示一些信息。如：
 636 
 637 @echo 正在编译XXX模块......
 638 
 639 当make执行时，会输出“正在编译XXX模块......”字串，但不会输出命令，若是没有“@”，那么，make将输出：
 640 
 641 echo 正在编译XXX模块......
 642 正在编译XXX模块......
 643 
 644 若是make执行时，带入make参数“-n”或“--just-print”，那么其只是显示命令，但不会执行命令，这个功能颇有利于咱们调试咱们的Makefile，看看咱们书写的命令是执行起来是什么样子的或是什么顺序的。
 645 
 646 而make参数“-s”或“--slient”则是全面禁止命令的显示。
 647 
 648 
 649 
 650 2、命令执行
 651 
 652 当依赖目标新于目标时，也就是当规则的目标须要被更新时，make会一条一条的执行其后的命令。须要注意的是，若是你要让上一条命令的结果应用在下一条命令时，你应该使用分号分隔这两条命令。好比你的第一条命令是cd命令，你但愿第二条命令得在cd以后的基础上运行，那么你就不能把这两条命令写在两行上，而应该把这两条命令写在一行上，用分号分隔。如：
 653 
 654 示例一：
 655 exec:
 656 cd /home/hchen
 657 pwd
 658 
 659 示例二：
 660 exec:
 661 cd /home/hchen; pwd
 662 
 663 当咱们执行“make exec”时，第一个例子中的cd没有做用，pwd会打印出当前的Makefile目录，而第二个例子中，cd就起做用了，pwd会打印出“/home/hchen”。
 664 
 665 make通常是使用环境变量SHELL中所定义的系统Shell来执行命令，默认状况下使用UNIX的标准Shell——/bin/sh来执行命令。但在MS-DOS下有点特殊，由于MS-DOS下没有SHELL环境变量，固然你也能够指定。若是你指定了UNIX风格的目录形式，首先，make会在SHELL所指定的路径中找寻命令解释器，若是找不到，其会在当前盘符中的当前目录中寻找，若是再找不到，其会在PATH环境变量中所定义的全部路径中寻找。MS-DOS中，若是你定义的命令解释器没有找到，其会给你的命令解释器加上诸如“.exe”、“.com”、“.bat”、“.sh”等后缀。
 666 
 667 
 668 
 669 3、命令出错
 670 
 671 每当命令运行完后，make会检测每一个命令的返回码，若是命令返回成功，那么make会执行下一条命令，当规则中全部的命令成功返回后，这个规则就算是成功完成了。若是一个规则中的某个命令出错了（命令退出码非零），那么make就会终止执行当前规则，这将有可能终止全部规则的执行。
 672 
 673 有些时候，命令的出错并不表示就是错误的。例如mkdir命令，咱们必定须要创建一个目录，若是目录不存在，那么mkdir就成功执行，万事大吉，若是目录存在，那么就出错了。咱们之因此使用mkdir的意思就是必定要有这样的一个目录，因而咱们就不但愿mkdir出错而终止规则的运行。
 674 
 675 为了作到这一点，忽略命令的出错，咱们能够在Makefile的命令行前加一个减号“-”（在Tab键以后），标记为无论命令出不出错都认为是成功的。如：
 676 
 677 clean:
 678 -rm -f *.o
 679 
 680 还有一个全局的办法是，给make加上“-i”或是“--ignore-errors”参数，那么，Makefile中全部命令都会忽略错误。而若是一个规则是以“.IGNORE”做为目标的，那么这个规则中的全部命令将会忽略错误。这些是不一样级别的防止命令出错的方法，你能够根据你的不一样喜欢设置。
 681 
 682 还有一个要提一下的make的参数的是“-k”或是“--keep-going”，这个参数的意思是，若是某规则中的命令出错了，那么就终目该规则的执行，但继续执行其它规则。
 683 
 684 
 685 
 686 4、嵌套执行make
 687 
 688 在一些大的工程中，咱们会把咱们不一样模块或是不一样功能的源文件放在不一样的目录中，咱们能够在每一个目录中都书写一个该目录的Makefile，这有利于让咱们的Makefile变得更加地简洁，而不至于把全部的东西所有写在一个Makefile中，这样会很难维护咱们的Makefile，这个技术对于咱们模块编译和分段编译有着很是大的好处。
 689 
 690 例如，咱们有一个子目录叫subdir，这个目录下有个Makefile文件，来指明了这个目录下文件的编译规则。那么咱们总控的Makefile能够这样书写：
 691 
 692 subsystem:
 693 cd subdir && $(MAKE)
 694 
 695 其等价于：
 696 
 697 subsystem:
 698 $(MAKE) -C subdir
 699 
 700 定义$(MAKE)宏变量的意思是，也许咱们的make须要一些参数，因此定义成一个变量比较利于维护。这两个例子的意思都是先进入“subdir”目录，而后执行make命令。
 701 
 702 咱们把这个Makefile叫作“总控Makefile”，总控Makefile的变量能够传递到下级的Makefile中（若是你显示的声明），可是不会覆盖下层的Makefile中所定义的变量，除非指定了“-e”参数。
 703 
 704 若是你要传递变量到下级Makefile中，那么你能够使用这样的声明：
 705 
 706 export <variable ...>
 707 
 708 若是你不想让某些变量传递到下级Makefile中，那么你能够这样声明：
 709 
 710 unexport <variable ...>
 711 
 712 如：
 713 
 714 示例一：
 715 
 716 export variable = value
 717 
 718 其等价于：
 719 
 720 variable = value
 721 export variable
 722 
 723 其等价于：
 724 
 725 export variable := value
 726 
 727 其等价于：
 728 
 729 variable := value
 730 export variable
 731 
 732 示例二：
 733 
 734 export variable += value
 735 
 736 其等价于：
 737 
 738 variable += value
 739 export variable
 740 
 741 若是你要传递全部的变量，那么，只要一个export就好了。后面什么也不用跟，表示传递全部的变量。
 742 
 743 须要注意的是，有两个变量，一个是SHELL，一个是MAKEFLAGS，这两个变量无论你是否export，其老是要传递到下层Makefile中，特别是MAKEFILES变量，其中包含了make的参数信息，若是咱们执行“总控Makefile”时有make参数或是在上层Makefile中定义了这个变量，那么MAKEFILES变量将会是这些参数，并会传递到下层Makefile中，这是一个系统级的环境变量。
 744 
 745 可是make命令中的有几个参数并不往下传递，它们是“-C”,“-f”,“-h”“-o”和“-W”（有关Makefile参数的细节将在后面说明），若是你不想往下层传递参数，那么，你能够这样来：
 746 
 747 subsystem:
 748 cd subdir && $(MAKE) MAKEFLAGS=
 749 
 750 若是你定义了环境变量MAKEFLAGS，那么你得确信其中的选项是你们都会用到的，若是其中有“-t”,“-n”,和“-q”参数，那么将会有让你意想不到的结果，或许会让你异常地恐慌。
 751 
 752 还有一个在“嵌套执行”中比较有用的参数，“-w”或是“--print-directory”会在make的过程当中输出一些信息，让你看到目前的工做目录。好比，若是咱们的下级make目录是“/home/hchen/gnu/make”，若是咱们使用“make -w”来执行，那么当进入该目录时，咱们会看到：
 753 
 754 make: Entering directory `/home/hchen/gnu/make'.
 755 
 756 而在完成下层make后离开目录时，咱们会看到：
 757 
 758 make: Leaving directory `/home/hchen/gnu/make'
 759 
 760 当你使用“-C”参数来指定make下层Makefile时，“-w”会被自动打开的。若是参数中有“-s”（“--slient”）或是“--no-print-directory”，那么，“-w”老是失效的。
 761 
 762 
 763 
 764 5、定义命令包
 765 
 766 若是Makefile中出现一些相同命令序列，那么咱们能够为这些相同的命令序列定义一个变量。定义这种命令序列的语法以“define”开始，以“endef”结束，如：
 767 
 768 define run-yacc
 769 yacc $(firstword $^)
 770 mv y.tab.c $@
 771 endef
 772 
 773 这里，“run-yacc”是这个命令包的名字，其不要和Makefile中的变量重名。在“define”和“endef”中的两行就是命令序列。这个命令包中的第一个命令是运行Yacc程序，由于Yacc程序老是生成“y.tab.c”的文件，因此第二行的命令就是把这个文件改更名字。仍是把这个命令包放到一个示例中来看看吧。
 774 
 775 foo.c : foo.y
 776 $(run-yacc)
 777 
 778 咱们能够看见，要使用这个命令包，咱们就好像使用变量同样。在这个命令包的使用中，命令包“run-yacc”中的“$^”就是“foo.y”，“$@”就是“foo.c”（有关这种以“$”开头的特殊变量，咱们会在后面介绍），make在执行命令包时，命令包中的每一个命令会被依次独立执行。
 779 
 780 使用变量
 781 ————
 782 
 783 在Makefile中的定义的变量，就像是C/C++语言中的宏同样，他表明了一个文本字串，在Makefile中执行的时候其会自动原模原样地展开在所使用的地方。其与C/C++所不一样的是，你能够在Makefile中改变其值。在Makefile中，变量能够使用在“目标”，“依赖目标”，“命令”或是Makefile的其它部分中。
 784 
 785 变量的命名字能够包含字符、数字，下划线（能够是数字开头），但不该该含有“:”、“#”、“=”或是空字符（空格、回车等）。变量是大小写敏感的，“foo”、“Foo”和“FOO”是三个不一样的变量名。传统的Makefile的变量名是全大写的命名方式，但我推荐使用大小写搭配的变量名，如：MakeFlags。这样能够避免和系统的变量冲突，而发生意外的事情。
 786 
 787 有一些变量是很奇怪字串，如“$<”、“$@”等，这些是自动化变量，我会在后面介绍。
 788 
 789 1、变量的基础
 790 
 791 变量在声明时须要给予初值，而在使用时，须要给在变量名前加上“$”符号，但最好用小括号“（）”或是大括号“{}”把变量给包括起来。若是你要使用真实的“$”字符，那么你须要用“$$”来表示。
 792 
 793 变量能够使用在许多地方，如规则中的“目标”、“依赖”、“命令”以及新的变量中。先看一个例子：
 794 
 795 objects = program.o foo.o utils.o
 796 program : $(objects)
 797 cc -o program $(objects)
 798 
 799 $(objects) : defs.h
 800 
 801 变量会在使用它的地方精确地展开，就像C/C++中的宏同样，例如：
 802 
 803 foo = c
 804 prog.o : prog.$(foo)
 805 $(foo)$(foo) -$(foo) prog.$(foo)
 806 
 807 展开后获得：
 808 
 809 prog.o : prog.c
 810 cc -c prog.c
 811 
 812 固然，千万不要在你的Makefile中这样干，这里只是举个例子来代表Makefile中的变量在使用处展开的真实样子。可见其就是一个“替代”的原理。
 813 
 814 另外，给变量加上括号彻底是为了更加安全地使用这个变量，在上面的例子中，若是你不想给变量加上括号，那也能够，但我仍是强烈建议你给变量加上括号。
 815 
 816 
 817 2、变量中的变量
 818 
 819 在定义变量的值时，咱们能够使用其它变量来构造变量的值，在Makefile中有两种方式来在用变量定义变量的值。
 820 
 821 先看第一种方式，也就是简单的使用“=”号，在“=”左侧是变量，右侧是变量的值，右侧变量的值能够定义在文件的任何一处，也就是说，右侧中的变量不必定非要是已定义好的值，其也能够使用后面定义的值。如：
 822 
 823 foo = $(bar)
 824 bar = $(ugh)
 825 ugh = Huh?
 826 
 827 all:
 828 echo $(foo)
 829 
 830 咱们执行“make all”将会打出变量$(foo)的值是“Huh?”（ $(foo)的值是$(bar)，$(bar)的值是$(ugh)，$(ugh)的值是“Huh?”）可见，变量是能够使用后面的变量来定义的。
 831 
 832 这个功能有好的地方，也有很差的地方，好的地方是，咱们能够把变量的真实值推到后面来定义，如：
 833 
 834 CFLAGS = $(include_dirs) -O
 835 include_dirs = -Ifoo -Ibar
 836 
 837 当“CFLAGS”在命令中被展开时，会是“-Ifoo -Ibar -O”。但这种形式也有很差的地方，那就是递归定义，如：
 838 
 839 CFLAGS = $(CFLAGS) -O
 840 
 841 或：
 842 
 843 A = $(B)
 844 B = $(A)
 845 
 846 这会让make陷入无限的变量展开过程当中去，固然，咱们的make是有能力检测这样的定义，并会报错。还有就是若是在变量中使用函数，那么，这种方式会让咱们的make运行时很是慢，更糟糕的是，他会使用得两个make的函数“wildcard”和“shell”发生不可预知的错误。由于你不会知道这两个函数会被调用多少次。
 847 
 848 为了不上面的这种方法，咱们能够使用make中的另外一种用变量来定义变量的方法。这种方法使用的是“:=”操做符，如：
 849 
 850 x := foo
 851 y := $(x) bar
 852 x := later
 853 
 854 其等价于：
 855 
 856 y := foo bar
 857 x := later
 858 
 859 值得一提的是，这种方法，前面的变量不能使用后面的变量，只能使用前面已定义好了的变量。若是是这样：
 860 
 861 y := $(x) bar
 862 x := foo
 863 
 864 那么，y的值是“bar”，而不是“foo bar”。
 865 
 866 上面都是一些比较简单的变量使用了，让咱们来看一个复杂的例子，其中包括了make的函数、条件表达式和一个系统变量“MAKELEVEL”的使用：
 867 
 868 ifeq (0,${MAKELEVEL})
 869 cur-dir := $(shell pwd)
 870 whoami := $(shell whoami)
 871 host-type := $(shell arch)
 872 MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}
 873 endif
 874 
 875 关于条件表达式和函数，咱们在后面再说，对于系统变量“MAKELEVEL”，其意思是，若是咱们的make有一个嵌套执行的动做（参见前面的“嵌套使用make”），那么，这个变量会记录了咱们的当前Makefile的调用层数。
 876 
 877 下面再介绍两个定义变量时咱们须要知道的，请先看一个例子，若是咱们要定义一个变量，其值是一个空格，那么咱们能够这样来：
 878 
 879 nullstring :=
 880 space := $(nullstring) # end of the line
 881 
 882 nullstring是一个Empty变量，其中什么也没有，而咱们的space的值是一个空格。由于在操做符的右边是很难描述一个空格的，这里采用的技术很管用，先用一个Empty变量来标明变量的值开始了，然后面采用“#”注释符来表示变量定义的终止，这样，咱们能够定义出其值是一个空格的变量。请注意这里关于“#”的使用，注释符“#”的这种特性值得咱们注意，若是咱们这样定义一个变量：
 883 
 884 dir := /foo/bar # directory to put the frobs in
 885 
 886 dir这个变量的值是“/foo/bar”，后面还跟了4个空格，若是咱们这样使用这样变量来指定别的目录——“$(dir)/file”那么就完蛋了。
 887 
 888 还有一个比较有用的操做符是“?=”，先看示例：
 889 
 890 FOO ?= bar
 891 
 892 其含义是，若是FOO没有被定义过，那么变量FOO的值就是“bar”，若是FOO先前被定义过，那么这条语将什么也不作，其等价于：
 893 
 894 ifeq ($(origin FOO), undefined)
 895 FOO = bar
 896 endif
 897 
 898 
 899 3、变量高级用法
 900 
 901 这里介绍两种变量的高级使用方法，第一种是变量值的替换。
 902 
 903 咱们能够替换变量中的共有的部分，其格式是“$(var:a=b)”或是“${var:a=b}”，其意思是，把变量“var”中全部以“a”字串“结尾”的“a”替换成“b”字串。这里的“结尾”意思是“空格”或是“结束符”。
 904 
 905 仍是看一个示例吧：
 906 
 907 foo := a.o b.o c.o
 908 bar := $(foo:.o=.c)
 909 
 910 这个示例中，咱们先定义了一个“$(foo)”变量，而第二行的意思是把“$(foo)”中全部以“.o”字串“结尾”所有替换成“.c”，因此咱们的“$(bar)”的值就是“a.c b.c c.c”。
 911 
 912 另一种变量替换的技术是以“静态模式”（参见前面章节）定义的，如：
 913 
 914 foo := a.o b.o c.o
 915 bar := $(foo:%.o=%.c)
 916 
 917 这依赖于被替换字串中的有相同的模式，模式中必须包含一个“%”字符，这个例子一样让$(bar)变量的值为“a.c b.c c.c”。
 918 
 919 第二种高级用法是——“把变量的值再当成变量”。先看一个例子：
 920 
 921 x = y
 922 y = z
 923 a := $($(x))
 924 
 925 在这个例子中，$(x)的值是“y”，因此$($(x))就是$(y)，因而$(a)的值就是“z”。（注意，是“x=y”，而不是“x=$(y)”）
 926 
 927 咱们还能够使用更多的层次：
 928 
 929 x = y
 930 y = z
 931 z = u
 932 a := $($($(x)))
 933 
 934 这里的$(a)的值是“u”，相关的推导留给读者本身去作吧。
 935 
 936 让咱们再复杂一点，使用上“在变量定义中使用变量”的第一个方式，来看一个例子：
 937 
 938 x = $(y)
 939 y = z
 940 z = Hello
 941 a := $($(x))
 942 
 943 这里的$($(x))被替换成了$($(y))，由于$(y)值是“z”，因此，最终结果是：a:=$(z)，也就是“Hello”。
 944 
 945 再复杂一点，咱们再加上函数：
 946 
 947 x = variable1
 948 variable2 := Hello
 949 y = $(subst 1,2,$(x))
 950 z = y
 951 a := $($($(z)))
 952 
 953 这个例子中，“$($($(z)))”扩展为“$($(y))”，而其再次被扩展为“$($(subst 1,2,$(x)))”。$(x)的值是“variable1”，subst函数把“variable1”中的全部“1”字串替换成“2”字串，因而，“variable1”变成“variable2”，再取其值，因此，最终，$(a)的值就是$(variable2)的值——“Hello”。（喔，好不容易）
 954 
 955 在这种方式中，或要能够使用多个变量来组成一个变量的名字，而后再取其值：
 956 
 957 first_second = Hello
 958 a = first
 959 b = second
 960 all = $($a_$b)
 961 
 962 这里的“$a_$b”组成了“first_second”，因而，$(all)的值就是“Hello”。
 963 
 964 再来看看结合第一种技术的例子：
 965 
 966 a_objects := a.o b.o c.o
 967 1_objects := 1.o 2.o 3.o
 968 
 969 sources := $($(a1)_objects:.o=.c)
 970 
 971 这个例子中，若是$(a1)的值是“a”的话，那么，$(sources)的值就是“a.c b.c c.c”；若是$(a1)的值是“1”，那么$(sources)的值是“1.c 2.c 3.c”。
 972 
 973 再来看一个这种技术和“函数”与“条件语句”一同使用的例子：
 974 
 975 ifdef do_sort
 976 func := sort
 977 else
 978 func := strip
 979 endif
 980 
 981 bar := a d b g q c
 982 
 983 foo := $($(func) $(bar))
 984 
 985 这个示例中，若是定义了“do_sort”，那么：foo := $(sort a d b g q c)，因而$(foo)的值就是“a b c d g q”，而若是没有定义“do_sort”，那么：foo := $(sort a d b g q c)，调用的就是strip函数。
 986 
 987 固然，“把变量的值再当成变量”这种技术，一样能够用在操做符的左边：
 988 
 989 dir = foo
 990 $(dir)_sources := $(wildcard $(dir)/*.c)
 991 define $(dir)_print
 992 lpr $($(dir)_sources)
 993 endef
 994 
 995 这个例子中定义了三个变量：“dir”，“foo_sources”和“foo_print”。
 996 
 997 
 998 4、追加变量值
 999 
1000 咱们能够使用“+=”操做符给变量追加值，如：
1001 
1002 objects = main.o foo.o bar.o utils.o
1003 objects += another.o
1004 
1005 因而，咱们的$(objects)值变成：“main.o foo.o bar.o utils.o another.o”（another.o被追加进去了）
1006 
1007 使用“+=”操做符，能够模拟为下面的这种例子：
1008 
1009 objects = main.o foo.o bar.o utils.o
1010 objects := $(objects) another.o
1011 
1012 所不一样的是，用“+=”更为简洁。
1013 
1014 若是变量以前没有定义过，那么，“+=”会自动变成“=”，若是前面有变量定义，那么“+=”会继承于前次操做的赋值符。若是前一次的是“:=”，那么“+=”会以“:=”做为其赋值符，如：
1015 
1016 variable := value
1017 variable += more
1018 
1019 等价于：
1020 
1021 variable := value
1022 variable := $(variable) more
1023 
1024 但若是是这种状况：
1025 
1026 variable = value
1027 variable += more
1028 
1029 因为前次的赋值符是“=”，因此“+=”也会以“=”来作为赋值，那么岂不会发生变量的递补归定义，这是很很差的，因此make会自动为咱们解决这个问题，咱们没必要担忧这个问题。
1030 
1031 
1032 5、override 指示符
1033 
1034 若是有变量是一般make的命令行参数设置的，那么Makefile中对这个变量的赋值会被忽略。若是你想在Makefile中设置这类参数的值，那么，你能够使用“override”指示符。其语法是：
1035 
1036 override <variable> = <value>
1037 
1038 override <variable> := <value>
1039 
1040 固然，你还能够追加：
1041 
1042 override <variable> += <more text>
1043 
1044 对于多行的变量定义，咱们用define指示符，在define指示符前，也一样能够使用ovveride指示符，如：
1045 
1046 override define foo
1047 bar
1048 endef
1049 
1050 6、多行变量
1051 
1052 还有一种设置变量值的方法是使用define关键字。使用define关键字设置变量的值能够有换行，这有利于定义一系列的命令（前面咱们讲过“命令包”的技术就是利用这个关键字）。
1053 
1054 define指示符后面跟的是变量的名字，而重起一行定义变量的值，定义是以endef关键字结束。其工做方式和“=”操做符同样。变量的值能够包含函数、命令、文字，或是其它变量。由于命令须要以[Tab]键开头，因此若是你用define定义的命令变量中没有以[Tab]键开头，那么make就不会把其认为是命令。
1055 
1056 下面的这个示例展现了define的用法：
1057 
1058 define two-lines
1059 echo foo
1060 echo $(bar)
1061 endef
1062 
1063 
1064 7、环境变量
1065 
1066 make运行时的系统环境变量能够在make开始运行时被载入到Makefile文件中，可是若是Makefile中已定义了这个变量，或是这个变量由make命令行带入，那么系统的环境变量的值将被覆盖。（若是make指定了“-e”参数，那么，系统环境变量将覆盖Makefile中定义的变量）
1067 
1068 所以，若是咱们在环境变量中设置了“CFLAGS”环境变量，那么咱们就能够在全部的Makefile中使用这个变量了。这对于咱们使用统一的编译参数有比较大的好处。若是Makefile中定义了CFLAGS，那么则会使用Makefile中的这个变量，若是没有定义则使用系统环境变量的值，一个共性和个性的统一，很像“全局变量”和“局部变量”的特性。
1069 
1070 当make嵌套调用时（参见前面的“嵌套调用”章节），上层Makefile中定义的变量会以系统环境变量的方式传递到下层的Makefile中。固然，默认状况下，只有经过命令行设置的变量会被传递。而定义在文件中的变量，若是要向下层Makefile传递，则须要使用exprot关键字来声明。（参见前面章节）
1071 
1072 固然，我并不推荐把许多的变量都定义在系统环境中，这样，在咱们执行不用的Makefile时，拥有的是同一套系统变量，这可能会带来更多的麻烦。
1073 
1074 
1075 8、目标变量
1076 
1077 前面咱们所讲的在Makefile中定义的变量都是“全局变量”，在整个文件，咱们均可以访问这些变量。固然，“自动化变量”除外，如“$<”等这种类量的自动化变量就属于“规则型变量”，这种变量的值依赖于规则的目标和依赖目标的定义。
1078 
1079 固然，我样一样能够为某个目标设置局部变量，这种变量被称为“Target-specific Variable”，它能够和“全局变量”同名，由于它的做用范围只在这条规则以及连带规则中，因此其值也只在做用范围内有效。而不会影响规则链之外的全局变量的值。
1080 
1081 其语法是：
1082 
1083 <target ...> : <variable-assignment>
1084 
1085 <target ...> : overide <variable-assignment>
1086 
1087 <variable-assignment>能够是前面讲过的各类赋值表达式，如“=”、“:=”、“+=”或是“？=”。第二个语法是针对于make命令行带入的变量，或是系统环境变量。
1088 
1089 这个特性很是的有用，当咱们设置了这样一个变量，这个变量会做用到由这个目标所引起的全部的规则中去。如：
1090 
1091 prog : CFLAGS = -g
1092 prog : prog.o foo.o bar.o
1093 $(CC) $(CFLAGS) prog.o foo.o bar.o
1094 
1095 prog.o : prog.c
1096 $(CC) $(CFLAGS) prog.c
1097 
1098 foo.o : foo.c
1099 $(CC) $(CFLAGS) foo.c
1100 
1101 bar.o : bar.c
1102 $(CC) $(CFLAGS) bar.c
1103 
1104 在这个示例中，无论全局的$(CFLAGS)的值是什么，在prog目标，以及其所引起的全部规则中（prog.o foo.o bar.o的规则），$(CFLAGS)的值都是“-g”
1105 
1106 
1107 9、模式变量
1108 
1109 在GNU的make中，还支持模式变量（Pattern-specific Variable），经过上面的目标变量中，咱们知道，变量能够定义在某个目标上。模式变量的好处就是，咱们能够给定一种“模式”，能够把变量定义在符合这种模式的全部目标上。
1110 
1111 咱们知道，make的“模式”通常是至少含有一个“%”的，因此，咱们能够以以下方式给全部以[.o]结尾的目标定义目标变量：
1112 
1113 %.o : CFLAGS = -O
1114 
1115 一样，模式变量的语法和“目标变量”同样：
1116 
1117 <pattern ...> : <variable-assignment>
1118 
1119 <pattern ...> : override <variable-assignment>
1120 
1121 override一样是针对于系统环境传入的变量，或是make命令行指定的变量。
1122 
1123 使用条件判断
1124 ——————
1125 
1126 使用条件判断，可让make根据运行时的不一样状况选择不一样的执行分支。条件表达式能够是比较变量的值，或是比较变量和常量的值。
1127 
1128 1、示例
1129 
1130 下面的例子，判断$(CC)变量是否“gcc”，若是是的话，则使用GNU函数编译目标。
1131 
1132 libs_for_gcc = -lgnu
1133 normal_libs =
1134 
1135 foo: $(objects)
1136 ifeq ($(CC),gcc)
1137 $(CC) -o foo $(objects) $(libs_for_gcc)
1138 else
1139 $(CC) -o foo $(objects) $(normal_libs)
1140 endif
1141 
1142 可见，在上面示例的这个规则中，目标“foo”能够根据变量“$(CC)”值来选取不一样的函数库来编译程序。
1143 
1144 咱们能够从上面的示例中看到三个关键字：ifeq、else和endif。ifeq的意思表示条件语句的开始，并指定一个条件表达式，表达式包含两个参数，以逗号分隔，表达式以圆括号括起。else表示条件表达式为假的状况。endif表示一个条件语句的结束，任何一个条件表达式都应该以endif结束。
1145 
1146 当咱们的变量$(CC)值是“gcc”时，目标foo的规则是：
1147 
1148 foo: $(objects)
1149 $(CC) -o foo $(objects) $(libs_for_gcc)
1150 
1151 而当咱们的变量$(CC)值不是“gcc”时（好比“cc”），目标foo的规则是：
1152 
1153 foo: $(objects)
1154 $(CC) -o foo $(objects) $(normal_libs)
1155 
1156 固然，咱们还能够把上面的那个例子写得更简洁一些：
1157 
1158 libs_for_gcc = -lgnu
1159 normal_libs =
1160 
1161 ifeq ($(CC),gcc)
1162 libs=$(libs_for_gcc)
1163 else
1164 libs=$(normal_libs)
1165 endif
1166 
1167 foo: $(objects)
1168 $(CC) -o foo $(objects) $(libs)
1169 
1170 
1171 2、语法
1172 
1173 条件表达式的语法为：
1174 
1175 <conditional-directive>
1176 <text-if-true>
1177 endif
1178 
1179 以及：
1180 
1181 <conditional-directive>
1182 <text-if-true>
1183 else
1184 <text-if-false>
1185 endif
1186 
1187 其中<conditional-directive>表示条件关键字，如“ifeq”。这个关键字有四个。
1188 
1189 第一个是咱们前面所见过的“ifeq”
1190 
1191 ifeq (<arg1>, <arg2> )
1192 ifeq '<arg1>' '<arg2>'
1193 ifeq "<arg1>" "<arg2>"
1194 ifeq "<arg1>" '<arg2>'
1195 ifeq '<arg1>' "<arg2>"
1196 
1197 比较参数“arg1”和“arg2”的值是否相同。固然，参数中咱们还能够使用make的函数。如：
1198 
1199 ifeq ($(strip $(foo)),)
1200 <text-if-empty>
1201 endif
1202 
1203 这个示例中使用了“strip”函数，若是这个函数的返回值是空（Empty），那么<text-if-empty>就生效。
1204 
1205 第二个条件关键字是“ifneq”。语法是：
1206 
1207 ifneq (<arg1>, <arg2> )
1208 ifneq '<arg1>' '<arg2>'
1209 ifneq "<arg1>" "<arg2>"
1210 ifneq "<arg1>" '<arg2>'
1211 ifneq '<arg1>' "<arg2>"
1212 
1213 其比较参数“arg1”和“arg2”的值是否相同，若是不一样，则为真。和“ifeq”相似。
1214 
1215 第三个条件关键字是“ifdef”。语法是：
1216 
1217 ifdef <variable-name>
1218 
1219 若是变量<variable-name>的值非空，那到表达式为真。不然，表达式为假。固然，<variable-name>一样能够是一个函数的返回值。注意，ifdef只是测试一个变量是否有值，其并不会把变量扩展到当前位置。仍是来看两个例子：
1220 
1221 示例一：
1222 bar =
1223 foo = $(bar)
1224 ifdef foo
1225 frobozz = yes
1226 else
1227 frobozz = no
1228 endif
1229 
1230 示例二：
1231 foo =
1232 ifdef foo
1233 frobozz = yes
1234 else
1235 frobozz = no
1236 endif
1237 
1238 第一个例子中，“$(frobozz)”值是“yes”，第二个则是“no”。
1239 
1240 第四个条件关键字是“ifndef”。其语法是：
1241 
1242 ifndef <variable-name>
1243 
1244 这个我就很少说了，和“ifdef”是相反的意思。
1245 
1246 在<conditional-directive>这一行上，多余的空格是被容许的，可是不能以[Tab]键作为开始（否则就被认为是命令）。而注释符“#”一样也是安全的。“else”和“endif”也同样，只要不是以[Tab]键开始就好了。
1247 
1248 特别注意的是，make是在读取Makefile时就计算条件表达式的值，并根据条件表达式的值来选择语句，因此，你最好不要把自动化变量（如“$@”等）放入条件表达式中，由于自动化变量是在运行时才有的。
1249 
1250 并且，为了不混乱，make不容许把整个条件语句分红两部分放在不一样的文件中。
1251 
1252 
1253 
1254 使用函数
1255 ————
1256 
1257 在Makefile中能够使用函数来处理变量，从而让咱们的命令或是规则更为的灵活和具备智能。make所支持的函数也不算不少，不过已经足够咱们的操做了。函数调用后，函数的返回值能够当作变量来使用。
1258 
1259 
1260 1、函数的调用语法
1261 
1262 函数调用，很像变量的使用，也是以“$”来标识的，其语法以下：
1263 
1264 $(<function> <arguments> )
1265 
1266 或是
1267 
1268 ${<function> <arguments>}
1269 
1270 这里，<function>就是函数名，make支持的函数很少。<arguments>是函数的参数，参数间以逗号“,”分隔，而函数名和参数之间以“空格”分隔。函数调用以“$”开头，以圆括号或花括号把函数名和参数括起。感受很像一个变量，是否是？函数中的参数能够使用变量，为了风格的统一，函数和变量的括号最好同样，如使用“$(subst a,b,$(x))”这样的形式，而不是“$(subst a,b,${x})”的形式。由于统一会更清楚，也会减小一些没必要要的麻烦。
1271 
1272 仍是来看一个示例：
1273 
1274 comma:= ,
1275 empty:=
1276 space:= $(empty) $(empty)
1277 foo:= a b c
1278 bar:= $(subst $(space),$(comma),$(foo))
1279 
1280 在这个示例中，$(comma)的值是一个逗号。$(space)使用了$(empty)定义了一个空格，$(foo)的值是“a b c”，$(bar)的定义用，调用了函数“subst”，这是一个替换函数，这个函数有三个参数，第一个参数是被替换字串，第二个参数是替换字串，第三个参数是替换操做做用的字串。这个函数也就是把$(foo)中的空格替换成逗号，因此$(bar)的值是“a,b,c”。
1281 
1282 
1283 2、字符串处理函数
1284 
1285 $(subst <from>,<to>,<text> )
1286 
1287 名称：字符串替换函数——subst。
1288 功能：把字串<text>中的<from>字符串替换成<to>。
1289 返回：函数返回被替换事后的字符串。
1290 
1291 示例：
1292 
1293 $(subst ee,EE,feet on the street)，
1294 
1295 把“feet on the street”中的“ee”替换成“EE”，返回结果是“fEEt on the strEEt”。
1296 
1297 
1298 $(patsubst <pattern>,<replacement>,<text> )
1299 
1300 名称：模式字符串替换函数——patsubst。
1301 功能：查找<text>中的单词（单词以“空格”、“Tab”或“回车”“换行”分隔）是否符合模式<pattern>，若是匹配的话，则以<replacement>替换。这里，<pattern>能够包括通配符“%”，表示任意长度的字串。若是<replacement>中也包含“%”，那么，<replacement>中的这个“%”将是<pattern>中的那个“%”所表明的字串。（能够用“/”来转义，以“/%”来表示真实含义的“%”字符）
1302 返回：函数返回被替换事后的字符串。
1303 
1304 示例：
1305 
1306 $(patsubst %.c,%.o,x.c.c bar.c)
1307 
1308 把字串“x.c.c bar.c”符合模式[%.c]的单词替换成[%.o]，返回结果是“x.c.o bar.o”
1309 
1310 备注：
1311 
1312 这和咱们前面“变量章节”说过的相关知识有点类似。如：
1313 
1314 “$(var:<pattern>=<replacement> )”
1315 至关于
1316 “$(patsubst <pattern>,<replacement>,$(var))”，
1317 
1318 而“$(var: <suffix>=<replacement> )”
1319 则至关于
1320 “$(patsubst %<suffix>,%<replacement>,$(var))”。
1321 
1322 例若有：objects = foo.o bar.o baz.o，
1323 那么，“$(objects:.o=.c)”和“$(patsubst %.o,%.c,$(objects))”是同样的。
1324 
1325 $(strip <string> )
1326 
1327 名称：去空格函数——strip。
1328 功能：去掉<string>字串中开头和结尾的空字符。
1329 返回：返回被去掉空格的字符串值。
1330 示例：
1331 
1332 $(strip a b c )
1333 
1334 把字串“a b c ”去到开头和结尾的空格，结果是“a b c”。
1335 
1336 $(findstring <find>,<in> )
1337 
1338 名称：查找字符串函数——findstring。
1339 功能：在字串<in>中查找<find>字串。
1340 返回：若是找到，那么返回<find>，不然返回空字符串。
1341 示例：
1342 
1343 $(findstring a,a b c)
1344 $(findstring a,b c)
1345 
1346 第一个函数返回“a”字符串，第二个返回“”字符串（空字符串）
1347 
1348 $(filter <pattern...>,<text> )
1349 
1350 名称：过滤函数——filter。
1351 功能：以<pattern>模式过滤<text>字符串中的单词，保留符合模式<pattern>的单词。能够有多个模式。
1352 返回：返回符合模式<pattern>的字串。
1353 示例：
1354 
1355 sources := foo.c bar.c baz.s ugh.h
1356 foo: $(sources)
1357 cc $(filter %.c %.s,$(sources)) -o foo
1358 
1359 $(filter %.c %.s,$(sources))返回的值是“foo.c bar.c baz.s”。
1360 
1361 $(filter-out <pattern...>,<text> )
1362 
1363 名称：反过滤函数——filter-out。
1364 功能：以<pattern>模式过滤<text>字符串中的单词，去除符合模式<pattern>的单词。能够有多个模式。
1365 返回：返回不符合模式<pattern>的字串。
1366 示例：
1367 
1368 objects=main1.o foo.o main2.o bar.o
1369 mains=main1.o main2.o
1370 
1371 $(filter-out $(mains),$(objects)) 返回值是“foo.o bar.o”。
1372 
1373 $(sort <list> )
1374 
1375 名称：排序函数——sort。
1376 功能：给字符串<list>中的单词排序（升序）。
1377 返回：返回排序后的字符串。
1378 示例：$(sort foo bar lose)返回“bar foo lose” 。
1379 备注：sort函数会去掉<list>中相同的单词。
1380 
1381 $(word <n>,<text> )
1382 
1383 名称：取单词函数——word。
1384 功能：取字符串<text>中第<n>个单词。（从一开始）
1385 返回：返回字符串<text>中第<n>个单词。若是<n>比<text>中的单词数要大，那么返回空字符串。
1386 示例：$(word 2, foo bar baz)返回值是“bar”。
1387 
1388 $(wordlist <s>,<e>,<text> )
1389 
1390 名称：取单词串函数——wordlist。
1391 功能：从字符串<text>中取从<s>开始到<e>的单词串。<s>和<e>是一个数字。
1392 返回：返回字符串<text>中从<s>到<e>的单词字串。若是<s>比<text>中的单词数要大，那么返回空字符串。若是<e>大于<text>的单词数，那么返回从<s>开始，到<text>结束的单词串。
1393 示例： $(wordlist 2, 3, foo bar baz)返回值是“bar baz”。
1394 
1395 $(words <text> )
1396 
1397 名称：单词个数统计函数——words。
1398 功能：统计<text>中字符串中的单词个数。
1399 返回：返回<text>中的单词数。
1400 示例：$(words, foo bar baz)返回值是“3”。
1401 备注：若是咱们要取<text>中最后的一个单词，咱们能够这样：$(word $(words <text> ),<text> )。
1402 
1403 $(firstword <text> )
1404 
1405 名称：首单词函数——firstword。
1406 功能：取字符串<text>中的第一个单词。
1407 返回：返回字符串<text>的第一个单词。
1408 示例：$(firstword foo bar)返回值是“foo”。
1409 备注：这个函数能够用word函数来实现：$(word 1,<text> )。
1410 
1411 以上，是全部的字符串操做函数，若是搭配混合使用，能够完成比较复杂的功能。这里，举一个现实中应用的例子。咱们知道，make使用“VPATH”变量来指定“依赖文件”的搜索路径。因而，咱们能够利用这个搜索路径来指定编译器对头文件的搜索路径参数CFLAGS，如：
1412 
1413 override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH)))
1414 
1415 若是咱们的“$(VPATH)”值是“src:../headers”，那么“$(patsubst %,-I%,$(subst :, ,$(VPATH)))”将返回“-Isrc -I../headers”，这正是cc或gcc搜索头文件路径的参数。
1416 
1417 
1418 3、文件名操做函数
1419 
1420 下面咱们要介绍的函数主要是处理文件名的。每一个函数的参数字符串都会被当作一个或是一系列的文件名来对待。
1421 
1422 $(dir <names...> )
1423 
1424 名称：取目录函数——dir。
1425 功能：从文件名序列<names>中取出目录部分。目录部分是指最后一个反斜杠（“/”）以前的部分。若是没有反斜杠，那么返回“./”。
1426 返回：返回文件名序列<names>的目录部分。
1427 示例： $(dir src/foo.c hacks)返回值是“src/ ./”。
1428 
1429 $(notdir <names...> )
1430 
1431 名称：取文件函数——notdir。
1432 功能：从文件名序列<names>中取出非目录部分。非目录部分是指最后一个反斜杠（“/”）以后的部分。
1433 返回：返回文件名序列<names>的非目录部分。
1434 示例： $(notdir src/foo.c hacks)返回值是“foo.c hacks”。
1435 
1436 $(suffix <names...> )
1437 
1438 名称：取后缀函数——suffix。
1439 功能：从文件名序列<names>中取出各个文件名的后缀。
1440 返回：返回文件名序列<names>的后缀序列，若是文件没有后缀，则返回空字串。
1441 示例：$(suffix src/foo.c src-1.0/bar.c hacks)返回值是“.c .c”。
1442 
1443 $(basename <names...> )
1444 
1445 名称：取前缀函数——basename。
1446 功能：从文件名序列<names>中取出各个文件名的前缀部分。
1447 返回：返回文件名序列<names>的前缀序列，若是文件没有前缀，则返回空字串。
1448 示例：$(basename src/foo.c src-1.0/bar.c hacks)返回值是“src/foo src-1.0/bar hacks”。
1449 
1450 $(addsuffix <suffix>,<names...> )
1451 
1452 名称：加后缀函数——addsuffix。
1453 功能：把后缀<suffix>加到<names>中的每一个单词后面。
1454 返回：返回加事后缀的文件名序列。
1455 示例：$(addsuffix .c,foo bar)返回值是“foo.c bar.c”。
1456 
1457 $(addprefix <prefix>,<names...> )
1458 
1459 名称：加前缀函数——addprefix。
1460 功能：把前缀<prefix>加到<names>中的每一个单词后面。
1461 返回：返回加过前缀的文件名序列。
1462 示例：$(addprefix src/,foo bar)返回值是“src/foo src/bar”。
1463 
1464 $(join <list1>,<list2> )
1465 
1466 名称：链接函数——join。
1467 功能：把<list2>中的单词对应地加到<list1>的单词后面。若是<list1>的单词个数要比<list2>的多，那么，<list1>中的多出来的单词将保持原样。若是<list2>的单词个数要比<list1>多，那么，<list2>多出来的单词将被复制到<list2>中。
1468 返回：返回链接事后的字符串。
1469 示例：$(join aaa bbb , 111 222 333)返回值是“aaa111 bbb222 333”。
1470 
1471 
1472 
1473 4、foreach 函数
1474 
1475 
1476 foreach函数和别的函数很是的不同。由于这个函数是用来作循环用的，Makefile中的foreach函数几乎是仿照于Unix标准Shell（/bin/sh）中的for语句，或是C-Shell（/bin/csh）中的foreach语句而构建的。它的语法是：
1477 
1478 
1479 
1480 $(foreach <var>,<list>,<text> )
1481 
1482 
1483 
1484 这个函数的意思是，把参数<list>中的单词逐一取出放到参数<var>所指定的变量中，而后再执行<text>所包含的表达式。每一次<text>会返回一个字符串，循环过程当中，<text>的所返回的每一个字符串会以空格分隔，最后当整个循环结束时，<text>所返回的每一个字符串所组成的整个字符串（以空格分隔）将会是foreach函数的返回值。
1485 
1486 
1487 
1488 因此，<var>最好是一个变量名，<list>能够是一个表达式，而<text>中通常会使用<var>这个参数来依次枚举<list>中的单词。举个例子：
1489 
1490 
1491 
1492 names := a b c d
1493 
1494 files := $(foreach n,$(names),$(n).o)
1495 
1496 
1497 
1498 上面的例子中，$(name)中的单词会被挨个取出，并存到变量“n”中，“$(n).o”每次根据“$(n)”计算出一个值，这些值以空格分隔，最后做为foreach函数的返回，因此，$(files)的值是“a.o b.o c.o d.o”。
1499 
1500 
1501 
1502 注意，foreach中的<var>参数是一个临时的局部变量，foreach函数执行完后，参数<var>的变量将不在做用，其做用域只在foreach函数当中。
1503 
1504 
1505 
1506 
1507 
1508 5、if 函数
1509 
1510 
1511 if函数很像GNU的make所支持的条件语句——ifeq（参见前面所述的章节），if函数的语法是：
1512 
1513 
1514 
1515 $(if <condition>,<then-part> )
1516 
1517 
1518 
1519 或是
1520 
1521 
1522 
1523 $(if <condition>,<then-part>,<else-part> )
1524 
1525 
1526 
1527 可见，if函数能够包含“else”部分，或是不含。即if函数的参数能够是两个，也能够是三个。<condition>参数是if的表达式，若是其返回的为非空字符串，那么这个表达式就至关于返回真，因而，<then-part>会被计算，不然<else-part>会被计算。
1528 
1529 
1530 
1531 而if函数的返回值是，若是<condition>为真（非空字符串），那个<then-part>会是整个函数的返回值，若是<condition>为假（空字符串），那么<else-part>会是整个函数的返回值，此时若是<else-part>没有被定义，那么，整个函数返回空字串。
1532 
1533 
1534 
1535 因此，<then-part>和<else-part>只会有一个被计算。
1536 
1537 
1538 
1539 
1540 
1541 6、call函数
1542 
1543 
1544 call函数是惟一一个能够用来建立新的参数化的函数。你能够写一个很是复杂的表达式，这个表达式中，你能够定义许多参数，而后你能够用call函数来向这个表达式传递参数。其语法是：
1545 
1546 
1547 
1548 $(call <expression>,<parm1>,<parm2>,<parm3>...)
1549 
1550 
1551 
1552 当make执行这个函数时，<expression>参数中的变量，如$(1)，$(2)，$(3)等，会被参数<parm1>，<parm2>，<parm3>依次取代。而<expression>的返回值就是call函数的返回值。例如：
1553 
1554 reverse = $(1) $(2)
1555 
1556 foo = $(call reverse,a,b)
1557 
1558 
1559 
1560 那么，foo的值就是“a b”。固然，参数的次序是能够自定义的，不必定是顺序的，如：
1561 
1562 
1563 
1564 reverse = $(2) $(1)
1565 
1566 foo = $(call reverse,a,b)
1567 
1568 
1569 
1570 此时的foo的值就是“b a”。
1571 
1572 
1573 
1574 
1575 
1576 7、origin函数
1577 origin函数不像其它的函数，他并不操做变量的值，他只是告诉你你的这个变量是哪里来的？其语法是：
1578 
1579 
1580 
1581 $(origin <variable> )
1582 
1583 
1584 
1585 注意，<variable>是变量的名字，不该该是引用。因此你最好不要在<variable>中使用“$”字符。Origin函数会以其返回值来告诉你这个变量的“出生状况”，下面，是origin函数的返回值:
1586 
1587 
1588 
1589 “undefined”
1590 
1591 若是<variable>历来没有定义过，origin函数返回这个值“undefined”。
1592 
1593 
1594 
1595 “default”
1596 
1597 若是<variable>是一个默认的定义，好比“CC”这个变量，这种变量咱们将在后面讲述。
1598 
1599 
1600 
1601 “environment”
1602 
1603 若是<variable>是一个环境变量，而且当Makefile被执行时，“-e”参数没有被打开。
1604 
1605 
1606 
1607 “file”
1608 
1609 若是<variable>这个变量被定义在Makefile中。
1610 
1611 
1612 
1613 “command line”
1614 
1615 若是<variable>这个变量是被命令行定义的。
1616 
1617 
1618 
1619 “override”
1620 
1621 若是<variable>是被override指示符从新定义的。
1622 
1623 
1624 
1625 “automatic”
1626 
1627 若是<variable>是一个命令运行中的自动化变量。关于自动化变量将在后面讲述。
1628 
1629 
1630 
1631 这些信息对于咱们编写Makefile是很是有用的，例如，假设咱们有一个Makefile其包了一个定义文件Make.def，在Make.def中定义了一个变量“bletch”，而咱们的环境中也有一个环境变量“bletch”，此时，咱们想判断一下，若是变量来源于环境，那么咱们就把之重定义了，若是来源于Make.def或是命令行等非环境的，那么咱们就不从新定义它。因而，在咱们的Makefile中，咱们能够这样写：
1632 
1633 
1634 
1635 ifdef bletch
1636 
1637 ifeq "$(origin bletch)" "environment"
1638 
1639 bletch = barf, gag, etc.
1640 
1641 endif
1642 
1643 endif
1644 
1645 
1646 
1647 固然，你也许会说，使用override关键字不就能够从新定义环境中的变量了吗？为何须要使用这样的步骤？是的，咱们用override是能够达到这样的效果，但是override过于粗暴，它同时会把从命令行定义的变量也覆盖了，而咱们只想从新定义环境传来的，而不想从新定义命令行传来的。
1648 
1649 
1650 
1651 
1652 
1653 8、shell函数
1654 
1655 
1656 shell函数也不像其它的函数。顾名思义，它的参数应该就是操做系统Shell的命令。它和反引号“`”是相同的功能。这就是说，shell函数把执行操做系统命令后的输出做为函数返回。因而，咱们能够用操做系统命令以及字符串处理命令awk，sed等等命令来生成一个变量，如：
1657 
1658 
1659 
1660 contents := $(shell cat foo)
1661 
1662 
1663 
1664 files := $(shell echo *.c)
1665 
1666 
1667 
1668 注意，这个函数会新生成一个Shell程序来执行命令，因此你要注意其运行性能，若是你的Makefile中有一些比较复杂的规则，并大量使用了这个函数，那么对于你的系统性能是有害的。特别是Makefile的隐晦的规则可能会让你的shell函数执行的次数比你想像的多得多。
1669 
1670 
1671 
1672 
1673 
1674 9、控制make的函数
1675 
1676 
1677 make提供了一些函数来控制make的运行。一般，你须要检测一些运行Makefile时的运行时信息，而且根据这些信息来决定，你是让make继续执行，仍是中止。
1678 
1679 
1680 
1681 $(error <text ...> )
1682 
1683 
1684 
1685 产生一个致命的错误，<text ...>是错误信息。注意，error函数不会在一被使用就会产生错误信息，因此若是你把其定义在某个变量中，并在后续的脚本中使用这个变量，那么也是能够的。例如：
1686 
1687 
1688 
1689 示例一：
1690 
1691 ifdef ERROR_001
1692 
1693 $(error error is $(ERROR_001))
1694 
1695 endif
1696 
1697 
1698 
1699 示例二：
1700 
1701 ERR = $(error found an error!)
1702 
1703 .PHONY: err
1704 
1705 err: ; $(ERR)
1706 
1707 
1708 
1709 示例一会在变量ERROR_001定义了后执行时产生error调用，而示例二则在目录err被执行时才发生error调用。
1710 
1711 
1712 
1713 $(warning <text ...> )
1714 
1715 
1716 
1717 这个函数很像error函数，只是它并不会让make退出，只是输出一段警告信息，而make继续执行。
1718 
1719 make 的运行
1720 ——————
1721 
1722 通常来讲，最简单的就是直接在命令行下输入make命令，make命令会找当前目录的makefile来执行，一切都是自动的。但也有时你也许只想让make重编译某些文件，而不是整个工程，而又有的时候你有几套编译规则，你想在不一样的时候使用不一样的编译规则，等等。本章节就是讲述如何使用make命令的。
1723 
1724 1、make的退出码
1725 
1726 make命令执行后有三个退出码：
1727 
1728 0 —— 表示成功执行。
1729 1 —— 若是make运行时出现任何错误，其返回1。
1730 2 —— 若是你使用了make的“-q”选项，而且make使得一些目标不须要更新，那么返回2。
1731 
1732 Make的相关参数咱们会在后续章节中讲述。
1733 
1734 
1735 2、指定Makefile
1736 
1737 前面咱们说过，GNU make找寻默认的Makefile的规则是在当前目录下依次找三个文件——“GNUmakefile”、“makefile”和“Makefile”。其按顺序找这三个文件，一旦找到，就开始读取这个文件并执行。
1738 
1739 当前，咱们也能够给make命令指定一个特殊名字的Makefile。要达到这个功能，咱们要使用make的“-f”或是“--file”参数（“--makefile”参数也行）。例如，咱们有个makefile的名字是“hchen.mk”，那么，咱们能够这样来让make来执行这个文件：
1740 
1741 make –f hchen.mk
1742 
1743 若是在make的命令行是，你不仅一次地使用了“-f”参数，那么，全部指定的makefile将会被连在一块儿传递给make执行。
1744 
1745 
1746 3、指定目标
1747 
1748 通常来讲，make的最终目标是makefile中的第一个目标，而其它目标通常是由这个目标连带出来的。这是make的默认行为。固然，通常来讲，你的makefile中的第一个目标是由许多个目标组成，你能够指示make，让其完成你所指定的目标。要达到这一目的很简单，需在make命令后直接跟目标的名字就能够完成（如前面提到的“make clean”形式）
1749 
1750 任何在makefile中的目标均可以被指定成终极目标，可是除了以“-”打头，或是包含了“=”的目标，由于有这些字符的目标，会被解析成命令行参数或是变量。甚至没有被咱们明确写出来的目标也能够成为make的终极目标，也就是说，只要make能够找到其隐含规则推导规则，那么这个隐含目标一样能够被指定成终极目标。
1751 
1752 有一个make的环境变量叫“MAKECMDGOALS”，这个变量中会存放你所指定的终极目标的列表，若是在命令行上，你没有指定目标，那么，这个变量是空值。这个变量可让你使用在一些比较特殊的情形下。好比下面的例子：
1753 
1754 sources = foo.c bar.c
1755 ifneq ( $(MAKECMDGOALS),clean)
1756 include $(sources:.c=.d)
1757 endif
1758 
1759 基于上面的这个例子，只要咱们输入的命令不是“make clean”，那么makefile会自动包含“foo.d”和“bar.d”这两个makefile。
1760 
1761 使用指定终极目标的方法能够很方便地让咱们编译咱们的程序，例以下面这个例子：
1762 
1763 .PHONY: all
1764 all: prog1 prog2 prog3 prog4
1765 
1766 从这个例子中，咱们能够看到，这个makefile中有四个须要编译的程序——“prog1”， “prog2”， “prog3”和 “prog4”，咱们能够使用“make all”命令来编译全部的目标（若是把all置成第一个目标，那么只需执行“make”），咱们也能够使用“make prog2”来单独编译目标“prog2”。
1767 
1768 即然make能够指定全部makefile中的目标，那么也包括“伪目标”，因而咱们能够根据这种性质来让咱们的makefile根据指定的不一样的目标来完成不一样的事。在Unix世界中，软件发布时，特别是GNU这种开源软件的发布时，其makefile都包含了编译、安装、打包等功能。咱们能够参照这种规则来书写咱们的makefile中的目标。
1769 
1770 “all”
1771 这个伪目标是全部目标的目标，其功能通常是编译全部的目标。
1772 “clean”
1773 这个伪目标功能是删除全部被make建立的文件。
1774 “install”
1775 这个伪目标功能是安装已编译好的程序，其实就是把目标执行文件拷贝到指定的目标中去。
1776 “print”
1777 这个伪目标的功能是例出改变过的源文件。
1778 “tar”
1779 这个伪目标功能是把源程序打包备份。也就是一个tar文件。
1780 “dist”
1781 这个伪目标功能是建立一个压缩文件，通常是把tar文件压成Z文件。或是gz文件。
1782 “TAGS”
1783 这个伪目标功能是更新全部的目标，以备完整地重编译使用。
1784 “check”和“test”
1785 这两个伪目标通常用来测试makefile的流程。
1786 
1787 固然一个项目的makefile中也不必定要书写这样的目标，这些东西都是GNU的东西，可是我想，GNU搞出这些东西必定有其可取之处（等你的UNIX下的程序文件一多时你就会发现这些功能颇有用了），这里只不过是说明了，若是你要书写这种功能，最好使用这种名字命名你的目标，这样规范一些，规范的好处就是——不用解释，你们都明白。并且若是你的makefile中有这些功能，一是很实用，二是能够显得你的makefile很专业（不是那种初学者的做品）。
1788 
1789 
1790 4、检查规则
1791 
1792 有时候，咱们不想让咱们的makefile中的规则执行起来，咱们只想检查一下咱们的命令，或是执行的序列。因而咱们能够使用make命令的下述参数：
1793 
1794 “-n”
1795 “--just-print”
1796 “--dry-run”
1797 “--recon”
1798 不执行参数，这些参数只是打印命令，无论目标是否更新，把规则和连带规则下的命令打印出来，但不执行，这些参数对于咱们调试makefile颇有用处。
1799 
1800 “-t”
1801 “--touch”
1802 这个参数的意思就是把目标文件的时间更新，但不更改目标文件。也就是说，make伪装编译目标，但不是真正的编译目标，只是把目标变成已编译过的状态。
1803 
1804 “-q”
1805 “--question”
1806 这个参数的行为是找目标的意思，也就是说，若是目标存在，那么其什么也不会输出，固然也不会执行编译，若是目标不存在，其会打印出一条出错信息。
1807 
1808 “-W <file>”
1809 “--what-if=<file>”
1810 “--assume-new=<file>”
1811 “--new-file=<file>”
1812 这个参数须要指定一个文件。通常是是源文件（或依赖文件），Make会根据规则推导来运行依赖于这个文件的命令，通常来讲，能够和“-n”参数一同使用，来查看这个依赖文件所发生的规则命令。
1813 
1814 另一个颇有意思的用法是结合“-p”和“-v”来输出makefile被执行时的信息（这个将在后面讲述）。
1815 
1816 
1817 5、make的参数
1818 
1819 下面列举了全部GNU make 3.80版的参数定义。其它版本和产商的make大同小异，不过其它产商的make的具体参数仍是请参考各自的产品文档。
1820 
1821 “-b”
1822 “-m”
1823 这两个参数的做用是忽略和其它版本make的兼容性。
1824 
1825 “-B”
1826 “--always-make”
1827 认为全部的目标都须要更新（重编译）。
1828 
1829 “-C <dir>”
1830 “--directory=<dir>”
1831 指定读取makefile的目录。若是有多个“-C”参数，make的解释是后面的路径之前面的做为相对路径，并以最后的目录做为被指定目录。如：“make –C ~hchen/test –C prog”等价于“make –C ~hchen/test/prog”。
1832 
1833 “—debug[=<options>]”
1834 输出make的调试信息。它有几种不一样的级别可供选择，若是没有参数，那就是输出最简单的调试信息。下面是<options>的取值：
1835 a —— 也就是all，输出全部的调试信息。（会很是的多）
1836 b —— 也就是basic，只输出简单的调试信息。即输出不须要重编译的目标。
1837 v —— 也就是verbose，在b选项的级别之上。输出的信息包括哪一个makefile被解析，不须要被重编译的依赖文件（或是依赖目标）等。
1838 i —— 也就是implicit，输出因此的隐含规则。
1839 j —— 也就是jobs，输出执行规则中命令的详细信息，如命令的PID、返回码等。
1840 m —— 也就是makefile，输出make读取makefile，更新makefile，执行makefile的信息。
1841 
1842 “-d”
1843 至关于“--debug=a”。
1844 
1845 “-e”
1846 “--environment-overrides”
1847 指明环境变量的值覆盖makefile中定义的变量的值。
1848 
1849 “-f=<file>”
1850 “--file=<file>”
1851 “--makefile=<file>”
1852 指定须要执行的makefile。
1853 
1854 “-h”
1855 “--help”
1856 显示帮助信息。
1857 
1858 “-i”
1859 “--ignore-errors”
1860 在执行时忽略全部的错误。
1861 
1862 “-I <dir>”
1863 “--include-dir=<dir>”
1864 指定一个被包含makefile的搜索目标。能够使用多个“-I”参数来指定多个目录。
1865 
1866 “-j [<jobsnum>]”
1867 “--jobs[=<jobsnum>]”
1868 指同时运行命令的个数。若是没有这个参数，make运行命令时能运行多少就运行多少。若是有一个以上的“-j”参数，那么仅最后一个“-j”才是有效的。（注意这个参数在MS-DOS中是无用的）
1869 
1870 “-k”
1871 “--keep-going”
1872 出错也不中止运行。若是生成一个目标失败了，那么依赖于其上的目标就不会被执行了。
1873 
1874 “-l <load>”
1875 “--load-average[=<load]”
1876 “—max-load[=<load>]”
1877 指定make运行命令的负载。
1878 
1879 “-n”
1880 “--just-print”
1881 “--dry-run”
1882 “--recon”
1883 仅输出执行过程当中的命令序列，但并不执行。
1884 
1885 “-o <file>”
1886 “--old-file=<file>”
1887 “--assume-old=<file>”
1888 不从新生成的指定的<file>，即便这个目标的依赖文件新于它。
1889 
1890 “-p”
1891 “--print-data-base”
1892 输出makefile中的全部数据，包括全部的规则和变量。这个参数会让一个简单的makefile都会输出一堆信息。若是你只是想输出信息而不想执行makefile，你能够使用“make -qp”命令。若是你想查看执行makefile前的预设变量和规则，你能够使用“make –p –f /dev/null”。这个参数输出的信息会包含着你的makefile文件的文件名和行号，因此，用这个参数来调试你的makefile会是颇有用的，特别是当你的环境变量很复杂的时候。
1893 
1894 “-q”
1895 “--question”
1896 不运行命令，也不输出。仅仅是检查所指定的目标是否须要更新。若是是0则说明要更新，若是是2则说明有错误发生。
1897 
1898 “-r”
1899 “--no-builtin-rules”
1900 禁止make使用任何隐含规则。
1901 
1902 “-R”
1903 “--no-builtin-variabes”
1904 禁止make使用任何做用于变量上的隐含规则。
1905 
1906 “-s”
1907 “--silent”
1908 “--quiet”
1909 在命令运行时不输出命令的输出。
1910 
1911 “-S”
1912 “--no-keep-going”
1913 “--stop”
1914 取消“-k”选项的做用。由于有些时候，make的选项是从环境变量“MAKEFLAGS”中继承下来的。因此你能够在命令行中使用这个参数来让环境变量中的“-k”选项失效。
1915 
1916 “-t”
1917 “--touch”
1918 至关于UNIX的touch命令，只是把目标的修改日期变成最新的，也就是阻止生成目标的命令运行。
1919 
1920 “-v”
1921 “--version”
1922 输出make程序的版本、版权等关于make的信息。
1923 
1924 “-w”
1925 “--print-directory”
1926 输出运行makefile以前和以后的信息。这个参数对于跟踪嵌套式调用make时颇有用。
1927 
1928 “--no-print-directory”
1929 禁止“-w”选项。
1930 
1931 “-W <file>”
1932 “--what-if=<file>”
1933 “--new-file=<file>”
1934 “--assume-file=<file>”
1935 假定目标<file>须要更新，若是和“-n”选项使用，那么这个参数会输出该目标更新时的运行动做。若是没有“-n”那么就像运行UNIX的“touch”命令同样，使得<file>的修改时间为当前时间。
1936 
1937 “--warn-undefined-variables”
1938 只要make发现有未定义的变量，那么就输出警告信息。
1939 
1940 隐含规则
1941 ————
1942 
1943 在咱们使用Makefile时，有一些咱们会常用，并且使用频率很是高的东西，好比，咱们编译C/C++的源程序为中间目标文件（Unix下是[.o]文件，Windows下是[.obj]文件）。本章讲述的就是一些在Makefile中的“隐含的”，早先约定了的，不须要咱们再写出来的规则。
1944 
1945 “隐含规则”也就是一种惯例，make会按照这种“惯例”心照不喧地来运行，那怕咱们的Makefile中没有书写这样的规则。例如，把[.c]文件编译成[.o]文件这一规则，你根本就不用写出来，make会自动推导出这种规则，并生成咱们须要的[.o]文件。
1946 
1947 “隐含规则”会使用一些咱们系统变量，咱们能够改变这些系统变量的值来定制隐含规则的运行时的参数。如系统变量“CFLAGS”能够控制编译时的编译器参数。
1948 
1949 咱们还能够经过“模式规则”的方式写下本身的隐含规则。用“后缀规则”来定义隐含规则会有许多的限制。使用“模式规则”会更回得智能和清楚，但“后缀规则”能够用来保证咱们Makefile的兼容性。
1950 咱们了解了“隐含规则”，可让其为咱们更好的服务，也会让咱们知道一些“约定俗成”了的东西，而不至于使得咱们在运行Makefile时出现一些咱们以为莫名其妙的东西。固然，任何事物都是矛盾的，水能载舟，亦可覆舟，因此，有时候“隐含规则”也会给咱们形成不小的麻烦。只有了解了它，咱们才能更好地使用它。
1951 
1952 
1953 1、使用隐含规则
1954 
1955 若是要使用隐含规则生成你须要的目标，你所须要作的就是不要写出这个目标的规则。那么，make会试图去自动推导产生这个目标的规则和命令，若是make能够自动推导生成这个目标的规则和命令，那么这个行为就是隐含规则的自动推导。固然，隐含规则是make事先约定好的一些东西。例如，咱们有下面的一个Makefile：
1956 
1957 foo : foo.o bar.o
1958 cc –o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)
1959 
1960 咱们能够注意到，这个Makefile中并无写下如何生成foo.o和bar.o这两目标的规则和命令。由于make的“隐含规则”功能会自动为咱们自动去推导这两个目标的依赖目标和生成命令。
1961 
1962 make会在本身的“隐含规则”库中寻找能够用的规则，若是找到，那么就会使用。若是找不到，那么就会报错。在上面的那个例子中，make调用的隐含规则是，把[.o]的目标的依赖文件置成[.c]，并使用C的编译命令“cc –c $(CFLAGS) [.c]”来生成[.o]的目标。也就是说，咱们彻底没有必要写下下面的两条规则：
1963 
1964 foo.o : foo.c
1965 cc –c foo.c $(CFLAGS)
1966 bar.o : bar.c
1967 cc –c bar.c $(CFLAGS)
1968 
1969 由于，这已是“约定”好了的事了，make和咱们约定好了用C编译器“cc”生成[.o]文件的规则，这就是隐含规则。
1970 
1971 固然，若是咱们为[.o]文件书写了本身的规则，那么make就不会自动推导并调用隐含规则，它会按照咱们写好的规则忠实地执行。
1972 
1973 还有，在make的“隐含规则库”中，每一条隐含规则都在库中有其顺序，越靠前的则是越被常用的，因此，这会致使咱们有些时候即便咱们显示地指定了目标依赖，make也不会管。以下面这条规则（没有命令）：
1974 
1975 foo.o : foo.p
1976 
1977 依赖文件“foo.p”（Pascal程序的源文件）有可能变得没有意义。若是目录下存在了“foo.c”文件，那么咱们的隐含规则同样会生效，并会经过“foo.c”调用C的编译器生成foo.o文件。由于，在隐含规则中，Pascal的规则出如今C的规则以后，因此，make找到能够生成foo.o的C的规则就再也不寻找下一条规则了。若是你确实不但愿任何隐含规则推导，那么，你就不要只写出“依赖规则”，而不写命令。
1978 
1979 
1980 2、隐含规则一览
1981 
1982 这里咱们将讲述全部预先设置（也就是make内建）的隐含规则，若是咱们不明确地写下规则，那么，make就会在这些规则中寻找所须要规则和命令。固然，咱们也能够使用make的参数“-r”或“--no-builtin-rules”选项来取消全部的预设置的隐含规则。
1983 
1984 固然，即便是咱们指定了“-r”参数，某些隐含规则仍是会生效，由于有许多的隐含规则都是使用了“后缀规则”来定义的，因此，只要隐含规则中有“后缀列表”（也就一系统定义在目标.SUFFIXES的依赖目标），那么隐含规则就会生效。默认的后缀列表是：.out, .a, .ln, .o, .c, .cc, .C, .p, .f, .F, .r, .y, .l, .s, .S, .mod, .sym, .def, .h, .info, .dvi, .tex, .texinfo, .texi, .txinfo, .w, .ch .web, .sh, .elc, .el。具体的细节，咱们会在后面讲述。
1985 
1986 仍是先来看一看经常使用的隐含规则吧。
1987 
1988 一、编译C程序的隐含规则。
1989 “<n>.o”的目标的依赖目标会自动推导为“<n>.c”，而且其生成命令是“$(CC) –c $(CPPFLAGS) $(CFLAGS)”
1990 
1991 二、编译C++程序的隐含规则。
1992 “<n>.o”的目标的依赖目标会自动推导为“<n>.cc”或是“<n>.C”，而且其生成命令是“$(CXX) –c $(CPPFLAGS) $(CFLAGS)”。（建议使用“.cc”做为C++源文件的后缀，而不是“.C”）
1993 
1994 三、编译Pascal程序的隐含规则。
1995 “<n>.o”的目标的依赖目标会自动推导为“<n>.p”，而且其生成命令是“$(PC) –c $(PFLAGS)”。
1996 
1997 四、编译Fortran/Ratfor程序的隐含规则。
1998 “<n>.o”的目标的依赖目标会自动推导为“<n>.r”或“<n>.F”或“<n>.f”，而且其生成命令是:
1999 “.f” “$(FC) –c $(FFLAGS)”
2000 “.F” “$(FC) –c $(FFLAGS) $(CPPFLAGS)”
2001 “.f” “$(FC) –c $(FFLAGS) $(RFLAGS)”
2002 
2003 五、预处理Fortran/Ratfor程序的隐含规则。
2004 “<n>.f”的目标的依赖目标会自动推导为“<n>.r”或“<n>.F”。这个规则只是转换Ratfor或有预处理的Fortran程序到一个标准的Fortran程序。其使用的命令是：
2005 “.F” “$(FC) –F $(CPPFLAGS) $(FFLAGS)”
2006 “.r” “$(FC) –F $(FFLAGS) $(RFLAGS)”
2007 
2008 六、编译Modula-2程序的隐含规则。
2009 “<n>.sym”的目标的依赖目标会自动推导为“<n>.def”，而且其生成命令是：“$(M2C) $(M2FLAGS) $(DEFFLAGS)”。“<n.o>” 的目标的依赖目标会自动推导为“<n>.mod”，而且其生成命令是：“$(M2C) $(M2FLAGS) $(MODFLAGS)”。
2010 
2011 七、汇编和汇编预处理的隐含规则。
2012 “<n>.o” 的目标的依赖目标会自动推导为“<n>.s”，默认使用编译品“as”，而且其生成命令是：“$(AS) $(ASFLAGS)”。“<n>.s” 的目标的依赖目标会自动推导为“<n>.S”，默认使用C预编译器“cpp”，而且其生成命令是：“$(AS) $(ASFLAGS)”。
2013 
2014 八、连接Object文件的隐含规则。
2015 “<n>”目标依赖于“<n>.o”，经过运行C的编译器来运行连接程序生成（通常是“ld”），其生成命令是：“$(CC) $(LDFLAGS) <n>.o $(LOADLIBES) $(LDLIBS)”。这个规则对于只有一个源文件的工程有效，同时也对多个Object文件（由不一样的源文件生成）的也有效。例如以下规则：
2016 
2017 x : y.o z.o
2018 
2019 而且“x.c”、“y.c”和“z.c”都存在时，隐含规则将执行以下命令：
2020 
2021 cc -c x.c -o x.o
2022 cc -c y.c -o y.o
2023 cc -c z.c -o z.o
2024 cc x.o y.o z.o -o x
2025 rm -f x.o
2026 rm -f y.o
2027 rm -f z.o
2028 
2029 若是没有一个源文件（如上例中的x.c）和你的目标名字（如上例中的x）相关联，那么，你最好写出本身的生成规则，否则，隐含规则会报错的。
2030 
2031 九、Yacc C程序时的隐含规则。
2032 “<n>.c”的依赖文件被自动推导为“n.y”（Yacc生成的文件），其生成命令是：“$(YACC) $(YFALGS)”。（“Yacc”是一个语法分析器，关于其细节请查看相关资料）
2033 
2034 十、Lex C程序时的隐含规则。
2035 “<n>.c”的依赖文件被自动推导为“n.l”（Lex生成的文件），其生成命令是：“$(LEX) $(LFALGS)”。（关于“Lex”的细节请查看相关资料）
2036 
2037 十一、Lex Ratfor程序时的隐含规则。
2038 “<n>.r”的依赖文件被自动推导为“n.l”（Lex生成的文件），其生成命令是：“$(LEX) $(LFALGS)”。
2039 
2040 十二、从C程序、Yacc文件或Lex文件建立Lint库的隐含规则。
2041 “<n>.ln” （lint生成的文件）的依赖文件被自动推导为“n.c”，其生成命令是：“$(LINT) $(LINTFALGS) $(CPPFLAGS) -i”。对于“<n>.y”和“<n>.l”也是一样的规则。
2042 
2043 
2044 3、隐含规则使用的变量
2045 
2046 在隐含规则中的命令中，基本上都是使用了一些预先设置的变量。你能够在你的makefile中改变这些变量的值，或是在make的命令行中传入这些值，或是在你的环境变量中设置这些值，不管怎么样，只要设置了这些特定的变量，那么其就会对隐含规则起做用。固然，你也能够利用make的“-R”或“--no–builtin-variables”参数来取消你所定义的变量对隐含规则的做用。
2047 
2048 例如，第一条隐含规则——编译C程序的隐含规则的命令是“$(CC) –c $(CFLAGS) $(CPPFLAGS)”。Make默认的编译命令是“cc”，若是你把变量“$(CC)”重定义成“gcc”，把变量“$(CFLAGS)”重定义成“-g”，那么，隐含规则中的命令所有会以“gcc –c -g $(CPPFLAGS)”的样子来执行了。
2049 
2050 咱们能够把隐含规则中使用的变量分红两种：一种是命令相关的，如“CC”；一种是参数相的关，如“CFLAGS”。下面是全部隐含规则中会用到的变量：
2051 
2052 一、关于命令的变量。
2053 
2054 AR
2055 函数库打包程序。默认命令是“ar”。
2056 AS
2057 汇编语言编译程序。默认命令是“as”。
2058 CC
2059 C语言编译程序。默认命令是“cc”。
2060 CXX
2061 C++语言编译程序。默认命令是“g++”。
2062 CO
2063 从 RCS文件中扩展文件程序。默认命令是“co”。
2064 CPP
2065 C程序的预处理器（输出是标准输出设备）。默认命令是“$(CC) –E”。
2066 FC
2067 Fortran 和 Ratfor 的编译器和预处理程序。默认命令是“f77”。
2068 GET
2069 从SCCS文件中扩展文件的程序。默认命令是“get”。
2070 LEX
2071 Lex方法分析器程序（针对于C或Ratfor）。默认命令是“lex”。
2072 PC
2073 Pascal语言编译程序。默认命令是“pc”。
2074 YACC
2075 Yacc文法分析器（针对于C程序）。默认命令是“yacc”。
2076 YACCR
2077 Yacc文法分析器（针对于Ratfor程序）。默认命令是“yacc –r”。
2078 MAKEINFO
2079 转换Texinfo源文件（.texi）到Info文件程序。默认命令是“makeinfo”。
2080 TEX
2081 从TeX源文件建立TeX DVI文件的程序。默认命令是“tex”。
2082 TEXI2DVI
2083 从Texinfo源文件建立军TeX DVI 文件的程序。默认命令是“texi2dvi”。
2084 WEAVE
2085 转换Web到TeX的程序。默认命令是“weave”。
2086 CWEAVE
2087 转换C Web 到 TeX的程序。默认命令是“cweave”。
2088 TANGLE
2089 转换Web到Pascal语言的程序。默认命令是“tangle”。
2090 CTANGLE
2091 转换C Web 到 C。默认命令是“ctangle”。
2092 RM
2093 删除文件命令。默认命令是“rm –f”。
2094 
2095 二、关于命令参数的变量
2096 
2097 下面的这些变量都是相关上面的命令的参数。若是没有指明其默认值，那么其默认值都是空。
2098 
2099 ARFLAGS
2100 函数库打包程序AR命令的参数。默认值是“rv”。
2101 ASFLAGS
2102 汇编语言编译器参数。（当明显地调用“.s”或“.S”文件时）。
2103 CFLAGS
2104 C语言编译器参数。
2105 CXXFLAGS
2106 C++语言编译器参数。
2107 COFLAGS
2108 RCS命令参数。
2109 CPPFLAGS
2110 C预处理器参数。（ C 和 Fortran 编译器也会用到）。
2111 FFLAGS
2112 Fortran语言编译器参数。
2113 GFLAGS
2114 SCCS “get”程序参数。
2115 LDFLAGS
2116 连接器参数。（如：“ld”）
2117 LFLAGS
2118 Lex文法分析器参数。
2119 PFLAGS
2120 Pascal语言编译器参数。
2121 RFLAGS
2122 Ratfor 程序的Fortran 编译器参数。
2123 YFLAGS
2124 Yacc文法分析器参数。
2125 
2126 
2127 4、隐含规则链
2128 
2129 有些时候，一个目标可能被一系列的隐含规则所做用。例如，一个[.o]的文件生成，可能会是先被Yacc的[.y]文件先成[.c]，而后再被C的编译器生成。咱们把这一系列的隐含规则叫作“隐含规则链”。
2130 
2131 在上面的例子中，若是文件[.c]存在，那么就直接调用C的编译器的隐含规则，若是没有[.c]文件，但有一个[.y]文件，那么Yacc的隐含规则会被调用，生成[.c]文件，而后，再调用C编译的隐含规则最终由[.c]生成[.o]文件，达到目标。
2132 
2133 咱们把这种[.c]的文件（或是目标），叫作中间目标。无论怎么样，make会努力自动推导生成目标的一切方法，无论中间目标有多少，其都会执着地把全部的隐含规则和你书写的规则所有合起来分析，努力达到目标，因此，有些时候，可能会让你以为奇怪，怎么个人目标会这样生成？怎么个人makefile发疯了？
2134 
2135 在默认状况下，对于中间目标，它和通常的目标有两个地方所不一样：第一个不一样是除非中间的目标不存在，才会引起中间规则。第二个不一样的是，只要目标成功产生，那么，产生最终目标过程当中，所产生的中间目标文件会被以“rm -f”删除。
2136 
2137 一般，一个被makefile指定成目标或是依赖目标的文件不能被看成中介。然而，你能够明显地说明一个文件或是目标是中介目标，你能够使用伪目标“.INTERMEDIATE”来强制声明。（如：.INTERMEDIATE ： mid ）
2138 
2139 你也能够阻止make自动删除中间目标，要作到这一点，你能够使用伪目标“.SECONDARY”来强制声明（如：.SECONDARY : sec）。你还能够把你的目标，以模式的方式来指定（如：%.o）成伪目标“.PRECIOUS”的依赖目标，以保存被隐含规则所生成的中间文件。
2140 
2141 在“隐含规则链”中，禁止同一个目标出现两次或两次以上，这样一来，就可防止在make自动推导时出现无限递归的状况。
2142 
2143 Make会优化一些特殊的隐含规则，而不生成中间文件。如，从文件“foo.c”生成目标程序“foo”，按道理，make会编译生成中间文件“foo.o”，而后连接成“foo”，但在实际状况下，这一动做能够被一条“cc”的命令完成（cc –o foo foo.c），因而优化过的规则就不会生成中间文件。
2144 
2145 
2146 
2147 5、定义模式规则
2148 
2149 你能够使用模式规则来定义一个隐含规则。一个模式规则就好像一个通常的规则，只是在规则中，目标的定义须要有"%"字符。"%"的意思是表示一个或多个任意字符。在依赖目标中一样能够使用"%"，只是依赖目标中的"%"的取值，取决于其目标。
2150 
2151 有一点须要注意的是，"%"的展开发生在变量和函数的展开以后，变量和函数的展开发生在make载入Makefile时，而模式规则中的"%"则发生在运行时。
2152 
2153 
2154 一、模式规则介绍
2155 
2156 模式规则中，至少在规则的目标定义中要包含"%"，不然，就是通常的规则。目标中的"%"定义表示对文件名的匹配，"%"表示长度任意的非空字符串。例如："%.c"表示以".c"结尾的文件名（文件名的长度至少为3），而"s.%.c"则表示以"s."开头，".c"结尾的文件名（文件名的长度至少为5）。
2157 
2158 若是"%"定义在目标中，那么，目标中的"%"的值决定了依赖目标中的"%"的值，也就是说，目标中的模式的"%"决定了依赖目标中"%"的样子。例若有一个模式规则以下：
2159 
2160 %.o : %.c ; <command ......>
2161 
2162 其含义是，指出了怎么从全部的[.c]文件生成相应的[.o]文件的规则。若是要生成的目标是"a.o b.o"，那么"%c"就是"a.c b.c"。
2163 
2164 一旦依赖目标中的"%"模式被肯定，那么，make会被要求去匹配当前目录下全部的文件名，一旦找到，make就会规则下的命令，因此，在模式规则中，目标可能会是多个的，若是有模式匹配出多个目标，make就会产生全部的模式目标，此时，make关心的是依赖的文件名和生成目标的命令这两件事。
2165 
2166 
2167 二、模式规则示例
2168 
2169 下面这个例子表示了,把全部的[.c]文件都编译成[.o]文件.
2170 
2171 %.o : %.c
2172 $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@
2173 
2174 其中，"$@"表示全部的目标的挨个值，"$<"表示了全部依赖目标的挨个值。这些奇怪的变量咱们叫"自动化变量"，后面会详细讲述。
2175 
2176 下面的这个例子中有两个目标是模式的：
2177 
2178 %.tab.c %.tab.h: %.y
2179 bison -d $<
2180 
2181 这条规则告诉make把全部的[.y]文件都以"bison -d <n>.y"执行，而后生成"<n>.tab.c"和"<n>.tab.h"文件。（其中，"<n>"表示一个任意字符串）。若是咱们的执行程序"foo"依赖于文件"parse.tab.o"和"scan.o"，而且文件"scan.o"依赖于文件"parse.tab.h"，若是"parse.y"文件被更新了，那么根据上述的规则，"bison -d parse.y"就会被执行一次，因而，"parse.tab.o"和"scan.o"的依赖文件就齐了。（假设，"parse.tab.o"由"parse.tab.c"生成，和"scan.o"由"scan.c"生成，而"foo"由"parse.tab.o"和"scan.o"连接生成，并且foo和其[.o]文件的依赖关系也写好，那么，全部的目标都会获得知足）
2182 
2183 
2184 三、自动化变量
2185 
2186 在上述的模式规则中，目标和依赖文件都是一系例的文件，那么咱们如何书写一个命令来完成从不一样的依赖文件生成相应的目标？由于在每一次的对模式规则的解析时，都会是不一样的目标和依赖文件。
2187 
2188 自动化变量就是完成这个功能的。在前面，咱们已经对自动化变量有所提涉，相信你看到这里已对它有一个感性认识了。所谓自动化变量，就是这种变量会把模式中所定义的一系列的文件自动地挨个取出，直至全部的符合模式的文件都取完了。这种自动化变量只应出如今规则的命令中。
2189 
2190 下面是全部的自动化变量及其说明：
2191 
2192 $@
2193 表示规则中的目标文件集。在模式规则中，若是有多个目标，那么，"$@"就是匹配于目标中模式定义的集合。
2194 
2195 $%
2196 仅当目标是函数库文件中，表示规则中的目标成员名。例如，若是一个目标是"foo.a(bar.o)"，那么，"$%"就是"bar.o"，"$@"就是"foo.a"。若是目标不是函数库文件（Unix下是[.a]，Windows下是[.lib]），那么，其值为空。
2197 
2198 $<
2199 依赖目标中的第一个目标名字。若是依赖目标是以模式（即"%"）定义的，那么"$<"将是符合模式的一系列的文件集。注意，其是一个一个取出来的。
2200 
2201 $?
2202 全部比目标新的依赖目标的集合。以空格分隔。
2203 
2204 $^
2205 全部的依赖目标的集合。以空格分隔。若是在依赖目标中有多个重复的，那个这个变量会去除重复的依赖目标，只保留一份。
2206 
2207 $+
2208 这个变量很像"$^"，也是全部依赖目标的集合。只是它不去除重复的依赖目标。
2209 
2210 $*
2211 这个变量表示目标模式中"%"及其以前的部分。若是目标是"dir/a.foo.b"，而且目标的模式是"a.%.b"，那么，"$*"的值就是"dir/a.foo"。这个变量对于构造有关联的文件名是比较有较。若是目标中没有模式的定义，那么"$*"也就不能被推导出，可是，若是目标文件的后缀是make所识别的，那么"$*"就是除了后缀的那一部分。例如：若是目标是"foo.c"，由于".c"是make所能识别的后缀名，因此，"$*"的值就是"foo"。这个特性是GNU make的，颇有可能不兼容于其它版本的make，因此，你应该尽可能避免使用"$*"，除非是在隐含规则或是静态模式中。若是目标中的后缀是make所不能识别的，那么"$*"就是空值。
2212 
2213 当你但愿只对更新过的依赖文件进行操做时，"$?"在显式规则中颇有用，例如，假设有一个函数库文件叫"lib"，其由其它几个object文件更新。那么把object文件打包的比较有效率的Makefile规则是：
2214 
2215 lib : foo.o bar.o lose.o win.o
2216 ar r lib $?
2217 
2218 在上述所列出来的自动量变量中。四个变量（$@、$<、$%、$*）在扩展时只会有一个文件，而另三个的值是一个文件列表。这七个自动化变量还能够取得文件的目录名或是在当前目录下的符合模式的文件名，只须要搭配上"D"或"F"字样。这是GNU make中老版本的特性，在新版本中，咱们使用函数"dir"或"notdir"就能够作到了。"D"的含义就是Directory，就是目录，"F"的含义就是File，就是文件。
2219 
2220 下面是对于上面的七个变量分别加上"D"或是"F"的含义：
2221 
2222 $(@D)
2223 表示"$@"的目录部分（不以斜杠做为结尾），若是"$@"值是"dir/foo.o"，那么"$(@D)"就是"dir"，而若是"$@"中没有包含斜杠的话，其值就是"."（当前目录）。
2224 
2225 $(@F)
2226 表示"$@"的文件部分，若是"$@"值是"dir/foo.o"，那么"$(@F)"就是"foo.o"，"$(@F)"至关于函数"$(notdir $@)"。
2227 
2228 "$(*D)"
2229 "$(*F)"
2230 和上面所述的同理，也是取文件的目录部分和文件部分。对于上面的那个例子，"$(*D)"返回"dir"，而"$(*F)"返回"foo"
2231 
2232 "$(%D)"
2233 "$(%F)"
2234 分别表示了函数包文件成员的目录部分和文件部分。这对于形同"archive(member)"形式的目标中的"member"中包含了不一样的目录颇有用。
2235 
2236 "$(<D)"
2237 "$(<F)"
2238 分别表示依赖文件的目录部分和文件部分。
2239 
2240 "$(^D)"
2241 "$(^F)"
2242 分别表示全部依赖文件的目录部分和文件部分。（无相同的）
2243 
2244 "$(+D)"
2245 "$(+F)"
2246 分别表示全部依赖文件的目录部分和文件部分。（能够有相同的）
2247 
2248 "$(?D)"
2249 "$(?F)"
2250 分别表示被更新的依赖文件的目录部分和文件部分。
2251 
2252 最后想提醒一下的是，对于"$<"，为了不产生没必要要的麻烦，咱们最好给$后面的那个特定字符都加上圆括号，好比，"$(< )"就要比"$<"要好一些。
2253 
2254 还得要注意的是，这些变量只使用在规则的命令中，并且通常都是"显式规则"和"静态模式规则"（参见前面"书写规则"一章）。其在隐含规则中并无意义。
2255 
2256 四、模式的匹配
2257 
2258 通常来讲，一个目标的模式有一个有前缀或是后缀的"%"，或是没有先后缀，直接就是一个"%"。由于"%"表明一个或多个字符，因此在定义好了的模式中，咱们把"%"所匹配的内容叫作"茎"，例如"%.c"所匹配的文件"test.c"中"test"就是"茎"。由于在目标和依赖目标中同时有"%"时，依赖目标的"茎"会传给目标，当作目标中的"茎"。
2259 
2260 当一个模式匹配包含有斜杠（实际也不常常包含）的文件时，那么在进行模式匹配时，目录部分会首先被移开，而后进行匹配，成功后，再把目录加回去。在进行"茎"的传递时，咱们须要知道这个步骤。例若有一个模式"e%t"，文件"src/eat"匹配于该模式，因而"src/a"就是其"茎"，若是这个模式定义在依赖目标中，而被依赖于这个模式的目标中又有个模式"c%r"，那么，目标就是"src/car"。（"茎"被传递）
2261 
2262 
2263 五、重载内建隐含规则
2264 
2265 你能够重载内建的隐含规则（或是定义一个全新的），例如你能够从新构造和内建隐含规则不一样的命令，如：
2266 
2267 %.o : %.c
2268 $(CC) -c $(CPPFLAGS) $(CFLAGS) -D$(date)
2269 
2270 你能够取消内建的隐含规则，只要不在后面写命令就行。如：
2271 
2272 %.o : %.s
2273 
2274 一样，你也能够从新定义一个全新的隐含规则，其在隐含规则中的位置取决于你在哪里写下这个规则。朝前的位置就靠前。
2275 
2276 
2277 6、老式风格的"后缀规则"
2278 
2279 后缀规则是一个比较老式的定义隐含规则的方法。后缀规则会被模式规则逐步地取代。由于模式规则更强更清晰。为了和老版本的Makefile兼容，GNU make一样兼容于这些东西。后缀规则有两种方式："双后缀"和"单后缀"。
2280 
2281 双后缀规则定义了一对后缀：目标文件的后缀和依赖目标（源文件）的后缀。如".c.o"至关于"%o : %c"。单后缀规则只定义一个后缀，也就是源文件的后缀。如".c"至关于"% : %.c"。
2282 
2283 后缀规则中所定义的后缀应该是make所认识的，若是一个后缀是make所认识的，那么这个规则就是单后缀规则，而若是两个连在一块儿的后缀都被make所认识，那就是双后缀规则。例如：".c"和".o"都是make所知道。于是，若是你定义了一个规则是".c.o"那么其就是双后缀规则，意义就是".c"是源文件的后缀，".o"是目标文件的后缀。以下示例：
2284 
2285 .c.o:
2286 $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
2287 
2288 后缀规则不容许任何的依赖文件，若是有依赖文件的话，那就不是后缀规则，那些后缀通通被认为是文件名，如：
2289 
2290 .c.o: foo.h
2291 $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
2292 
2293 这个例子，就是说，文件".c.o"依赖于文件"foo.h"，而不是咱们想要的这样：
2294 
2295 %.o: %.c foo.h
2296 $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
2297 
2298 后缀规则中，若是没有命令，那是毫无心义的。由于他也不会移去内建的隐含规则。
2299 
2300 而要让make知道一些特定的后缀，咱们能够使用伪目标".SUFFIXES"来定义或是删除，如：
2301 
2302 .SUFFIXES: .hack .win
2303 
2304 把后缀.hack和.win加入后缀列表中的末尾。
2305 
2306 .SUFFIXES: # 删除默认的后缀
2307 .SUFFIXES: .c .o .h # 定义本身的后缀
2308 
2309 先清楚默认后缀，后定义本身的后缀列表。
2310 
2311 make的参数"-r"或"-no-builtin-rules"也会使用得默认的后缀列表为空。而变量"SUFFIXE"被用来定义默认的后缀列表，你能够用".SUFFIXES"来改变后缀列表，但请不要改变变量"SUFFIXE"的值。
2312 
2313 
2314 7、隐含规则搜索算法
2315 
2316 好比咱们有一个目标叫 T。下面是搜索目标T的规则的算法。请注意，在下面，咱们没有提到后缀规则，缘由是，全部的后缀规则在Makefile被载入内存时，会被转换成模式规则。若是目标是"archive(member)"的函数库文件模式，那么这个算法会被运行两次，第一次是找目标T，若是没有找到的话，那么进入第二次，第二次会把"member"看成T来搜索。
2317 
2318 一、把T的目录部分分离出来。叫D，而剩余部分叫N。（如：若是T是"src/foo.o"，那么，D就是"src/"，N就是"foo.o"）
2319 
2320 二、建立全部匹配于T或是N的模式规则列表。
2321 
2322 三、若是在模式规则列表中有匹配全部文件的模式，如"%"，那么从列表中移除其它的模式。
2323 
2324 四、移除列表中没有命令的规则。
2325 
2326 五、对于第一个在列表中的模式规则：
2327 1）推导其"茎"S，S应该是T或是N匹配于模式中"%"非空的部分。
2328 2）计算依赖文件。把依赖文件中的"%"都替换成"茎"S。若是目标模式中没有包含斜框字符，而把D加在第一个依赖文件的开头。
2329 3）测试是否全部的依赖文件都存在或是理当存在。（若是有一个文件被定义成另一个规则的目标文件，或者是一个显式规则的依赖文件，那么这个文件就叫"理当存在"）
2330 4）若是全部的依赖文件存在或是理当存在，或是就没有依赖文件。那么这条规则将被采用，退出该算法。
2331 
2332 六、若是通过第5步，没有模式规则被找到，那么就作更进一步的搜索。对于存在于列表中的第一个模式规则：
2333 1）若是规则是终止规则，那就忽略它，继续下一条模式规则。
2334 2）计算依赖文件。（同第5步）
2335 3）测试全部的依赖文件是否存在或是理当存在。
2336 4）对于不存在的依赖文件，递归调用这个算法查找他是否能够被隐含规则找到。
2337 5）若是全部的依赖文件存在或是理当存在，或是就根本没有依赖文件。那么这条规则被采用，退出该算法。
2338 
2339 七、若是没有隐含规则能够使用，查看".DEFAULT"规则，若是有，采用，把".DEFAULT"的命令给T使用。
2340 
2341 一旦规则被找到，就会执行其至关的命令，而此时，咱们的自动化变量的值才会生成。
2342 
2343 
2344 使用make更新函数库文件
2345 ———————————
2346 
2347 函数库文件也就是对Object文件（程序编译的中间文件）的打包文件。在Unix下，通常是由命令"ar"来完成打包工做。
2348 
2349 1、函数库文件的成员
2350 
2351 一个函数库文件由多个文件组成。你能够以以下格式指定函数库文件及其组成：
2352 
2353 archive(member)
2354 
2355 这个不是一个命令，而一个目标和依赖的定义。通常来讲，这种用法基本上就是为了"ar"命令来服务的。如：
2356 
2357 foolib(hack.o) : hack.o
2358 ar cr foolib hack.o
2359 
2360 若是要指定多个member，那就以空格分开，如：
2361 
2362 foolib(hack.o kludge.o)
2363 
2364 其等价于：
2365 
2366 foolib(hack.o) foolib(kludge.o)
2367 
2368 你还能够使用Shell的文件通配符来定义，如：
2369 
2370 foolib(*.o)
2371 
2372 
2373 2、函数库成员的隐含规则
2374 
2375 当make搜索一个目标的隐含规则时，一个特殊的特性是，若是这个目标是"a(m)"形式的，其会把目标变成"(m)"。因而，若是咱们的成员是"%.o"的模式定义，而且若是咱们使用"make foo.a(bar.o)"的形式调用Makefile时，隐含规则会去找"bar.o"的规则，若是没有定义bar.o的规则，那么内建隐含规则生效，make会去找bar.c文件来生成bar.o，若是找获得的话，make执行的命令大体以下：
2376 
2377 cc -c bar.c -o bar.o
2378 ar r foo.a bar.o
2379 rm -f bar.o
2380 
2381 还有一个变量要注意的是"$%"，这是专属函数库文件的自动化变量，有关其说明请参见"自动化变量"一节。
2382 
2383 
2384 3、函数库文件的后缀规则
2385 
2386 你能够使用"后缀规则"和"隐含规则"来生成函数库打包文件，如：
2387 
2388 .c.a:
2389 $(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o
2390 $(AR) r $@ $*.o
2391 $(RM) $*.o
2392 
2393 其等效于：
2394 
2395 (%.o) : %.c
2396 $(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o
2397 $(AR) r $@ $*.o
2398 $(RM) $*.o
2399 
2400 
2401 4、注意事项
2402 
2403 在进行函数库打包文件生成时，请当心使用make的并行机制（"-j"参数）。若是多个ar命令在同一时间运行在同一个函数库打包文件上，就颇有能够损坏这个函数库文件。因此，在make将来的版本中，应该提供一种机制来避免并行操做发生在函数打包文件上。
2404 
2405 但就目前而言，你仍是应该不要尽可能不要使用"-j"参数。
2406 
2407 
2408 
2409 后序
2410 ——
2411 
2412 终于到写结束语的时候了，以上基本上就是GNU make的Makefile的全部细节了。其它的产商的make基本上也就是这样的，不管什么样的make，都是以文件的依赖性为基础的，其基本是都是遵循一个标准的。这篇文档中80%的技术细节都适用于任何的make，我猜想"函数"那一章的内容可能不是其它make所支持的，而隐含规则方面，我想不一样的make会有不一样的实现，我没有精力来查看GNU的make和VC的nmake、BCB的make，或是别的UNIX下的make有些什么样的差异，一是时间精力不够，二是由于我基本上都是在Unix下使用make，之前在SCO Unix和IBM的AIX，如今在Linux、Solaris、HP-UX、AIX和Alpha下使用，Linux和Solaris下更多一点。不过，我能够确定的是，在Unix下的make，不管是哪一种平台，几乎都使用了Richard Stallman开发的make和cc/gcc的编译器，并且，基本上都是GNU的make（公司里全部的UNIX机器上都被装上了GNU的东西，因此，使用GNU的程序也就多了一些）。GNU的东西仍是很不错的，特别是使用得深了之后，愈来愈以为GNU的软件的强大，也愈来愈以为GNU的在操做系统中（主要是Unix，甚至Windows）"杀伤力"。
2413 
2414 对于上述全部的make的细节，咱们不但能够利用make这个工具来编译咱们的程序，还能够利用make来完成其它的工做，由于规则中的命令能够是任何Shell之下的命令，因此，在Unix下，你不必定只是使用程序语言的编译器，你还能够在Makefile中书写其它的命令，如：tar、awk、mail、sed、cvs、compress、ls、rm、yacc、rpm、ftp……等等，等等，来完成诸如"程序打包"、"程序备份"、"制做程序安装包"、"提交代码"、"使用程序模板"、"合并文件"等等五花八门的功能，文件操做，文件管理，编程开发设计，或是其它一些异想天开的东西。好比，之前在书写银行交易程序时，因为银行的交易程序基本同样，就见到有人书写了一些交易的通用程序模板，在该模板中把一些网络通信、数据库操做的、业务操做共性的东西写在一个文件中，在这些文件中用些诸如"@@@N、###N"奇怪字串标注一些位置，而后书写交易时，只需按照一种特定的规则书写特定的处理，最后在make时，使用awk和sed，把模板中的"@@@N、###N"等字串替代成特定的程序，造成C文件，而后再编译。这个动做很像数据库的"扩展C"语言（即在C语言中用"EXEC　SQL"的样子执行SQL语句，在用cc/gcc编译以前，须要使用"扩展C"的翻译程序，如cpre，把其翻译成标准C）。若是你在使用make时有一些更为绝妙的方法，请记得告诉我啊。
2415 
2416 回头看看整篇文档，不觉记起几年前刚刚开始在Unix下作开发的时候，有人问我会不会写Makefile时，我两眼发直，根本不知道在说什么。一开始看到别人在vi中写完程序后输入"!make"时，还觉得是vi的功能，后来才知道有一个Makefile在做怪，因而上网查啊查，那时又不肯意看英文，发现就根本没有中文的文档介绍Makefile，只得看别人写的Makefile，本身瞎碰瞎搞才积累了一点知识，但在不少地方彻底是知其然不知因此然。后来开始从事UNIX下产品软件的开发，看到一个400人年，近200万行代码的大工程，发现要编译这样一个庞然大物，若是没有Makefile，那会是多么恐怖的同样事啊。因而横下心来，狠命地读了一堆英文文档，才以为对其掌握了。但发现目前网上对Makefile介绍的文章仍是少得那么的可怜，因此想写这样一篇文章，共享给你们，但愿能对各位有所帮助。
2417 
2418 如今我终于写完了，看了看文件的建立时间，这篇技术文档也写了两个多月了。发现，本身知道是一回事，要写下来，跟别人讲述又是另一回事，并且，如今愈来愈没有时间专研技术细节，因此在写做时，发如今阐述一些细节问题时很难作到严谨和精练，并且对先讲什么后讲什么不是很清楚，因此，仍是参考了一些国外站点上的资料和题纲，以及一些技术书籍的语言风格，才得以完成。整篇文档的提纲是基于GNU的Makefile技术手册的提纲来书写的，并结合了本身的工做经验，以及本身的学习历程。由于历来没有写过这么长，这么细的文档，因此必定会有不少地方存在表达问题，语言歧义或是错误。因些，我迫切地得等待各位给我指证和建议，以及任何的反馈。
2419 
2420 最后，仍是利用这个后序，介绍一下本身。我目前从事于全部Unix平台下的软件研发，主要是作分布式计算/网格计算方面的系统产品软件，而且我对于下一代的计算机革命——网格计算很是地感兴趣，对于分布式计算、P2P、Web Service、J2EE技术方向也很感兴趣，同时，对于项目实施、团队管理、项目管理也小有心得，但愿一样和我战斗在“技术和管理并重”的阵线上的年轻一代，可以和我多多地交流。个人MSN是：haoel@hotmail.com（经常使用），QQ是：753640（不经常使用）。（注：请勿给我MSN的邮箱发信，因为hotmail的垃圾邮件致使我拒收这个邮箱的全部来信）
2421 
2422 我欢迎任何形式的交流，不管是讨论技术仍是管理，或是其它海阔天空的东西。除了政治和娱乐新闻我不关心，其它只要积极向上的东西我都欢迎！
2423 
2424 最最后，我还想介绍一下make程序的设计开发者。
2425 
2426 首当其冲的是： Richard Stallman
2427 
2428 开源软件的领袖和先驱，历来没有领过一天工资，历来没有使用过Windows操做系统。对于他的事迹和他的软件以及他的思想，我无需说过多的话，相信你们对这我的并不比我陌生，这是他的主页：http://www.stallman.org/ 。
2429 
2430 
2431 
2432 第二位是：Roland McGrath
2433 
2434 我的主页是：http://www.frob.com/~roland/ ，下面是他的一些事迹：
2435 
2436 1） 合做编写了并维护GNU make。
2437 
2438 2） 和Thomas Bushnell一同编写了GNU Hurd。
2439 
2440 3） 编写并维护着GNU C library。
2441 
2442 4） 合做编写并维护着部分的GNU Emacs。
2443 
2444 
2445 
2446 在此，向这两位开源项目的斗士致以最真切的敬意。
2447 
2448 
2449 （全文完）