在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.o foo.o bar.o utils.o another.o”(another.o被追加進去了)
使用“+=”操作符,可以模擬為下面的這種例子:
objects = main.o foo.o bar.o utils.o
objects := $(objects) another.o
所不同的是,用“+=”更為簡潔。
如果變量之前沒有定義過,那么,“+=”會自動變成“=”,如果前面有變量定義,那么“+=”會繼承於前次操作的賦值符。如果前一次的是“:=”,那么“+=”會以“:=”作為其賦值符,如:
variable := value
variable += more
等價於:
variable := value
variable := $(variable) more
但如果是這種情況:
variable = value
variable += more
由於前次的賦值符是“=”,所以“+=”也會以“=”來做為賦值,那么豈不會發生變量的遞補歸定義,這是很不好的,所以make會自動為我們解決這個問題,我們不必擔心這個問題。
五、override 指示符
如果有變量是通常make的命令行參數設置的,那么Makefile中對這個變量的賦值會被忽略。如果你想在Makefile中設置這類參數的值,那么,你可以使用“override”指示符。其語法是:
override <variable>; = <value>;
override <variable>; := <value>;
當然,你還可以追加:
override <variable>; += <more text>;
對於多行的變量定義,我們用define指示符,在define指示符前,也同樣可以使用ovveride指示符,如:
override define foo
bar
endef
六、多行變量
還有一種設置變量值的方法是使用define關鍵字。使用define關鍵字設置變量的值可以有換行,這有利於定義一系列的命令(前面我們講過“命令包”的技術就是利用這個關鍵字)。
define指示符后面跟的是變量的名字,而重起一行定義變量的值,定義是以endef關鍵字結束。其工作方式和“=”操作符一樣。變量的值可以 包含函數、命令、文字,或是其它變量。因為命令需要以[Tab]鍵開頭,所以如果你用define定義的命令變量中沒有以[Tab]鍵開頭,那么make 就不會把其認為是命令。
下面的這個示例展示了define的用法:
define two-lines
echo foo
echo $(bar)
endef
七、環境變量
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 : 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不允許把整個條件語句分成兩部分放在不同的文件中。
使用函數
————
在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 = $(call reverse,a,b)
此時的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
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))
endif
示例二:
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)
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發現有未定義的變量,那么就輸出警告信息。
隱含規則
————
在我們使用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、重載內建隱含規則
你可以重載內建的隱含規則(或是定義一個全新的),例如你可以重新構造和內建隱含規則不同的命令,如:
%.o : %.c
$(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
$(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
這個例子,就是說,文件".c.o"依賴於文件"foo.h",而不是我們想要的這樣:
%.o: %.c foo.h
$(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
后綴規則中,如果沒有命令,那是毫無意義的。因為他也不會移去內建的隱含規則。
而要讓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
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o
$(AR) r $@ $*.o
$(RM) $*.o
四、注意事項
在進行函數庫打包文件生成時,請小心使用make的並行機制("-j"參數)。如果多個ar命令在同一時間運行在同一個函數庫打包文件上,就很有可以損壞這個函數庫文件。所以,在make未來的版本中,應該提供一種機制來避免並行操作發生在函數打包文件上。
但就目前而言,你還是應該不要盡量不要使用"-j"參數。