跟我一起寫 Makefile

什麼是makefile？或許很多Winodws的程序員都不知道這個東西，因為那些Windows的IDE都
為你做了這個工作，但我覺得要作一個好的和professional的程序員，makefile還是要懂。
這就好像現在有這麼多的HTML的編輯器，但如果你想成為一個專業人士，你還是要了解HTM
L的標識的含義。特別在Unix下的軟體編譯，你就不能不自己寫makefile了，會不會寫makef
ile，從一個側面說明了一個人是否具備完成大型工程的能力。
因為，makefile關係到了整個工程的編譯規則。一個工程中的源文件不計數，其按類型、功
能、模塊分別放在若干個目錄中，makefile定義了一系列的規則來指定，哪些文件需要先編
譯，哪些文件需要后編譯，哪些文件需要重新編譯，甚至於進行更複雜的功能操作，因為ma
kefile就像一個Shell腳本一樣，其中也可以執行操作系統的命令。
makefile帶來的好處就是——「自動化編譯」，一旦寫好，只需要一個make命令，整個工程
完全自動編譯，極大的提高了軟體開發的效率。make是一個命令工具，是一個解釋makefil
e中指令的命令工具，一般來說，大多數的IDE都有這個命令，比如：Delphi的make，Visual
C++的nmake，Linux下GNU的make。可見，makefile都成為了一種在工程方面的編譯方法。
現在講述如何寫makefile的文章比較少，這是我想寫這篇文章的原因。當然，不同產商的ma
ke各不相同，也有不同的語法，但其本質都是在「文件依賴性」上做文章，這裡，我僅對GN
U的make進行講述，我的環境是RedHat Linux 8.0，make的版本是3.80。必竟，這個make是
應用最為廣泛的，也是用得最多的。而且其還是最遵循於IEEE 1003.2-1992 標準的（POSIX
.2）。
在這篇文檔中，將以C/C++的源碼作為我們基礎，所以必然涉及一些關於C/C++的編譯的知識
，相關於這方面的內容，還請各位查看相關的編譯器的文檔。這裡所默認的編譯器是UNIX下
的GCC和CC。
關於程序的編譯和鏈接
——————————
在此，我想多說關於程序編譯的一些規範和方法，一般來說，無論是C、C++、還是pas，首
先要把源文件編譯成中間代碼文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，
即 Object File，這個動作叫做編譯（compile）。然後再把大量的Object File合成執行文
件，這個動作叫作鏈接（link）。
編譯時，編譯器需要的是語法的正確，函數與變數的聲明的正確。對於後者，通常是你需要
告訴編譯器頭文件的所在位置（頭文件中應該只是聲明，而定義應該放在C/C++文件中），
只要所有的語法正確，編譯器就可以編譯出中間目標文件。一般來說，每個源文件都應該對
應於一個中間目標文件（O文件或是OBJ文件）。
鏈接時，主要是鏈接函數和全局變數，所以，我們可以使用這些中間目標文件（O文件或是O
BJ文件）來鏈接我們的應用程序。鏈接器並不管函數所在的源文件，只管函數的中間目標文
件（Object File），在大多數時候，由於源文件太多，編譯生成的中間目標文件太多，而
在鏈接時需要明顯地指出中間目標文件名，這對於編譯很不方便，所以，我們要給中間目標
文件打個包，在Windows下這種包叫「庫文件」（Library File)，也就是 .lib 文件，在UN
IX下，是Archive File，也就是 .a 文件。
總結一下，源文件首先會生成中間目標文件，再由中間目標文件生成執行文件。在編譯時，
編譯器只檢測程序語法，和函數、變數是否被聲明。如果函數未被聲明，編譯器會給出一個
警告，但可以生成Object File。而在鏈接程序時，鏈接器會在所有的Object File中找尋函
數的實現，如果找不到，那到就會報鏈接錯誤碼（Linker Error），在VC下，這種錯誤一般
是：Link 2001錯誤，意思說是說，鏈接器未能找到函數的實現。你需要指定函數的Object
File.
好，言歸正傳，GNU的make有許多的內容，閑言少敘，還是讓我們開始吧。

