Makefile 规范组织

1.Makefile规范

target ... : prerequisites ...
   command
   ...
   ...

  target 这 一 个 或 多 个 的 目 标 文 件 依 赖 于prerequisites 中 的 文 件 ， 其 生 成 规 则 定 义 在 command （任意的Shell命令）中 。command 是命令行，如果其不与“target:prerequisites”在一行，那么，必须以[Tab键]开头。
一个示例

 foo.o: foo.c defs.h       # foo模块
 cc -c -g foo.c

  a. 文件的依赖关系，foo.o依赖于foo.c和defs.h的文件，如果foo.c
和defs.h的文件日期要比foo.o文件日期要新，或是foo.o不存在，
那么依赖关系发生。

  b. 如果生成（或更新）foo.o文件。也就是那个cc命令，其说明了，
如何生成foo.o这个文件。（当然foo.c文件include了defs.h文件）

2.书写命令

  每条规则中的命令和操作系统 Shell 的命令行是一致的。 make 会一按顺序一条一条的执行命令，每条命令的开头必须以[Tab]键开头，从上下，从左到右，依次执行。
   如果你要让上一条命令的结果应用在下一条命令时，你应该使用分号分隔这两条命令。比如你的第一条命令是 cd 命令，你希望第二条命令得在 cd 之后的基础上运行，那么你就不能把这两条命令写在两行上，而应该把这两条命令写在一行上，用分号分隔。

     exec:
    cd /home/hchen; pwd

  当我们执行“make exec”时， pwd 会打印出“/home/hchen”。“#”是注释符，很像 C/C++中的“//”，其后的本行字符都被注释。

3.命令出错

  命令行前加一个减号“-”（在Tab 键之后），标记为不管命令出不出错都认为是成功的。如：

clean:
    -rm -f *.o

  例如 mkdir 命令，我们一定需要建立一个目录，如果目录不存在，那么 mkdir 就成功执行，万事大吉，如果目录存在，那么就出错了。我们之所以使用 mkdir 的意思就是一定要有这样的一个目录，于是我们就不希望 mkdir 出错而终止规则的运行。

4.嵌套执行 make

  我们有一个子目录叫 subdir，这个目录下有个 Makefile 文件，来指明了这个目录下文件的编译规则。那么我们总控的 Makefile 可以这样书写：

 subsystem:
         cd subdir && $(MAKE)

其等价于：

subsystem:
    $(MAKE) -C subdir     （-C是大写的C，小写的c编译出目标文件）

  定义$(MAKE)宏变量的意思是，也许我们的 make 需要一些参数，所以定义成一个变量比较利于维护。这两个例子的意思都是先进入“subdir”目录，然后执行 make 命令。

        MAKE=make  XXXX

  如果你要传递变量到下级 Makefile 中，那么你可以使用这样的声明：

       export <variable ...>

  如果你不想让某些变量传递到下级 Makefile 中，那么你可以这样声明：

    unexport <variable ...>

5.定义命令包

  如果 Makefile 中出现一些相同命令序列，那么我们可以为这些相同的命令序列定义一个变量。定义这种命令序列的语法以“define”开始，以“endef”结束，如：

define run-yacc
yacc $(firstword $^)
mv y.tab.c $@
endef

  把这个命令包放到一个示例中来看看吧。

foo.c : foo.y
    $(run-yacc)

  make 在执行命令包时，命令包中的每个命令会被依次独立执行。

6.使用变量

  a.使用“=”号，在“=”左侧是变量，右侧是变量的值

    foo = $(ugh)
    ugh = Huh?

  变量$(foo)的值是“Huh?”（$(foo)的值是$(bar)，变量是可以使用后面的变量来定义的。
  b.使用“:=”操作符
  前面的变量不能使用后面的变量，只能使用前面已定义好了的变量。如果是这样：

    y := $(x) bar
    x := foo

  那么， y 的值是“bar”，而不是“foo bar”
  c.使用“?=”操作符

        FOO ?= bar

  如果 FOO 没有被定义过，那么变量 FOO 的值就是“bar”，如果 FOO 先前被定义过，那么这条语将什么也不做，在使用时，需要给在变量名前加上“$”符号

