來自陳浩的一片老文，但絕對營養(yǎng)。

示例工程：3 個頭文件*.h，和 8 個 C 文件*.c。

初

編譯過程，源文件首先會生成中間目標(biāo)文件，再由中間目標(biāo)文件生成執(zhí)行文件。在編譯時(shí)，編譯器只檢測程序語法，和函數(shù)、變量是否被聲明。如果函數(shù)未被聲明，編譯器會給出一個警告，但可以生成 Object File。而在鏈接程序時(shí)，鏈接器會在所有的 Object File 中找尋函數(shù)的實(shí)現(xiàn)，如果找不到，那到就會報(bào)鏈接錯誤碼（Linker Error）。

• Makefile規(guī)則:

//target: 目標(biāo)文件
//prerequisites: 依賴文件
//command: 執(zhí)行命令
target  : prerequisites    
command

示例，

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  
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 main.o kbd.o command.o display.o \    
insert.o search.o files.o utils.o

• 使用變量

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)

• 自動推導(dǎo)(隱晦規(guī)則)
  只要 make 看到一個*.o 文件，它就會自動的把*.c文件加在依賴關(guān)系中，.PHONY偽目標(biāo)文件。

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)

• 清空目標(biāo)文件
  一般做法，

clean:    
rm edit $(objects)

推薦做法，

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

.PHONY表示 clean 是一個“偽目標(biāo)”，-rm 是某些文件出現(xiàn)問題，但不要管，繼續(xù)做后面的事，clean的規(guī)則放在文件的最后”。

細(xì)節(jié)

Makefile 里主要包含了五個東西：顯式規(guī)則、隱晦規(guī)則、變量定義、文件指示和注釋。在 Makefile 中的命令，必須要以[Tab]鍵開始。

1. 顯式規(guī)則
   顯式規(guī)則說明了，如何生成一個或多的的目標(biāo)文件。這是由 Makefile 的書寫者明顯指出，要生成的文件，文件的依賴文件，生成的命令。
2. 隱晦規(guī)則
   由于我們的 make 有自動推導(dǎo)的功能，所以隱晦的規(guī)則可以讓我們比較粗糙地簡略地書寫 Makefile，這是由 make 所支持的。
3. 變量的定義
   在 Makefile 中我們要定義一系列的變量，變量一般都是字符串，這個有點(diǎn)你 C 語言中的宏，當(dāng) Makefile 被執(zhí)行時(shí)，其中的變量都會被擴(kuò)展到相應(yīng)的引用位置上。
4. 文件指示

• 在一個 Makefile 中引用另一個 Makefile，就像 C 語言中的include 一樣；
• 根據(jù)某些情況指定 Makefile 中的有效部分，就像 C 語言中的預(yù)編譯#if 一樣；
• 定義一個多行的命令。

5. 注釋
   Makefile 中只有行注釋，和 UNIX 的 Shell 腳本一樣，其注釋是用#字符。如果你要在你的 Makefile 中使用#字符，可以用反斜框進(jìn)行轉(zhuǎn)義，如：\#。

• Makefile 文件名
  默認(rèn)的情況下，make 命令會在當(dāng)前目錄下按順序?yàn)?code>GNUmakefile、makefile、Makefile的文件，推薦Makefile。make -f[--file]參數(shù),指定特定的 Makefile。

• 引用Makefile
  include <filename>
<filename>可以是當(dāng)前操作系統(tǒng) Shell 的文件模式（可以保含路徑和通配符）,在 include前面可以有一些空字符，不能是[Tab]鍵。include 和<filename>用一個或多個空格隔開。例，

bar = e.mk f.mk
include foo.make *.mk $(bar)

等價(jià)于，

include foo.make a.mk b.mk c.mk e.mk f.mk

make 命令開始時(shí)，把include 所指出的其它 Makefile安置在當(dāng)前
的位。如果文件都沒有指定絕對路徑或是相對路徑的話，make 會在當(dāng)前目錄下首先尋找，如果當(dāng)前目錄下沒有找到，那么，make 還會在下面的幾個目錄下找：

1. 如果 make 執(zhí)行時(shí)，有-I或--include-dir參數(shù)，那么 make 就會在這個參數(shù)所指定的目錄下去尋找。
2. 如果目錄<prefix>/include（一般是：/usr/local/bin 或/usr/include）存在的話，make 也會去找。如果有文件沒有找到的話，make 會生成一條警告信息，繼續(xù)載入其它的文件，一旦完成 Makefile 的讀取，make 會再重試這些沒有找到，或是不能讀取的文件，如果還是不行，make 才會出現(xiàn)一條致命信息。在 include 前加一個減號-，如： -include <filename>其表示，無論 include 過程中出現(xiàn)什么錯誤，都不要報(bào)錯繼續(xù)執(zhí)行。其它版本 make兼容的相關(guān)命令是 sinclude。

• 環(huán)境變量 MAKEFILES
  如果你的當(dāng)前環(huán)境中定義了環(huán)境變量 MAKEFILES，那么，make 會把這個變量中的值做一個類似于 include 的動作。這個變量中的值是其它的 Makefile，用空格分隔。
  ** 建議不要使用這個環(huán)境變量。 **

• make 的工作方式
  GNU 的 make 工作時(shí)的執(zhí)行步驟入下：

  • 讀入所有的 Makefile
  • 讀入被 include 的其它 Makefile
  • 初始化文件中的變量
  • 推導(dǎo)隱晦規(guī)則，并分析所有規(guī)則
  • 為所有的目標(biāo)文件創(chuàng)建依賴關(guān)系鏈
  • 根據(jù)依賴關(guān)系，決定哪些目標(biāo)要重新生成
  • 執(zhí)行生成命令

1-5 步為第一個階段，6-7 為第二個階段。第一個階段中，如果定義的變量出現(xiàn)在依賴關(guān)系的規(guī)則中，那么僅當(dāng)這條依賴被決定要使用了，變量才會在其內(nèi)部展開。

書寫規(guī)則

規(guī)則包含兩個部分，一個是依賴關(guān)系，一個是生成目標(biāo)的方法。
在 Makefile 中，第一條規(guī)則中的目標(biāo)將被確立為最終的目標(biāo)。

