跟我一塊兒寫Makefile:MakeFile介紹

make命令運行時。需要一個 makefile 文件，以告訴make命令怎樣去編譯和連接程序。

首先。咱們用一個演示樣例來講明makefile的書寫規則。

以便給你們一個感性認識。這個演示樣例來源於gnu的make使用手冊，在這個演示樣例中。咱們的project有8個c文件，和3個頭文件，咱們要寫一個makefile來告訴make命令怎樣編譯和連接這幾個文件。咱們的規則是：
1）假設這個project沒有編譯過。那麼咱們的所有c文件都要編譯並被連接。

2）假設這個project的某幾個c文件被改動，那麼咱們僅僅編譯被改動的c文件，並連接目標程序。

3）假設這個project的頭文件被改變了，那麼咱們需要編譯引用了這幾個頭文件的c文件，並連接目標程序。
僅僅要咱們的makefile寫得夠好，所有的這一切，咱們僅僅用一個make命令就可以完畢。make命令會本身主動智能地依據當前的文件改動的狀況來肯定哪些文件需要重編譯。從而本身編譯所需要的文件和連接目標程序。


makefile的規則
在講述這個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還不夠，我會之後面一點一點地結合個人工做經驗給你慢慢道來。內容還多着呢。：）

一個演示樣例
正如前面所說的。假設一個project有3個頭文件，和8個c文件。咱們爲了完畢前面所述的那三個規則，咱們的makefile應該是如下這個樣子的。

edit : main.o kbd.o command.o display.o \
                insert.o search.o files.o utils.o       /*凝視:假設後面這些.o文件比edit可運行文件新,那麼纔會去運行如下這句命令*/
        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就不會本身主動去找它的依賴性。也就不會本身主動運行其後所定義的命令。

要運行其後的命令（不只用於clean。其它lable相同適用），就要在make命令後明顯得指出這個lable的名字。這個方案很實用，咱們可以在一個makefile中定義不用的編譯或是和編譯無關的命令。比方程序的打包，程序的備份。等等。

make是怎樣工做的
在默認的方式下，也就是咱們僅僅輸入make命令。那麼，
1. make會在當前文件夾下找名字叫「Makefile」或「makefile」的文件。

2. 假設找到，它會找文件裏的第一個目標文件（target），在上面的樣例中，他會找到「edit」這個文件，並把這個文件做爲終於的目標文件。

3. 假設edit文件不存在。或是edit所依賴的後面的 .o 文件的文件改動時間要比edit這個文件新，那麼，他就會運行後面所定義的命令來生成edit這個文件。

4. 假設edit所依賴的.o文件也不存在。那麼make會在當前文件裏找目標爲.o文件的依賴性。假設找到則再依據那一個規則生成.o文件。

（這有點像一個堆棧的過程）

5. 固然，你的C文件和H文件是存在的啦，因而make會生成 .o 文件，而後再用 .o 文件生成make的終極任務。也就是運行文件edit了。

這就是整個make的依賴性。make會一層又一層地去找文件的依賴關係，直到終於編譯出第一個目標文件。

在找尋的過程當中，假設出現錯誤，比方最後被依賴的文件找不到。那麼make就會直接退出。並報錯，而對於所定義的命令的錯誤。或是編譯不成功，make根本不理。

make僅僅管文件的依賴性。即，假設在我找了依賴關係以後，冒號後面的文件仍是不在，那麼對不起，我就不工做啦。

經過上述分析。咱們知道。像clean這樣的。沒有被第一個目標文件直接或間接關聯，那麼它後面所定義的命令將不會被本身主動運行，只是。咱們可以顯式要make運行。即命令——「make clean」，以此來清除所有的目標文件，以便重編譯。
因而在咱們編程中，假設這個project已被編譯過了，當咱們改動了當中一個源文件，比方file.c。那麼依據咱們的依賴性，咱們的目標file.o會被重編譯（也就是在這個依性關係後面所定義的命令），因而file.o的文件也是最新的啦。因而file.o的文件改動時間要比edit要新。因此 edit也會被又一次連接了（詳見edit目標文件後定義的命令）。

