GUN Make介紹

1 GUN Make 和 makefile簡介

在大型的開發項目中，通常有幾十到上百個的源文件，如果每次均手工鍵入 gcc 命令進行編譯的話，則會非常不方便。因此，人們通常利用 make 工具來自動完成編譯工作。這些工作包括：如果僅修改了某幾個源文件，則只重新編譯這幾個源文件；如果某個頭文件被修改了，則重新編譯所有包含該頭文件的源 文件。
利用這種自動編譯可大大簡化開發工作，避免不必要的重新編譯。
實際上，make 工具通過一個稱為 makefile 的文件來完成并自動維護編譯工作。makefile 需要按照某種語法進行編寫，其中說明了如何編譯各個源文件并連接生成可執行文件，并定義了源文件之間的依賴關系。
當修改了其中某個源文件時，如果其他源文件依賴于該文件，則也要重新編譯所有依賴該文件的源文件。
makefile 文件是許多編譯器，包括 Windows NT 下的編譯器維護編譯信息的常用方法，只是在集成開發環境中，用戶通過友好的界面修改 makefile 文件而已。
默認情況下，GNU make 工具在當前工作目錄中按如下順序搜索 makefile：
* GNUmakefile
* makefile
* Makefile
在 UNIX 系統中，習慣使用 Makefile 作為 makfile 文件。如果要使用其他文件作為 makefile，則可利用類
似下面的 make 命令選項指定 makefile 文件：
$ make -f Makefile.debug

2 GNU Make 工具
~~~~~~~~~~~~~~~~
?
2.1 基本 makefile 結構
GNU Make 的主要工作是讀進一個文本文件， makefile 。這個文件里主要是有關哪些文件（‘target’目的文件）是從哪些別的 文件（‘dependencies’依靠文件）中產生的，用什么命令來進行這個產生過程。有了這些信息， make 會檢查磁碟上的文件，如果 目的文件的時間戳（該文件生成或被改動時的時間）比至少它的一個依靠文件舊的話， make 就執行相應的命令，以便更新目的文件。 （目的文件不一定是最后的可執行檔，它可以是任何一個文件。）
?
makefile 一般被叫做“makefile”或“Makefile”。當然你可以 在 make 的命令行指定別的文件名。如果你不特別指定，它會尋 找“makefile”或“Makefile”，因此使用這兩個名字是最簡單 的。
一個 makefile 主要含有一系列的規則，如下：

:?
(tab)<command>
(tab)<command>
.
.
.

?
例如，考慮以下的 makefile ：

===?makefile?開始?===
myprog?:?foo.o?bar.o
?gcc?foo.o?bar.o?-o?myprog
?
foo.o?:?foo.c?foo.h?bar.h
?gcc?-c?foo.c?-o?foo.o
?
bar.o?:?bar.c?bar.h
?gcc?-c?bar.c?-o?bar.o
===?makefile?結束?===

