在我們使用Makefile時，有一些我們會常用，而且使用頻率非常高的東西，比方，我們編譯C/C++的源程式為中間目標檔案（Unix下是[.o]檔案，Windows下是[.obj]檔案）。本章講述的就是一些在Makefile中的“隱含的”，早先約定了的，不須要我們再寫出來的規則。

“隱含規則”也就是一種慣例，make會依照這樣的“慣例”心照不喧地來執行，那怕我們的Makefile中沒有書寫這樣的規則。比如，把[.c]檔案編譯成[.o]檔案這一規則，你根本就不用寫出來，make會自己主動推匯出這樣的規則，並生成我們須要的[.o]檔案。

“隱含規則”會使用一些我們系統變數，我們能夠改變這些系統變數的值來定製隱含規則的執行時的引數。如系統變數“CFLAGS”能夠控制編譯時的編譯器引數。

我們還能夠通過“模式規則”的方式寫下自己的隱含規則。用“字尾規則”來定義隱含規則會有很多的限制。使用“模式規則”會更回得智慧和清晰，但“字尾規則”能夠用來保證我們Makefile的相容性。
我們瞭解了“隱含規則”，能夠讓其為我們更好的服務，也會讓我們知道一些“約定俗成”了的東西，而不至於使得我們在執行Makefile時出現一些我們覺得莫名其妙的東西。當然，不論什麼事物都是矛盾的，水能載舟，亦可覆舟，所以，有時候“隱含規則”也會給我們造成不小的麻煩。唯獨瞭解了它，我們才幹更好地使用它。

一、使用隱含規則

假設要使用隱含規則生成你需要的目標，你所需要做的就是不要寫出這個目標的規則。那麼，make會試圖去自己主動推導產生這個目標的規則和命令，假設make能夠自己主動推導生成這個目標的規則和命令，那麼這個行為就是隱含規則的自己主動推導。當然，隱含規則是make事先約定好的一些東西。比如，我們有以下的一個Makefile：

foo : foo.o bar.o
    cc –o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)

我們能夠注意到，這個Makefile中並沒有寫下怎樣生成foo.o和bar.o這兩目標的規則和命令。由於make的“隱含規則”功能會自己主動為我們自己主動去推導這兩個目標的依賴目標和生成命令。

make會在自己的“隱含規則”庫中尋找能夠用的規則，假設找到，那麼就會使用。假設找不到，那麼就會報錯。在上面的那個樣例中，make呼叫的隱含規則是，把[.o]的目標的依賴檔案置成[.c]，並使用C的編譯命令“cc –c $(CFLAGS) [.c]”來生成[.o]的目標。也就是說，我們全然沒有必要寫下以下的兩條規則：

foo.o : foo.c
    cc –c foo.c $(CFLAGS)
bar.o : bar.c
    cc –c bar.c $(CFLAGS)

(CFLAGS 表示用於 C 編譯器的選項，
CXXFLAGS 表示用於 C++ 編譯器的選項。
這兩個變數實際上涵蓋了編譯和彙編兩個步驟。)

由於，這已經是“約定”好了的事了，make和我們約定好了用C編譯器“cc”生成[.o]檔案的規則，這就是隱含規則。

當然，假設我們為[.o]檔案書寫了自己的規則，那麼make就不會自己主動推導並呼叫隱含規則，它會依照我們寫好的規則忠實地執行。

還有，在make的“隱含規則庫”中，每一條隱含規則都在庫中有其順序，越靠前的則是越被常用的，所以，這會導致我們有些時候即使我們顯示地指定了目標依賴，make也不會管。如以下這條規則（沒有命令）：

foo.o : foo.p

依賴檔案“foo.p”（Pascal程式的原始檔）有可能變得沒有意義。假設資料夾下存在了“foo.c”檔案，那麼我們的隱含規則一樣會生效，並會通過“foo.c”呼叫C的編譯器生成foo.o檔案。由於，在隱含規則中，Pascal的規則出如今C的規則之後，所以，make找到能夠生成foo.o的C的規則就不再尋找下一條規則了。假設你確實不希望不論什麼隱含規則推導，那麼，你就不要僅僅寫出“依賴規則”，而不寫命令。

二、隱含規則一覽

這裡我們將講述全部預先設定（也就是make內建）的隱含規則，假設我們不明白地寫下規則，那麼，make就會在這些規則中尋找所須要規則和命令。當然，我們也能夠使用make的引數“-r”或“--no-builtin-rules”選項來取消全部的預設定的隱含規則。

