GNUMake简介.doc

GNU Make简介

　　Make 程序最初设计是为了维护C 程序文件防止不必要的重新编译。在使用命令行编译器的时候，修改了一个工程中的头文件，如何确保包含这个头文件的所有文件都得到编译？现在10 机的版本生成是使用批处理程序，编译那些文件依赖于程序的维护者，在模块之间相互引用头文件的情况下，要将所有需要重新编译的文件找出来是一件痛苦的事情；在找到这些文件之后，修改批处理进行编译。实际上这些工作可以让make 程序来自动完成，make 工具对于维护一些具有相互依赖关系的文件特别有用，它对文件和命令的联系（在文件改变时调用来更新其它文件的程序）提供一套编码方法。Make 工具的基本概念类似于Proglog语言，你告诉make 需要做什么，提供一些规则，make 来完成剩下的工作。

1 简介
　　make 工作自动确定工程的哪部分需要重新编译，执行命令去编译它们。虽然make多用于C 程序，然而只要提供命令行的编译器，你可以将其用于任何语言。实际上，make 工具的应用范围不仅于编程，你可以描述任和一些文件改变需要自动更新另一些文件的任务来使用它。

1.1 准备工作
　　如果要使用make，你必须写一个叫做“makefile”的文件，这个文件描述工程中文件之间的关系，提供更新每个文件的命令。典型的工程是这样的：可执行文件靠目标文件来更新，目标文件靠编译源文件来更新。

　　Makefile 写好之后，每次更改了源文件后，只要执行make 就足够了，所有必要的重新编译将执行。Make 程序利用makefile 中的数据库和文件的最后修改时间来确定那个文件需要更新；对于需要更新的文件，make 执行数据库中记录的命令。可以提供命令行参数给make 来控制那个文件需要重新编译。

1.2 Makefile 介绍
　　Makefile 文件告诉make 做什么，多数情况是怎样编译和链接一个程序。这里有一个简单的makefile，描述如何编译链接由8 个C 文件和3 个头文件组成的一个编辑器：
　　-----------------------------------------------------------------------------
　　edit : main.o kbd.o command.o display.o insert.o serach.o files.o utils.o
　　        cc -o edit main.o kbd.o command.o display.o insert.o search.o files.o utils.o

　　main.o : main.c defs.h
　　        cc -c main.c

　　kdb.o : kbd.c defs.h command.h
　　        cc -c kbd.c

　　command.o : command.c defs.h command.h
　　        cc -c command.c

　　display.o : display.c defs.h buffer.h
　　        cc -c display.c

　　insert.o : insert.c defs.h buffer.h
　　        cc -c insert.c

　　search.o : search.c defs.h buffer.h
　　        cc -c search.c

　　files.o : files.c defs.h buffer.h command.h
　　        cc -c files.c

　　utils.o : utils.c defs.h
　　        cc -c utils.c

　　clean :
　　rm edit main.o kbd.o command.o display.o insert.o search.o files.o utils.o
　　----------------------------------------------------------------------------

　　将长行用\分开便于阅读，这和使用一个长行的作用是一样的。使用这个makefile 创建可执行文件“edit”时运行make 就可以了；如果要将可执行文件和目标文件删除，执行make clean

　　make 重新编译这个编辑器时，每个更改的C 文件必须重新编译；如果头文件更改了，每个包含头文件的C 文件必须重新编译；每次编译产生一个对应于原文件的目标文件。最终，目标文件链接在一起产生新的可执行文件。

1.3 规则简介
　　makefile 中的规则是这样的：
　　TARGET... : DEPENDENCIES ...
　　        COMMAND
　　        ...

　　目标（TARGET）程序产生的文件，如可执行文件和目标文件；目标也可以是要执行的动作，如“clean”。
　　依赖（DEPENDENCIES）是用来产生目标的输入文件，一个目标通常依赖于多个文件。
　　命令（COMMAND）是make 执行的动作，一个可以有多个命令，每个占一行。
　　注意：每个命令行的起始字符必须为TAB 字符！

