- Makefile學習教程: 跟我一起寫 Makefile
- 0 Makefile概述
- 1 Makefile 介紹
- 1.1 Makefile的規則
- 1.2 一個示例
- 1.3 make是如何工作的
- 1.4 makefile中使用變數
- 1.5 讓make自動推導
- 1.6 另類風格的makefile
- 1.7 清空目標文件的規則
- 2 Makefile 總述
- 2.1 Makefile里有什麼？
- 2.2Makefile的文件名
- 2.3 引用其它的Makefile
- 2.4 環境變數 MAKEFILES
- 2.5 make的工作方式
- 3 Makefile書寫規則
- 3.1 規則舉例
- 3.2 規則的語法
- 3.3 在規則中使用通配符
- 3.4 文件搜尋
- 3.5 偽目標
- 3.6 多目標
- 3.7 靜態模式
- 3.8 自動生成依賴性
- 4 Makefile 書寫命令
- 4.1 顯示命令
- 4.2 命令執行
- 4.3 命令出錯
- 4.4 嵌套執行make
- 4.5 定義命令包
0 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錯誤,意思說是說,鏈接器未能找到函數的實現.你需要指定函數的Object File. 好,言歸正傳,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命令會自動智能地根據當前的文件修改的情況來確定哪些文件需要重編譯,從而自己編譯所需要的文件和鏈接目標程序. 1.1 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還不夠,我會以後面一點一點地結合我的工作經驗給你慢慢到來.內容還多著呢.：） 1.2 一個示例 正如前面所說的,如果一個工程有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中定義不用的編譯或是和編譯無關的命令,比如程序的打包,程序的備份,等等. 1.3 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”,以此來清除所有的目標文件,以便重編譯. 於是在我們編程中,如果這個工程已被編譯過了,當我們修改了其中一個源文件,比如file.c,那麼根據我們的依賴性,我們的目標 file.o會被重編譯（也就是在這個依性關係後面所定義的命令）,於是file.o的文件也是最新的啦,於是file.o的文件修改時間要比edit要新,
edit也會被重新鏈接了（詳見edit目標文件后定義的命令）. 而如果我們改變了“command.h”,那麼,kdb.o、command.o和files.o都會被重編譯,並且,edit會被重鏈接. 1.4 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]文件的字元串被重複了兩次,如果我們的工程需要加入一個新的[.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 變數就可以了. 關於變數更多的話題,我會在後續給你一一道來. 1.5 讓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 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是個偽目標文件. 關於更為詳細的“隱晦規則”和“偽目標文件”,我會在後續給你一一道來. 1.6 另類風格的makefile 即然我們的make可以自動推導命令,那麼我看到那堆[.o]和[.h]的依賴就有點不爽,那麼多的重複的[.h],能不能把其收攏起來,好吧,沒有問題,這個對於make來說很容易,誰叫它提供了自動推導命令和文件的功能呢？來看看最新風格的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變得很簡單,但我們的文件依賴關係就顯得有點凌亂了.魚和熊掌不可兼得.還看你的喜好了.我是不喜歡這種風格的,一是文件的依賴關係看不清楚,二是如果文件一多,要加入幾個新的.o文件,那就理不清楚了. 1.7 清空目標文件的規則 每個Makefile中都應該寫一個清空目標文件（.o和執行文件）的規則,這不僅便於重編譯,也很利於保持文件的清潔.這是一個“修養”（呵呵,還記得我的《編程修養》嗎）.一般的風格都是： clean:
rm edit $(objects) 更為穩健的做法是： .PHONY : clean
clean : -rm edit $(objects) 前面說過,.PHONY意思表示clean是一個“偽目標”,.而在rm命令前面加了一個小減號的意思就是,也許某些文件出現問題,但不要管,繼續做後面的事.當然,clean的規則不要放在文件的開頭,不然,這就會變成make的默認目標,相信誰也不願意這樣.不成文的規矩是—— “clean從來都是放在文件的
”. 上面就是一個makefile的概貌,也是makefile的基礎,下面還有很多makefile的相關細節,準備好了嗎？準備好了就來.
2 Makefile 總述 2.1 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]鍵開始. 2.2Makefile的文件名 默認的情況下,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. 2.3 引用其它的Makefile 在Makefile使用include關鍵字可以把別的Makefile包含進來,這很像C語言的#include,被包含的文件會原模原樣的放在當前文件的包含位置.include的語法是： include <filename>
filename可以是當前操作系統Shell的文件模式（可以保含路徑和通配符） 在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還會在下面的幾個目錄下找：
1. 如果make執行時,有“-I”或“--include-dir”參數,那麼make就會在這個參數所指定的目錄下去尋找.
2. 如果目錄/include（一般是：/usr/local/bin或/usr/include）存在的話,make也會去找. 如果有文件沒有找到的話,make會生成一條警告信息,但不會馬上出現致命錯誤.它會繼續載入其它的文件,一旦完成makefile的讀取,make會再重試這些沒有找到,或是不能讀取的文件,如果還是不行,make才會出現一條致命信息.如果你想讓make不理那些無法讀取的文件,而繼續執行,你可以在include前加一個減號“-”.如： -include <filename>
其表示,無論include過程中出現什麼錯誤,都不要報錯繼續執行.和其它版本make兼容的相關命令是sinclude,其作用和這一個是一樣的. 2.4 環境變數 MAKEFILES 如果你的當前環境中定義了環境變數MAKEFILES,那麼,make會把這個變數中的值做一個類似於include的動作.這個變數中的值是其它的Makefile,用空格分隔.只是,它和include不同的是,從這個環境變中引入的Makefile的“目標”不會起作用,如果環境變數中定義的文件發現錯誤,make也會不理. 但是在這裡我還是建議不要使用這個環境變數,因為只要這個變數一被定義,那麼當你使用make時,所有的Makefile都會受到它的影響,這絕不是你想看到的.在這裡提這個事,只是為了告訴大家,也許有時候你的Makefile出現了怪事,那麼你可以看看當前環境中有沒有定義這個變數. 2.5 make的工作方式 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所完成的也就是這個目標. 好了,還是讓我們來看一看如何書寫規則. 3.1 規則舉例 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文件） 3.2 規則的語法 targets : prerequisites
command ... 或是這樣： targets : prerequisites ; command
command ... targets是文件名,以空格分開,可以使用通配符.一般來說,我們的目標基本上是一個文件,但也有可能是多個文件. command是命令行,如果其不與“target:prerequisites”在一行,那麼,必須以[Tab鍵]開頭,如果和prerequisites在一行,那麼可以用分號做為分隔.（見上） prerequisites也就是目標所依賴的文件（或依賴目標）.如果其中的某個文件要比目標文件要新,那麼,目標就被認為是“過時的”,被認為是需要重生成的.這個在前面已經講過了. 如果命令太長,你可以使用反斜框（‘’）作為換行符.make對一行上有多少個字元沒有限制.規則告訴make兩件事,文件的依賴關係和如何成成目標文件. 一般來說,make會以UNIX的標準Shell,也就是/bin/sh來執行命令. 3.3 在規則中使用通配符 如果我們想定義一系列比較類似的文件,我們很自然地就想起使用通配符.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的關鍵字,我們將在後面討論. 3.4 文件搜尋 在一些大的工程中,有大量的源文件,我們通常的做法是把這許多的源文件分類,並存放在不同的目錄中.
,當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
vpath % blish 而上面的語句則表示“.c”結尾的文件,先在“foo”目錄,然後是“bar”目錄,
才是“blish”目錄. 3.5 偽目標 最早先的一個例子中,我們提到過一個“clean”的目標,這是一個“偽目標”, clean:
rm *.o temp 正像我們前面例子中的“clean”一樣,即然我們生成了許多文件編譯文件,我們也應該提供一個清除它們的“目標”以備完整地重編譯而用.（以“make clean”來使用該目標） 因為,我們並不生成“clean”這個文件.“偽目標”並不是一個文件,只是一個標籤,由於“偽目標”不是文件,
make無法生成它的依賴關係和決定它是否要執行.我們只有通過顯示地指明這個“目標”才能讓其生效.當然,“偽目標”的取名不能和文件名重名,不然其就失去了“偽目標”的意義了. 當然,為了避免和文件重名的這種情況,我們可以使用一個特殊的標記“.PHONY”來顯示地指明一個目標是“偽目標”,向make說明,不管是否有這個文件,這個目標就是“偽目標”. .PHONY : clean 只要有這個聲明,不管是否有“clean”文件,要運行“clean”這個目標,只有“make clean”這樣.於是整個過程可以這樣寫： .PHONY: clean
clean: rm *.o temp 偽目標一般沒有依賴的文件.但是,我們也可以為偽目標指定所依賴的文件.偽目標同樣可以作為“默認目標”,只要將其放在第一個.一個示例就是,如果你的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 “make clean”將清除所有要被清除的文件.“cleanobj”和“cleandiff”這兩個偽目標有點像“子程序”的意思.我們可以輸入“make cleanall”和“make cleanobj”和“make cleandiff”命令來達到清除不同種類文件的目的 3.6 多目標 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,後面的為參數.關於函數,將在後面講述.這裡的這個函數是截取字元串的意思,“$@”表示目標的集合,就像一個數組,“$@”依次取出目標,並執於命令. 3.7 靜態模式 靜態模式可以更加容易地定義多目標的規則,可以讓我們的規則變得更加的有彈性和靈活.我們還是先來看一下語法： <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”的“%”,也就是“foo bar”,並為其加下“.c”的後綴,於是,我們的依賴目標就是“foo.c bar.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 $(CC) -c $(CFLAGS) $< -o $@ $(filter %.elc,$(files)): %.elc: %.el emacs -f batch-byte-compile $< $(filter %.o,$(files))表示調用Makefile的filter函數,過濾“$filter”集,只要其中模式為“%.o”的內容.其的它內容,我就不用多說了吧.這個例字展示了Makefile中更大的彈性. 3.8 自動生成依賴性 在Makefile中,我們的依賴關係可能會需要包含一系列的頭文件,比如,如果我們的main.c中有一句“#include "defs.h"”,那麼我們的依賴關係應該是： main.o : main.c defs.h 但是,如果是一個比較大型的工程,你必需清楚哪些C文件包含了哪些頭文件,並且,你在加入或刪除頭文件時,也需要小心地修改 Makefile,這是一個很沒有維護性的工作.為了避免這種繁重而又容易出錯的事情,我們可以使用C/C 編譯的一個功能.大多數的C/C 編譯器都支持一個“-M”的選項,即自動找尋源文件中包含的頭文件,並生成一個依賴關係.例如,如果我們執行下面的命令： cc -M main.c 其輸出是： main.o : main.c defs.h 於是由編譯器自動生成的依賴關係,這樣一來,你就不必再手動書寫若干文件的依賴關係,而由編譯器自動生成了.需要提醒一句的是,如果你使用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 $@.$$$$ 這個規則的意思是,所有的[.d]文件依賴於[.c]文件,“rm -f $@”的意思是刪除所有的目標,也就是[.d]文件,第二行的意思是,為每個依賴文件“$<”,也就是[.c]文件生成依賴文件,“$@”表示模式 “%.d”文件,如果有一個C文件是name.c,那麼“%”就是“name”,“$$$$”意為一個隨機編號,第二行生成的文件有可能是 “name.d.12345”,第三行使用sed命令做了一個替換,關於sed命令的用法請參看相關的使用文檔.第四行就是刪除臨時文件. 總而言之,這個模式要做的事就是在編譯器生成的依賴關係中加入[.d]文件的依賴,即把依賴關係： main.o : main.c defs.h 轉成： main.o main.d : main.c defs.h 於是,我們的[.d]文件也會自動更新了,並會自動生成了,當然,你還可以在這個[.d]文件中加入的不只是依賴關係,包括生成的命令也可一併加入,讓每個[.d]文件都包含一個完賴的規則.一旦我們完成這個工作,接下來,我們就要把這些自動生成的規則放進我們的主Makefile中.我們可以使用Makefile的“include”命令,來引入別的Makefile文件（前面講過）,例如： sources = foo.c bar.c
include $(sources:.c=.d) 上述語句中的“$(sources:.c=.d)”中的“.c=.d”的意思是做一個替換,把變數$(sources)所有[.c]的字串都替換成[.d],關於這個“替換”的內容,在後面我會有更為詳細的講述.當然,你得注意次序,因為include是按次來載入文件,最先載入的[.d]文件中的目標會成為默認目標 4 Makefile 書寫命令
每條規則中的命令和操作系統Shell的命令行是一致的.make會一按順序一條一條的執行命令,每條命令的開頭必須以[Tab]鍵開頭,除非,命令是緊跟在依賴規則後面的分號后的.在命令行之間中的空格或是空行會被忽略,但是如果該空格或空行是以Tab鍵開頭的,那麼make會認為其是一個空命令. 我們在UNIX下可能會使用不同的Shell,但是make的命令默認是被“/bin/sh”——UNIX的標準Shell解釋執行的.除非你特別指定一個其它的Shell.Makefile中,“#”是註釋符,很像C/C 中的“//”,其後的本行字元都被註釋. 4.1 顯示命令 通常,make會把其要執行的命令行在命令執行前輸出到屏幕上.當我們用“@”字元在命令行前,那麼,這個命令將不被make顯示出來,最具代表性的例子是,我們用這個功能來像屏幕顯示一些信息.如： @echo 正在編譯
XXX模塊...... 當make執行時,會輸出“正在編譯XXX模塊......”字串,但不會輸出命令,如果沒有“@”,那麼,make將輸出： echo 正在編譯
XXX模塊...... 正在編譯
XXX模塊...... 如果make執行時,帶入make參數“-n”或“--just-print”,那麼其只是顯示命令,但不會執行命令,這個功能很有利於我們調試我們的Makefile,看看我們書寫的命令是執行起來是什麼樣子的或是什麼順序的.而make參數“-s”或“--slient”則是全面禁止命令的顯示. 4.2 命令執行 當依賴目標新於目標時,也就是當規則的目標需要被更新時,make會一條一條的執行其後的命令.需要注意的是,如果你要讓上一條命令的結果應用在下一條命令時,你應該使用分號分隔這兩條命令.比如你的第一條命令是cd命令,你希望第二條命令得在cd之後的基礎上運行,那麼你就不能把這兩條命令寫在兩行上,而應該把這兩條命令寫在一行上,用分號分隔.如： 示例一：
exec: cd /home/hchen pwd 示例二：
exec: cd /home/hchen; pwd 當我們執行“make exec”時,第一個例子中的cd沒有作用,pwd會列印出當前的Makefile目錄,而第二個例子中,cd就起作用了,pwd會列印出“/home/hchen”. make一般是使用環境變數SHELL中所定義的系統Shell來執行命令,默認情況下使用UNIX的標準Shell——/bin/sh來執行命令.但在MS-DOS下有點特殊,因為MS-DOS下沒有SHELL環境變數,當然你也可以指定.如果你指定了UNIX風格的目錄形式,
,make會在SHELL所指定的路徑中找尋命令解釋器,如果找不到,其會在當前盤符中的當前目錄中尋找,如果再找不到,其會在PATH環境變數中所定義的所有路徑中尋找.MS-DOS中,如果你定義的命令解釋器沒有找到,其會給你的命令解釋器加上諸如“.exe”、“.com”、“.bat”、 “.sh”等後綴. 4.3 命令出錯 每當命令運行完后,make會檢測每個命令的返回碼,如果命令返回成功,那麼make會執行下一條命令,當規則中所有的命令成功返回后,這個規則就算是成功完成了.如果一個規則中的某個命令出錯了（命令退出碼非零）,那麼make就會終止執行當前規則,這將有可能終止所有規則的執行. 有些時候,命令的出錯並不表示就是錯誤的.例如mkdir命令,我們一定需要建立一個目錄,如果目錄不存在,那麼mkdir就成功執行,萬事大吉,如果目錄存在,那麼就出錯了.我們之
使用mkdir的意思就是一定要有這樣的一個目錄,於是我們就不希望mkdir出錯而終止規則的運行. 為了做到這一點,忽略命令的出錯,我們可以在Makefile的命令行前加一個減號“-”（在Tab鍵之後）,標記為不管命令出不出錯都認為是成功的.如： clean:
-rm -f *.o 還有一個全局的辦法是,給make加上“-i”或是“--ignore-errors”參數,那麼,Makefile中所有命令都會忽略錯誤.而如果一個規則是以“.IGNORE”作為目標的,那麼這個規則中的所有命令將會忽略錯誤.這些是不同級別的防止命令出錯的方法,你可以根據你的不同喜歡設置.還有一個要提一下的make的參數的是“-k”或是“--keep-going”,這個參數的意思是,如果某規則中的命令出錯了,那麼就終目該規則的執行,但繼續執行其它規則. 4.4 嵌套執行make 在一些大的工程中,我們會把我們不同模塊或是不同功能的源文件放在不同的目錄中,我們可以在每個目錄中都書寫一個該目錄的Makefile,這有利於讓我們的Makefile變得更加地簡潔,而不至於把所有的東西全部寫在一個Makefile中,這樣會很難維護我們的Makefile,這個技術對於我們模塊編譯和分段編譯有著非常大的好處. 例如,我們有一個子目錄叫subdir,這個目錄下有個Makefile文件,來指明了這個目錄下文件的編譯規則.那麼我們總控的Makefile可以這樣書寫： subsystem:
cd subdir && $(MAKE) 其等價於：
subsystem: $(MAKE) -C subdir 定義$(MAKE)宏變數的意思是,也許我們的make需要一些參數,
定義成一個變數比較利於維護.這兩個例子的意思都是先進入“subdir”目錄,然後執行make命令.我們把這個Makefile叫做“總控Makefile”,總控Makefile的變數可以傳遞到下級的Makefile中（如果你顯示的聲明）,但是不會覆蓋下層的Makefile中所定義的變數,除非指定了“-e”參數. 如果你要傳遞變數到下級Makefile中,那麼你可以使用這樣的聲明： export <variable ...>
如果你不想讓某些變數傳遞到下級Makefile中,那麼你可以這樣聲明： unexport <variable ...>
如： 示例一：
export variable = value 其等價於：
variable = value export variable 其等價於：
export variable := value 其等價於：
variable := value export variable 示例二：
export variable = value 其等價於：
variable = value export variable 如果你要傳遞所有的變數,那麼,只要一個export就行了.後面什麼也不用跟,表示傳遞所有的變數.需要注意的是,有兩個變數,一個是SHELL,一個是MAKEFLAGS,這兩個變數不管你是否export,其總是要傳遞到下層Makefile 中,特別是MAKEFILES變數,其中包含了make的參數信息,如果我們執行“總控Makefile”時有make參數或是在上層Makefile中定義了這個變數,那麼MAKEFILES變數將會是這些參數,並會傳遞到下層Makefile中,這是一個系統級的環境變數. 但是make命令中的有幾個參數並不往下傳遞,它們是“-C”,“-f”,“-h”“-o”和“-W”（有關Makefile參數的細節將在後面說明）,如果你不想往下層傳遞參數,那麼,你可以這樣來： subsystem:
cd subdir && $(MAKE) MAKEFLAGS= 如果你定義了環境變數MAKEFLAGS,那麼你得確信其中的選項是大家都會用到的,如果其中有“-t”,“-n”,和“-q”參數,那麼將會有讓你意想不到的結果,或許會讓你異常地恐慌.還有一個在“嵌套執行”中比較有用的參數,“-w”或是“--print-directory”會在make的過程中輸出一些信息,讓你看到目前的工作目錄.比如,如果我們的下級make目錄是“/home/hchen/gnu/make”,如果我們使用“make -w”來執行,那麼當進入該目錄時,我們會看到： make: Entering directory `/home/hchen/gnu/make'. 而在完成下層make后離開目錄時,我們會看到： make: Leaving directory `/home/hchen/gnu/make' 當你使用“-C”參數來指定make下層Makefile時,“-w”會被自動打開的.如果參數中有“-s”（“--slient”）或是“--no-print-directory”,那麼,“-w”總是失效的. 4.5 定義命令包 如果Makefile中出現一些相同命令序列,那麼我們可以為這些相同的命令序列定義一個變數.定義這種命令序列的語法以“define”開始,以“endef”結束,如： define run-yacc
yacc $(firstword $^) mv y.tab.c $@ endef 這裡,“run-yacc”是這個命令包的名字,其不要和Makefile中的變數重名.在“define”和“endef”中的兩行就是命令序列.這個命令包中的第一個命令是運行Yacc程序,因為Yacc程序總是生成“y.tab.c”的文件,
第二行的命令就是把這個文件改改名字.還是把這個命令包放到一個示例中來看看吧. foo.c : foo.y
$(run-yacc) 我們可以看見,要使用這個命令包,我們就好像使用變數一樣.在這個命令包的使用中,命令包“run-yacc”中的“$^”就是 “foo.y”,“$@”就是“foo.c”（有關這種以“$”開頭的特殊變數,我們會在後面介紹）,make在執行命令包時,命令包中的每個命令會被依次獨立執行.
本文出自 「流浪鳥」 博客,請務必保留此出處http://liulangniao.blog.51cto.com/2455855/434138
