Makefile里主要包含了五个东西：显式规则、隐晦规则、变量定义、文件指示和注释。

 

1、显式规则。显式规则说明了，如何生成一个或多的的目标文件。这是由 Makefile的

书写者明显指出，要生成的文件，文件的依赖文件，生成的命令。

 

2、隐晦规则。由于我们的 make有自动推导的功能，所以隐晦的规则可以让我们比较

粗糙地简略地书写 Makefile，这是由 make所支持的（name.o:xx.h 命令和name.cc被自动推导）。

 

3、变量的定义。在 Makefile中我们要定义一系列的变量，变量一般都是字符串，这个

有点你 C语言中的宏，当 Makefile被执行时，其中的变量都会被扩展到相应的引用位置上。

 

4、文件指示。其包括了三个部分，一个是在一个 Makefile中引用另一个 Makefile，就

像 C语言中的 include一样；另一个是指根据某些情况指定 Makefile中的有效部分，就像 C

语言中的预编译#if一样；还有就是定义一个多行的命令。有关这一部分的内容，在后续的

部分中讲述。

 

5、注释。Makefile中只有行注释，和 UNIX的 Shell脚本一样，其注释是用“#”字符，

这个就像 C/C++中的“//”一样。如果你要在你的 Makefile中使用“#”字符，可以用反斜框进行

转义，如：“\#”。

最后，还值得一提的是，在 Makefile中的命令，必须要以[Tab]键开始。

 

6.在 include前面可以有一些空字符，但是绝不能是[Tab]键开始。

eg:include foo.make *.mk $(bar)

 

7,在指令前加“-”表示不要报错，继续执行

 

GNU的 make工作时的执行步骤入下：（想来其它的 make也是类似）

1、读入所有的 Makefile。

2、读入被 include的其它Makefile。

3、初始化文件中的变量。

4、推导隐晦规则，并分析所有规则。

5、为所有的目标文件创建依赖关系链。

6、根据依赖关系，决定哪些目标要重新生成。

7、执行生成命令。

 

 

8，是第一条规则中的目标将被确立为最终的目标。如果第一条规则中的目标有很多个，那么，第一个目标会成为最终的目标。

 

9，是“~/test”，这就表示当前用

户的$HOME目录下的test目录。而“~hchen/test”则表示用户hchen的宿主目录下的test目录。

 

10，如果你要让通配符在变量中展开，也就是让 objects的值是所有[.o]的文件名的集合，那么，你可以这样：

objects := $(wildcard *.o)

这种用法由关键字“wildcard”指出。

 

11，查找目录顺序

make命令开始时，会把找寻 include所指出的其它 Makefile，并把其内容安置在当前的

位置。就好像 C/C++的#include指令一样。如果文件都没有指定绝对路径或是相对路径的话，

make会在当前目录下首先寻找，如果当前目录下没有找到，那么，make还会在下面的几个

目录下找：

1、如果 make执行时，有“-I”或“--include-dir”参数，那么 make就会在这个参数所指定

的目录下去寻找。

2、如果目录<prefix>/include（一般是：/usr/local/bin或/usr/include）存在的话，make

也会去找。

3，设置在当前目录中找不到文件时的搜索路径。

    3.1 VPATH = src:../headers

    3.2 1、vpath <pattern> <directories>

          为符合模式<pattern>的文件指定搜索            目录<directories>。

         2、vpath <pattern>

              清除符合模式<pattern>的文件的              搜索目录。

         3、vpath

4，伪目标一般没有依赖的文件。但是，我们也可以为伪目标指定所依赖的文件。伪目标同

样可以作为“默认目标”，只要将其放在第一个。一个示例就是，如果你的 Makefile需要一口

气生成若干个可执行文件，但你只想简单地敲一个 make完事，并且，所有的目标文件都写

在一个 Makefile中，那么你可以使用“伪目标”这个特性：

 

5，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，后

