Makefile經典教程(掌握這些足夠)

該篇文章為轉載，是對原作者系列文章的總彙加上标注。

支援原創，請移步陳浩大神部落格：

http://blog.csdn.net/haoel/article/details/2886

本篇文章轉載于：makefile經典教程(掌握這些足夠) - ruglcc's blog - 部落格頻道 - csdn.net http://blog.csdn.net/ruglcc/article/details/7814546/

支援原創。

makefile很重要

      什麼是makefile？或許很多winodws的程式員都不知道這個東西，因為那些windows的ide都為你做了這個工作，但我覺得要作一個好的和professional的程式員，makefile還是要懂。這就好像現在有這麼多的html的編輯器，但如果你想成為一個專業人士，你還是要了解html的辨別的含義。特别在unix下的軟體編譯，你就不能不自己寫makefile了，會不會寫makefile，從一個側面說明了一個人是否具備完成大型工程的能力。因為，makefile關系到了整個工程的編譯規則。一個工程中的源檔案不計數，其按類型、功能、子產品分别放在若幹個目錄中，makefile定義了一系列的規則來指定，哪些檔案需要先編譯，哪些檔案需要後編譯，哪些檔案需要重新編譯，甚至于進行更複雜的功能操作，因為makefile就像一個shell腳本一樣，其中也可以執行作業系統的指令。makefile帶來的好處就是——“自動化編譯”，一旦寫好，隻需要一個make指令，整個工程完全自動編譯，極大的提高了軟體開發的效率。make是一個指令工具，是一個解釋makefile中指令的指令工具，一般來說，大多數的ide都有這個指令，比如：delphi的make，visual c++的nmake，linux下gnu的make。可見，makefile都成為了一種在工程方面的編譯方法。

      現在講述如何寫makefile的文章比較少，這是我想寫這篇文章的原因。當然，不同産商的make各不相同，也有不同的文法，但其本質都是在“檔案依賴性”上做文章，這裡，我僅對gnu的make進行講述，我的環境是redhat linux 8.0，make的版本是3.80。必竟，這個make是應用最為廣泛的，也是用得最多的。而且其還是最遵循于ieee 1003.2-1992 标準的（posix.2）。

    在這篇文檔中，将以c/c++的源碼作為我們基礎，是以必然涉及一些關于c/c++的編譯的知識，相關于這方面的内容，還請各位檢視相關的編譯器的文檔。這裡所預設的編譯器是unix下的gcc和cc。

0.1 關于程式的編譯和連結

   在此，我想多說關于程式編譯的一些規範和方法，一般來說，無論是c、c++、還是pas，首先要把源檔案編譯成中間代碼檔案，在windows下也就是 .obj 檔案，unix下是 .o 檔案，即 object file，這個動作叫做編譯（compile）。然後再把大量的object file合成執行檔案，這個動作叫作連結（link）。   

       編譯時，編譯器需要的是文法的正确，函數與變量的聲明的正确。對于後者，通常是你需要告訴編譯器頭檔案的所在位置（頭檔案中應該隻是聲明，而定義應該放在c/c++檔案中），隻要所有的文法正确，編譯器就可以編譯出中間目标檔案。一般來說，每個源檔案都應該對應于一個中間目标檔案（o檔案或是obj檔案）。 

       連結時，主要是連結函數和全局變量，是以，我們可以使用這些中間目标檔案（o檔案或是obj檔案）來連結我們的應用程式。連結器并不管函數所在的源檔案，隻管函數的中間目标檔案（object file），在大多數時候，由于源檔案太多，編譯生成的中間目标檔案太多，而在連結時需要明顯地指出中間目标檔案名，這對于編譯很不友善，是以，我們要給中間目标檔案打個包，在windows下這種包叫“庫檔案”（library file)，也就是 .lib 檔案，在unix下，是archive file，也就是 .a 檔案。

      總結一下，源檔案首先會生成中間目标檔案，再由中間目标檔案生成執行檔案。在編譯時，編譯器隻檢測程式文法，和函數、變量是否被聲明。如果函數未被聲明，編譯器會給出一個警告，但可以生成object file。而在連結程式時，連結器會在所有的object file中找尋函數的實作，如果找不到，那到就會報連結錯誤碼（linker error），在vc下，這種錯誤一般是：link 2001錯誤，意思說是說，連結器未能找到函數的實作。你需要指定函數的objectfile.

       好，言歸正傳，gnu的make有許多的内容，閑言少叙，還是讓我們開始吧。