Makefile 介紹
———————
make命令執行時，需要一個 Makefile 文件，以告訴make命令需要怎麼樣的去編譯和鏈接程
序。
首先，我們用一個示例來說明Makefile的書寫規則。以便給大家一個感興認識。這個示例來
源於GNU的make使用手冊，在這個示例中，我們的工程有8個C文件，和3個頭文件，我們要寫
一個Makefile來告訴make命令如何編譯和鏈接這幾個文件。我們的規則是：
1）如果這個工程沒有編譯過，那麼我們的所有C文件都要編譯並被鏈接。
2）如果這個工程的某幾個C文件被修改，那麼我們只編譯被修改的C文件，並鏈接目標
程序。
3）如果這個工程的頭文件被改變了，那麼我們需要編譯引用了這幾個頭文件的C文件，
並鏈接目標程序。
只要我們的Makefile寫得夠好，所有的這一切，我們只用一個make命令就可以完成，make命
令會自動智能地根據當前的文件修改的情況來確定哪些文件需要重編譯，從而自己編譯所需
要的文件和鏈接目標程序。

一、Makefile的規則
在講述這個Makefile之前，還是讓我們先來粗略地看一看Makefile的規則。
target ... : prerequisites ...
command
...
...
target也就是一個目標文件，可以是Object File，也可以是執行文件。還可以是一個
標籤（Label），對於標籤這種特性，在後續的「偽目標」章節中會有敘述。
prerequisites就是，要生成那個target所需要的文件或是目標。
command也就是make需要執行的命令。（任意的Shell命令）
這是一個文件的依賴關係，也就是說，target這一個或多個的目標文件依賴於prerequisite
s中的文件，其生成規則定義在command中。說白一點就是說，prerequisites中如果有一個
以上的文件比target文件要新的話，command所定義的命令就會被執行。這就是Makefile的
規則。也就是Makefile中最核心的內容。
說到底，Makefile的東西就是這樣一點，好像我的這篇文檔也該結束了。呵呵。還不盡然，
這是Makefile的主線和核心，但要寫好一個Makefile還不夠，我會以後面一點一點地結合我
的工作經驗給你慢慢到來。內容還多著呢。：）

二、一個示例
正如前面所說的，如果一個工程有3個頭文件，和8個C文件，我們為了完成前面所述的那三
個規則，我們的Makefile應該是下面的這個樣子的。
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
反斜杠（\）是換行符的意思。這樣比較便於Makefile的易讀。我們可以把這個內容保存在
文件為「Makefile」或「makefile」的文件中，然後在該目錄下直接輸入命令「make」就可
以生成執行文件edit。如果要刪除執行文件和所有的中間目標文件，那麼，只要簡單地執行
一下「make clean」就可以了。
在這個makefile中，目標文件（target）包含：執行文件edit和中間目標文件（*.o），依
賴文件（prerequisites）就是冒號後面的那些 .c 文件和 .h文件。每一個 .o 文件都有一
組依賴文件，而這些 .o 文件又是執行文件 edit 的依賴文件。依賴關係的實質上就是說明
了目標文件是由哪些文件生成的，換言之，目標文件是哪些文件更新的。
在定義好依賴關係后，後續的那一行定義了如何生成目標文件的操作系統命令，一定要以一
個Tab鍵作為開頭。記住，make並不管命令是怎麼工作的，他只管執行所定義的命令。make
會比較targets文件和prerequisites文件的修改日期，如果prerequisites文件的日期要比t
argets文件的日期要新，或者target不存在的話，那麼，make就會執行後續定義的命令。
這裡要說明一點的是，clean不是一個文件，它只不過是一個動作名字，有點像C語言中的la
ble一樣，其冒號后什麼也沒有，那麼，make就不會自動去找文件的依賴性，也就不會自動
執行其後所定義的命令。要執行其後的命令，就要在make命令后明顯得指出這個lable的名
字。這樣的方法非常有用，我們可以在一個makefile中定義不用的編譯或是和編譯無關的命
令，比如程序的打包，程序的備份，等等。

