【轉載】跟我一起寫(xiě) Makefile （二）

七、環(huán)境變量

make運行時(shí)的系統環(huán)境變量可以在make開(kāi)始運行時(shí)被載入到Makefile文件中，但是如果Makefile中已定義了這個(gè)變量，或是這個(gè)變量由 make命令行帶入，那么系統的環(huán)境變量的值將被覆蓋。（如果make指定了“-e”參數，那么，系統環(huán)境變量將覆蓋Makefile中定義的變量）

因此，如果我們在環(huán)境變量中設置了“CFLAGS”環(huán)境變量，那么我們就可以在所有的Makefile中使用這個(gè)變量了。這對于我們使用統一的編譯參數有 比較大的好處。如果Makefile中定義了CFLAGS，那么則會(huì )使用Makefile中的這個(gè)變量，如果沒(méi)有定義則使用系統環(huán)境變量的值，一個(gè)共性和 個(gè)性的統一，很像“全局變量”和“局部變量”的特性。

當make嵌套調用時(shí)（參見(jiàn)前面的“嵌套調用”章節），上層Makefile中定義的變量會(huì )以系統環(huán)境變量的方式傳遞到下層的Makefile中。當然， 默認情況下，只有通過(guò)命令行設置的變量會(huì )被傳遞。而定義在文件中的變量，如果要向下層Makefile傳遞，則需要使用exprot關(guān)鍵字來(lái)聲明。（參見(jiàn) 前面章節）

當然，我并不推薦把許多的變量都定義在系統環(huán)境中，這樣，在我們執行不用的Makefile時(shí)，擁有的是同一套系統變量，這可能會(huì )帶來(lái)更多的麻煩。

八、目標變量

前面我們所講的在Makefile中定義的變量都是“全局變量”，在整個(gè)文件，我們都可以訪(fǎng)問(wèn)這些變量。當然，“自動(dòng)化變量”除外，如“$<”等這種類(lèi)量的自動(dòng)化變量就屬于“規則型變量”，這種變量的值依賴(lài)于規則的目標和依賴(lài)目標的定義。

當然，我樣同樣可以為某個(gè)目標設置局部變量，這種變量被稱(chēng)為“Target-specific Variable”，它可以和“全局變量”同名，因為它的作用范圍只在這條規則以及連帶規則中，所以其值也只在作用范圍內有效。而不會(huì )影響規則鏈以外的全局變量的值。

其語(yǔ)法是：

    <target ...>; : <variable-assignment>;

    <target ...>; : overide <variable-assignment>;

<variable-assignment>;可以是前面講過(guò)的各種賦值表達式，如“=”、“:=”、“+=”或是“？=”。第二個(gè)語(yǔ)法是針對于make命令行帶入的變量，或是系統環(huán)境變量。

這個(gè)特性非常的有用，當我們設置了這樣一個(gè)變量，這個(gè)變量會(huì )作用到由這個(gè)目標所引發(fā)的所有的規則中去。如：

    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

在這個(gè)示例中，不管全局的$(CFLAGS)的值是什么，在prog目標，以及其所引發(fā)的所有規則中（prog.o foo.o bar.o的規則），$(CFLAGS)的值都是“-g”

九、模式變量

在GNU的make中，還支持模式變量（Pattern-specific Variable），通過(guò)上面的目標變量中，我們知道，變量可以定義在某個(gè)目標上。模式變量的好處就是，我們可以給定一種“模式”，可以把變量定義在符合這種模式的所有目標上。

我們知道，make的“模式”一般是至少含有一個(gè)“%”的，所以，我們可以以如下方式給所有以[.o]結尾的目標定義目標變量：

    %.o : CFLAGS = -O

同樣，模式變量的語(yǔ)法和“目標變量”一樣：

    <pattern ...>; : <variable-assignment>;

    <pattern ...>; : override <variable-assignment>;

override同樣是針對于系統環(huán)境傳入的變量，或是make命令行指定的變量。

使用條件判斷
——————

使用條件判斷，可以讓make根據運行時(shí)的不同情況選擇不同的執行分支。條件表達式可以是比較變量的值，或是比較變量和常量的值。

一、示例

下面的例子，判斷$(CC)變量是否“gcc”，如果是的話(huà)，則使用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

可見(jiàn)，在上面示例的這個(gè)規則中，目標“foo”可以根據變量“$(CC)”值來(lái)選取不同的函數庫來(lái)編譯程序。

我們可以從上面的示例中看到三個(gè)關(guān)鍵字：ifeq、else和endif。ifeq的意思表示條件語(yǔ)句的開(kāi)始，并指定一個(gè)條件表達式，表達式包含兩個(gè)參 數，以逗號分隔，表達式以圓括號括起。else表示條件表達式為假的情況。endif表示一個(gè)條件語(yǔ)句的結束，任何一個(gè)條件表達式都應該以endif結 束。

當我們的變量$(CC)值是“gcc”時(shí)，目標foo的規則是：

    foo: $(objects)
            $(CC) -o foo $(objects) $(libs_for_gcc)

而當我們的變量$(CC)值不是“gcc”時(shí)（比如“cc”），目標foo的規則是：

    foo: $(objects)
            $(CC) -o foo $(objects) $(normal_libs)

當然，我們還可以把上面的那個(gè)例子寫(xiě)得更簡(jiǎn)潔一些：

    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)

二、語(yǔ)法

條件表達式的語(yǔ)法為：

    <conditional-directive>;
    <text-if-true>;
    endif

以及：

    <conditional-directive>;
    <text-if-true>;
    else
    <text-if-false>;
    endif

其中<conditional-directive>;表示條件關(guān)鍵字，如“ifeq”。這個(gè)關(guān)鍵字有四個(gè)。

第一個(gè)是我們前面所見(jiàn)過(guò)的“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

這個(gè)示例中使用了“strip”函數，如果這個(gè)函數的返回值是空（Empty），那么<text-if-empty>;就生效。