1 makefile 介紹

      make指令執行時，需要一個 makefile 檔案，以告訴make指令需要怎麼樣的去編譯和連結程式。

      首先，我們用一個示例來說明makefile的書寫規則。以便給大家一個感興認識。這個示例來源于gnu的make使用手冊，在這個示例中，我們的工程有8個c檔案，和3個頭檔案，我們要寫一個makefile來告訴make指令如何編譯和連結這幾個檔案。我們的規則是：

            1.如果這個工程沒有編譯過，那麼我們的所有c檔案都要編譯并被連結。

            2.如果這個工程的某幾個c檔案被修改，那麼我們隻編譯被修改的c檔案，并連結目标程式。

            3.如果這個工程的頭檔案被改變了，那麼我們需要編譯引用了這幾個頭檔案的c檔案，并連結目标程式。

      隻要我們的makefile寫得夠好，所有的這一切，我們隻用一個make指令就可以完成，make指令會自動智能地根據目前的檔案修改的情況來确定哪些檔案需要重編譯，進而自己編譯所需要的檔案和連結目标程式。

   在講述這個makefile之前，還是讓我們先來粗略地看一看makefile的規則。

          target... : prerequisites ...

          command

          ...

         -------------------------------------------------------------------------------

       target也就是一個目标檔案，可以是object file，也可以是執行檔案。還可以是一個标簽（label），對于标簽這種特性，在後續的“僞目标”章節中會有叙述。

       prerequisites就是，要生成那個target所需要的檔案或是目标。

       command也就是make需要執行的指令。（任意的shell指令）

       這是一個檔案的依賴關系，也就是說，target這一個或多個的目标檔案依賴于prerequisites中的檔案，其生成規則定義在command中。說白一點就是說，prerequisites中如果有一個以上的檔案比target檔案要新的話，command所定義的指令就會被執行。這就是makefile的規則。也就是makefile中最核心的内容。

       說到底，makefile的東西就是這樣一點，好像我的這篇文檔也該結束了。呵呵。還不盡然，這是makefile的主線和核心，但要寫好一個makefile還不夠，我會以後面一點一點地結合我的工作經驗給你慢慢到來。内容還多着呢。：）

正如前面所說的，如果一個工程有3個頭檔案，和8個c檔案，我們為了完成前面所述的那三個規則，我們的makefile應該是下面的這個樣子的。

   edit : main.o kbd.o command.o display.o \

          insert.o search.o files.o utils.o

           cc -o edit main.o kbd.o command.o display.o \

                      insert.o search.o files.o utils.o

   main.o : main.c defs.h

           cc -c main.c

   kbd.o : kbd.c defs.h command.h

           cc -c kbd.c

   command.o : command.c defs.h command.h

           cc -c command.c

   display.o : display.c defs.h buffer.h

           cc -c display.c

   insert.o : insert.c defs.h buffer.h

           cc -c insert.c

   search.o : search.c defs.h buffer.h

           cc -c search.c

   files.o : files.c defs.h buffer.h command.h

           cc -c files.c

   utils.o : utils.c defs.h

           cc -c utils.c

   clean :

           rm edit main.o kbd.o command.o display.o \

              insert.o search.o files.o utils.o

        反斜杠（\）是換行符的意思。這樣比較便于makefile的易讀。我們可以把這個内容儲存在檔案為“makefile”或“makefile”的檔案中，然後在該目錄下直接輸入指令“make”就可以生成執行檔案edit。如果要删除執行檔案和所有的中間目标檔案，那麼，隻要簡單地執行一下“make clean”就可以了。

        在這個makefile中，目标檔案（target）包含：執行檔案edit和中間目标檔案（*.o），依賴檔案（prerequisites）就是冒号後面的那些 .c 檔案和 .h檔案。每一個 .o 檔案都有一組依賴檔案，而這些 .o 檔案又是執行檔案 edit 的依賴檔案。依賴關系的實質上就是說明了目标檔案是由哪些檔案生成的，換言之，目标檔案是哪些檔案更新的。

        在定義好依賴關系後，後續的那一行定義了如何生成目标檔案的作業系統指令，一定要以一個tab鍵作為開頭。記住，make并不管指令是怎麼工作的，他隻管執行所定義的指令。make會比較targets檔案和prerequisites檔案的修改日期，如果prerequisites檔案的日期要比targets檔案的日期要新，或者target不存在的話，那麼，make就會執行後續定義的指令。

        這裡要說明一點的是，clean不是一個檔案，它隻不過是一個動作名字，有點像c語言中的lable一樣，其冒号後什麼也沒有，那麼，make就不會自動去找檔案的依賴性，也就不會自動執行其後所定義的指令。要執行其後的指令，就要在make指令後明顯得指出這個lable的名字。這樣的方法非常有用，我們可以在一個makefile中定義不用的編譯或是和編譯無關的指令，比如程式的打包，程式的備份，等等。