一、規(guī)則舉例

foo.o : foo.c defs.h # foo 模塊    
cc -c -g foo.c  

foo.o 是我們的目標(biāo)，foo.c和 defs.h 是目標(biāo)所依賴的源文件，而只有一個命令cc -c -g foo.c（以Tab 鍵開頭）。

• 文件的依賴關(guān)系，foo.o 依賴于 foo.c 和 defs.h 的文件，如果 foo.c 和 defs.h 的文件日期要比 foo.o 文件日期要新，或是 foo.o 不存在，那么依賴關(guān)系發(fā)生。
• 如果生成（或更新）foo.o 文件。也就是那個 cc 命令，其說明了，如何生成 foo.o這個文件。

二、規(guī)則的語法

targets : prerequisites    
command

或是這樣：

targets : prerequisites ; command    
command    

targets 是文件名，以空格分開，可以使用通配符。一般來說，我們的目標(biāo)基本上是一個文件，但也有可能是多個文件。command 是命令行，如果其不與target:prerequisites在一行，那么，必須以[Tab]開頭，如果和 prerequisites 在一行，那么可以用;做為分隔。 prerequisites也就是目標(biāo)所依賴的文件（或依賴目標(biāo)）。如果其中的某個文件要比目標(biāo)文件要新，那么， 目標(biāo)就被認(rèn)為是“過時(shí)的”，被認(rèn)為是需要重生成的。

如果命令太長，你可以使用反斜框（\）作為換行符。make 對一行上有多少個字符沒有限制。規(guī)則告訴 make 兩件事，文件的依賴關(guān)系和如何成成目標(biāo)文件。

三、在規(guī)則中使用通配符
如果我們想定義一系列比較類似的文件，我們很自然地就想起使用通配符。make 支持三各通配符：*，?和[...]。這是和 Unix 的 B-Shell 是相同的。 波浪號（~）字符在文件名中也有比較特殊的用途。如果是“~/test，這就表示當(dāng)前用戶的$HOME 目錄下的 test 目錄。而~hchen/test則表示用戶 hchen 的宿主目錄下的 test 目錄。而在 Windows 或是 MS-DOS 下，用戶沒有宿主目錄，那么波浪號所指的目錄則根據(jù)環(huán)境變量HOME而定。

通配符代替了你一系列的文件，如*.c表示所以后綴為 c 的文件用轉(zhuǎn)義字符\，如\*來表示真實(shí)的*字符。
例：

clean:    
rm -f *.o

print: *.c    
lpr -p $?    
touch print

這個例子說明了通配符也可以在我們的規(guī)則中，目標(biāo) print 依賴于所有的.c文件。其中的$?是一個自動化變量。

objects = *.o

上面這個例子，表示了，通符同樣可以用在變量中。并不是說*.o會展開，不！objects的值就是*.o。如果要讓通配符在變量中展開，也就是讓 objects 的值是所有.o的文件名的集合，那么，你可以這樣：

objects := $(wildcard *.o)    

這種用法由關(guān)鍵字wildcard指出，關(guān)于 Makefile 的關(guān)鍵字。

四、文件搜尋
Makefile 文件中的變量VPATH，如果沒有指明這個變量，make 只會在當(dāng)前的目錄中去找尋依賴文件和目標(biāo)文件。如果定義了這個變量，那么，make就會在當(dāng)當(dāng)前目錄找不到的情況下，到所指定的目錄中去找尋文件了。

VPATH = src:../headers

上面的的定義指定兩個目錄，src和../headers，make 會按照這個順序進(jìn)行搜索。目錄由:分隔。
另一個設(shè)置文件搜索路徑的方法是使用 make 的vpath關(guān)鍵字，不是變量，這是一個 make 的關(guān)鍵字，可以指定不同的文件在不同的搜索目錄中。這是一個很靈活的功能。它的使用方法有三種：

• vpath <pattern> <directories>
  為符合模式<pattern>的文件指定搜索目錄<directories>。
• vpath <pattern>
  清除符合模式<pattern>的文件的搜索目錄。
• vpath
  清除所有已被設(shè)置好了的文件搜索目錄。

vapth 使用方法中的<pattern>需要包含%字符匹配零或若干字符，例如 ， %.h表示所有以 .h結(jié) 尾 的 文 件 。<pattern>指 定 了 要 搜 索 的 文 件 集 ， 而 <directories>則指定了<pattern>的文件集的搜索的目錄。例如：vpath %.h ../headers，要求 make 在../headers目錄下搜索所有以.h結(jié)尾的文件。
我們可以連續(xù)地使用 vpath 語句，以指定不同搜索策略。如果連續(xù)的 vpath 語句中出現(xiàn)了相同的<pattern>，或是被重復(fù)了的<pattern>，那么，make 會按照 vpath 語句的先后順序來執(zhí)行搜索。如：

vpath %.c foo    
vpath % blish    
vpath %.c bar

其表示.c結(jié)尾的文件，先在foo目錄，然后是blish，最后是bar目錄。

vpath %.c foo:bar    
vpath % blish

而上面的語句則表示.c結(jié)尾的文件，先在foo目錄，然后是bar目錄，最后才是blish目錄。

偽目標(biāo)

最早先的一個例子中，我們提到過一個“clean”的目標(biāo)，這是一個“偽目標(biāo)”，
clean:
rm *.o temp
正像我們前面例子中的“clean”一樣，即然我們生成了許多文件編譯文件，我們也應(yīng)
該提供一個清除它們的“目標(biāo)”以備完整地重編譯而用。 （以“make clean”來使用該目
標(biāo)）
因?yàn)椋覀儾⒉簧伞癱lean”這個文件?！皞文繕?biāo)”并不是一個文件，只是一個標(biāo)簽，
由于“偽目標(biāo)”不是文件，所以 make 無法生成它的依賴關(guān)系和決定它是否要執(zhí)行。我們只
有通過顯示地指明這個“目標(biāo)”才能讓其生效。當(dāng)然，“偽目標(biāo)”的取名不能和文件名重名，
不然其就失去了“偽目標(biāo)”的意義了。