?
這 是一個非常基本的 makefile —— make 從最上面開始，把上面第一個目的，‘myprog’，做為它的主要目標（一個它需要保 證其總是最新的最終目標）。給出的規則說明只要文件‘myprog’ 比文件‘foo.o’或‘bar.o’中的任何一個舊，下一行的命令將 會被執行。
?
但 是，在檢查文件 foo.o 和 bar.o 的時間戳之前，它會往下查找那些把 foo.o 或 bar.o 做為目標文件的規則。它找到的關于 foo.o 的規則，該文件的依靠文件是 foo.c, foo.h 和 bar.h 。 它從下面再找不到生成這些依靠文件的規則，它就開始檢查磁碟 上這些依靠文件的時間戳。如果這些文件中任何一個的時間戳比 foo.o 的新，命令 'gcc -o foo.o foo.c' 將會執行，從而更新 文件 foo.o 。
?
接下來對文件 bar.o 做類似的檢查，依靠文件在這里是文件 bar.c 和 bar.h 。
?
現在， make 回到‘myprog’的規則。如果剛才兩個規則中的任 何一個被執行，myprog 就需要重建（因為其中一個 .o 檔就會比 ‘myprog’新），因此連接命令將被執行。
?
希 望到此，你可以看出使用 make 工具來建立程序的好處——前一章中所有繁瑣的檢查步驟都由 make 替你做了：檢查時間戳。 你的源碼文件里一個簡單改變都會造成那個文件被重新編譯（因 為 .o 文件依靠 .c 文件），進而可執行文件被重新連接（因為 .o 文件被改變了）。其實真正的得益是在當你改變一個 header 檔的時候——你不再需要記住那個源碼文件依靠它，因為所有的 資料都在 makefile 里。 make 會很輕松的替你重新編譯所有那些因依靠這個 header 文件而改變了的源碼文件，如有需要，再 進行重新連接。
?
當然，你要確定你在 makefile 中所寫的規則是正確無誤的，只 列出那些在源碼文件中被 #include 的 header 檔……
?
2.2 編寫 make 規則 (Rules)
?
最 明顯的（也是最簡單的）編寫規則的方法是一個一個的查看源碼文件，把它們的目標文件做為目的，而Ｃ源碼文件和被它 #include 的 header 檔做為依靠文件。但是你也要把其它被這些 header 檔 #include 的 header 檔也列為依靠文件，還有那些被 包括的文件所包括的文件……然后你會發現要對越來越多的文件進行管理，然后你的頭發開始脫落，你的脾氣開始變壞，你的臉 色變成菜色，你走在路上開始跟電線桿子碰撞，終于你搗毀你的電腦顯示器，停止編程。到低有沒有些容易點兒的方法呢？
?
當然有！向編譯器 要！在編譯每一個源碼文件的時候，它實在應該知道應該包括什么樣的 header 檔。使用 gcc 的時候，用 -M 開關，它會為每一個你給它的Ｃ文件輸出一個規則，把目標文件做為目的，而這個Ｃ文件和所有應該被 #include 的 header 文 件將做為依靠文件。注意這個規則會加入所有 header 文件，包括被角括號(`<', `>')和雙引號(`"')所包圍的文件。其實我們可以 相當肯定系統 header 檔（比如 stdio.h, stdlib.h 等等）不會 被我們更改，如果你用 -MM 來代替 -M 傳遞給 gcc，那些用角括 號包圍的 header 檔將不會被包括。（這會節省一些編譯時間）
?
由 gcc 輸出的規則不會含有命令部分；你可以自己寫入你的命令 或者什么也不寫，而讓 make 使用它的隱含的規則（參考下面的 2.4 節）。
?
2.3 Makefile 變量
?
上面提到 makefiles 里主要包含一些規則。它們包含的其它的東 西是變量定義。
?
makefile 里的變量就像一個環境變量(environment variable)。 事實上，環境變量在 make 過程中被解釋成 make 的變量。這些變量是大小寫敏感的，一般使用大寫字母。它們可以從幾乎任何 地方被引用，也可以被用來做很多事情，比如：
i) 貯存一個文件名列表。在上面的例子里，生成可執行文件的 規則包含一些目標文件名做為依靠。在這個規則的命令行 里同樣的那些文件被輸送給 gcc 做為命令參數。如果在這 里使用一個變數來貯存所有的目標文件名，加入新的目標 文件會變的簡單而且較不易出錯。
?
ii) 貯存可執行文件名。如果你的項目被用在一個非 gcc 的系 統里，或者如果你想使用一個不同的編譯器，你必須將所 有使用編譯器的地方改成用新的編譯器名。但是如果使用一 個變量來代替編譯器名，那么你只需要改變一個地方，其 它所有地方的命令名就都改變了。
?
iii) 貯存編譯器旗標。假設你想給你所有的編譯命令傳遞一組 相同的選項（例如 -Wall -O -g）；如果你把這組選項存 入一個變量，那么你可以把這個變量放在所有呼叫編譯器 的地方。而當你要改變選項的時候，你只需在一個地方改 變這個變量的內容。
要設定一個變量，你只要在一行的開始寫下這個變量的名字，后 面跟一個 = 號，后面跟你要設定的這個變量的值。以后你要引用 這個變量，寫一個 $ 符號，后面是圍在括號里的變量名。比如在 下面，我們把前面的 makefile 利用變量重寫一遍：
?

===?makefile?開始?===
OBJS?=?foo.o?bar.o
CC?=?gcc
CFLAGS?=?-Wall?-O?-g
?
myprog?:?$(OBJS)
?$(CC)?$(OBJS)?-o?myprog
?
foo.o?:?foo.c?foo.h?bar.h
?$(CC)?$(CFLAGS)?-c?foo.c?-o?foo.o
?
bar.o?:?bar.c?bar.h
?$(CC)?$(CFLAGS)?-c?bar.c?-o?bar.o
===?makefile?結束?===