在預設的方式下，也就是我們隻輸入make指令。那麼，

  make會在目前目錄下找名字叫“makefile”或“makefile”的檔案。

  如果找到，它會找檔案中的第一個目标檔案（target），在上面的例子中，他會找到“edit”這個檔案，并把這個檔案作為最終的目标檔案。

  如果edit檔案不存在，或是edit所依賴的後面的 .o 檔案的檔案修改時間要比edit這個檔案新，那麼，他就會執行後面所定義的指令來生成edit這個檔案。

  如果edit所依賴的.o檔案也存在，那麼make會在目前檔案中找目标為.o檔案的依賴性，如果找到則再根據那一個規則生成.o檔案。（這有點像一個堆棧的過程）

  當然，你的c檔案和h檔案是存在的啦，于是make會生成 .o 檔案，然後再用 .o 檔案聲明make的終極任務，也就是執行檔案edit了。

        通過上述分析，我們知道，像clean這種，沒有被第一個目标檔案直接或間接關聯，那麼它後面所定義的指令将不會被自動執行，不過，我們可以顯示要make執行。即指令——“make clean”，以此來清除所有的目标檔案，以便重編譯。

      于是在我們程式設計中，如果這個工程已被編譯過了，當我們修改了其中一個源檔案，比如file.c，那麼根據我們的依賴性，我們的目标file.o會被重編譯（也就是在這個依性關系後面所定義的指令），于是file.o的檔案也是最新的啦，于是file.o的檔案修改時間要比edit要新，是以edit也會被重新連結了（詳見edit目标檔案後定義的指令）。

而如果我們改變了“command.h”，那麼，kdb.o、command.o和files.o都會被重編譯，并且，edit會被重連結。

在上面的例子中，先讓我們看看edit的規則：

     edit : main.o kbd.o command.o display.o \

                 insert.o search.o files.o utils.o

    我們可以看到[.o]檔案的字元串被重複了兩次，如果我們的工程需要加入一個新的[.o]檔案，那麼我們需要在兩個地方加（應該是三個地方，還有一個地方在clean中）。當然，我們的makefile并不複雜，是以在兩個地方加也不累，但如果makefile變得複雜，那麼我們就有可能會忘掉一個需要加入的地方，而導緻編譯失敗。是以，為了makefile的易維護，在makefile中我們可以使用變量。makefile的變量也就是一個字元串，了解成c語言中的宏可能會更好。

比如，我們聲明一個變量，叫objects, objects, objs, objs, obj, 或是 obj，反正不管什麼啦，隻要能夠表示obj檔案就行了。我們在makefile一開始就這樣定義：

    objects = main.o kbd.o command.o display.o \

             insert.o search.o files.o utils.o

于是，我們就可以很友善地在我們的makefile中以“$(objects)”的方式來使用這個變量了，于是我們的改良版makefile就變成下面這個樣子：

于是如果有新的 .o 檔案加入，我們隻需簡單地修改一下 objects 變量就可以了。

關于變量更多的話題，我會在後續給你一一道來。

gnu的make很強大，它可以自動推導檔案以及檔案依賴關系後面的指令，于是我們就沒必要去在每一個[.o]檔案後都寫上類似的指令，因為，我們的make會自動識别，并自己推導指令。

    隻要make看到一個[.o]檔案，它就會自動的把[.c]檔案加在依賴關系中，如果make找到一個whatever.o，那麼whatever.c，就會是whatever.o的依賴檔案。并且 cc -c whatever.c 也會被推導出來，于是，我們的makefile再也不用寫得這麼複雜。我們的是新的makefile又出爐了。

這種方法，也就是make的“隐晦規則”。上面檔案内容中，“.phony”表示，clean是個僞目标檔案。

關于更為詳細的“隐晦規則”和“僞目标檔案”，我會在後續給你一一道來。

    即然我們的make可以自動推導指令，那麼我看到那堆[.o]和[.h]的依賴就有點不爽，那麼多的重複的[.h]，能不能把其收攏起來，好吧，沒有問題，這個對于make來說很容易，誰叫它提供了自動推導指令和檔案的功能呢？來看看最新風格的makefile吧。

