來自陳浩的一片老文，但絕對營養。
示例工程：3 個頭文件*.h，和 8 個 C 文件*.c。
初
編譯過程，源文件首先會生成中間目標文件，再由中間目標文件生成執行文件。在編譯時，編譯器只檢測程序語法，和函數、變量是否被聲明。如果函數未被聲明，編譯器會給出一個警告，但可以生成 Object File。而在鏈接程序時，鏈接器會在所有的 Object File 中找尋函數的實現，如果找不到，那到就會報鏈接錯誤碼（Linker Error）。
- Makefile規則:
//target: 目標文件
//prerequisites: 依賴文件
//command: 執行命令
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)
- 自動推導(隱晦規則)
只要make看到一個*.o文件，它就會自動的把*.c文件加在依賴關系中，.PHONY偽目標文件。
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)
- 清空目標文件
一般做法，
clean:
rm edit $(objects)
推薦做法，
.PHONY : clean
clean :
-rm edit $(objects)
.PHONY表示 clean 是一個“偽目標”，-rm 是某些文件出現問題，但不要管，繼續做后面的事，clean的規則放在文件的最后”。
細節
Makefile 里主要包含了五個東西：顯式規則、隱晦規則、變量定義、文件指示和注釋。在 Makefile 中的命令，必須要以[Tab]鍵開始。
- 顯式規則
顯式規則說明了，如何生成一個或多的的目標文件。這是由 Makefile 的書寫者明顯指出，要生成的文件，文件的依賴文件，生成的命令。 - 隱晦規則
由于我們的make有自動推導的功能，所以隱晦的規則可以讓我們比較粗糙地簡略地書寫Makefile，這是由make所支持的。 - 變量的定義
在Makefile中我們要定義一系列的變量，變量一般都是字符串，這個有點你 C 語言中的宏，當Makefile被執行時，其中的變量都會被擴展到相應的引用位置上。 - 文件指示
- 在一個
Makefile中引用另一個Makefile，就像 C 語言中的include一樣； - 根據某些情況指定
Makefile中的有效部分，就像 C 語言中的預編譯#if一樣； - 定義一個多行的命令。
- 注釋
Makefile中只有行注釋，和 UNIX 的 Shell 腳本一樣，其注釋是用#字符。如果你要在你的 Makefile 中使用#字符，可以用反斜框進行轉義，如：\#。
Makefile 文件名
默認的情況下，make命令會在當前目錄下按順序為GNUmakefile、makefile、Makefile的文件，推薦Makefile。make -f[--file]參數,指定特定的Makefile。引用Makefile
include <filename>
<filename>可以是當前操作系統Shell的文件模式（可以保含路徑和通配符）,在include前面可以有一些空字符，不能是[Tab]鍵。include和<filename>用一個或多個空格隔開。例，
bar = e.mk f.mk
include foo.make *.mk $(bar)
等價于，
include foo.make a.mk b.mk c.mk e.mk f.mk
make 命令開始時，把include 所指出的其它 Makefile安置在當前
的位。如果文件都沒有指定絕對路徑或是相對路徑的話，make 會在當前目錄下首先尋找，如果當前目錄下沒有找到，那么，make 還會在下面的幾個目錄下找：
- 如果
make執行時，有-I或--include-dir參數，那么make就會在這個參數所指定的目錄下去尋找。 - 如果目錄
<prefix>/include（一般是：/usr/local/bin或/usr/include）存在的話，make也會去找。如果有文件沒有找到的話，make會生成一條警告信息，繼續載入其它的文件，一旦完成Makefile的讀取，make會再重試這些沒有找到，或是不能讀取的文件，如果還是不行，make才會出現一條致命信息。在include前加一個減號-，如：-include <filename>其表示，無論include過程中出現什么錯誤，都不要報錯繼續執行。其它版本make兼容的相關命令是sinclude。
環境變量
MAKEFILES
如果你的當前環境中定義了環境變量MAKEFILES，那么，make 會把這個變量中的值做一個類似于include的動作。這個變量中的值是其它的Makefile，用空格分隔。
** 建議不要使用這個環境變量。 **-
make 的工作方式
GNU的make工作時的執行步驟入下：- 讀入所有的 Makefile
- 讀入被 include 的其它 Makefile
- 初始化文件中的變量
- 推導隱晦規則，并分析所有規則
- 為所有的目標文件創建依賴關系鏈
- 根據依賴關系，決定哪些目標要重新生成
- 執行生成命令
1-5 步為第一個階段，6-7 為第二個階段。第一個階段中，如果定義的變量出現在依賴關系的規則中，那么僅當這條依賴被決定要使用了，變量才會在其內部展開。
書寫規則
規則包含兩個部分，一個是依賴關系，一個是生成目標的方法。
在 Makefile 中，第一條規則中的目標將被確立為最終的目標。
一、規則舉例
foo.o : foo.c defs.h # foo 模塊
cc -c -g foo.c
foo.o 是我們的目標，foo.c和 defs.h 是目標所依賴的源文件，而只有一個命令cc -c -g foo.c（以Tab 鍵開頭）。
- 文件的依賴關系，
foo.o依賴于foo.c和defs.h的文件，如果foo.c和defs.h的文件日期要比foo.o文件日期要新，或是foo.o不存在，那么依賴關系發生。 - 如果生成（或更新）
foo.o文件。也就是那個cc命令，其說明了，如何生成foo.o這個文件。
二、規則的語法
targets : prerequisites
command
或是這樣：
targets : prerequisites ; command
command
targets 是文件名，以空格分開，可以使用通配符。一般來說，我們的目標基本上是一個文件，但也有可能是多個文件。command 是命令行，如果其不與target:prerequisites在一行，那么，必須以[Tab]開頭，如果和 prerequisites 在一行，那么可以用;做為分隔。 prerequisites也就是目標所依賴的文件（或依賴目標）。如果其中的某個文件要比目標文件要新，那么， 目標就被認為是“過時的”，被認為是需要重生成的。
如果命令太長，你可以使用反斜框（\）作為換行符。make 對一行上有多少個字符沒有限制。規則告訴 make 兩件事，文件的依賴關系和如何成成目標文件。
三、在規則中使用通配符
如果我們想定義一系列比較類似的文件，我們很自然地就想起使用通配符。make 支持三各通配符：*，?和[...]。這是和 Unix 的 B-Shell 是相同的。 波浪號（~）字符在文件名中也有比較特殊的用途。如果是“~/test，這就表示當前用戶的$HOME 目錄下的 test 目錄。而~hchen/test則表示用戶 hchen 的宿主目錄下的 test 目錄。而在 Windows 或是 MS-DOS 下，用戶沒有宿主目錄，那么波浪號所指的目錄則根據環境變量HOME而定。
通配符代替了你一系列的文件，如*.c表示所以后綴為 c 的文件用轉義字符\，如\*來表示真實的*字符。
例：
clean:
rm -f *.o
print: *.c
lpr -p $?
touch print
這個例子說明了通配符也可以在我們的規則中，目標 print 依賴于所有的.c文件。其中的$?是一個自動化變量。
objects = *.o
上面這個例子，表示了，通符同樣可以用在變量中。并不是說*.o會展開，不！objects的值就是*.o。如果要讓通配符在變量中展開，也就是讓 objects 的值是所有.o的文件名的集合，那么，你可以這樣：
objects := $(wildcard *.o)
這種用法由關鍵字wildcard指出，關于 Makefile 的關鍵字。
四、文件搜尋
Makefile 文件中的變量VPATH，如果沒有指明這個變量，make 只會在當前的目錄中去找尋依賴文件和目標文件。如果定義了這個變量，那么，make就會在當當前目錄找不到的情況下，到所指定的目錄中去找尋文件了。
VPATH = src:../headers
上面的的定義指定兩個目錄，src和../headers，make 會按照這個順序進行搜索。目錄由:分隔。
另一個設置文件搜索路徑的方法是使用 make 的vpath關鍵字，不是變量，這是一個 make 的關鍵字，可以指定不同的文件在不同的搜索目錄中。這是一個很靈活的功能。它的使用方法有三種：
-
vpath <pattern> <directories>
為符合模式<pattern>的文件指定搜索目錄<directories>。 -
vpath <pattern>
清除符合模式<pattern>的文件的搜索目錄。 -
vpath
清除所有已被設置好了的文件搜索目錄。
vapth 使用方法中的<pattern>需要包含%字符匹配零或若干字符，例如 ， %.h表示所有以 .h結 尾 的 文 件 。<pattern>指 定 了 要 搜 索 的 文 件 集 ， 而 <directories>則指定了<pattern>的文件集的搜索的目錄。例如：vpath %.h ../headers，要求 make 在../headers目錄下搜索所有以.h結尾的文件。
我們可以連續地使用 vpath 語句，以指定不同搜索策略。如果連續的 vpath 語句中出現了相同的<pattern>，或是被重復了的<pattern>，那么，make 會按照 vpath 語句的先后順序來執行搜索。如：
vpath %.c foo
vpath % blish
vpath %.c bar
其表示.c結尾的文件，先在foo目錄，然后是blish，最后是bar目錄。
vpath %.c foo:bar
vpath % blish
而上面的語句則表示.c結尾的文件，先在foo目錄，然后是bar目錄，最后才是blish目錄。
偽目標
最早先的一個例子中，我們提到過一個“clean”的目標，這是一個“偽目標”，
clean:
rm *.o temp
正像我們前面例子中的“clean”一樣，即然我們生成了許多文件編譯文件，我們也應
該提供一個清除它們的“目標”以備完整地重編譯而用。 （以“make clean”來使用該目
標）
因為，我們并不生成“clean”這個文件。“偽目標”并不是一個文件，只是一個標簽，
由于“偽目標”不是文件，所以 make 無法生成它的依賴關系和決定它是否要執行。我們只
有通過顯示地指明這個“目標”才能讓其生效。當然，“偽目標”的取名不能和文件名重名，
不然其就失去了“偽目標”的意義了。
當然，為了避免和文件重名的這種情況，我們可以使用一個特殊的標記“.PHONY”來顯
示地指明一個目標是“偽目標”，向 make 說明，不管是否有這個文件，這個目標就是“偽
目標”。
.PHONY : clean
只要有這個聲明，不管是否有“clean”文件，要運行“clean”這個目標，只有“make
clean”這樣。于是整個過程可以這樣寫：
第 20 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
.PHONY: clean
clean:
rm *.o temp
偽目標一般沒有依賴的文件。但是，我們也可以為偽目標指定所依賴的文件。偽目標同
樣可以作為“默認目標”，只要將其放在第一個。一個示例就是，如果你的 Makefile 需要
一口氣生成若干個可執行文件，但你只想簡單地敲一個 make 完事，并且，所有的目標文件
都寫在一個 Makefile 中，那么你可以使用“偽目標”這個特性：
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 中的第一個目標會被作為其默認目標。我們聲明了一個“all”的
偽目標，其依賴于其它三個目標。由于偽目標的特性是，總是被執行的，所以其依賴的那三
個目標就總是不如“all”這個目標新。所以，其它三個目標的規則總是會被決議。也就達
到了我們一口氣生成多個目標的目的。“.PHONY : all”聲明了“all”這個目標為“偽目
標”。
隨便提一句，從上面的例子我們可以看出，目標也可以成為依賴。所以，偽目標同樣也
可成為依賴。看下面的例子：
.PHONY: cleanall cleanobj cleandiff
cleanall : cleanobj cleandiff
rm program
cleanobj :
rm *.o
cleandiff :
rm *.diff
“make clean”將清除所有要被清除的文件。“cleanobj”和“cleandiff”這兩個偽
目標有點像“子程序”的意思。我們可以輸入“make cleanall”和“make cleanobj”和
“make cleandiff”命令來達到清除不同種類文件的目的。
第 21 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
六、多目標
Makefile 的規則中的目標可以不止一個，其支持多目標，有可能我們的多個目標同時依賴
于一個文件，并且其生成的命令大體類似。于是我們就能把其合并起來。當然，多個目標的
生成規則的執行命令是同一個，這可能會可我們帶來麻煩，不過好在我們的可以使用一個自
動化變量“$@”（關于自動化變量，將在后面講述），這個變量表示著目前規則中所有的目
標的集合，這樣說可能很抽象，還是看一個例子吧。
bigoutput littleoutput : text.g
generate text.g -$(subst output,,$@) > $@
上述規則等價于：
bigoutput : text.g
generate text.g -big > bigoutput
littleoutput : text.g
generate text.g -little > littleoutput
其中，-$(subst output,,$@)中的“$”表示執行一個 Makefile 的函數，函數名為 subst，
后面的為參數。關于函數，將在后面講述。這里的這個函數是截取字符串的意思，“$@”表
示目標的集合，就像一個數組，“$@”依次取出目標，并執于命令。
七、靜態模式
靜態模式可以更加容易地定義多目標的規則，可以讓我們的規則變得更加的有彈性和靈
活
。我們還是先來看一下語法：
<targets ...>: <target-pattern>: <prereq-patterns ...>
<commands>
....
targets 定義了一系列的目標文件，可以有通配符。是目標的一個集合。
target-parrtern 是指明了 targets 的模式，也就是的目標集模式。
prereq-parrterns 是目標的依賴模式，它對 target-parrtern 形成的模式再進行一次依賴
目標的定義。
這樣描述這三個東西，可能還是沒有說清楚，還是舉個例子來說明一下吧。如果我們的
第 22 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
<target-parrtern>定義成“%.o”，意思是我們的<target>集合中都是以“.o”結尾的，而
如果我們的<prereq-parrterns>定義成“%.c”，意思是對<target-parrtern>所形成的目標
集進行二次定義，其計算方法是，取<target-parrtern>模式中的“%”（也就是去掉了[.o]
這個結尾），并為其加上[.c]這個結尾，形成的新集合。
所以，我們的“目標模式”或是“依賴模式”中都應該有“%”這個字符，如果你的文
件名中有“%”那么你可以使用反斜杠“\”進行轉義，來標明真實的“%”字符。
看一個例子：
objects = foo.o bar.o
all: $(objects)
$(objects): %.o: %.c
$(CC) -c $(CFLAGS) {1}lt; -o $@
上面的例子中，指明了我們的目標從$object 中獲取，“%.o”表明要所有以“.o”結
尾的目標，也就是“foo.o bar.o”，也就是變量$object 集合的模式，而依賴模式“%.c”
則取模式“%.o”的“%”，也就是“foo bar”，并為其加下“.c”的后綴，于是，我們的
依賴目標就是“foo.c bar.c”。而命令中的“{1}lt;”和“$@”則是自動化變量，“{1}lt;”表示
所有的依賴目標集（也就是“foo.c bar.c”），“$@”表示目標集（也就是“foo.o bar.o”）。
于是，上面的規則展開后等價于下面的規則：
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”有幾百個，那種我們只要用這種很簡單的“靜態模式規則”
就可以寫完一堆規則，實在是太有效率了。“靜態模式規則”的用法很靈活，如果用得好，
那會一個很強大的功能。再看一個例子：
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))表示調用 Makefile 的 filter 函數，過濾“$filter”集，只要其
中模式為“%.o”的內容。其的它內容，我就不用多說了吧。這個例字展示了 Makefile 中更
大的彈性。
第 23 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
八、自動生成依賴性
在 Makefile 中，我們的依賴關系可能會需要包含一系列的頭文件，比如，如果我們的 main.c
中有一句“#include "defs.h"”，那么我們的依賴關系應該是：
main.o : main.c defs.h
但是，如果是一個比較大型的工程，你必需清楚哪些 C 文件包含了哪些頭文件，并且，
你在加入或刪除頭文件時，也需要小心地修改 Makefile，這是一個很沒有維護性的工作。
為了避免這種繁重而又容易出錯的事情，我們可以使用 C/C++編譯的一個功能。大多數的
C/C++編譯器都支持一個“-M”的選項，即自動找尋源文件中包含的頭文件，并生成一個依
賴關系。例如，如果我們執行下面的命令：
cc -M main.c
其輸出是：
main.o : main.c defs.h
于是由編譯器自動生成的依賴關系，這樣一來，你就不必再手動書寫若干文件的依賴關
系，而由編譯器自動生成了。需要提醒一句的是，如果你使用 GNU 的 C/C++編譯器，你得用
“-MM”參數，不然，“-M”參數會把一些標準庫的頭文件也包含進來。
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 聯系在一起呢。因為這樣一來，我們
的 Makefile 也要根據這些源文件重新生成，讓 Makefile 自已依賴于源文件？這個功能并不
現實，不過我們可以有其它手段來迂回地實現這一功能。GNU 組織建議把編譯器為每一個源
第 24 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
文 件 的 自 動 生 成 的 依 賴 關 系 放 到 一 個 文 件 中 ， 為 每 一 個 “name.c” 的 文 件 都 生 成 一 個
“name.d”的 Makefile 文件，[.d]文件中就存放對應[.c]文件的依賴關系。于是，我們可
以寫出[.c]文件和[.d]文件的依賴關系，并讓 make 自動更新或自成[.d]文件，并把其包含
在我們的主 Makefile 中，這樣，我們就可以自動化地生成每個文件的依賴關系了。
這里，我們給出了一個模式規則來產生[.d]文件：
%.d: %.c
@set -e; rm -f $@; \
$(CC) -M $(CPPFLAGS) {1}lt; > $@.$$; \
sed 's,$?.o[ :]*,\1.o $@ : ,g' < $@.$$ > $@; \
rm -f $@.$$
這個規則的意思是，所有的[.d]文件依賴于[.c]文件，“rm -f $@”的意思是刪除所有
的目標，也就是[.d]文件，第二行的意思是，為每個依賴文件“{1}lt;”，也就是[.c]文件生成
依賴文件，“$@”表示模式“%.d”文件，如果有一個 C 文件是 name.c，那么“%”就是
“name”，“$$”意為一個隨機編號，第二行生成的文件有可能是“name.d.12345”，第
三行使用 sed 命令做了一個替換，關于 sed 命令的用法請參看相關的使用文檔。第四行就是
刪除臨時文件。
總而言之，這個模式要做的事就是在編譯器生成的依賴關系中加入[.d]文件的依賴，即
把依賴關系：
main.o : main.c defs.h
轉成：
main.o main.d : main.c defs.h
于是，我們的[.d]文件也會自動更新了，并會自動生成了，當然，你還可以在這個[.d]
文件中加入的不只是依賴關系，包括生成的命令也可一并加入，讓每個[.d]文件都包含一個
完賴的規則。一旦我們完成這個工作，接下來，我們就要把這些自動生成的規則放進我們的
主 Makefile 中。我們可以使用 Makefile 的“include”命令，來引入別的 Makefile 文件（前
面講過），例如：
sources = foo.c bar.c
include $(sources:.c=.d)
上 述 語 句 中 的 “$(sources:.c=.d)” 中 的 “.c=.d” 的 意 思 是 做 一 個 替 換 ， 把 變 量
$(sources)所有[.c]的字串都替換成[.d]，關于這個“替換”的內容，在后面我會有更為詳
細的講述。當然，你得注意次序，因為 include 是按次來載入文件，最先載入的[.d]文件中
的目標會成為默認目標。
第六部分 書寫命令
第 25 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
每條規則中的命令和操作系統 Shell 的命令行是一致的。make 會一按順序一條一條的
執行命令，每條命令的開頭必須以[Tab]鍵開頭，除非，命令是緊跟在依賴規則后面的分號
后的。在命令行之間中的空格或是空行會被忽略，但是如果該空格或空行是以 Tab 鍵開頭的，
那么 make 會認為其是一個空命令。
我 們 在 UNIX 下 可 能 會 使 用 不 同 的 Shell ， 但 是 make 的 命 令 默 認 是 被
“/bin/sh”——UNIX 的標準 Shell 解釋執行的。除非你特別指定一個其它的 Shell。
Makefile 中，“#”是注釋符，很像 C/C++中的“//”，其后的本行字符都被注釋。
一、顯示命令
通常，make 會把其要執行的命令行在命令執行前輸出到屏幕上。當我們用“@”字符在
命令行前，那么，這個命令將不被 make 顯示出來，最具代表性的例子是，我們用這個功能
來像屏幕顯示一些信息。如：
@echo 正在編譯 XXX 模塊......
當 make 執行時，會輸出“正在編譯 XXX 模塊......”字串，但不會輸出命令，如果沒
有“@”，那么，make 將輸出：
echo 正在編譯 XXX 模塊......
正在編譯 XXX 模塊......
如果 make 執行時，帶入 make 參數“-n”或“--just-print”，那么其只是顯示命令，
但不會執行命令，這個功能很有利于我們調試我們的 Makefile，看看我們書寫的命令是執
行起來是什么樣子的或是什么順序的。
而 make 參數“-s”或“--slient”則是全面禁止命令的顯示。
二、命令執行
當依賴目標新于目標時，也就是當規則的目標需要被更新時，make 會一條一條的執行
其后的命令。需要注意的是，如果你要讓上一條命令的結果應用在下一條命令時，你應該使
用分號分隔這兩條命令。比如你的第一條命令是 cd 命令，你希望第二條命令得在 cd 之后的
基礎上運行，那么你就不能把這兩條命令寫在兩行上，而應該把這兩條命令寫在一行上，用
分號分隔。如：
示例一：
exec:
cd /home/hchen
pwd
第 26 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
示例二：
exec:
cd /home/hchen; pwd
當我們執行“make exec”時，第一個例子中的 cd 沒有作用，pwd 會打印出當前的
Makefile 目錄，而第二個例子中，cd 就起作用了，pwd 會打印出“/home/hchen”。make
一般是使用環境變量 SHELL 中所定義的系統 Shell 來執行命令，默認情況下使用 UNIX 的
標準 Shell——/bin/sh 來執行命令。但在 MS-DOS 下有點特殊，因為 MS-DOS 下沒有 SHELL
環境變量，當然你也可以指定。如果你指定了 UNIX 風格的目錄形式，首先，make 會在 SHELL
所指定的路徑中找尋命令解釋器，如果找不到，其會在當前盤符中的當前目錄中尋找，如果
再找不到，其會在 PATH 環境變量中所定義的所有路徑中尋找。MS-DOS 中，如果你定義的命
令解釋器沒有找到，其會給你的命令解釋器加上諸如“.exe”、“.com”、“.bat”、“.sh”
等后綴。
三、命令出錯
每當命令運行完后，make 會檢測每個命令的返回碼，如果命令返回成功，那么 make 會
執行下一條命令，當規則中所有的命令成功返回后，這個規則就算是成功完成了。如果一個
規則中的某個命令出錯了（命令退出碼非零），那么 make 就會終止執行當前規則，這將有可
能終止所有規則的執行。
有些時候，命令的出錯并不表示就是錯誤的。例如 mkdir 命令，我們一定需要建立一個
目錄，如果目錄不存在，那么 mkdir 就成功執行，萬事大吉，如果目錄存在，那么就出錯了。
我們之所以使用 mkdir 的意思就是一定要有這樣的一個目錄，于是我們就不希望 mkdir 出錯
而終止規則的運行。
為了做到這一點，忽略命令的出錯，我們可以在 Makefile 的命令行前加一個減號“-”
（在 Tab 鍵之后），標記為不管命令出不出錯都認為是成功的。如：
clean:
-rm -f *.o
還有一個全局的辦法是，給 make 加上“-i”或是“--ignore-errors”參數，那么，
Makefile 中所有命令都會忽略錯誤。而如果一個規則是以“.IGNORE”作為目標的，那么這
個規則中的所有命令將會忽略錯誤。這些是不同級別的防止命令出錯的方法，你可以根據你
的不同喜歡設置。
還有一個要提一下的 make 的參數的是“-k”或是“--keep-going”，這個參數的意思
是，如果某規則中的命令出錯了，那么就終目該規則的執行，但繼續執行其它規則。
第 27 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
四、嵌套執行 make
在一些大的工程中，我們會把我們不同模塊或是不同功能的源文件放在不同的目錄中，
我們可以在每個目錄中都書寫一個該目錄的 Makefile，這有利于讓我們的 Makefile 變得更
加地簡潔，而不至于把所有的東西全部寫在一個 Makefile 中，這樣會很難維護我們的
Makefile，這個技術對于我們模塊編譯和分段編譯有著非常大的好處。
例如，我們有一個子目錄叫 subdir，這個目錄下有個 Makefile 文件，來指明了這個目
錄下文件的編譯規則。那么我們總控的 Makefile 可以這樣書寫：
subsystem:
cd subdir && $(MAKE)
其等價于：
subsystem:
$(MAKE) -C subdir
定義$(MAKE)宏變量的意思是，也許我們的 make 需要一些參數，所以定義成一個變量比
較利于維護。這兩個例子的意思都是先進入“subdir”目錄，然后執行 make 命令。
我們把這個 Makefile 叫做“總控 Makefile”，總控 Makefile 的變量可以傳遞到下級
的 Makefile 中（如果你顯示的聲明），但是不會覆蓋下層的 Makefile 中所定義的變量，除
非指定了“-e”參數。
如果你要傳遞變量到下級 Makefile 中，那么你可以使用這樣的聲明：
export <variable ...>
如果你不想讓某些變量傳遞到下級 Makefile 中，那么你可以這樣聲明：
unexport <variable ...>
如：
示例一：
export variable = value
其等價于：
variable = value
export variable
第 28 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
其等價于：
export variable := value
其等價于：
variable := value
export variable
示例二：
export variable += value
其等價于：
variable += value
export variable
如果你要傳遞所有的變量，那么，只要一個 export 就行了。后面什么也不用跟，表示
傳遞所有的變量。
需要注意的是，有兩個變量，一個是 SHELL，一個是 MAKEFLAGS，這兩個變量不管你是
否 export，其總是要傳遞到下層 Makefile 中，特別是 MAKEFILES 變量，其中包含了 make
的參數信息，如果我們執行“總控 Makefile”時有 make 參數或是在上層 Makefile 中定義
了這個變量，那么 MAKEFILES 變量將會是這些參數，并會傳遞到下層 Makefile 中，這是一
個系統級的環境變量。
但是 make 命令中的有幾個參數并不往下傳遞，它們是“-C”,“-f”,“-h”“-o”和
“-W”（有關 Makefile 參數的細節將在后面說明），如果你不想往下層傳遞參數，那么，你
可以這樣來：
subsystem:
cd subdir && $(MAKE) MAKEFLAGS=
如果你定義了環境變量 MAKEFLAGS，那么你得確信其中的選項是大家都會用到的，如果
其中有“-t”,“-n”,和“-q”參數，那么將會有讓你意想不到的結果，或許會讓你異常地
恐慌。
還有一個在“嵌套執行”中比較有用的參數，“-w”或是“--print-directory”會在
make 的過程中輸出一些信息，讓你看到目前的工作目錄。比如，如果我們的下級 make 目錄
是“/home/hchen/gnu/make”，如果我們使用“make -w”來執行，那么當進入該目錄時，
我們會看到：
第 29 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
make: Entering directory `/home/hchen/gnu/make'.
而在完成下層 make 后離開目錄時，我們會看到：
make: Leaving directory `/home/hchen/gnu/make'
當你使用“-C”參數來指定 make 下層 Makefile 時，“-w”會被自動打開的。如果參數中有
“-s”（“--slient”）或是“--no-print-directory”，那么，“-w”總是失效的。
五、定義命令包
如果 Makefile 中出現一些相同命令序列，那么我們可以為這些相同的命令序列定義一
個變量。定義這種命令序列的語法以“define”開始，以“endef”結束，如：
define run-yacc
yacc $(firstword $^)
mv y.tab.c $@
endef
這里，“run-yacc”是這個命令包的名字，其不要和 Makefile 中的變量重名。在
“define”和“endef”中的兩行就是命令序列。這個命令包中的第一個命令是運行 Yacc
程序，因為 Yacc 程序總是生成“y.tab.c”的文件，所以第二行的命令就是把這個文件改改
名字。還是把這個命令包放到一個示例中來看看吧。
foo.c : foo.y
$(run-yacc)
我們可以看見，要使用這個命令包，我們就好像使用變量一樣。在這個命令包的使用中，
命令包“run-yacc”中的“$^”就是“foo.y”，“$@”就是“foo.c”（有關這種以“$”
開頭的特殊變量，我們會在后面介紹），make 在執行命令包時，命令包中的每個命令會被依
次獨立執行。
第七部分 使用變量
在 Makefile 中的定義的變量，就像是 C/C++語言中的宏一樣，他代表了一個文本字串，
在 Makefile 中執行的時候其會自動原模原樣地展開在所使用的地方。其與 C/C++所不同的
是，你可以在 Makefile 中改變其值。在 Makefile 中，變量可以使用在“目標”，“依賴目
標”，“命令”或是 Makefile 的其它部分中。
變量的命名字可以包含字符、數字，下劃線（可以是數字開頭），但不應該含有“:”、
第 30 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
“#”、“=”或是空字符（空格、回車等）。變量是大小寫敏感的，“foo”、“Foo”和“FOO”
是三個不同的變量名。傳統的 Makefile 的變量名是全大寫的命名方式，但我推薦使用大小
寫搭配的變量名，如：MakeFlags。這樣可以避免和系統的變量沖突，而發生意外的事情。
有一些變量是很奇怪字串，如“{1}lt;”、“$@”等，這些是自動化變量，我會在后面介紹。
一、變量的基礎
變量在聲明時需要給予初值，而在使用時，需要給在變量名前加上“$”符號，但最好
用小括號“（）”或是大括號“{}”把變量給包括起來。如果你要使用真實的“$”字符，
那么你需要用“$”來表示。
變量可以使用在許多地方，如規則中的“目標”、“依賴”、“命令”以及新的變量中。先
看一個例子：
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
當然，千萬不要在你的 Makefile 中這樣干，這里只是舉個例子來表明 Makefile 中的變
量在使用處展開的真實樣子。可見其就是一個“替代”的原理。
另外，給變量加上括號完全是為了更加安全地使用這個變量，在上面的例子中，如果你
不想給變量加上括號，那也可以，但我還是強烈建議你給變量加上括號。
第 31 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
二、變量中的變量
在定義變量的值時，我們可以使用其它變量來構造變量的值，在 Makefile 中有兩種方
式來在用變量定義變量的值。
先看第一種方式，也就是簡單的使用“=”號，在“=”左側是變量，右側是變量的值，右側
變量的值可以定義在文件的任何一處，也就是說，右側中的變量不一定非要是已定義好的值，
其也可以使用后面定義的值。如：
foo = $(bar)
bar = $(ugh)
ugh = Huh?
all:
echo $(foo)
我們執行“make all”將會打出變量$(foo)的值是“Huh?”（ $(foo)的值是$(bar)，
$(bar)的值是$(ugh)，$(ugh)的值是“Huh?”）可見，變量是可以使用后面的變量來定義的。
這個功能有好的地方，也有不好的地方，好的地方是，我們可以把變量的真實值推到后
面來定義，如：
CFLAGS = $(include_dirs) -O
include_dirs = -Ifoo -Ibar
當“CFLAGS”在命令中被展開時，會是“-Ifoo -Ibar -O”。但這種形式也有不好的地
方，那就是遞歸定義，如：
CFLAGS = $(CFLAGS) -O
或：
A = $(B)
B = $(A)
這會讓 make 陷入無限的變量展開過程中去，當然，我們的 make 是有能力檢測這樣的定
義，并會報錯。還有就是如果在變量中使用函數，那么，這種方式會讓我們的 make 運行時
非常慢，更糟糕的是，他會使用得兩個 make 的函數“wildcard”和“shell”發生不可預知
的錯誤。因為你不會知道這兩個函數會被調用多少次。
為了避免上面的這種方法，我們可以使用 make 中的另一種用變量來定義變量的方法。
這種方法使用的是“:=”操作符，如：
第 32 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
x := foo
y := $(x) bar
x := later
其等價于：
y := foo bar
x := later
值得一提的是，這種方法，前面的變量不能使用后面的變量，只能使用前面已定義好了的變
量。如果是這樣：
y := $(x) bar
x := foo
那么，y 的值是“bar”，而不是“foo bar”。
上面都是一些比較簡單的變量使用了，讓我們來看一個復雜的例子，其中包括了 make
的函數、條件表達式和一個系統變量“MAKELEVEL”的使用：
ifeq (0,${MAKELEVEL})
cur-dir := $(shell pwd)
whoami := $(shell whoami)
host-type := $(shell arch)
MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}
endif
關于條件表達式和函數，我們在后面再說，對于系統變量“MAKELEVEL”，其意思是，
如果我們的 make 有一個嵌套執行的動作（參見前面的“嵌套使用 make”），那么，這個變
量會記錄了我們的當前 Makefile 的調用層數。
下面再介紹兩個定義變量時我們需要知道的，請先看一個例子，如果我們要定義一個變
量，其值是一個空格，那么我們可以這樣來：
nullstring :=
space := $(nullstring) # end of the line
nullstring 是一個 Empty 變量，其中什么也沒有，而我們的 space 的值是一個空格。因為
在
操作符的右邊是很難描述一個空格的，這里采用的技術很管用，先用一個 Empty 變量來
標明變量的值開始了，而后面采用“#”注釋符來表示變量定義的終止，這樣，我們可以定
義出其值是一個空格的變量。請注意這里關于“#”的使用，注釋符“#”的這種特性值得我
第 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 先前被定義
過，那么這條語將什么也不做，其等價于：
ifeq ($(origin FOO), undefined)
FOO = bar
endif
三、變量高級用法
這里介紹兩種變量的高級使用方法，第一種是變量值的替換。我們可以替換變量中的共有的
部分，其格式是“$(var:a=b)”或是“${var:a=b}”，其意思是，把變量“var”中所有以
“a”字串“結尾”的“a”替換成“b”字串。這里的“結尾”意思是“空格”或是“結束
符”。
還是看一個示例吧：
foo := a.o b.o c.o
bar := $(foo:.o=.c)
這個示例中，我們先定義了一個“$(foo)”變量，而第二行的意思是把“$(foo)”中所
有以“.o”字串“結尾”全部替換成“.c”，所以我們的“$(bar)”的值就是“a.c b.c
c.c”。
另外一種變量替換的技術是以“靜態模式”（參見前面章節）定義的，如：
foo := a.o b.o c.o
bar := $(foo:%.o=%.c)
這依賴于被替換字串中的有相同的模式，模式中必須包含一個“%”字符，這個例子同
樣讓$(bar)變量的值為“a.c b.c c.c”。
第二種高級用法是——“把變量的值再當成變量”。先看一個例子：
第 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”，相關的推導留給讀者自己去做吧。
讓我們再復雜一點，使用上“在變量定義中使用變量”的第一個方式，來看一個例子：
x = $(y)
y = z
z = Hello
a := $($(x))
這里的$($(x))被替換成了$($(y))，因為$(y)值是“z”，所以，最終結果是：a:=$(z)，也
就是“Hello”。
再復雜一點，我們再加上函數：
x = variable1
variable2 := Hello
y = $(subst 1,2,$(x))
z = y
a := $($($(z)))
這 個 例 子 中 ， “$($($(z)))” 擴 展 為 “$($(y))” ， 而 其 再 次 被 擴 展 為 “$($(subst
1,2,$(x)))”。$(x)的值是“variable1”，subst 函數把“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”。
再來看看結合第一種技術的例子：
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”。
再來看一個這種技術和“函數”與“條件語句”一同使用的例子：
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)，調用的就是 strip 函數。
當然，“把變量的值再當成變量”這種技術，同樣可以用在操作符的左邊：
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
被追加進去了）
使用“+=”操作符，可以模擬為下面的這種例子：
objects = main.o foo.o bar.o utils.o
objects := $(objects) another.o
所不同的是，用“+=”更為簡潔。
如果變量之前沒有定義過，那么，“+=”會自動變成“=”，如果前面有變量定義，那么“+=”
會繼承于前次操作的賦值符。如果前一次的是“:=”，那么“+=”會以“:=”作為其賦值符，
如：
variable := value
variable += more
等價于：
variable := value
variable := $(variable) more
但如果是這種情況：
variable = value
variable += more
由于前次的賦值符是“=”，所以“+=”也會以“=”來做為賦值，那么豈不會發生變量的遞
補歸定義，這是很不好的，所以 make 會自動為我們解決這個問題，我們不必擔心這個問題。
五、override 指示符
如果有變量是通常make 的命令行參數設置的，那么Makefile 中對這個變量的賦值會被忽略。
第 37 頁共 78 頁 2005 年 10 月 14 日整理：祝冬華跟我一起寫 Makefile 作者：陳皓
如果你想在 Makefile 中設置這類參數的值，那么，你可以使用“override”指示符。其語
法是：
override <variable> = <value>
override <variable> := <value>
當然，你還可以追加：
override <variable> += <more text>
對于多行的變量定義，我們用 define 指示符，在 define 指示符前，也同樣可以使用 ovveride
指示符，如：
override define foo
bar
endef
六、多行變量
還有一種設置變量值的方法是使用 define 關鍵字。使用 define 關鍵字設置變量的值可
以有換行，這有利于定義一系列的命令（前面我們講過“命令包”的技術就是利用這個關鍵
字）。
define 指示符后面跟的是變量的名字，而重起一行定義變量的值，定義是以 endef 關
鍵字結束。其工作方式和“=”操作符一樣。變量的值可以包含函數、命令、文字，或是其
它變量。因為命令需要以[Tab]鍵開頭，所以如果你用 define 定義的命令變量中沒有以[Tab]
鍵開頭，那么 make 就不會把其認為是命令。
下面的這個示例展示了 define 的用法：
define two-lines
echo foo
echo $(bar)
endef