二、
三、make是如何工作的
在默認的方式下，也就是我們只輸入make命令。那麼，
1、make會在當前目錄下找名字叫「Makefile」或「makefile」的文件。
2、如果找到，它會找文件中的第一個目標文件（target），在上面的例子中，他會找
到「edit」這個文件，並把這個文件作為最終的目標文件。
3、如果edit文件不存在，或是edit所依賴的後面的 .o 文件的文件修改時間要比edit
這個文件新，那麼，他就會執行後面所定義的命令來生成edit這個文件。
4、如果edit所依賴的.o文件也存在，那麼make會在當前文件中找目標為.o文件的依賴
性，如果找到則再根據那一個規則生成.o文件。（這有點像一個堆棧的過程）
5、當然，你的C文件和H文件是存在的啦，於是make會生成 .o 文件，然後再用 .o 文
件生命make的終極任務，也就是執行文件edit了。
這就是整個make的依賴性，make會一層又一層地去找文件的依賴關係，直到最終編譯出第一
個目標文件。在找尋的過程中，如果出現錯誤，比如最後被依賴的文件找不到，那麼make就
會直接退出，並報錯，而對於所定義的命令的錯誤，或是編譯不成功，make根本不理。mak
e只管文件的依賴性，即，如果在我找了依賴關係之後，冒號後面的文件還是不在，那麼對
不起，我就不工作啦。
通過上述分析，我們知道，像clean這種，沒有被第一個目標文件直接或間接關聯，那麼它
後面所定義的命令將不會被自動執行，不過，我們可以顯示要make執行。即命令——「make
clean」，以此來清除所有的目標文件，以便重編譯。
於是在我們編程中，如果這個工程已被編譯過了，當我們修改了其中一個源文件，比如file
.c，那麼根據我們的依賴性，我們的目標file.o會被重編譯（也就是在這個依性關係後面所
定義的命令），於是file.o的文件也是最新的啦，於是file.o的文件修改時間要比edit要新
，所以edit也會被重新鏈接了（詳見edit目標文件后定義的命令）。
而如果我們改變了「command.h」，那麼，kdb.o、command.o和files.o都會被重編譯，並且
，edit會被重鏈接。

四、makefile中使用變數
在上面的例子中，先讓我們看看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
我們可以看到[.o]文件的字元串被重複了兩次，如果我們的工程需要加入一個新的[.o]文件
，那麼我們需要在兩個地方加（應該是三個地方，還有一個地方在clean中）。當然，我們
的makefile並不複雜，所以在兩個地方加也不累，但如果makefile變得複雜，那麼我們就有
可能會忘掉一個需要加入的地方，而導致編譯失敗。所以，為了makefile的易維護，在make
file中我們可以使用變數。makefile的變數也就是一個字元串，理解成C語言中的宏可能會
更好。
比如，我們聲明一個變數，叫objects, OBJECTS, objs, OBJS, obj, 或是 OBJ，反正不管
什麼啦，只要能夠表示obj文件就行了。我們在makefile一開始就這樣定義：
objects = main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
於是，我們就可以很方便地在我們的makefile中以「$(objects)」的方式來使用這個變數了
，於是我們的改良版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)

於是如果有新的 .o 文件加入，我們只需簡單地修改一下 objects 變數就可以了。
關於變數更多的話題，我會在後續給你一一道來。

五、讓make自動推導
GNU的make很強大，它可以自動推導文件以及文件依賴關係後面的命令，於是我們就沒必要
去在每一個[.o]文件后都寫上類似的命令，因為，我們的make會自動識別，並自己推導命令
。
只要make看到一個[.o]文件，它就會自動的把[.c]文件加在依賴關係中，如果make找到一個
whatever.o，那麼whatever.c，就會是whatever.o的依賴文件。並且 cc -c whatever.c 也
會被推導出來，於是，我們的makefile再也不用寫得這麼複雜。我們的是新的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)
這種方法，也就是make的「隱晦規則」。上面文件內容中，「.PHONY」表示，clean是個偽
目標文件。
關於更為詳細的「隱晦規則」和「偽目標文件」，我會在後續給你一一道來。

六、另類風格的makefile
即然我們的make可以自動推導命令，那麼我看到那堆[.o]和[.h]的依賴就有點不爽，那麼多
的重複的[.h]，能不能把其收攏起來，好吧，沒有問題，這個對於make來說很容易，誰叫它
提供了自動推導命令和文件的功能呢？來看看最新風格的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
.PHONY : clean
clean :
rm edit $(objects)
這種風格，讓我們的makefile變得很簡單，但我們的文件依賴關係就顯得有點凌亂了。魚和
熊掌不可兼得。還看你的喜好了。我是不喜歡這種風格的，一是文件的依賴關係看不清楚，
二是如果文件一多，要加入幾個新的.o文件，那就理不清楚了。