　　有依赖关系规则中的命令通常在依赖文件变化时负责产生target 文件，make 执行这些命令更新或产生target。规则可以没有依赖关系，如包含target “clean”的规则。

　　规则解释如何和何时重做该规则中的文件，make 根据依赖关系执行产生或更新目标；规则也说明如何和何时执行动作。有的规则看起来很复杂，但都符合上述模式。

1.4 make 工作原理

　　缺省make 从第一个target 开始（第一个非 "." 开始的target），这称作缺省目标。在上述的makefile 中，缺省目标是更新执行程序"edit"，将这个目标置于最前面。当执行make 的时候，make 程序从当前目录读入makefile 开始处理第一个规则；在例子中，这个规则是重新链接"edit"；在make 处理这个规则之前，必须处理"edit"所依赖的那些文件的规则，例子中是目标文件。这些文件按照他们自己的规则处理：通过编译源文件来更新每个".o"文件；当依赖关系中的源文件或头文件比目标文件新，或目标文件不存在时，必须重新编译。

　　其它的规则被处理是因为他们的target是目标的依赖，和目标没有依赖关系的规则不会被处理，除非指定make 处理（如make clean）。在重新编译目标文件之前，make 会试图更新它的依赖：源文件和头文件。例子中的makefile 对源文件和头文件未指定任何操作：".c"和".h"文件不是任何规则的目标。确认所有的目标文件都是最新的之后，make 决定是否重新链接"edit"：如果"edit"不存在，或者任何一个目标文件都比它新，则链接工作将进行。

　　这样，如果我们改变insert.c 运行make，make 会编译这个文件来更新"insert.o"，然后链接"edit"；如果修改了"command.h"运行make， "kbd.o"， "command.o"， "files.o"会重新生成，链接"edit"。

1.5 使用变量
　　在例子中，在规则"edit"中，目标文件被列出来两次：
　　edit : main.o kbd.o command.o display.o insert.o search.o files.o utils.o
　　cc -o edit main.o kbd.o command.o display.o insert.o search.o files.o utils.o
　　这样的重复容易出错：假设工程中加入了一个新的目标文件，可能只将其加入了一个列表中；通过使用变量可以消除这种风险：变量允许一个预定义的字符串在多个地方被替换。

　 在makefile 中，可以写这样一行来定义"object"变量：
　 objects = main.o kbd.o command.o display.o insert.o search.o files.o utils.o
　 于是在需要目标文件名列表的地方，使用$(object) 来代替变量的值。以下是使用了变量以后的makefile：
　 ----------------------------------------------------------------------------
　 objects = main.o kbd.o command.o display.o insert.o search.o files.o utils.o

　 edit : $(objects)
　         cc -o edit $(objects)

　 main.o : main.c defs.h
　         cc -c main.c

　 kbd.o : kbd.c defs.h command.h
　         cc -c kbd.c

　 command.o : command.c defs.h command.h
　         cc -c command.c

　 display.o : display.c defs.h buffer.h
　         cc -c display.c

　 insert.o : insert.c defs.h buffer.h
　         cc -c insert.c

　 search.o : search.c defs.h buffer.h
　         cc -c search.c

　 files.o : files.c defs.h buffer.h command.h
　         cc -c files.c

　 utils.o : utils.c defs.h
　         cc -c utils.c

　 clean :
　 rm edit $(objects)
　 --------------------------------------------------------------------------------

1.6 简化命令
　　为每个文件写出编译命令不是必要的，因为make 可以自己来做；以".c"文件更新".o"文件有一个隐含的规则，使用"cc -c"命令。Make 将利用"cc -c main.c -o main.o"来将main.c 编译为main.o，因此在生成目标文件的规则中，可以省略命令。

　　当".c"文件以这样的方式使用时，将自动加入到依赖关系中；由是在省略命令的前提下，可以将".c"文件从依赖关系中省略。以下是简化过的makefile：
　　--------------------------------------------------------------------------------
　　objects = main.o kbd.o command.o display.o insert.o search.o files.o utils.o