?
還 有一些設定好的內部變量，它們根據每一個規則內容定義。三個 比較有用的變量是 $@, $< 和 $^ （這些變量不需要括號括住）。 $@ 擴展成當前規則的目的文件名， $< 擴展成依靠列表中的第一個依靠文件，而 $^ 擴展成整個依靠的列表（除掉了里面所有重 復的文件名）。利用這些變量，我們可以把上面的 makefile 寫成：
?

===?makefile?開始?===
OBJS?=?foo.o?bar.o
CC?=?gcc
CFLAGS?=?-Wall?-O?-g
?
myprog?:?$(OBJS)
?$(CC)?$^?-o?$@
?
foo.o?:?foo.c?foo.h?bar.h
?$(CC)?$(CFLAGS)?-c?$<?-o?$@
?
bar.o?:?bar.c?bar.h
?$(CC)?$(CFLAGS)?-c?$<?-o?$@
===?makefile?結束?===

?
你可以用變量做許多其它的事情，特別是當你把它們和函數混合 使用的時候。如果需要更進一步的了解，請參考 GNU Make 手冊。 ('man make', 'man makefile')
?
2.4 隱含規則 (Implicit Rules)
?
請 注意，在上面的例子里，幾個產生 .o 文件的命令都是一樣的。 都是從 .c 文件和相關文件里產生 .o 文件，這是一個標準的步 驟。其實 make 已經知道怎么做——它有一些叫做隱含規則的內置的規則，這些規則告訴它當你沒有給出某些命令的時候，應該 怎么辦。
?
如果你把 生成 foo.o 和 bar.o 的命令從它們的規則中刪除， make 將會查找它的隱含規則，然后會找到一個適當的命令。它的命令會 使用一些變量，因此你可以按照你的想法來設定它：它使用變量 CC 做為編譯器（象我們在前面的例子），并且傳遞變量 CFLAGS （給 C 編譯器，C++ 編譯器用 CXXFLAGS ），CPPFLAGS （ C 預 處理器旗標）， TARGET_ARCH （現在不用考慮這個），然后它加 入旗標 '-c' ，后面跟變量 $< （第一個依靠名），然后是旗 標 '-o' 跟變量 $@ （目的文件名）。一個Ｃ編譯的具體命令將 會是：
?
$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c $< -o $@
?
當然你可以按照你自己的需要來定義這些變量。這就是為什么用 gcc 的 -M 或 -MM 開關輸出的碼可以直接用在一個 makefile 里。