七、清空目標文件的規則
每個Makefile中都應該寫一個清空目標文件（.o和執行文件）的規則，這不僅便於重編譯，
也很利於保持文件的清潔。這是一個「修養」（呵呵，還記得我的《編程修養》嗎）。一般
的風格都是：
clean:
rm edit $(objects)
更為穩健的做法是：
.PHONY : clean
clean :
-rm edit $(objects)
前面說過，.PHONY意思表示clean是一個「偽目標」，。而在rm命令前面加了一個小減號的
意思就是，也許某些文件出現問題，但不要管，繼續做後面的事。當然，clean的規則不要
放在文件的開頭，不然，這就會變成make的默認目標，相信誰也不願意這樣。不成文的規矩
是——「clean從來都是放在文件的最後」。

上面就是一個makefile的概貌，也是makefile的基礎，下面還有很多makefile的相關細節，
準備好了嗎？準備好了就來。


三、Makefile 總述
———————
一、Makefile里有什麼？
Makefile里主要包含了五個東西：顯式規則、隱晦規則、變數定義、文件指示和註釋。
1、顯式規則。顯式規則說明了，如何生成一個或多的的目標文件。這是由Makefile的書寫
者明顯指出，要生成的文件，文件的依賴文件，生成的命令。
2、隱晦規則。由於我們的make有自動推導的功能，所以隱晦的規則可以讓我們比較粗糙地
簡略地書寫Makefile，這是由make所支持的。
3、變數的定義。在Makefile中我們要定義一系列的變數，變數一般都是字元串，這個有點
你C語言中的宏，當Makefile被執行時，其中的變數都會被擴展到相應的引用位置上。
4、文件指示。其包括了三個部分，一個是在一個Makefile中引用另一個Makefile，就像C語
言中的include一樣；另一個是指根據某些情況指定Makefile中的有效部分，就像C語言中的
預編譯#if一樣；還有就是定義一個多行的命令。有關這一部分的內容，我會在後續的部分
中講述。
5、註釋。Makefile中只有行註釋，和UNIX的Shell腳本一樣，其註釋是用「#」字元，這個
就像C/C++中的「//」一樣。如果你要在你的Makefile中使用「#」字元，可以用反斜框進行
轉義，如：「\#」。
最後，還值得一提的是，在Makefile中的命令，必須要以[Tab]鍵開始。

二、Makefile的文件名
默認的情況下，make命令會在當前目錄下按順序找尋文件名為「GNUmakefile」、「makefil
e」、「Makefile」的文件，找到了解釋這個文件。在這三個文件名中，最好使用「Makefil
e」這個文件名，因為，這個文件名第一個字元為大寫，這樣有一種顯目的感覺。最好不要
用「GNUmakefile」，這個文件是GNU的make識別的。有另外一些make只對全小寫的「makefi
le」文件名敏感，但是基本上來說，大多數的make都支持「makefile」和「Makefile」這兩
種默認文件名。
當然，你可以使用別的文件名來書寫Makefile，比如：「Make.Linux」，「Make.Solaris」
，「Make.AIX」等，如果要指定特定的Makefile，你可以使用make的「-f」和「--file」參
數，如：make -f Make.Linux或make --file Make.AIX。