7.变量高级用法

  第一种是变量值的替换可以替换变量中的共有的部分，其格式是“$(var:a=b)”或是“${var:a=b}”，其意思是，把变量“var”中所有以“a”字串“结尾”的“a”替换成“b”字串。这里的“结尾”意思是“空格”或是“结束符”。
还是看一个示例吧：

    foo := a.o b.o c.o
    bar := $(foo:.o=.c)  或者 bar := $(foo:%.o=%.c)

  这个示例中，我们先定义了一个“$(foo)”变量，而第二行的意思是把“$(foo)”中所有以“.o”字串“结尾”全部替换成“.c”，所以我们的“$(bar)”的值就是“a.c b.c c.c”。
  把变量的值再当成变量

x = y
y = z
a := $($(x))

  在这个例子中， $(x)的值是“y”，所以$($(x))就是$(y)，于是$(a)的值就是“z”。（注意，是“x=y”，而不是“x=$(y)”）
  追加变量值，我们可以使用“+=”操作符给变量追加值，如：

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

  于是，我们的$(objects)值变成： “main.o foo.o bar.o utils.o another.o”，如果变量之前没有定义过，那么，“+=”会自动变成“=”

8.override 指示符

  有变量是通常 make 的命令行参数设置的，那么 Makefile 中对这个变量的赋值会被忽略。如果你想在 Makefile 中设置这类参数的值，那么，你可以使用“override”指示符。
其语法是：

      override <variable> = <value>
      override <variable> := <value>

当然，你还可以追加：

      override <variable> += <more text>
    例如：
      @echo ARCH  #x86  
      override ARCH = arm

9.环境变量

  如果我们在环境变量中设置了“CFLAGS”环境变量，那么我们就可以在所有的Makefile 中使用这个变量了。
  当 make 嵌套调用时，上层 Makefile 中定义的变量会以系统环境变量的方式传递到下层的 Makefile 中。当然，默认情况下，只有通过命令行设置的变量会被传递。而定义在文件中的变量，如果要向下层 Makefile 传递，则需要使用export关键字来声明。

KBUILD_AFLAGS_MODULE  := -DMODULE
export KBUILD_AFLAGS_MODULE

10.目标变量或者局部变量

  其语法是：

<target ...> : <variable-assignment>
<target ...> : overide <variable-assignment>

  <variable-assignment>可以是前面讲过的各种赋值表达式，如“=”、“:=”、“+=”或是“?=”。第二个语法是针对于 make 命令行带入的变量，或是系统环境变量。

      prog : CFLAGS = -g
      prog : prog.o foo.o bar.o
      $(CC) $(CFLAGS) prog.o foo.o bar.o

  不管全局的$(CFLAGS)的值是什么，在 prog 目标，以及其所引发的所有规
则中（prog.o foo.o bar.o 的规则）， $(CFLAGS)的值都是“-g”

11.模式变量

  make 的“模式”一般是至少含有一个“%”的，所以，我们可以以如下方式给所有以[.o]结尾的目标定义目标变量：

          %.o : CFLAGS = -O

  同样，模式变量的语法和“目标变量”一样：

<pattern ...> : <variable-assignment>
<pattern ...> : override <variable-assignment>

  override 同样是针对于系统环境传入的变量，或是 make 命令行指定的变量.

12.自动变量 含义

  $* 不包含扩展名的目标文件名称
  这个变量表示目标模式中“%”及其之前的部分。如果目标是“dir/a.foo.b”，并且目标的模式是“a.%.b”，那么，“$”的值就是“dir/a.foo”。 如果目标是“foo.c”，因为“.c”是 make 所能识别的后缀名，所以，“$”的值就是“foo”。

  $+ 所有的依赖文件，以空格分开，并以出现的先后为序，可能包含重复的依赖文件。

  $< 第一个依赖文件的名称,依赖目标中的第一个目标名字。如果依赖目标是以模式