面的为参数。关于函数，将在后面讲述。这里的这个函数是截取字符串的意思，“$@”表示

目标的集合，就像一个数组，“$@”依次取出目标，并执行命令。

6,make -n(显示但不执行命令)/-s(禁止命令的显示)。通常make在执行一个命令之前会将命令显示到屏幕，但如果在命令前加@将不显示该命令eg.

@ehco 正在编译xxx模块......当执行make时会输出"正在编译xxx模块......"，而不会输出echo.

7,如果要将上一个命令产生的效果运用于下一个命令，则这两个命令必须写在一行并由‘;‘分开

eg:

exec:

    cd ../../;pwd

8,make -i (让所有命令忽略错误继续执行）/-k(如果某规则中的命令出错，那么就终止该规则的执行，但继续执行其它规则).在文件中可以在tab之后命令之前加‘-‘表示忽略该命令的错误。目标指示为.IGNORE则忽略该目标的所有命令错误。

 

9,进入目录进行make

eg:

  subsystem:

    cd subdir && $(MAKE)

其等价于：

  subsystem:

    $(MAKE) -C subdir

MAKE为定义的变量，可以带参数。

10,总控Makefile的变量可以传递下层，但是不会覆盖下层定义的变量，除非指定-e（环境变量重写）参数。方法如下：

示例一：

export variable = value

其等价于：

variable = value

export variable

其等价于：

export variable := value

其等价于：

variable := value

export variable

示例二：

export variable += value

其等价于：

variable += value

export variable

如果要传递所有的变量只要一个export后面什么都不跟就行了。SHELL,和MAKEFLAGS总是被传到下层。make -w显示进出目录的情况

11.定义命令包：

eg:

define run-yacc

yacc $(firstword $^)

mv y.tab.c $@

endef

使用：

foo.c : foo.y

$(run-yacc)

 

1.变量可以改变值，不应该含有":","#","="或空字符。

2.变量使用$()/${},要使用$应该$$.

3.可以用变量来给变量赋值

  方法一：

    foo = $(bar)

    bar = $(ugh)

    ugh = Huh?

    all:

    echo $(foo)

   用于赋值的变量可以在后面定义

   输出为Huh?

  方法二：

    x := foo

    y := $(x) bar

    x := later

  用于赋值的变量不能在后面定义

     如果是这样：

    y := $(x) bar

    x := foo

    那么，y的值是“bar”，而不是“foo         bar”。

    定义空格：

    nullstring:=

    space:=$(nullstring)#end of the         line

    nullstring是一个 Empty变量，其中什    么也没有，而我们的 space的值是一个    空格。因为

    在操作符的右边是很难描述一个空格的    ，这里采用的技术很管用，先用一个     Empty变量来

    标明变量的值开始了，而后面采用“#”    注释符来表示变量定义的终止，这样，    我们可以定义

    出其值是一个空格的变量。请注意这里        关于“#”的使用，注释符“#”的这种        特    性值得我们注意，

    如果我们这样定义一个变量：

    dir := /foo/bar # directory to put         the frobs in

    dir这个变量的值是“/foo/bar”，后面        还跟了 4个空格，如果我们这样使用变        量    来指定别

    的目录——“$(dir)/file”那么就完蛋    了。

 

    FOO?=bar//如果FOO没有定义过则FOO的    值是bar,否则这条语句什么也不做。

 

4.变量定义的高级用法：

变量相同部分替换

  foo := a.o b.o c.o

  bar := $(foo:.o=.c)

  @echo bar

  bar的值是a.c b.c c.c

  静态模式

  foo := a.o b.o c.o

  bar := $(foo:%.o=%.c)

将变量的值作为变量：

 

  x = variable1

  variable2 := Hello

  y = $(subst 1,2,$(x))

  z = y

  a := $($($(z)))

  这个例子中，“$($($(z)))”扩展为“$($(y))”，而其再次被扩展为“$($(subst 1,2,$(x)))”。$(x)

的值是“variable1”，subst函数把“variable1”中的所有“1”字串替换成“2”字串，于是，“variable1”

变成“variable2”，再取其值，所以，最终，$(a)的值就是$(variable2)的值——“Hello”。（喔，

好不容易）

first_second = Hello

a = first

b = second

all = $($a_$b)

这里的“$a_$b”组成了“first_second”，于是，$(all)的值就是“Hello”。

再来看看结合第一种技术的例子：

a_objects := a.o b.o c.o

1_objects := 1.o 2.o 3.o

sources := $($(a1)_objects:.o=.c)

这个例子中，如果$(a1)的值是“a”的话，那么，$(sources)的值就是“a.c b.c c.c”；如果$(a1)

的值是“1”，那么$(sources)的值是“1.c 2.c 3.c”。

 

5.追加变量值

objects = main.o foo.o bar.o utils.o

objects += another.o

于是，我们的$(objects)值变成：“main.o foo.o bar.o utils.o another.o”（another.o被追加进

去了）

 

6.override指示符。

  如果有变量是通常 make的命令行参数设置的，那么 Makefile中对这个变量的赋值会被

忽略。如果你想在 Makefile中设置这类参数的值，那么，你可以使用“override”指示符。其

语法是：

override <variable> = <value>

override <variable> := <value>

当然，你还可以追加：

override <variable> += <more text>

 

 

7.多行变量

 

define two-lines

    echo foo

    echo $(bar)

endef

two-lines值为：

    echo foo

    echo $(bar)

 

前面有tab键

 

8，系统变量会被带到makefile中，但是如果该makefile有同名的变量，则覆盖系统变量。

 

9.目标变量：

，当我们设置了这样一个变量，这个变量会作用到由这个目标所引

发的所有的规则中去。如：

 

prog : CFLAGS = -g

prog : prog.o foo.o bar.o

$(CC) $(CFLAGS) prog.o foo.o bar.o

prog.o : prog.c

$(CC) $(CFLAGS) prog.c

foo.o : foo.c

$(CC) $(CFLAGS) foo.c

bar.o : bar.c

$(CC) $(CFLAGS) bar.c

 

在这个示例中，不管全局的$(CFLAGS)的值是什么，在 prog目标，以及其所引发的所

有规则中（prog.o foo.o bar.o的规则），$(CFLAGS)的值都是“-g”

 

10.模式变量：

为所有的.o目标定义目标变量

%.o : CFLAGS = -O

 

 

 

使用条件判断：

1.相等if

   ifeq (<arg1>, <arg2> ) /  ifeq ‘<arg1>‘ ‘<arg2>‘/   ifeq "<arg1>" "<arg2>"/  ifeq "<arg1>" ‘<arg2>‘/   ifeq ‘<arg1>‘ "<arg2>"

 

   xxxxxxxx

   else

   xxxxxxx

   endif

ifeq ($(strip $(foo)),)

<text-if-empty>

endif

这个示例中使用了“strip”函数，如果这个函数的返回值是空（Empty），那么

<text-if-empty>就生效。

2.ifneq.....

3.ifdef <variable-name>

如果变量<variable-name>的值非空，那到表达式为真。否则，表达式为假。当然，

<variable-name>同样可以是一个函数的返回值。注意，ifdef只是测试一个变量是否有值，其

并不会把变量扩展到当前位置。还是来看两个例子：

示例一：

bar =

foo = $(bar)

ifdef foo

frobozz = yes

else

frobozz = no

endif

示例二：

foo =

ifdef foo

frobozz = yes

else

frobozz = no

endif

第一个例子中，“$(frobozz)”值是“yes”，第二个则是“no”。

4.ifndef

 

 

函数的使用：

函数调用，很像变量的使用，也是以“$”来标识的，其语法如下：

$(<function> <arguments> )

或是

${<function> <arguments>}

这里，<function>就是函数名，make支持的函数不多。<arguments>是函数的参数，参

数间以逗号“,”分隔，而函数名和参数之间以“空格”分隔。函数调用以“$”开头，以圆括号或

花括号把函数名和参数括起。感觉很像一个变量，是不是？函数中的参数可以使用变量，为

了风格的统一，函数和变量的括号最好一样，如使用“$(subst a,b,$(x))”这样的形式，而不是

“$(subst a,b,${x})”的形式。因为统一会更清楚，也会减少一些不必要的麻烦。

 

1. $(subst <from>,<to>,<text> )

名称：字符串替换函数——subst。

功能：把字串<text>中的<from>字符串替换成<to>。

返回：函数返回被替换过后的字符串。

示例：

$(subst ee,EE,feet on the street)，

把“feet on the street”中的“ee”替换成“EE”，返回结果是“fEEt on the strEEt”。

 

2.$(patsubst <pattern>,<replacement>,<text> )

名称：模式字符串替换函数——patsubst。

功能：查找<text>中的单词（单词以“空格”、“Tab”或“回车”“换行”分隔）是否符合模式

<pattern>，如果匹配的话，则以<replacement>替换。这里，<pattern>可以包括通配符“%”，

表示任意长度的字串。如果<replacement>中也包含“%”，那么，<replacement>中的这个“%”

将是<pattern>中的那个“%”所代表的字串。（可以用“\”来转义，以“\%”来表示真实含义的“%”

字符）

返回：函数返回被替换过后的字符串。

示例：

$(patsubst %.c,%.o,x.c.c bar.c)

把字串“x.c.c bar.c”符合模式[%.c]的单词替换成[%.o]，返回结果是“x.c.o bar.o”

 

 

3.$(strip <string> )

名称：去空格函数——strip。

功能：去掉<string>字串中开头和结尾的空字符。

返回：返回被去掉空格的字符串值。

示例：

$(strip a b c )

把字串“a b c ”去到开头和结尾的空格，结果是“a b c”。

 

4. $(findstring <find>,<in> )

名称：查找字符串函数——findstring。

功能：在字串<in>中查找<find>字串。

返回：如果找到，那么返回<find>，否则返回空字符串。

示例：

$(findstring a,a b c)

$(findstring a,b c)

第一个函数返回“a”字符串，第二个返回“”字符串（空字符串）

 

5. $(filter <pattern...>,<text> )

名称：过滤函数——filter。

功能：以<pattern>模式过滤<text>字符串中的单词，保留符合模式<pattern>的单词。可

以有多个模式。

返回：返回符合模式<pattern>的字串。

示例：

sources := foo.c bar.c baz.s ugh.h

foo: $(sources)

cc $(filter %.c %.s,$(sources)) -o foo

$(filter %.c %.s,$(sources))返回的值是“foo.c bar.c baz.s”。

 

6. $(filter-out <pattern...>,<text> )

名称：反过滤函数——filter-out。

功能：以<pattern>模式过滤<text>字符串中的单词，去除符合模式<pattern>的单词。可

以有多个模式。

返回：返回不符合模式<pattern>的字串。

示例：

objects=main1.o foo.o main2.o bar.o

mains=main1.o main2.o

$(filter-out $(mains),$(objects)) 返回值是“foo.o bar.o”。

 

7. $(sort <list> )

名称：排序函数——sort。

功能：给字符串<list>中的单词排序（升序）。

返回：返回排序后的字符串。

示例：$(sort foo bar lose)返回“bar foo lose” 。

备注：sort函数会去掉<list>中相同的单词。

 

8. $(word <n>,<text> )

名称：取单词函数——word。

功能：取字符串<text>中第<n>个单词。（从一开始）

返回：返回字符串<text>中第<n>个单词。如果<n>比<text>中的单词数要大，那么返回

空字符串。

示例：$(word 2, foo bar baz)返回值是“bar”。

 

9.$(wordlist <s>,<e>,<text> )

名称：取单词串函数——wordlist。

功能：从字符串<text>中取从<s>开始到<e>的单词串。<s>和<e>是一个数字。

返回：返回字符串<text>中从<s>到<e>的单词字串。如果<s>比<text>中的单词数要大，

那么返回空字符串。如果<e>大于<text>的单词数，那么返回从<s>开始，到<text>结束

的单词串。

示例： $(wordlist 2, 3, foo bar baz)返回值是“bar baz”。

 

 

10. $(words <text> )

名称：单词个数统计函数——words。

功能：统计<text>中字符串中的单词个数。

返回：返回<text>中的单词数。

示例：$(words, foo bar baz)返回值是“3”。

备注：如果我们要取<text>中最后的一个单词，我们可以这样：$(word $(words

<text> ),<text> )。

 

 

11. $(firstword <text> )

名称：首单词函数——firstword。

功能：取字符串<text>中的第一个单词。

返回：返回字符串<text>的第一个单词。

示例：$(firstword foo bar)返回值是“foo”。

备注：这个函数可以用 word函数来实现：$(word 1,<text> )。

以上，是所有的字符串操作函数，如果搭配混合使用，可以完成比较复杂的功能。这里，

举一个现实中应用的例子。我们知道，make使用“VPATH”变量来指定“依赖文件”的搜索路

径。于是，我们可以利用这个搜索路径来指定编译器对头文件的搜索路径参数 CFLAGS，

如：

override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH)))