三、引用其它的Makefile
在Makefile使用include關鍵字可以把別的Makefile包含進來，這很像C語言的#include，被
包含的文件會原模原樣的放在當前文件的包含位置。include的語法是：
include
filename可以是當前操作系統Shell的文件模式（可以保含路徑和通配符）
在include前面可以有一些空字元，但是絕不能是[Tab]鍵開始。include和可以
用一個或多個空格隔開。舉個例子，你有這樣幾個Makefile：a.mk、b.mk、c.mk，還有一個
文件叫foo.make，以及一個變數$(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，並把其內容安置在當前的位置
。就好像C/C++的#include指令一樣。如果文件都沒有指定絕對路徑或是相對路徑的話，mak
e會在當前目錄下首先尋找，如果當前目錄下沒有找到，那麼，make還會在下面的幾個目錄
下找：
1、如果make執行時，有「-I」或「--include-dir」參數，那麼make就會在這個參數所
指定的目錄下去尋找。
2、如果目錄/include（一般是：/usr/local/bin或/usr/include）存在的話
，make也會去找。
如果有文件沒有找到的話，make會生成一條警告信息，但不會馬上出現致命錯誤。它會繼續
載入其它的文件，一旦完成makefile的讀取，make會再重試這些沒有找到，或是不能讀取的
文件，如果還是不行，make才會出現一條致命信息。如果你想讓make不理那些無法讀取的文
件，而繼續執行，你可以在include前加一個減號「-」。如：
-include
其表示，無論include過程中出現什麼錯誤，都不要報錯繼續執行。和其它版本make兼
容的相關命令是sinclude，其作用和這一個是一樣的。

四、環境變數 MAKEFILES
如果你的當前環境中定義了環境變數MAKEFILES，那麼，make會把這個變數中的值做一個類
似於include的動作。這個變數中的值是其它的Makefile，用空格分隔。只是，它和includ
e不同的是，從這個環境變中引入的Makefile的「目標」不會起作用，如果環境變數中定義
的文件發現錯誤，make也會不理。
但是在這裡我還是建議不要使用這個環境變數，因為只要這個變數一被定義，那麼當你使用
make時，所有的Makefile都會受到它的影響，這絕不是你想看到的。在這裡提這個事，只是
為了告訴大家，也許有時候你的Makefile出現了怪事，那麼你可以看看當前環境中有沒有定
義這個變數。

五、make的工作方式
GNU的make工作時的執行步驟入下：（想來其它的make也是類似）
1、讀入所有的Makefile。
2、讀入被include的其它Makefile。
3、初始化文件中的變數。
4、推導隱晦規則，並分析所有規則。
5、為所有的目標文件創建依賴關係鏈。
6、根據依賴關係，決定哪些目標要重新生成。
7、執行生成命令。
1-5步為第一個階段，6-7為第二個階段。第一個階段中，如果定義的變數被使用了，那麼，
make會把其展開在使用的位置。但make並不會完全馬上展開，make使用的是拖延戰術，如果
變數出現在依賴關係的規則中，那麼僅當這條依賴被決定要使用了，變數才會在其內部展開
。
當然，這個工作方式你不一定要清楚，但是知道這個方式你也會對make更為熟悉。有了這個
基礎，後續部分也就容易看懂了。



四、書寫規則
————
規則包含兩個部分，一個是依賴關係，一個是生成目標的方法。
在Makefile中，規則的順序是很重要的，因為，Makefile中只應該有一個最終目標，其它的
目標都是被這個目標所連帶出來的，所以一定要讓make知道你的最終目標是什麼。一般來說
，定義在Makefile中的目標可能會有很多，但是第一條規則中的目標將被確立為最終的目標
。如果第一條規則中的目標有很多個，那麼，第一個目標會成為最終的目標。make所完成的
也就是這個目標。
好了，還是讓我們來看一看如何書寫規則。

一、規則舉例
foo.o : foo.c defs.h # foo模塊
cc -c -g foo.c
看到這個例子，各位應該不是很陌生了，前面也已說過，foo.o是我們的目標，foo.c和defs
.h是目標所依賴的源文件，而只有一個命令「cc -c -g foo.c」（以Tab鍵開頭）。這個規
則告訴我們兩件事：
1、文件的依賴關係，foo.o依賴於foo.c和defs.h的文件，如果foo.c和defs.h的文件日
期要比foo.o文件日期要新，或是foo.o不存在，那麼依賴關係發生。
2、如果生成（或更新）foo.o文件。也就是那個cc命令，其說明了，如何生成foo.o這
個文件。（當然foo.c文件include了defs.h文件）

二、規則的語法
targets : prerequisites
command
...
或是這樣：
targets : prerequisites ; command
command
...
targets是文件名，以空格分開，可以使用通配符。一般來說，我們的目標基本上是一個文
件，但也有可能是多個文件。
command是命令行，如果其不與「target:prerequisites」在一行，那麼，必須以[Tab鍵]開
頭，如果和prerequisites在一行，那麼可以用分號做為分隔。（見上）
prerequisites也就是目標所依賴的文件（或依賴目標）。如果其中的某個文件要比目標文
件要新，那麼，目標就被認為是「過時的」，被認為是需要重生成的。這個在前面已經講過
了。
如果命令太長，你可以使用反斜框（『\』）作為換行符。make對一行上有多少個字元沒有
限制。規則告訴make兩件事，文件的依賴關係和如何成成目標文件。
一般來說，make會以UNIX的標準Shell，也就是/bin/sh來執行命令。

三、在規則中使用通配符
如果我們想定義一系列比較類似的文件，我們很自然地就想起使用通配符。make支持三各通
配符：「*」，「?」和「[...]」。這是和Unix的B-Shell是相同的。
波浪號（「~」）字元在文件名中也有比較特殊的用途。如果是「~/test」，這就表示當前
用戶的$HOME目錄下的test目錄。而「~hchen/test」則表示用戶hchen的宿主目錄下的test
目錄。（這些都是Unix下的小知識了，make也支持）而在Windows或是MS-DOS下，用戶沒有
宿主目錄，那麼波浪號所指的目錄則根據環境變數「HOME」而定。
通配符代替了你一系列的文件，如「*.c」表示所以後綴為c的文件。一個需要我們注意的是
，如果我們的文件名中有通配符，如：「*」，那麼可以用轉義字元「\」，如「\*」來表示
真實的「*」字元，而不是任意長度的字元串。
好吧，還是先來看幾個例子吧：
clean:
rm -f *.o
上面這個例子我不不多說了，這是操作系統Shell所支持的通配符。這是在命令中的通
配符。
print: *.c
lpr -p $?
touch print
上面這個例子說明了通配符也可以在我們的規則中，目標print依賴於所有的[.c]文件
。其中的「$?」是一個自動化變數，我會在後面給你講述。
objects = *.o
上面這個例子，表示了，通符同樣可以用在變數中。並不是說[*.o]會展開，不！objec
ts的值就是「*.o」。Makefile中的變數其實就是C/C++中的宏。如果你要讓通配符在變數中
展開，也就是讓objects的值是所有[.o]的文件名的集合，那麼，你可以這樣：
objects := $(wildcard *.o)
這種用法由關鍵字「wildcard」指出，關於Makefile的關鍵字，我們將在後面討論。

四、文件搜尋
在一些大的工程中，有大量的源文件，我們通常的做法是把這許多的源文件分類，並存放在
不同的目錄中。所以，當make需要去找尋文件的依賴關係時，你可以在文件前加上路徑，但
最好的方法是把一個路徑告訴make，讓make在自動去找。
Makefile文件中的特殊變數「VPATH」就是完成這個功能的，如果沒有指明這個變數，make
只會在當前的目錄中去找尋依賴文件和目標文件。如果定義了這個變數，那麼，make就會在
噹噹前目錄找不到的情況下，到所指定的目錄中去找尋文件了。
VPATH = src:../headers
上面的的定義指定兩個目錄，「src」和「../headers」，make會按照這個順序進行搜索。
目錄由「冒號」分隔。（當然，當前目錄永遠是最高優先搜索的地方）
另一個設置文件搜索路徑的方法是使用make的「vpath」關鍵字（注意，它是全小寫的），
這不是變數，這是一個make的關鍵字，這和上面提到的那個VPATH變數很類似，但是它更為
靈活。它可以指定不同的文件在不同的搜索目錄中。這是一個很靈活的功能。它的使用方法
有三種：
1、vpath
為符合模式的文件指定搜索目錄。
2、vpath
清除符合模式的文件的搜索目錄。
3、vpath
清除所有已被設置好了的文件搜索目錄。
vapth使用方法中的需要包含「%」字元。「%」的意思是匹配零或若干字元，例如
，「%.h」表示所有以「.h」結尾的文件。指定了要搜索的文件集，而es>則指定了的文件集的搜索的目錄。例如：
vpath %.h ../headers
該語句表示，要求make在「../headers」目錄下搜索所有以「.h」結尾的文件。（如果某文
件在當前目錄沒有找到的話）
我們可以連續地使用vpath語句，以指定不同搜索策略。如果連續的vpath語句中出現了相同
的，或是被重複了的，那麼，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 cle
an」這樣。於是整個過程可以這樣寫：
.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」命令來達到清除不同種類文件的目的。


五、
六、多目標
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的函數，函數名為subs
t，後面的為參數。關於函數，將在後面講述。這裡的這個函數是截取字元串的意思，「$@
」表示目標的集合，就像一個數組，「$@」依次取出目標，並執於命令。

七、靜態模式
靜態模式可以更加容易地定義多目標的規則，可以讓我們的規則變得更加的有彈性和靈活。
我們還是先來看一下語法：
: :

...

targets定義了一系列的目標文件，可以有通配符。是目標的一個集合。
target-parrtern是指明了targets的模式，也就是的目標集模式。
prereq-parrterns是目標的依賴模式，它對target-parrtern形成的模式再進行一次依
賴目標的定義。
這樣描述這三個東西，可能還是沒有說清楚，還是舉個例子來說明一下吧。如果我們的get-parrtern>定義成「%.o」，意思是我們的集合中都是以「.o」結尾的，而如果
我們的定義成「%.c」，意思是對所形成的目標集進
行二次定義，其計算方法是，取模式中的「%」（也就是去掉了[.o]這個
結尾），並為其加上[.c]這個結尾，形成的新集合。
所以，我們的「目標模式」或是「依賴模式」中都應該有「%」這個字元，如果你的文件名
中有「%」那麼你可以使用反斜杠「\」進行轉義，來標明真實的「%」字元。
看一個例子：
objects = foo.o bar.o
all: $(objects)
$(objects): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@

上面的例子中，指明了我們的目標從$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」）。
於是，上面的規則展開后等價於下面的規則：
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) $< -o $@
$(filter %.elc,$(files)): %.elc: %.el
emacs -f batch-byte-compile $<