而假設咱們改變了「command.h」，那麼，kdb.o、command.o和files.o都會被重編譯，並且，edit會被重連接。

makefile中使用變量

在上面的樣例中，先讓咱們看看edit的規則：

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

咱們可以看到[.o]文件的字符串被反覆了兩次，假設咱們的project需要增長一個新的[.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變爲例如如下：

objects = main.o kbd.o command.o display.o \
                insert.o search.o files.o utils.o


edit : $(objects)
        cc -o edit $(objects)
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 $(objects)

假設有新的 .o 文件增長，咱們僅僅需簡單地改動變量objects就能夠。
不少其它關於變量的話題。我會在興許具體介紹。

讓make本身主動推導

GNU的make很是強大，它可以本身主動推導文件以及文件依賴關係後面的命令。因而咱們就不是必需去在每一個[.o]文件後都寫上相似的命令。因爲，咱們的make會本身主動識別，並本身推導命令。
僅僅要make看到一個[.o]文件，它就會本身主動的把[.c]文件加在依賴關係中。假設make找到一個whatever.o，那麼 whatever.c，就會是whatever.o的依賴文件。

並且 cc -c whatever.c 也會被推導出來。因而，咱們的makefile 不再用寫得這麼複雜。咱們的新makefile又出爐了。

objects = main.o kbd.o command.o display.o \
                insert.o search.o files.o utils.o
 cc = gcc


edit : $(objects)
        cc -o edit $(objects)


main.o : defs.h
kbd.o : defs.h command.h
command.o : defs.h command.h
display.o : defs.h buffer.h
insert.o : defs.h buffer.h
search.o : defs.h buffer.h
files.o : defs.h buffer.h command.h
utils.o : defs.h


.PHONY : clean
clean :
        rm edit $(objects)

這樣的方法，也就是make的「隱晦規則」。上面文件內容中，「.PHONY」表示。clean是個僞目標文件。
關於更爲具體的「隱晦規則」和「僞目標文件」，我會在興許給你一一道來。

另類風格的makefile

既然咱們的make可以本身主動推導命令，那麼我看到那堆[.o]和[.h]的依賴就有點不爽，那麼多的反覆的[.h]。能不能把其收攏起來。好吧，沒有問題，這個對於make來講很是easy，誰叫它提供了本身主動推導命令和文件的功能呢？來看看最新風格的makefile吧。

objects = main.o kbd.o command.o display.o \
                insert.o search.o files.o utils.o


edit : $(objects)
        cc -o edit $(objects)


$(objects) : defs.h
kbd.o command.o files.o : command.h
display.o insert.o search.o files.o : buffer.h


.PHONY : clean
clean :
        rm edit $(objects)

這樣的風格，讓咱們的makefile變得很是easy。但咱們的文件依賴關係就顯得有點凌亂了。

魚和熊掌不可兼得。

還看你的喜愛了。我是不喜歡這樣的風格的，一是文件的依賴關係看不清楚，二是假設文件一多，要增長几個新的.o文件，那就理不清楚了。

清空目標文件的規則

每個Makefile中都應該寫一個清空目標文件（.o和運行文件）的規則，這不只便於重編譯，也很是利於保持文件的清潔。這是一個「修養」（呵呵，還記得個人《編程修養》嗎）。通常的風格都是：

clean:
        rm edit $(objects)
#更爲穩健的作法是：
.PHONY : clean
clean :
        -rm edit $(objects)

前面說過，.PHONY意思表示clean是一個「僞目標」，。

而在rm命令前面加了一個小減號的意思就是，或許某些文件出現故障，但不要管，繼續作後面的事。固然，clean的規則不要放在文件的開頭。否則，這就會變成make的默認目標，相信誰也不肯意這樣。

不成文的規矩是——「clean歷來都是放在文件的最後」。

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

Makefile裏有什麼？

Makefile裏主要包括了五個東西：顯式規則、隱晦規則、變量定義、文件指示和凝視。

1. 顯式規則。

顯式規則說明了。怎樣生成一個或多個目標文件。這是由Makefile的書寫者明顯指出，要生成的文件。文件的依賴文件。生成的命令。
2. 隱晦規則。由於咱們的make有本身主動推導的功能，因此隱晦的規則可以讓咱們比較簡略地書寫Makefile，這是由make所支持的。
3. 變量的定義。在Makefile中咱們要定義一系列的變量。變量通常都是字符串。這個有點像你C語言中的宏，當Makefile被運行時，當中的變量都會被擴展到對應的引用位置上。
4. 文件指示。其包含了三個部分。一個是在一個Makefile中引用還有一個Makefile，就像C語言中的include同樣；還有一個是指依據某些狀況指定Makefile中的有效部分，就像C語言中的預編譯#if同樣。還有就是定義一個多行的命令。

有關這一部分的內容，我會在興許的部分中講述。
5. 凝視。Makefile中僅僅有行凝視，和UNIX的Shell腳本同樣。其凝視是用「#」字符。這個就像C/C++中的「//」同樣。

假設你要在你的Makefile中使用「#」字符。可以用反斜槓進行轉義，如：「\#」。

最後，還值得一提的是，在Makefile中的命令，必須要以[Tab]鍵開始。

Makefile的文件名稱

默認的狀況下，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

在Makefile使用includekeyword可以把別的Makefile包括進來，這很是像C語言的#include，被包括的文件會原模原樣的放在當前文件的包括位置。

include的語法是：
include <filename>;
filename可以是當前操做系統Shell的文件模式（可以包括路徑和通配符）
在include前面可以有一些空字符，但是毫不能是[Tab]鍵開始。

include和<filename>;可以用一個或多個空格隔開。

舉個樣例，你有這樣幾個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還會在如下的幾個文件夾下找：
1. 假設make運行時，有「-I」或「--include-dir」參數，那麼make就會在這個參數所指定的文件夾下去尋找。

2. 假設文件夾<prefix>;/include（一般是：/usr/local/bin或/usr/include）存在的話，make也會去找。
假設有文件沒有找到的話。make會生成一條警告信息。但不會當即出現致命錯誤。它會繼續加載其餘的文件，一旦完畢makefile的讀取。 make會再重試這些沒有找到。或是不能讀取的文件，假設仍是不行，make纔會出現一條致命信息。假設你想讓make不理那些沒法讀取的文件。而繼續運行，你可以在include前加一個減號「-」。如：

-include <filename>;

其表示，無論include過程當中出現什麼錯誤，都不要報錯繼續運行。和其餘版本號make兼容的相關命令是sinclude，其做用和這一個是同樣的。

環境變量 MAKEFILES

假設你的當前環境中定義了環境變量MAKEFILES。那麼，make會把這個變量中的值作一個相似於include的動做。這個變量中的值是其餘的Makefile，用空格分隔。

僅僅是，它和include不一樣的是，從這個環境變量中引入的Makefile的「目標」不會起做用，假設環境變量中定義的文件發現錯誤，make也會不理。
但是在這裏我仍是建議不要使用這個環境變量，因爲僅僅要這個變量一被定義，那麼當你使用make時，所有的Makefile都會受到它的影響。這毫不是你想看到的。在這裏提這個事。僅僅是爲了告訴你們，或許有時候你的Makefile出現了怪事。那麼你可以看看當前環境中有未定義這個變量。

make的工做方式

GNU的make工做時的運行過程例如如下：（想來其餘的make也是相似）
1. 讀入所有的Makefile。

2. 讀入被include的其餘Makefile。
3. 初始化文件裏的變量。
4. 推導隱晦規則，並分析所有規則。
5. 爲所有的目標文件建立依賴關係鏈。
6. 依據依賴關係。決定哪些目標要又一次生成。

7. 運行生成命令。
1-5步爲第一個階段，6-7爲第二個階段。

第一個階段中，假設定義的變量被使用了。那麼。make會把其展開在使用的位置。但make並不會全然當即展開，make使用的是遲延戰術。假設變量出現在依賴關係的規則中，那麼僅當這條依賴被決定要使用了。變量纔會在其內部展開。

固然。這個工做方式你不必定要清楚。但是知道這個方式你也會對make更爲熟悉。

有了這個基礎，興許部分也就easy看懂了。

from Ubuntu wiki