當(dāng)然，為了避免和文件重名的這種情況，我們可以使用一個特殊的標(biāo)記“.PHONY”來顯
示地指明一個目標(biāo)是“偽目標(biāo)”，向 make 說明，不管是否有這個文件，這個目標(biāo)就是“偽
目標(biāo)”。
.PHONY : clean
只要有這個聲明，不管是否有“clean”文件，要運(yùn)行“clean”這個目標(biāo)，只有“make
clean”這樣。于是整個過程可以這樣寫：
第 20 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
.PHONY: clean
clean:
rm *.o temp

偽目標(biāo)一般沒有依賴的文件。但是，我們也可以為偽目標(biāo)指定所依賴的文件。偽目標(biāo)同
樣可以作為“默認(rèn)目標(biāo)”，只要將其放在第一個。一個示例就是，如果你的 Makefile 需要
一口氣生成若干個可執(zhí)行文件，但你只想簡單地敲一個 make 完事，并且，所有的目標(biāo)文件
都寫在一個 Makefile 中，那么你可以使用“偽目標(biāo)”這個特性：

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
我們知道，Makefile 中的第一個目標(biāo)會被作為其默認(rèn)目標(biāo)。我們聲明了一個“all”的
偽目標(biāo)，其依賴于其它三個目標(biāo)。由于偽目標(biāo)的特性是，總是被執(zhí)行的，所以其依賴的那三
個目標(biāo)就總是不如“all”這個目標(biāo)新。所以，其它三個目標(biāo)的規(guī)則總是會被決議。也就達(dá)
到了我們一口氣生成多個目標(biāo)的目的?！?PHONY : all”聲明了“all”這個目標(biāo)為“偽目
標(biāo)”。

隨便提一句，從上面的例子我們可以看出，目標(biāo)也可以成為依賴。所以，偽目標(biāo)同樣也
可成為依賴?？聪旅娴睦樱?br> .PHONY: cleanall cleanobj cleandiff
cleanall : cleanobj cleandiff
rm program
cleanobj :
rm *.o
cleandiff :
rm *.diff
“make clean”將清除所有要被清除的文件?！癱leanobj”和“cleandiff”這兩個偽
目標(biāo)有點(diǎn)像“子程序”的意思。我們可以輸入“make cleanall”和“make cleanobj”和
“make cleandiff”命令來達(dá)到清除不同種類文件的目的。
第 21 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
六、多目標(biāo)

Makefile 的規(guī)則中的目標(biāo)可以不止一個，其支持多目標(biāo)，有可能我們的多個目標(biāo)同時(shí)依賴
于一個文件，并且其生成的命令大體類似。于是我們就能把其合并起來。當(dāng)然，多個目標(biāo)的
生成規(guī)則的執(zhí)行命令是同一個，這可能會可我們帶來麻煩，不過好在我們的可以使用一個自
動化變量“$@”（關(guān)于自動化變量，將在后面講述），這個變量表示著目前規(guī)則中所有的目
標(biāo)的集合，這樣說可能很抽象，還是看一個例子吧。

bigoutput littleoutput : text.g
generate text.g -$(subst output,,$@) > $@
上述規(guī)則等價(jià)于：
bigoutput : text.g
generate text.g -big > bigoutput
littleoutput : text.g
generate text.g -little > littleoutput

其中，-$(subst output,,$@)中的“$”表示執(zhí)行一個 Makefile 的函數(shù)，函數(shù)名為 subst，
后面的為參數(shù)。關(guān)于函數(shù)，將在后面講述。這里的這個函數(shù)是截取字符串的意思，“$@”表
示目標(biāo)的集合，就像一個數(shù)組，“$@”依次取出目標(biāo)，并執(zhí)于命令。
七、靜態(tài)模式
靜態(tài)模式可以更加容易地定義多目標(biāo)的規(guī)則，可以讓我們的規(guī)則變得更加的有彈性和靈
活
。我們還是先來看一下語法：
<targets ...>: <target-pattern>: <prereq-patterns ...>
<commands>
....

targets 定義了一系列的目標(biāo)文件，可以有通配符。是目標(biāo)的一個集合。
target-parrtern 是指明了 targets 的模式，也就是的目標(biāo)集模式。
prereq-parrterns 是目標(biāo)的依賴模式，它對 target-parrtern 形成的模式再進(jìn)行一次依賴
目標(biāo)的定義。

這樣描述這三個東西，可能還是沒有說清楚，還是舉個例子來說明一下吧。如果我們的
第 22 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
<target-parrtern>定義成“%.o”，意思是我們的<target>集合中都是以“.o”結(jié)尾的，而
如果我們的<prereq-parrterns>定義成“%.c”，意思是對<target-parrtern>所形成的目標(biāo)
集進(jìn)行二次定義，其計(jì)算方法是，取<target-parrtern>模式中的“%”（也就是去掉了[.o]
這個結(jié)尾），并為其加上[.c]這個結(jié)尾，形成的新集合。

所以，我們的“目標(biāo)模式”或是“依賴模式”中都應(yīng)該有“%”這個字符，如果你的文
件名中有“%”那么你可以使用反斜杠“\”進(jìn)行轉(zhuǎn)義，來標(biāo)明真實(shí)的“%”字符。
看一個例子：
objects = foo.o bar.o

all: $(objects)
$(objects): %.o: %.c
$(CC) -c $(CFLAGS) {1}lt; -o $@
上面的例子中，指明了我們的目標(biāo)從$object 中獲取，“%.o”表明要所有以“.o”結(jié)
尾的目標(biāo)，也就是“foo.o bar.o”，也就是變量$object 集合的模式，而依賴模式“%.c”
則取模式“%.o”的“%”，也就是“foo bar”，并為其加下“.c”的后綴，于是，我們的
依賴目標(biāo)就是“foo.c bar.c”。而命令中的“{1}lt;”和“$@”則是自動化變量，“{1}lt;”表示
所有的依賴目標(biāo)集（也就是“foo.c bar.c”），“$@”表示目標(biāo)集（也就是“foo.o bar.o”）。
于是，上面的規(guī)則展開后等價(jià)于下面的規(guī)則：

foo.o : foo.c
$(CC) -c $(CFLAGS) foo.c -o foo.o
bar.o : bar.c
$(CC) -c $(CFLAGS) bar.c -o bar.o