這種風格，讓我們的makefile變得很簡單，但我們的檔案依賴關系就顯得有點淩亂了。魚和熊掌不可兼得。還看你的喜好了。我是不喜歡這種風格的，一是檔案的依賴關系看不清楚，二是如果檔案一多，要加入幾個新的.o檔案，那就理不清楚了。

      每個makefile中都應該寫一個清空目标檔案（.o和執行檔案）的規則，這不僅便于重編譯，也很利于保持檔案的清潔。這是一個“修養”（呵呵，還記得我的《程式設計修養》嗎）。一般的風格都是：

       clean:

           rm edit $(objects)

更為穩健的做法是：

       .phony : clean

       clean :

               -rm edit $(objects)

前面說過，.phony意思表示clean是一個“僞目标”，。而在rm指令前面加了一個小減号的意思就是，也許某些檔案出現問題，但不要管，繼續做後面的事。當然，clean的規則不要放在檔案的開頭，不然，這就會變成make的預設目标，相信誰也不願意這樣。不成文的規矩是——“clean從來都是放在檔案的最後”。

上面就是一個makefile的概貌，也是makefile的基礎，下面還有很多makefile的相關細節，準備好了嗎？準備好了就來。

2 makefile 總述

makefile裡主要包含了五個東西：顯式規則、隐晦規則、變量定義、檔案訓示和注釋。

顯式規則。顯式規則說明了，如何生成一個或多的的目标檔案。這是由makefile的書寫者明顯指出，要生成的檔案，檔案的依賴檔案，生成的指令。 隐晦規則。由于我們的make有自動推導的功能，是以隐晦的規則可以讓我們比較粗糙地簡略地書寫makefile，這是由make所支援的。 變量的定義。在makefile中我們要定義一系列的變量，變量一般都是字元串，這個有點你c語言中的宏，當makefile被執行時，其中的變量都會被擴充到相應的引用位置上。 檔案訓示。其包括了三個部分，一個是在一個makefile中引用另一個makefile，就像c語言中的include一樣；另一個是指根據某些情況指定makefile中的有效部分，就像c語言中的預編譯#if一樣；還有就是定義一個多行的指令。有關這一部分的内容，我會在後續的部分中講述。  注釋。makefile中隻有行注釋，和unix的shell腳本一樣，其注釋是用“#”字元，這個就像c/c++中的“//”一樣。如果你要在你的makefile中使用“#”字元，可以用反斜框進行轉義，如：“\#”。

最後，還值得一提的是，在makefile中的指令，必須要以[tab]鍵開始。

        預設的情況下，make指令會在目前目錄下按順序找尋檔案名為“gnumakefile”、“makefile”、“makefile”的檔案，找到了解釋這個檔案。在這三個檔案名中，最好使用“makefile”這個檔案名，因為，這個檔案名第一個字元為大寫，這樣有一種顯目的感覺。最好不要用“gnumakefile”，這個檔案是gnu的make識别的。有另外一些make隻對全小寫的“makefile”檔案名敏感，但是基本上來說，大多數的make都支援“makefile”和“makefile”這兩種預設檔案名。

     當然，你可以使用别的檔案名來書寫makefile，比如：“make.linux”，“make.solaris”，“make.aix”等，如果要指定特定的makefile，你可以使用make的“-f”和“--file”參數，如：make -f make.linux或make --file make.aix。

    在makefile使用include關鍵字可以把别的makefile包含進來，這很像c語言的#include，被包含的檔案會原模原樣的放在目前檔案的包含位置。include的文法是：

在include前面可以有一些空字元，但是絕不能是[tab]鍵開始。include和可以用一個或多個空格隔開。舉個例子，你有這樣幾個makefile：a.mk、b.mk、c.mk，還有一個檔案叫foo.make，以及一個變量$(bar)，其包含了e.mk和f.mk，那麼，下面的語句：

   include foo.make *.mk $(bar)

等價于：

   include foo.make a.mk b.mk c.mk e.mk f.mk

make指令開始時，會把找尋include所指出的其它makefile，并把其内容安置在目前的位置。就好像c/c++的#include指令一樣。如果檔案都沒有指定絕對路徑或是相對路徑的話，make會在目前目錄下首先尋找，如果目前目錄下沒有找到，那麼，make還會在下面的幾個目錄下找：

      如果有檔案沒有找到的話，make會生成一條警告資訊，但不會馬上出現緻命錯誤。它會繼續載入其它的檔案，一旦完成makefile的讀取，make會再重試這些沒有找到，或是不能讀取的檔案，如果還是不行，make才會出現一條緻命資訊。如果你想讓make不理那些無法讀取的檔案，而繼續執行，你可以在include前加一個減号“-”。如：