　　edit : $(objects)
　　        cc -o edit $(objects)

　　main.o : defs.h
　　kbd.o : defs.h command.h
　　command.o : defs.h command.h
　　display.o : defs.h buffer.h
　　insert.o : defs.h buffer.h
　　search.o : defs.h buffer.h
　　files.o : defs.h buffer.h command.h
　　utils.o : defs.h
　　.PHONY : clean
　　clean :
　　-rm edit $(objects)
　　---------------------------------------------------------------------------------

1.7 另一种风格
　　如果makefile 中的目标都是以隐含规则生成，可以将规则按照依赖关系分组：
　　----------------------------------------------------------------------------
　　objects = main.o kbd.o command.o display.o insert.o search.o files.o utils.o

　　edit : $(objects)
　　        cc -o edit $(objects)
　　$(objects) : defs.h
　　kbd.o command.o files.o : command.h
　　display.o insert.o search.o files.o : buffer.h
　　----------------------------------------------------------------------------

　　这里"defs.h"作为所有目标文件的依赖。这种风格是好是坏取决于个人喜好，它非常紧凑，但是将每个目标的依赖信息放在一起看起来更清楚一些。

1.8 清理
　　编写规则不至于编译程序。Makefile 通常描述如何做其它事情：比如删除目录中的目标文件和可执行文件来清理目录。例子中是这样写的：
　　clean:
        rm edit $(objects)
　　实际情况是，我们需要处理一些意外事件：存在一个叫做"clean"的文件；如果rm 出错，并不希望make 过程停止下来，修改过的版本如下：
　　.PHONY : clean
　　clean :
        rm edit $(objects)

　　这样的规则当然不能放在makefile 的开始，因为这并不是我们缺省要做的工作。由于"clean"并不是"edit"的依赖，在运行make 时没有参数时，这条规则不会执行；要执行这个规则，必须运行"make clean"。

Makefile
　 Makefile 中包含五种内容：显式规则，隐式规则，变量定义，指令（directive）和注释。

　 显式规则描述如何生成规则的目标，它列出了目标依赖的文件，指定了产生或更新目标的命令
　 隐式规则描述如何生成基于文件名的一类文件，说明目标可能依赖于和其文件名类似的文件，指定了相应的命令。
　 指令类似与编译器的伪指令，包含：指示make 读入另一个makefile;决定是否忽略makefile 中的一部分;定义一个变量;一行中‘#"开始是注释，直到行末，除非遇到续行符号。在"define"和命令中不能有注释，其它情况下注释可出现在任何地方。

2.1 makefile 名字
　 缺省情况下，make 以下列名字查找makefile："GNUmakefile"，"makefile" 和 "Makefile"（注意大小写）。通常你的makefile 应叫做"makefile"或"Makefile"。"GNUmakefile"不推荐，除非你的makefile 是为GNU 的make 定制的，其它的make 不认为该名字是一个makefile 的名字。如果你使用非标准命名的makefile，必须用命令开关"-f" 或 "-file"。参数 "-f NAME" 或 "--file NAME"告诉make 读入NAME 作为makefile。如果使用多个该开关，所有的文件将按顺序连接起来。如果使用该选项，标准的makefile 名字不会自动检测。

2.2 包含
　　"include"指令告诉make 暂停处理余下的内容，读入其它makefile。语法如下：
　　include FILENAMES
　　这一行起始可以有空格，但TAB 字符不允许。如果文件名包含变量或函数，这些将被扩展。

2.3‘MAKEFILE"变量
　　如果环境变量"MAKEFILE"已定义，make 认为它的值是一系列空格隔开的文件名，这些文件在处理其它makefile 前被make 程序读入。这类似于include 指令；这些文件中的目标不会影响缺省目标，而且如果文件未找到的话，make 并不认为是错误。这个变量的主要用途是递归引用make 程序时通讯。