試想，如果我們的“%.o”有幾百個，那種我們只要用這種很簡單的“靜態(tài)模式規(guī)則”
就可以寫完一堆規(guī)則，實(shí)在是太有效率了。“靜態(tài)模式規(guī)則”的用法很靈活，如果用得好，
那會一個很強(qiáng)大的功能。再看一個例子：

files = foo.elc bar.o lose.o

$(filter %.o,$(files)): %.o: %.c
$(CC) -c $(CFLAGS) {1}lt; -o $@
$(filter %.elc,$(files)): %.elc: %.el
emacs -f batch-byte-compile {1}lt;
$(filter %.o,$(files))表示調(diào)用 Makefile 的 filter 函數(shù)，過濾“$filter”集，只要其
中模式為“%.o”的內(nèi)容。其的它內(nèi)容，我就不用多說了吧。這個例字展示了 Makefile 中更
大的彈性。

第 23 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓

八、自動生成依賴性
在 Makefile 中，我們的依賴關(guān)系可能會需要包含一系列的頭文件，比如，如果我們的 main.c
中有一句“#include "defs.h"”，那么我們的依賴關(guān)系應(yīng)該是：

main.o : main.c defs.h
但是，如果是一個比較大型的工程，你必需清楚哪些 C 文件包含了哪些頭文件，并且，
你在加入或刪除頭文件時(shí)，也需要小心地修改 Makefile，這是一個很沒有維護(hù)性的工作。
為了避免這種繁重而又容易出錯的事情，我們可以使用 C/C++編譯的一個功能。大多數(shù)的
C/C++編譯器都支持一個“-M”的選項(xiàng)，即自動找尋源文件中包含的頭文件，并生成一個依
賴關(guān)系。例如，如果我們執(zhí)行下面的命令：
cc -M main.c

其輸出是：
main.o : main.c defs.h
于是由編譯器自動生成的依賴關(guān)系，這樣一來，你就不必再手動書寫若干文件的依賴關(guān)
系，而由編譯器自動生成了。需要提醒一句的是，如果你使用 GNU 的 C/C++編譯器，你得用
“-MM”參數(shù)，不然，“-M”參數(shù)會把一些標(biāo)準(zhǔn)庫的頭文件也包含進(jìn)來。
gcc -M main.c 的輸出是：
main.o: main.c defs.h /usr/include/stdio.h /usr/include/features.h \
/usr/include/sys/cdefs.h /usr/include/gnu/stubs.h \
/usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stddef.h \
/usr/include/bits/types.h /usr/include/bits/pthreadtypes.h \
/usr/include/bits/sched.h /usr/include/libio.h \
/usr/include/_G_config.h /usr/include/wchar.h \
/usr/include/bits/wchar.h /usr/include/gconv.h \
/usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stdarg.h \
/usr/include/bits/stdio_lim.h
gcc -MM main.c 的輸出則是：
main.o: main.c defs.h
那么，編譯器的這個功能如何與我們的 Makefile 聯(lián)系在一起呢。因?yàn)檫@樣一來，我們
的 Makefile 也要根據(jù)這些源文件重新生成，讓 Makefile 自已依賴于源文件？這個功能并不
現(xiàn)實(shí)，不過我們可以有其它手段來迂回地實(shí)現(xiàn)這一功能。GNU 組織建議把編譯器為每一個源
第 24 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
文 件 的 自 動 生 成 的 依 賴 關(guān) 系 放 到 一 個 文 件 中 ， 為 每 一 個 “name.c” 的 文 件 都 生 成 一 個
“name.d”的 Makefile 文件，[.d]文件中就存放對應(yīng)[.c]文件的依賴關(guān)系。于是，我們可
以寫出[.c]文件和[.d]文件的依賴關(guān)系，并讓 make 自動更新或自成[.d]文件，并把其包含
在我們的主 Makefile 中，這樣，我們就可以自動化地生成每個文件的依賴關(guān)系了。
這里，我們給出了一個模式規(guī)則來產(chǎn)生[.d]文件：

%.d: %.c
@set -e; rm -f $@; \
$(CC) -M $(CPPFLAGS) {1}lt; > $@.$$; \
sed 's,$?.o[ :]*,\1.o $@ : ,g' < $@.$$ > $@; \
rm -f $@.$$
這個規(guī)則的意思是，所有的[.d]文件依賴于[.c]文件，“rm -f $@”的意思是刪除所有
的目標(biāo)，也就是[.d]文件，第二行的意思是，為每個依賴文件“{1}lt;”，也就是[.c]文件生成
依賴文件，“$@”表示模式“%.d”文件，如果有一個 C 文件是 name.c，那么“%”就是
“name”，“$$”意為一個隨機(jī)編號，第二行生成的文件有可能是“name.d.12345”，第
三行使用 sed 命令做了一個替換，關(guān)于 sed 命令的用法請參看相關(guān)的使用文檔。第四行就是
刪除臨時(shí)文件。

總而言之，這個模式要做的事就是在編譯器生成的依賴關(guān)系中加入[.d]文件的依賴，即
把依賴關(guān)系：
main.o : main.c defs.h
轉(zhuǎn)成：
main.o main.d : main.c defs.h
于是，我們的[.d]文件也會自動更新了，并會自動生成了，當(dāng)然，你還可以在這個[.d]
文件中加入的不只是依賴關(guān)系，包括生成的命令也可一并加入，讓每個[.d]文件都包含一個
完賴的規(guī)則。一旦我們完成這個工作，接下來，我們就要把這些自動生成的規(guī)則放進(jìn)我們的
主 Makefile 中。我們可以使用 Makefile 的“include”命令，來引入別的 Makefile 文件（前
面講過），例如：
sources = foo.c bar.c
include $(sources:.c=.d)
上 述 語 句 中 的 “$(sources:.c=.d)” 中 的 “.c=.d” 的 意 思 是 做 一 個 替 換 ， 把 變 量
$(sources)所有[.c]的字串都替換成[.d]，關(guān)于這個“替換”的內(nèi)容，在后面我會有更為詳
細(xì)的講述。當(dāng)然，你得注意次序，因?yàn)?include 是按次來載入文件，最先載入的[.d]文件中
的目標(biāo)會成為默認(rèn)目標(biāo)。

