讀書筆記系列之：Linux下makefile教程
笛風
2013.12.13
http://www.chinaunix.net/old_jh/23/408225.html
make 的運行
——————
一般來說，最簡單的就是直接在命令行下輸入make命令，make命令會找當前目錄的makefile來執行，一切都是自動的。但也有時你也許只想讓make重編譯某些文件，而不是整個工程，而又有的時候你有幾套編譯規則，你想在不同的時候使用不同的編譯規則，等等。本章節就是講述如何使用make命令的。
一、make的退出碼
make命令執行後有三個退出碼：
0 —— 表示成功執行。
1 —— 如果make運行時出現任何錯誤，其返回1。
2 —— 如果你使用了make的“-q”選項，並且make使得一些目標不需要更新，那麼返回2。
Make的相關參數我們會在後續章節中講述。
二、指定Makefile
前面我們說過，GNU make找尋默認的Makefile的規則是在當前目錄下依次找三個文件——“GNUmakefile”、“makefile”和“Makefile”。其按順序找這三個文件，一旦找到，就開始讀取這個文件並執行。
當前，我們也可以給make命令指定一個特殊名字的Makefile。要達到這個功能，我們要使用make的“-f”或是“--file”參數（“--makefile”參數也行）。例如，我們有個makefile的名字是“hchen.mk”，那麼，我們可以這樣來讓make來執行這個文件：
make –f hchen.mk
如果在make的命令行是，你不只一次地使用了“-f”參數，那麼，所有指定的makefile將會被連在一起傳遞給make執行。
三、指定目標
一般來說，make的最終目標是makefile中的第一個目標，而其它目標一般是由這個目標連帶出來的。這是make的默認行爲。當然，一般來說，你的makefile中的第一個目標是由許多個目標組成，你可以指示make，讓其完成你所指定的目標。要達到這一目的很簡單，需在make命令後直接跟目標的名字就可以完成（如前面提到的“make clean”形式）
任何在makefile中的目標都可以被指定成終極目標，但是除了以“-”打頭，或是包含了“=”的目標，因爲有這些字符的目標，會被解析成命令行參數或是變量。甚至沒有被我們明確寫出來的目標也可以成爲make的終極目標，也就是說，只要make可以找到其隱含規則推導規則，那麼這個隱含目標同樣可以被指定成終極目標。
有一個make的環境變量叫“MAKECMDGOALS”，這個變量中會存放你所指定的終極目標的列表，如果在命令行上，你沒有指定目標，那麼，這個變量是空值。這個變量可以讓你使用在一些比較特殊的情形下。比如下面的例子：
sources = foo.c bar.c
ifneq ( $(MAKECMDGOALS),clean)
include $(sources:.c=.d)
endif
基於上面的這個例子，只要我們輸入的命令不是“make clean”，那麼makefile會自動包含“foo.d”和“bar.d”這兩個makefile。
使用指定終極目標的方法可以很方便地讓我們編譯我們的程序，例如下面這個例子：
.PHONY: all
all: prog1 prog2 prog3 prog4
從這個例子中，我們可以看到，這個makefile中有四個需要編譯的程序——“prog1”， “prog2”， “prog3”和 “prog4”，我們可以使用“make all”命令來編譯所有的目標（如果把all置成第一個目標，那麼只需執行“make”），我們也可以使用“make prog2”來單獨編譯目標“prog2”。
即然make可以指定所有makefile中的目標，那麼也包括“僞目標”，於是我們可以根據這種性質來讓我們的makefile根據指定的不同的目標來完成不同的事。在Unix世界中，軟件發佈時，特別是GNU這種開源軟件的發佈時，其makefile都包含了編譯、安裝、打包等功能。我們可以參照這種規則來書寫我們的makefile中的目標。
“all”
這個僞目標是所有目標的目標，其功能一般是編譯所有的目標。
“clean”
這個僞目標功能是刪除所有被make創建的文件。
“install”
這個僞目標功能是安裝已編譯好的程序，其實就是把目標執行文件拷貝到指定的目標中去。
“print”
這個僞目標的功能是例出改變過的源文件。
“tar”
這個僞目標功能是把源程序打包備份。也就是一個tar文件。
“dist”
這個僞目標功能是創建一個壓縮文件，一般是把tar文件壓成Z文件。或是gz文件。
“TAGS”
這個僞目標功能是更新所有的目標，以備完整地重編譯使用。
“check”和“test”
這兩個僞目標一般用來測試makefile的流程。
當然一個項目的makefile中也不一定要書寫這樣的目標，這些東西都是GNU的東西，但是我想，GNU搞出這些東西一定有其可取之處（等你的UNIX下的程序文件一多時你就會發現這些功能很有用了），這裏只不過是說明了，如果你要書寫這種功能，最好使用這種名字命名你的目標，這樣規範一些，規範的好處就是——不用解釋，大家都明白。而且如果你的makefile中有這些功能，一是很實用，二是可以顯得你的makefile很專業（不是那種初學者的作品）。
四、檢查規則
有時候，我們不想讓我們的makefile中的規則執行起來，我們只想檢查一下我們的命令，或是執行的序列。於是我們可以使用make命令的下述參數：
“-n”
“--just-print”
“--dry-run”
“--recon”
不執行參數，這些參數只是打印命令，不管目標是否更新，把規則和連帶規則下的命令打印出來，但不執行，這些參數對於我們調試makefile很有用處。
“-t”
“--touch”
這個參數的意思就是把目標文件的時間更新，但不更改目標文件。也就是說，make假裝編譯目標，但不是真正的編譯目標，只是把目標變成已編譯過的狀態。
“-q”
“--question”
這個參數的行爲是找目標的意思，也就是說，如果目標存在，那麼其什麼也不會輸出，當然也不會執行編譯，如果目標不存在，其會打印出一條出錯信息。
“-W <file>”
“--what-if=<file>”
“--assume-new=<file>”
“--new-file=<file>”
這個參數需要指定一個文件。一般是是源文件（或依賴文件），Make會根據規則推導來運行依賴於這個文件的命令，一般來說，可以和“-n”參數一同使用，來查看這個依賴文件所發生的規則命令。
另外一個很有意思的用法是結合“-p”和“-v”來輸出makefile被執行時的信息（這個將在後面講述）。
五、make的參數
下面列舉了所有GNU make 3.80版的參數定義。其它版本和產商的make大同小異，不過其它產商的make的具體參數還是請參考各自的產品文檔。
“-b”
“-m”
這兩個參數的作用是忽略和其它版本make的兼容性。
“-B”
“--always-make”
認爲所有的目標都需要更新（重編譯）。
“-C <dir>”
“--directory=<dir>”
指定讀取makefile的目錄。如果有多個“-C”參數，make的解釋是後面的路徑以前面的作爲相對路徑，並以最後的目錄作爲被指定目錄。如：“make –C ~hchen/test –C prog”等價於“make –C~hchen/test/prog”。
“—debug[=<options>]”
輸出make的調試信息。它有幾種不同的級別可供選擇，如果沒有參數，那就是輸出最簡單的調試信息。下面是<options>的取值：
a —— 也就是all，輸出所有的調試信息。（會非常的多）
b —— 也就是basic，只輸出簡單的調試信息。即輸出不需要重編譯的目標。
v —— 也就是verbose，在b選項的級別之上。輸出的信息包括哪個makefile被解析，不需要被重編譯的依賴文件（或是依賴目標）等。
i —— 也就是implicit，輸出所以的隱含規則。
j —— 也就是jobs，輸出執行規則中命令的詳細信息，如命令的PID、返回碼等。
m —— 也就是makefile，輸出make讀取makefile，更新makefile，執行makefile的信息。
“-d”
相當於“--debug=a”。
“-e”
“--environment-overrides”
指明環境變量的值覆蓋makefile中定義的變量的值。
“-f=<file>”
“--file=<file>”
“--makefile=<file>”
指定需要執行的makefile。
“-h”
“--help”
顯示幫助信息。
“-i”
“--ignore-errors”
在執行時忽略所有的錯誤。
“-I <dir>”
“--include-dir=<dir>”
指定一個被包含makefile的搜索目標。可以使用多個“-I”參數來指定多個目錄。
“-j [<jobsnum>]”
“--jobs[=<jobsnum>]”
指同時運行命令的個數。如果沒有這個參數，make運行命令時能運行多少就運行多少。如果有一個以上的“-j”參數，那麼僅最後一個“-j”纔是有效的。（注意這個參數在MS-DOS中是無用的）
“-k”
“--keep-going”
出錯也不停止運行。如果生成一個目標失敗了，那麼依賴於其上的目標就不會被執行了。
“-l <load>”
“--load-average[=<load]”
“—max-load[=<load>]”
指定make運行命令的負載。
“-n”
“--just-print”
“--dry-run”
“--recon”
僅輸出執行過程中的命令序列，但並不執行。
“-o <file>”
“--old-file=<file>”
“--assume-old=<file>”
不重新生成的指定的<file>，即使這個目標的依賴文件新於它。
“-p”
“--print-data-base”
輸出makefile中的所有數據，包括所有的規則和變量。這個參數會讓一個簡單的makefile都會輸出一堆信息。如果你只是想輸出信息而不想執行makefile，你可以使用“make -qp”命令。如果你想查看執行makefile前的預設變量和規則，你可以使用“make –p –f/dev/null”。這個參數輸出的信息會包含着你的makefile文件的文件名和行號，所以，用這個參數來調試你的makefile會是很有用的，特別是當你的環境變量很複雜的時候。
“-q”
“--question”
不運行命令，也不輸出。僅僅是檢查所指定的目標是否需要更新。如果是0則說明要更新，如果是2則說明有錯誤發生。
“-r”
“--no-builtin-rules”
禁止make使用任何隱含規則。
“-R”
“--no-builtin-variabes”
禁止make使用任何作用於變量上的隱含規則。
“-s”
“--silent”
“--quiet”
在命令運行時不輸出命令的輸出。
“-S”
“--no-keep-going”
“--stop”
取消“-k”選項的作用。因爲有些時候，make的選項是從環境變量“MAKEFLAGS”中繼承下來的。所以你可以在命令行中使用這個參數來讓環境變量中的“-k”選項失效。
“-t”
“--touch”
相當於UNIX的touch命令，只是把目標的修改日期變成最新的，也就是阻止生成目標的命令運行。
“-v”
“--version”
輸出make程序的版本、版權等關於make的信息。
“-w”
“--print-directory”
輸出運行makefile之前和之後的信息。這個參數對於跟蹤嵌套式調用make時很有用。
“--no-print-directory”
禁止“-w”選項。
“-W <file>”
“--what-if=<file>”
“--new-file=<file>”
“--assume-file=<file>”
假定目標<file>需要更新，如果和“-n”選項使用，那麼這個參數會輸出該目標更新時的運行動作。如果沒有“-n”那麼就像運行UNIX的“touch”命令一樣，使得<file>的修改時間爲當前時間。
“--warn-undefined-variables”
只要make發現有未定義的變量，那麼就輸出警告信息。
Linux下makefile教程（二）
分類： 專題小結 2011-12-21 18:47 709人閱讀評論(0) 收藏舉報
makefilelinuxincludeshellwildcard編譯器
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”、“makef
ile”、“Makefile”的文件，找到了解釋這個文件。在這三個文件名中，最好使用“Mak
efile”這個文件名，因爲，這個文件名第一個字符爲大寫，這樣有一種顯目的感覺。最好
不要用 “GNUmakefile”，這個文件是GNU的make識別的。有另外一些make只對全小寫的“
makefile”文件名敏感，但是基本上來說，大多數的make都支持“makefile”和“Makefi
le”這兩種默認文件名。
當然，你可以使用別的文件名來書寫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>
filename可以是當前操作系統Shell的文件模式（可以保含路徑和通配符）
在 include前面可以有一些空字符，但是絕不能是[Tab]鍵開始。include和<filename>可
以用一個或多個空格隔開。舉個例子，你有這樣幾個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指令一樣。如果文件都沒有指定絕對路徑或是相對路徑的話，
make會在當前目錄下首先尋找，如果當前目錄下沒有找到，那麼，make還會在下面的幾個
目錄下找：
1、如果make執行時，有“-I”或“--include-dir”參數，那麼make就會在這個參數所指
定的目錄下去尋找。
2、如果目錄<prefix>/include（一般是：/usr/local/bin或/usr/include）存在的話，m
ake也會去找。
如果有文件沒有找到的話，make會生成一條警告信息，但不會馬上出現致命錯誤。它會繼
續載入其它的文件，一旦完成makefile的讀取，make會再重試這些沒有找到，或是不能讀
取的文件，如果還是不行，make纔會出現一條致命信息。如果你想讓make不理那些無法讀
取的文件，而繼續執行，你可以在 include前加一個減號“-”。如：
-include <filename>
其表示，無論include過程中出現什麼錯誤，都不要報錯繼續執行。和其它版本make兼容的
相關命令是sinclude，其作用和這一個是一樣的。
四、環境變量 MAKEFILES
如果你的當前環境中定義了環境變量MAKEFILES，那麼，make會把這個變量中的值做一個類
似於include的動作。這個變量中的值是其它的Makefile，用空格分隔。只是，它和incl
ude不同的是，從這個環境變中引入的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和de
fs.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的宿主目錄下的te
st目錄。（這些都是Unix下的小知識了，make也支持）而在Windows或是MS-DOS下，用戶
沒有宿主目錄，那麼波浪號所指的目錄則根據環境變量“HOME”而定。
通配符代替了你一系列的文件，如“*.c”表示所以後綴爲c的文件。一個需要我們注意的
是，如果我們的文件名中有通配符，如：“*”，那麼可以用轉義字符“\”，如“\*”來
表示真實的“*”字符，而不是任意長度的字符串。
好吧，還是先來看幾個例子吧：
clean:
rm -f *.o
上面這個例子我不不多說了，這是操作系統Shell所支持的通配符。這是在命令中的通配符。
print: *.c
lpr -p $?
touch print
上面這個例子說明了通配符也可以在我們的規則中，目標print依賴於所有的[.c]文件。其
中的“$?”是一個自動化變量，我會在後面給你講述。
objects = *.o
上面這個例子，表示了，通符同樣可以用在變量中。並不是說[*.o]會展開，不！objects
的值就是“*.o”。Makefile中的變量其實就是 C/C++中的宏。如果你要讓通配符在變量中
展開，也就是讓objects的值是所有[.o]的文件名的集合，那麼，你可以這樣：
objects := $(wildcard *.o)
這種用法由關鍵字“wildcard”指出，關於Makefile的關鍵字，我們將在後面討論。
四、文件搜尋
在一些大的工程中，有大量的源文件，我們通常的做法是把這許多的源文件分類，並存放
在不同的目錄中。所以，當make需要去找尋文件的依賴關係時，你可以在文件前加上路徑
，但最好的方法是把一個路徑告訴make，讓make在自動去找。
Makefile文件中的特殊變量“VPATH”就是完成這個功能的，如果沒有指明這個變量，mak
e只會在當前的目錄中去找尋依賴文件和目標文件。如果定義了這個變量，那麼，make就會
在噹噹前目錄找不到的情況下，到所指定的目錄中去找尋文件了。
VPATH = src:../headers
上面的的定義指定兩個目錄，“src”和“../headers”，make會按照這個順序進行搜索。
目錄由“冒號”分隔。（當然，當前目錄永遠是最高優先搜索的地方）
另一個設置文件搜索路徑的方法是使用make的“vpath”關鍵字（注意，它是全小寫的），
這不是變量，這是一個make的關鍵字，這和上面提到的那個 VPATH變量很類似，但是它更
爲靈活。它可以指定不同的文件在不同的搜索目錄中。這是一個很靈活的功能。它的使用
方法有三種：
1、vpath <pattern> <directories>
爲符合模式<pattern>的文件指定搜索目錄<directories>。
2、vpath <pattern>
清除符合模式<pattern>的文件的搜索目錄。
3、vpath
清除所有已被設置好了的文件搜索目錄。
vapth 使用方法中的<pattern>需要包含“%”字符。“%”的意思是匹配零或若干字符，例
如，“%.h”表示所有以“.h”結尾的文件。<pattern>指定了要搜索的文件集，而<direc
tories>則指定了<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 c
lean”這樣。於是整個過程可以這樣寫：
.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”和“ma
ke 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的函數，函數名爲subst，
後面的爲參數。關於函數，將在後面講述。這裏的這個函數是截取字符串的意思，“$@”
表示目標的集合，就像一個數組，“$@”依次取出目標，並執於命令。
七、靜態模式
靜態模式可以更加容易地定義多目標的規則，可以讓我們的規則變得更加的有彈性和靈活
。我們還是先來看一下語法：
<targets ...>: <target-pattern>: <prereq-patterns ...>
<commands>
...
targets定義了一系列的目標文件，可以有通配符。是目標的一個集合。
target-parrtern是指明瞭targets的模式，也就是的目標集模式。
prereq-parrterns是目標的依賴模式，它對target-parrtern形成的模式再進行一次依賴目
標的定義。
這樣描述這三個東西，可能還是沒有說清楚，還是舉個例子來說明一下吧。如果我們的<t
arget-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) $< -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聯繫在一起呢。因爲這樣一來，我們的Makefile
也要根據這些源文件重新生成，讓Makefile 自已依賴於源文件？這個功能並不現實，不過我們可以
有其它手段來迂迴地實現這一功能。GNU組織建議把編譯器爲每一個源文件的自動生成的依賴關係
放到一個文件中，爲每一個“name.c”的文件都生成一個“name.d”的Makefile文件，[.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]文件都包含一個
完賴的規則。一旦我們完成這個工作，接下來，我們就要把這些自動生成的規則放進我們
的主Makefile中。我們可以使用 Makefile的“include”命令，來引入別的Makefile文件
（前面講過），例如：
sources = foo.c bar.c
include $(sources:.c=.d)
上述語句中的“$(sources:.c=.d)”中的“.c=.d”的意思是做一個替換，把變量$(sourc
es)所有[.c]的字串都替換成 [.d]，關於這個“替換”的內容，在後面我會有更爲詳細的
講述。當然，你得注意次序，因爲include是按次來載入文件，最先載入的[.d]文件中的目
標會成爲默認目標。
書寫命令
————
每條規則中的命令和操作系統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
示例二：
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”，這個參數的意思是，如果某規則中的命令出錯了，那麼就終目該規則的執行，
但繼續執行其它規則。
四、嵌套執行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
其等價於：
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”來執行，那麼當進入該目錄時，我們會看到：
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的其它部分中。
變量的命名字可以包含字符、數字，下劃線（可以是數字開頭），但不應該含有“:”、“#”、“=”或是空字符（空格、回車等）。
變量是大小寫敏感的，“foo”、“Foo”和“FOO”是三個不同的變量名。傳統的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)))
這裏的$(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
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 b
g q c)，調用的就是strip函數。
當然，“把變量的值再當成變量”這種技術，同樣可以用在操作符的左邊：
dir = foo
$(dir)_sources := $(wildcard $(dir)/*.c)
define $(dir)_print
lpr $($(dir)_sources)
endef
這個例子中定義了三個變量：“dir”，“foo_sources”和“foo_print”。
四、追加變量值
我們可以使用“+=”操作符給變量追加值，如：
objects = main.o foo.o bar.o utils.o
objects += another.o
於是，我們的$(objects)值變成：“main.ofoo.o bar.o utils.o another.o”（anothe
r.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中對這個變量的賦值會被忽略
。如果你想在Makefile中設置這類參數的值，那麼，你可以使用“override”指示符。其
語法是：
override <variable> = <value>
override <variable> := <value>
當然，你還可以追加：
override <variable> += <more text>
對於多行的變量定義，我們用define指示符，在define指示符前，也同樣可以使用ovveri
de指示符，如：
override define foo
bar
endef
六、多行變量
還有一種設置變量值的方法是使用define關鍵字。使用define關鍵字設置變量的值可以有
換行，這有利於定義一系列的命令（前面我們講過“命令包”的技術就是利用這個關鍵字
）。
define 指示符後面跟的是變量的名字，而重起一行定義變量的值，定義是以endef關鍵字
結束。其工作方式和“=”操作符一樣。變量的值可以包含函數、命令、文字，或是其它變
量。因爲命令需要以[Tab]鍵開頭，所以如果你用define定義的命令變量中沒有以[Tab]鍵
開頭，那麼make就不會把其認爲是命令。
下面的這個示例展示了define的用法：
define two-lines
echo foo
echo $(bar)
endef
七、環境變量
make 運行時的系統環境變量可以在make開始運行時被載入到Makefile文件中，但是如果M
akefile中已定義了這個變量，或是這個變量由make命令行帶入，那麼系統的環境變量的值
將被覆蓋。（如果make指定了“-e”參數，那麼，系統環境變量將覆蓋Makefile中定義的
變量）
因此，如果我們在環境變量中設置了“CFLAGS”環境變量，那麼我們就可以在所有的Make
file中使用這個變量了。這對於我們使用統一的編譯參數有比較大的好處。如果Makefile
中定義了CFLAGS，那麼則會使用Makefile中的這個變量，如果沒有定義則使用系統環境變
量的值，一個共性和個性的統一，很像“全局變量”和“局部變量”的特性。
當make嵌套調用時（參見前面的“嵌套調用”章節），上層Makefile中定義的變量會以系
統環境變量的方式傳遞到下層的Makefile中。當然，默認情況下，只有通過命令行設置的
變量會被傳遞。而定義在文件中的變量，如果要向下層 Makefile傳遞，則需要使用expro
t關鍵字來聲明。（參見前面章節）
當然，我並不推薦把許多的變量都定義在系統環境中，這樣，在我們執行不用的Makefile
時，擁有的是同一套系統變量，這可能會帶來更多的麻煩。
八、目標變量
前面我們所講的在Makefile中定義的變量都是“全局變量”，在整個文件，我們都可以訪
問這些變量。當然，“自動化變量”除外，如“$<”等這種類量的自動化變量就屬於“規
則型變量”，這種變量的值依賴於規則的目標和依賴目標的定義。
當然，我樣同樣可以爲某個目標設置局部變量，這種變量被稱爲“Target-specific Vari
able”，它可以和“全局變量”同名，因爲它的作用範圍只在這條規則以及連帶規則中，
所以其值也只在作用範圍內有效。而不會影響規則鏈以外的全局變量的值。
其語法是：
<target ...> : <variable-assignment>
<target ...> : overide <variable-assignment>
<variable-assignment>可以是前面講過的各種賦值表達式，如“=”、“:=”、“+=”或
是“？=”。第二個語法是針對於make命令行帶入的變量，或是系統環境變量。
這個特性非常的有用，當我們設置了這樣一個變量，這個變量會作用到由這個目標所引發
的所有的規則中去。如：
prog : CFLAGS = -g
prog : prog.o foo.o bar.o
$(CC) $(CFLAGS) prog.o foo.o bar.o
prog.o : prog.c
$(CC) $(CFLAGS) prog.c
foo.o : foo.c
$(CC) $(CFLAGS) foo.c
bar.o : bar.c
$(CC) $(CFLAGS) bar.c
在這個示例中，不管全局的$(CFLAGS)的值是什麼，在prog目標，以及其所引發的所有規則
中（prog.o foo.o bar.o的規則），$(CFLAGS)的值都是“-g”
九、模式變量
在GNU的make中，還支持模式變量（Pattern-specific Variable），通過上面的目標變量
中，我們知道，變量可以定義在某個目標上。模式變量的好處就是，我們可以給定一種“
模式”，可以把變量定義在符合這種模式的所有目標上。
我們知道，make的“模式”一般是至少含有一個“%”的，所以，我們可以以如下方式給所
有以[.o]結尾的目標定義目標變量：
%.o : CFLAGS = -O
同樣，模式變量的語法和“目標變量”一樣：
<pattern ...> : <variable-assignment>
<pattern ...> : override <variable-assignment>
override同樣是針對於系統環境傳入的變量，或是make命令行指定的變量。
使用條件判斷
——————
使用條件判斷，可以讓make根據運行時的不同情況選擇不同的執行分支。條件表達式可以是比較變量的值，
或是比較變量和常量的值。
一、示例
下面的例子，判斷$(CC)變量是否“gcc”，如果是的話，則使用GNU函數編譯目標。
libs_for_gcc = -lgnu
normal_libs =
foo: $(objects)
ifeq ($(CC),gcc)
$(CC) -o foo $(objects) $(libs_for_gcc)
else
$(CC) -o foo $(objects) $(normal_libs)
endif
可見，在上面示例的這個規則中，目標“foo”可以根據變量“$(CC)”值來選取不同的函數庫來編譯程序。
我們可以從上面的示例中看到三個關鍵字：ifeq、else和endif。ifeq的意思表示條件語句的開始，並指
定一個條件表達式，表達式包含兩個參數，以逗號分隔，表達式以圓括號括起。else表示條件表達式爲
假的情況。endif表示一個條件語句的結束，任何一個條件表達式都應該以endif結束。
當我們的變量$(CC)值是“gcc”時，目標foo的規則是：
foo: $(objects)
$(CC) -o foo $(objects) $(libs_for_gcc)
而當我們的變量$(CC)值不是“gcc”時（比如“cc”），目標foo的規則是：
foo: $(objects)
$(CC) -o foo $(objects) $(normal_libs)
當然，我們還可以把上面的那個例子寫得更簡潔一些：
libs_for_gcc = -lgnu
normal_libs =
ifeq ($(CC),gcc)
libs=$(libs_for_gcc)
else
libs=$(normal_libs)
endif
foo: $(objects)
$(CC) -o foo $(objects) $(libs)
二、語法
條件表達式的語法爲：
<conditional-directive>
<text-if-true>
endif
以及：
<conditional-directive>
<text-if-true>
else
<text-if-false>
endif
其中<conditional-directive>表示條件關鍵字，如“ifeq”。這個關鍵字有四個。第一個是我們前面所見過的“ifeq”
ifeq (<arg1>, <arg2> )
ifeq '<arg1>' '<arg2>'
ifeq "<arg1>" "<arg2>"
ifeq "<arg1>" '<arg2>'
ifeq '<arg1>' "<arg2>"
比較參數“arg1”和“arg2”的值是否相同。當然，參數中我們還可以使用make的函數。
如：
ifeq ($(strip $(foo)),)
<text-if-empty>
endif
這個示例中使用了“strip”函數，如果這個函數的返回值是空（Empty），那麼<text-if-empty>就生效。
第二個條件關鍵字是“ifneq”。語法是：
ifneq (<arg1>, <arg2> )
ifneq '<arg1>' '<arg2>'
ifneq "<arg1>" "<arg2>"
ifneq "<arg1>" '<arg2>'
ifneq '<arg1>' "<arg2>"
其比較參數“arg1”和“arg2”的值是否相同，如果不同，則爲真。和“ifeq”類似。
第三個條件關鍵字是“ifdef”。語法是：
ifdef <variable-name>
如果變量<variable-name>的值非空，那到表達式爲真。否則，表達式爲假。當然，<variable-name>同樣可以是
一個函數的返回值。注意，ifdef只是測試一個變量是否有值，其並不會把變量擴展到當前位置。還是來看兩個例子：
示例一：
bar =
foo = $(bar)
ifdef foo
frobozz = yes
else
frobozz = no
endif
示例二：
foo =
ifdef foo
frobozz = yes
else
frobozz = no
endif
第一個例子中，“$(frobozz)”值是“yes”，第二個則是“no”。
第四個條件關鍵字是“ifndef”。其語法是：
ifndef <variable-name>
這個我就不多說了，和“ifdef”是相反的意思。
在<conditional-directive>這一行上，多餘的空格是被允許的，但是不能以[Tab]鍵做爲
開始（不然就被認爲是命令）。而註釋符“#”同樣也是安全的。“else”和“endif”也
一樣，只要不是以[Tab]鍵開始就行了。
特別注意的是，make是在讀取Makefile時就計算條件表達式的值，並根據條件表達式的值
來選擇語句，所以，你最好不要把自動化變量（如“$@”等）放入條件表達式中，因爲自
動化變量是在運行時纔有的。
而且，爲了避免混亂，make不允許把整個條件語句分成兩部分放在不同的文件中。