【 MAKEFILE 程式設計基礎之四】詳解MAKEFILE 函數的文法與使用！

在makefile中可以使用函數來處理變量，進而讓我們的指令或是規則更為的靈活和具有智能。make所支援的函數也不算很多，不過已經足夠我們的操作了。函數調用後，函數的傳回值可以當做變量來使用。

一、函數的調用文法

函數調用，很像變量的使用，也是以“$”來辨別的，其文法如下：

$(<function> <arguments> )

或是

${<function> <arguments>}

這裡，<function>就是函數名，make支援的函數不多。<arguments>是函數的參數，參數間以逗号“,”分隔，而函數名和參數之間以“空格”分隔。函數調用以“$”開頭，以圓括号或花括号把函數名和參數括起。感覺很像一個變量，是不是？函數中的參數可以使用變量，為了風格的統一，函數和變量的括号最好一樣，如使用“$(subst a,b,$(x))”這樣的形式，而不是“$(subst a,b,${x})”的形式。因為統一會更清楚，也會減少一些不必要的麻煩。

還是來看一個示例：

comma:= ,

empty:=

space:= $(empty) $(empty)

foo:= a b c

bar:= $(subst $(space),$(comma),$(foo))

在這個示例中，$(comma)的值是一個逗号。$(space)使用了$(empty)定義了一個空格，$(foo)的值是“a b c”，$(bar)的定義用，調用了函數“subst”，這是一個替換函數，這個函數有三個參數，第一個參數是被替換字串，第二個參數是替換字串，第三個參數是替換操作作用的字串。這個函數也就是把$(foo)中的空格替換成逗号，是以$(bar)的值是“a,b,c”。

二、字元串處理函數

$(subst <from>,<to>,<text> )

名稱：字元串替換函數——subst。

功能：把字串<text>中的<from>字元串替換成<to>。

傳回：函數傳回被替換過後的字元串。

示例：

$(subst ee,ee,feet on the street)，

把“feet on the street”中的“ee”替換成“ee”，傳回結果是“feet on the street”。

$(patsubst <pattern>,<replacement>,<text> )

名稱：模式字元串替換函數——patsubst。

功能：查找<text>中的單詞（單詞以“空格”、“tab”或“回車”“換行”分隔）是否符合模式<pattern>，如果比對的話，則以<replacement>替換。這裡，<pattern>可以包括通配符“%”，表示任意長度的字串。如果<replacement>中也包含“%”，那麼，<replacement>中的這個“%”将是<pattern>中的那個“%”所代表的字串。（可以用“/”來轉義，以“/%”來表示真實含義的“%”字元）

$(patsubst %.c,%.o,x.c.c bar.c)

把字串“x.c.c bar.c”符合模式[%.c]的單詞替換成[%.o]，傳回結果是“x.c.o bar.o”

備注：

這和我們前面“變量章節”說過的相關知識有點相似。如：

“$(var:<pattern>=<replacement> )”

相當于

“$(patsubst <pattern>,<replacement>,$(var))”，

而“$(var: <suffix>=<replacement> )”

則相當于

“$(patsubst %<suffix>,%<replacement>,$(var))”。

例如有：objects = foo.o bar.o baz.o，

那麼，“$(objects:.o=.c)”和“$(patsubst %.o,%.c,$(objects))”是一樣的。

$(strip <string> )

名稱：去空格函數——strip。

功能：去掉<string>字串中開頭和結尾的空字元。

傳回：傳回被去掉空格的字元串值。

$(strip a b c )

把字串“a b c ”去到開頭和結尾的空格，結果是“a b c”。

$(findstring <find>,<in> )

名稱：查找字元串函數——findstring。

功能：在字串<in>中查找<find>字串。

傳回：如果找到，那麼傳回<find>，否則傳回空字元串。

$(findstring a,a b c)

$(findstring a,b c)

第一個函數傳回“a”字元串，第二個傳回“”字元串（空字元串）

$(filter <pattern…>,<text> )

名稱：過濾函數——filter。

功能：以<pattern>模式過濾<text>字元串中的單詞，保留符合模式<pattern>的單詞。可以有多個模式。

傳回：傳回符合模式<pattern>的字串。

sources := foo.c bar.c baz.s ugh.h

foo: $(sources)

cc $(filter %.c %.s,$(sources)) -o foo

$(filter %.c %.s,$(sources))傳回的值是“foo.c bar.c baz.s”。

$(filter-out <pattern…>,<text> )

名稱：反過濾函數——filter-out。

功能：以<pattern>模式過濾<text>字元串中的單詞，去除符合模式<pattern>的單詞。可以有多個模式。

傳回：傳回不符合模式<pattern>的字串。