第六部分 書寫命令

第 25 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
每條規(guī)則中的命令和操作系統(tǒng) Shell 的命令行是一致的。make 會一按順序一條一條的
執(zhí)行命令，每條命令的開頭必須以[Tab]鍵開頭，除非，命令是緊跟在依賴規(guī)則后面的分號
后的。在命令行之間中的空格或是空行會被忽略，但是如果該空格或空行是以 Tab 鍵開頭的，
那么 make 會認(rèn)為其是一個空命令。

我 們 在 UNIX 下 可 能 會 使 用 不 同 的 Shell ， 但 是 make 的 命 令 默 認(rèn) 是 被
“/bin/sh”——UNIX 的標(biāo)準(zhǔn) Shell 解釋執(zhí)行的。除非你特別指定一個其它的 Shell。
Makefile 中，“#”是注釋符，很像 C/C++中的“//”，其后的本行字符都被注釋。
一、顯示命令
通常，make 會把其要執(zhí)行的命令行在命令執(zhí)行前輸出到屏幕上。當(dāng)我們用“@”字符在
命令行前，那么，這個命令將不被 make 顯示出來，最具代表性的例子是，我們用這個功能
來像屏幕顯示一些信息。如：
@echo 正在編譯 XXX 模塊......
當(dāng) make 執(zhí)行時(shí)，會輸出“正在編譯 XXX 模塊......”字串，但不會輸出命令，如果沒
有“@”，那么，make 將輸出：
echo 正在編譯 XXX 模塊......
正在編譯 XXX 模塊......
如果 make 執(zhí)行時(shí)，帶入 make 參數(shù)“-n”或“--just-print”，那么其只是顯示命令，
但不會執(zhí)行命令，這個功能很有利于我們調(diào)試我們的 Makefile，看看我們書寫的命令是執(zhí)
行起來是什么樣子的或是什么順序的。

而 make 參數(shù)“-s”或“--slient”則是全面禁止命令的顯示。

二、命令執(zhí)行

當(dāng)依賴目標(biāo)新于目標(biāo)時(shí)，也就是當(dāng)規(guī)則的目標(biāo)需要被更新時(shí)，make 會一條一條的執(zhí)行
其后的命令。需要注意的是，如果你要讓上一條命令的結(jié)果應(yīng)用在下一條命令時(shí)，你應(yīng)該使
用分號分隔這兩條命令。比如你的第一條命令是 cd 命令，你希望第二條命令得在 cd 之后的
基礎(chǔ)上運(yùn)行，那么你就不能把這兩條命令寫在兩行上，而應(yīng)該把這兩條命令寫在一行上，用
分號分隔。如：

示例一：
exec:
cd /home/hchen
pwd

第 26 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
示例二：
exec:
cd /home/hchen; pwd

當(dāng)我們執(zhí)行“make exec”時(shí)，第一個例子中的 cd 沒有作用，pwd 會打印出當(dāng)前的
Makefile 目錄，而第二個例子中，cd 就起作用了，pwd 會打印出“/home/hchen”。make
一般是使用環(huán)境變量 SHELL 中所定義的系統(tǒng) Shell 來執(zhí)行命令，默認(rèn)情況下使用 UNIX 的
標(biāo)準(zhǔn) Shell——/bin/sh 來執(zhí)行命令。但在 MS-DOS 下有點(diǎn)特殊，因?yàn)?MS-DOS 下沒有 SHELL
環(huán)境變量，當(dāng)然你也可以指定。如果你指定了 UNIX 風(fēng)格的目錄形式，首先，make 會在 SHELL
所指定的路徑中找尋命令解釋器，如果找不到，其會在當(dāng)前盤符中的當(dāng)前目錄中尋找，如果
再找不到，其會在 PATH 環(huán)境變量中所定義的所有路徑中尋找。MS-DOS 中，如果你定義的命
令解釋器沒有找到，其會給你的命令解釋器加上諸如“.exe”、“.com”、“.bat”、“.sh”
等后綴。

三、命令出錯

每當(dāng)命令運(yùn)行完后，make 會檢測每個命令的返回碼，如果命令返回成功，那么 make 會
執(zhí)行下一條命令，當(dāng)規(guī)則中所有的命令成功返回后，這個規(guī)則就算是成功完成了。如果一個
規(guī)則中的某個命令出錯了（命令退出碼非零），那么 make 就會終止執(zhí)行當(dāng)前規(guī)則，這將有可
能終止所有規(guī)則的執(zhí)行。
有些時(shí)候，命令的出錯并不表示就是錯誤的。例如 mkdir 命令，我們一定需要建立一個
目錄，如果目錄不存在，那么 mkdir 就成功執(zhí)行，萬事大吉，如果目錄存在，那么就出錯了。
我們之所以使用 mkdir 的意思就是一定要有這樣的一個目錄，于是我們就不希望 mkdir 出錯
而終止規(guī)則的運(yùn)行。

為了做到這一點(diǎn)，忽略命令的出錯，我們可以在 Makefile 的命令行前加一個減號“-”
（在 Tab 鍵之后），標(biāo)記為不管命令出不出錯都認(rèn)為是成功的。如：
clean:
-rm -f *.o

還有一個全局的辦法是，給 make 加上“-i”或是“--ignore-errors”參數(shù)，那么，
Makefile 中所有命令都會忽略錯誤。而如果一個規(guī)則是以“.IGNORE”作為目標(biāo)的，那么這
個規(guī)則中的所有命令將會忽略錯誤。這些是不同級別的防止命令出錯的方法，你可以根據(jù)你
的不同喜歡設(shè)置。

還有一個要提一下的 make 的參數(shù)的是“-k”或是“--keep-going”，這個參數(shù)的意思
是，如果某規(guī)則中的命令出錯了，那么就終目該規(guī)則的執(zhí)行，但繼續(xù)執(zhí)行其它規(guī)則。
第 27 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
四、嵌套執(zhí)行 make