$(filter %.o,$(files))表示調用Makefile的filter函數，過濾「$filter」集，只要其中
模式為「%.o」的內容。其的它內容，我就不用多說了吧。這個例字展示了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聯繫在一起呢。因為這樣一來，我們的Make
file也要根據這些源文件重新生成，讓Makefile自已依賴於源文件？這個功能並不現實，不
過我們可以有其它手段來迂迴地實現這一功能。GNU組織建議把編譯器為每一個源文件的自
動生成的依賴關係放到一個文件中，為每一個「name.c」的文件都生成一個「name.d」的Ma
kefile文件，[.d]文件中就存放對應[.c]文件的依賴關係。
於是，我們可以寫出[.c]文件和[.d]文件的依賴關係，並讓make自動更新或自成[.d]文件，
並把其包含在我們的主Makefile中，這樣，我們就可以自動化地生成每個文件的依賴關係了
。
這裡，我們給出了一個模式規則來產生[.d]文件：
%.d: %.c
@set -e; rm -f $@; \
$(CC) -M $(CPPFLAGS) $< > $@.$$$$; \
sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
rm -f $@.$$$$

這個規則的意思是，所有的[.d]文件依賴於[.c]文件，「rm -f $@」的意思是刪除所有的目
標，也就是[.d]文件，第二行的意思是，為每個依賴文件「$<」，也就是[.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]文件都包含一個完賴
的規則。一旦我們完成這個工作，接下來，我們就要把這些自動生成的規則放進我們的主Ma
kefile中。我們可以使用Makefile的「include」命令，來引入別的Makefile文件（前面講
過），例如：
sources = foo.c bar.c
include $(sources:.c=.d)
上述語句中的「$(sources:.c=.d)」中的「.c=.d」的意思是做一個替換，把變數$(sources
)所有[.c]的字串都替換成[.d]，關於這個「替換」的內容，在後面我會有更為詳細的講述
。當然，你得注意次序，因為include是按次來載入文件，最先載入的[.d]文件中的目標會
成為默認目標


