|
七、環境變量 make運行時的系統環境變量可以在make開始運行時被載入到Makefile文件中，但是如果Makefile中已定義了這個變量，或是這個變量由 make命令行帶入，那么系統的環境變量的值將被覆蓋。（如果make指定了“-e”參數，那么，系統環境變量將覆蓋Makefile中定義的變量） 因此，如果我們在環境變量中設置了“CFLAGS”環境變量，那么我們就可以在所有的Makefile中使用這個變量了。這對于我們使用統一的編譯參數有 比較大的好處。如果Makefile中定義了CFLAGS，那么則會使用Makefile中的這個變量，如果沒有定義則使用系統環境變量的值，一個共性和 個性的統一，很像“全局變量”和“局部變量”的特性。 當make嵌套調用時（參見前面的“嵌套調用”章節），上層Makefile中定義的變量會以系統環境變量的方式傳遞到下層的Makefile中。當然， 默認情況下，只有通過命令行設置的變量會被傳遞。而定義在文件中的變量，如果要向下層Makefile傳遞，則需要使用exprot關鍵字來聲明。（參見 前面章節） 當然，我并不推薦把許多的變量都定義在系統環境中，這樣，在我們執行不用的Makefile時，擁有的是同一套系統變量，這可能會帶來更多的麻煩。
前面我們所講的在Makefile中定義的變量都是“全局變量”，在整個文件，我們都可以訪問這些變量。當然，“自動化變量”除外，如“$<”等這種類量的自動化變量就屬于“規則型變量”，這種變量的值依賴于規則的目標和依賴目標的定義。 當然，我樣同樣可以為某個目標設置局部變量，這種變量被稱為“Target-specific Variable”，它可以和“全局變量”同名，因為它的作用范圍只在這條規則以及連帶規則中，所以其值也只在作用范圍內有效。而不會影響規則鏈以外的全局變量的值。 其語法是： <target ...>; : <variable-assignment>; <target ...>; : overide <variable-assignment>; <variable-assignment>;可以是前面講過的各種賦值表達式，如“=”、“:=”、“+=”或是“？=”。第二個語法是針對于make命令行帶入的變量，或是系統環境變量。 這個特性非常的有用，當我們設置了這樣一個變量，這個變量會作用到由這個目標所引發的所有的規則中去。如： prog : CFLAGS = -g prog.o : prog.c foo.o : foo.c bar.o : 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 foo: $(objects) 可見，在上面示例的這個規則中，目標“foo”可以根據變量“$(CC)”值來選取不同的函數庫來編譯程序。 我們可以從上面的示例中看到三個關鍵字：ifeq、else和endif。ifeq的意思表示條件語句的開始，并指定一個條件表達式，表達式包含兩個參 數，以逗號分隔，表達式以圓括號括起。else表示條件表達式為假的情況。endif表示一個條件語句的結束，任何一個條件表達式都應該以endif結 束。 當我們的變量$(CC)值是“gcc”時，目標foo的規則是： foo: $(objects) 而當我們的變量$(CC)值不是“gcc”時（比如“cc”），目標foo的規則是： foo: $(objects) 當然，我們還可以把上面的那個例子寫得更簡潔一些： libs_for_gcc = -lgnu ifeq ($(CC),gcc) foo: $(objects)
條件表達式的語法為： <conditional-directive>; 以及： <conditional-directive>; 其中<conditional-directive>;表示條件關鍵字，如“ifeq”。這個關鍵字有四個。 第一個是我們前面所見過的“ifeq” ifeq (<arg1>;, <arg2> 比較參數“arg1”和“arg2”的值是否相同。當然，參數中我們還可以使用make的函數。如： ifeq ($(strip $(foo)),) 這個示例中使用了“strip”函數，如果這個函數的返回值是空（Empty），那么<text-if-empty>;就生效。 第二個條件關鍵字是“ifneq”。語法是： ifneq (<arg1>;, <arg2> 其比較參數“arg1”和“arg2”的值是否相同，如果不同，則為真。和“ifeq”類似。 第三個條件關鍵字是“ifdef”。語法是： ifdef <variable-name>; 如果變量<variable-name>;的值非空，那到表達式為真。否則，表達式為假。當然，<variable- name>;同樣可以是一個函數的返回值。注意，ifdef只是測試一個變量是否有值，其并不會把變量擴展到當前位置。還是來看兩個例子： 示例一： 示例二： 第一個例子中，“$(frobozz)”值是“yes”，第二個則是“no”。 第四個條件關鍵字是“ifndef”。其語法是： ifndef <variable-name>; 這個我就不多說了，和“ifdef”是相反的意思。 在<conditional-directive>;這一行上，多余的空格是被允許的，但是不能以[Tab]鍵做為開始（不然就被認為是命令）。而注釋符“#”同樣也是安全的。“else”和“endif”也一樣，只要不是以[Tab]鍵開始就行了。 特別注意的是，make是在讀取Makefile時就計算條件表達式的值，并根據條件表達式的值來選擇語句，所以，你最好不要把自動化變量（如“$@”等）放入條件表達式中，因為自動化變量是在運行時才有的。 而且，為了避免混亂，make不允許把整個條件語句分成兩部分放在不同的文件中。 在Makefile中可以使用函數來處理變量，從而讓我們的命令或是規則更為的靈活和具有智能。make所支持的函數也不算很多，不過已經足夠我們的操作了。函數調用后，函數的返回值可以當做變量來使用。
函數調用，很像變量的使用，也是以“$”來標識的，其語法如下： $(<function>; <arguments> 或是 ${<function>; <arguments>;} 這里，<function>;就是函數名，make支持的函數不多。<arguments>;是函數的參數，參數間以逗號“,” 分隔，而函數名和參數之間以“空格”分隔。函數調用以“$”開頭，以圓括號或花括號把函數名和參數括起。感覺很像一個變量，是不是？函數中的參數可以使用 變量，為了風格的統一，函數和變量的括號最好一樣，如使用“$(subst a,b,$(x))”這樣的形式，而不是“$(subst a,b,${x})”的形式。因為統一會更清楚，也會減少一些不必要的麻煩。 還是來看一個示例： comma:= , 在這個示例中，$(comma)的值是一個逗號。$(space)使用了$(empty)定義了一個空格，$(foo)的值是“a b c”，$(bar)的定義用，調用了函數“subst”，這是一個替換函數，這個函數有三個參數，第一個參數是被替換字串，第二個參數是替換字串，第三個 參數是替換操作作用的字串。這個函數也就是把$(foo)中的空格替換成逗號，所以$(bar)的值是“a,b,c”。
$(subst <from>;,<to>;,<text> 名稱：字符串替換函數——subst。 示例：
名稱：模式字符串替換函數——patsubst。 示例： $(patsubst %.c,%.o,x.c.c bar.c) 把字串“x.c.c bar.c”符合模式[%.c]的單詞替換成[%.o]，返回結果是“x.c.o bar.o” 備注： 這和我們前面“變量章節”說過的相關知識有點相似。如： “$(var:<pattern>;=<replacement>” 而“$(var: <suffix>;=<replacement>” 例如有：objects = foo.o bar.o baz.o， $(strip <string> 名稱：去空格函數——strip。 把字串“a b c ”去到開頭和結尾的空格，結果是“a b c”。 $(findstring <find>;,<in> 名稱：查找字符串函數——findstring。 $(findstring a,a b c) 第一個函數返回“a”字符串，第二個返回“”字符串（空字符串） $(filter <pattern...>;,<text> 名稱：過濾函數——filter。 sources := foo.c bar.c baz.s ugh.h $(filter %.c %.s,$(sources))返回的值是“foo.c bar.c baz.s”。 $(filter-out <pattern...>;,<text> 名稱：反過濾函數——filter-out。 bjects=main1.o foo.o main2.o bar.o 名稱：排序函數——sort。 $(word <n>;,<text>;) 名稱：取單詞函數——word。 $(wordlist <s>;,<e>;,<text>;) 名稱：取單詞串函數——wordlist。 $(words <text>;) 名稱：單詞個數統計函數——words。 $(firstword <text>;) 名稱：首單詞函數——firstword。 以上，是所有的字符串操作函數，如果搭配混合使用，可以完成比較復雜的功能。這里，舉一個現實中應用的例子。我們知道，make使用“VPATH”變量來指定“依賴文件”的搜索路徑。于是，我們可以利用這個搜索路徑來指定編譯器對頭文件的搜索路徑參數CFLAGS，如： override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH))) 如果我們的“$(VPATH)”值是“src:../headers”，那么“$(patsubst %,-I%,$(subst :, ,$(VPATH)))”將返回“-Isrc -I../headers”，這正是cc或gcc搜索頭文件路徑的參數。
下面我們要介紹的函數主要是處理文件名的。每個函數的參數字符串都會被當做一個或是一系列的文件名來對待。 $(dir <names...>;) 名稱：取目錄函數——dir。 $(notdir <names...>;) 名稱：取文件函數——notdir。 $(suffix <names...>;) $(basename <names...>;) 名稱：取前綴函數——basename。 $(addsuffix <suffix>;,<names...>;) 名稱：加后綴函數——addsuffix。 $(addprefix <prefix>;,<names...>;) 名稱：加前綴函數——addprefix。 $(join <list1>;,<list2>;) 名稱：連接函數——join。
$(foreach <var>;,<list>;,<text>
這個函數的意思是，把參數<list>;中的單詞逐一取出放到參數<var>;所指定的變量中，然后再執行< text>;所包含的表達式。每一次<text>;會返回一個字符串，循環過程中，<text>;的所返回的每個字符串會 以空格分隔，最后當整個循環結束時，<text>;所返回的每個字符串所組成的整個字符串（以空格分隔）將會是foreach函數的返回值。
所以，<var>;最好是一個變量名，<list>;可以是一個表達式，而<text>;中一般會使用<var>;這個參數來依次枚舉<list>;中的單詞。舉個例子：
names := a b c d files := $(foreach n,$(names),$(n).o)
上面的例子中，$(name)中的單詞會被挨個取出，并存到變量“n”中，“$(n).o”每次根據“$(n)”計算出一個值，這些值以空格分隔，最后作為foreach函數的返回，所以，$(files)的值是“a.o b.o c.o d.o”。
注意，foreach中的<var>;參數是一個臨時的局部變量，foreach函數執行完后，參數<var>;的變量將不在作用，其作用域只在foreach函數當中。
五、if 函數
$(if <condition>;,<then-part>
或是
$(if <condition>;,<then-part>;,<else-part>
可見，if函數可以包含“else”部分，或是不含。即if函數的參數可以是兩個，也可以是三個。<condition>;參數是if的表達 式，如果其返回的為非空字符串，那么這個表達式就相當于返回真，于是，<then-part>;會被計算，否則<else- part>;會被計算。
而if函數的返回值是，如果<condition>;為真（非空字符串），那個<then-part>;會是整個函數的返回值， 如果<condition>;為假（空字符串），那么<else-part>;會是整個函數的返回值，此時如果<else -part>;沒有被定義，那么，整個函數返回空字串。
所以，<then-part>;和<else-part>;只會有一個被計算。
六、call函數
$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)
當make執行這個函數時，<expression>;參數中的變量，如$(1)，$(2)，$(3)等，會被參數< parm1>;，<parm2>;，<parm3>;依次取代。而<expression>;的返回值就是 call函數的返回值。例如： reverse = $(1) $(2) foo = $(call reverse,a,b)
那么，foo的值就是“a b”。當然，參數的次序是可以自定義的，不一定是順序的，如：
reverse = $(2) $(1) foo = $(call reverse,a,b)
此時的foo的值就是“b a”。
七、origin函數
$(origin <variable>
注意，<variable>;是變量的名字，不應該是引用。所以你最好不要在<variable>;中使用“$”字符。Origin函數會以其返回值來告訴你這個變量的“出生情況”，下面，是origin函數的返回值:
“undefined” 如果<variable>;從來沒有定義過，origin函數返回這個值“undefined”。
“default” 如果<variable>;是一個默認的定義，比如“CC”這個變量，這種變量我們將在后面講述。
“environment” 如果<variable>;是一個環境變量，并且當Makefile被執行時，“-e”參數沒有被打開。
“file” 如果<variable>;這個變量被定義在Makefile中。
“command line” 如果<variable>;這個變量是被命令行定義的。
“override” 如果<variable>;是被override指示符重新定義的。
“automatic” 如果<variable>;是一個命令運行中的自動化變量。關于自動化變量將在后面講述。
這些信息對于我們編寫Makefile是非常有用的，例如，假設我們有一個Makefile其包了一個定義文件Make.def，在Make.def中定 義了一個變量“bletch”，而我們的環境中也有一個環境變量“bletch”，此時，我們想判斷一下，如果變量來源于環境，那么我們就把之重定義了， 如果來源于Make.def或是命令行等非環境的，那么我們就不重新定義它。于是，在我們的Makefile中，我們可以這樣寫：
ifdef bletch ifeq "$(origin bletch)" "environment" bletch = barf, gag, etc. endif endif
當然，你也許會說，使用override關鍵字不就可以重新定義環境中的變量了嗎？為什么需要使用這樣的步驟？是的，我們用override是可以達到這 樣的效果，可是override過于粗暴，它同時會把從命令行定義的變量也覆蓋了，而我們只想重新定義環境傳來的，而不想重新定義命令行傳來的。
八、shell函數
contents := $(shell cat foo)
files := $(shell echo *.c)
注意，這個函數會新生成一個Shell程序來執行命令，所以你要注意其運行性能，如果你的Makefile中有一些比較復雜的規則，并大量使用了這個函 數，那么對于你的系統性能是有害的。特別是Makefile的隱晦的規則可能會讓你的shell函數執行的次數比你想像的多得多。
九、控制make的函數
$(error <text ...>
產生一個致命的錯誤，<text ...>;是錯誤信息。注意，error函數不會在一被使用就會產生錯誤信息，所以如果你把其定義在某個變量中，并在后續的腳本中使用這個變量，那么也是可以的。例如：
示例一： ifdef ERROR_001 $(error error is $(ERROR_001)) endif
示例二： ERR = $(error found an error!) .PHONY: err err: ; $(ERR)
示例一會在變量ERROR_001定義了后執行時產生error調用，而示例二則在目錄err被執行時才發生error調用。
$(warning <text ...>
這個函數很像error函數，只是它并不會讓make退出，只是輸出一段警告信息，而make繼續執行。 一般來說，最簡單的就是直接在命令行下輸入make命令，make命令會找當前目錄的makefile來執行，一切都是自動的。但也有時你也許只想讓 make重編譯某些文件，而不是整個工程，而又有的時候你有幾套編譯規則，你想在不同的時候使用不同的編譯規則，等等。本章節就是講述如何使用make命 令的。 一、make的退出碼 make命令執行后有三個退出碼： 0 —— 表示成功執行。 Make的相關參數我們會在后續章節中講述。
前面我們說過，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 基于上面的這個例子，只要我們輸入的命令不是“make clean”，那么makefile會自動包含“foo.d”和“bar.d”這兩個makefile。 使用指定終極目標的方法可以很方便地讓我們編譯我們的程序，例如下面這個例子： .PHONY: all 從這個例子中，我們可以看到，這個makefile中有四個需要編譯的程序——“prog1”， “prog2”， “prog3”和 “prog4”，我們可以使用“make all”命令來編譯所有的目標（如果把all置成第一個目標，那么只需執行“make”），我們也可以使用“make prog2”來單獨編譯目標“prog2”。 即然make可以指定所有makefile中的目標，那么也包括“偽目標”，于是我們可以根據這種性質來讓我們的makefile根據指定的不同的目標來 完成不同的事。在Unix世界中，軟件發布時，特別是GNU這種開源軟件的發布時，其makefile都包含了編譯、安裝、打包等功能。我們可以參照這種 規則來書寫我們的makefile中的目標。 “all” 當然一個項目的makefile中也不一定要書寫這樣的目標，這些東西都是GNU的東西，但是我想，GNU搞出這些東西一定有其可取之處（等你的UNIX 下的程序文件一多時你就會發現這些功能很有用了），這里只不過是說明了，如果你要書寫這種功能，最好使用這種名字命名你的目標，這樣規范一些，規范的好處 就是——不用解釋，大家都明白。而且如果你的makefile中有這些功能，一是很實用，二是可以顯得你的makefile很專業（不是那種初學者的作 品）。
有時候，我們不想讓我們的makefile中的規則執行起來，我們只想檢查一下我們的命令，或是執行的序列。于是我們可以使用make命令的下述參數： “-n” “-t” “-q” “-W <file>;” 另外一個很有意思的用法是結合“-p”和“-v”來輸出makefile被執行時的信息（這個將在后面講述）。
下面列舉了所有GNU make 3.80版的參數定義。其它版本和產商的make大同小異，不過其它產商的make的具體參數還是請參考各自的產品文檔。 “-b” “-B” “-C <dir>;” “—debug[=<options>;]” “-d” “-e” “-f=<file>;” “-h” “-i” “-I <dir>;” “-j [<jobsnum>;]” “-k” “-l <load>;” “-n” “-o <file>;” “-p” “-q” “-r” “-R” “-s” “-S” “-t” “-v” “-w” “--no-print-directory” “-W <file>;” “--warn-undefined-variables” 隱含規則 在我們使用Makefile時，有一些我們會經常使用，而且使用頻率非常高的東西，比如，我們編譯C/C++的源程序為中間目標文件（Unix下是 [.o]文件，Windows下是[.obj]文件）。本章講述的就是一些在Makefile中的“隱含的”，早先約定了的，不需要我們再寫出來的規則。 “隱含規則”也就是一種慣例，make會按照這種“慣例”心照不喧地來運行，那怕我們的Makefile中沒有書寫這樣的規則。例如，把[.c]文件編譯成[.o]文件這一規則，你根本就不用寫出來，make會自動推導出這種規則，并生成我們需要的[.o]文件。 “隱含規則”會使用一些我們系統變量，我們可以改變這些系統變量的值來定制隱含規則的運行時的參數。如系統變量“CFLAGS”可以控制編譯時的編譯器參數。 我們還可以通過“模式規則”的方式寫下自己的隱含規則。用“后綴規則”來定義隱含規則會有許多的限制。使用“模式規則”會更回得智能和清楚，但“后綴規則”可以用來保證我們Makefile的兼容性。
如果要使用隱含規則生成你需要的目標，你所需要做的就是不要寫出這個目標的規則。那么，make會試圖去自動推導產生這個目標的規則和命令，如果make 可以自動推導生成這個目標的規則和命令，那么這個行為就是隱含規則的自動推導。當然，隱含規則是make事先約定好的一些東西。例如，我們有下面的一個 Makefile： foo : foo.o bar.o 我們可以注意到，這個Makefile中并沒有寫下如何生成foo.o和bar.o這兩目標的規則和命令。因為make的“隱含規則”功能會自動為我們自動去推導這兩個目標的依賴目標和生成命令。 make會在自己的“隱含規則”庫中尋找可以用的規則，如果找到，那么就會使用。如果找不到，那么就會報錯。在上面的那個例子中，make調用的隱含規則 是，把[.o]的目標的依賴文件置成[.c]，并使用C的編譯命令“cc –c $(CFLAGS) [.c]”來生成[.o]的目標。也就是說，我們完全沒有必要寫下下面的兩條規則： foo.o : foo.c 因為，這已經是“約定”好了的事了，make和我們約定好了用C編譯器“cc”生成[.o]文件的規則，這就是隱含規則。 當然，如果我們為[.o]文件書寫了自己的規則，那么make就不會自動推導并調用隱含規則，它會按照我們寫好的規則忠實地執行。 還有，在make的“隱含規則庫”中，每一條隱含規則都在庫中有其順序，越靠前的則是越被經常使用的，所以，這會導致我們有些時候即使我們顯示地指定了目標依賴，make也不會管。如下面這條規則（沒有命令）： foo.o : foo.p 依賴文件“foo.p”（Pascal程序的源文件）有可能變得沒有意義。如果目錄下存在了“foo.c”文件，那么我們的隱含規則一樣會生效，并會通過 “foo.c”調用C的編譯器生成foo.o文件。因為，在隱含規則中，Pascal的規則出現在C的規則之后，所以，make找到可以生成foo.o的 C的規則就不再尋找下一條規則了。如果你確實不希望任何隱含規則推導，那么，你就不要只寫出“依賴規則”，而不寫命令。
這里我們將講述所有預先設置（也就是make內建）的隱含規則，如果我們不明確地寫下規則，那么，make就會在這些規則中尋找所需要規則和命令。當然，我們也可以使用make的參數“-r”或“--no-builtin-rules”選項來取消所有的預設置的隱含規則。 當然，即使是我們指定了“-r”參數，某些隱含規則還是會生效，因為有許多的隱含規則都是使用了“后綴規則”來定義的，所以，只要隱含規則中有“后綴列 表”（也就一系統定義在目標.SUFFIXES的依賴目標），那么隱含規則就會生效。默認的后綴列表是：.out, .a, .ln, .o, .c, .cc, .C, .p, .f, .F, .r, .y, .l, .s, .S, .mod, .sym, .def, .h, .info, .dvi, .tex, .texinfo, .texi, .txinfo, .w, .ch .web, .sh, .elc, .el。具體的細節，我們會在后面講述。 還是先來看一看常用的隱含規則吧。 1、編譯C程序的隱含規則。 2、編譯C++程序的隱含規則。 3、編譯Pascal程序的隱含規則。 4、編譯Fortran/Ratfor程序的隱含規則。 5、預處理Fortran/Ratfor程序的隱含規則。 6、編譯Modula-2程序的隱含規則。 7、匯編和匯編預處理的隱含規則。 8、鏈接Object文件的隱含規則。 x : y.o z.o 并且“x.c”、“y.c”和“z.c”都存在時，隱含規則將執行如下命令： cc -c x.c -o x.o 如果沒有一個源文件（如上例中的x.c）和你的目標名字（如上例中的x）相關聯，那么，你最好寫出自己的生成規則，不然，隱含規則會報錯的。 9、Yacc C程序時的隱含規則。 10、Lex C程序時的隱含規則。 11、Lex Ratfor程序時的隱含規則。 12、從C程序、Yacc文件或Lex文件創建Lint庫的隱含規則。
在隱含規則中的命令中，基本上都是使用了一些預先設置的變量。你可以在你的makefile中改變這些變量的值，或是在make的命令行中傳入這些值，或 是在你的環境變量中設置這些值，無論怎么樣，只要設置了這些特定的變量，那么其就會對隱含規則起作用。當然，你也可以利用make的“-R”或“-- no–builtin-variables”參數來取消你所定義的變量對隱含規則的作用。 例如，第一條隱含規則——編譯C程序的隱含規則的命令是“$(CC) –c $(CFLAGS) $(CPPFLAGS)”。Make默認的編譯命令是“cc”，如果你把變量“$(CC)”重定義成“gcc”，把變量“$(CFLAGS)”重定義成 “-g”，那么，隱含規則中的命令全部會以“gcc –c -g $(CPPFLAGS)”的樣子來執行了。 我們可以把隱含規則中使用的變量分成兩種：一種是命令相關的，如“CC”；一種是參數相的關，如“CFLAGS”。下面是所有隱含規則中會用到的變量： 1、關于命令的變量。 AR 2、關于命令參數的變量 下面的這些變量都是相關上面的命令的參數。如果沒有指明其默認值，那么其默認值都是空。 ARFLAGS
有些時候，一個目標可能被一系列的隱含規則所作用。例如，一個[.o]的文件生成，可能會是先被Yacc的[.y]文件先成[.c]，然后再被C的編譯器生成。我們把這一系列的隱含規則叫做“隱含規則鏈”。 在上面的例子中，如果文件[.c]存在，那么就直接調用C的編譯器的隱含規則，如果沒有[.c]文件，但有一個[.y]文件，那么Yacc的隱含規則會被調用，生成[.c]文件，然后，再調用C編譯的隱含規則最終由[.c]生成[.o]文件，達到目標。 我們把這種[.c]的文件（或是目標），叫做中間目標。不管怎么樣，make會努力自動推導生成目標的一切方法，不管中間目標有多少，其都會執著地把所有 的隱含規則和你書寫的規則全部合起來分析，努力達到目標，所以，有些時候，可能會讓你覺得奇怪，怎么我的目標會這樣生成？怎么我的makefile發瘋 了？ 在默認情況下，對于中間目標，它和一般的目標有兩個地方所不同：第一個不同是除非中間的目標不存在，才會引發中間規則。第二個不同的是，只要目標成功產生，那么，產生最終目標過程中，所產生的中間目標文件會被以“rm -f”刪除。 通常，一個被makefile指定成目標或是依賴目標的文件不能被當作中介。然而，你可以明顯地說明一個文件或是目標是中介目標，你可以使用偽目標“.INTERMEDIATE”來強制聲明。（如：.INTERMEDIATE ： mid ） 你也可以阻止make自動刪除中間目標，要做到這一點，你可以使用偽目標“.SECONDARY”來強制聲明（如：.SECONDARY : sec）。你還可以把你的目標，以模式的方式來指定（如：%.o）成偽目標“.PRECIOUS”的依賴目標，以保存被隱含規則所生成的中間文件。 在“隱含規則鏈”中，禁止同一個目標出現兩次或兩次以上，這樣一來，就可防止在make自動推導時出現無限遞歸的情況。 Make會優化一些特殊的隱含規則，而不生成中間文件。如，從文件“foo.c”生成目標程序“foo”，按道理，make會編譯生成中間文件 “foo.o”，然后鏈接成“foo”，但在實際情況下，這一動作可以被一條“cc”的命令完成（cc –o foo foo.c），于是優化過的規則就不會生成中間文件。 你可以使用模式規則來定義一個隱含規則。一個模式規則就好像一個一般的規則，只是在規則中，目標的定義需要有"%"字符。"%"的意思是表示一個或多個任意字符。在依賴目標中同樣可以使用"%"，只是依賴目標中的"%"的取值，取決于其目標。 有一點需要注意的是，"%"的展開發生在變量和函數的展開之后，變量和函數的展開發生在make載入Makefile時，而模式規則中的"%"則發生在運行時。
模式規則中，至少在規則的目標定義中要包含"%"，否則，就是一般的規則。目標中的"%"定義表示對文件名的匹配，"%"表示長度任意的非空字符串。例 如："%.c"表示以".c"結尾的文件名（文件名的長度至少為3），而"s.%.c"則表示以"s."開頭，".c"結尾的文件名（文件名的長度至少為 5）。 如果"%"定義在目標中，那么，目標中的"%"的值決定了依賴目標中的"%"的值，也就是說，目標中的模式的"%"決定了依賴目標中"%"的樣子。例如有一個模式規則如下： %.o : %.c ; <command ......>; 其含義是，指出了怎么從所有的[.c]文件生成相應的[.o]文件的規則。如果要生成的目標是"a.o b.o"，那么"%c"就是"a.c b.c"。 一旦依賴目標中的"%"模式被確定，那么，make會被要求去匹配當前目錄下所有的文件名，一旦找到，make就會規則下的命令，所以，在模式規則中，目 標可能會是多個的，如果有模式匹配出多個目標，make就會產生所有的模式目標，此時，make關心的是依賴的文件名和生成目標的命令這兩件事。
下面這個例子表示了,把所有的[.c]文件都編譯成[.o]文件. %.o : %.c 其中，"$@"表示所有的目標的挨個值，"$<"表示了所有依賴目標的挨個值。這些奇怪的變量我們叫"自動化變量"，后面會詳細講述。 下面的這個例子中有兩個目標是模式的： %.tab.c %.tab.h: %.y 這條規則告訴make把所有的[.y]文件都以"bison -d <n>;.y"執行，然后生成"<n>;.tab.c"和"<n>;.tab.h"文件。（其中，"< n>;"表示一個任意字符串）。如果我們的執行程序"foo"依賴于文件"parse.tab.o"和"scan.o"，并且文件"scan.o" 依賴于文件"parse.tab.h"，如果"parse.y"文件被更新了，那么根據上述的規則，"bison -d parse.y"就會被執行一次，于是，"parse.tab.o"和"scan.o"的依賴文件就齊了。（假設，"parse.tab.o"由 "parse.tab.c"生成，和"scan.o"由"scan.c"生成，而"foo"由"parse.tab.o"和"scan.o"鏈接生成，而 且foo和其[.o]文件的依賴關系也寫好，那么，所有的目標都會得到滿足）
在上述的模式規則中，目標和依賴文件都是一系例的文件，那么我們如何書寫一個命令來完成從不同的依賴文件生成相應的目標？因為在每一次的對模式規則的解析時，都會是不同的目標和依賴文件。 自動化變量就是完成這個功能的。在前面，我們已經對自動化變量有所提涉，相信你看到這里已對它有一個感性認識了。所謂自動化變量，就是這種變量會把模式中所定義的一系列的文件自動地挨個取出，直至所有的符合模式的文件都取完了。這種自動化變量只應出現在規則的命令中。 下面是所有的自動化變量及其說明： $@ $% $< $? $^ $+ $* 當你希望只對更新過的依賴文件進行操作時，"$?"在顯式規則中很有用，例如，假設有一個函數庫文件叫"lib"，其由其它幾個object文件更新。那么把object文件打包的比較有效率的Makefile規則是： lib : foo.o bar.o lose.o win.o 在上述所列出來的自動量變量中。四個變量（$@、$<、$%、$*）在擴展時只會有一個文件，而另三個的值是一個文件列表。這七個自動化變量還可以 取得文件的目錄名或是在當前目錄下的符合模式的文件名，只需要搭配上"D"或"F"字樣。這是GNU make中老版本的特性，在新版本中，我們使用函數"dir"或"notdir"就可以做到了。"D"的含義就是Directory，就是目錄，"F"的 含義就是File，就是文件。 下面是對于上面的七個變量分別加上"D"或是"F"的含義： $(@D) $(@F) "$(*D)" "$(%D)" "$(<D)" "$(^D)" "$(+D)" "$(?D)" 最后想提醒一下的是，對于"$<"，為了避免產生不必要的麻煩，我們最好給$后面的那個特定字符都加上圓括號，比如，"$(<"就要比"$<"要好一些。 還得要注意的是，這些變量只使用在規則的命令中，而且一般都是"顯式規則"和"靜態模式規則"（參見前面"書寫規則"一章）。其在隱含規則中并沒有意義。 4、模式的匹配 一般來說，一個目標的模式有一個有前綴或是后綴的"%"，或是沒有前后綴，直接就是一個"%"。因為"%"代表一個或多個字符，所以在定義好了的模式中， 我們把"%"所匹配的內容叫做"莖"，例如"%.c"所匹配的文件"test.c"中"test"就是"莖"。因為在目標和依賴目標中同時有"%"時，依 賴目標的"莖"會傳給目標，當做目標中的"莖"。 當一個模式匹配包含有斜杠（實際也不經常包含）的文件時，那么在進行模式匹配時，目錄部分會首先被移開，然后進行匹配，成功后，再把目錄加回去。在進行" 莖"的傳遞時，我們需要知道這個步驟。例如有一個模式"e%t"，文件"src/eat"匹配于該模式，于是"src/a"就是其"莖"，如果這個模式定 義在依賴目標中，而被依賴于這個模式的目標中又有個模式"c%r"，那么，目標就是"src/car"。（"莖"被傳遞）
你可以重載內建的隱含規則（或是定義一個全新的），例如你可以重新構造和內建隱含規則不同的命令，如： %.o : %.c 你可以取消內建的隱含規則，只要不在后面寫命令就行。如： %.o : %.s 同樣，你也可以重新定義一個全新的隱含規則，其在隱含規則中的位置取決于你在哪里寫下這個規則。朝前的位置就靠前。
后綴規則是一個比較老式的定義隱含規則的方法。后綴規則會被模式規則逐步地取代。因為模式規則更強更清晰。為了和老版本的Makefile兼容，GNU make同樣兼容于這些東西。后綴規則有兩種方式："雙后綴"和"單后綴"。 雙后綴規則定義了一對后綴：目標文件的后綴和依賴目標（源文件）的后綴。如".c.o"相當于"%o : %c"。單后綴規則只定義一個后綴，也就是源文件的后綴。如".c"相當于"% : %.c"。 后綴規則中所定義的后綴應該是make所認識的，如果一個后綴是make所認識的，那么這個規則就是單后綴規則，而如果兩個連在一起的后綴都被make所 認識，那就是雙后綴規則。例如：".c"和".o"都是make所知道。因而，如果你定義了一個規則是".c.o"那么其就是雙后綴規則，意義就是 ".c"是源文件的后綴，".o"是目標文件的后綴。如下示例： .c.o: 后綴規則不允許任何的依賴文件，如果有依賴文件的話，那就不是后綴規則，那些后綴統統被認為是文件名，如： .c.o: foo.h 這個例子，就是說，文件".c.o"依賴于文件"foo.h"，而不是我們想要的這樣： %.o: %.c foo.h 后綴規則中，如果沒有命令，那是毫無意義的。因為他也不會移去內建的隱含規則。 而要讓make知道一些特定的后綴，我們可以使用偽目標".SUFFIXES"來定義或是刪除，如： .SUFFIXES: .hack .win 把后綴.hack和.win加入后綴列表中的末尾。 .SUFFIXES: # 刪除默認的后綴 先清楚默認后綴，后定義自己的后綴列表。 make的參數"-r"或"-no-builtin-rules"也會使用得默認的后綴列表為空。而變量"SUFFIXE"被用來定義默認的后綴列表，你可以用".SUFFIXES"來改變后綴列表，但請不要改變變量"SUFFIXE"的值。
比如我們有一個目標叫 T。下面是搜索目標T的規則的算法。請注意，在下面，我們沒有提到后綴規則，原因是，所有的后綴規則在Makefile被載入內存時，會被轉換成模式規 則。如果目標是"archive(member)"的函數庫文件模式，那么這個算法會被運行兩次，第一次是找目標T，如果沒有找到的話，那么進入第二次， 第二次會把"member"當作T來搜索。 1、把T的目錄部分分離出來。叫D，而剩余部分叫N。（如：如果T是"src/foo.o"，那么，D就是"src/"，N就是"foo.o"） 2、創建所有匹配于T或是N的模式規則列表。 3、如果在模式規則列表中有匹配所有文件的模式，如"%"，那么從列表中移除其它的模式。 4、移除列表中沒有命令的規則。 5、對于第一個在列表中的模式規則： 6、如果經過第5步，沒有模式規則被找到，那么就做更進一步的搜索。對于存在于列表中的第一個模式規則： 7、如果沒有隱含規則可以使用，查看".DEFAULT"規則，如果有，采用，把".DEFAULT"的命令給T使用。 一旦規則被找到，就會執行其相當的命令，而此時，我們的自動化變量的值才會生成。 使用make更新函數庫文件 函數庫文件也就是對Object文件（程序編譯的中間文件）的打包文件。在Unix下，一般是由命令"ar"來完成打包工作。 一、函數庫文件的成員 一個函數庫文件由多個文件組成。你可以以如下格式指定函數庫文件及其組成： archive(member) 這個不是一個命令，而一個目標和依賴的定義。一般來說，這種用法基本上就是為了"ar"命令來服務的。如： foolib(hack.o) : hack.o 如果要指定多個member，那就以空格分開，如： foolib(hack.o kludge.o) 其等價于： foolib(hack.o) foolib(kludge.o) 你還可以使用Shell的文件通配符來定義，如： foolib(*.o)
當make搜索一個目標的隱含規則時，一個特殊的特性是，如果這個目標是"a(m)"形式的，其會把目標變成"(m)"。于是，如果我們的成員是"%. o"的模式定義，并且如果我們使用"make foo.a(bar.o)"的形式調用Makefile時，隱含規則會去找"bar.o"的規則，如果沒有定義bar.o的規則，那么內建隱含規則生效， make會去找bar.c文件來生成bar.o，如果找得到的話，make執行的命令大致如下： cc -c bar.c -o bar.o 還有一個變量要注意的是"$%"，這是專屬函數庫文件的自動化變量，有關其說明請參見"自動化變量"一節。
你可以使用"后綴規則"和"隱含規則"來生成函數庫打包文件，如： .c.a: 其等效于： (%.o) : %.c
在進行函數庫打包文件生成時，請小心使用make的并行機制（"-j"參數）。如果多個ar命令在同一時間運行在同一個函數庫打包文件上，就很有可以損壞這個函數庫文件。所以，在make未來的版本中，應該提供一種機制來避免并行操作發生在函數打包文件上。 但就目前而言，你還是應該不要盡量不要使用"-j"參數。
后序 終于到寫結束語的時候了，以上基本上就是GNU make的Makefile的所有細節了。其它的產商的make基本上也就是這樣的，無論什么樣的make，都是以文件的依賴性為基礎的，其基本是都是遵 循一個標準的。這篇文檔中80%的技術細節都適用于任何的make，我猜測"函數"那一章的內容可能不是其它make所支持的，而隱含規則方面，我想不同 的make會有不同的實現，我沒有精力來查看GNU的make和VC的nmake、BCB的make，或是別的UNIX下的make有些什么樣的差別，一 是時間精力不夠，二是因為我基本上都是在Unix下使用make，以前在SCO Unix和IBM的AIX，現在在Linux、Solaris、HP-UX、AIX和Alpha下使用，Linux和Solaris下更多一點。不過，我 可以肯定的是，在Unix下的make，無論是哪種平臺，幾乎都使用了Richard Stallman開發的make和cc/gcc的編譯器，而且，基本上都是GNU的make（公司里所有的UNIX機器上都被裝上了GNU的東西，所以， 使用GNU的程序也就多了一 |