在一些大的工程中，我們會把我們不同模塊或是不同功能的源文件放在不同的目錄中，
我們可以在每個目錄中都書寫一個該目錄的 Makefile，這有利于讓我們的 Makefile 變得更
加地簡潔，而不至于把所有的東西全部寫在一個 Makefile 中，這樣會很難維護(hù)我們的
Makefile，這個技術(shù)對于我們模塊編譯和分段編譯有著非常大的好處。

例如，我們有一個子目錄叫 subdir，這個目錄下有個 Makefile 文件，來指明了這個目
錄下文件的編譯規(guī)則。那么我們總控的 Makefile 可以這樣書寫：
subsystem:
cd subdir && $(MAKE)
其等價(jià)于：
subsystem:
$(MAKE) -C subdir
定義$(MAKE)宏變量的意思是，也許我們的 make 需要一些參數(shù)，所以定義成一個變量比
較利于維護(hù)。這兩個例子的意思都是先進(jìn)入“subdir”目錄，然后執(zhí)行 make 命令。
我們把這個 Makefile 叫做“總控 Makefile”，總控 Makefile 的變量可以傳遞到下級
的 Makefile 中（如果你顯示的聲明），但是不會覆蓋下層的 Makefile 中所定義的變量，除
非指定了“-e”參數(shù)。

如果你要傳遞變量到下級 Makefile 中，那么你可以使用這樣的聲明：
export <variable ...>
如果你不想讓某些變量傳遞到下級 Makefile 中，那么你可以這樣聲明：
unexport <variable ...>
如：
示例一：
export variable = value
其等價(jià)于：
variable = value
export variable
第 28 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓

其等價(jià)于：
export variable := value
其等價(jià)于：
variable := value
export variable
示例二：
export variable += value
其等價(jià)于：
variable += value
export variable
如果你要傳遞所有的變量，那么，只要一個 export 就行了。后面什么也不用跟，表示
傳遞所有的變量。
需要注意的是，有兩個變量，一個是 SHELL，一個是 MAKEFLAGS，這兩個變量不管你是
否 export，其總是要傳遞到下層 Makefile 中，特別是 MAKEFILES 變量，其中包含了 make
的參數(shù)信息，如果我們執(zhí)行“總控 Makefile”時(shí)有 make 參數(shù)或是在上層 Makefile 中定義
了這個變量，那么 MAKEFILES 變量將會是這些參數(shù)，并會傳遞到下層 Makefile 中，這是一
個系統(tǒng)級的環(huán)境變量。

但是 make 命令中的有幾個參數(shù)并不往下傳遞，它們是“-C”,“-f”,“-h”“-o”和
“-W”（有關(guān) Makefile 參數(shù)的細(xì)節(jié)將在后面說明），如果你不想往下層傳遞參數(shù)，那么，你
可以這樣來：
subsystem:
cd subdir && $(MAKE) MAKEFLAGS=
如果你定義了環(huán)境變量 MAKEFLAGS，那么你得確信其中的選項(xiàng)是大家都會用到的，如果
其中有“-t”,“-n”,和“-q”參數(shù)，那么將會有讓你意想不到的結(jié)果，或許會讓你異常地
恐慌。
還有一個在“嵌套執(zhí)行”中比較有用的參數(shù)，“-w”或是“--print-directory”會在
make 的過程中輸出一些信息，讓你看到目前的工作目錄。比如，如果我們的下級 make 目錄
是“/home/hchen/gnu/make”，如果我們使用“make -w”來執(zhí)行，那么當(dāng)進(jìn)入該目錄時(shí)，
我們會看到：

第 29 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
make: Entering directory `/home/hchen/gnu/make'.

而在完成下層 make 后離開目錄時(shí)，我們會看到：
make: Leaving directory `/home/hchen/gnu/make'
當(dāng)你使用“-C”參數(shù)來指定 make 下層 Makefile 時(shí)，“-w”會被自動打開的。如果參數(shù)中有
“-s”（“--slient”）或是“--no-print-directory”，那么，“-w”總是失效的。
五、定義命令包

如果 Makefile 中出現(xiàn)一些相同命令序列，那么我們可以為這些相同的命令序列定義一
個變量。定義這種命令序列的語法以“define”開始，以“endef”結(jié)束，如：
define run-yacc
yacc $(firstword $^)
mv y.tab.c $@
endef

這里，“run-yacc”是這個命令包的名字，其不要和 Makefile 中的變量重名。在
“define”和“endef”中的兩行就是命令序列。這個命令包中的第一個命令是運(yùn)行 Yacc
程序，因?yàn)?Yacc 程序總是生成“y.tab.c”的文件，所以第二行的命令就是把這個文件改改
名字。還是把這個命令包放到一個示例中來看看吧。

foo.c : foo.y
$(run-yacc)
我們可以看見，要使用這個命令包，我們就好像使用變量一樣。在這個命令包的使用中，
命令包“run-yacc”中的“$^”就是“foo.y”，“$@”就是“foo.c”（有關(guān)這種以“$”
開頭的特殊變量，我們會在后面介紹），make 在執(zhí)行命令包時(shí)，命令包中的每個命令會被依
次獨(dú)立執(zhí)行。

第七部分 使用變量

在 Makefile 中的定義的變量，就像是 C/C++語言中的宏一樣，他代表了一個文本字串，
在 Makefile 中執(zhí)行的時(shí)候其會自動原模原樣地展開在所使用的地方。其與 C/C++所不同的
是，你可以在 Makefile 中改變其值。在 Makefile 中，變量可以使用在“目標(biāo)”，“依賴目
標(biāo)”，“命令”或是 Makefile 的其它部分中。

變量的命名字可以包含字符、數(shù)字，下劃線（可以是數(shù)字開頭），但不應(yīng)該含有“:”、
第 30 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
“#”、“=”或是空字符（空格、回車等）。變量是大小寫敏感的，“foo”、“Foo”和“FOO”
是三個不同的變量名。傳統(tǒng)的 Makefile 的變量名是全大寫的命名方式，但我推薦使用大小
寫搭配的變量名，如：MakeFlags。這樣可以避免和系統(tǒng)的變量沖突，而發(fā)生意外的事情。

有一些變量是很奇怪字串，如“{1}lt;”、“$@”等，這些是自動化變量，我會在后面介紹。