（即“%”）定义的，那么“$<”将是符合模式的一系列的文件集。注意，其是一个一个取出来的。

  $? 所有时间戳比目标文件晚的依赖文件，并以空格分开

  $@ 目标文件的完整名称,表示规则中的目标文件集。在模式规则中，如果有多个目标，那么，“$@”就是匹配于目标中模式定义的集合。

  $^ 所有不重复的依赖文件，以空格分开

  $% 仅当 目 标是函数库 文件中，表 示规则中的 目标成员名 。例如，如 果一个目标 是“foo.a(bar.o)”，那么，“$%”就是“bar.o”，“$@”就是“foo.a”。如果目标不是函数库文件（Unix 下是[.a]， Windows 下是[.lib]），那么，其值为空。

objects = foo.o bar.o
  all: $(objects)
  $(objects): %.o: %.c
  $(CC) -c $(CFLAGS) $< -o $@

  “%.o”表明要所有以“.o”结尾的目标，也就是“foo.o bar.o”，“%.c”则取模式“%.o”的“%”，也就是“foo bar”，并为其加下“.c”的后缀，所以依赖目标就是“foo.c bar.c”。
  “$<”表示所有的依赖目标集（也就是“foo.c bar.c”），“$@”表示目标集（也就是“foo.o bar.o”）

OBJS = kang.o yul.o
CC = gcc
CFLAGS =-Wall -O -g
david : $ (OBJS)
$(CC) $^ -o $@
kang.o : kang.c kang.h
$(CC) $(CFLAGS) -c $< -o $@
yul.o : yul.c yul.h
$(CC) $(CFLAGS) -c $< -o $@ 

$^：为$ (OBJS) ，既kang.o yul.o
$<: kang.c

% 与 * 区别

   “%”的意思是匹配零或若干字符,例如,“%.h”表示所有以“.h”结尾的文件.
它是在GUNmake的语法层次上的,例如 vpath %.h ../headers ,该语句表示,要求make在“../headers”目录下搜索所有以“.h”结尾的文件.
是Shell所支持的通配符,是在shell的语法层次上,.c,一般用在shell命令里面,如：

clean:
rm -f *.o

make 自己的变量

  环境变量， 比较重要的是PATH, PWD
cc 是 /usr/bin/cc -> /usr/bin/gcc
CXX 是 g++
INCLUDE_DIRS = /usr/include /usr/local/include /usr/include
MAKE_VERSION ＃make 版本
CURDIR ＃make 执行时的所在目录
MAKEFILE_LIST ＃make 用到的文件
MAKECMDGOALS ＃make的目标

13.使用条件判断

  下面的例子，判断$(CC)变量是否“gcc”，如果是的话，则使用 GNU 函数编译目标

 ifeq ($(CC),gcc)
    $(CC) -o foo $(objects) $(libs_for_gcc)
else
    $(CC) -o foo $(objects) $(normal_libs)
endif

其他条件关键字是ifneq。ifdef。ifndef

14.使用函数

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

$(<function> <arguments>)
或是
${<function> <arguments>}

  <function>就是函数名， make 支持的函数不多。 <arguments>是函数的参数，参数间以逗号“,”分隔，而函数名和参数之间以“空格”分隔。

字符串处理函数

    subst  patsubst strip findstring filter  filter-out sort  word wordlist 
words firstword

文件名操作函数

    dir notdir suffix basename addsuffix addprefix join

其他

    foreach  if  call  origin  shell  error