當然，即使是我們指定了“-r”引數，某些隱含規則還是會生效，由於有很多的隱含規則都是使用了“字尾規則”來定義的，所以，僅僅要隱含規則中有“字尾列表”（也就一系統定義在目標.SUFFIXES的依賴目標），那麼隱含規則就會生效。預設的字尾列表是：.out, .a, .ln, .o, .c, .cc, .C, .p, .f, .F, .r, .y, .l, .s, .S, .mod, .sym, .def, .h, .info, .dvi, .tex, .texinfo, .texi, .txinfo, .w, .ch .web, .sh, .elc, .el。具體的細節，我們會在後面講述。

還是先來看一看常用的隱含規則吧。

1、編譯C程式的隱含規則。
“<n>.o”的目標的依賴目標會自己主動推導為“<n>.c”，而且其生成命令是“$(CC) –c $(CPPFLAGS) $(CFLAGS)”

2、編譯C++程式的隱含規則。
“<n>.o”的目標的依賴目標會自己主動推導為“<n>.cc”或是“<n>.C”，而且其生成命令是“$(CXX) –c $(CPPFLAGS) $(CFLAGS)”。（建議使用“.cc”作為C++原始檔的字尾，而不是“.C”）

3、編譯Pascal程式的隱含規則。
“<n>.o”的目標的依賴目標會自己主動推導為“<n>.p”，而且其生成命令是“$(PC) –c $(PFLAGS)”。

4、編譯Fortran/Ratfor程式的隱含規則。
“<n>.o”的目標的依賴目標會自己主動推導為“<n>.r”或“<n>.F”或“<n>.f”，而且其生成命令是:
“.f” “$(FC) –c $(FFLAGS)”
“.F” “$(FC) –c $(FFLAGS) $(CPPFLAGS)”
“.f” “$(FC) –c $(FFLAGS) $(RFLAGS)”

5、預處理Fortran/Ratfor程式的隱含規則。
“<n>.f”的目標的依賴目標會自己主動推導為“<n>.r”或“<n>.F”。這個規則僅僅是轉換Ratfor或有預處理的Fortran程式到一個標準的Fortran程式。其使用的命令是：
“.F” “$(FC) –F $(CPPFLAGS) $(FFLAGS)”
“.r” “$(FC) –F $(FFLAGS) $(RFLAGS)”

6、編譯Modula-2程式的隱含規則。
“<n>.sym”的目標的依賴目標會自己主動推導為“<n>.def”，而且其生成命令是：“$(M2C) $(M2FLAGS) $(DEFFLAGS)”。“<n.o>” 的目標的依賴目標會自己主動推導為“<n>.mod”，而且其生成命令是：“$(M2C) $(M2FLAGS) $(MODFLAGS)”。

7、彙編和彙編預處理的隱含規則。
“<n>.o” 的目標的依賴目標會自己主動推導為“<n>.s”，預設使用編譯品“as”，而且其生成命令是：“$(AS) $(ASFLAGS)”。“<n>.s” 的目標的依賴目標會自己主動推導為“<n>.S”，預設使用C預編譯器“cpp”，而且其生成命令是：“$(AS) $(ASFLAGS)”。

8、連結Object檔案的隱含規則。
“<n>”目標依賴於“<n>.o”，通過執行C的編譯器來執行連結程式生成（通常是“ld”），其生成命令是：“$(CC) $(LDFLAGS) <n>.o $(LOADLIBES) $(LDLIBS)”。這個規則對於唯獨一個原始檔的工程有效，同一時候也對多個Object檔案（由不同的原始檔生成）的也有效。比如例如以下規則：

x : y.o z.o

而且“x.c”、“y.c”和“z.c”都存在時，隱含規則將執行例如以下命令：

cc -c x.c -o x.o
cc -c y.c -o y.o
cc -c z.c -o z.o
cc x.o y.o z.o -o x
rm -f x.o
rm -f y.o
rm -f z.o

假設沒有一個原始檔（如上例中的x.c）和你的目標名字（如上例中的x）相關聯，那麼，你最好寫出自己的生成規則，不然，隱含規則會報錯的。

9、Yacc C程式時的隱含規則。
“<n>.c”的依賴檔案被自己主動推導為“n.y”（Yacc生成的檔案），其生成命令是：“$(YACC) $(YFALGS)”。（“Yacc”是一個語法分析器，關於其細節請檢視相關資料）