假象目的 (Phony Targets)
?
假 設你的一個項目最后需要產生兩個可執行文件。你的主要目標是產生兩個可執行文件，但這兩個文件是相互獨立的——如果一 個文件需要重建，并不影響另一個。你可以使用“假象目的”來達到這種效果。一個假象目的跟一個正常的目的幾乎是一樣的， 只是這個目的文件是不存在的。因此， make 總是會假設它需要被生成，當把它的依賴文件更新后，就會執行它的規則里的命令 行。
?
如果在我們的 makefile 開始處輸入：
?
all : exec1 exec2
?
其 中 exec1 和 exec2 是我們做為目的的兩個可執行文件。 make 把這個 'all' 做為它的主要目的，每次執行時都會嘗試把 'all' 更新。但既然這行規則里沒有哪個命令來作用在一個叫 'all' 的實際文件（事實上 all 并不會在磁碟上實際產生），所以這個規 則并不真的改變 'all' 的狀態。可既然這個文件并不存在，所以 make 會嘗試更新 all 規則，因此就檢查它的依靠 exec1, exec2 是否需要更新，如果需要，就把它們更新，從而達到我們的目的。
?
假象目的也可以用來描述一組非預設的動作。例如，你想把所有由 make 產生的文件刪除，你可以在 makefile 里設立這樣一個規則：
?
veryclean :
?rm *.o
?rm myprog
?
前提是沒有其它的規則依靠這個 'veryclean' 目的，它將永遠 不會被執行。但是，如果你明確的使用命令 'make veryclean' ， make 會把這個目的做為它的主要目標，執行那些 rm 命令。
?
如 果你的磁碟上存在一個叫 veryclean 文件，會發生什么事？這時因為在這個規則里沒有任何依靠文件，所以這個目的文件一定是 最新的了（所有的依靠文件都已經是最新的了），所以既使用戶明 確命令 make 重新產生它，也不會有任何事情發生。解決方法是標 明所有的假象目的（用 .PHONY），這就告訴 make 不用檢查它們是否存在于磁碟上，也不用查找任何隱含規則，直接假設指定的目 的需要被更新。在 makefile 里加入下面這行包含上面規則的規則：
?
.PHONY : veryclean
?
就可以了。注意，這是一個特殊的 make 規則，make 知道 .PHONY 是一個特殊目的，當然你可以在它的依靠里加入你想用的任何假象 目的，而 make 知道它們都是假象目的。
?
2.6 函數 (Functions)
?
makefile 里的函數跟它的變量很相似——使用的時候，你用一個 $ 符號跟開括號，函數名，空格后跟一列由逗號分隔的參數，最后 用關括號結束。例如，在 GNU Make 里有一個叫 'wildcard' 的函數，它有一個參數，功能是展開成一列所有符合由其參數描述的文 件名，文件間以空格間隔。你可以像下面所示使用這個命令：
?
SOURCES = $(wildcard *.c)
?
這行會產生一個所有以 '.c' 結尾的文件的列表，然后存入變量 SOURCES 里。當然你不需要一定要把結果存入一個變量。
?
另一個有用的函數是 patsubst （ patten substitude, 匹配替 換的縮寫）函數。它需要３個參數——第一個是一個需要匹配的 式樣，第二個表示用什么來替換它，第三個是一個需要被處理的由空格分隔的字列。例如，處理那個經過上面定義后的變量，
?
OBJS = $(patsubst %.c,%.o,$(SOURCES))
?
這 行將處理所有在 SOURCES 字列中的字（一列文件名），如果它的 結尾是 '.c' ，就用 '.o' 把 '.c' 取代。注意這里的 % 符號將匹 配一個或多個字符，而它每次所匹配的字串叫做一個‘柄’(stem) 。在第二個參數里， % 被解讀成用第一參數所匹配的那個柄。
?
2.7 一個比較有效的 makefile
?
利用我們現在所學的，我們可以建立一個相當有效的 makefile 。 這個 makefile 可以完成大部分我們需要的依靠檢查，不用做太大 的改變就可直接用在大多數的項目里。
?
首先我們需要一個基本的 makefile 來建我們的程序。我們可以讓它搜索當前目錄，找到源碼文件，并且假設它們都是屬于我們的項 目的，放進一個叫 SOURCES 的變量。這里如果也包含所有的 *.cc 文件，也許會更保險，因為源碼文件可能是 C++ 碼的。
?
SOURCES = $(wildcard *.c *.cc)
?
利用 patsubst ，我們可以由源碼文件名產生目標文件名，我們需 要編譯出這些目標文件。如果我們的源碼文件既有 .c 文件，也有 .cc 文件，我們需要使用相嵌的 patsubst 函數呼叫：
?
OBJS = $(patsubst %.c,%.o,$(patsubst %.cc,%.o,$(SOURCES)))
?
最里面一層 patsubst 的呼叫會對 .cc 文件進行后綴替代，產生的結 果被外層的 patsubst 呼叫處理，進行對 .c 文件后綴的替代。
?
現在我們可以設立一個規則來建可執行文件：
?
myprog : $(OBJS)
?gcc -o myprog $(OBJS)
?
進一步的規則不一定需要， gcc 已經知道怎么去生成目標文件 (object files) 。下面我們可以設定產生依靠信息的規則：
?
depends : $(SOURCES)
?gcc -M $(SOURCES) > depends
?
在 這里如果一個叫 'depends' 的文件不存在，或任何一個源碼文件比一個已存在的 depends 文件新，那么一個 depends 文件會被生 成。depends 文件將會含有由 gcc 產生的關于源碼文件的規則（注 意 -M 開關）。現在我們要讓 make 把這些規則當做 makefile 檔 的一部分。這里使用的技巧很像 C 語言中的 #include 系統——我 們要求 make 把這個文件 include 到 makefile 里，如下：
?
include depends
?
GNU Make 看到這個，檢查 'depends' 目的是否更新了，如果沒有， 它用我們給它的命令重新產生 depends 檔。然后它會把這組（新） 規則包含進來，繼續處理最終目標 'myprog' 。當看到有關 myprog 的規則，它會檢查所有的目標文件是否更新——利用 depends 文件里的規則，當然這些規則現在已經是更新過的了。
?
這個系統其實效率很低，因為每當一個源碼文件被改動，所有的源碼 文件都要被預處理以產生一個新的 'depends' 文件。而且它也不是 100% 的安全，這是因為當一個 header 檔被改動，依靠信息并不會 被更新。但就基本工作來說，它也算相當有用的了。