一、變量的基礎(chǔ)

變量在聲明時(shí)需要給予初值，而在使用時(shí)，需要給在變量名前加上“$”符號，但最好
用小括號“（）”或是大括號“{}”把變量給包括起來。如果你要使用真實(shí)的“$”字符，
那么你需要用“$”來表示。
變量可以使用在許多地方，如規(guī)則中的“目標(biāo)”、“依賴”、“命令”以及新的變量中。先
看一個例子：
objects = program.o foo.o utils.o
program : $(objects)
cc -o program $(objects)
$(objects) : defs.h
變量會在使用它的地方精確地展開，就像 C/C++中的宏一樣，例如：
foo = c
prog.o : prog.$(foo)
$(foo)$(foo) -$(foo) prog.$(foo)
展開后得到：
prog.o : prog.c
cc -c prog.c
當(dāng)然，千萬不要在你的 Makefile 中這樣干，這里只是舉個例子來表明 Makefile 中的變
量在使用處展開的真實(shí)樣子。可見其就是一個“替代”的原理。

另外，給變量加上括號完全是為了更加安全地使用這個變量，在上面的例子中，如果你
不想給變量加上括號，那也可以，但我還是強(qiáng)烈建議你給變量加上括號。
第 31 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
二、變量中的變量

在定義變量的值時(shí)，我們可以使用其它變量來構(gòu)造變量的值，在 Makefile 中有兩種方
式來在用變量定義變量的值。
先看第一種方式，也就是簡單的使用“=”號，在“=”左側(cè)是變量，右側(cè)是變量的值，右側(cè)
變量的值可以定義在文件的任何一處，也就是說，右側(cè)中的變量不一定非要是已定義好的值，
其也可以使用后面定義的值。如：
foo = $(bar)
bar = $(ugh)
ugh = Huh?
all:
echo $(foo)
我們執(zhí)行“make all”將會打出變量$(foo)的值是“Huh?”（ $(foo)的值是$(bar)，
$(bar)的值是$(ugh)，$(ugh)的值是“Huh?”）可見，變量是可以使用后面的變量來定義的。

這個功能有好的地方，也有不好的地方，好的地方是，我們可以把變量的真實(shí)值推到后
面來定義，如：
CFLAGS = $(include_dirs) -O
include_dirs = -Ifoo -Ibar
當(dāng)“CFLAGS”在命令中被展開時(shí)，會是“-Ifoo -Ibar -O”。但這種形式也有不好的地
方，那就是遞歸定義，如：
CFLAGS = $(CFLAGS) -O
或：
A = $(B)
B = $(A)
這會讓 make 陷入無限的變量展開過程中去，當(dāng)然，我們的 make 是有能力檢測這樣的定
義，并會報(bào)錯。還有就是如果在變量中使用函數(shù)，那么，這種方式會讓我們的 make 運(yùn)行時(shí)
非常慢，更糟糕的是，他會使用得兩個 make 的函數(shù)“wildcard”和“shell”發(fā)生不可預(yù)知
的錯誤。因?yàn)槟悴粫肋@兩個函數(shù)會被調(diào)用多少次。

為了避免上面的這種方法，我們可以使用 make 中的另一種用變量來定義變量的方法。
這種方法使用的是“:=”操作符，如：
第 32 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓

x := foo
y := $(x) bar
x := later
其等價(jià)于：
y := foo bar
x := later
值得一提的是，這種方法，前面的變量不能使用后面的變量，只能使用前面已定義好了的變
量。如果是這樣：
y := $(x) bar
x := foo
那么，y 的值是“bar”，而不是“foo bar”。
上面都是一些比較簡單的變量使用了，讓我們來看一個復(fù)雜的例子，其中包括了 make
的函數(shù)、條件表達(dá)式和一個系統(tǒng)變量“MAKELEVEL”的使用：
ifeq (0,${MAKELEVEL})
cur-dir := $(shell pwd)
whoami := $(shell whoami)
host-type := $(shell arch)
MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}
endif

關(guān)于條件表達(dá)式和函數(shù)，我們在后面再說，對于系統(tǒng)變量“MAKELEVEL”，其意思是，
如果我們的 make 有一個嵌套執(zhí)行的動作（參見前面的“嵌套使用 make”），那么，這個變
量會記錄了我們的當(dāng)前 Makefile 的調(diào)用層數(shù)。

下面再介紹兩個定義變量時(shí)我們需要知道的，請先看一個例子，如果我們要定義一個變
量，其值是一個空格，那么我們可以這樣來：
nullstring :=
space := $(nullstring) # end of the line
nullstring 是一個 Empty 變量，其中什么也沒有，而我們的 space 的值是一個空格。因?yàn)?br> 在
操作符的右邊是很難描述一個空格的，這里采用的技術(shù)很管用，先用一個 Empty 變量來
標(biāo)明變量的值開始了，而后面采用“#”注釋符來表示變量定義的終止，這樣，我們可以定
義出其值是一個空格的變量。請注意這里關(guān)于“#”的使用，注釋符“#”的這種特性值得我
第 33 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
們注意，如果我們這樣定義一個變量：

dir := /foo/bar # directory to put the frobs in
dir 這個變量的值是“/foo/bar”，后面還跟了 4 個空格，如果我們這樣使用這樣變量來指
定別的目錄——“$(dir)/file”那么就完蛋了。
還有一個比較有用的操作符是“?=”，先看示例：
FOO ?= bar
其含義是，如果 FOO 沒有被定義過，那么變量 FOO 的值就是“bar”，如果 FOO 先前被定義
過，那么這條語將什么也不做，其等價(jià)于：
ifeq ($(origin FOO), undefined)
FOO = bar
endif
三、變量高級用法

這里介紹兩種變量的高級使用方法，第一種是變量值的替換。我們可以替換變量中的共有的
部分，其格式是“$(var:a=b)”或是“${var:a=b}”，其意思是，把變量“var”中所有以
“a”字串“結(jié)尾”的“a”替換成“b”字串。這里的“結(jié)尾”意思是“空格”或是“結(jié)束
符”。