如果我们的“$(VPATH)” 值是“src:../headers” ，那么“$(patsubst

%,-I%,$(subst :, ,$(VPATH)))”将返回“-Isrc -I../headers”，这正是 cc或 gcc搜索头文件路径的

参数。

 

 

 

 

下面我们要介绍的函数主要是处理文件名的。每个函数的参数字符串都会被当做一个或

是一系列的文件名来对待。

 

1. $(dir <names...> )

名称：取目录函数——dir。

功能：从文件名序列<names>中取出目录部分。目录部分是指最后一个反斜杠（“/”）之

前的部分。如果没有反斜杠，那么返回“./”。

返回：返回文件名序列<names>的目录部分。

示例： $(dir src/foo.c hacks)返回值是“src/ ./”。

 

2. $(notdir <names...> )

名称：取文件函数——notdir。

功能：从文件名序列<names>中取出非目录部分。非目录部分是指最后一个反斜杠（“/”）

之后的部分。

返回：返回文件名序列<names>的非目录部分。

示例： $(notdir src/foo.c hacks)返回值是“foo.c hacks”。

 

3. $(suffix <names...> )

名称：取后缀函数——suffix。

功能：从文件名序列<names>中取出各个文件名的后缀。

返回：返回文件名序列<names>的后缀序列，如果文件没有后缀，则返回空字串。