2.8 一個更好的 makefile
?
這是一個我為我大多數項目設計的 makefile 。它應該可以不需要修改的用在大部分項目里。我主要把它用在 djgpp 上，那是一個 DOS 版的 gcc 編譯器。因此你可以看到執行的命令名、 'alleg' 程序包、 和 RM -F 變量都反映了這一點。
?

===?makefile?開始?===
?
######################################
#
#?Generic?makefile
#
#?by?George?Foot
#?email:?george.foot@merton.ox.ac.uk
#
#?Copyright?(c)?1997?George?Foot
#?All?rights?reserved.
#?保留所有版權
#
#?No?warranty,?no?liability;
#?you?use?this?at?your?own?risk.
#?沒保險，不負責
#?你要用這個，你自己擔風險
#
#?You?are?free?to?modify?and
#?distribute?this?without?giving
#?credit?to?the?original?author.
#?你可以隨便更改和散發這個文件
#?而不需要給原作者什么榮譽。
#?（你好意思？）
#
######################################
?
###?Customising
#?用戶設定
#
#?Adjust?the?following?if?necessary;?EXECUTABLE?is?the?target
#?executable's?filename,?and?LIBS?is?a?list?of?libraries?to?link?in
#?(e.g.?alleg,?stdcx,?iostr,?etc).?You?can?override?these?on?make's
#?command?line?of?course,?if?you?prefer?to?do?it?that?way.
#
#?如果需要，調整下面的東西。?EXECUTABLE?是目標的可執行文件名，?LIBS
#?是一個需要連接的程序包列表（例如?alleg,?stdcx,?iostr?等等）。當然你
#?可以在?make?的命令行覆蓋它們，你愿意就沒問題。
#
?
EXECUTABLE?:=?mushroom.exe
LIBS?:=?alleg
?
#?Now?alter?any?implicit?rules'?variables?if?you?like,?e.g.:
#
#?現在來改變任何你想改動的隱含規則中的變量，例如
?
CFLAGS?:=?-g?-Wall?-O3?-m486
CXXFLAGS?:=?$(CFLAGS)
?
#?The?next?bit?checks?to?see?whether?rm?is?in?your?djgpp?bin
#?directory;?if?not?it?uses?del?instead,?but?this?can?cause?(harmless)
#?`File?not?found'?error?messages.?If?you?are?not?using?DOS?at?all,
#?set?the?variable?to?something?which?will?unquestioningly?remove
#?files.
#
#?下面先檢查你的?djgpp?命令目錄下有沒有?rm?命令，如果沒有，我們使用
#?del?命令來代替，但有可能給我們?'File?not?found'?這個錯誤信息，這沒
#?什么大礙。如果你不是用?DOS?，把它設定成一個刪文件而不廢話的命令。
#?（其實這一步在?UNIX?類的系統上是多余的，只是方便?DOS?用戶。?UNIX
#?用戶可以刪除這５行命令。）
?
ifneq?($(wildcard?$(DJDIR)/bin/rm.exe),)
RM-F?:=?rm?-f
else
RM-F?:=?del
endif
?
#?You?shouldn't?need?to?change?anything?below?this?point.
#
#?從這里開始，你應該不需要改動任何東西。（我是不太相信，太ＮＢ了！）
?
SOURCE?:=?$(wildcard?*.c)?$(wildcard?*.cc)
OBJS?:=?$(patsubst?%.c,%.o,$(patsubst?%.cc,%.o,$(SOURCE)))
DEPS?:=?$(patsubst?%.o,%.d,$(OBJS))
MISSING_DEPS?:=?$(filter-out?$(wildcard?$(DEPS)),$(DEPS))
MISSING_DEPS_SOURCES?:=?$(wildcard?$(patsubst?%.d,%.c,$(MISSING_DEPS))?\
$(patsubst?%.d,%.cc,$(MISSING_DEPS)))
CPPFLAGS?+=?-MD
?
.PHONY?:?everything?deps?objs?clean?veryclean?rebuild
?
everything?:?$(EXECUTABLE)
?
deps?:?$(DEPS)
?
objs?:?$(OBJS)
?
clean?:
?@$(RM-F)?*.o
?@$(RM-F)?*.d
?
veryclean:?clean
?@$(RM-F)?$(EXECUTABLE)
?
rebuild:?veryclean?everything
?
ifneq?($(MISSING_DEPS),)
$(MISSING_DEPS)?:
?@$(RM-F)?$(patsubst?%.d,%.o,$@)
endif
?
-include?$(DEPS)
?
$(EXECUTABLE)?:?$(OBJS)
?gcc?-o?$(EXECUTABLE)?$(OBJS)?$(addprefix?-l,$(LIBS))
?
===?makefile?結束?===