2.4 如何重新生成makefile
　　有时候makefile 是从其它文件生成的，比如RCS 或SCCS 文件。如果makefile 是由其它文件生成的，需要make读入最新版本的makefile。
　　在读入所有makefile 之后，make 认为每个makefile 是一个目标，试图去更新它；如果makefile 中有一条如何更新它的规则，或者有适用的隐式规则，需要的更新会进行。所有的makefile 检查完之后，如果有的改变了，make 重新开始再读入（make 会试图再做更新，但通常不会再改变了，因为已经是最新的了）。

　　如果一个文件使用双冒号规则，提供了命令但没有依赖关系，文件始终会被更新。在makefile 的情况下，如果makefile 双冒号规则，提供了命令但没有依赖关系，这样makefile 始终会重新生成，这会导致循环：make 只是在不断更新makefile，却不干活。为避免这种情况，make 不会重新生成那些只有命令没有依赖关系的双冒号规则的makefile。

　　如果没有使用"-f"或"--file"选项，make 会尝试缺省的makefile 文件名。和指明"-f"或"--file"选项不同，make 不能确定这些文件是否应当存在。然而，如果缺省makefile 不存在但可以通过运行make 规则生成，你可能希望这些规则被运行使得makefile 可以使用。

　　因此，如果没有缺省makefile，make 试图按照makefile 名查找的顺序生成它，直到成功或名字用完。注意如果make 不能找到或生成makefile，这并不是错误；makefile 不总是必需的。

　　当使用"-t"或"--touch"选项时，不希望使用过时的makefile 来决定那个目标来touch。所以"-t"选项对makefile 更新不起作用；类似"-q"（or ‘-question"）和"-n"（or "-just-print"）不阻止makefile 的更新，因为过时的makefile 会产生错误的输出。这样"make -f mfile -n foo"会更新"mfile"，读入它，打印出更新"foo"需要执行的命令但不运行这些命令。与"foo"有关的命令是更新过的"mfile"中的内容。

　　但是有时不希望更新makefile，可以将makefile 作为命令行的目标，当makefile被显式指定为目标时，"-t"选项也适用于它们。
　　这样"make -f mfile -n mfile foo"会读入"mfile"，打印出更新执行的命令，"foo"的命令是当前的"mfile"中的内容。

2.5 重载makefile

　　可以使用"include"指令来包含其它makefile，增加目标的变量定义。然而，make 不允许同一个目标有不同的命令，有其它的途径可以达到目的。
　　假设有"makefile" 和"mfile"，"makfile"要包含"mfile"，但都有对于目标"foo"的规则。这是可以在"makefile"中写一条匹配任意模式的规则，指明当make 在"makefile"中未找到目标时，搜索"mfile"：
　　foo:
        frobnicate >; foo
　　%: force
　        @$(MAKE) -f mfile $@
　　force: ;

　　当执行"make foo"时，make 找到"makefile"，执行命令" frobnicate >; foo"；执行"make bar"时，在"makefile"中未找到相应的规则，这时模式规则适用，执行命令"make -f mfile bar"，"makefile"中未提及的其它目标也是类似的。

　　这种方法之所有工作是因为模式规则的模式是"%"，可以匹配任何的目标；这条规则的依赖是"force"，保证即使目标存在命令也会执行；"force"规则的命令为空防止"make"为其搜索隐式规则－这样会导致依赖循环。

3 规则
　　makefile 中的规则描述如何生成特定的文件，即规则的目标。规则列出了目标的依赖文件，指定生成或更新目标的命令。规则的次序是不重要的，除非是确定缺省目标：缺省目标是第一个makefile 中的第一个规则；如果第一个规则有多个目标，第一个目标是缺省的。有两个例外：以"."开头的目标不是缺省目标；模式规则对缺省目标没有影响。
　　通常我们所写的第一个规则是编译整个或makefile 中指定的所有程序。

3.1 例子
　　foo.o : foo.c defs.h　　　　　 # module for twiddling the frobs
        cc -c -g foo.c