示例：$(suffix src/foo.c src-1.0/bar.c hacks)返回值是“.c .c”。

 

4. $(basename <names...> )

名称：取前缀函数——basename。

功能：从文件名序列<names>中取出各个文件名的前缀部分。

返回：返回文件名序列<names>的前缀序列，如果文件没有前缀，则返回空字串。

示例：$(basename src/foo.c src-1.0/bar.c hacks)返回值是“src/foo src-1.0/bar hacks”。

 

5. $(addsuffix <suffix>,<names...> )

名称：加后缀函数——addsuffix。

功能：把后缀<suffix>加到<names>中的每个单词后面。

返回：返回加过后缀的文件名序列。

示例：$(addsuffix .c,foo bar)返回值是“foo.c bar.c”。

 

6. h$(addprefix <prefix>,<names...> )

名称：加前缀函数——addprefix。

功能：把前缀<prefix>加到<names>中的每个单词后面。

返回：返回加过前缀的文件名序列。

示例：$(addprefix src/,foo bar)返回值是“src/foo src/bar”。

 

 

7. $(join <list1>,<list2> )

名称：连接函数——join。

功能：把<list2>中的单词对应地加到<list1>的单词后面。如果<list1>的单词个数要比

<list2>的多，那么，<list1>中的多出来的单词将保持原样。如果<list2>的单词个数要比