$(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”。

$(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.obar.o”

$(strip <string>)

名称：去空格函数——strip。
功能：去掉<string>字串中开头和结尾的空字符。

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

$(strip a b c )

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

$(findstring <find>,<in>)

名称：查找字符串函数——findstring。
功能：在字串<in>中查找<find>字串。

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

        $(findstring a,a b c)
        $(findstring a,b c)

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

$(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”。

$(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”。

$(sort <list>)

名称：排序函数——sort。
功能：给字符串<list>中的单词排序（升序）。

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

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

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

$(word <n>,<text>)

名称：取单词函数——word。
功能：取字符串<text>中第<n>个单词。（从一开始）

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

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

$(firstword <text>)

名称：首单词函数——firstword。
功能：取字符串<text>中的第一个单词。

返回：返回字符串<text>的第一个单词。
示例： $(firstword foo bar)返回值是“foo”。
备注：这个函数可以用 word 函数来实现： $(word 1,<text>)。
  以上，是所有的字符串操作函数，如果搭配混合使用，可以完成比较复杂的功能。这里，举一个现实中应用的例子。我们知道， make 使用“VPATH”变量来指定“依赖文件”的搜索路径。于是，我们可以利用这个搜索路径来指定编译器对头文件的搜索路径参数 CFLAGS，如：

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

  指定make命令查找的路径如 果 我 们 的 “$(VPATH) ” 值 是 “src:../headers ”， 那 么 “$(patsubst%,-I%,$(subst :, ,$(VPATH)))”将返回“-Isrc -I../headers”，这正是 cc 或gcc 搜索头文件路径的参数。

$(notdir <names...>)

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

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

$(notdir src/foo.c hacks)

返回值是“foo.c hacks”。

$(suffix <names...>)

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

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

 $(suffix src/foo.c src-1.0/bar.c hacks)

  返回值是“.c .c”

$(basename <names...>)

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

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

 $(basename src/foo.c src-1.0/bar.c hacks)

  返回值是“src/foo src-1.0/bar hacks”。

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

名称：加后缀函数——addsuffix。
功能：把后缀<suffix>加到<names>中的每个单词后面。
返回：返回加过后缀的文件名序列。
示例：

$(addsuffix .c,foo bar)

  返回值是“foo.c bar.c”

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

名称：加前缀函数——addprefix。
功能：把前缀<prefix>加到<names>中的每个单词后面。
返回：返回加过前缀的文件名序列。
示例：

$(addprefix src/,foo bar)

  返回值是“src/foo src/bar”

$(join <list1>,<list2>)

名称：连接函数——join。
功能：把<list2>中的单词对应地加到<list1>的单词后面。如果<list1>的单词个数要比<list2>的多，那么， <list1>中的多出来的单词将保持原样。如果<list2>的单词个数要比<list1>多，那么， <list2>多出来的单词将被复制到<list2>中。

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

 $(join aaa bbb , 111 222 333)

  返回值是“aaa111 bbb222 333”。

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

  把参数<list>中的单词逐一取出放到参数<var>所指定的变量中，然后再执行<text>所包含的表达式。每一次<text>会返回一个字符串，循环过程中， <text>的所返回的每个字符串会以空格分隔，最后当整个循环结束时， <text>所返回的每个字符串所组成的整个字符串（以空格分隔）将会是 foreach 函数的返回值。

     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”。

$(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>没有被定义，那么，整个函数返回空字串。

$(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 <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 其包了一个定义文件 Make.def，在 Make.def 中定义了一个变量“bletch”，而我们的环境中也有一个环境变量“bletch”，此时，我们想判断一下，如果变量来源于环境。

    ifdef bletch
        ifeq "$(origin bletch)" "environment"
            bletch = barf, gag, etc.
        endif
    endif

shell 函数

  shell 函数也不像其它的函数。顾名思义，它的参数应该就是操作系统 Shell 的命令。它和反引号“`”是相同的功能。这就是说， shell 函数把执行操作系统命令后的输出作为函数返回。于是，我们可以用操作系统命令以及字符串处理命令 awk， sed 等等命令来生成一个变量，如：

    files := $(shell echo *.c)

$(error <text ...>)

  产生一个致命的错误， <text ...>是错误信息。

$(warning <text ...>)

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

15.指定 Makefile

  我们也可以给 make 命令指定一个特殊名字的 Makefile。要达到这个功能，我们要使用 make 的“-f”或是“--file”参数（“--makefile”参数也行）。例

            make -f huang.mk

16.指定目标

  一般来说， make 的最终目标是 makefile 中的第一个目标，而其它目标一般是由这个目标连带出来的。这是 make 的默认行为。当然，一般来说，你的 makefile 中的第一个目标是由许多个目标组成，你可以指示 make，让其完成你所指定的目标。要达到这一目的很简单，需在 make 命令后直接跟目标的名字就可以完成（如前面提到的“make clean”形式）。
   任何在 makefile 中的目标都可以被指定成终极目标，但是除了以“-”打头，或是包含了“=”的目标，因为有这些字符的目标，会被解析成命令行参数或是变量。甚至没有被我们明确写出来的目标也可以成为 make 的终极目标，也就是说，只要 make 可以找到其隐含规则推导规则，那么这个隐含目标同样可以被指定成终极目标。
例如下面这个例子：

    .PHONY: all
    all: prog1 prog2 prog3 prog4

  从这个例子中，我们可以看到，这个 makefile 中有四个需要编译的程序——“prog1”，“prog2”， “prog3”和 “prog4”，我们可以使用“make all”命令来编译所有的目标（如果把 all 置成第一个目标，那么只需执行“make”），我们也可以使用“make prog2”来单独编译目标“prog2”。

17.检查规则

-B
--always-make

  认为所有的目标都需要更新（重编译）。

-C <dir>
--directory=<dir>

  指定读取 makefile 的目录。如果有多个“-C”参数， make 的解释是后面的路径以前面的作为相对路径，并以最后的目录作为被指定目录。如：

make –C ~hchen/test –C prog

-debug[=<options>]

  输出 make 的调试信息。

-a

  也就是 all，输出所有的调试信息。（会非常的多）

-b 

  也就是 basic，只输出简单的调试信息。即输出不需要重编译的目标。

-v 

  也就是 verbose，在 b 选项的级别之上。输出的信息包括哪个 makefile 被解析，不需要被重编译的依赖文件（或是依赖目标）等。

-i 

  也就是 implicit，输出所以的隐含规则。

-m 

  也就是 makefile，输出 make 读取 makefile，更新 makefile，执行makefile 的信息。

-d

  相当于“--debug=a”。

-e
--environment-overrides

  指明环境变量的值覆盖 makefile 中定义的变量的值。

-f=<file>
--file=<file>
--makefile=<file>

  指定需要执行的 makefile。

-h
--help

  显示帮助信息。

--ignore-errors

  在执行时忽略所有的错误。

-I <dir>
--include-dir=<dir>

  指定一个被包含 makefile 的搜索目标。可以使用多个“-I”参数来指定多个目录。

-j [<jobsnum>]
--jobs[=<jobsnum>]

  指同时运行命令的个数。如果没有这个参数， make 运行命令时能运行多少就运行多少。如果有一个以上的“-j”参数，那么仅最后一个“-j”才是有效的。（注意这个参数在 MS-DOS中是无用的）

-k
--keep-going

  出错也不停止运行。如果生成一个目标失败了，那么依赖于其上的目标就不会被执行。

-n
--just-print
--dry-run
--recon

  仅输出执行过程中的命令序列，但并不执行。

-o <file>
--old-file=<file>
--assume-old=<file>

  不重新生成的指定的<file>，即使这个目标的依赖文件新于它。

-q
--question

  不运行命令，也不输出。仅仅是检查所指定的目标是否需要更新。如果是 0 则说明要更新，如果是 2 则说明有错误发生。

-p
--print-data-base

  输出makefile 中的所有数据，包括所有的规则和变量。这个参数会让一个简单的makefile都会输出一堆信息。如果你只是想输出信息而不想执行 makefile，你可以使用“make -qp”命令。如果你想查看执行 makefile 前的预设变量和规则，
  你可以使用“make –p –f/dev/null”。这个参数输出的信息会包含着你的 makefile 文件的文件名和行号，所以，用这个参数来调试你的 makefile 会是很有用的，特别是当你的环境变量很复杂的时候。

-r
--no-builtin-rules

  禁止 make 使用任何隐含规则。

-R
--no-builtin-variabes

  禁止 make 使用任何作用于变量上的隐含规则。

-s
--silent
--quiet

  在命令运行时不输出命令的输出。

-S
--no-keep-going
--stop

  取消“-k”选项的作用。因为有些时候， make 的选项是从环境变量“MAKEFLAGS”中继承下来的。所以你可以在命令行中使用这个参数来让环境变量中的“-k”选项失效。

-t
--touch

  相当于 UNIX 的 touch 命令，只是把目标的修改日期变成最新的，也就是阻止生成目标的命令运行。

-v
--version

  输出 make 程序的版本、版权等关于 make 的信息。

-w
--print-directory

  输出运行 makefile 之前和之后的信息。这个参数对于跟踪嵌套式调用 make 时很有用。

--no-print-directory
    禁止“-w”选项。
-W <file>
--what-if=<file>
--new-file=<file>
--assume-file=<file>

  假定目标<file>需要更新，如果和“-n”选项使用，那么这个参数会输出该目标更新时的运行动作。如果没有“-n”那么就像运行 UNIX 的“touch”命令一样，使得<file>的修改时间为当前时间。

--warn-undefined-variables

  只要 make 发现有未定义的变量，那么就输出警告信息

18.隐含规则

  “隐含规则”也就是一种惯例， make 会按照这种“惯例”心照不喧地来运行，那怕我们的Makefile 中没有书写这样的规则。例如，把[.c]文件编译成[.o]文件这一规则，你根本就不用写出来， make 会自动推导出这种规则，并生成我们需要的[.o]文件。
  我们还可以通过“模式规则”的方式写下自己的隐含规则。用“后缀规则”来定义隐含规则会有许多的限制。
例如，我们有下面的一个 Makefile：

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

  因为 make 的“隐含规则”功能会自动为我们自动去推导这两个目标的依赖目标和生成命令。如果找不到，那么就会报错。
  完全没有必要写下下面的两条规则：

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

编译 C 程序的隐含规则。

   “<n>.o”的目标的依赖目标会自动推导为“<n>.c”，并且其生成命令是“$(CC) –c $(CPPFLAGS) $(CFLAGS)”

编译 C++程序的隐含规则。

   “<n>.o”的目标的依赖目标会自动推导为“<n>.cc”或是“<n>.C”，并且其生成命令是“$(CXX) –c $(CPPFLAGS) $(CFLAGS)”。（建议使用“.cc”作为 C++源文件的后缀，而不是“.C”）

汇编和汇编预处理的隐含规则。

  “<n>.o” 的目标的依赖目标会自动推导为“<n>.s”，默认使用编译品“as”，并且其生成命令是：“$(AS) $(ASFLAGS)”。“<n>.s” 的目标的依赖目标会自动推导为“<n>.S”，默认使用 C 预编译器“cpp”，并且其生成命令是：“$(AS) $(ASFLAGS)”。

链接 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）相关联，那么，你最好写出自己的生成规则，不然，隐含规则会报错的。

19.关于命令参数的变量

ARFLAGS 函数库打包程序 AR 命令的参数。默认值是“rv”。
ASFLAGS 汇编语言编译器参数。（当明显地调用“.s”或“.S”文件时）。
CFLAGS C 语言编译器参数。
CXXFLAGS C++语言编译器参数。
CPPFLAGS C 预处理器参数。（C 和 Fortran 编译器也会用到）。

LDFLAGS 连接器参数（如“ld”）

20.模式规则介绍

   模式规则中，至少在规则的目标定义中要包含“%”，否则，就是一般的规则。目标中的“%”定义表示对文件名的匹配，“%”表示长度任意的非空字符串。例如：“%.c”表示以“.c”结尾的文件名（文件名的长度至少为 3），而“s.%.c”则表示以“s.”开头，“.c”结尾的文件名（文件名的长度至少为 5）。
如果“%”定义在目标中，那么，目标中的“%”的值决定了依赖目标中的“%”的值，也就是说，目标中的模式的“%”决定了依赖目标中“%”的样子。例如有一个模式规则如下：

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

  其含义是，指出了怎么从所有的[.c]文件生成相应的[.o]文件的规则。如果要生成的目标是“a.o b.o”，那么“%c”就是“a.c b.c”。