第二個(gè)條件關(guān)鍵字是“ifneq”。語(yǔ)法是：

    ifneq (<arg1>;, <arg2>
    ifneq '<arg1>;' '<arg2>;'
    ifneq "<arg1>;" "<arg2>;"
    ifneq "<arg1>;" '<arg2>;'
    ifneq '<arg1>;' "<arg2>;"

其比較參數“arg1”和“arg2”的值是否相同，如果不同，則為真。和“ifeq”類(lèi)似。

第三個(gè)條件關(guān)鍵字是“ifdef”。語(yǔ)法是：

    ifdef <variable-name>;

如果變量<variable-name>;的值非空，那到表達式為真。否則，表達式為假。當然，<variable- name>;同樣可以是一個(gè)函數的返回值。注意，ifdef只是測試一個(gè)變量是否有值，其并不會(huì )把變量擴展到當前位置。還是來(lái)看兩個(gè)例子：

    示例一：
    bar =
    foo = $(bar)
    ifdef foo
    frobozz = yes
    else
    frobozz = no
    endif

    示例二：
    foo =
    ifdef foo
    frobozz = yes
    else
    frobozz = no
    endif

第一個(gè)例子中，“$(frobozz)”值是“yes”，第二個(gè)則是“no”。

第四個(gè)條件關(guān)鍵字是“ifndef”。其語(yǔ)法是：

    ifndef <variable-name>;

這個(gè)我就不多說(shuō)了，和“ifdef”是相反的意思。

在<conditional-directive>;這一行上，多余的空格是被允許的，但是不能以[Tab]鍵做為開(kāi)始（不然就被認為是命令）。而注釋符“#”同樣也是安全的�！癳lse”和“endif”也一樣，只要不是以[Tab]鍵開(kāi)始就行了。

特別注意的是，make是在讀取Makefile時(shí)就計算條件表達式的值，并根據條件表達式的值來(lái)選擇語(yǔ)句，所以，你最好不要把自動(dòng)化變量（如“$@”等）放入條件表達式中，因為自動(dòng)化變量是在運行時(shí)才有的。

而且，為了避免混亂，make不允許把整個(gè)條件語(yǔ)句分成兩部分放在不同的文件中。
使用函數
————

在Makefile中可以使用函數來(lái)處理變量，從而讓我們的命令或是規則更為的靈活和具有智能。make所支持的函數也不算很多，不過(guò)已經(jīng)足夠我們的操作了。函數調用后，函數的返回值可以當做變量來(lái)使用。

一、函數的調用語(yǔ)法

函數調用，很像變量的使用，也是以“$”來(lái)標識的，其語(yǔ)法如下：

    $(<function>; <arguments>

或是

    ${<function>; <arguments>;}

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

還是來(lái)看一個(gè)示例：

    comma:= ,
    empty:=
    space:= $(empty) $(empty)
    foo:= a b c
    bar:= $(subst $(space),$(comma),$(foo))

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

二、字符串處理函數

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

    名稱(chēng)：字符串替換函數——subst。
    功能：把字串<text>;中的<from>;字符串替換成<to>;。
    返回：函數返回被替換過(guò)后的字符串。

    示例：
       
        $(subst ee,EE,feet on the street)，
       
        把“feet on the street”中的“ee”替換成“EE”，返回結果是“fEEt on the strEEt”。

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

    名稱(chēng)：模式字符串替換函數——patsubst。
    功能：查找<text>;中的單詞（單詞以“空格”、“Tab”或“回車(chē)”“換行”分隔）是否符合模式<pattern>;，如 果匹配的話(huà)，則以<replacement>;替換。這里，<pattern>;可以包括通配符“%”，表示任意長(cháng)度的字串。如 果<replacement>;中也包含“%”，那么，<replacement>;中的這個(gè)“%”將是< pattern>;中的那個(gè)“%”所代表的字串。（可以用“\”來(lái)轉義，以“\%”來(lái)表示真實(shí)含義的“%”字符）
    返回：函數返回被替換過(guò)后的字符串。

    示例：

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

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

    備注：

        這和我們前面“變量章節”說(shuō)過(guò)的相關(guān)知識有點(diǎn)相似。如：

        “$(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>

    名稱(chēng)：去空格函數——strip。
    功能：去掉<string>;字串中開(kāi)頭和結尾的空字符。
    返回：返回被去掉空格的字符串值。
    示例：
       
        $(strip a b c )

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

$(findstring <find>;,<in>

    名稱(chēng)：查找字符串函數——findstring。
    功能：在字串<in>;中查找<find>;字串。
    返回：如果找到，那么返回<find>;，否則返回空字符串。
    示例：

        $(findstring a,a b c)
        $(findstring a,b c)

        第一個(gè)函數返回“a”字符串，第二個(gè)返回“”字符串（空字符串）

$(filter <pattern...>;,<text>

    名稱(chēng)：過(guò)濾函數——filter。
    功能：以<pattern>;模式過(guò)濾<text>;字符串中的單詞，保留符合模式<pattern>;的單詞�？梢杂卸鄠�(gè)模式。
    返回：返回符合模式<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>

    名稱(chēng)：反過(guò)濾函數——filter-out。
    功能：以<pattern>;模式過(guò)濾<text>;字符串中的單詞，去除符合模式<pattern>;的單詞�？梢杂卸鄠�(gè)模式。
    返回：返回不符合模式<pattern>;的字串。
    示例：

        bjects=main1.o foo.o main2.o bar.o
        mains=main1.o main2.o
       
        $(filter-out $(mains),$(objects)) 返回值是“foo.o bar.o”。
       
$(sort <list>

    名稱(chēng)：排序函數——sort。
    功能：給字符串<list>;中的單詞排序（升序）。
    返回：返回排序后的字符串。
    示例：$(sort foo bar lose)返回“bar foo lose” 。
    備注：sort函數會(huì )去掉<list>;中相同的單詞。

$(word <n>;,<text>;)

    名稱(chēng)：取單詞函數——word。
    功能：取字符串<text>;中第<n>;個(gè)單詞。（從一開(kāi)始）
    返回：返回字符串<text>;中第<n>;個(gè)單詞。如果<n>;比<text>;中的單詞數要大，那么返回空字符串。
    示例：$(word 2, foo bar baz)返回值是“bar”。

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

    名稱(chēng)：取單詞串函數——wordlist。
    功能：從字符串<text>;中取從<s>;開(kāi)始到<e>;的單詞串。<s>;和<e>;是一個(gè)數字。
    返回：返回字符串<text>;中從<s>;到<e>;的單詞字串。如果<s>;比< text>;中的單詞數要大，那么返回空字符串。如果<e>;大于<text>;的單詞數，那么返回從< s>;開(kāi)始，到<text>;結束的單詞串。
    示例： $(wordlist 2, 3, foo bar baz)返回值是“bar baz”。

$(words <text>;)

    名稱(chēng)：?jiǎn)卧~個(gè)數統計函數——words。
    功能：統計<text>;中字符串中的單詞個(gè)數。
    返回：返回<text>;中的單詞數。
    示例：$(words, foo bar baz)返回值是“3”。
    備注：如果我們要取<text>;中最后的一個(gè)單詞，我們可以這樣：$(word $(words <text>;),<text>;)。

$(firstword <text>;)

    名稱(chēng)：首單詞函數——firstword。
    功能：取字符串<text>;中的第一個(gè)單詞。
    返回：返回字符串<text>;的第一個(gè)單詞。
    示例：$(firstword foo bar)返回值是“foo”。
    備注：這個(gè)函數可以用word函數來(lái)實(shí)現：$(word 1,<text>;)。

以上，是所有的字符串操作函數，如果搭配混合使用，可以完成比較復雜的功能。這里，舉一個(gè)現實(shí)中應用的例子。我們知道，make使用“VPATH”變量來(lái)指定“依賴(lài)文件”的搜索路徑。于是，我們可以利用這個(gè)搜索路徑來(lái)指定編譯器對頭文件的搜索路徑參數CFLAGS，如：

    override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH)))

    如果我們的“$(VPATH)”值是“src:../headers”，那么“$(patsubst %,-I%,$(subst :, ,$(VPATH)))”將返回“-Isrc -I../headers”，這正是cc或gcc搜索頭文件路徑的參數。

三、文件名操作函數

下面我們要介紹的函數主要是處理文件名的。每個(gè)函數的參數字符串都會(huì )被當做一個(gè)或是一系列的文件名來(lái)對待。

$(dir <names...>;)

    名稱(chēng)：取目錄函數——dir。
    功能：從文件名序列<names>;中取出目錄部分。目錄部分是指最后一個(gè)反斜杠（“/”）之前的部分。如果沒(méi)有反斜杠，那么返回“./”。
    返回：返回文件名序列<names>;的目錄部分。
    示例： $(dir src/foo.c hacks)返回值是“src/ ./”。

$(notdir <names...>;)

    名稱(chēng)：取文件函數——notdir。
    功能：從文件名序列<names>;中取出非目錄部分。非目錄部分是指最后一個(gè)反斜杠（“/”）之后的部分。
    返回：返回文件名序列<names>;的非目錄部分。
    示例： $(notdir src/foo.c hacks)返回值是“foo.c hacks”。

$(suffix <names...>;)
   
    名稱(chēng)：取后綴函數——suffix。
    功能：從文件名序列<names>;中取出各個(gè)文件名的后綴。
    返回：返回文件名序列<names>;的后綴序列，如果文件沒(méi)有后綴，則返回空字串。
    示例：$(suffix src/foo.c src-1.0/bar.c hacks)返回值是“.c .c”。

$(basename <names...>;)

    名稱(chēng)：取前綴函數——basename。
    功能：從文件名序列<names>;中取出各個(gè)文件名的前綴部分。
    返回：返回文件名序列<names>;的前綴序列，如果文件沒(méi)有前綴，則返回空字串。
    示例：$(basename src/foo.c src-1.0/bar.c hacks)返回值是“src/foo src-1.0/bar hacks”。

$(addsuffix <suffix>;,<names...>;)

    名稱(chēng)：加后綴函數——addsuffix。
    功能：把后綴<suffix>;加到<names>;中的每個(gè)單詞后面。
    返回：返回加過(guò)后綴的文件名序列。
    示例：$(addsuffix .c,foo bar)返回值是“foo.c bar.c”。

$(addprefix <prefix>;,<names...>;)

    名稱(chēng)：加前綴函數——addprefix。
    功能：把前綴<prefix>;加到<names>;中的每個(gè)單詞后面。
    返回：返回加過(guò)前綴的文件名序列。
    示例：$(addprefix src/,foo bar)返回值是“src/foo src/bar”。

$(join <list1>;,<list2>;)

    名稱(chēng)：連接函數——join。
    功能：把<list2>;中的單詞對應地加到<list1>;的單詞后面。如果<list1>;的單詞個(gè)數要比 <list2>;的多，那么，<list1>;中的多出來(lái)的單詞將保持原樣。如果<list2>;的單詞個(gè)數要比 <list1>;多，那么，<list2>;多出來(lái)的單詞將被復制到<list2>;中。
    返回：返回連接過(guò)后的字符串。
    示例：$(join aaa bbb , 111 222 333)返回值是“aaa111 bbb222 333”。
四、foreach 函數

foreach函數和別的函數非常的不一樣。因為這個(gè)函數是用來(lái)做循環(huán)用的，Makefile中的foreach函數幾乎是仿照于Unix標準Shell （/bin/sh）中的for語(yǔ)句，或是C-Shell（/bin/csh）中的foreach語(yǔ)句而構建的。它的語(yǔ)法是：

    $(foreach <var>;,<list>;,<text>

這個(gè)函數的意思是，把參數<list>;中的單詞逐一取出放到參數<var>;所指定的變量中，然后再執行< text>;所包含的表達式。每一次<text>;會(huì )返回一個(gè)字符串，循環(huán)過(guò)程中，<text>;的所返回的每個(gè)字符串會(huì ) 以空格分隔，最后當整個(gè)循環(huán)結束時(shí)，<text>;所返回的每個(gè)字符串所組成的整個(gè)字符串（以空格分隔）將會(huì )是foreach函數的返回值。

所以，<var>;最好是一個(gè)變量名，<list>;可以是一個(gè)表達式，而<text>;中一般會(huì )使用<var>;這個(gè)參數來(lái)依次枚舉<list>;中的單詞。舉個(gè)例子：

    names := a b c d

    files := $(foreach n,$(names),$(n).o)

上面的例子中，$(name)中的單詞會(huì )被挨個(gè)取出，并存到變量“n”中，“$(n).o”每次根據“$(n)”計算出一個(gè)值，這些值以空格分隔，最后作為foreach函數的返回，所以，$(files)的值是“a.o b.o c.o d.o”。

注意，foreach中的<var>;參數是一個(gè)臨時(shí)的局部變量，foreach函數執行完后，參數<var>;的變量將不在作用，其作用域只在foreach函數當中。

五、if 函數

if函數很像GNU的make所支持的條件語(yǔ)句——ifeq（參見(jiàn)前面所述的章節），if函數的語(yǔ)法是：

    $(if <condition>;,<then-part>

或是

    $(if <condition>;,<then-part>;,<else-part>

可見(jiàn)，if函數可以包含“else”部分，或是不含。即if函數的參數可以是兩個(gè)，也可以是三個(gè)。<condition>;參數是if的表達 式，如果其返回的為非空字符串，那么這個(gè)表達式就相當于返回真，于是，<then-part>;會(huì )被計算，否則<else- part>;會(huì )被計算。

而if函數的返回值是，如果<condition>;為真（非空字符串），那個(gè)<then-part>;會(huì )是整個(gè)函數的返回值， 如果<condition>;為假（空字符串），那么<else-part>;會(huì )是整個(gè)函數的返回值，此時(shí)如果<else -part>;沒(méi)有被定義，那么，整個(gè)函數返回空字串。

所以，<then-part>;和<else-part>;只會(huì )有一個(gè)被計算。

六、call函數

call函數是唯一一個(gè)可以用來(lái)創(chuàng )建新的參數化的函數。你可以寫(xiě)一個(gè)非常復雜的表達式，這個(gè)表達式中，你可以定義許多參數，然后你可以用call函數來(lái)向這個(gè)表達式傳遞參數。其語(yǔ)法是：

    $(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)

當make執行這個(gè)函數時(shí)，<expression>;參數中的變量，如$(1)，$(2)，$(3)等，會(huì )被參數< parm1>;，<parm2>;，<parm3>;依次取代。而<expression>;的返回值就是 call函數的返回值。例如：

    reverse =  $(1) $(2)

    foo = $(call reverse,a,b)

那么，foo的值就是“a b”。當然，參數的次序是可以自定義的，不一定是順序的，如：

    reverse =  $(2) $(1)

    foo = $(call reverse,a,b)

此時(shí)的foo的值就是“b a”。

七、origin函數
origin函數不像其它的函數，他并不操作變量的值，他只是告訴你你的這個(gè)變量是哪里來(lái)的？其語(yǔ)法是：

    $(origin <variable>

注意，<variable>;是變量的名字，不應該是引用。所以你最好不要在<variable>;中使用“$”字符。Origin函數會(huì )以其返回值來(lái)告訴你這個(gè)變量的“出生情況”，下面，是origin函數的返回值:

“undefined”

      如果<variable>;從來(lái)沒(méi)有定義過(guò)，origin函數返回這個(gè)值“undefined”。

“default”

      如果<variable>;是一個(gè)默認的定義，比如“CC”這個(gè)變量，這種變量我們將在后面講述。

“environment”

      如果<variable>;是一個(gè)環(huán)境變量，并且當Makefile被執行時(shí)，“-e”參數沒(méi)有被打開(kāi)。

“file”

      如果<variable>;這個(gè)變量被定義在Makefile中。

“command line”

      如果<variable>;這個(gè)變量是被命令行定義的。

“override”

      如果<variable>;是被override指示符重新定義的。

“automatic”

      如果<variable>;是一個(gè)命令運行中的自動(dòng)化變量。關(guān)于自動(dòng)化變量將在后面講述。

這些信息對于我們編寫(xiě)Makefile是非常有用的，例如，假設我們有一個(gè)Makefile其包了一個(gè)定義文件Make.def，在Make.def中定 義了一個(gè)變量“bletch”，而我們的環(huán)境中也有一個(gè)環(huán)境變量“bletch”，此時(shí)，我們想判斷一下，如果變量來(lái)源于環(huán)境，那么我們就把之重定義了， 如果來(lái)源于Make.def或是命令行等非環(huán)境的，那么我們就不重新定義它。于是，在我們的Makefile中，我們可以這樣寫(xiě)：

    ifdef bletch

    ifeq "$(origin bletch)" "environment"

    bletch = barf, gag, etc.

    endif

    endif

當然，你也許會(huì )說(shuō)，使用override關(guān)鍵字不就可以重新定義環(huán)境中的變量了嗎？為什么需要使用這樣的步驟？是的，我們用override是可以達到這 樣的效果，可是override過(guò)于粗暴，它同時(shí)會(huì )把從命令行定義的變量也覆蓋了，而我們只想重新定義環(huán)境傳來(lái)的，而不想重新定義命令行傳來(lái)的。

八、shell函數

shell函數也不像其它的函數。顧名思義，它的參數應該就是操作系統Shell的命令。它和反引號“`”是相同的功能。這就是說(shuō)，shell函數把執行 操作系統命令后的輸出作為函數返回。于是，我們可以用操作系統命令以及字符串處理命令awk，sed等等命令來(lái)生成一個(gè)變量，如：

    contents := $(shell cat foo)

    files := $(shell echo *.c)

注意，這個(gè)函數會(huì )新生成一個(gè)Shell程序來(lái)執行命令，所以你要注意其運行性能，如果你的Makefile中有一些比較復雜的規則，并大量使用了這個(gè)函 數，那么對于你的系統性能是有害的。特別是Makefile的隱晦的規則可能會(huì )讓你的shell函數執行的次數比你想像的多得多。

九、控制make的函數

make提供了一些函數來(lái)控制make的運行。通常，你需要檢測一些運行Makefile時(shí)的運行時(shí)信息，并且根據這些信息來(lái)決定，你是讓make繼續執行，還是停止。

$(error <text ...>

    產(chǎn)生一個(gè)致命的錯誤，<text ...>;是錯誤信息。注意，error函數不會(huì )在一被使用就會(huì )產(chǎn)生錯誤信息，所以如果你把其定義在某個(gè)變量中，并在后續的腳本中使用這個(gè)變量，那么也是可以的。例如：

    示例一：

    ifdef ERROR_001

    $(error error is $(ERROR_001))

    endif

    示例二：

    ERR = $(error found an error!)

    .PHONY: err

    err: ; $(ERR)

    示例一會(huì )在變量ERROR_001定義了后執行時(shí)產(chǎn)生error調用，而示例二則在目錄err被執行時(shí)才發(fā)生error調用。

$(warning <text ...>

     這個(gè)函數很像error函數，只是它并不會(huì )讓make退出，只是輸出一段警告信息，而make繼續執行。
make 的運行
——————

一般來(lái)說(shuō)，最簡(jiǎn)單的就是直接在命令行下輸入make命令，make命令會(huì )找當前目錄的makefile來(lái)執行，一切都是自動(dòng)的。但也有時(shí)你也許只想讓 make重編譯某些文件，而不是整個(gè)工程，而又有的時(shí)候你有幾套編譯規則，你想在不同的時(shí)候使用不同的編譯規則，等等。本章節就是講述如何使用make命 令的。

一、make的退出碼

make命令執行后有三個(gè)退出碼：

    0 —— 表示成功執行。
    1 —— 如果make運行時(shí)出現任何錯誤，其返回1。
    2 —— 如果你使用了make的“-q”選項，并且make使得一些目標不需要更新，那么返回2。

Make的相關(guān)參數我們會(huì )在后續章節中講述。

二、指定Makefile

前面我們說(shuō)過(guò)，GNU make找尋默認的Makefile的規則是在當前目錄下依次找三個(gè)文件——“GNUmakefile”、“makefile”和“Makefile”。其按順序找這三個(gè)文件，一旦找到，就開(kāi)始讀取這個(gè)文件并執行。

當前，我們也可以給make命令指定一個(gè)特殊名字的Makefile。要達到這個(gè)功能，我們要使用make的“-f”或是“--file”參數（“-- makefile”參數也行）。例如，我們有個(gè)makefile的名字是“hchen.mk”，那么，我們可以這樣來(lái)讓make來(lái)執行這個(gè)文件：

    make –f hchen.mk

如果在make的命令行是，你不只一次地使用了“-f”參數，那么，所有指定的makefile將會(huì )被連在一起傳遞給make執行。

三、指定目標

一般來(lái)說(shuō)，make的最終目標是makefile中的第一個(gè)目標，而其它目標一般是由這個(gè)目標連帶出來(lái)的。這是make的默認行為。當然，一般來(lái)說(shuō)，你的 makefile中的第一個(gè)目標是由許多個(gè)目標組成，你可以指示make，讓其完成你所指定的目標。要達到這一目的很簡(jiǎn)單，需在make命令后直接跟目標 的名字就可以完成（如前面提到的“make clean”形式）

任何在makefile中的目標都可以被指定成終極目標，但是除了以“-”打頭，或是包含了“=”的目標，因為有這些字符的目標，會(huì )被解析成命令行參數或 是變量。甚至沒(méi)有被我們明確寫(xiě)出來(lái)的目標也可以成為make的終極目標，也就是說(shuō)，只要make可以找到其隱含規則推導規則，那么這個(gè)隱含目標同樣可以被 指定成終極目標。

有一個(gè)make的環(huán)境變量叫“MAKECMDGOALS”，這個(gè)變量中會(huì )存放你所指定的終極目標的列表，如果在命令行上，你沒(méi)有指定目標，那么，這個(gè)變量是空值。這個(gè)變量可以讓你使用在一些比較特殊的情形下。比如下面的例子：

    sources = foo.c bar.c
    ifneq ( $(MAKECMDGOALS),clean)
    include $(sources:.c=.d)
    endif

基于上面的這個(gè)例子，只要我們輸入的命令不是“make clean”，那么makefile會(huì )自動(dòng)包含“foo.d”和“bar.d”這兩個(gè)makefile。

使用指定終極目標的方法可以很方便地讓我們編譯我們的程序，例如下面這個(gè)例子：

    .PHONY: all
    all: prog1 prog2 prog3 prog4

從這個(gè)例子中，我們可以看到，這個(gè)makefile中有四個(gè)需要編譯的程序——“prog1”， “prog2”， “prog3”和 “prog4”，我們可以使用“make all”命令來(lái)編譯所有的目標（如果把all置成第一個(gè)目標，那么只需執行“make”），我們也可以使用“make prog2”來(lái)單獨編譯目標“prog2”。

即然make可以指定所有makefile中的目標，那么也包括“偽目標”，于是我們可以根據這種性質(zhì)來(lái)讓我們的makefile根據指定的不同的目標來(lái) 完成不同的事。在Unix世界中，軟件發(fā)布時(shí)，特別是GNU這種開(kāi)源軟件的發(fā)布時(shí)，其makefile都包含了編譯、安裝、打包等功能。我們可以參照這種 規則來(lái)書(shū)寫(xiě)我們的makefile中的目標。

     “all”
        這個(gè)偽目標是所有目標的目標，其功能一般是編譯所有的目標。
     “clean”
        這個(gè)偽目標功能是刪除所有被make創(chuàng )建的文件。
     “install”
        這個(gè)偽目標功能是安裝已編譯好的程序，其實(shí)就是把目標執行文件拷貝到指定的目標中去。
     “print”
        這個(gè)偽目標的功能是例出改變過(guò)的源文件。
     “tar”
        這個(gè)偽目標功能是把源程序打包備份。也就是一個(gè)tar文件。
     “dist”
        這個(gè)偽目標功能是創(chuàng )建一個(gè)壓縮文件，一般是把tar文件壓成Z文件�；蚴莋z文件。
     “TAGS”
        這個(gè)偽目標功能是更新所有的目標，以備完整地重編譯使用。
     “check”和“test”
        這兩個(gè)偽目標一般用來(lái)測試makefile的流程。

當然一個(gè)項目的makefile中也不一定要書(shū)寫(xiě)這樣的目標，這些東西都是GNU的東西，但是我想，GNU搞出這些東西一定有其可取之處（等你的UNIX 下的程序文件一多時(shí)你就會(huì )發(fā)現這些功能很有用了），這里只不過(guò)是說(shuō)明了，如果你要書(shū)寫(xiě)這種功能，最好使用這種名字命名你的目標，這樣規范一些，規范的好處 就是——不用解釋?zhuān)�大家都明白。而且如果你的makefile中有這些功能，一是很實(shí)用，二是可以顯得你的makefile很專(zhuān)業(yè)（不是那種初學(xué)者的作 品）。

四、檢查規則

有時(shí)候，我們不想讓我們的makefile中的規則執行起來(lái)，我們只想檢查一下我們的命令，或是執行的序列。于是我們可以使用make命令的下述參數：

    “-n”
    “--just-print”
    “--dry-run”
    “--recon”
    不執行參數，這些參數只是打印命令，不管目標是否更新，把規則和連帶規則下的命令打印出來(lái)，但不執行，這些參數對于我們調試makefile很有用處。

    “-t”
    “--touch”
    這個(gè)參數的意思就是把目標文件的時(shí)間更新，但不更改目標文件。也就是說(shuō)，make假裝編譯目標，但不是真正的編譯目標，只是把目標變成已編譯過(guò)的狀態(tài)。

    “-q”
    “--question”
    這個(gè)參數的行為是找目標的意思，也就是說(shuō)，如果目標存在，那么其什么也不會(huì )輸出，當然也不會(huì )執行編譯，如果目標不存在，其會(huì )打印出一條出錯信息。

    “-W <file>;”
    “--what-if=<file>;”
    “--assume-new=<file>;”
    “--new-file=<file>;”
    這個(gè)參數需要指定一個(gè)文件。一般是是源文件（或依賴(lài)文件），Make會(huì )根據規則推導來(lái)運行依賴(lài)于這個(gè)文件的命令，一般來(lái)說(shuō)，可以和“-n”參數一同使用，來(lái)查看這個(gè)依賴(lài)文件所發(fā)生的規則命令。

另外一個(gè)很有意思的用法是結合“-p”和“-v”來(lái)輸出makefile被執行時(shí)的信息（這個(gè)將在后面講述）。

五、make的參數

下面列舉了所有GNU make 3.80版的參數定義。其它版本和產(chǎn)商的make大同小異，不過(guò)其它產(chǎn)商的make的具體參數還是請參考各自的產(chǎn)品文檔。

“-b”
“-m”
這兩個(gè)參數的作用是忽略和其它版本make的兼容性。

“-B”
“--always-make”
認為所有的目標都需要更新（重編譯）。

“-C <dir>;”
“--directory=<dir>;”
指定讀取makefile的目錄。如果有多個(gè)“-C”參數，make的解釋是后面的路徑以前面的作為相對路徑，并以最后的目錄作為被指定目錄。如：“make –C ~hchen/test –C prog”等價(jià)于“make –C ~hchen/test/prog”。

“—debug[=<options>;]”
輸出make的調試信息。它有幾種不同的級別可供選擇，如果沒(méi)有參數，那就是輸出最簡(jiǎn)單的調試信息。下面是<options>;的取值：
    a —— 也就是all，輸出所有的調試信息。（會(huì )非常的多）
    b —— 也就是basic，只輸出簡(jiǎn)單的調試信息。即輸出不需要重編譯的目標。
    v —— 也就是verbose，在b選項的級別之上。輸出的信息包括哪個(gè)makefile被解析，不需要被重編譯的依賴(lài)文件（或是依賴(lài)目標）等。
    i —— 也就是implicit，輸出所以的隱含規則。
    j —— 也就是jobs，輸出執行規則中命令的詳細信息，如命令的PID、返回碼等。
    m —— 也就是makefile，輸出make讀取makefile，更新makefile，執行makefile的信息。

“-d”
相當于“--debug=a”。

“-e”
“--environment-overrides”
指明環(huán)境變量的值覆蓋makefile中定義的變量的值。

“-f=<file>;”
“--file=<file>;”
“--makefile=<file>;”
指定需要執行的makefile。

“-h”
“--help”
顯示幫助信息。

“-i”
“--ignore-errors”
在執行時(shí)忽略所有的錯誤。

“-I <dir>;”
“--include-dir=<dir>;”
指定一個(gè)被包含makefile的搜索目標�？梢允褂枚鄠�(gè)“-I”參數來(lái)指定多個(gè)目錄。

“-j [<jobsnum>;]”
“--jobs[=<jobsnum>;]”
指同時(shí)運行命令的個(gè)數。如果沒(méi)有這個(gè)參數，make運行命令時(shí)能運行多少就運行多少。如果有一個(gè)以上的“-j”參數，那么僅最后一個(gè)“-j”才是有效的。（注意這個(gè)參數在MS-DOS中是無(wú)用的）

“-k”
“--keep-going”
出錯也不停止運行。如果生成一個(gè)目標失敗了，那么依賴(lài)于其上的目標就不會(huì )被執行了。

“-l <load>;”
“--load-average[=<load]”
“—max-load[=<load>;]”
指定make運行命令的負載。

“-n”
“--just-print”
“--dry-run”
“--recon”
僅輸出執行過(guò)程中的命令序列，但并不執行。

“-o <file>;”
“--old-file=<file>;”
“--assume-old=<file>;”
不重新生成的指定的<file>;，即使這個(gè)目標的依賴(lài)文件新于它。

“-p”
“--print-data-base”
輸出makefile中的所有數據，包括所有的規則和變量。這個(gè)參數會(huì )讓一個(gè)簡(jiǎn)單的makefile都會(huì )輸出一堆信息。如果你只是想輸出信息而不想執行 makefile，你可以使用“make -qp”命令。如果你想查看執行makefile前的預設變量和規則，你可以使用“make –p –f /dev/null”。這個(gè)參數輸出的信息會(huì )包含著(zhù)你的makefile文件的文件名和行號，所以，用這個(gè)參數來(lái)調試你的makefile會(huì )是很有用的， 特別是當你的環(huán)境變量很復雜的時(shí)候。

“-q”
“--question”
不運行命令，也不輸出。僅僅是檢查所指定的目標是否需要更新。如果是0則說(shuō)明要更新，如果是2則說(shuō)明有錯誤發(fā)生。

“-r”
“--no-builtin-rules”
禁止make使用任何隱含規則。

“-R”
“--no-builtin-variabes”
禁止make使用任何作用于變量上的隱含規則。

“-s”
“--silent”
“--quiet”
在命令運行時(shí)不輸出命令的輸出。

“-S”
“--no-keep-going”
“--stop”
取消“-k”選項的作用。因為有些時(shí)候，make的選項是從環(huán)境變量“MAKEFLAGS”中繼承下來(lái)的。所以你可以在命令行中使用這個(gè)參數來(lái)讓環(huán)境變量中的“-k”選項失效。

“-t”
“--touch”
相當于UNIX的touch命令，只是把目標的修改日期變成最新的，也就是阻止生成目標的命令運行。

“-v”
“--version”
輸出make程序的版本、版權等關(guān)于make的信息。

“-w”
“--print-directory”
輸出運行makefile之前和之后的信息。這個(gè)參數對于跟蹤嵌套式調用make時(shí)很有用。

“--no-print-directory”
禁止“-w”選項。

“-W <file>;”
“--what-if=<file>;”
“--new-file=<file>;”
“--assume-file=<file>;”
假定目標<file>;需要更新，如果和“-n”選項使用，那么這個(gè)參數會(huì )輸出該目標更新時(shí)的運行動(dòng)作。如果沒(méi)有“-n”那么就像運行UNIX的“touch”命令一樣，使得<file>;的修改時(shí)間為當前時(shí)間。

“--warn-undefined-variables”
只要make發(fā)現有未定義的變量，那么就輸出警告信息。

隱含規則
————

在我們使用Makefile時(shí)，有一些我們會(huì )經(jīng)常使用，而且使用頻率非常高的東西，比如，我們編譯C/C++的源程序為中間目標文件（Unix下是 [.o]文件，Windows下是[.obj]文件）。本章講述的就是一些在Makefile中的“隱含的”，早先約定了的，不需要我們再寫(xiě)出來(lái)的規則。

“隱含規則”也就是一種慣例，make會(huì )按照這種“慣例”心照不喧地來(lái)運行，那怕我們的Makefile中沒(méi)有書(shū)寫(xiě)這樣的規則。例如，把[.c]文件編譯成[.o]文件這一規則，你根本就不用寫(xiě)出來(lái)，make會(huì )自動(dòng)推導出這種規則，并生成我們需要的[.o]文件。

“隱含規則”會(huì )使用一些我們系統變量，我們可以改變這些系統變量的值來(lái)定制隱含規則的運行時(shí)的參數。如系統變量“CFLAGS”可以控制編譯時(shí)的編譯器參數。

我們還可以通過(guò)“模式規則”的方式寫(xiě)下自己的隱含規則。用“后綴規則”來(lái)定義隱含規則會(huì )有許多的限制。使用“模式規則”會(huì )更回得智能和清楚，但“后綴規則”可以用來(lái)保證我們Makefile的兼容性。
我們了解了“隱含規則”，可以讓其為我們更好的服務(wù)，也會(huì )讓我們知道一些“約定俗成”了的東西，而不至于使得我們在運行Makefile時(shí)出現一些我們覺(jué) 得莫名其妙的東西。當然，任何事物都是矛盾的，水能載舟，亦可覆舟，所以，有時(shí)候“隱含規則”也會(huì )給我們造成不小的麻煩。只有了解了它，我們才能更好地使 用它。

一、使用隱含規則

如果要使用隱含規則生成你需要的目標，你所需要做的就是不要寫(xiě)出這個(gè)目標的規則。那么，make會(huì )試圖去自動(dòng)推導產(chǎn)生這個(gè)目標的規則和命令，如果make 可以自動(dòng)推導生成這個(gè)目標的規則和命令，那么這個(gè)行為就是隱含規則的自動(dòng)推導。當然，隱含規則是make事先約定好的一些東西。例如，我們有下面的一個(gè) Makefile：

    foo : foo.o bar.o
            cc –o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)

我們可以注意到，這個(gè)Makefile中并沒(méi)有寫(xiě)下如何生成foo.o和bar.o這兩目標的規則和命令。因為make的“隱含規則”功能會(huì )自動(dòng)為我們自動(dòng)去推導這兩個(gè)目標的依賴(lài)目標和生成命令。

make會(huì )在自己的“隱含規則”庫中尋找可以用的規則，如果找到，那么就會(huì )使用。如果找不到，那么就會(huì )報錯。在上面的那個(gè)例子中，make調用的隱含規則 是，把[.o]的目標的依賴(lài)文件置成[.c]，并使用C的編譯命令“cc –c $(CFLAGS) [.c]”來(lái)生成[.o]的目標。也就是說(shuō)，我們完全沒(méi)有必要寫(xiě)下下面的兩條規則：

    foo.o : foo.c
            cc –c foo.c $(CFLAGS)
    bar.o : bar.c
        cc –c bar.c $(CFLAGS)

因為，這已經(jīng)是“約定”好了的事了，make和我們約定好了用C編譯器“cc”生成[.o]文件的規則，這就是隱含規則。

當然，如果我們?yōu)閇.o]文件書(shū)寫(xiě)了自己的規則，那么make就不會(huì )自動(dòng)推導并調用隱含規則，它會(huì )按照我們寫(xiě)好的規則忠實(shí)地執行。

還有，在make的“隱含規則庫”中，每一條隱含規則都在庫中有其順序，越靠前的則是越被經(jīng)常使用的，所以，這會(huì )導致我們有些時(shí)候即使我們顯示地指定了目標依賴(lài)，make也不會(huì )管。如下面這條規則（沒(méi)有命令）：

    foo.o : foo.p

依賴(lài)文件“foo.p”（Pascal程序的源文件）有可能變得沒(méi)有意義。如果目錄下存在了“foo.c”文件，那么我們的隱含規則一樣會(huì )生效，并會(huì )通過(guò) “foo.c”調用C的編譯器生成foo.o文件。因為，在隱含規則中，Pascal的規則出現在C的規則之后，所以，make找到可以生成foo.o的 C的規則就不再尋找下一條規則了。如果你確實(shí)不希望任何隱含規則推導，那么，你就不要只寫(xiě)出“依賴(lài)規則”，而不寫(xiě)命令。

二、隱含規則一覽

這里我們將講述所有預先設置（也就是make內建）的隱含規則，如果我們不明確地寫(xiě)下規則，那么，make就會(huì )在這些規則中尋找所需要規則和命令。當然，我們也可以使用make的參數“-r”或“--no-builtin-rules”選項來(lái)取消所有的預設置的隱含規則。

當然，即使是我們指定了“-r”參數，某些隱含規則還是會(huì )生效，因為有許多的隱含規則都是使用了“后綴規則”來(lái)定義的，所以，只要隱含規則中有“后綴列 表”（也就一系統定義在目標.SUFFIXES的依賴(lài)目標），那么隱含規則就會(huì )生效。默認的后綴列表是：.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。具體的細節，我們會(huì )在后面講述。

還是先來(lái)看一看常用的隱含規則吧。

1、編譯C程序的隱含規則。
“<n>;.o”的目標的依賴(lài)目標會(huì )自動(dòng)推導為“<n>;.c”，并且其生成命令是“$(CC) –c $(CPPFLAGS) $(CFLAGS)”

2、編譯C++程序的隱含規則。
“<n>;.o”的目標的依賴(lài)目標會(huì )自動(dòng)推導為“<n>;.cc”或是“<n>;.C”，并且其生成命令是“$ (CXX) –c $(CPPFLAGS) $(CFLAGS)”。（建議使用“.cc”作為C++源文件的后綴，而不是“.C”）

3、編譯Pascal程序的隱含規則。
“<n>;.o”的目標的依賴(lài)目標會(huì )自動(dòng)推導為“<n>;.p”，并且其生成命令是“$(PC) –c  $(PFLAGS)”。

4、編譯Fortran/Ratfor程序的隱含規則。
“<n>;.o”的目標的依賴(lài)目標會(huì )自動(dòng)推導為“<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”的目標的依賴(lài)目標會(huì )自動(dòng)推導為“<n>;.r”或“<n>;.F”。這個(gè)規則只是轉換Ratfor或有預處理的Fortran程序到一個(gè)標準的Fortran程序。其使用的命令是：
    “.F”  “$(FC) –F $(CPPFLAGS) $(FFLAGS)”
    “.r”  “$(FC) –F $(FFLAGS) $(RFLAGS)”

6、編譯Modula-2程序的隱含規則。
“<n>;.sym”的目標的依賴(lài)目標會(huì )自動(dòng)推導為“<n>;.def”，并且其生成命令是：“$(M2C) $(M2FLAGS) $(DEFFLAGS)”�！�<n.o>;” 的目標的依賴(lài)目標會(huì )自動(dòng)推導為“<n>;.mod”，并且其生成命令是：“$(M2C) $(M2FLAGS) $(MODFLAGS)”。

7、匯編和匯編預處理的隱含規則。
“<n>;.o” 的目標的依賴(lài)目標會(huì )自動(dòng)推導為“<n>;.s”，默認使用編譯品“as”，并且其生成命令是：“$(AS) $(ASFLAGS)”�！�<n>;.s” 的目標的依賴(lài)目標會(huì )自動(dòng)推導為“<n>;.S”，默認使用C預編譯器“cpp”，并且其生成命令是：“$(AS) $(ASFLAGS)”。

8、鏈接Object文件的隱含規則。
“<n>;”目標依賴(lài)于“<n>;.o”，通過(guò)運行C的編譯器來(lái)運行鏈接程序生成（一般是“l(fā)d”），其生成命令是：“$ (CC) $(LDFLAGS) <n>;.o $(LOADLIBES) $(LDLIBS)”。這個(gè)規則對于只有一個(gè)源文件的工程有效，同時(shí)也對多個(gè)Object文件（由不同的源文件生成）的也有效。例如如下規則：

    x : y.o z.o

并且“x.c”、“y.c”和“z.c”都存在時(shí)，隱含規則將執行如下命令：

    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

如果沒(méi)有一個(gè)源文件（如上例中的x.c）和你的目標名字（如上例中的x）相關(guān)聯(lián)，那么，你最好寫(xiě)出自己的生成規則，不然，隱含規則會(huì )報錯的。

9、Yacc C程序時(shí)的隱含規則。
“<n>;.c”的依賴(lài)文件被自動(dòng)推導為“n.y”（Yacc生成的文件），其生成命令是：“$(YACC) $(YFALGS)”。（“Yacc”是一個(gè)語(yǔ)法分析器，關(guān)于其細節請查看相關(guān)資料）

10、Lex C程序時(shí)的隱含規則。
“<n>;.c”的依賴(lài)文件被自動(dòng)推導為“n.l”（Lex生成的文件），其生成命令是：“$(LEX) $(LFALGS)”。（關(guān)于“Lex”的細節請查看相關(guān)資料）

11、Lex Ratfor程序時(shí)的隱含規則。
“<n>;.r”的依賴(lài)文件被自動(dòng)推導為“n.l”（Lex生成的文件），其生成命令是：“$(LEX) $(LFALGS)”。

12、從C程序、Yacc文件或Lex文件創(chuàng )建Lint庫的隱含規則。
“<n>;.ln” （lint生成的文件）的依賴(lài)文件被自動(dòng)推導為“n.c”，其生成命令是：“$(LINT) $(LINTFALGS) $(CPPFLAGS) -i”。對于“<n>;.y”和“<n>;.l”也是同樣的規則。

三、隱含規則使用的變量

在隱含規則中的命令中，基本上都是使用了一些預先設置的變量。你可以在你的makefile中改變這些變量的值，或是在make的命令行中傳入這些值，或 是在你的環(huán)境變量中設置這些值，無(wú)論怎么樣，只要設置了這些特定的變量，那么其就會(huì )對隱含規則起作用。當然，你也可以利用make的“-R”或“-- no–builtin-variables”參數來(lái)取消你所定義的變量對隱含規則的作用。

例如，第一條隱含規則——編譯C程序的隱含規則的命令是“$(CC) –c $(CFLAGS) $(CPPFLAGS)”。Make默認的編譯命令是“cc”，如果你把變量“$(CC)”重定義成“gcc”，把變量“$(CFLAGS)”重定義成 “-g”，那么，隱含規則中的命令全部會(huì )以“gcc –c -g $(CPPFLAGS)”的樣子來(lái)執行了。

我們可以把隱含規則中使用的變量分成兩種：一種是命令相關(guān)的，如“CC”；一種是參數相的關(guān)，如“CFLAGS”。下面是所有隱含規則中會(huì )用到的變量：

1、關(guān)于命令的變量。

AR
    函數庫打包程序。默認命令是“ar”。
AS
    匯編語(yǔ)言編譯程序。默認命令是“as”。
CC
    C語(yǔ)言編譯程序。默認命令是“cc”。
CXX
    C++語(yǔ)言編譯程序。默認命令是“g++”。
CO
    從 RCS文件中擴展文件程序。默認命令是“co”。
CPP
    C程序的預處理器（輸出是標準輸出設備）。默認命令是“$(CC) –E”。
FC
    Fortran 和 Ratfor 的編譯器和預處理程序。默認命令是“f77”。
GET
    從SCCS文件中擴展文件的程序。默認命令是“get”。
LEX
    Lex方法分析器程序（針對于C或Ratfor）。默認命令是“l(fā)ex”。
PC
    Pascal語(yǔ)言編譯程序。默認命令是“pc”。
YACC
    Yacc文法分析器（針對于C程序）。默認命令是“yacc”。
YACCR
    Yacc文法分析器（針對于Ratfor程序）。默認命令是“yacc –r”。
MAKEINFO
    轉換Texinfo源文件（.texi）到Info文件程序。默認命令是“makeinfo”。
TEX
    從TeX源文件創(chuàng )建TeX DVI文件的程序。默認命令是“tex”。
TEXI2DVI
    從Texinfo源文件創(chuàng )建軍TeX DVI 文件的程序。默認命令是“texi2dvi”。
WEAVE
    轉換Web到TeX的程序。默認命令是“weave”。
CWEAVE
    轉換C Web 到 TeX的程序。默認命令是“cweave”。
TANGLE
    轉換Web到Pascal語(yǔ)言的程序。默認命令是“tangle”。
CTANGLE
    轉換C Web 到 C。默認命令是“ctangle”。
RM
    刪除文件命令。默認命令是“rm –f”。

2、關(guān)于命令參數的變量

下面的這些變量都是相關(guān)上面的命令的參數。如果沒(méi)有指明其默認值，那么其默認值都是空。

ARFLAGS
    函數庫打包程序AR命令的參數。默認值是“rv”。
ASFLAGS
    匯編語(yǔ)言編譯器參數。（當明顯地調用“.s”或“.S”文件時(shí)）。
CFLAGS
    C語(yǔ)言編譯器參數。
CXXFLAGS
    C++語(yǔ)言編譯器參數。
COFLAGS
    RCS命令參數。
CPPFLAGS
    C預處理器參數。（ C 和 Fortran 編譯器也會(huì )用到）。
FFLAGS
    Fortran語(yǔ)言編譯器參數。
GFLAGS
    SCCS “get”程序參數。
LDFLAGS
    鏈接器參數。（如：“l(fā)d”）
LFLAGS
    Lex文法分析器參數。
PFLAGS
    Pascal語(yǔ)言編譯器參數。
RFLAGS
    Ratfor 程序的Fortran 編譯器參數。
YFLAGS
    Yacc文法分析器參數。

四、隱含規則鏈

有些時(shí)候，一個(gè)目標可能被一系列的隱含規則所作用。例如，一個(gè)[.o]的文件生成，可能會(huì )是先被Yacc的[.y]文件先成[.c]，然后再被C的編譯器生成。我們把這一系列的隱含規則叫做“隱含規則鏈”。

在上面的例子中，如果文件[.c]存在，那么就直接調用C的編譯器的隱含規則，如果沒(méi)有[.c]文件，但有一個(gè)[.y]文件，那么Yacc的隱含規則會(huì )被調用，生成[.c]文件，然后，再調用C編譯的隱含規則最終由[.c]生成[.o]文件，達到目標。

我們把這種[.c]的文件（或是目標），叫做中間目標。不管怎么樣，make會(huì )努力自動(dòng)推導生成目標的一切方法，不管中間目標有多少，其都會(huì )執著(zhù)地把所有 的隱含規則和你書(shū)寫(xiě)的規則全部合起來(lái)分析，努力達到目標，所以，有些時(shí)候，可能會(huì )讓你覺(jué)得奇怪，怎么我的目標會(huì )這樣生成？怎么我的makefile發(fā)瘋 了？

在默認情況下，對于中間目標，它和一般的目標有兩個(gè)地方所不同：第一個(gè)不同是除非中間的目標不存在，才會(huì )引發(fā)中間規則。第二個(gè)不同的是，只要目標成功產(chǎn)生，那么，產(chǎn)生最終目標過(guò)程中，所產(chǎn)生的中間目標文件會(huì )被以“rm -f”刪除。

通常，一個(gè)被makefile指定成目標或是依賴(lài)目標的文件不能被當作中介。然而，你可以明顯地說(shuō)明一個(gè)文件或是目標是中介目標，你可以使用偽目標“.INTERMEDIATE”來(lái)強制聲明。（如：.INTERMEDIATE ： mid ）

你也可以阻止make自動(dòng)刪除中間目標，要做到這一點(diǎn)，你可以使用偽目標“.SECONDARY”來(lái)強制聲明（如：.SECONDARY : sec）。你還可以把你的目標，以模式的方式來(lái)指定（如：%.o）成偽目標“.PRECIOUS”的依賴(lài)目標，以保存被隱含規則所生成的中間文件。

在“隱含規則鏈”中，禁止同一個(gè)目標出現兩次或兩次以上，這樣一來(lái)，就可防止在make自動(dòng)推導時(shí)出現無(wú)限遞歸的情況。

Make會(huì )優(yōu)化一些特殊的隱含規則，而不生成中間文件。如，從文件“foo.c”生成目標程序“foo”，按道理，make會(huì )編譯生成中間文件 “foo.o”，然后鏈接成“foo”，但在實(shí)際情況下，這一動(dòng)作可以被一條“cc”的命令完成（cc –o foo foo.c），于是優(yōu)化過(guò)的規則就不會(huì )生成中間文件。
五、定義模式規則

你可以使用模式規則來(lái)定義一個(gè)隱含規則。一個(gè)模式規則就好像一個(gè)一般的規則，只是在規則中，目標的定義需要有"%"字符。"%"的意思是表示一個(gè)或多個(gè)任意字符。在依賴(lài)目標中同樣可以使用"%"，只是依賴(lài)目標中的"%"的取值，取決于其目標。

有一點(diǎn)需要注意的是，"%"的展開(kāi)發(fā)生在變量和函數的展開(kāi)之后，變量和函數的展開(kāi)發(fā)生在make載入Makefile時(shí)，而模式規則中的"%"則發(fā)生在運行時(shí)。

1、模式規則介紹

模式規則中，至少在規則的目標定義中要包含"%"，否則，就是一般的規則。目標中的"%"定義表示對文件名的匹配，"%"表示長(cháng)度任意的非空字符串。例 如："%.c"表示以".c"結尾的文件名（文件名的長(cháng)度至少為3），而"s.%.c"則表示以"s."開(kāi)頭，".c"結尾的文件名（文件名的長(cháng)度至少為 5）。

如果"%"定義在目標中，那么，目標中的"%"的值決定了依賴(lài)目標中的"%"的值，也就是說(shuō)，目標中的模式的"%"決定了依賴(lài)目標中"%"的樣子。例如有一個(gè)模式規則如下：

    %.o : %.c ; <command ......>;

其含義是，指出了怎么從所有的[.c]文件生成相應的[.o]文件的規則。如果要生成的目標是"a.o b.o"，那么"%c"就是"a.c b.c"。

一旦依賴(lài)目標中的"%"模式被確定，那么，make會(huì )被要求去匹配當前目錄下所有的文件名，一旦找到，make就會(huì )規則下的命令，所以，在模式規則中，目 標可能會(huì )是多個(gè)的，如果有模式匹配出多個(gè)目標，make就會(huì )產(chǎn)生所有的模式目標，此時(shí)，make關(guān)心的是依賴(lài)的文件名和生成目標的命令這兩件事。

2、模式規則示例

下面這個(gè)例子表示了,把所有的[.c]文件都編譯成[.o]文件.

    %.o : %.c
            $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@

其中，"$@"表示所有的目標的挨個(gè)值，"$<"表示了所有依賴(lài)目標的挨個(gè)值。這些奇怪的變量我們叫"自動(dòng)化變量"，后面會(huì )詳細講述。

下面的這個(gè)例子中有兩個(gè)目標是模式的：

    %.tab.c %.tab.h: %.y
            bison -d $<

這條規則告訴make把所有的[.y]文件都以"bison -d <n>;.y"執行，然后生成"<n>;.tab.c"和"<n>;.tab.h"文件。（其中，"< n>;"表示一個(gè)任意字符串）。如果我們的執行程序"foo"依賴(lài)于文件"parse.tab.o"和"scan.o"，并且文件"scan.o" 依賴(lài)于文件"parse.tab.h"，如果"parse.y"文件被更新了，那么根據上述的規則，"bison -d parse.y"就會(huì )被執行一次，于是，"parse.tab.o"和"scan.o"的依賴(lài)文件就齊了。（假設，"parse.tab.o"由 "parse.tab.c"生成，和"scan.o"由"scan.c"生成，而"foo"由"parse.tab.o"和"scan.o"鏈接生成，而 且foo和其[.o]文件的依賴(lài)關(guān)系也寫(xiě)好，那么，所有的目標都會(huì )得到滿(mǎn)足）

3、自動(dòng)化變量

在上述的模式規則中，目標和依賴(lài)文件都是一系例的文件，那么我們如何書(shū)寫(xiě)一個(gè)命令來(lái)完成從不同的依賴(lài)文件生成相應的目標？因為在每一次的對模式規則的解析時(shí)，都會(huì )是不同的目標和依賴(lài)文件。

自動(dòng)化變量就是完成這個(gè)功能的。在前面，我們已經(jīng)對自動(dòng)化變量有所提涉，相信你看到這里已對它有一個(gè)感性認識了。所謂自動(dòng)化變量，就是這種變量會(huì )把模式中所定義的一系列的文件自動(dòng)地挨個(gè)取出，直至所有的符合模式的文件都取完了。這種自動(dòng)化變量只應出現在規則的命令中。

下面是所有的自動(dòng)化變量及其說(shuō)明：

$@
    表示規則中的目標文件集。在模式規則中，如果有多個(gè)目標，那么，"$@"就是匹配于目標中模式定義的集合。

$%
    僅當目標是函數庫文件中，表示規則中的目標成員名。例如，如果一個(gè)目標是"foo.a(bar.o)"，那么，"$%"就是"bar.o"，"$@"就是 "foo.a"。如果目標不是函數庫文件（Unix下是[.a]，Windows下是[.lib]），那么，其值為空。

$<
    依賴(lài)目標中的第一個(gè)目標名字。如果依賴(lài)目標是以模式（即"%"）定義的，那么"$<"將是符合模式的一系列的文件集。注意，其是一個(gè)一個(gè)取出來(lái)的。

$?
    所有比目標新的依賴(lài)目標的集合。以空格分隔。

$^
    所有的依賴(lài)目標的集合。以空格分隔。如果在依賴(lài)目標中有多個(gè)重復的，那個(gè)這個(gè)變量會(huì )去除重復的依賴(lài)目標，只保留一份。

$+
    這個(gè)變量很像"$^"，也是所有依賴(lài)目標的集合。只是它不去除重復的依賴(lài)目標。

$*
   這個(gè)變量表示目標模式中"%"及其之前的部分。如果目標是"dir/a.foo.b"，并且目標的模式是"a.%.b"，那么，"$*"的值就是 "dir/a.foo"。這個(gè)變量對于構造有關(guān)聯(lián)的文件名是比較有較。如果目標中沒(méi)有模式的定義，那么"$*"也就不能被推導出，但是，如果目標文件的后 綴是make所識別的，那么"$*"就是除了后綴的那一部分。例如：如果目標是"foo.c"，因為".c"是make所能識別的后綴名，所以，"$*" 的值就是"foo"。這個(gè)特性是GNU make的，很有可能不兼容于其它版本的make，所以，你應該盡量避免使用"$*"，除非是在隱含規則或是靜態(tài)模式中。如果目標中的后綴是make所不 能識別的，那么"$*"就是空值。

當你希望只對更新過(guò)的依賴(lài)文件進(jìn)行操作時(shí)，"$?"在顯式規則中很有用，例如，假設有一個(gè)函數庫文件叫"lib"，其由其它幾個(gè)object文件更新。那么把object文件打包的比較有效率的Makefile規則是：

    lib : foo.o bar.o lose.o win.o
            ar r lib $?

在上述所列出來(lái)的自動(dòng)量變量中。四個(gè)變量（$@、$<、$%、$*）在擴展時(shí)只會(huì )有一個(gè)文件，而另三個(gè)的值是一個(gè)文件列表。這七個(gè)自動(dòng)化變量還可以 取得文件的目錄名或是在當前目錄下的符合模式的文件名，只需要搭配上"D"或"F"字樣。這是GNU make中老版本的特性，在新版本中，我們使用函數"dir"或"notdir"就可以做到了。"D"的含義就是Directory，就是目錄，"F"的 含義就是File，就是文件。

下面是對于上面的七個(gè)變量分別加上"D"或是"F"的含義：

$(@D)
    表示"$@"的目錄部分（不以斜杠作為結尾），如果"$@"值是"dir/foo.o"，那么"$(@D)"就是"dir"，而如果"$@"中沒(méi)有包含斜杠的話(huà)，其值就是"."（當前目錄）。

$(@F)
    表示"$@"的文件部分，如果"$@"值是"dir/foo.o"，那么"$(@F)"就是"foo.o"，"$(@F)"相當于函數"$(notdir $@)"。

"$(*D)"
"$(*F)"
    和上面所述的同理，也是取文件的目錄部分和文件部分。對于上面的那個(gè)例子，"$(*D)"返回"dir"，而"$(*F)"返回"foo"

"$(%D)"
"$(%F)"
    分別表示了函數包文件成員的目錄部分和文件部分。這對于形同"archive(member)"形式的目標中的"member"中包含了不同的目錄很有用。

"$(<D)"
"$(<F)"
    分別表示依賴(lài)文件的目錄部分和文件部分。

"$(^D)"
"$(^F)"
    分別表示所有依賴(lài)文件的目錄部分和文件部分。（無(wú)相同的）

"$(+D)"
"$(+F)"
    分別表示所有依賴(lài)文件的目錄部分和文件部分。（可以有相同的）

"$(?D)"
"$(?F)"
    分別表示被更新的依賴(lài)文件的目錄部分和文件部分。

最后想提醒一下的是，對于"$<"，為了避免產(chǎn)生不必要的麻煩，我們最好給$后面的那個(gè)特定字符都加上圓括號，比如，"$(<"就要比"$<"要好一些。

還得要注意的是，這些變量只使用在規則的命令中，而且一般都是"顯式規則"和"靜態(tài)模式規則"（參見(jiàn)前面"書(shū)寫(xiě)規則"一章）。其在隱含規則中并沒(méi)有意義。

4、模式的匹配

一般來(lái)說(shuō)，一個(gè)目標的模式有一個(gè)有前綴或是后綴的"%"，或是沒(méi)有前后綴，直接就是一個(gè)"%"。因為"%"代表一個(gè)或多個(gè)字符，所以在定義好了的模式中， 我們把"%"所匹配的內容叫做"莖"，例如"%.c"所匹配的文件"test.c"中"test"就是"莖"。因為在目標和依賴(lài)目標中同時(shí)有"%"時(shí)，依 賴(lài)目標的"莖"會(huì )傳給目標，當做目標中的"莖"。

當一個(gè)模式匹配包含有斜杠（實(shí)際也不經(jīng)常包含）的文件時(shí)，那么在進(jìn)行模式匹配時(shí)，目錄部分會(huì )首先被移開(kāi)，然后進(jìn)行匹配，成功后，再把目錄加回去。在進(jìn)行" 莖"的傳遞時(shí)，我們需要知道這個(gè)步驟。例如有一個(gè)模式"e%t"，文件"src/eat"匹配于該模式，于是"src/a"就是其"莖"，如果這個(gè)模式定 義在依賴(lài)目標中，而被依賴(lài)于這個(gè)模式的目標中又有個(gè)模式"c%r"，那么，目標就是"src/car"。（"莖"被傳遞）

5、重載內建隱含規則

你可以重載內建的隱含規則（或是定義一個(gè)全新的），例如你可以重新構造和內建隱含規則不同的命令，如：

    %.o : %.c
            $(CC) -c $(CPPFLAGS) $(CFLAGS) -D$(date)

你可以取消內建的隱含規則，只要不在后面寫(xiě)命令就行。如：

    %.o : %.s

同樣，你也可以重新定義一個(gè)全新的隱含規則，其在隱含規則中的位置取決于你在哪里寫(xiě)下這個(gè)規則。朝前的位置就靠前。

六、老式風(fēng)格的"后綴規則"

后綴規則是一個(gè)比較老式的定義隱含規則的方法。后綴規則會(huì )被模式規則逐步地取代。因為模式規則更強更清晰。為了和老版本的Makefile兼容，GNU make同樣兼容于這些東西。后綴規則有兩種方式："雙后綴"和"單后綴"。

雙后綴規則定義了一對后綴：目標文件的后綴和依賴(lài)目標（源文件）的后綴。如".c.o"相當于"%o : %c"。單后綴規則只定義一個(gè)后綴，也就是源文件的后綴。如".c"相當于"% : %.c"。

后綴規則中所定義的后綴應該是make所認識的，如果一個(gè)后綴是make所認識的，那么這個(gè)規則就是單后綴規則，而如果兩個(gè)連在一起的后綴都被make所 認識，那就是雙后綴規則。例如：".c"和".o"都是make所知道。因而，如果你定義了一個(gè)規則是".c.o"那么其就是雙后綴規則，意義就是 ".c"是源文件的后綴，".o"是目標文件的后綴。如下示例：

    .c.o:
            $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<

后綴規則不允許任何的依賴(lài)文件，如果有依賴(lài)文件的話(huà)，那就不是后綴規則，那些后綴統統被認為是文件名，如：

    .c.o: foo.h
            $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<

這個(gè)例子，就是說(shuō)，文件".c.o"依賴(lài)于文件"foo.h"，而不是我們想要的這樣：

    %.o: %.c foo.h
            $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<

后綴規則中，如果沒(méi)有命令，那是毫無(wú)意義的。因為他也不會(huì )移去內建的隱含規則。

而要讓make知道一些特定的后綴，我們可以使用偽目標".SUFFIXES"來(lái)定義或是刪除，如：

    .SUFFIXES: .hack .win

把后綴.hack和.win加入后綴列表中的末尾。

    .SUFFIXES:              # 刪除默認的后綴
    .SUFFIXES: .c .o .h   # 定義自己的后綴

先清楚默認后綴，后定義自己的后綴列表。

make的參數"-r"或"-no-builtin-rules"也會(huì )使用得默認的后綴列表為空。而變量"SUFFIXE"被用來(lái)定義默認的后綴列表，你可以用".SUFFIXES"來(lái)改變后綴列表，但請不要改變變量"SUFFIXE"的值。

七、隱含規則搜索算法

比如我們有一個(gè)目標叫 T。下面是搜索目標T的規則的算法。請注意，在下面，我們沒(méi)有提到后綴規則，原因是，所有的后綴規則在Makefile被載入內存時(shí)，會(huì )被轉換成模式規 則。如果目標是"archive(member)"的函數庫文件模式，那么這個(gè)算法會(huì )被運行兩次，第一次是找目標T，如果沒(méi)有找到的話(huà)，那么進(jìn)入第二次， 第二次會(huì )把"member"當作T來(lái)搜索。

1、把T的目錄部分分離出來(lái)。叫D，而剩余部分叫N。（如：如果T是"src/foo.o"，那么，D就是"src/"，N就是"foo.o"）

2、創(chuàng )建所有匹配于T或是N的模式規則列表。

3、如果在模式規則列表中有匹配所有文件的模式，如"%"，那么從列表中移除其它的模式。

4、移除列表中沒(méi)有命令的規則。

5、對于第一個(gè)在列表中的模式規則：
    1）推導其"莖"S，S應該是T或是N匹配于模式中"%"非空的部分。
    2）計算依賴(lài)文件。把依賴(lài)文件中的"%"都替換成"莖"S。如果目標模式中沒(méi)有包含斜框字符，而把D加在第一個(gè)依賴(lài)文件的開(kāi)頭。
3）測試是否所有的依賴(lài)文件都存在或是理當存在。（如果有一個(gè)文件被定義成另外一個(gè)規則的目標文件，或者是一個(gè)顯式規則的依賴(lài)文件，那么這個(gè)文件就叫"理當存在"）
    4）如果所有的依賴(lài)文件存在或是理當存在，或是就沒(méi)有依賴(lài)文件。那么這條規則將被采用，退出該算法。

6、如果經(jīng)過(guò)第5步，沒(méi)有模式規則被找到，那么就做更進(jìn)一步的搜索。對于存在于列表中的第一個(gè)模式規則：
    1）如果規則是終止規則，那就忽略它，繼續下一條模式規則。
2）計算依賴(lài)文件。（同第5步）
3）測試所有的依賴(lài)文件是否存在或是理當存在。
4）對于不存在的依賴(lài)文件，遞歸調用這個(gè)算法查找他是否可以被隱含規則找到。
5）如果所有的依賴(lài)文件存在或是理當存在，或是就根本沒(méi)有依賴(lài)文件。那么這條規則被采用，退出該算法。

7、如果沒(méi)有隱含規則可以使用，查看".DEFAULT"規則，如果有，采用，把".DEFAULT"的命令給T使用。

一旦規則被找到，就會(huì )執行其相當的命令，而此時(shí)，我們的自動(dòng)化變量的值才會(huì )生成。

使用make更新函數庫文件
———————————

函數庫文件也就是對Object文件（程序編譯的中間文件）的打包文件。在Unix下，一般是由命令"ar"來(lái)完成打包工作。

一、函數庫文件的成員

一個(gè)函數庫文件由多個(gè)文件組成。你可以以如下格式指定函數庫文件及其組成：

    archive(member)

這個(gè)不是一個(gè)命令，而一個(gè)目標和依賴(lài)的定義。一般來(lái)說(shuō)，這種用法基本上就是為了"ar"命令來(lái)服務(wù)的。如：

    foolib(hack.o) : hack.o
            ar cr foolib hack.o

如果要指定多個(gè)member，那就以空格分開(kāi)，如：

    foolib(hack.o kludge.o)

其等價(jià)于：

    foolib(hack.o) foolib(kludge.o)

你還可以使用Shell的文件通配符來(lái)定義，如：

    foolib(*.o)

二、函數庫成員的隱含規則

當make搜索一個(gè)目標的隱含規則時(shí)，一個(gè)特殊的特性是，如果這個(gè)目標是"a(m)"形式的，其會(huì )把目標變成"(m)"。于是，如果我們的成員是"%. o"的模式定義，并且如果我們使用"make foo.a(bar.o)"的形式調用Makefile時(shí)，隱含規則會(huì )去找"bar.o"的規則，如果沒(méi)有定義bar.o的規則，那么內建隱含規則生效， make會(huì )去找bar.c文件來(lái)生成bar.o，如果找得到的話(huà)，make執行的命令大致如下：

    cc -c bar.c -o bar.o
    ar r foo.a bar.o
    rm -f bar.o

還有一個(gè)變量要注意的是"$%"，這是專(zhuān)屬函數庫文件的自動(dòng)化變量，有關(guān)其說(shuō)明請參見(jiàn)"自動(dòng)化變量"一節。

三、函數庫文件的后綴規則

你可以使用"后綴規則"和"隱含規則"來(lái)生成函數庫打包文件，如：

    .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

四、注意事項

在進(jìn)行函數庫打包文件生成時(shí)，請小心使用make的并行機制（"-j"參數）。如果多個(gè)ar命令在同一時(shí)間運行在同一個(gè)函數庫打包文件上，就很有可以損壞這個(gè)函數庫文件。所以，在make未來(lái)的版本中，應該提供一種機制來(lái)避免并行操作發(fā)生在函數打包文件上。

但就目前而言，你還是應該不要盡量不要使用"-j"參數。

后序
——

終于到寫(xiě)結束語(yǔ)的時(shí)候了，以上基本上就是GNU make的Makefile的所有細節了。其它的產(chǎn)商的make基本上也就是這樣的，無(wú)論什么樣的make，都是以文件的依賴(lài)性為基礎的，其基本是都是遵 循一個(gè)標準的。這篇文檔中80%的技術(shù)細節都適用于任何的make，我猜測"函數"那一章的內容可能不是其它make所支持的，而隱含規則方面，我想不同 的make會(huì )有不同的實(shí)現，我沒(méi)有精力來(lái)查看GNU的make和VC的nmake、BCB的make，或是別的UNIX下的make有些什么樣的差別，一 是時(shí)間精力不夠，二是因為我基本上都是在Unix下使用make，以前在SCO Unix和IBM的AIX，現在在Linux、Solaris、HP-UX、AIX和Alpha下使用，Linux和Solaris下更多一點(diǎn)。不過(guò)，我 可以肯定的是，在Unix下的make，無(wú)論是哪種平臺，幾乎都使用了Richard Stallman開(kāi)發(fā)的make和cc/gcc的編譯器，而且，基本上都是GNU的make（公司里所有的UNIX機器上都被裝上了GNU的東西，所以， 使用GNU的程序也就多了一