规则:

目标 : 依赖

        命令

make是如何工作的:

    (1)make在当前目录下寻找makefile或Makefile。 

   (2)如果找到，他会寻找文件中的第一个目标文件(target)，并把这个文件作为第一个目标。

   (3)如果目标文件不存在，或者目标文件所依赖的.o文件修改时间要比目标文件新，那么，就会执行后面所定义的命令来生成目标文件。

   (4)如果目标文件所以依赖的.o文件也存在，那么make会在当前文件中寻找目标为.o文件所依赖性，如果找到则再根据这一规则生成.o文件。(这有些像堆栈的过程。)

   (5)于是make生成.o文件，然后再用.o文件生成make的终极目标。

   这就是make的依赖性，make会一层又一层的去找文件的依赖关系，直到最终编译出第一个目标文件。在寻找的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make就会直接退出，并报错，而对于所定义的命令的错误，或者编译不成功，make根本就不理会。make只会管文件的依赖性。

   所以，像clean那样，没有被第一个目标文件直接或者间接关联，那么他后面所定义的命令就不会被自动执行，不过，我们可以显式的要make执行---make clean

Makefile的 组成:

    (1)显示规则

        说明如何生成一个或多个目标文件，需要作者明确指出要生成的文件、文件的依赖文件，生成的命令。

    (2)隐晦规则

        因为make有自动推到功能，所以隐晦的规则可以让我们比较粗糙简略的书写Makefile。

    (3)变量的定义

        Makefile中我们需要定义一些变量，变量一般都是字符串。这个有点像C语言中的宏，当Makefile被执行时，变量会自动扩展到相应的引用位置。

    (4)文件指示

        包含三部分:

            a.在一个Makefile中引用另一个Makefile，像C语言中的include。

            b.根据某些情况制定Makefile中的有小部分，像C语言中的预编译#if。

            c.定义一个多行的命令

    (5)注释

        Makefile中只有行注释，用#字符，如果在Makefile要使用#，则使用反斜杠进行转义，例如"\#" 。

GNU的make工作步骤:(其他的make类似)

    (1)读入所有的Makefile

    (2)读入被include的其他Makefile

    (3)初始化文件中的变量

    (4)推导隐晦规则，并分析所有规则

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

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

    (7)执行生成命令

    其中1~5属于第一阶段，6~7属于第二阶段。第一阶段中，如果定义的变量被使用，那么make会把其展开在使用的位置上，但make并不会立刻展开，make使用的是拖延战术，如果变量出现在依赖关系的规则中，那么仅当这条依赖被决定要使用了，变量才会在其内部展开。

在规则中使用通配符:

如果想定义一系列比较类似的文件，则通配符是较好的选择。make支持的通配符有三种。

    (1) * 

        例如*.c表示后缀为c的文件，需要注意的是，如果文件名中有通配符，如*，则可以使用转义字符\*来表示真实的*字符。

    (2) ？ 

    (3) [..]

文件搜索:

    大的工程中，有大量的源文件，我们通常的做法是把这些源文件分类，病存放在不同的目录中。所以，当make需要去找文件的依赖关系式，可以再文件前加上路径名，但有一个最好的方法就是把一个路径告诉make，让make自己去找。

    Makefile中的特殊变量VPATH就是完成这任务的，如果没有知名这个变量，make只会在当前的目录中寻找依赖关系和目标文件。如果定义了这个变量，那么make就会在当前目录找不到的情况下，去指定的目录去寻找文件了。

            VPATH = src:../headers

    指明了两个目录，src和../headers，make会按照这个顺序去搜索。目录“冒号”分开(但是，当前目录永远都是最高优先搜索的地方)。

    另外一个设置文件搜索路径的方法就是使用make的关键字vpath(注意是小写)，这个不是变量，这是一个make关键字，这和上面的VPATH变量类似，但是它更加灵活，他可以指定不同的文件在不同的搜索目录中。这是一个灵活的功能，使用方法由三种:

    (1)vpath  <pattern>  <directories>

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

    (2)vpath <pattern>

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

    (3)vpath

        清除所有被设置好了的文件搜素目录。

    vpath是哦那个方法中的pattern需要包含%字符。%字符意思是匹配零或者若干字符，例如，%.h表示所有以.h结尾的文件。<pattern>指定了要搜素的文件集，而<directories>则指定了<pattern>的文件的搜索目录。

    例如:vpath %.h    ../headers表示make在../headers目录下搜索所有的.h结尾的文件。(如果某些文件在当前目录没有找到的话)