objects=main1.o foo.o main2.o bar.o

mains=main1.o main2.o

$(filter-out $(mains),$(objects)) 傳回值是“foo.o bar.o”。

$(sort <list> )

名稱：排序函數——sort。

功能：給字元串<list>中的單詞排序（升序）。

傳回：傳回排序後的字元串。

示例：$(sort foo bar lose)傳回“bar foo lose” 。

備注：sort函數會去掉<list>中相同的單詞。

$(word <n>,<text> )

名稱：取單詞函數——word。

功能：取字元串<text>中第<n>個單詞。（從一開始）

傳回：傳回字元串<text>中第<n>個單詞。如果<n>比<text>中的單詞數要大，那麼傳回空字元串。

示例：$(word 2, foo bar baz)傳回值是“bar”。

$(wordlist <s>,<e>,<text> )

名稱：取單詞串函數——wordlist。

功能：從字元串<text>中取從<s>開始到<e>的單詞串。<s>和<e>是一個數字。

傳回：傳回字元串<text>中從<s>到<e>的單詞字串。如果<s>比<text>中的單詞數要大，那麼傳回空字元串。如果<e>大于<text>的單詞數，那麼傳回從<s>開始，到<text>結束的單詞串。

示例： $(wordlist 2, 3, foo bar baz)傳回值是“bar baz”。

$(words <text> )

名稱：單詞個數統計函數——words。

功能：統計<text>中字元串中的單詞個數。

傳回：傳回<text>中的單詞數。

示例：$(words, foo bar baz)傳回值是“3”。

備注：如果我們要取<text>中最後的一個單詞，我們可以這樣：$(word $(words <text> ),<text> )。

$(firstword <text> )

名稱：首單詞函數——firstword。

功能：取字元串<text>中的第一個單詞。

傳回：傳回字元串<text>的第一個單詞。

示例：$(firstword foo bar)傳回值是“foo”。

備注：這個函數可以用word函數來實作：$(word 1,<text> )。

以上，是所有的字元串操作函數，如果搭配混合使用，可以完成比較複雜的功能。這裡，舉一個現實中應用的例子。我們知道，make使用“vpath”變量來指定“依賴檔案”的搜尋路徑。于是，我們可以利用這個搜尋路徑來指定編譯器對頭檔案的搜尋路徑參數cflags，如：

override cflags += $(patsubst %,-i%,$(subst :, ,$(vpath)))

如果我們的“$(vpath)”值是“src:../headers”，那麼“$(patsubst %,-i%,$(subst :, ,$(vpath)))”将傳回“-isrc -i../headers”，這正是cc或gcc搜尋頭檔案路徑的參數。

三、檔案名操作函數

下面我們要介紹的函數主要是處理檔案名的。每個函數的參數字元串都會被當做一個或是一系列的檔案名來對待。

$(dir <names…> )

名稱：取目錄函數——dir。

功能：從檔案名序列<names>中取出目錄部分。目錄部分是指最後一個反斜杠（“/”）之前的部分。如果沒有反斜杠，那麼傳回“./”。

傳回：傳回檔案名序列<names>的目錄部分。

示例： $(dir src/foo.c hacks)傳回值是“src/ ./”。

$(notdir <names…> )

名稱：取檔案函數——notdir。

功能：從檔案名序列<names>中取出非目錄部分。非目錄部分是指最後一個反斜杠（“/”）之後的部分。

傳回：傳回檔案名序列<names>的非目錄部分。

示例： $(notdir src/foo.c hacks)傳回值是“foo.c hacks”。

$(suffix <names…> )

名稱：取字尾函數——suffix。

功能：從檔案名序列<names>中取出各個檔案名的字尾。

傳回：傳回檔案名序列<names>的字尾序列，如果檔案沒有字尾，則傳回空字串。

示例：$(suffix src/foo.c src-1.0/bar.c hacks)傳回值是“.c .c”。

$(basename <names…> )

名稱：取字首函數——basename。

功能：從檔案名序列<names>中取出各個檔案名的字首部分。

傳回：傳回檔案名序列<names>的字首序列，如果檔案沒有字首，則傳回空字串。

示例：$(basename src/foo.c src-1.0/bar.c hacks)傳回值是“src/foo src-1.0/bar hacks”。

$(addsuffix <suffix>,<names…> )

名稱：加字尾函數——addsuffix。

功能：把字尾<suffix>加到<names>中的每個單詞後面。

傳回：傳回加過字尾的檔案名序列。

示例：$(addsuffix .c,foo bar)傳回值是“foo.c bar.c”。

$(addprefix <prefix>,<names…> )

名稱：加字首函數——addprefix。