<list1>多，那么，<list2>多出来的单词将被复制到<list2>中。

返回：返回连接过后的字符串。

示例：$(join aaa bbb , 111 222 333)返回值是“aaa111 bbb222 333”。

 

 

 

 

 

 

 

 

 

 

关键字：wildcard,vpath

变量：MAKELEVEL //如果make有嵌套执行动作，      这个变量将记录当前makefile的调用层数。

      VPATH //文件搜索路径

 

循环函数

 

1.foreach 函数

foreach函数和别的函数非常的不一样。因为这个函数是用来做循环用的，Makefile中

的 foreach函数几乎是仿照于 Unix标准 Shell（/bin/sh）中的 for语句，或是 C-Shell（/bin/csh）

中的 foreach语句而构建的。它的语法是：

$(foreach <var>,<list>,<text> )

这个函数的意思是，把参数<list>中的单词逐一取出放到参数<var>所指定的变量中，然

后再执行<text>所包含的表达式。每一次<text>会返回一个字符串，循环过程中，<text>的所

返回的每个字符串会以空格分隔，最后当整个循环结束时，<text>所返回的每个字符串所组

成的整个字符串（以空格分隔）将会是 foreach函数的返回值。

所以，<var>最好是一个变量名，<list>可以是一个表达式，而<text>中一般会使用<var>