伪目标:

一般的Makefile最后的"clean"的目标，就是一个伪目标。

    像前面所说的那样，既然我们生成了许多编译文件，我们也需要一个清楚他们的“目标”以备完整的重新编译而用。

我们并不是生成"clean"这个文件。“伪目标”并不是一个文件，只是一个标签，由于“伪目标”不是文件，所以make无法为生产它的依赖关系和决定它是否要执行，我们只有通过显式的指明需要生成这个目标，才会使其生效。当然，“伪目标”的取名不能和文件名重名，不然其就失去了“伪目标”的意义。

    当然，为了更好的避免和文件重名，我们一般使用一个特殊的标记".PHONY"来指明一个目标是“伪目标”，向make说明，不论是否有这个文件，这个目标就是“伪目标”

静态模式:

静态模式可以更加容易定义多目标的规则。语法为:

    target定义了一系列的目标文件，可以有通配符。是一个目标的集合。

    target-pattern是指明了targets的模式，也就是目标集模式。

    prereq-patterns是目标文件的依赖模式，它对target-pattern形成的模式在进行一次依赖目标的定义。例如:<target-pattern>定义成%.c，意思是我们的<target>集合中都是以".o"结尾的，二如果我们的<prereq-patterns>定义成为"%.c"，意思是对<target-pattern>所形成的目标集进行二次定义，其计算方法是:取<target-pattern>模式的"%“(也就是去掉[.o]这个结尾)，并为其加上[.c]这个结尾，形成新的集合。

    所以，”目标模式“或是”依赖模式“都可以有"%"这个字符，如果文件名中有"%",那么可以使用"\%"表示。

例如:

    指明了我们的目标从$(objects)中获取，"%.o”表明要所有以".o"结尾的目标，也就是"foo.o bar.o"，也就是变量$object集合的模式，而依赖模式"%.c"则驱魔师"%.o"的"%"，也就是"foo bar "，并为其加上".c"后缀，于是，我们的依赖目标就是"foo.c bar.c"。而命令中的"$<"和"$@"都是自动化变量。"S<"表示所有的依赖目标集(也就是"foo.c  bar.c")，"$@"则表示目标集(也就是"foo.o  bar.o")。

    于是上面的规则展开后就是:

如果"%.o"有几百个，那么这种简单的"静态模式规则"可以写完一大堆的规则，效率很高。

命令出错:

    每当命令运行完后，make会检查每一个命令的返回码，如果命令返回成功，那么make会执行下一条命令，如果一个规则中的某一个命令错了(命令退出码非零)，那么make就会终止当前的规则，将有可能终止所有的规则的执行。

    有时候，命令的出错并不代表就是错误的，例如mkdir，如果当前目录不存在需要创建的文件，就会成功执行，但是如果，当前目录中有一个这样的同名文件，那么就会出错二终止规则的运行。为了忽略出错，我们可以再Makefile的命令行前面加一个减号“-”(在TAB键之后)，标记为不管命令是否出错都认为是成功的。

例如:

下面定义一个变量，其值为空格:

nullstring是一个Empty变量，其中什么也没有，而我们的space的值是一个空格，因为在操作符右边很难描述一个空格，这里采用的技术很管用，先用一个Empty变量来标明变量的值开始了，而后采用“#”注释符来表明变量的定义的终止。这样，我们就可以定义出其值为空格的变量。

显式命令:

    通常，make会把要执行的命令显示在屏幕，当使用"@"字符在命令行前，那么这个命令就不会别显式出来。

    例如:

       echo 正在编译这个模块...

    执行效果为，屏幕显示:

        echo 正在编译这个模块...

        正在编译这个模块...

    但，使用"@，屏幕显示:

        正在编译这个模块...

命令执行:

要注意，需要在上一条命令的结果需要作用于下一条命令，应该使用分好隔离这两条命令。例如:

而使用"；"，即:

其中，执行make exec时，第一个例子中的cd没有作用，pwd会打印出当前Makefile的目录，而第二个cd 就会起作用，pwd会打印出"/home/yangrui/study"

定义命令包:

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

    例如:

这里的run-yacd就是这个命令报的名字，其不可以和Makfile中的变量重名。(类似于C语言的函数)

变量:

    (1)变量基础

        变量在声明时需要赋初值，而在使用时需要在变量名之前加上"$"，但最好用()或者{}包括起来，若需要使用真正的‘$‘字符，则需要使用“$$"。

        例如:

        变量会在使用的地方展开，像c/c++中的宏。

        例如: 

        展开后成为:

                        (但是一般不会像这样去做)

    (2)变量中的变量

        定义变量时，还可以使用其他变量来够着变量的值。在Makefile中有两种定义变量值得方法:

            <1>使用"="

                "=“左边是变量，右边是其他变量，且右侧的其他变量也试试文件中的任何一处，也就是说，右侧的值不一定是已经定义好的值 ，也可以使用后面定义的值。

                例如: 

                则使用make all时，结果为"Huh?"

                这种方法有好处也有坏处，比如递归定义时:

                这样，会让make嵌入无限的变量展开过程中去，当然，make是有能力检查这种错误并报错的，但是效率太低。

        <2>使用":="

            这种方法中变量的值不能使用后面的变量，只能使用前面已经定义好的变量。

            例如: 

            则，y的值为”bar“，而不是”foo  bar“.

            技巧:如何定义一个值为空格的变量

            nullstring是一个Empty变量，其中什么都没有，而我们space值为空格，因为在操作符右边很难去描述一个空格，这里的技术很管用，先使用一个Empty的变量来表明变量的开始，而后面采用"#"注释来表明变量定义的终止，这样，我们就可以定义出一个值为空格的变量。

    (3)变量的高级用法

        <1>变量值的替换

            a.可以替换变量中共有的部分。格式为

                $(var:a=b) 或者 ${var:a=b}

            意思是吧变量"var"中所有以"a"字符结“结尾”的“a"全部替换为“b”字串。这里“结尾”的意思是“空格”或者“结束符”。

            例如:

        这时候$(bar)的值就是“a.c  b.c  c.c”

        b.另外一种变量替换的技术以"静态模式"定义。

        例如:

        这个例子让$(bar)变量的值为"a.c b.c c.c"。

    <2>把变量的值在当变量

        例如:

        这里,$(a)的值就是"z"。

        这种方式中，还可以使用多个变量组成一个变量的名字，然后取值:

        例如:

        这里，$(all)就是"hello"。

追加变量值:

    可以使用"+="操作符给变量追加值。

override指示符:

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

                override <variable> = <value>

                override <variable> := <value>

当然，还可以追加:

                override <variable> +=<more text>

对于多行的命令符，我们使用define指示符，在define指示符前，也同样可以使用override指示符，例如:

多行变量:

    使用define关键字设置变量的值可以换行，这有利于一系列的命令(前面的"命令包"就利用这种关键字)。

define指示符后面跟的是变量的名字，重起一行是变量的值，定义以endef关键字结束。工作方式和"="相同。例如:

环境变量:

    make运行时的系统环境变量可以再make开始运行时被载入到Makefile中，但是如果Makefile中已经定义了这个变量，或者这个变量由make命令带入，那么系统的环境变量的值就会被覆盖。(如果make指定了"-e"参数，那么系统环境变量将会覆盖Makefile中定义的变量)。

    因此，如果我们在环境变量中设置了"CFLAGS"环境变量，那么我们就可以在所有的Makefile中使用这个变量了。这对于我们使用统一的编译参数有较大的好处。如果Makefile中定义了CFLAGS，那么则会使用Makfile中的变量，如果没有定义则使用系统环境变量的值，一个共性和个性的统一，像"全局变量"和"局部变量"的特性。

    当make嵌套使用时，上层的Makfile定义的变量会以系统环境变量的方式传递到下层的Makefile中。当然，在默认情况下，只有通过命令行设置的变量才会被传递。而定义在文件中的变量，如果要向下层Makefile传递，则需要使用export关键字。