　　它的目标是"foo.o"，依赖于"foo.c"和"defs.h"，有一个命令"cc -c -g foo.c"。命令行以TAB 字符开始标识它是一个命令。
这条规则说明两件事：如何决定"foo.o"是旧的：如果它不存在，或者"foo.c"或者"defs.h"比它新。如何更新"foo.o"文件：通过运行"cc"程序。命令未提及"defs.h"，但可以猜想"foo.c"包含了它，这是"defs.h"被置于依赖关系中的理由。

3.2 规则的语法
　 语法如下：
　 TARGETS : DEPENDENCIES
　         COMMAND
　         ...
　 或者
　 TARGETS : DEPENDENCIES ; COMMAND
　         COMMAND
　         ...

　 TARGETS 是以空格隔开的文件名，统配符可以使用。通常一个规则只有一个目标，偶尔也有多个。命令行以TAB 键开始。第一条命令可在依赖关系的下一行；或者在同一行，在分号后面；两种方式效果相同。

　 因为"$"符号被用做变量引用，如果要在规则中使用"$"符号，必须写两个："$$"。可以用"\"符号来分割一个长行，这不是必须的，因为make 对行的长度没有限制。

3.3 通配符
　　规则中的文件名可以包含统配符，如"*"，"?"。 文件名前的字符"~"有特殊的含义。单独使用，或跟随一个"/"，代表用户的
home 目录，比如"~/bin"扩展为/home/you/bin"；如果"~"跟随一个单词，表示单词指示的那个用户的home 目录，如"~john/bin"扩展为"/home/john/bin"。通配符在目标，依赖关系，命令中自动扩展，其它情况下，统配符的扩展除非显式使用"wildcard"函数。通配符的特殊意义可以使用"\"符号关闭。
　　例子：
　　clean:
　　rm -f *.o
　　和
　　print: *.c
　　lpr -p $?
　　touch print
　　通配符在定义变量时并不扩展，例如：objects = *.o 则objects 的值是字符串"*.o"；但是如果你将objects 用于目标，依赖或命令中，扩展会进行。要将objects 设置成扩展过的内容，使用：objects := $(wildcard *.o)

3.3.1 通配符的缺陷
　　这是一个使用通配符的例子，但结果不是你所期望的。假设可执行文件"foo" 是从当前目录中的所有".o"文件生成的：
　　objects = *.o
　　        foo : $(objects)
　　        cc -o foo $(CFLAGS) $(objects)
　　objects 变量的值是字符串"*.o"。通配符扩展在规则"foo"中进行，于是所有存在的".o"文件成为"foo"的依赖而且在需要时重新编译。
但如果删除了所有的".o"文件呢？当通配符不匹配任何文件时，一切都保持原样：则"foo"依赖于一个叫做"*.o"的文件；由于这个文件不大可能存在，"make"程序会报告一个无法生成"*.o"文件的错误，这不是期待的结果。实际上可以用通配符获得期望结果，但是需要复杂的技术，包括"wildcard"函数和字符串替换函数。

3.3.2wildcard 函数
　　通配符自动在规则中进行。但是在变量赋值的和函数的参数中通配符不会扩展，如果在这些情况下需要通配符扩展，必须使用"wildcard"函数。语法如下：$(wildcard PATTERN...)
　　这个在makefile 任何地方出现的字符串，会被匹配任何一个文件名格式的以空格隔开的现有文件列表替换。如果没有任何文件匹配一个模式，这个模式从"wildcard"的输出中忽略，注意，这和上述的通配符的处理是不一样的。"wildcard"函数的一个功能是找出目录中所有的".c"文件：$(wildcard *.c)，可以通过替换后缀".c"为".o"从C 文件列表得到目标文件的列表：
　　$(patsubst %.c,%.o,$(wildcard *.c))
　　这样，上节中的makefile 改写为：
　　objects := $(patsubst %.c,%.o,$(wildcard *.c))
　　foo : $(objects)
　　        cc -o foo $(objects)
　　这个makefile 利用了编译C 程序的隐含规则，所以不需要对编译写出显式的规则。（":="是"="的一个变体）
　　注意："ATTERN"是大小写敏感的。