10、Lex C程式時的隱含規則。
“<n>.c”的依賴檔案被自己主動推導為“n.l”（Lex生成的檔案），其生成命令是：“$(LEX) $(LFALGS)”。（關於“Lex”的細節請檢視相關資料）

11、Lex Ratfor程式時的隱含規則。
“<n>.r”的依賴檔案被自己主動推導為“n.l”（Lex生成的檔案），其生成命令是：“$(LEX) $(LFALGS)”。

12、從C程式、Yacc檔案或Lex檔案建立Lint庫的隱含規則。
“<n>.ln” （lint生成的檔案）的依賴檔案被自己主動推導為“n.c”，其生成命令是：“$(LINT) $(LINTFALGS) $(CPPFLAGS) -i”。對於“<n>.y”和“<n>.l”也是相同的規則。

三、隱含規則使用的變數

在隱含規則中的命令中，基本上都是使用了一些預先設定的變數。你能夠在你的makefile中改變這些變數的值，或是在make的命令列中傳入這些值，或是在你的環境變數中設定這些值，無論怎麼樣，僅僅要設定了這些特定的變數，那麼其就會對隱含規則起作用。當然，你也能夠利用make的“-R”或“--no–builtin-variables”引數來取消你所定義的變數對隱含規則的作用。

比如，第一條隱含規則——編譯C程式的隱含規則的命令是“$(CC) –c $(CFLAGS) $(CPPFLAGS)”。Make預設的編譯命令是“cc”，假設你把變數“$(CC)”重定義成“gcc”，把變數“$(CFLAGS)”重定義成“-g”，那麼，隱含規則中的命令全部會以“gcc –c -g $(CPPFLAGS)”的樣子來運行了。

我們能夠把隱含規則中使用的變數分成兩種：一種是命令相關的，如“CC”；一種是引數相的關，如“CFLAGS”。以下是全部隱含規則中會用到的變數：

1、關於命令的變數。

AR 
函式庫打包程式。預設命令是“ar”。 
AS 
組合語言編譯程式。預設命令是“as”。
CC 
C語言編譯程式。預設命令是“cc”。
CXX 
C++語言編譯程式。預設命令是“g++”。
CO 
從 RCS檔案裡擴充套件檔案程式。預設命令是“co”。
CPP 
C程式的前處理器（輸出是標準輸出裝置）。預設命令是“$(CC) –E”。
FC 
Fortran 和 Ratfor 的編譯器和預處理程式。預設命令是“f77”。
GET 
從SCCS檔案裡擴充套件檔案的程式。預設命令是“get”。 
LEX 
Lex方法分析器程式（針對於C或Ratfor）。預設命令是“lex”。
PC 
Pascal語言編譯程式。預設命令是“pc”。
YACC 
Yacc文法分析器（針對於C程式）。預設命令是“yacc”。
YACCR 
Yacc文法分析器（針對於Ratfor程式）。預設命令是“yacc –r”。
MAKEINFO 
轉換Texinfo原始檔（.texi）到Info檔案程式。預設命令是“makeinfo”。
TEX 
從TeX原始檔建立TeX DVI檔案的程式。預設命令是“tex”。
TEXI2DVI 
從Texinfo原始檔建立軍TeX DVI 檔案的程式。預設命令是“texi2dvi”。
WEAVE 
轉換Web到TeX的程式。預設命令是“weave”。
CWEAVE 
轉換C Web 到 TeX的程式。預設命令是“cweave”。
TANGLE 
轉換Web到Pascal語言的程式。預設命令是“tangle”。
CTANGLE 
轉換C Web 到 C。預設命令是“ctangle”。
RM 
刪除檔案命令。預設命令是“rm –f”。

2、關於命令引數的變數

以下的這些變數都是相關上面的命令的引數。假設沒有指明其預設值，那麼其預設值都是空。

ARFLAGS 
函式庫打包程式AR命令的引數。預設值是“rv”。
ASFLAGS 
組合語言編譯器引數。（當明顯地呼叫“.s”或“.S”檔案時）。 
CFLAGS 
C語言編譯器引數。
CXXFLAGS 
C++語言編譯器引數。
COFLAGS 
RCS命令引數。 
CPPFLAGS 
C前處理器引數。（ C 和 Fortran 編譯器也會用到）。
FFLAGS 
Fortran語言編譯器引數。
GFLAGS 
SCCS “get”程式引數。
LDFLAGS 
連結器引數。（如：“ld”）
LFLAGS 
Lex文法分析器引數。
PFLAGS 
Pascal語言編譯器引數。
RFLAGS 
Ratfor 程式的Fortran 編譯器引數。
YFLAGS 
Yacc文法分析器引數。 

