2. 隐含规则和模式规则

上一节的Makefile写得中规中矩,比较繁琐,是为了讲清楚基本概念,其实Makefile有很多灵活的写法,可以写得更简洁,同时减少出错的可能。本节我们来看看这样一个例子还有哪些改进的余地。

一个目标依赖的所有条件不一定非得写在一条规则中,也可以拆开写,例如:

  1. main.o: main.h stack.h maze.h
  2.  
  3. main.o: main.c
  4. gcc -c main.c

就相当于:

  1. main.o: main.c main.h stack.h maze.h
  2. gcc -c main.c

如果一个目标拆开写多条规则,其中只有一条规则允许有命令列表,其它规则应该没有命令列表,否则make会报警告并且采用最后一条规则的命令列表。

这样我们的例子可以改写成:

  1. main: main.o stack.o maze.o
  2. gcc main.o stack.o maze.o -o main
  3.  
  4. main.o: main.h stack.h maze.h
  5. stack.o: stack.h main.h
  6. maze.o: maze.h main.h
  7.  
  8. main.o: main.c
  9. gcc -c main.c
  10.  
  11. stack.o: stack.c
  12. gcc -c stack.c
  13.  
  14. maze.o: maze.c
  15. gcc -c maze.c
  16.  
  17. clean:
  18. -rm main *.o
  19.  
  20. .PHONY: clean

这不是比原来更繁琐了吗?现在可以把提出来的三条规则删去,写成:

  1. main: main.o stack.o maze.o
  2. gcc main.o stack.o maze.o -o main
  3.  
  4. main.o: main.h stack.h maze.h
  5. stack.o: stack.h main.h
  6. maze.o: maze.h main.h
  7.  
  8. clean:
  9. -rm main *.o
  10.  
  11. .PHONY: clean

这就比原来简单多了。可是现在main.ostack.omaze.o这三个目标连编译命令都没有了,怎么编译的呢?试试看:

  1. $ make
  2. cc -c -o main.o main.c
  3. cc -c -o stack.o stack.c
  4. cc -c -o maze.o maze.c
  5. gcc main.o stack.o maze.o -o main

现在解释一下前三条编译命令是怎么来。如果一个目标在Makefile中的所有规则都没有命令列表,make会尝试在内建的隐含规则(Implicit Rule)数据库中查找适用的规则。make的隐含规则数据库可以用make -p命令打印,打印出来的格式也是Makefile的格式,包括很多变量和规则,其中和我们这个例子有关的隐含规则有:

  1. # default
  2. OUTPUT_OPTION = -o $@
  3.  
  4. # default
  5. CC = cc
  6.  
  7. # default
  8. COMPILE.c = $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c
  9.  
  10. %.o: %.c
  11. # commands to execute (built-in):
  12. $(COMPILE.c) $(OUTPUT_OPTION) $<

#号在Makefile中表示单行注释,就像C语言的//注释一样。CC是一个Makefile变量,用CC = cc定义和赋值,用$(CC)取它的值,其值应该是cc。Makefile变量像C的宏定义一样,代表一串字符,在取值的地方展开。cc是一个符号链接,通常指向gcc,在有些UNIX系统上可能指向另外一种C编译器。

  1. $ which cc
  2. /usr/bin/cc
  3. $ ls -l /usr/bin/cc
  4. lrwxrwxrwx 1 root root 20 2008-07-04 05:59 /usr/bin/cc -> /etc/alternatives/cc
  5. $ ls -l /etc/alternatives/cc
  6. lrwxrwxrwx 1 root root 12 2008-11-01 09:10 /etc/alternatives/cc -> /usr/bin/gcc

CFLAGS这个变量没有定义,$(CFLAGS)展开是空,CPPFLAGSTARGET_ARCH也是如此。这样$(COMPILE.c)展开应该是cc␣空␣空␣空␣-c,去掉所有的“空”得到cc␣␣␣␣-c,注意中间留下4个空格,所以%.o: %.c规则的命令$(COMPILE.c)␣$(OUTPUT_OPTION)␣$<展开之后是cc␣␣␣␣-c␣-o␣$@␣$<,和上面的编译命令已经很接近了。

$@$<是两个特殊的变量,$@的取值为规则中的目标,$<的取值为规则中的第一个条件。%.o: %.c是一种特殊的规则,称为模式规则(Pattern Rule)。现在回顾一下整个过程,在我们的Makefile中以main.o为目标的规则都没有命令列表,所以make会查找隐含规则,发现隐含规则中有这样一条模式规则适用,main.o符合%.o的模式,现在%就代表main(称为main.o这个名字的Stem),再替换到%.c中就是main.c。所以这条模式规则相当于:

  1. main.o: main.c
  2. cc -c -o main.o main.c

随后,在处理stack.o目标时又用到这条模式规则,这时又相当于:

  1. stack.o: stack.c
  2. cc -c -o stack.o stack.c

maze.o也同样处理。这三条规则可以由make的隐含规则推导出来,所以不必写在Makefile中。

先前我们写Makefile都是以目标为中心,一个目标依赖于若干条件,现在换个角度,以条件为中心,Makefile还可以这么写:

  1. main: main.o stack.o maze.o
  2. gcc main.o stack.o maze.o -o main
  3.  
  4. main.o stack.o maze.o: main.h
  5. main.o maze.o: maze.h
  6. main.o stack.o: stack.h
  7.  
  8. clean:
  9. -rm main *.o
  10.  
  11. .PHONY: clean

我们知道,写规则的目的是让make建立依赖关系图,不管怎么写,只要把所有的依赖关系都描述清楚了就行。对于多目标的规则,make会拆成几条单目标的规则来处理,例如

  1. target1 target2: prerequisite1 prerequisite2
  2. command $< -o $@

这样一条规则相当于:

  1. target1: prerequisite1 prerequisite2
  2. command prerequisite1 -o target1
  3.  
  4. target2: prerequisite1 prerequisite2
  5. command prerequisite1 -o target2

注意两条规则的命令列表是一样的,但$@的取值不同。