六書寫命令
————
每條規則中的命令和操作系統Shell的命令行是一致的。make會一按順序一條一條的執行命
令，每條命令的開頭必須以[Tab]鍵開頭，除非，命令是緊跟在依賴規則後面的分號后的。
在命令行之間中的空格或是空行會被忽略，但是如果該空格或空行是以Tab鍵開頭的，那麼m
ake會認為其是一個空命令。
我們在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
示例二：
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的命令行前加一個減號「-」（在T
ab鍵之後），標記為不管命令出不出錯都認為是成功的。如：
clean:
-rm -f *.o
還有一個全局的辦法是，給make加上「-i」或是「--ignore-errors」參數，那麼，Makefil
e中所有命令都會忽略錯誤。而如果一個規則是以「.IGNORE」作為目標的，那麼這個規則中
的所有命令將會忽略錯誤。這些是不同級別的防止命令出錯的方法，你可以根據你的不同喜
歡設置。
還有一個要提一下的make的參數的是「-k」或是「--keep-going」，這個參數的意思是，如
果某規則中的命令出錯了，那麼就終目該規則的執行，但繼續執行其它規則。


四、嵌套執行make
在一些大的工程中，我們會把我們不同模塊或是不同功能的源文件放在不同的目錄中，我們
可以在每個目錄中都書寫一個該目錄的Makefile，這有利於讓我們的Makefile變得更加地簡
潔，而不至於把所有的東西全部寫在一個Makefile中，這樣會很難維護我們的Makefile，這
個技術對於我們模塊編譯和分段編譯有著非常大的好處。
例如，我們有一個子目錄叫subdir，這個目錄下有個Makefile文件，來指明了這個目錄下文
件的編譯規則。那麼我們總控的Makefile可以這樣書寫：
subsystem:
cd subdir && $(MAKE)
其等價於：
subsystem:
$(MAKE) -C subdir
定義$(MAKE)宏變數的意思是，也許我們的make需要一些參數，所以定義成一個變數比較利
於維護。這兩個例子的意思都是先進入「subdir」目錄，然後執行make命令。
我們把這個Makefile叫做「總控Makefile」，總控Makefile的變數可以傳遞到下級的Makefi
le中（如果你顯示的聲明），但是不會覆蓋下層的Makefile中所定義的變數，除非指定了「
-e」參數。
如果你要傳遞變數到下級Makefile中，那麼你可以使用這樣的聲明：
export
如果你不想讓某些變數傳遞到下級Makefile中，那麼你可以這樣聲明：
unexport
如：