-include<filename>

其表示，無論include過程中出現什麼錯誤，都不要報錯繼續執行。和其它版本make相容的相關指令是sinclude，其作用和這一個是一樣的。

如果你的目前環境中定義了環境變量makefiles，那麼，make會把這個變量中的值做一個類似于include的動作。這個變量中的值是其它的makefile，用空格分隔。隻是，它和include不同的是，從這個環境變中引入的makefile的“目标”不會起作用，如果環境變量中定義的檔案發現錯誤，make也會不理。

但是在這裡我還是建議不要使用這個環境變量，因為隻要這個變量一被定義，那麼當你使用make時，所有的makefile都會受到它的影響，這絕不是你想看到的。在這裡提這個事，隻是為了告訴大家，也許有時候你的makefile出現了怪事，那麼你可以看看目前環境中有沒有定義這個變量。

gnu的make工作時的執行步驟入下：（想來其它的make也是類似）

1.        讀入所有的makefile。 2.        讀入被include的其它makefile。 3.        初始化檔案中的變量。 4.        推導隐晦規則，并分析所有規則。 5.        為所有的目标檔案建立依賴關系鍊。 6.        根據依賴關系，決定哪些目标要重新生成。 7.        執行生成指令。

1-5步為第一個階段，6-7為第二個階段。第一個階段中，如果定義的變量被使用了，那麼，make會把其展開在使用的位置。但make并不會完全馬上展開，make使用的是拖延戰術，如果變量出現在依賴關系的規則中，那麼僅當這條依賴被決定要使用了，變量才會在其内部展開。

當然，這個工作方式你不一定要清楚，但是知道這個方式你也會對make更為熟悉。有了這個基礎，後續部分也就容易看懂了。

3 makefile書寫規則

 規則包含兩個部分，一個是依賴關系，一個是生成目标的方法。

在makefile中，規則的順序是很重要的，因為，makefile中隻應該有一個最終目标，其它的目标都是被這個目标所連帶出來的，是以一定要讓make知道你的最終目标是什麼。一般來說，定義在makefile中的目标可能會有很多，但是第一條規則中的目标将被确立為最終的目标。如果第一條規則中的目标有很多個，那麼，第一個目标會成為最終的目标。make所完成的也就是這個目标。

好了，還是讓我們來看一看如何書寫規則。

 foo.o: foo.c defs.h       # foo子產品

           cc -c -g foo.c

看到這個例子，各位應該不是很陌生了，前面也已說過，foo.o是我們的目标，foo.c和defs.h是目标所依賴的源檔案，而隻有一個指令“cc -c -g foo.c”（以tab鍵開頭）。這個規則告訴我們兩件事：

1.        檔案的依賴關系，foo.o依賴于foo.c和defs.h的檔案，如果foo.c和defs.h的檔案日期要比foo.o檔案日期要新，或是foo.o不存在，那麼依賴關系發生。 2.        如果生成（或更新）foo.o檔案。也就是那個cc指令，其說明了，如何生成foo.o這個檔案。（當然foo.c檔案include了defs.h檔案）

     targets : prerequisites

       command

       ...

或是這樣：

     targets : prerequisites ; command

           command

           ...

targets是檔案名，以空格分開，可以使用通配符。一般來說，我們的目标基本上是一個檔案，但也有可能是多個檔案。

command是指令行，如果其不與“target:prerequisites”在一行，那麼，必須以[tab鍵]開頭，如果和prerequisites在一行，那麼可以用分号做為分隔。（見上）

prerequisites也就是目标所依賴的檔案（或依賴目标）。如果其中的某個檔案要比目标檔案要新，那麼，目标就被認為是“過時的”，被認為是需要重生成的。這個在前面已經講過了。

如果指令太長，你可以使用反斜框（‘\’）作為換行符。make對一行上有多少個字元沒有限制。規則告訴make兩件事，檔案的依賴關系和如何成成目标檔案。

一般來說，make會以unix的标準shell，也就是/bin/sh來執行指令。

     如果我們想定義一系列比較類似的檔案，我們很自然地就想起使用通配符。make支援三各通配符：“*”，“?”和“[...]”。這是和unix的b-shell是相同的。

"~"