注意:不建议把环境变量定义在系统环境中。

目标变量:

    前面所说的都是"全局变量"，在整个文件中，我们都可以访问这些变量。当然"自动化变量"除外，如"$<"这种自动化变量就属于"规则性变量"，这种变量的值依赖于规则的目标和依赖目标的定义。当然，也可以为某个目标设置局部变量，这种变量被称为"Target-specific Variable".他可以和全局变量同名，因为他的作用于就是这个规则以及连带的规则，所以只在作用范围内有效，而不会影响到规则链以外的全局变量的值。语法是:

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

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

    <variable-assignment>可以使前面提到的各种赋值表达式，如"="、":="、"+="或者"?="。第二个语法是针对make命令带入的变量，或者是系统环境变量。这个特性非常有用，当我们设置这样一个变量，这个变量会作用到由这个目标引发的所有的规则中去。

例如:

这个例子中，不管全局的"CFLAGS"值是什么，在prog目标，以及其所引发的所有规则中(prog.o  foo.o  bar.o 的规则中)，$(CFLAGS)的值都是"-g"。

模式变量:

    在GNU的make中，还支持模式变量(Pattern-specific  Variable)，通过上面的目标变量，我们知道，变量还可以定义在目标上。模式变量的好处是:我们可以定义一种"模式"，然后把变量定义在符合这种模式的所有目标上。

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

                %.o : CFLAGS -o 

同样的，模式变量的语法和"目标变量"一样:

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

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

overirde同样是针对系统环境传入的变量，或者make命令行指定的变量。

使用条件判断:

例如:

含义:判断是否使用"gcc"，如果是，则使用"GUN"函数编译目标。

上面的例子中有三个关键字:ifeq  else   endif 。

上面的例子还可以写的更加简洁些:

语法:

    <1>

        <condiitonal-directive>

        <text-if-true>

        endif

    <2>

        <condiitonal-directive>

        <text-if-true>

        else

        <text-if-false>

        endif

    这里的<condiitonal-directive>表示关键字共有四个:

    <1>关键字ifeq

        ifeq   (<arg1> , <arg2>)

        ifeq   ‘<arg1>’ , ‘<arg2>‘

        ifeq   ”<arg1>“ , "<arg2>"

        ifeq   "<arg1>" , ‘<arg2>‘

        ifeq   ‘<arg1>‘ , "<arg2>"

    <2>关键字ifneq

        ifneq   (<arg1> , <arg2>)

        ifneq   ‘<arg1>’ , ‘<arg2>‘

        ifneq   ”<arg1>“ , "<arg2>"

        ifneq   "<arg1>" , ‘<arg2>‘

        ifneq   ‘<arg1>‘ , "<arg2>"

    <3>关键字ifdef

    <4>关键字ifndef

    其中，<condiitonal-directive>这一行，多余的空格是允许的，但是不能以[TAB]作为开始，否则就会被认为是命令。

    注意:make实在读取Makefile时就会计算条件表达式的值，并根据表达式的值来选择语句。所以，你最好不要把自动化变量(如"$@"等)放入条件表达式，因为自动化变量是在运行时才有的。