这个参数来依次枚举<list>中的单词。举个例子：

names := a b c d

files := $(foreach n,$(names),$(n).o)

上面的例子中，$(name)中的单词会被挨个取出，并存到变量“n”中，“$(n).o”每次根据

“$(n)”计算出一个值，这些值以空格分隔，最后作为 foreach函数的返回，所以，$(files)的值

是“a.o b.o c.o d.o”。

注意，foreach中的<var>参数是一个临时的局部变量，foreach函数执行完后，参数<var>的变量将不在作用，其作用域只在 foreach函数当中。

 

 

 

条件控制函数

if 函数

if函数很像 GNU的 make所支持的条件语句——ifeq（参见前面所述的章节），if函数

的语法是：

$(if <condition>,<then-part> )

或是

$(if <condition>,<then-part>,<else-part> )

可见，if函数可以包含“else”部分，或是不含。即 if函数的参数可以是两个，也可以是

三个。<condition>参数是 if的表达式，如果其返回的为非空字符串，那么这个表达式就相当

于返回真，于是，<then-part>会被计算，否则<else-part>会被计算。

而 if函数的返回值是，如果<condition>为真（非空字符串），那个<then-part>会是整个

函数的返回值，如果<condition>为假（空字符串），那么<else-part>会是整个函数的返回值，

此时如果<else-part>没有被定义，那么，整个函数返回空字串。

所以，<then-part>和<else-part>只会有一个被计算。

 

其他：

 

call函数

call函数是唯一一个可以用来创建新的参数化的函数。你可以写一个非常复杂的表达

式，这个表达式中，你可以定义许多参数，然后你可以用 call函数来向这个表达式传递参数。

其语法是：

$(call <expression>,<parm1>,<parm2>,<parm3>...)

当 make执行这个函数时，<expression>参数中的变量，如$(1)，$(2)，$(3)等，会被参

数<parm1>，<parm2>，<parm3>依次取代。而<expression>的返回值就是 call函数的返回值。

例如：

reverse = $(1) $(2)

foo = $(call reverse,a,b)

那么，foo的值就是“a b”。当然，参数的次序是可以自定义的，不一定是顺序的，如：

reverse = $(2) $(1)

foo = $(call reverse,a,b)