波浪号（“~”）字元在檔案名中也有比較特殊的用途。如果是“~/test”，這就表示目前使用者的$home目錄下的test目錄。而“~hchen/test”則表示使用者hchen的宿主目錄下的test目錄。（這些都是unix下的小知識了，make也支援）而在windows或是ms-dos下，使用者沒有宿主目錄，那麼波浪号所指的目錄則根據環境變量“home”而定。

"*"

通配符代替了你一系列的檔案，如“*.c”表示是以字尾為c的檔案。一個需要我們注意的是，如果我們的檔案名中有通配符，如：“*”，那麼可以用轉義字元“\”，如“\*”來表示真實的“*”字元，而不是任意長度的字元串。

好吧，還是先來看幾個例子吧：

   clean:

        rm -f *.o

上面這個例子我不不多說了，這是作業系統shell所支援的通配符。這是在指令中的通配符。

   print: *.c

        lpr -p $?

        touch print

上面這個例子說明了通配符也可以在我們的規則中，目标print依賴于所有的[.c]檔案。其中的“$?”是一個自動化變量，我會在後面給你講述。

   objects = *.o

上面這個例子，表示了，通符同樣可以用在變量中。并不是說[*.o]會展開，不！objects的值就是“*.o”。makefile中的變量其實就是c/c++中的宏。如果你要讓通配符在變量中展開，也就是讓objects的值是所有[.o]的檔案名的集合，那麼，你可以這樣：

   objects := $(wildcard *.o)

這種用法由關鍵字“wildcard”指出，關于makefile的關鍵字，我們将在後面讨論。

     在一些大的工程中，有大量的源檔案，我們通常的做法是把這許多的源檔案分類，并存放在不同的目錄中。是以，當make需要去找尋檔案的依賴關系時，你可以在檔案前加上路徑，但最好的方法是把一個路徑告訴make，讓make在自動去找。

makefile檔案中的特殊變量“vpath”就是完成這個功能的，如果沒有指明這個變量，make隻會在目前的目錄中去找尋依賴檔案和目标檔案。如果定義了這個變量，那麼，make就會在當目前目錄找不到的情況下，到所指定的目錄中去找尋檔案了。

   vpath = src:../headers

上面的的定義指定兩個目錄，“src”和“../headers”，make會按照這個順序進行搜尋。目錄由“冒号”分隔。（當然，目前目錄永遠是最高優先搜尋的地方）

另一個設定檔案搜尋路徑的方法是使用make的“vpath”關鍵字（注意，它是全小寫的），這不是變量，這是一個make的關鍵字，這和上面提到的那個vpath變量很類似，但是它更為靈活。它可以指定不同的檔案在不同的搜尋目錄中。這是一個很靈活的功能。它的使用方法有三種：

1.        vpath < pattern> < directories>    為符合模式< pattern>的檔案指定搜尋目錄<directories>。 2.        vpath < pattern>                              清除符合模式< pattern>的檔案的搜尋目錄。 3.        vpath                                                 清除所有已被設定好了的檔案搜尋目錄。

vapth使用方法中的< pattern>需要包含“%”字元。“%”的意思是比對零或若幹字元，例如，“%.h”表示所有以“.h”結尾的檔案。< pattern>指定了要搜尋的檔案集，而< directories>則指定了的檔案集的搜尋的目錄。例如：

   vpath %.h ../headers

該語句表示，要求make在“../headers”目錄下搜尋所有以“.h”結尾的檔案。（如果某檔案在目前目錄沒有找到的話）

我們可以連續地使用vpath語句，以指定不同搜尋政策。如果連續的vpath語句中出現了相同的< pattern>，或是被重複了的< pattern>，那麼，make會按照vpath語句的先後順序來執行搜尋。如：

   vpath %.c foo

   vpath %   blish

   vpath %.c bar

其表示“.c”結尾的檔案，先在“foo”目錄，然後是“blish”，最後是“bar”目錄。

   vpath %.c foo:bar

而上面的語句則表示“.c”結尾的檔案，先在“foo”目錄，然後是“bar”目錄，最後才是“blish”目錄。

最早先的一個例子中，我們提到過一個“clean”的目标，這是一個“僞目标”，

           rm *.o temp

正像我們前面例子中的“clean”一樣，即然我們生成了許多檔案編譯檔案，我們也應該提供一個清除它們的“目标”以備完整地重編譯而用。 （以“make clean”來使用該目标）

