使用變量
————

在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”。