此时的 foo的值就是“b a”。

 

origin函数

origin函数不像其它的函数，他并不操作变量的值，他只是告诉你你的这个变量是哪里

来的？其语法是：

$(origin <variable> )

注意，<variable>是变量的名字，不应该是引用。所以你最好不要在<variable>中使用“$”

字符。Origin函数会以其返回值来告诉你这个变量的“出生情况”，下面，是 origin函数的返

回值:

“undefined”

如果<variable>从来没有定义过，origin函数返回这个值“undefined”。

“default”

如果<variable>是一个默认的定义，比如“CC”这个变量，这种变量我们将在后面讲述。

“environment”

如果<variable>是一个环境变量，并且当 Makefile被执行时，“-e”参数没有被打开。

“file”

如果<variable>这个变量被定义在 Makefile中。

“command line”

如果<variable>这个变量是被命令行定义的。

“override”

如果<variable>是被 override指示符重新定义的。

“automatic”

如果<variable>是一个命令运行中的自动化变量。关于自动化变量将在后面讲述。

这些信息对于我们编写 Makefile是非常有用的，例如，假设我们有一个 Makefile其包

了一个定义文件 Make.def，在 Make.def中定义了一个变量“bletch”，而我们的环境中也有一

个环境变量“bletch”，此时，我们想判断一下，如果变量来源于环境，那么我们就把之重定

义了，如果来源于 Make.def或是命令行等非环境的，那么我们就不重新定义它。于是，在

我们的 Makefile中，我们可以这样写：

ifdef bletch

ifeq "$(origin bletch)" "environment"

bletch = barf, gag, etc.

endif

endif

当然，你也许会说，使用 override关键字不就可以重新定义环境中的变量了吗？为什么

需要使用这样的步骤？是的，我们用 override是可以达到这样的效果，可是 override过于粗

暴，它同时会把从命令行定义的变量也覆盖了，而我们只想重新定义环境传来的，而不想重

新定义命令行传来的。

 

 

shell函数

shell函数

shell函数也不像其它的函数。顾名思义，它的参数应该就是操作系统 Shell的命令。它