3.4 目录搜索
　　对于大的系统，通常将源文件和目标文件放在不同的目录中。目录搜索功能可以让make 自动在多个目录中搜寻依赖文件，当你将文件重新分布是，不需要改变规则，更改搜索路径即可。

3.4.1‘VPATH"
　　make 变量"VPATH"列出make 应当搜索的目录列表。很多情况下，当前目录不包含依赖文件，"VPATH"描述一个对所有文件的搜索列表，包含那些是规则的目标的文件。如果一个目标或者依赖文件在当前目录没找到的话，"make"在"VPATH"中列出的目录中查找同名的文件。如果找到的话，那个文件成为依赖文件；规则可以象这些文件在当前目录中一样来使用他们。
　　"VPATH"变量中，目录名以冒号或空格隔开；目录列出的顺序决定make查找的顺序。（注：在pSOSystem 2.5 移植到Win32 的GNU make 目录名必须使用分号隔开，以下均简称Win32 GNU make）。举例说明：
　　VPATH = src:../headers 则规则
　　foo.o : foo.c
　　被解释为
　　foo.o : src/foo.c
　　假设"foo.c"在当前目录不存在，在"src"目录中可以找到。

3.4.2 选择性搜索
　　与"VPATH"变量相似但更具选择性的是"vpath"指令（注意是小写），可以指定对于符合特定模式文件的查找路径。这样可以为不同类型的文件指定不同的搜索路径。
　　"vpath"指令共有三中形式：
　　"vpath PATTERN DIRECTORIES"　为匹配PATTERN 的文件名指定搜索路径DIRECTORIES，目录的分隔和"VPATH"的相同
　　"vpath PATTERN" 清除为匹配PATTERN 的文件名指定的搜索路径
　　"vpath" 清除所有以前用"vpath"指定的搜索路径
　　"vpath"的模式是包含"%"的字符串：这个字符串必须匹配需要搜索的依赖文件名，"%"字符匹配0 个或多个任意字符。例如："%.h"匹配任何以".h"结尾的文件（如果没有%，则PATTERN 必须和依赖文件完全一致，这种用法不太多）。

　　 当前目录中不存在依赖文件时，如果"vpath"中的PATTERN 匹配依赖文件名，则指令中DIRECTORIES 列出的目录和"VPATH"中同样处理。举例：
　　 vpath %.h ../headers
　　 告诉make 在当前目录中未找到的".h"文件在../headers 目录中查找。如果多个"vapth"的模式匹配依赖文件名，make 将逐一处理，在所有指定的目录中搜索。Make 按照"vapth"在makefile 中的次序；来处理它们，多个相同模式的"vapth"是相互独立的。
　　 vpath %.c foo
　　 vpath % blish
　　 vpath %.c bar
　　 将按照"foo"，‘blish"，"bar"的次序查找".c"文件。而
　　 vpath %.c foo:bar
　　 vpath % blish
　　 按照"foo"，"bar"，"blish"的顺序搜索。

3.4.3 使用自动变量
　　目录搜索的结果并不改变规则中的命令：命令按原样被执行。因此，必须写出与目录搜索功相适应的命令。这可以通过使用"$^"这样的自动变量来完成。
　 "$^"表示规则中的所有依赖文件，包含它们所在的目录名（参见目录搜索）；"$@"表示目标。例如：
　　foo.o : foo.c
　　cc -c $(CFLAGS) $^ -o $@
　　通常情况下，依赖文件也包含头文件，但命令中并不提及这些文件：
　　变量"$<"表示第一个依赖文件：
　　VPATH = src:../headers
　　foo.o : foo.c defs.h hack.h
　　cc -c $(CFLAGS) $< -o $@

3.4.4 目录搜索和隐含规则
　　使用"VPATH"和"vpath"指定目录搜索也会影响隐含规则。例如：文件"foo.o"没有显式规则，make 会考虑隐式规则：如果"foo.c"存在则编译它；如果这个文件不存在，则在相应的目录中查找；如果"foo.c"在任一的目录中存在，则C编译的隐式规则被应用。
　　隐式规则的命令使用自动变量通常是必要的，这样无需其它努力即可以使用目录搜索得到的文件名。