?
有幾個地方值得解釋一下的。首先，我在定義大部分變量的時候使 用的是 := 而不是 = 符號。它的作用是立即把定義中參考到的函 數和變量都展開了。如果使用 = 的話，函數和變量參考會留在那 兒，就是說改變一個變量的值會導致其它變量的值也被改變。例 如：
?
A = foo
B = $(A)
# 現在 B 是 $(A) ，而 $(A) 是 'foo' 。
A = bar
# 現在 B 仍然是 $(A) ，但它的值已隨著變成 'bar' 了。
B := $(A)
# 現在 B 的值是 'bar' 。
A = foo
# B 的值仍然是 'bar' 。
?
make 會忽略在 # 符號后面直到那一行結束的所有文字。
?
ifneg...else...endif 系統是 makefile 里讓某一部分碼有條件的 失效／有效的工具。 ifeq 使用兩個參數，如果它們相同，它把直 到 else （或者 endif ，如果沒有 else 的話）的一段碼加進 makefile 里；如果不同，把 else 到 endif 間的一段碼加入 makefile （如果有 else ）。 ifneq 的用法剛好相反。
?
'filter-out' 函數使用兩個用空格分開的列表，它把第二列表中所 有的存在于第一列表中的項目刪除。我用它來處理 DEPS 列表，把所 有已經存在的項目都刪除，而只保留缺少的那些。
?
我 前面說過， CPPFLAGS 存有用于隱含規則中傳給預處理器的一些 旗標。而 -MD 開關類似 -M 開關，但是從源碼文件 .c 或 .cc 中 形成的文件名是使用后綴 .d 的（這就解釋了我形成 DEPS 變量的步驟）。DEPS 里提到的文件后來用 '-include' 加進了 makefile 里，它隱藏了所有因文件不存在而產生的錯誤信息。
?
如果任何依靠文件不存在， makefile 會把相應的 .o 文件從磁碟 上刪除，從而使得 make 重建它。因為 CPPFLAGS 指定了 -MD ， 它的 .d 文件也被重新產生。
?
最后， 'addprefix' 函數把第二個參數列表的每一項前綴上第一 個參數值。
?
這個 makefile 的那些目的是（這些目的可以傳給 make 的命令行 來直接選用）：
?
everything:（預設） 更新主要的可執行程序，并且為每一個 源碼文件生成或更新一個 '.d' 文件和一個 '.o' 文件。
?
deps: 只是為每一個源碼程序產生或更新一個 '.d' 文件。
?
objs: 為每一個源碼程序生成或更新 '.d' 文件和目標文件。
?
clean: 刪除所有中介／依靠文件（ *.d 和 *.o ）。
?
veryclean: 做 `clean' 和刪除可執行文件。
?
rebuild: 先做 `veryclean' 然后 `everything' ；既完全重建。
?
除了預設的 everything 以外，這里頭只有 clean ， veryclean ， 和 rebuild 對用戶是有意義的。
?
我 還沒有發現當給出一個源碼文件的目錄，這個 makefile 會失敗的情況，除非依靠文件被弄亂。如果這種弄亂的情況發生了，只要輸入 `make clean' ，所有的目標文件和依靠文件會被刪除，問題就應該被解決了。當然，最好不要把它們弄亂。如果你發現在某種情況下這 個 makefile 文件不能完成它的工作，請告訴我，我會把它整好的。
?

3 總結
~~~~~~~~~~~~~~~
?
我希望這篇文章足夠詳細的解釋了多文件項目是怎么運作的，也說明了 怎樣安全而合理的使用它。到此，你應該可以輕松的利用 GNU Make 工 具來管理小型的項目，如果你完全理解了后面幾個部分的話，這些對于 你來說應該沒什么困難。

4 轉自：http://oss.org.cn/ossdocs/gnu/linux/gmake.html

轉載于:https://www.cnblogs.com/itech/archive/2009/09/15/1567001.html

總結

以上是生活随笔為你收集整理的GUN Make指南的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。