使用函数:

    (1)函数的调用语法

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

    这里，<function>就是函数名，make支持的函数不多.<arguments>就是函数的参数，参数间以逗号","分隔，而函数名和参数之间以“空格”分隔。函数调用以"$"开头。

    (2)字符串处理函数

        <1>subst

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

            名称:字符串替换函数----subst

            功能:把字符串<text>中的<from>字符串替换为<to>

            返回:函数返回替换过来的字符串

            例子:

            返回的结果就是"fEEt  on  the strEEt"

        <2>patsubst

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

            名称:模式字符串替换函数----patsubst

            功能:查找<text>中的单词(单词以“空格”、“TAB”或者“回车”、“换行”分隔)是否符合模式<pattern>，如果匹配，则以<replacement>替换。这里的<pattern>可以使通配符"%"，表示任意长度的字串，如果<replacement>中冶包含"%",那么，<replacement>中的这个"%"将是<pattern>里的"%"所代表的字串。(也可以使用"‘\"来转义，用"\%"表示)。

            返回:被替代过后的字符串。

            例子:

            返回结果是:"x.c.o  bar.o"

            这个前面提到的“变量”章节有关知识很相似:

                $(var:<pattern> = <replacement>)

            相当于:

                $(patsubst  <pattern>, <replacement> ,$(var))

        <3>strip

                $(strip <string>)

                名称:去空格函数----strip

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

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

                例子:

                返回结果是:"a b c"

        <4>findstring

                $(findstring <find>,<in>)

                名称:在字串<in>中查找<find>字串。

                例子:

                返回结果，第一个返回"a"字符串，第二个返回“”字符串(空字符)。

        <5>filter

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

                名称:过滤函数----filter

                功能:以<pattern>模式过滤<text>字符串的单词，保留符合模式<pattern>的单词。可以有多个模式。

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

                例子:

                则,$(filter  %.c  %.s ,$(sources))返回的值是"foo.c   bar.c  baz.s"

        <6>filter-out

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

                名称:反过滤函数----filter-out

                功能:以<pattern>模式过滤<teext>字串中的单词，去除符合模式<pattern>的单词，可以有多个模式。

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

                例子:

                则返回值为"foo.o  bar.o"

        <7>sort

                $(sort<list>)

                名称:排序函数----sort

                功能:给字符串<list>中的单词排序(升序)

                返回:排序后的字符串

                例子:

                返回结果为: "bar  foo  lose"

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

    <8>word

                $(word  <n>,<text>)

                名称:取单词函数----word

                功能:取字符串<text>中第n个单词。(从第一个开始)

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

                例子：

                返回:"bar"

    <9>wordlist

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

                名称：取单词函数----worklist

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

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

                例子：

                返回："bar  baz"

    <10>works

                $(words <text>)

                名称：单词个数统计函数----words

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

                返回：<text>中的单词数

                例子：

                返回值是"3".

                备注：如果我们要提取<text>最后一个单词，可以这样：

                                $(word $(words<text>),<text>)

    <11>firstword

                $(firstword <text>)

                名称：首单词函数----firstword

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

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

                例子：

                返回值："foo"。

                备注：这个函数还可以用word实现：

                                $(word  1,<text>)

文件名操作函数：

    <1>dir

                $(dir  <names...>)

                名称：取目录函数----dir 

                功能：从文件名序列<name>中取出目录部分。目录部分是值最后一个反斜杠"/"之前的部分，如果没有反斜杠，就返回"./"。

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

                例子：

                返回值："src/   ./"

    <2>notdir

                $(notdir  <names...>)  

                名称：取文件函数----notdir

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

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

                例子：

                返回："foo.c  hacks"

    <3>suffix

                $(suffix <names>)

                名称：取后缀函数----suffix

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

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

                例子:

                返回值：".c  .c "

    <4>basename

                $(basename <names...>)

                名称：取前缀函数----basename

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

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

                例子：

                返回值："src/foo   src-1.0/bar  hacks"。

    <5>addsuffix

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

                名称：加前缀函数----addsuffix 

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

                例子：

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

    <6>addprefix

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

                名称：加前缀函数----addprefix

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

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

                例子：

                返回:"src/foo  src/bar "

    <7>join

                $(join  <list1> , <list2>)

                名称：连接函数

                功能：把<list2>中的单词对应的加入到<list1>的单词的后面。如果<list1>的单词比<list2>要多，那么<list1>中多出来的单词将保持原样。如果<list2>的单词比<list1>多，则<list2>多出来的单词将会被复制到<list2>中。

例子：

                返回："aaa111 bbb222  333"

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>中的单词。

例子：

则files的值为"a.o  b.o  c.o  d.o"

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

if函数：

    if函数非常像GNU的make所支持的条件语句----ifeq，其语法是：

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

或者：

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

返回值：如果<condition>为真，(非空字符串)，那么<then-part>会是整个函数的返回值。如果<condition>位假，(空字符串)，那么<else-part>会是整个函数的返回值，此时如果<else-part>没有被定义，则整个函数返回空字串。

call函数：

    call函数是唯一一个可以用来创建新的参数化的函数。可以写一个复杂的表达式，在表达式中，可以定义很多参数，然后你可以用call函数向这个表达式传递参数，语法：

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

    当make执行这个函数时，<expression>参数中的变量，如$(1),$(2),$(3)等，会被参数<的返回值就是call函数的返回值。

例子：

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

例子：

那么，foo的值就是"b  a"。

origin函数：

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

                $(origin <variable>)

    注意：<variable>是变量的名字，不应该是引用。最好不要在<variable>中使用"$"字符。origin会以返回值的方式告诉你这个变量的"出生情况"，有一下情况：

    (1)“undefined”

        就是未定义的变量。

    (2)“default”

        变量<variable>是一个默认的值，比如"CC"这个变量。

    (3)"file"

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

    (4)"command line"

        如果变量<variable>被命令行定义。

    (5)“override”

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

    (6)“automatic”

        如果<variable>是一个命令运行中的自动变量。

shell函数：

    shell函数不像其他函数。他的参数是操作系统的Shell命令，它和反引号" ‘ "是相同的功能。

例子：

    注意，这个函数会生成另一个shell程序执行命令，所以必须注意其运行性能，如果你的Makefile中有一个复杂的规则，并大量利用了这个函数，那么对你的系统是有害的。特别是Makefile的隐晦规则可能让你的shell函数执行次数比你想象的要多。

控制Makefile的函数：

    make提供了一下函数控制make的运行，通常，你需要检测一些运行Makefile时的运行信息，并且根据这个信息来决定，你是让make继续执行，还是停止。

    (1)error

                $(error <text.....>)

    产生一个致命错误，<text...>是错误信息。注意，error函数不会在一被使用就产生错误信息，所以如果你把其定义在某个变量中，并在后续脚本中使用了这个变量，那么，可以这样：

范例一：

范例二：

    （2）warning

                $(warning  <text...>)

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

make的运行：

    （1）make的退出码(三个)：

                0 - 表示成功执行

                1 - 如果make运行时出现任何错误，其返回1。

                2 - 如果你使用了make的"-q"选项，并且make使得一些目标不需要更新，那么返回2。

    (2)执行Makefile

        前面提到，GNU  make默认寻找的Makefile的规则是在当前目录下依次寻找三个文件——"GUNmakefile"、"makefile"、"Makefile"。按照顺序寻找三个文件，一旦找到，就开始读取这个文件并执行。

当前，我们也可以给make命令制定一个特殊的名字Makefile。要达到这样效果需要使用make的"-f"或者“--file”参数（"--makefile"参数也可以）。例如我们的Makefile的名字是"hchen.mk"，则可以：

make -f  hchen.mk

来运行。

    (3)指定目标

        一般来说，make的最终目标是makefile中的第一个目标。而其他的目标一般是由这个目标连带出来的。这是make的默认行为。一般来说，你的makefile的第一个目标是由多个目标组成的，你可以指定make，让其完成你指定的目标，需要在make命令后直接跟着目标的名字就可以了。(例如之前说到的"make clean"形式)。

    任何在makefile中的目标都可以成为最终目标，但是除了"-"打头，或者包含了"="的目标。因为有这些字符的目标，会被解析为命令行参数或者变了。甚至没有被我们明确写出来的目标也可以成为make的终极目标。也就是说，只要make可以找到其隐含规则推导规则，那么这个隐含目标同样可以成为终极目标。

    有一个make的环境变量"MAKECMDGOALS"，这个变量会存在你指定的终极目标的列表中，如果在命令行上，你没有指定目标，那么，这个变量是空值。这个变量可以让你使用在一些特殊的情况下，例如：

sources = foo.c  bar.c 
ifneq ($(MAKECMDGOALS) ,clean)
includes $(sources :.c=.d)
endif

基于上面的例子，只要我们输入的命令不是"make clean"，那么makefile会自动包含"foo.d"和"bar.d"这两个makefile。

使用指定终极目标的方法可以方便的编译我们的程序，例如：

.PHONY : all
all : prog1  prog2  prog3  prog4 

可以看出，这个make中有四个需要编译的程序，我们可以使用"make all"编译所有的目标（如果把all作为第一个目标，那么只需要执行"make"），也可以使用"make prog2"来单独编译目标"prog2"。

既然make可以指定所有的makef中的目标，那么也包括"为目标"，于是我们根据这种性质来让我们的makefile根据不同的目标完成不同的事情。在Unix中，软件发布时，特别是GNU这种开源的软件发布时，其makefile都包含了编译、安装、打包等功能，我们可以根据这种规则来书写我们的makefile的目标。

    <1>"all"

        这个伪目标是所有目标的目标，其功能一般是编译所有的目标。

    <2>“clean”

        这个伪目标是为了删除所有被make创建的文件。

    <3>"install"

        这个文目标是为了安装已经编译好的程序，其实就是把目标执行文件拷贝到指定的目标中去。

    <4>"print"

        这个伪目标功能室列出改变过的源文件。

    <5>"tar"

        这个伪目标是为了把源程序打包，也就是一个tar文件。

    <6>“dist”

        这个伪目标功能就是创建一个压缩文件，一般是把tar文件压缩成为Z文件，或者gz文件。

    <6>"TAGS"

        这个伪目标功能室更新所有的目标，以备完整的重新编译。

    <7>"check"和"test"

        这两个伪目标一般用来测试makefile的流程。

    当一个项目的makefile不一定要书写这些目标，这些东西都是GNU的东西，但是如果这样写，一是充实，而是专业。并且，如果要书写这些功能，最好使用这种名字来命令你的目标。

检查规则：

有时候，我们不希望makefile中的规则执行起来，我们只是检查一下我们的命令，或者执行的序列。可以使用：

        "-n"

        "--just-printf"

        "--dry-run"

        "--recon"

只打印，不执行

        "-t"

        "--touch"

把目标文件的时间更新，但不更改目标文件，也就是make假装编译目标，但是不是真正编译目标，只是把目标变成已编译的状态。

        “-q”

        "--question"

如果目标存在，那就什么都不输出，什么也不执行，如果目标不存在，打印一条出错信息。

        "-W <file>"

        “--what-if=<file>”

        "--assume-new=<file>"

        "--new-file=<file>"

这个参数需要制定一个文件，一般是源文件(或者是依赖文件)，Make根据推到规则来运行依赖于这个文件的命令，一般来说，可以和"-n"参数一同使用，来查看这个依赖文件所发生的规则命令。

make参数：

频率较高：

"-b"

"-m"

用于忽略和其他版本的兼容性。

"-B"

"--always-make"

认为所有的目标都需要更新(重编译)

“-C  <dir>”

“--directory=<dir>”

指定读取makef的目录。若有多个"-C "参数，make的解释是后面的路径以前面的作为相对路径，并以最后的目录作为被指定的目录。如"make -C ~hchen/test -C  prog"相当于"make -C ~hchen/test/prog"

“-debug[=<options>]”

输出make的调试信息，它有集中不同的级别可供选择，如果没有参数，那就是输出最简单的调试信息。<option>的取值：

a——也就是all,输出所有的调试信息。

b——basic，只输出简单的调试信息。

v——也就是verbose，在b的选项级别上。输出的I信息包括那个makefile被解析，不需要被重新编译的依赖文件(或依赖目标)等。

...........................（其他省略）

自动化变量：

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

    （1）$@

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

    (2)$%

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

    (3)$<

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

     (4)$?

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

    (5)$^

        所有的依赖目标的集合。以空格分隔。如果在依赖目标中由多个重复的，那么这个变量会出去重复的依赖目标，只保留一份。

    （6）$+

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

    (7)$*

    这个变量表示目标模式中"%"及其之前的部分。如果目标是"dir/a.foo.b"，那么目标的模式是"a.%.b"，那么，"$*"值就是"dir/a.foo"。这个变量对于构造有关的文件名是比较快的。如果目标中没有模式的定义，那么"$*"也就不能推到出来。但是如果目标文件的后缀是make所识别的，name"$*"就是除了后缀的那一部分。例如：如果目标是"foo.c"，因为".c"是make所能识别的后缀名，所以，"$*"的值就是"foo"，这个特性是GNU   make的，很有可能不能兼容其他版本的make。所以，应该尽量避免使用"$* "，除非是在隐含规则或者静态模式中。如果目标中的后缀是make不能识别的，那么"$*"就是空值。