3.5 PHONY 目标
　　PHONY 目标并非实际的文件名：只是在显式请求时执行命令的名字。有两种理由需要使用PHONY 目标：避免和同名文件冲突，改善性能。
　　如果编写一个规则，并不产生目标文件，则其命令在每次make 该目标时都执行。
　　例如：
　　clean:
　　rm *.o temp
　　因为"rm"命令并不产生"clean"文件，则每次执行"make clean"的时候，该命令都会执行。如果目录中出现了"clean"文件，则规则失效了：没有依赖文件，文件"clean"始终是最新的，命令永远不会执行；为避免这个问题，可使用".PHONY"指明该目标。如：
　　.PHONY : clean
　　这样执行"make clean"会无视"clean"文件存在与否。

　　已知phony 目标并非是由其它文件生成的实际文件，make 会跳过隐含规则搜索。这就是声明phony 目标会改善性能的原因，即使你并不担心实际文件存在与否。
　　完整的例子如下：
　　.PHONY : clean
　　clean :
　　rm *.o temp
　　phony 目标不应是真正目标文件的依赖。如果这样，每次make 在更新此文件时，命令都会执行。只要phony 目标不是真正目标的依赖，规则的命令只有在指定此目标时才执行。

　　phony 目标可以有依赖关系。当一个目录中有多个程序，将其放在一个makefile 中会更方便。因为缺省目标是makefile 中的第一个目标，通常将这个phony 目标叫做"all"，其依赖文件为各个程序：
　　all : prog1 prog2 prog3
　　.PHONY : all
　　prog1 : prog1.o utils.o
　　        cc -o prog1 prog1.o utils.o
　　prog2 : prog2.o
　　        cc -o prog2 prog2.o
　　prog3 : prog3.o sort.o utils.o
　　        cc -o prog3 prog3.o sort.o utils.o

　　这样，使用"make"将可以将三个程序都生成了。d
　　当一个phony 目标是另一个的依赖，其作用相当于子程序，例如：
　　.PHONY: cleanall cleanobj cleandiff
　　cleanall : cleanobj cleandiff
　　        rm program
　　cleanobj :
　　        rm *.o
　　cleandiff :
　　        rm *.diff

3.6 FORCE 目标
　　当规则没有依赖关系也没有命令，而且其目标不是存在的文件名，make 认为此规则运行时这个目标总是被更新。这意味着如果规则依赖于此目标，其命令总是被执行。
　　clean: FORCE
　　        rm $(objects)
　　FORCE:
　　例中目标"FORCE"满足这种特殊条件，这样依赖于它的目标"clean"被强制执行其命令。名字"FORCE"没有特殊含义，只不过通常这样用而已。这种方式使用"FORCE"和".PHONY : clean"效果相同。使用".PHONY"更加明确高效，但不是所有的"make"都支持；这样许多makefile 中使用了"FORCE"。

3.7 空目标
　　空目标（empty target）是phony 目标的变种：用来执行显式请求的一个动作。和phony 目标不同的是：这个目标文件可以真实存在，但文件的内容无关紧要，通常是空的。空目标文件的目的是利用其最后修改时间来记录命令最近一次执行的时间，这是通过使用"touch"命令更新目标文件来达到的。
　　print: foo.c bar.c
　　lpr -p $?
　　touch print
　　利用这条规则，执行"make print"时如果自上次"make print"之后任一文件改变了，"lpr"命令会执行。自动变量"$?"是为了只打印出那些变化了的文件。

3.8 内建的特殊目标
　　某些名字作为目标存在时有特殊含义。
　　★.PHONY 该目标的依赖被认为是phony 目标，处理这些目标时，命令无条件被执行，不管文件名是否存在及其最后修改时间
　　★.SUFFIXES 该目标的依赖被认为是一个后缀列表，在检查后缀规则时使用