和反引号“`”是相同的功能。这就是说，shell函数把执行操作系统命令后的输出作为函数返

回。于是，我们可以用操作系统命令以及字符串处理命令 awk，sed等等命令来生成一个变

量，如：

contents := $(shell cat foo)

files := $(shell echo *.c)

注意，这个函数会新生成一个 Shell程序来执行命令，所以你要注意其运行性能，如果

你的 Makefile中有一些比较复杂的规则，并大量使用了这个函数，那么对于你的系统性能

是有害的。特别是 Makefile的隐晦的规则可能会让你的 shell函数执行的次数比你想像的多

得多。

 

控制make的函数

make提供了一些函数来控制 make的运行。通常，你需要检测一些运行 Makefile时的

运行时信息，并且根据这些信息来决定，你是让 make继续执行，还是停止。

$(error <text ...> )

产生一个致命的错误，<text ...>是错误信息。注意，error函数不会在一被使用就会产生

错误信息，所以如果你把其定义在某个变量中，并在后续的脚本中使用这个变量，那么也是

可以的。例如：

示例一：

ifdef ERROR_001

$(error error is $(ERROR_001))

endif

示例二：

ERR = $(error found an error!)

.PHONY: err

err: ; $(ERR)

示例一会在变量 ERROR_001定义了后执行时产生 error调用，而示例二则在目录 err

被执行时才发生 error调用。

$(warning <text ...> )

这个函数很像 error函数，只是它并不会让 make退出，只是输出一段警告信息，而 make

继续执行。

 

contents := $(shell cat foo

 

 

 

 

隐含规则：

因为.o有隐含的推导规则所以其目标，依赖，命令都可以不写。

.o的隐含规则：把[.o]的目标的依赖文件置成[.c]，并使用 C的编译命令“cc –c $(CFLAGS) [.c]”来生成[.o]的目标。

 

隐含规则列表：

。默认的后缀列表

是：.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。具体的细节，我们会在后面讲述。

 

可以用make -r来取消隐含规则的执行。

隐含规则会使用像（CFLAGS)这样的预定义变量，如果对这些变量值进行修改，就会影响到隐含规则。

可以用make -R来取消你定义的变量对隐含规则起作用。

 

关于命令的变量：

AR

函数库打包程序。默认命令是“ar”。

CC

C语言编译程序。默认命令是“cc”。

RM

删除文件命令。默认命令是“rm –f”。

关于命令参数的变量：

模式规则：

%.o:%.c

 

自动化变量：

所谓自动化变量，就是这种变量会把模式中所定义的一系列的文件自动地挨个取出，直至所有的符合模式的文件都取完了。这种自动化变量只应出现在规则的命令中。

下面是所有的自动化变量及其说明：

$@

表示规则中的目标文件集。在模式规则中，如果有多个目标，那么，"$@"就是匹配于

目标中模式定义的集合。

$%

仅当目标是函数库文件中，表示规则中的目标成员名。例如，如果一个目标是

"foo.a(bar.o)"，那么，"$%"就是"bar.o"，"$@"就是"foo.a"。如果目标不是函数库文件（Unix

下是[.a]，Windows下是[.lib]），那么，其值为空。

$<

依赖目标中的第一个目标名字。如果依赖目标是以模式（即"%

"）定义的，那么"$<"将

是符合模式的一系列的文件集。注意，其是一个一个取出来的。

$?

所有比目标新的依赖目标的集合。以空格分隔。

$^

所有的依赖目标的集合。以空格分隔。如果在依赖目标中有多个重复的，那个这个变量

会去除重复的依赖目标，只保留一份。

$+

这个变量很像"$^"，也是所有依赖目标的集合。只是它不去除重复的依赖目标。

$*

这个变量表示目标模式中"%"及其之前的部分。

 

在上述所列出来的自动量变量中。四个变量（$@、$<、$%、$*）在扩展时只会有一个

文件，而另三个的值是一个文件列表。

提醒一下的是，对于"$<"，为了避免产生不必要的麻烦，我们最好给$后面的那

个特定字符都加上圆括号，比如，"$(< )"就要比"$<"要好一些。

 

这七个自动化变量还可以取得文件的目录名或是在当前目录下的符合模式的文件名，只需要搭配上"D"或"F"字样

 

模式的匹配

一般来说，一个目标的模式有一个有前缀或是后缀的"%"，或是没有前后缀，直接就是

一个"%"。因为"%"代表一个或多个字符，所以在定义好了的模式中，我们把"%"所匹配的内

容叫做"茎"，例如"%.c"所匹配的文件"test.c"中"test"就是"茎"。因为在目标和依赖目标中同

时有"%"时，依赖目标的"茎"会传给目标，当做目标中的"茎"。

当一个模式匹配包含有斜杠（实际也不经常包含）的文件时，那么在进行模式匹配时，

目录部分会首先被移开，然后进行匹配，成功后，再把目录加回去。在进行"茎"的传递时，

我们需要知道这个步骤。例如有一个模式"e%t"，文件"src/eat"匹配于该模式，于是"src/a"就

是其"茎"，如果这个模式定义在依赖目标中，而被依赖于这个模式的目标中又有个模式

"c%r"，那么，目标就是"src/car"。（"茎"被传递）

 

 

使用make更新函数库

archive(member)

这个不是一个命令，而一个目标和依赖的定义。一般来说，这种用法基本上就是为了"ar"

命令来服务的。如：

foolib(hack.o) : hack.o

ar cr foolib hack.o

 

 

 

 

 

 

 

系统变量CFLAGS:控制编译时编译器参数

 

 

 

 

 

.PHONY防止目标名和文件名相同