lab/how-to-write-makefile
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix rst format

Browse Source
This commit is contained in:
Dongdong Tian
2015-11-09 11:41:27 +08:00
parent c21904a8ae
commit 956141d25f
6 changed files with 250 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
source/implicit_rules.rst
View File

@@ -1,11 +1,11 @@
隐含规则
========
在我们使用Makefile时，有一些我们会经常使用，而且使用频率非常高的东西，比如，我们编译C/C++的源程序为中间目标文件（Unix下是[.o]文件，Windows下是[.obj]文件）。本章讲述的就是一些在Makefile中的“隐含的”，早先约定了的，不需要我们再写出来的规则。
在我们使用Makefile时，有一些我们会经常使用，而且使用频率非常高的东西，比如，我们编译C/C++的源程序为中间目标文件（Unix下是 ``.o`` 文件，Windows下是 ``.obj`` 文件）。本章讲述的就是一些在Makefile中的“隐含的”，早先约定了的，不需要我们再写出来的规则。
“隐含规则”也就是一种惯例，make会按照这种“惯例”心照不喧地来运行，那怕我们的Makefile中没有书写这样的规则。例如，把[.c]文件编译成[.o]文件这一规则，你根本就不用写出来，make会自动推导出这种规则，并生成我们需要的[.o]文件。
“隐含规则”也就是一种惯例，make会按照这种“惯例”心照不喧地来运行，那怕我们的Makefile中没有书写这样的规则。例如，把 ``.c`` 文件编译成 ``.o`` 文件这一规则，你根本就不用写出来，make会自动推导出这种规则，并生成我们需要的 ``.o`` 文件。
“隐含规则”会使用一些我们系统变量，我们可以改变这些系统变量的值来定制隐含规则的运行时的参数。如系统变量“CFLAGS”可以控制编译时的编译器参数。
“隐含规则”会使用一些我们系统变量，我们可以改变这些系统变量的值来定制隐含规则的运行时的参数。如系统变量 ``CFLAGS`` 可以控制编译时的编译器参数。
我们还可以通过“模式规则”的方式写下自己的隐含规则。用“后缀规则”来定义隐含规则会有许多的限制。使用“模式规则”会更回得智能和清楚，但“后缀规则”可以用来保证我们Makefile的兼容性。
我们了解了“隐含规则”，可以让其为我们更好的服务，也会让我们知道一些“约定俗成”了的东西，而不至于使得我们在运行Makefile时出现一些我们觉得莫名其妙的东西。当然，任何事物都是矛盾的，水能载舟，亦可覆舟，所以，有时候“隐含规则”也会给我们造成不小的麻烦。只有了解了它，我们才能更好地使用它。
@@ -20,9 +20,9 @@
foo : foo.o bar.o
cc –o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)
我们可以注意到，这个Makefile中并没有写下如何生成foo.o和bar.o这两目标的规则和命令。因为make的“隐含规则”功能会自动为我们自动去推导这两个目标的依赖目标和生成命令。
我们可以注意到，这个Makefile中并没有写下如何生成 ``foo.o`` 和 ``bar.o`` 这两目标的规则和命令。因为make的“隐含规则”功能会自动为我们自动去推导这两个目标的依赖目标和生成命令。
make会在自己的“隐含规则”库中寻找可以用的规则，如果找到，那么就会使用。如果找不到，那么就会报错。在上面的那个例子中，make调用的隐含规则是，把[.o]的目标的依赖文件置成[.c]，并使用C的编译命令“cc –c $(CFLAGS) [.c]”来生成[.o]的目标。也就是说，我们完全没有必要写下下面的两条规则：
make会在自己的“隐含规则”库中寻找可以用的规则，如果找到，那么就会使用。如果找不到，那么就会报错。在上面的那个例子中，make调用的隐含规则是，把 ``.o`` 的目标的依赖文件置成 ``.c`` ，并使用C的编译命令 ``cc –c $(CFLAGS) foo.c`` 来生成 ``foo.o`` 的目标。也就是说，我们完全没有必要写下下面的两条规则：
.. code-block:: makefile
@@ -31,9 +31,9 @@ make会在自己的“隐含规则”库中寻找可以用的规则，如果找
bar.o : bar.c
cc –c bar.c $(CFLAGS)
因为，这已经是“约定”好了的事了，make和我们约定好了用C编译器“cc”生成[.o]文件的规则，这就是隐含规则。
因为，这已经是“约定”好了的事了，make和我们约定好了用C编译器 ``cc`` 生成 ``.o`` 文件的规则，这就是隐含规则。
当然，如果我们为[.o]文件书写了自己的规则，那么make就不会自动推导并调用隐含规则，它会按照我们写好的规则忠实地执行。
当然，如果我们为 ``.o`` 文件书写了自己的规则，那么make就不会自动推导并调用隐含规则，它会按照我们写好的规则忠实地执行。
还有，在make的“隐含规则库”中，每一条隐含规则都在库中有其顺序，越靠前的则是越被经常使用的，所以，这会导致我们有些时候即使我们显示地指定了目标依赖，make也不会管。如下面这条规则（没有命令）：
@@ -41,59 +41,59 @@ make会在自己的“隐含规则”库中寻找可以用的规则，如果找
foo.o : foo.p
依赖文件“foo.p”（Pascal程序的源文件）有可能变得没有意义。如果目录下存在了“foo.c”文件，那么我们的隐含规则一样会生效，并会通过“foo.c”调用C的编译器生成foo.o文件。因为，在隐含规则中，Pascal的规则出现在C的规则之后，所以，make找到可以生成 foo.o的C的规则就不再寻找下一条规则了。如果你确实不希望任何隐含规则推导，那么，你就不要只写出“依赖规则”，而不写命令。
依赖文件 ``foo.p`` （Pascal程序的源文件）有可能变得没有意义。如果目录下存在了 ``foo.c`` 文件，那么我们的隐含规则一样会生效，并会通过 ``foo.c`` 调用C的编译器生成 ``foo.o`` 文件。因为，在隐含规则中，Pascal的规则出现在C的规则之后，所以，make找到可以生成 ``foo.o`` 的C的规则就不再寻找下一条规则了。如果你确实不希望任何隐含规则推导，那么，你就不要只写出“依赖规则”，而不写命令。
隐含规则一览
------------
这里我们将讲述所有预先设置（也就是make内建）的隐含规则，如果我们不明确地写下规则，那么，make就会在这些规则中寻找所需要规则和命令。当然，我们也可以使用make的参数“-r”或“--no-builtin-rules”选项来取消所有的预设置的隐含规则。
这里我们将讲述所有预先设置（也就是make内建）的隐含规则，如果我们不明确地写下规则，那么，make就会在这些规则中寻找所需要规则和命令。当然，我们也可以使用make的参数 ``-r`` 或 ``--no-builtin-rules`` 选项来取消所有的预设置的隐含规则。
当然，即使是我们指定了“-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。具体的细节，我们会在后面讲述。
当然，即使是我们指定了 ``-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。具体的细节，我们会在后面讲述。
还是先来看一看常用的隐含规则吧。
#. 编译C程序的隐含规则。
“<n>.o”的目标的依赖目标会自动推导为“<n>.c”，并且其生成命令是“$(CC) –c $(CPPFLAGS) $(CFLAGS)”
``<n>.o`` 的目标的依赖目标会自动推导为 ``<n>.c`` ，并且其生成命令是 ``$(CC) –c $(CPPFLAGS) $(CFLAGS)``
#. 编译C++程序的隐含规则。
“<n>.o”的目标的依赖目标会自动推导为“<n>.cc”或是“<n>.C”，并且其生成命令是 “$(CXX) –c $(CPPFLAGS) $(CFLAGS)”。（建议使用“.cc”作为C++源文件的后缀，而不是“.C”）
``<n>.o`` 的目标的依赖目标会自动推导为 ``<n>.cc`` 或是 ``<n>.C`` ，并且其生成命令是 ``$(CXX) –c $(CPPFLAGS) $(CFLAGS)`` 。（建议使用 ``.cc`` 作为C++源文件的后缀，而不是 ``.C`` ）
#. 编译Pascal程序的隐含规则。
“<n>.o”的目标的依赖目标会自动推导为“<n>.p”，并且其生成命令是“$(PC) –c $(PFLAGS)”。
``<n>.o`` 的目标的依赖目标会自动推导为 ``<n>.p`` ，并且其生成命令是 ``$(PC) –c $(PFLAGS)`` 。
#. 编译Fortran/Ratfor程序的隐含规则。
“<n>.o”的目标的依赖目标会自动推导为“<n>.r”或“<n>.F”或“<n>.f”，并且其生成命令是:
``<n>.o`` 的目标的依赖目标会自动推导为 ``<n>.r`` 或 ``<n>.F`` 或 ``<n>.f`` ，并且其生成命令是:
- “.f” “$(FC) –c $(FFLAGS)”
- “.F” “$(FC) –c $(FFLAGS) $(CPPFLAGS)”
- “.f” “$(FC) –c $(FFLAGS) $(RFLAGS)”
- ``.f`` ``$(FC) –c $(FFLAGS)``
- ``.F`` ``$(FC) –c $(FFLAGS) $(CPPFLAGS)``
- ``.f`` ``$(FC) –c $(FFLAGS) $(RFLAGS)``
#. 预处理Fortran/Ratfor程序的隐含规则。
“<n>.f”的目标的依赖目标会自动推导为“<n>.r”或“<n>.F”。这个规则只是转换Ratfor或有预处理的Fortran程序到一个标准的Fortran程序。其使用的命令是：
``<n>.f`` 的目标的依赖目标会自动推导为 ``<n>.r`` 或 ``<n>.F`` 。这个规则只是转换Ratfor或有预处理的Fortran程序到一个标准的Fortran程序。其使用的命令是：
- “.F” “$(FC) –F $(CPPFLAGS) $(FFLAGS)”
- “.r” “$(FC) –F $(FFLAGS) $(RFLAGS)”
- ``.F`` ``$(FC) –F $(CPPFLAGS) $(FFLAGS)``
- ``.r`` ``$(FC) –F $(FFLAGS) $(RFLAGS)``
#. 编译Modula-2程序的隐含规则。
“<n>.sym”的目标的依赖目标会自动推导为“<n>.def”，并且其生成命令是：“$(M2C) $ (M2FLAGS) $(DEFFLAGS)”。“<n>.o” 的目标的依赖目标会自动推导为“<n>.mod”，并且其生成命令是：“$(M2C) $(M2FLAGS) $(MODFLAGS)”。
``<n>.sym`` 的目标的依赖目标会自动推导为 ``<n>.def`` ，并且其生成命令是： ``$(M2C) $(M2FLAGS) $(DEFFLAGS)`` 。 ``<n>.o`` 的目标的依赖目标会自动推导为 ``<n>.mod`` ，并且其生成命令是： ``$(M2C) $(M2FLAGS) $(MODFLAGS)`` 。
#. 汇编和汇编预处理的隐含规则。
“<n>.o” 的目标的依赖目标会自动推导为“<n>.s”，默认使用编译品“as”，并且其生成命令是：“$ (AS) $(ASFLAGS)”。“<n>.s” 的目标的依赖目标会自动推导为“<n>.S”，默认使用C预编译器 “cpp”，并且其生成命令是：“$(AS) $(ASFLAGS)”。
``<n>.o`` 的目标的依赖目标会自动推导为 ``<n>.s`` ，默认使用编译品 ``as`` ，并且其生成命令是： ``$ (AS) $(ASFLAGS)`` 。 ``<n>.s`` 的目标的依赖目标会自动推导为 ``<n>.S`` ，默认使用C预编译器 ``cpp`` ，并且其生成命令是： ``$(AS) $(ASFLAGS)`` 。
#. 链接Object文件的隐含规则。
“<n>”目标依赖于“<n>.o”，通过运行C的编译器来运行链接程序生成（一般是“ld”），其生成命令是： “$(CC) $(LDFLAGS) <n>.o $(LOADLIBES) $(LDLIBS)”。这个规则对于只有一个源文件的工程有效，同时也对多个Object文件（由不同的源文件生成）的也有效。例如如下规则::
``<n>`` 目标依赖于 ``<n>.o`` ，通过运行C的编译器来运行链接程序生成（一般是 ``ld`` ），其生成命令是： ``$(CC) $(LDFLAGS) <n>.o $(LOADLIBES) $(LDLIBS)`` 。这个规则对于只有一个源文件的工程有效，同时也对多个Object文件（由不同的源文件生成）的也有效。例如如下规则::
x : y.o z.o
并且“x.c”、“y.c”和“z.c”都存在时，隐含规则将执行如下命令::
并且 ``x.c`` 、 ``y.c`` 和 ``z.c`` 都存在时，隐含规则将执行如下命令::
cc -c x.c -o x.o
cc -c y.c -o y.o
@@ -107,40 +107,40 @@ make会在自己的“隐含规则”库中寻找可以用的规则，如果找
#. Yacc C程序时的隐含规则。
“<n>.c”的依赖文件被自动推导为“n.y”（Yacc生成的文件），其生成命令是：“$(YACC) $(YFALGS)”。（“Yacc”是一个语法分析器，关于其细节请查看相关资料）
``<n>.c`` 的依赖文件被自动推导为 ``n.y`` （Yacc生成的文件），其生成命令是： ``$(YACC) $(YFALGS)`` 。（“Yacc”是一个语法分析器，关于其细节请查看相关资料）
#. Lex C程序时的隐含规则。
“<n>.c”的依赖文件被自动推导为“n.l”（Lex生成的文件），其生成命令是：“$(LEX) $(LFALGS)”。（关于“Lex”的细节请查看相关资料）
``<n>.c`` 的依赖文件被自动推导为 ``n.l`` （Lex生成的文件），其生成命令是： ``$(LEX) $(LFALGS)`` 。（关于“Lex”的细节请查看相关资料）
#. Lex Ratfor程序时的隐含规则。
“<n>.r”的依赖文件被自动推导为“n.l”（Lex生成的文件），其生成命令是：“$(LEX) $(LFALGS)”。
``<n>.r`` 的依赖文件被自动推导为 ``n.l`` （Lex生成的文件），其生成命令是： ``$(LEX) $(LFALGS)`` 。
#. 从C程序、Yacc文件或Lex文件创建Lint库的隐含规则。
“<n>.ln” （lint生成的文件）的依赖文件被自动推导为“n.c”，其生成命令是：“$(LINT) $(LINTFALGS) $(CPPFLAGS) -i”。对于“<n>.y”和“<n>.l”也是同样的规则。
``<n>.ln`` （lint生成的文件）的依赖文件被自动推导为 ``n.c`` ，其生成命令是： ``$(LINT) $(LINTFALGS) $(CPPFLAGS) -i`` 。对于 ``<n>.y`` 和 ``<n>.l`` 也是同样的规则。
隐含规则使用的变量
------------------
在隐含规则中的命令中，基本上都是使用了一些预先设置的变量。你可以在你的makefile中改变这些变量的值，或是在make的命令行中传入这些值，或是在你的环境变量中设置这些值，无论怎么样，只要设置了这些特定的变量，那么其就会对隐含规则起作用。当然，你也可以利用make的“-R”或 “--no–builtin-variables”参数来取消你所定义的变量对隐含规则的作用。
在隐含规则中的命令中，基本上都是使用了一些预先设置的变量。你可以在你的makefile中改变这些变量的值，或是在make的命令行中传入这些值，或是在你的环境变量中设置这些值，无论怎么样，只要设置了这些特定的变量，那么其就会对隐含规则起作用。当然，你也可以利用make的 ``-R`` 或 ``--no–builtin-variables`` 参数来取消你所定义的变量对隐含规则的作用。
例如，第一条隐含规则——编译C程序的隐含规则的命令是“$(CC) –c $(CFLAGS) $(CPPFLAGS)”。Make默认的编译命令是“cc”，如果你把变量“$(CC)”重定义成“gcc”，把变量“$(CFLAGS)”重定义成“-g”，那么，隐含规则中的命令全部会以 “gcc –c -g $(CPPFLAGS)”的样子来执行了。
例如，第一条隐含规则——编译C程序的隐含规则的命令是 ``$(CC) –c $(CFLAGS) $(CPPFLAGS)`` 。Make默认的编译命令是 ``cc`` ，如果你把变量 ``$(CC)`` 重定义成 ``gcc`` ，把变量 ``$(CFLAGS)`` 重定义成 ``-g`` ，那么，隐含规则中的命令全部会以 ``gcc –c -g $(CPPFLAGS)`` 的样子来执行了。
我们可以把隐含规则中使用的变量分成两种：一种是命令相关的，如“CC”；一种是参数相的关，如“CFLAGS”。下面是所有隐含规则中会用到的变量：
我们可以把隐含规则中使用的变量分成两种：一种是命令相关的，如 ``CC`` ；一种是参数相的关，如 ``CFLAGS`` 。下面是所有隐含规则中会用到的变量：
关于命令的变量。
~~~~~~~~~~~~~~~~
- AR:函数库打包程序。默认命令是“ar”。
- AR:函数库打包程序。默认命令是“ar”。
- AS:汇编语言编译程序。默认命令是“as”。
- CC:C语言编译程序。默认命令是“cc”。
- CXX:C++语言编译程序。默认命令是“g++”。
- CO:从 RCS文件中扩展文件程序。默认命令是“co”。
- CPP:C程序的预处理器（输出是标准输出设备）。默认命令是“$(CC) –E”。
- FC:Fortran 和 Ratfor 的编译器和预处理程序。默认命令是“f77”。
- GET:从SCCS文件中扩展文件的程序。默认命令是“get”。
- GET:从SCCS文件中扩展文件的程序。默认命令是“get”。
- LEX:Lex方法分析器程序（针对于C或Ratfor）。默认命令是“lex”。
- PC:Pascal语言编译程序。默认命令是“pc”。
- YACC:Yacc文法分析器（针对于C程序）。默认命令是“yacc”。
@@ -160,10 +160,10 @@ make会在自己的“隐含规则”库中寻找可以用的规则，如果找
下面的这些变量都是相关上面的命令的参数。如果没有指明其默认值，那么其默认值都是空。
- ARFLAGS:函数库打包程序AR命令的参数。默认值是“rv”。
- ASFLAGS:汇编语言编译器参数。（当明显地调用“.s”或“.S”文件时）。
- ASFLAGS:汇编语言编译器参数。（当明显地调用“.s”或“.S”文件时）。
- CFLAGS:C语言编译器参数。
- CXXFLAGS:C++语言编译器参数。
- COFLAGS:RCS命令参数。
- COFLAGS:RCS命令参数。
- CPPFLAGS:C预处理器参数。（ C 和 Fortran 编译器也会用到）。
- FFLAGS:Fortran语言编译器参数。
- GFLAGS:SCCS “get”程序参数。
@@ -171,20 +171,20 @@ make会在自己的“隐含规则”库中寻找可以用的规则，如果找
- LFLAGS:Lex文法分析器参数。
- PFLAGS:Pascal语言编译器参数。
- RFLAGS:Ratfor 程序的Fortran 编译器参数。
- YFLAGS:Yacc文法分析器参数。
- YFLAGS:Yacc文法分析器参数。
隐含规则链
----------
有些时候，一个目标可能被一系列的隐含规则所作用。例如，一个[.o]的文件生成，可能会是先被Yacc的[.y]文件先成[.c]，然后再被C的编译器生成。我们把这一系列的隐含规则叫做“隐含规则链”。
有些时候，一个目标可能被一系列的隐含规则所作用。例如，一个 ``.o`` 的文件生成，可能会是先被Yacc的[.y]文件先成 ``.c`` ，然后再被C的编译器生成。我们把这一系列的隐含规则叫做“隐含规则链”。
在上面的例子中，如果文件[.c]存在，那么就直接调用C的编译器的隐含规则，如果没有[.c]文件，但有一个[.y]文件，那么Yacc的隐含规则会被调用，生成[.c]文件，然后，再调用C编译的隐含规则最终由[.c]生成[.o]文件，达到目标。
在上面的例子中，如果文件 ``.c`` 存在，那么就直接调用C的编译器的隐含规则，如果没有 ``.c`` 文件，但有一个[.y]文件，那么Yacc的隐含规则会被调用，生成 ``.c`` 文件，然后，再调用C编译的隐含规则最终由 ``.c`` 生成 ``.o`` 文件，达到目标。
我们把这种[.c]的文件（或是目标），叫做中间目标。不管怎么样，make会努力自动推导生成目标的一切方法，不管中间目标有多少，其都会执着地把所有的隐含规则和你书写的规则全部合起来分析，努力达到目标，所以，有些时候，可能会让你觉得奇怪，怎么我的目标会这样生成？怎么我的 makefile发疯了？
我们把这种 ``.c`` 的文件（或是目标），叫做中间目标。不管怎么样，make会努力自动推导生成目标的一切方法，不管中间目标有多少，其都会执着地把所有的隐含规则和你书写的规则全部合起来分析，努力达到目标，所以，有些时候，可能会让你觉得奇怪，怎么我的目标会这样生成？怎么我的 makefile发疯了？
在默认情况下，对于中间目标，它和一般的目标有两个地方所不同：第一个不同是除非中间的目标不存在，才会引发中间规则。第二个不同的是，只要目标成功产生，那么，产生最终目标过程中，所产生的中间目标文件会被以“rm -f”删除。
在默认情况下，对于中间目标，它和一般的目标有两个地方所不同：第一个不同是除非中间的目标不存在，才会引发中间规则。第二个不同的是，只要目标成功产生，那么，产生最终目标过程中，所产生的中间目标文件会被以 ``rm -f`` 删除。
通常，一个被makefile指定成目标或是依赖目标的文件不能被当作中介。然而，你可以明显地说明一个文件或是目标是中介目标，你可以使用伪目标“.INTERMEDIATE”来强制声明。（如：.INTERMEDIATE ： mid ）
通常，一个被makefile指定成目标或是依赖目标的文件不能被当作中介。然而，你可以明显地说明一个文件或是目标是中介目标，你可以使用伪目标 ``.INTERMEDIATE`` 来强制声明。（如：.INTERMEDIATE : mid ）
你也可以阻止make自动删除中间目标，要做到这一点，你可以使用伪目标“.SECONDARY”来强制声明（如：.SECONDARY : sec）。你还可以把你的目标，以模式的方式来指定（如：%.o）成伪目标“.PRECIOUS”的依赖目标，以保存被隐含规则所生成的中间文件。
@@ -210,14 +210,14 @@ Make会优化一些特殊的隐含规则，而不生成中间文件。如，从
%.o : %.c ; <command ......>;
其含义是，指出了怎么从所有的[.c]文件生成相应的[.o]文件的规则。如果要生成的目标是“a.o b.o”，那么“%c”就是“a.c b.c”。
其含义是，指出了怎么从所有的 ``.c`` 文件生成相应的 ``.o`` 文件的规则。如果要生成的目标是“a.o b.o”，那么“%c”就是“a.c b.c”。
一旦依赖目标中的“%”模式被确定，那么，make会被要求去匹配当前目录下所有的文件名，一旦找到，make就会规则下的命令，所以，在模式规则中，目标可能会是多个的，如果有模式匹配出多个目标，make就会产生所有的模式目标，此时，make关心的是依赖的文件名和生成目标的命令这两件事。
模式规则示例
~~~~~~~~~~~~
下面这个例子表示了,把所有的[.c]文件都编译成[.o]文件.
下面这个例子表示了,把所有的 ``.c`` 文件都编译成 ``.o`` 文件.
.. code-block:: makefile
@@ -233,7 +233,7 @@ Make会优化一些特殊的隐含规则，而不生成中间文件。如，从
%.tab.c %.tab.h: %.y
bison -d $<
这条规则告诉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]文件的依赖关系也写好，那么，所有的目标都会得到满足）
这条规则告诉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`` 文件的依赖关系也写好，那么，所有的目标都会得到满足）
自动化变量
~~~~~~~~~~
@@ -246,7 +246,7 @@ Make会优化一些特殊的隐含规则，而不生成中间文件。如，从
- $@: 表示规则中的目标文件集。在模式规则中，如果有多个目标，那么，“$@”就是匹配于目标中模式定义的集合。
- $%: 仅当目标是函数库文件中，表示规则中的目标成员名。例如，如果一个目标是“foo.a(bar.o)”，那么，“$%”就是“bar.o”，“$@”就是“foo.a”。如果目标不是函数库文件（Unix下是[.a]，Windows下是[.lib]），那么，其值为空。
- $<: 依赖目标中的第一个目标名字。如果依赖目标是以模式（即“%”）定义的，那么“$<”将是符合模式的一系列的文件集。注意，其是一个一个取出来的。
- $<: 依赖目标中的第一个目标名字。如果依赖目标是以模式（即“%”）定义的，那么“$<”将是符合模式的一系列的文件集。注意，其是一个一个取出来的。
- $?: 所有比目标新的依赖目标的集合。以空格分隔。
- $^:所有的依赖目标的集合。以空格分隔。如果在依赖目标中有多个重复的，那个这个变量会去除重复的依赖目标，只保留一份。
- $+:这个变量很像“$^”，也是所有依赖目标的集合。只是它不去除重复的依赖目标。
@@ -311,7 +311,7 @@ Make会优化一些特殊的隐含规则，而不生成中间文件。如，从
你可以取消内建的隐含规则，只要不在后面写命令就行。如：
.. code-block:: makefile
%.o : %.s
同样，你也可以重新定义一个全新的隐含规则，其在隐含规则中的位置取决于你在哪里写下这个规则。朝前的位置就靠前。
@@ -381,7 +381,7 @@ make的参数“-r”或“-no-builtin-rules”也会使用得默认的后缀列
#. 如果所有的依赖文件存在或是理当存在，或是就没有依赖文件。那么这条规则将被采用，退出该算法。
#. 如果经过第5步，没有模式规则被找到，那么就做更进一步的搜索。对于存在于列表中的第一个模式规则：
#. 如果规则是终止规则，那就忽略它，继续下一条模式规则。
#. 计算依赖文件。（同第5步）
#. 测试所有的依赖文件是否存在或是理当存在。