功能：把字首<prefix>加到<names>中的每個單詞後面。

傳回：傳回加過字首的檔案名序列。

示例：$(addprefix src/,foo bar)傳回值是“src/foo src/bar”。

$(join <list1>,<list2> )

名稱：連接配接函數——join。

功能：把<list2>中的單詞對應地加到<list1>的單詞後面。如果<list1>的單詞個數要比<list2>的多，那麼，<list1>中的多出來的單詞将保持原樣。如果<list2>的單詞個數要比<list1>多，那麼，<list2>多出來的單詞将被複制到<list2>中。

傳回：傳回連接配接過後的字元串。

示例：$(join aaa bbb , 111 222 333)傳回值是“aaa111 bbb222 333”。

四、foreach 函數

foreach函數和别的函數非常的不一樣。因為這個函數是用來做循環用的，makefile中的foreach函數幾乎是仿照于unix标準shell（/bin/sh）中的for語句，或是c-shell（/bin/csh）中的foreach語句而建構的。它的文法是：

$(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函數很像gnu的make所支援的條件語句——ifeq（參見前面所述的章節），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函數是唯一一個可以用來建立新的參數化的函數。你可以寫一個非常複雜的表達式，這個表達式中，你可以定義許多參數，然後你可以用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的值就是“b a”。

七、origin函數

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

當然，你也許會說，使用override關鍵字不就可以重新定義環境中的變量了嗎？為什麼需要使用這樣的步驟？是的，我們用override是可以達到這樣的效果，可是override過于粗暴，它同時會把從指令行定義的變量也覆寫了，而我們隻想重新定義環境傳來的，而不想重新定義指令行傳來的。

八、shell函數

shell函數也不像其它的函數。顧名思義，它的參數應該就是作業系統shell的指令。它和反引号“`”是相同的功能。這就是說，shell函數把執行作業系統指令後的輸出作為函數傳回。于是，我們可以用作業系統指令以及字元串處理指令awk，sed等等指令來生成一個變量，如：

contents := $(shell cat foo)

files := $(shell echo *.c)

注意，這個函數會新生成一個shell程式來執行指令，是以你要注意其運作性能，如果你的makefile中有一些比較複雜的規則，并大量使用了這個函數，那麼對于你的系統性能是有害的。特别是makefile的隐晦的規則可能會讓你的shell函數執行的次數比你想像的多得多。

九、控制make的函數

make提供了一些函數來控制make的運作。通常，你需要檢測一些運作makefile時的運作時資訊，并且根據這些資訊來決定，你是讓make繼續執行，還是停止。

$(error <text …> )

産生一個緻命的錯誤，<text …>是錯誤資訊。注意，error函數不會在一被使用就會産生錯誤資訊，是以如果你把其定義在某個變量中，并在後續的腳本中使用這個變量，那麼也是可以的。例如：

示例一：

ifdef error_001

$(error error is $(error_001))

示例二：

err = $(error found an error!)

.phony: err

err: ; $(err)

示例一會在變量error_001定義了後執行時産生error調用，而示例二則在目錄err被執行時才發生error調用。

$(warning <text …> )

這個函數很像error函數，隻是它并不會讓make退出，隻是輸出一段警告資訊，而make繼續執行。

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)

基于上面的這個例子，隻要我們輸入的指令不是“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的相容性。

“–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運作指令的負載。

僅輸出執行過程中的指令序列，但并不執行。

“-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會是很有用的，特别是當你的環境變量很複雜的時候。

不運作指令，也不輸出。僅僅是檢查所指定的目标是否需要更新。如果是0則說明要更新，如果是2則說明有錯誤發生。

“-r”

“–no-builtin-rules”

禁止make使用任何隐含規則。

“–no-builtin-variabes”

禁止make使用任何作用于變量上的隐含規則。

“-s”

“–silent”

“–quiet”

在指令運作時不輸出指令的輸出。

“–no-keep-going”

“–stop”

取消“-k”選項的作用。因為有些時候，make的選項是從環境變量“makeflags”中繼承下來的。是以你可以在指令行中使用這個參數來讓環境變量中的“-k”選項失效。

相當于unix的touch指令，隻是把目标的修改日期變成最新的，也就是阻止生成目标的指令運作。

“-v”

“–version”

輸出make程式的版本、版權等關于make的資訊。

“-w”

“–print-directory”

輸出運作makefile之前和之後的資訊。這個參數對于跟蹤嵌套式調用make時很有用。

“–no-print-directory”

禁止“-w”選項。

“–assume-file=<file>”

假定目标<file>需要更新，如果和“-n”選項使用，那麼這個參數會輸出該目标更新時的運作動作。如果沒有“-n”那麼就像運作unix的“touch”指令一樣，使得<file>的修改時間為目前時間。

“–warn-undefined-variables”

隻要make發現有未定義的變量，那麼就輸出警告資訊。

隐含規則

————

在我們使用makefile時，有一些我們會經常使用，而且使用頻率非常高的東西，比如，我們編譯c/c++的源程式為中間目标檔案（unix下是[.o]檔案，windows下是[.obj]檔案）。本章講述的就是一些在makefile中的“隐含的”，早先約定了的，不需要我們再寫出來的規則。

“隐含規則”也就是一種慣例，make會按照這種“慣例”心照不喧地來運作，那怕我們的makefile中沒有書寫這樣的規則。例如，把[.c]檔案編譯成[.o]檔案這一規則，你根本就不用寫出來，make會自動推導出這種規則，并生成我們需要的[.o]檔案。

“隐含規則”會使用一些我們系統變量，我們可以改變這些系統變量的值來定制隐含規則的運作時的參數。如系統變量“cflags”可以控制編譯時的編譯器參數。

我們還可以通過“模式規則”的方式寫下自己的隐含規則。用“字尾規則”來定義隐含規則會有許多的限制。使用“模式規則”會更回得智能和清楚，但“字尾規則”可以用來保證我們makefile的相容性。

我們了解了“隐含規則”，可以讓其為我們更好的服務，也會讓我們知道一些“約定俗成”了的東西，而不至于使得我們在運作makefile時出現一些我們覺得莫名其妙的東西。當然，任何事物都是沖突的，水能載舟，亦可覆舟，是以，有時候“隐含規則”也會給我們造成不小的麻煩。隻有了解了它，我們才能更好地使用它。

一、使用隐含規則

如果要使用隐含規則生成你需要的目标，你所需要做的就是不要寫出這個目标的規則。那麼，make會試圖去自動推導産生這個目标的規則和指令，如果make可以自動推導生成這個目标的規則和指令，那麼這個行為就是隐含規則的自動推導。當然，隐含規則是make事先約定好的一些東西。例如，我們有下面的一個makefile：

foo : foo.o bar.o

cc –o foo foo.o bar.o $(cflags) $(ldflags)

我們可以注意到，這個makefile中并沒有寫下如何生成foo.o和bar.o這兩目标的規則和指令。因為make的“隐含規則”功能會自動為我們自動去推導這兩個目标的依賴目标和生成指令。

make會在自己的“隐含規則”庫中尋找可以用的規則，如果找到，那麼就會使用。如果找不到，那麼就會報錯。在上面的那個例子中，make調用的隐含規則是，把[.o]的目标的依賴檔案置成[.c]，并使用c的編譯指令“cc –c $(cflags) [.c]”來生成[.o]的目标。也就是說，我們完全沒有必要寫下下面的兩條規則：

foo.o : foo.c

cc –c foo.c $(cflags)

bar.o : bar.c

cc –c bar.c $(cflags)

因為，這已經是“約定”好了的事了，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程式的隐含規則。

“<n>.o”的目标的依賴目标會自動推導為“<n>.c”，并且其生成指令是“$(cc) –c $(cppflags) $(cflags)”

2、編譯c++程式的隐含規則。

“<n>.o”的目标的依賴目标會自動推導為“<n>.cc”或是“<n>.c”，并且其生成指令是“$(cxx) –c $(cppflags) $(cflags)”。（建議使用“.cc”作為c++源檔案的字尾，而不是“.c”）

3、編譯pascal程式的隐含規則。

“<n>.o”的目标的依賴目标會自動推導為“<n>.p”，并且其生成指令是“$(pc) –c $(pflags)”。

4、編譯fortran/ratfor程式的隐含規則。

“<n>.o”的目标的依賴目标會自動推導為“<n>.r”或“<n>.f”或“<n>.f”，并且其生成指令是:

“.f” “$(fc) –c $(fflags)”

“.f” “$(fc) –c $(fflags) $(cppflags)”

“.f” “$(fc) –c $(fflags) $(rflags)”

5、預處理fortran/ratfor程式的隐含規則。

“<n>.f”的目标的依賴目标會自動推導為“<n>.r”或“<n>.f”。這個規則隻是轉換ratfor或有預處理的fortran程式到一個标準的fortran程式。其使用的指令是：

“.f” “$(fc) –f $(cppflags) $(fflags)”

“.r” “$(fc) –f $(fflags) $(rflags)”

6、編譯modula-2程式的隐含規則。

“<n>.sym”的目标的依賴目标會自動推導為“<n>.def”，并且其生成指令是：“$(m2c) $(m2flags) $(defflags)”。“<n.o>” 的目标的依賴目标會自動推導為“<n>.mod”，并且其生成指令是：“$(m2c) $(m2flags) $(modflags)”。

7、彙編和彙編預處理的隐含規則。

“<n>.o” 的目标的依賴目标會自動推導為“<n>.s”，預設使用編譯品“as”，并且其生成指令是：“$(as) $(asflags)”。“<n>.s” 的目标的依賴目标會自動推導為“<n>.s”，預設使用c預編譯器“cpp”，并且其生成指令是：“$(as) $(asflags)”。

8、連結object檔案的隐含規則。

“<n>”目标依賴于“<n>.o”，通過運作c的編譯器來運作連結程式生成（一般是“ld”），其生成指令是：“$(cc) $(ldflags) <n>.o $(loadlibes) $(ldlibs)”。這個規則對于隻有一個源檔案的工程有效，同時也對多個object檔案（由不同的源檔案生成）的也有效。例如如下規則：

x : y.o z.o

并且“x.c”、“y.c”和“z.c”都存在時，隐含規則将執行如下指令：

cc -c x.c -o x.o

cc -c y.c -o y.o

cc -c z.c -o z.o

cc x.o y.o z.o -o x

rm -f x.o

rm -f y.o

rm -f z.o

如果沒有一個源檔案（如上例中的x.c）和你的目标名字（如上例中的x）相關聯，那麼，你最好寫出自己的生成規則，不然，隐含規則會報錯的。

9、yacc c程式時的隐含規則。

“<n>.c”的依賴檔案被自動推導為“n.y”（yacc生成的檔案），其生成指令是：“$(yacc) $(yfalgs)”。（“yacc”是一個文法分析器，關于其細節請檢視相關資料）

10、lex c程式時的隐含規則。

“<n>.c”的依賴檔案被自動推導為“n.l”（lex生成的檔案），其生成指令是：“$(lex) $(lfalgs)”。（關于“lex”的細節請檢視相關資料）

11、lex ratfor程式時的隐含規則。

“<n>.r”的依賴檔案被自動推導為“n.l”（lex生成的檔案），其生成指令是：“$(lex) $(lfalgs)”。

12、從c程式、yacc檔案或lex檔案建立lint庫的隐含規則。

“<n>.ln” （lint生成的檔案）的依賴檔案被自動推導為“n.c”，其生成指令是：“$(lint) $(lintfalgs) $(cppflags) -i”。對于“<n>.y”和“<n>.l”也是同樣的規則。

三、隐含規則使用的變量

在隐含規則中的指令中，基本上都是使用了一些預先設定的變量。你可以在你的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

函數庫打包程式。預設指令是“ar”。

as

彙編語言編譯程式。預設指令是“as”。

cc

c語言編譯程式。預設指令是“cc”。

cxx

c++語言編譯程式。預設指令是“g++”。

co

從 rcs檔案中擴充檔案程式。預設指令是“co”。

cpp

c程式的預處理器（輸出是标準輸出裝置）。預設指令是“$(cc) –e”。

fc

fortran 和 ratfor 的編譯器和預處理程式。預設指令是“f77”。

get

從sccs檔案中擴充檔案的程式。預設指令是“get”。

lex

lex方法分析器程式（針對于c或ratfor）。預設指令是“lex”。

pc

pascal語言編譯程式。預設指令是“pc”。

yacc

yacc文法分析器（針對于c程式）。預設指令是“yacc”。

yaccr

yacc文法分析器（針對于ratfor程式）。預設指令是“yacc –r”。

makeinfo

轉換texinfo源檔案（.texi）到info檔案程式。預設指令是“makeinfo”。

tex

從tex源檔案建立tex dvi檔案的程式。預設指令是“tex”。

texi2dvi

從texinfo源檔案建立軍tex dvi 檔案的程式。預設指令是“texi2dvi”。

weave

轉換web到tex的程式。預設指令是“weave”。

cweave

轉換c web 到 tex的程式。預設指令是“cweave”。

tangle

轉換web到pascal語言的程式。預設指令是“tangle”。

ctangle

轉換c web 到 c。預設指令是“ctangle”。

rm

删除檔案指令。預設指令是“rm –f”。

2、關于指令參數的變量

下面的這些變量都是相關上面的指令的參數。如果沒有指明其預設值，那麼其預設值都是空。

arflags

函數庫打包程式ar指令的參數。預設值是“rv”。

asflags

彙編語言編譯器參數。（當明顯地調用“.s”或“.s”檔案時）。

cflags

c語言編譯器參數。

cxxflags

c++語言編譯器參數。

coflags

rcs指令參數。

cppflags

c預處理器參數。（ c 和 fortran 編譯器也會用到）。

fflags

fortran語言編譯器參數。

gflags

sccs “get”程式參數。

ldflags

連結器參數。（如：“ld”）

lflags

lex文法分析器參數。

pflags

pascal語言編譯器參數。

rflags

ratfor 程式的fortran 編譯器參數。

yflags

yacc文法分析器參數。

四、隐含規則鍊

有些時候，一個目标可能被一系列的隐含規則所作用。例如，一個[.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時，而模式規則中的”%”則發生在運作時。

1、模式規則介紹

模式規則中，至少在規則的目标定義中要包含”%”，否則，就是一般的規則。目标中的”%”定義表示對檔案名的比對，”%”表示長度任意的非空字元串。例如：”%.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關心的是依賴的檔案名和生成目标的指令這兩件事。

2、模式規則示例

下面這個例子表示了,把所有的[.c]檔案都編譯成[.o]檔案.

%.o : %.c

$(cc) -c $(cflags) $(cppflags) $< -o $@

其中，”$@”表示所有的目标的挨個值，”$<“表示了所有依賴目标的挨個值。這些奇怪的變量我們叫”自動化變量”，後面會詳細講述。

下面的這個例子中有兩個目标是模式的：

%.tab.c %.tab.h: %.y

bison -d $<

這條規則告訴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]檔案的依賴關系也寫好，那麼，所有的目标都會得到滿足）

3、自動化變量

在上述的模式規則中，目标和依賴檔案都是一系例的檔案，那麼我們如何書寫一個指令來完成從不同的依賴檔案生成相應的目标？因為在每一次的對模式規則的解析時，都會是不同的目标和依賴檔案。

自動化變量就是完成這個功能的。在前面，我們已經對自動化變量有所提涉，相信你看到這裡已對它有一個感性認識了。所謂自動化變量，就是這種變量會把模式中所定義的一系列的檔案自動地挨個取出，直至所有的符合模式的檔案都取完了。這種自動化變量隻應出現在規則的指令中。

下面是所有的自動化變量及其說明：

$@

表示規則中的目标檔案集。在模式規則中，如果有多個目标，那麼，”$@”就是比對于目标中模式定義的集合。

$%

僅當目标是函數庫檔案中，表示規則中的目标成員名。例如，如果一個目标是”foo.a(bar.o)”，那麼，”$%”就是”bar.o”，”$@”就是”foo.a”。如果目标不是函數庫檔案（unix下是[.a]，windows下是[.lib]），那麼，其值為空。

$<

依賴目标中的第一個目标名字。如果依賴目标是以模式（即”%”）定義的，那麼”$<“将是符合模式的一系列的檔案集。注意，其是一個一個取出來的。

$?

所有比目标新的依賴目标的集合。以空格分隔。

$^

所有的依賴目标的集合。以空格分隔。如果在依賴目标中有多個重複的，那個這個變量會去除重複的依賴目标，隻保留一份。

$+

這個變量很像”$^”，也是所有依賴目标的集合。隻是它不去除重複的依賴目标。

$*

這個變量表示目标模式中”%”及其之前的部分。如果目标是”dir/a.foo.b”，并且目标的模式是”a.%.b”，那麼，”$*”的值就是”dir/a.foo”。這個變量對于構造有關聯的檔案名是比較有較。如果目标中沒有模式的定義，那麼”$*”也就不能被推導出，但是，如果目标檔案的字尾是make所識别的，那麼”$*”就是除了字尾的那一部分。例如：如果目标是”foo.c”，因為”.c”是make所能識别的字尾名，是以，”$*”的值就是”foo”。這個特性是gnu make的，很有可能不相容于其它版本的make，是以，你應該盡量避免使用”$*”，除非是在隐含規則或是靜态模式中。如果目标中的字尾是make所不能識别的，那麼”$*”就是空值。

當你希望隻對更新過的依賴檔案進行操作時，”$?”在顯式規則中很有用，例如，假設有一個函數庫檔案叫”lib”，其由其它幾個object檔案更新。那麼把object檔案打包的比較有效率的makefile規則是：

lib : foo.o bar.o lose.o win.o

ar r lib $?

在上述所列出來的自動量變量中。四個變量（$@、$<、$%、$*）在擴充時隻會有一個檔案，而另三個的值是一個檔案清單。這七個自動化變量還可以取得檔案的目錄名或是在目前目錄下的符合模式的檔案名，隻需要搭配上”d”或”f”字樣。這是gnu make中老版本的特性，在新版本中，我們使用函數”dir”或”notdir”就可以做到了。”d”的含義就是directory，就是目錄，”f”的含義就是file，就是檔案。

下面是對于上面的七個變量分别加上”d”或是”f”的含義：

$(@d)

表示”$@”的目錄部分（不以斜杠作為結尾），如果”$@”值是”dir/foo.o”，那麼”$(@d)”就是”dir”，而如果”$@”中沒有包含斜杠的話，其值就是”.”（目前目錄）。

$(@f)

表示”$@”的檔案部分，如果”$@”值是”dir/foo.o”，那麼”$(@f)”就是”foo.o”，”$(@f)”相當于函數”$(notdir $@)”。

“$(*d)”

“$(*f)”

和上面所述的同理，也是取檔案的目錄部分和檔案部分。對于上面的那個例子，”$(*d)”傳回”dir”，而”$(*f)”傳回”foo”

“$(%d)”

“$(%f)”

分别表示了函數封包件成員的目錄部分和檔案部分。這對于形同”archive(member)”形式的目标中的”member”中包含了不同的目錄很有用。

“$(<d)”

“$(<f)”

分别表示依賴檔案的目錄部分和檔案部分。

“$(^d)”

“$(^f)”

分别表示所有依賴檔案的目錄部分和檔案部分。（無相同的）

“$(+d)”

“$(+f)”

分别表示所有依賴檔案的目錄部分和檔案部分。（可以有相同的）

“$(?d)”

“$(?f)”

分别表示被更新的依賴檔案的目錄部分和檔案部分。

最後想提醒一下的是，對于”$<“，為了避免産生不必要的麻煩，我們最好給$後面的那個特定字元都加上圓括号，比如，”$(< )”就要比”$<“要好一些。

還得要注意的是，這些變量隻使用在規則的指令中，而且一般都是”顯式規則”和”靜态模式規則”（參見前面”書寫規則”一章）。其在隐含規則中并沒有意義。

4、模式的比對

一般來說，一個目标的模式有一個有字首或是字尾的”%”，或是沒有前字尾，直接就是一個”%”。因為”%”代表一個或多個字元，是以在定義好了的模式中，我們把”%”所比對的内容叫做”莖”，例如”%.c”所比對的檔案”test.c”中”test”就是”莖”。因為在目标和依賴目标中同時有”%”時，依賴目标的”莖”會傳給目标，當做目标中的”莖”。

當一個模式比對包含有斜杠（實際也不經常包含）的檔案時，那麼在進行模式比對時，目錄部分會首先被移開，然後進行比對，成功後，再把目錄加回去。在進行”莖”的傳遞時，我們需要知道這個步驟。例如有一個模式”e%t”，檔案”src/eat”比對于該模式，于是”src/a”就是其”莖”，如果這個模式定義在依賴目标中，而被依賴于這個模式的目标中又有個模式”c%r”，那麼，目标就是”src/car”。（”莖”被傳遞）

5、重載内建隐含規則

你可以重載内建的隐含規則（或是定義一個全新的），例如你可以重新構造和内建隐含規則不同的指令，如：

$(cc) -c $(cppflags) $(cflags) -d$(date)

你可以取消内建的隐含規則，隻要不在後面寫指令就行。如：

%.o : %.s

同樣，你也可以重新定義一個全新的隐含規則，其在隐含規則中的位置取決于你在哪裡寫下這個規則。朝前的位置就靠前。

六、老式風格的”字尾規則”

字尾規則是一個比較老式的定義隐含規則的方法。字尾規則會被模式規則逐漸地取代。因為模式規則更強更清晰。為了和老版本的makefile相容，gnu make同樣相容于這些東西。字尾規則有兩種方式：”雙字尾”和”單字尾”。

雙字尾規則定義了一對字尾：目标檔案的字尾和依賴目标（源檔案）的字尾。如”.c.o”相當于”%o : %c”。單字尾規則隻定義一個字尾，也就是源檔案的字尾。如”.c”相當于”% : %.c”。

字尾規則中所定義的字尾應該是make所認識的，如果一個字尾是make所認識的，那麼這個規則就是單字尾規則，而如果兩個連在一起的字尾都被make所認識，那就是雙字尾規則。例如：”.c”和”.o”都是make所知道。因而，如果你定義了一個規則是”.c.o”那麼其就是雙字尾規則，意義就是”.c”是源檔案的字尾，”.o”是目标檔案的字尾。如下示例：

.c.o:

$(cc) -c $(cflags) $(cppflags) -o $@ $<

字尾規則不允許任何的依賴檔案，如果有依賴檔案的話，那就不是字尾規則，那些字尾統統被認為是檔案名，如：

.c.o: foo.h

這個例子，就是說，檔案”.c.o”依賴于檔案”foo.h”，而不是我們想要的這樣：

%.o: %.c foo.h

字尾規則中，如果沒有指令，那是毫無意義的。因為他也不會移去内建的隐含規則。

而要讓make知道一些特定的字尾，我們可以使用僞目标”.suffixes”來定義或是删除，如：

.suffixes: .hack .win

把字尾.hack和.win加入字尾清單中的末尾。

.suffixes: # 删除預設的字尾

.suffixes: .c .o .h # 定義自己的字尾

先清楚預設字尾，後定義自己的字尾清單。

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、對于第一個在清單中的模式規則：

1）推導其”莖”s，s應該是t或是n比對于模式中”%”非空的部分。

2）計算依賴檔案。把依賴檔案中的”%”都替換成”莖”s。如果目标模式中沒有包含斜框字元，而把d加在第一個依賴檔案的開頭。

3）測試是否所有的依賴檔案都存在或是理當存在。（如果有一個檔案被定義成另外一個規則的目标檔案，或者是一個顯式規則的依賴檔案，那麼這個檔案就叫”理當存在”）

4）如果所有的依賴檔案存在或是理當存在，或是就沒有依賴檔案。那麼這條規則将被采用，退出該算法。

6、如果經過第5步，沒有模式規則被找到，那麼就做更進一步的搜尋。對于存在于清單中的第一個模式規則：

1）如果規則是終止規則，那就忽略它，繼續下一條模式規則。

2）計算依賴檔案。（同第5步）

3）測試所有的依賴檔案是否存在或是理當存在。

4）對于不存在的依賴檔案，遞歸調用這個算法查找他是否可以被隐含規則找到。

5）如果所有的依賴檔案存在或是理當存在，或是就根本沒有依賴檔案。那麼這條規則被采用，退出該算法。

7、如果沒有隐含規則可以使用，檢視”.default”規則，如果有，采用，把”.default”的指令給t使用。

一旦規則被找到，就會執行其相當的指令，而此時，我們的自動化變量的值才會生成。

使用make更新函數庫檔案

———————————

函數庫檔案也就是對object檔案（程式編譯的中間檔案）的打封包件。在unix下，一般是由指令”ar”來完成打包工作。

一、函數庫檔案的成員

一個函數庫檔案由多個檔案組成。你可以以如下格式指定函數庫檔案及其組成：

archive(member)

這個不是一個指令，而一個目标和依賴的定義。一般來說，這種用法基本上就是為了”ar”指令來服務的。如：

foolib(hack.o) : hack.o

ar cr foolib 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

ar r foo.a bar.o

rm -f bar.o

還有一個變量要注意的是”$%”，這是專屬函數庫檔案的自動化變量，有關其說明請參見”自動化變量”一節。

三、函數庫檔案的字尾規則

你可以使用”字尾規則”和”隐含規則”來生成函數庫打封包件，如：

.c.a:

$(cc) $(cflags) $(cppflags) -c $< -o $*.o

$(ar) r $@ $*.o

$(rm) $*.o

其等效于：

(%.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的程式也就多了一些）。gnu的東西還是很不錯的，特别是使用得深了以後，越來越覺得gnu的軟體的強大，也越來越覺得gnu的在作業系統中（主要是unix，甚至windows）”殺傷力”。

對于上述所有的make的細節，我們不但可以利用make這個工具來編譯我們的程式，還可以利用make來完成其它的工作，因為規則中的指令可以是任何shell之下的指令，是以，在unix下，你不一定隻是使用程式語言的編譯器，你還可以在makefile中書寫其它的指令，如：tar、awk、mail、sed、cvs、compress、ls、rm、yacc、rpm、ftp……等等，等等，來完成諸如”程式打包”、”程式備份”、”制作程式安裝包”、”送出代碼”、”使用程式模闆”、”合并檔案”等等五花八門的功能，檔案操作，檔案管理，程式設計開發設計，或是其它一些異想天開的東西。比如，以前在書寫銀行交易程式時，由于銀行的交易程式基本一樣，就見到有人書寫了一些交易的通用程式模闆，在該模闆中把一些網絡通訊、資料庫操作的、業務操作共性的東西寫在一個檔案中，在這些檔案中用些諸如”@@@n、###n”奇怪字串标注一些位置，然後書寫交易時，隻需按照一種特定的規則書寫特定的處理，最後在make時，使用awk和sed，把模闆中的”@@@n、###n”等字串替代成特定的程式，形成c檔案，然後再編譯。這個動作很像資料庫的”擴充c”語言（即在c語言中用”exec　sql”的樣子執行sql語句，在用cc/gcc編譯之前，需要使用”擴充c”的翻譯程式，如cpre，把其翻譯成标準c）。