四、隱含規則鏈

有些時候，一個目標可能被一系列的隱含規則所作用。比如，一個[.o]的檔案生成，可能會是先被Yacc的[.y]檔案先成[.c]，然後再被C的編譯器生成。我們把這一系列的隱含規則叫做“隱含規則鏈”。

在上面的樣例中，假設檔案[.c]存在，那麼就直接呼叫C的編譯器的隱含規則，假設沒有[.c]檔案，但有一個[.y]檔案，那麼Yacc的隱含規則會被呼叫，生成[.c]檔案，然後，再呼叫C編譯的隱含規則終於由[.c]生成[.o]檔案，達到目標。

我們把這樣的[.c]的檔案（或是目標），叫做中間目標。無論怎麼樣，make會努力自己主動推導生成目標的一切方法，無論中間目標有多少，其都會執著地把全部的隱含規則和你書寫的規則全部合起來分析，努力達到目標，所以，有些時候，可能會讓你覺得奇怪，怎麼我的目標會這樣生成？怎麼我的makefile發瘋了？

在預設情況下，對於中間目標，它和一般的目標有兩個地方所不同：第一個不同是除非中間的目標不存在，才會引發中間規則。第二個不同的是，僅僅要目標成功產生，那麼，產生終於目標過程中，所產生的中間目標檔案會被以“rm -f”刪除。

通常，一個被makefile指定成目標或是依賴目標的檔案不能被當作中介。然而，你能夠明顯地說明一個檔案或是目標是中介目標，你能夠使用偽目標“.INTERMEDIATE”來強制宣告。（如：.INTERMEDIATE ： mid ）

你也能夠阻止make自己主動刪除中間目標，要做到這一點，你能夠使用偽目標“.SECONDARY”來強制宣告（如：.SECONDARY : sec）。你還能夠把你的目標，以模式的方式來指定（如：%.o）成偽目標“.PRECIOUS”的依賴目標，以儲存被隱含規則所生成的中間檔案。

在“隱含規則鏈”中，禁止同一個目標出現兩次或兩次以上，這樣一來，就可防止在make自己主動推導時出現無限遞迴的情況。

Make會優化一些特殊的隱含規則，而不生成中間檔案。如，從檔案“foo.c”生成目標程式“foo”，按道理，make會編譯生成中間檔案“foo.o”，然後連結成“foo”，但在實際情況下，這一動作能夠被一條“cc”的命令完成（cc –o foo foo.c），於是優化過的規則就不會生成中間檔案。

 

五、定義模式規則

你能夠使用模式規則來定義一個隱含規則。一個模式規則就好像一個一般的規則，僅僅是在規則中，目標的定義須要有"%"字元。"%"的意思是表示一個或多個隨意字元。在依賴目標中相同能夠使用"%"，僅僅是依賴目標中的"%"的取值，取決於其目標。

有一點須要注意的是，"%"的展開發生在變數和函式的展開之後，變數和函式的展開發生在make載入Makefile時，而模式規則中的"%"則發生在執行時。

1、模式規則介紹

模式規則中，至少在規則的目標定義中要包括"%"，否則，就是一般的規則。目標中的"%"定義表示對檔名稱的匹配，"%"表示長度隨意的非空字串。比如："%.c"表示以".c"結尾的檔名稱（檔名稱的長度至少為3），而"s.%.c"則表示以"s."開頭，".c"結尾的檔名稱（檔名稱的長度至少為5）。

假設"%"定義在目標中，那麼，目標中的"%"的值決定了依賴目標中的"%"的值，也就是說，目標中的模式的"%"決定了依賴目標中"%"的樣子。比如有一個模式規則例如以下：

%.o : %.c ; <command ......>

其含義是，指出了怎麼從全部的[.c]檔案生成對應的[.o]檔案的規則。假設要生成的目標是"a.o b.o"，那麼"%c"就是"a.c b.c"。