示例一：
export variable = value
其等價於：
variable = value
export variable
其等價於：
export variable := value
其等價於：
variable := value
export variable
示例二：
export variable += value
其等價於：
variable += value
export variable
如果你要傳遞所有的變數，那麼，只要一個export就行了。後面什麼也不用跟，表示傳遞所
有的變數。
需要注意的是，有兩個變數，一個是SHELL，一個是MAKEFLAGS，這兩個變數不管你是否expo
rt，其總是要傳遞到下層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目錄是「/h
ome/hchen/gnu/make」，如果我們使用「make -w」來執行，那麼當進入該目錄時，我們會
看到：
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程序，因為Yac
c程序總是生成「y.tab.c」的文件，所以第二行的命令就是把這個文件改改名字。還是把這
個命令包放到一個示例中來看看吧。
foo.c : foo.y
$(run-yacc)
我們可以看見，要使用這個命令包，我們就好像使用變數一樣。在這個命令包的使用中，命
令包「run-yacc」中的「$^」就是「foo.y」，「$@」就是「foo.c」（有關這種以「$」開
頭的特殊變數，我們會在後面介紹），make在執行命令包時，命令包中的每個命令會被依次
獨立執行。



七
使用變數
————
在Makefile中的定義的變數，就像是C/C++語言中的宏一樣，他代表了一個文本字串，在Mak
efile中執行的時候其會自動原模原樣地展開在所使用的地方。其與C/C++所不同的是，你可
以在Makefile中改變其值。在Makefile中，變數可以使用在「目標」，「依賴目標」，「命
令」或是Makefile的其它部分中。
變數的命名字可以包含字元、數字，下劃線（可以是數字開頭），但不應該含有「:」、「
#」、「=」或是空字元（空格、回車等）。變數是大小寫敏感的，「foo」、「Foo」和「FO
O」是三個不同的變數名。傳統的Makefile的變數名是全大寫的命名方式，但我推薦使用大
小寫搭配的變數名，如：MakeFlags。這樣可以避免和系統的變數衝突，而發生意外的事情
。
有一些變數是很奇怪字串，如「$<」、「$@」等，這些是自動化變數，我會在後面介紹。
一、變數的基礎
變數在聲明時需要給予初值，而在使用時，需要給在變數名前加上「$」符號，但最好用小
括弧「（）」或是大括弧「{}」把變數給包括起來。如果你要使用真實的「$」字元，那麼
你需要用「$$」來表示。
變數可以使用在許多地方，如規則中的「目標」、「依賴」、「命令」以及新的變數中。先
看一個例子：
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中的變數在使
用處展開的真實樣子。可見其就是一個「替代」的原理。
另外，給變數加上括弧完全是為了更加安全地使用這個變數，在上面的例子中，如果你不想
給變數加上括弧，那也可以，但我還是強烈建議你給變數加上括弧。

二、變數中的變數
在定義變數的值時，我們可以使用其它變數來構造變數的值，在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中的另一種用變數來定義變數的方法。這種方
法使用的是「:=」操作符，如：
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變數來標明變
量的值開始了，而後面採用「#」註釋符來表示變數定義的終止，這樣，我們可以定義出其
值是一個空格的變數。請注意這裡關於「#」的使用，註釋符「#」的這種特性值得我們注意
，如果我們這樣定義一個變數：
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」。
第二種高級用法是——「把變數的值再當成變數」。先看一個例子：
x = y
y = z
a := $($(x))
在這個例子中，$(x)的值是「y」，所以$($(x))就是$(y)，於是$(a)的值就是「z」。（注
意，是「x=y」，而不是「x=$(y)」）
我們還可以使用更多的層次：
x = y
y = z
z = u
a := $($($(x)))

Tags: linux system 內核