因為，我們并不生成“clean”這個檔案。“僞目标”并不是一個檔案，隻是一個标簽，由于“僞目标”不是檔案，是以make無法生成它的依賴關系和決定它是否要執行。我們隻有通過顯示地指明這個“目标”才能讓其生效。當然，“僞目标”的取名不能和檔案名重名，不然其就失去了“僞目标”的意義了。

當然，為了避免和檔案重名的這種情況，我們可以使用一個特殊的标記“.phony”來顯示地指明一個目标是“僞目标”，向make說明，不管是否有這個檔案，這個目标就是“僞目标”。

   .phony : clean

隻要有這個聲明，不管是否有“clean”檔案，要運作“clean”這個目标，隻有“make clean”這樣。于是整個過程可以這樣寫：

    .phony: clean

僞目标一般沒有依賴的檔案。但是，我們也可以為僞目标指定所依賴的檔案。僞目标同樣可以作為“預設目标”，隻要将其放在第一個。一個示例就是，如果你的makefile需要一口氣生成若幹個可執行檔案，但你隻想簡單地敲一個make完事，并且，所有的目标檔案都寫在一個makefile中，那麼你可以使用“僞目标”這個特性：

   all : prog1 prog2 prog3

   .phony : all

   prog1 : prog1.o utils.o

           cc -o prog1 prog1.o utils.o

   prog2 : prog2.o

           cc -o prog2 prog2.o

   prog3 : prog3.o sort.o utils.o

           cc -o prog3 prog3.o sort.o utils.o

我們知道，makefile中的第一個目标會被作為其預設目标。我們聲明了一個“all”的僞目标，其依賴于其它三個目标。由于僞目标的特性是，總是被執行的，是以其依賴的那三個目标就總是不如“all”這個目标新。是以，其它三個目标的規則總是會被決議。也就達到了我們一口氣生成多個目标的目的。“.phony : all”聲明了“all”這個目标為“僞目标”。

随便提一句，從上面的例子我們可以看出，目标也可以成為依賴。是以，僞目标同樣也可成為依賴。看下面的例子：

   .phony: cleanall cleanobj cleandiff

   cleanall : cleanobj cleandiff

           rm program

   cleanobj :

           rm *.o

   cleandiff :

           rm *.diff

“makeclean”将清除所有要被清除的檔案。“cleanobj”和“cleandiff”這兩個僞目标有點像“子程式”的意思。我們可以輸入“makecleanall”和“make cleanobj”和“makecleandiff”指令來達到清除不同種類檔案的目的

makefile的規則中的目标可以不止一個，其支援多目标，有可能我們的多個目标同時依賴于一個檔案，并且其生成的指令大體類似。于是我們就能把其合并起來。當然，多個目标的生成規則的執行指令是同一個，這可能會可我們帶來麻煩，不過好在我們的可以使用一個自動化變量“$@”（關于自動化變量，将在後面講述），這個變量表示着目前規則中所有的目标的集合，這樣說可能很抽象，還是看一個例子吧。

   bigoutput littleoutput : text.g

           generate text.g -$(subst output,,$@) > $@

   上述規則等價于：

   bigoutput : text.g

           generate text.g -big > bigoutput

   littleoutput : text.g

           generate text.g -little > littleoutput

其中，-$(subst output,,$@)中的“$”表示執行一個makefile的函數，函數名為subst，後面的為參數。關于函數，将在後面講述。這裡的這個函數是截取字元串的意思，“$@”表示目标的集合，就像一個數組，“$@”依次取出目标，并執于指令。

靜态模式可以更加容易地定義多目标的規則，可以讓我們的規則變得更加的有彈性和靈活。我們還是先來看一下文法：

<targets...>: <target-pattern>: <prereq-patterns ...>

　　　<commands>

...

targets定義了一系列的目标檔案，可以有通配符。是目标的一個集合。

target-parrtern是指明了targets的模式，也就是的目标集模式。

prereq-parrterns是目标的依賴模式，它對target-parrtern形成的模式再進行一次依賴目标的定義。

這樣描述這三個東西，可能還是沒有說清楚，還是舉個例子來說明一下吧。如果我們的<target-parrtern>定義成“%.o”，意思是我們的集合中都是以“.o”結尾的，而如果我們的<prereq-parrterns>定義成“%.c”，意思是對<target-parrtern>所形成的目标集進行二次定義，其計算方法是，取<target-parrtern>模式中的“%”（也就是去掉了[.o]這個結尾），并為其加上[.c]這個結尾，形成的新集合。