一旦依賴目標中的"%"模式被確定，那麼，make會被要求去匹配當前資料夾下全部的檔名稱，一旦找到，make就會規則下的命令，所以，在模式規則中，目標可能會是多個的，假設有模式匹配出多個目標，make就會產生全部的模式目標，此時，make關心的是依賴的檔名稱和生成目標的命令這兩件事。

2、模式規則演示例子

以下這個樣例表示了,把全部的[.c]檔案都編譯成[.o]檔案.

%.o : %.c
$(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o [email protected]

當中，"[email protected]"表示全部的目標的挨個值，"$<"表示了全部依賴目標的挨個值。這些奇怪的變數我們叫"自己主動化變數"，後面會具體講述。

以下的這個樣例中有兩個目標是模式的：

%.tab.c %.tab.h: %.y
bison -d $<

這條規則告訴make把全部的[.y]檔案都以"bison -d <n>.y"執行，然後生成"<n>.tab.c"和"<n>.tab.h"檔案。（當中，"<n>"表示一個隨意字串）。假設我們的執行程式"foo"依賴於檔案"parse.tab.o"和"scan.o"，而且檔案"scan.o"依賴於檔案"parse.tab.h"，假設"parse.y"檔案被更新了，那麼依據上述的規則，"bison -d parse.y"就會被執行一次，於是，"parse.tab.o"和"scan.o"的依賴檔案就齊了。（假設，"parse.tab.o"由"parse.tab.c"生成，和"scan.o"由"scan.c"生成，而"foo"由"parse.tab.o"和"scan.o"連結生成，而且foo和其[.o]檔案的依賴關係也寫好，那麼，全部的目標都會得到滿足）

3、自己主動化變數

在上述的模式規則中，目標和依賴檔案都是一系例的檔案，那麼我們怎樣書寫一個命令來完成從不同的依賴檔案生成對應的目標？由於在每一次的對模式規則的解析時，都會是不同的目標和依賴檔案。

自己主動化變數就是完成這個功能的。在前面，我們已經對自己主動化變數有所提涉，相信你看到這裡已對它有一個感性認識了。所謂自己主動化變數，就是這樣的變數會把模式中所定義的一系列的檔案自己主動地挨個取出，直至全部的符合模式的檔案都取完了。這樣的自己主動化變數僅僅應出如今規則的命令中。

以下是全部的自己主動化變數及其說明：

[email protected]
表示規則中的目標檔案集。在模式規則中，假設有多個目標，那麼，"[email protected]"就是匹配於目標中模式定義的集合。

$%
僅當目標是函式庫檔案裡，表示規則中的目標成員名。比如，假設一個目標是"foo.a(bar.o)"，那麼，"$%"就是"bar.o"，"[email protected]"就是"foo.a"。假設目標不是函式庫檔案（Unix下是[.a]，Windows下是[.lib]），那麼，其值為空。

$<
依賴目標中的第一個目標名字。假設依賴目標是以模式（即"%"）定義的，那麼"$<"將是符合模式的一系列的檔案集。注意，其是一個一個取出來的。

$?
全部比目標新的依賴目標的集合。以空格分隔。

$^
全部的依賴目標的集合。以空格分隔。假設在依賴目標中有多個反覆的，那個這個變數會去除反覆的依賴目標，僅僅保留一份。

$+
這個變數非常像"$^"，也是全部依賴目標的集合。僅僅是它不去除反覆的依賴目標。

$* 
這個變量表示目標模式中"%"及其之前的部分。假設目標是"dir/a.foo.b"，而且目標的模式是"a.%.b"，那麼，"$*"的值就是"dir/a.foo"。這個變數對於構造有關聯的檔名稱是比較有較。假設目標中沒有模式的定義，那麼"$*"也就不能被推匯出，可是，假設目標檔案的字尾是make所識別的，那麼"$*"就是除了字尾的那一部分。比如：假設目標是"foo.c"，由於".c"是make所能識別的字尾名，所以，"$*"的值就是"foo"。這個特性是GNU make的，非常有可能不兼容於其他版本號的make，所以，你應該儘量避免使用"$*"，除非是在隱含規則或是靜態模式中。假設目標中的字尾是make所不能識別的，那麼"$*"就是空值。

當你希望僅僅對更新過的依賴檔案進行操作時，"$?"在顯式規則中非常實用，比如，假設有一個函式庫檔案叫"lib"，其由其他幾個object檔案更新。那麼把object檔案打包的比較有效率的Makefile規則是：

lib : foo.o bar.o lose.o win.o
ar r lib $?

在上述所列出來的自己主動量變數中。四個變數（[email protected]、$<、$%、$*）在擴充套件時僅僅會有一個檔案，而另三個的值是一個檔案列表。這七個自己主動化變數還能夠取得檔案的資料夾名或是在當前資料夾下的符合模式的檔名稱，僅僅須要搭配上"D"或"F"字樣。這是GNU make中老版本號的特性，在新版本號中，我們使用函式"dir"或"notdir"就能夠做到了。"D"的含義就是Directory，就是資料夾，"F"的含義就是File，就是檔案。

以下是對於上面的七個變數分別加上"D"或是"F"的含義：

$(@D)
表示"[email protected]"的資料夾部分（不以斜槓作為結尾），假設"[email protected]"值是"dir/foo.o"，那麼"$(@D)"就是"dir"，而假設"[email protected]"中沒有包括斜槓的話，其值就是"."（當前資料夾）。

$(@F)
表示"[email protected]"的檔案部分，假設"[email protected]"值是"dir/foo.o"，那麼"$(@F)"就是"foo.o"，"$(@F)"相當於函式"$(notdir [email protected])"。

"$(*D)"
"$(*F)"
和上面所述的同理，也是取檔案的資料夾部分和檔案部分。對於上面的那個樣例，"$(*D)"返回"dir"，而"$(*F)"返回"foo"

"$(%D)"
"$(%F)"
分別表示了函式包檔案成員的資料夾部分和檔案部分。這對於形同"archive(member)"形式的目標中的"member"中包括了不同的資料夾非常實用。

"$(<D)"
"$(<F)"
分別表示依賴檔案的資料夾部分和檔案部分。

"$(^D)"
"$(^F)"
分別表示全部依賴檔案的資料夾部分和檔案部分。（無相同的）

"$(+D)"
"$(+F)"
分別表示全部依賴檔案的資料夾部分和檔案部分。（能夠有相同的）

"$(?D)"
"$(?F)"
分別表示被更新的依賴檔案的資料夾部分和檔案部分。

最後想提醒一下的是，對於"$<"，為了避免產生不必要的麻煩，我們最好給$後面的那個特定字元都加上圓括號，比方，"$(< )"就要比"$<"要好一些。

還得要注意的是，這些變數僅僅使用在規則的命令中，而且一般都是"顯式規則"和"靜態模式規則"（參見前面"書寫規則"一章）。其在隱含規則中並沒有意義。

4、模式的匹配

一般來說，一個目標的模式有一個有字首或是字尾的"%"，或是沒有前後綴，直接就是一個"%"。由於"%"代表一個或多個字元，所以在定義好了的模式中，我們把"%"所匹配的內容叫做"莖"，比如"%.c"所匹配的檔案"test.c"中"test"就是"莖"。由於在目標和依賴目標中同一時候有"%"時，依賴目標的"莖"會傳給目標，當做目標中的"莖"。

當一個模式匹配包括有斜槓（實際也不常常包括）的檔案時，那麼在進行模式匹配時，資料夾部分會首先被移開，然後進行匹配，成功後，再把資料夾加回去。在進行"莖"的傳遞時，我們須要知道這個步驟。比如有一個模式"e%t"，檔案"src/eat"匹配於該模式，於是"src/a"就是其"莖"，假設這個模式定義在依賴目標中，而被依賴於這個模式的目標中又有個模式"c%r"，那麼，目標就是"src/car"。（"莖"被傳遞）

5、過載內建隱含規則

你能夠過載內建的隱含規則（或是定義一個全新的），比如你能夠又一次構造和內建隱含規則不同的命令，如：

%.o : %.c
$(CC) -c $(CPPFLAGS) $(CFLAGS) -D$(date)

你能夠取消內建的隱含規則，僅僅要不在後面寫命令就可以。如：

%.o : %.s

相同，你也能夠又一次定義一個全新的隱含規則，其在隱含規則中的位置取決於你在哪裡寫下這個規則。朝前的位置就靠前。

六、老式風格的"字尾規則"

字尾規則是一個比較老式的定義隱含規則的方法。字尾規則會被模式規則逐步地代替。由於模式規則更強更清晰。為了和老版本號的Makefile相容，GNU make相同兼容於這些東西。字尾規則有兩種方式："雙字尾"和"單字尾"。

雙字尾規則定義了一對字尾：目標檔案的字尾和依賴目標（原始檔）的字尾。如".c.o"相當於"%o : %c"。單字尾規則僅僅定義一個字尾，也就是原始檔的字尾。如".c"相當於"% : %.c"。

字尾規則中所定義的字尾應該是make所認識的，假設一個字尾是make所認識的，那麼這個規則就是單字尾規則，而假設兩個連在一起的字尾都被make所認識，那就是雙字尾規則。比如：".c"和".o"都是make所知道。因而，假設你定義了一個規則是".c.o"那麼其就是雙字尾規則，意義就是".c"是原始檔的字尾，".o"是目標檔案的字尾。例如以下演示例子：

.c.o:
$(CC) -c $(CFLAGS) $(CPPFLAGS) -o [email protected] $<

字尾規則不同意不論什麼的依賴檔案，假設有依賴檔案的話，那就不是字尾規則，那些字尾統統被覺得是檔名稱，如：

.c.o: foo.h
$(CC) -c $(CFLAGS) $(CPPFLAGS) -o [email protected] $<

這個樣例，就是說，檔案".c.o"依賴於檔案"foo.h"，而不是我們想要的這樣：

%.o: %.c foo.h
$(CC) -c $(CFLAGS) $(CPPFLAGS) -o [email protected] $<

字尾規則中，假設沒有命令，那是毫無意義的。由於他也不會移去內建的隱含規則。

而要讓make知道一些特定的字尾，我們能夠使用偽目標".SUFFIXES"來定義或是刪除，如：

.SUFFIXES: .hack .win

把字尾.hack和.win新增字尾列表中的末尾。

.SUFFIXES: # 刪除預設的字尾
.SUFFIXES: .c .o .h # 定義自己的字尾

先清晰預設字尾，後定義自己的字尾列表。

make的引數"-r"或"-no-builtin-rules"也會使用得預設的字尾列表為空。而變數"SUFFIXE"被用來定義預設的字尾列表，你能夠用".SUFFIXES"來改變字尾列表，但請不要改變變數"SUFFIXE"的值。

七、隱含規則搜尋演算法

比方我們有一個目標叫 T。以下是搜尋目標T的規則的演算法。請注意，在以下，我們沒有提到字尾規則，原因是，全部的字尾規則在Makefile被載入記憶體時，會被轉換成模式規則。假設目標是"archive(member)"的函式庫檔案模式，那麼這個演算法會被執行兩次，第一次是找目標T，假設沒有找到的話，那麼進入第二次，第二次會把"member"當作T來搜尋。

1、把T的資料夾部分分離出來。叫D，而剩餘部分叫N。（如：假設T是"src/foo.o"，那麼，D就是"src/"，N就是"foo.o"）

2、建立全部匹配於T或是N的模式規則列表。

3、假設在模式規則列表中有匹配全部檔案的模式，如"%"，那麼從列表中移除其他的模式。

4、移除列表中沒有命令的規則。

5、對於第一個在列表中的模式規則：
1）推導其"莖"S，S應該是T或是N匹配於模式中"%"非空的部分。
2）計算依賴檔案。把依賴檔案裡的"%"都替換成"莖"S。假設目標模式中沒有包括斜框字元，而把D加在第一個依賴檔案的開頭。
3）測試是否全部的依賴檔案都存在或是理當存在。（假設有一個檔案被定義成另外一個規則的目標檔案，或者是一個顯式規則的依賴檔案，那麼這個檔案就叫"理當存在"）
4）假設全部的依賴檔案存在或是理當存在，或是就沒有依賴檔案。那麼這條規則將被採用，退出該演算法。

6、假設經過第5步，沒有模式規則被找到，那麼就做更進一步的搜尋。對於存在於列表中的第一個模式規則：
1）假設規則是終止規則，那就忽略它，繼續下一條模式規則。
2）計算依賴檔案。（同第5步）
3）測試全部的依賴檔案是否存在或是理當存在。
4）對於不存在的依賴檔案，遞迴呼叫這個演算法查詢他能否夠被隱含規則找到。
5）假設全部的依賴檔案存在或是理當存在，或是就根本沒有依賴檔案。那麼這條規則被採用，退出該演算法。

7、假設沒有隱含規則能夠使用，檢視".DEFAULT"規則，假設有，採用，把".DEFAULT"的命令給T使用。

一旦規則被找到，就會執行其相當的命令，而此時，我們的自己主動化變數的值才會生成。