還是看一個示例吧：
foo := a.o b.o c.o
bar := $(foo:.o=.c)
這個示例中，我們先定義了一個“$(foo)”變量，而第二行的意思是把“$(foo)”中所
有以“.o”字串“結(jié)尾”全部替換成“.c”，所以我們的“$(bar)”的值就是“a.c b.c
c.c”。
另外一種變量替換的技術(shù)是以“靜態(tài)模式”（參見前面章節(jié)）定義的，如：
foo := a.o b.o c.o
bar := $(foo:%.o=%.c)
這依賴于被替換字串中的有相同的模式，模式中必須包含一個“%”字符，這個例子同
樣讓$(bar)變量的值為“a.c b.c c.c”。
第二種高級用法是——“把變量的值再當(dāng)成變量”。先看一個例子：
第 34 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓

x = y
y = z
a := $($(x))
在這個例子中，$(x)的值是“y”，所以$($(x))就是$(y)，于是$(a)的值就是“z”。（注意，
是“x=y”，而不是“x=$(y)”）

我們還可以使用更多的層次：
x = y
y = z
z = u
a := $($($(x)))

這里的$(a)的值是“u”，相關(guān)的推導(dǎo)留給讀者自己去做吧。
讓我們再復(fù)雜一點(diǎn)，使用上“在變量定義中使用變量”的第一個方式，來看一個例子：
x = $(y)
y = z
z = Hello
a := $($(x))

這里的$($(x))被替換成了$($(y))，因?yàn)?(y)值是“z”，所以，最終結(jié)果是：a:=$(z)，也
就是“Hello”。
再復(fù)雜一點(diǎn)，我們再加上函數(shù)：
x = variable1
variable2 := Hello
y = $(subst 1,2,$(x))
z = y
a := $($($(z)))

這 個 例 子 中 ， “$($($(z)))” 擴(kuò) 展 為 “$($(y))” ， 而 其 再 次 被 擴(kuò) 展 為 “$($(subst
1,2,$(x)))”。$(x)的值是“variable1”，subst 函數(shù)把“variable1”中的所有“1”字
串替換成“2”字串，于是，“variable1”變成“variable2”，再取其值，所以，最終，
$(a)的值就是$(variable2)的值——“Hello”。（喔，好不容易）

在這種方式中，或要可以使用多個變量來組成一個變量的名字，然后再取其值：
first_second = Hello
a = first
第 35 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
b = second
all = $($a_$b)

這里的“$a_$b”組成了“first_second”，于是，$(all)的值就是“Hello”。
再來看看結(jié)合第一種技術(shù)的例子：
a_objects := a.o b.o c.o
1_objects := 1.o 2.o 3.o
sources := $($(a1)_objects:.o=.c)
這個例子中，如果$(a1)的值是“a”的話，那么，$(sources)的值就是“a.c b.c c.c”；
如果$(a1)的值是“1”，那么$(sources)的值是“1.c 2.c 3.c”。

再來看一個這種技術(shù)和“函數(shù)”與“條件語句”一同使用的例子：
ifdef do_sort
func := sort
else
func := strip
endif

bar := a d b g q c
foo := $($(func) $(bar))
這個示例中，如果定義了“do_sort”，那么：foo := $(sort a d b g q c)，于是$(foo)
的值就是“a b c d g q”，而如果沒有定義“do_sort”，那么：foo := $(sort a d bg q
c)，調(diào)用的就是 strip 函數(shù)。
當(dāng)然，“把變量的值再當(dāng)成變量”這種技術(shù)，同樣可以用在操作符的左邊：
dir = foo
$(dir)_sources := $(wildcard $(dir)/*.c)
define $(dir)_print
lpr $($(dir)_sources)
endef

這個例子中定義了三個變量：“dir”，“foo_sources”和“foo_print”。
第 36 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
四、追加變量值

我們可以使用“+=”操作符給變量追加值，如：
objects = main.o foo.o bar.o utils.o
objects += another.o
于是，我們的$(objects)值變成：“main.o foo.o bar.o utils.o another.o”（another.o
被追加進(jìn)去了）

使用“+=”操作符，可以模擬為下面的這種例子：
objects = main.o foo.o bar.o utils.o
objects := $(objects) another.o
所不同的是，用“+=”更為簡潔。
如果變量之前沒有定義過，那么，“+=”會自動變成“=”，如果前面有變量定義，那么“+=”
會繼承于前次操作的賦值符。如果前一次的是“:=”，那么“+=”會以“:=”作為其賦值符，
如：

variable := value
variable += more
等價(jià)于：
variable := value
variable := $(variable) more
但如果是這種情況：
variable = value
variable += more
由于前次的賦值符是“=”，所以“+=”也會以“=”來做為賦值，那么豈不會發(fā)生變量的遞
補(bǔ)歸定義，這是很不好的，所以 make 會自動為我們解決這個問題，我們不必?fù)?dān)心這個問題。

五、override 指示符

如果有變量是通常make 的命令行參數(shù)設(shè)置的，那么Makefile 中對這個變量的賦值會被忽略。
第 37 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
如果你想在 Makefile 中設(shè)置這類參數(shù)的值，那么，你可以使用“override”指示符。其語
法是：

override <variable> = <value>
override <variable> := <value>
當(dāng)然，你還可以追加：
override <variable> += <more text>
對于多行的變量定義，我們用 define 指示符，在 define 指示符前，也同樣可以使用 ovveride
指示符，如：

override define foo
bar
endef
六、多行變量
還有一種設(shè)置變量值的方法是使用 define 關(guān)鍵字。使用 define 關(guān)鍵字設(shè)置變量的值可
以有換行，這有利于定義一系列的命令（前面我們講過“命令包”的技術(shù)就是利用這個關(guān)鍵
字）。

define 指示符后面跟的是變量的名字，而重起一行定義變量的值，定義是以 endef 關(guān)
鍵字結(jié)束。其工作方式和“=”操作符一樣。變量的值可以包含函數(shù)、命令、文字，或是其
它變量。因?yàn)槊钚枰訹Tab]鍵開頭，所以如果你用 define 定義的命令變量中沒有以[Tab]
鍵開頭，那么 make 就不會把其認(rèn)為是命令。

下面的這個示例展示了 define 的用法：
define two-lines
echo foo
echo $(bar)
endef