是以，我們的“目标模式”或是“依賴模式”中都應該有“%”這個字元，如果你的檔案名中有“%”那麼你可以使用反斜杠“\”進行轉義，來标明真實的“%”字元。

看一個例子：

   objects = foo.o bar.o

   all: $(objects)

   $(objects): %.o: %.c

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

上面的例子中，指明了我們的目标從$object中擷取，“%.o”表明要所有以“.o”結尾的目标，也就是“foo.o bar.o”，也就是變量$object集合的模式，而依賴模式“%.c”則取模式“%.o”的“%”，也就是“foobar”，并為其加下“.c”的字尾，于是，我們的依賴目标就是“foo.cbar.c”。而指令中的“$<”和“$@”則是自動化變量，“$<”表示所有的依賴目标集（也就是“foo.c bar.c”），“$@”表示目标集（也褪恰癴oo.o bar.o”）。于是，上面的規則展開後等價于下面的規則：

   foo.o : foo.c

           $(cc) -c $(cflags) foo.c -o foo.o

   bar.o : bar.c

           $(cc) -c $(cflags) bar.c -o bar.o

試想，如果我們的“%.o”有幾百個，那種我們隻要用這種很簡單的“靜态模式規則”就可以寫完一堆規則，實在是太有效率了。“靜态模式規則”的用法很靈活，如果用得好，那會一個很強大的功能。再看一個例子：

   files = foo.elc bar.o lose.o

   $(filter %.o,$(files)): %.o: %.c

   $(filter %.elc,$(files)): %.elc: %.el

           emacs -f batch-byte-compile $<

$(filter%.o,$(files))表示調用makefile的filter函數，過濾“$filter”集，隻要其中模式為“%.o”的内容。其的它内容，我就不用多說了吧。這個例字展示了makefile中更大的彈性。

在makefile中，我們的依賴關系可能會需要包含一系列的頭檔案，比如，如果我們的main.c中有一句“#include "defs.h"”，那麼我們的依賴關系應該是：

但是，如果是一個比較大型的工程，你必需清楚哪些c檔案包含了哪些頭檔案，并且，你在加入或删除頭檔案時，也需要小心地修改makefile，這是一個很沒有維護性的工作。為了避免這種繁重而又容易出錯的事情，我們可以使用c/c++編譯的一個功能。大多數的c/c++編譯器都支援一個“-m”的選項，即自動找尋源檔案中包含的頭檔案，并生成一個依賴關系。例如，如果我們執行下面的指令：

   cc -m main.c

其輸出是：

于是由編譯器自動生成的依賴關系，這樣一來，你就不必再手動書寫若幹檔案的依賴關系，而由編譯器自動生成了。需要提醒一句的是，如果你使用gnu的c/c++編譯器，你得用“-mm”參數，不然，“-m”參數會把一些标準庫的頭檔案也包含進來。

gcc-m main.c的輸出是：

   main.o: main.c defs.h /usr/include/stdio.h /usr/include/features.h \

        /usr/include/sys/cdefs.h /usr/include/gnu/stubs.h \

        /usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stddef.h \

        /usr/include/bits/types.h /usr/include/bits/pthreadtypes.h \

        /usr/include/bits/sched.h /usr/include/libio.h \

        /usr/include/_g_config.h /usr/include/wchar.h \

        /usr/include/bits/wchar.h /usr/include/gconv.h \

        /usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stdarg.h \

        /usr/include/bits/stdio_lim.h

gcc-mm main.c的輸出則是：

   main.o: main.c defs.h

那麼，編譯器的這個功能如何與我們的makefile聯系在一起呢。因為這樣一來，我們的makefile也要根據這些源檔案重新生成，讓makefile自已依賴于源檔案？這個功能并不現實，不過我們可以有其它手段來迂回地實作這一功能。gnu組織建議把編譯器為每一個源檔案的自動生成的依賴關系放到一個檔案中，為每一個“name.c”的檔案都生成一個“name.d”的makefile檔案，[.d]檔案中就存放對應[.c]檔案的依賴關系。

于是，我們可以寫出[.c]檔案和[.d]檔案的依賴關系，并讓make自動更新或自成[.d]檔案，并把其包含在我們的主makefile中，這樣，我們就可以自動化地生成每個檔案的依賴關系了。

這裡，我們給出了一個模式規則來産生[.d]檔案：

   %.d: %.c

           @set -e; rm -f $@; \

            $(cc) -m $(cppflags) $< > $@.

; \

            sed 's,$\.o[ :]*,\1.o $@ : ,g' < $@.

> $@; \

            rm -f $@.