规则:
目标 : 依靠
命令
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) [..]
文件搜索:
大的project中,有大量的源文件。我们通常的做法是把这些源文件分类,病存放在不同的文件夹中。
所以,当make须要去找文件的依赖关系式。能够再文件前加上路径名,但有一个最好的方法就是把一个路径告诉make。让make自己去找。
Makefile中的特殊变量VPATH就是完毕这任务的。假设没有知名这个变量。make仅仅会在当前的文件夹中寻找依赖关系和目标文件。假设定义了这个变量,那么make就会在当前文件夹找不到的情况下,去指定的文件夹去寻找文件了。
VPATH
= src:../headers
指明了两个文件夹。src和../headers,make会依照这个顺序去搜索。文件夹“冒号”分开(可是,当前文件夹永远都是最高优先搜索的地方)。
另外一个设置文件搜索路径的方法就是使用make的keywordvpath(注意是小写)。这个不是变量。这是一个makekeyword,这和上面的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说明,不论是否有这个文件。这个目标就是“伪目标”
1
2
3
4
5
|
.PHONY:clean
clean:
rm *.o
|
静态模式:
静态模式能够更加easy定义多目标的规则。语法为:
1
2
3
4
5
|
<target...>:<target-pattern>:<prereq-patterns...>
< command >
......
|
target定义了一系列的目标文件,能够有通配符。
是一个目标的集合。
target-pattern是指明了targets的模式,也就是目标集模式。
prereq-patterns是目标文件的依赖模式,它对target-pattern形成的模式在进行一次依赖目标的定义。比如:<target-pattern>定义成%.c,意思是我们的<target>集合中都是以".o"结尾的,二假设我们的<prereq-patterns>定义成为"%.c",意思是对<target-pattern>所形成的目标集进行二次定义。其计算方法是:取<target-pattern>模式的"%“(也就是去掉[.o]这个结尾),并为其加上[.c]这个结尾。形成新的集合。
所以,”目标模式“或是”依赖模式“都能够有"%"这个字符。假设文件名称中有"%",那么能够使用"\%"表示。
比如:
1
2
3
4
5
6
7
|
objects
all
$(objects):%.o:%.c
$(cc)
|
指明了我们的目标从$(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")。
于是上面的规则展开后就是:
1
2
3
4
5
6
7
|
foo.o
$(cc)
bar.o
$(cc)
|
假设"%.o"有几百个。那么这样的简单的"静态模式规则"能够写完一大堆的规则,效率非常高。
命令出错:
每当命令运行完后,make会检查每个命令的返回码。假设命令返回成功,那么make会运行下一条命令。假设一个规则中的某一个命令错了(命令退出码非零)。那么make就会终止当前的规则,将有可能终止全部的规则的运行。
有时候,命令的出错并不代表就是错误的,比如mkdir。假设当前文件夹不存在须要创建的文件,就会成功执行。可是假设。当前文件夹中有一个这种同名文件,那么就会出错二终止规则的执行。为了忽略出错,我们能够再Makefile的命令行前面加一个减号“-”(在TAB键之后),标记为无论命令是否出错都觉得是成功的。
比如:
1
2
3
|
clean:
- rm -f
|
以下定义一个变量。其值为空格:
1
2
3
|
nullstring
space #end
|
nullstring是一个Empty变量,当中什么也没有,而我们的space的值是一个空格。由于在操作符右边非常难描写叙述一个空格。这里採用的技术非常管用,先用一个Empty变量来标明变量的值開始了,而后採用“#”凝视符来表明变量的定义的终止。
这样。我们就能够定义出其值为空格的变量。
显式命令:
通常,make会把要运行的命令显示在屏幕,当使用"@"字符在命令行前,那么这个命令就不会别显式出来。
比如:
echo 正在编译这个模块...
运行效果为,屏幕显示:
echo 正在编译这个模块...
正在编译这个模块...
但。使用"@。屏幕显示:
正在编译这个模块...
命令运行:
要注意,须要在上一条命令的结果须要作用于下一条命令。应该使用分好隔离这两条命令。比如:
1
2
3
|
cd /home/yangrui/study
pwd
|
而使用";"。即:
1
|
cd /home/yangrui/study ; pwd
|
当中,运行make exec时,第一个样例中的cd没有作用。pwd会打印出当前Makefile的文件夹,而第二个cd 就会起作用。pwd会打印出"/home/yangrui/study"
定义命令包:
假设Makefile中出现一些同样的命令序列。那么我们能够为这些同样的序列定义一个变量。定义这样的命令序列以"define"開始,以"endef"结束。
比如:
1
2
3
4
5
|
define
run-yacc
mv y.tab.c
|
这里的run-yacd就是这个命令报的名字。其不能够和Makfile中的变量重名。(类似于C语言的函数)
变量:
(1)变量基础
变量在声明时须要赋初值,而在使用时须要在变量名之前加上"$",但最好用()或者{}包含起来,若须要使用真正的‘$'字符,则须要使用“$$"。
比如:
1
2
3
4
5
6
7
|
objects
program
cc
$(objects)
|
变量会在使用的地方展开,像c/c++中的宏。
比如:
1
2
3
4
5
|
foo
prog.o
$(foo)$(foo)
|
展开后成为:
1
2
3
|
prog.o
cc
|
(可是一般不会像这样去做)
(2)变量中的变量
定义变量时。还能够使用其它变量来够着变量的值。在Makefile中有两种定义变量值得方法:
<1>使用"="
"=“左边是变量,右边是其它变量。且右側的其它变量也试试文件里的不论什么一处,也就是说。右側的值不一定是已经定义好的值 。也能够使用后面定义的值。
比如:
1
2
3
4
5
6
7
8
9
|
foo
bar
ugh
all:
echo :
|
则使用make all时,结果为"Huh?"
这样的方法有优点也有坏处,比方递归定义时:
1
2
3
|
a
b
|
这样,会让make嵌入无限的变量展开过程中去,当然,make是有能力检查这样的错误并报错的,可是效率太低。
<2>使用":="
这样的方法中变量的值不能使用后面的变量。仅仅能使用前面已经定义好的变量。
比如:
1
2
3
|
y
x
|
则,y的值为”bar“。而不是”foo
bar“.
技巧:怎样定义一个值为空格的变量
1
2
3
|
nullstring
space #end
|
nullstring是一个Empty变量,当中什么都没有。而我们space值为空格。由于在操作符右边非常难去描写叙述一个空格,这里的技术非常管用。先使用一个Empty的变量来表明变量的開始,而后面採用"#"凝视来表明变量定义的终止,这样,我们就能够定义出一个值为空格的变量。
(3)变量的高级使用方法
<1>变量值的替换
a.能够替换变量*同拥有的部分。
格式为
$(var:a=b) 或者 ${var:a=b}
意思是吧变量"var"中所有以"a"字符结“结尾”的“a"所有替换为“b”字串。这里“结尾”的意思是“空格”或者“结束符”。
比如:
1
2
3
|
foo
bar
|
这时候$(bar)的值就是“a.c b.c c.c”
b.第二种变量替换的技术以"静态模式"定义。
比如:
1
2
3
|
foo
bar
|
这个样例让$(bar)变量的值为"a.c b.c c.c"。
<2>把变量的值在当变量
比如:
1
2
3
4
5
|
x
y
a:=$($(x))
|
这里,$(a)的值就是"z"。
这样的方式中,还能够使用多个变量组成一个变量的名字,然后取值:
比如:
1
2
3
4
5
6
7
|
first_second
a
b
all=$($a_$b)
|
这里。$(all)就是"hello"。
追加变量值:
能够使用"+="操作符给变量追加值。
override指示符:
假设有变量是通过make的命令行參数设置的。那么Makefile中对这个变量的赋值会被忽略。假设想在Makefile中设置这类參数,那么,能够使用"override"指示符,语法是:
override <variable> = <value>
override <variable> := <value>
当然,还能够追加:
override <variable> +=<more text>
对于多行的命令符。我们使用define指示符。在define指示符前,也相同能够使用override指示符。比如:
1
2
3
4
5
|
override
bar
endef
|
多行变量:
使用definekeyword设置变量的值能够换行。这有利于一系列的命令(前面的"命令包"就利用这样的keyword)。
define指示符后面跟的是变量的名字,重起一行是变量的值。定义以endefkeyword结束。
工作方式和"="同样。
比如:
1
2
3
4
5
6
7
|
define
echo foo
echo $(bar)
endef
|
环境变量:
make执行时的系统环境变量能够再make開始执行时被加载到Makefile中,可是假设Makefile中已经定义了这个变量,或者这个变量由make命令带入,那么系统的环境变量的值就会被覆盖。(假设make指定了"-e"參数,那么系统环境变量将会覆盖Makefile中定义的变量)。
因此,假设我们在环境变量中设置了"CFLAGS"环境变量。那么我们就能够在全部的Makefile中使用这个变量了。
这对于我们使用统一的编译參数有较大的优点。假设Makefile中定义了CFLAGS,那么则会使用Makfile中的变量,假设未定义则使用系统环境变量的值,一个共性和个性的统一,像"全局变量"和"局部变量"的特性。
当make嵌套使用时,上层的Makfile定义的变量会以系统环境变量的方式传递到下层的Makefile中。当然。在默认情况下,仅仅有通过命令行设置的变量才会被传递。而定义在文件里的变量,假设要向下层Makefile传递。则须要使用exportkeyword。
注意:不建议把环境变量定义在系统环境中。
目标变量:
前面所说的都是"全局变量",在整个文件里,我们都能够訪问这些变量。当然"自己主动化变量"除外。如"$<"这样的自己主动化变量就属于"规则性变量"。这样的变量的值依赖于规则的目标和依赖目标的定义。当然,也能够为某个目标设置局部变量,这样的变量被称为"Target-specific
Variable".他能够和全局变量同名,由于他的作用于就是这个规则以及连带的规则,所以仅仅在作用范围内有效,而不会影响到规则链以外的全局变量的值。
语法是:
<target ...> : <variable-assignment>
<target ...> : overirde<variable-assignment>
<variable-assignment>能够使前面提到的各种赋值表达式,如"="、":="、"+="或者"?
="。第二个语法是针对make命令带入的变量,或者是系统环境变量。这个特性很实用。当我们设置这样一个变量,这个变量会作用到由这个目标引发的全部的规则中去。
比如:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
prog
prog
$(cc)
prog.o
$(cc)
foo.o
$(cc)
bar.o
$(cc)
|
这个样例中,无论全局的"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命令行指定的变量。
使用条件推断:
比如:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
libs_for_gcc
normal_libs
foo
ifeq($(cc)
$(cc)
else
$(cc)
endif
|
含义:推断是否使用"gcc"。假设是。则使用"GUN"函数编译目标。
上面的样例中有三个keyword:ifeq else endif 。
上面的样例还能够写的更加简洁些:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
libs_for_gcc
normal_libs
ifeq($(cc)
libs
else
libs
endif
foo:
$(cc)
|
语法:
<1>
<condiitonal-directive>
<text-if-true>
endif
<2>
<condiitonal-directive>
<text-if-true>
else
<text-if-false>
endif
这里的<condiitonal-directive>表示keyword共同拥有四个:
<1>keywordifeq
ifeq (<arg1> , <arg2>)
ifeq ‘<arg1>’ , '<arg2>'
ifeq ”<arg1>“ , "<arg2>"
ifeq "<arg1>" , '<arg2>'
ifeq '<arg1>' , "<arg2>"
<2>keywordifneq
ifneq (<arg1> , <arg2>)
ifneq ‘<arg1>’ , '<arg2>'
ifneq ”<arg1>“ , "<arg2>"
ifneq "<arg1>" , '<arg2>'
ifneq '<arg1>' , "<arg2>"
<3>keywordifdef
<4>keywordifndef
当中,<condiitonal-directive>这一行,多余的空格是同意的,可是不能以[TAB]作为開始,否则就会被觉得是命令。
注意:make实在读取Makefile时就会计算条件表达式的值。并依据表达式的值来选择语句。所以,你最好不要把自己主动化变量(如"$@"等)放入条件表达式,由于自己主动化变量是在执行时才有的。
使用函数:
(1)函数的调用语法
$(<function> <arguments>)或者${<function> <arguments>}
这里。<function>就是函数名,make支持的函数不多.<arguments>就是函数的參数。參数间以逗号","分隔,而函数名和參数之间以“空格”分隔。函数调用以"$"开头。
(2)字符串处理函数
<1>subst
$(subst <from> , <to> , <text>)
名称:字符串替换函数----subst
功能:把字符串<text>中的<from>字符串替换为<to>
返回:函数返回替换过来的字符串
样例:
1
|
$(subst
|
返回的结果就是"fEEt
on the strEEt"
<2>patsubst
$(patsubst
<pattern>,<replacement>,<text>)
名称:模式字符串替换函数----patsubst
功能:查找<text>中的单词(单词以“空格”、“TAB”或者“回车”、“换行”分隔)是否符合模式<pattern>,假设匹配,则以<replacement>替换。
这里的<pattern>能够使通配符"%"。表示随意长度的字串,假设<replacement>中冶包括"%",那么,<replacement>中的这个"%"将是<pattern>里的"%"所代表的字串。
(也能够使用"'\"来转义,用"\%"表示)。
返回:被替代过后的字符串。
样例:
1
|
$(patsubst
|
返回结果是:"x.c.o
bar.o"
这个前面提到的“变量”章节有关知识非常相似:
$(var:<pattern> = <replacement>)
相当于:
$(patsubst <pattern>, <replacement> ,$(var))
<3>strip
$(strip <string>)
名称:去空格函数----strip
功能:去掉<string>字串中开头和结尾的空字符。
返回:被去掉空格的字符串值。
样例:
1
|
$(strip
|
返回结果是:"a b c"
<4>findstring
$(findstring <find>,<in>)
名称:在字串<in>中查找<find>字串。
样例:
1
2
3
|
$(findstring
$(findstring
|
返回结果。第一个返回"a"字符串。第二个返回“”字符串(空字符)。
<5>filter
$(filter <pattern ....>, <text>)
名称:过滤函数----filter
功能:以<pattern>模式过滤<text>字符串的单词,保留符合模式<pattern>的单词。
能够有多个模式。
返回:符合模式<pattern>的字串。
样例:
1
2
3
4
5
|
sources
foo
cc
|
则,$(filter %.c %.s ,$(sources))返回的值是"foo.c bar.c baz.s"
<6>filter-out
$(filter-out <pattern ...> , <text>)
名称:反过滤函数----filter-out
功能:以<pattern>模式过滤<teext>字串中的单词,去除符合模式<pattern>的单词。能够有多个模式。
返回:不符合模式<pattern>的字串
样例:
1
2
3
4
5
|
objects
mains
$(filter-out-out
|
则返回值为"foo.o bar.o"
<7>sort
$(sort<list>)
名称:排序函数----sort
功能:给字符串<list>中的单词排序(升序)
返回:排序后的字符串
样例:
1
|
$( sort foo
|
返回结果为: "bar foo lose"
备注:sort函数会去掉<list>中同样的单词。
<8>word
$(word <n>,<text>)
名称:取单词函数----word
功能:取字符串<text>中第n个单词。(从第一个開始)
返回:字符串<text>的第<n>个单词。
假设<n>比<text>中的单词数要大,那么返回空字符串。
样例:
1
|
$(word
|
返回:"bar"
<9>wordlist
$(wordlist <s>,<e>,<text>)
名称:取单词函数----worklist
功能:从字符串<text>中取从<s>開始到<e>的单词,<s>和<e>都是数字。
返回:返回字符串<text>中从<s>到<e>的单词。假设<s>比<text>的单词数要打,那么返回空字符串,假设<e>大于<text>的单词数。那么返回<s>開始,到<text>结束的单词。
样例:
1
|
$(wordlist
|
返回:"bar baz"
<10>works
$(words <text>)
名称:单词个数统计函数----words
功能:统计<text>中字符串的单词个数
返回:<text>中的单词数
样例:
1
|
$(words
|
返回值是"3".
备注:假设我们要提取<text>最后一个单词。能够这样:
$(word $(words<text>),<text>)
<11>firstword
$(firstword <text>)
名称:首单词函数----firstword
功能:取字符串<text>的第一个单词。
返回:字符串<text>的第一个单词。
样例:
1
|
$(firstword
|
返回值:"foo"。
备注:这个函数还能够用word实现:
$(word 1,<text>)
文件名称操作函数:
<1>dir
$(dir <names...>)
名称:取文件夹函数----dir
功能:从文件名称序列<name>中取出文件夹部分。
文件夹部分是值最后一个反斜杠"/"之前的部分。假设没有反斜杠。就返回"./"。
返回:返回文件名称序列<name>的文件夹部分。
样例:
1
|
$( dir src /soo .c
|
返回值:"src/ ./"
<2>notdir
$(notdir <names...>)
名称:取文件函数----notdir
功能:从文件名称序列<names>中取出非文件夹部分。非文件夹部分是指最后一个反斜杠“/”之后的部分。
返回:文件名称序列<names>的非文件夹部分。
样例:
1
|
$(notdir /foo .c
|
返回:"foo.c hacks"
<3>suffix
$(suffix <names>)
名称:取后缀函数----suffix
功能:从文件名称序列<names>中取出各个文件名称的后缀。
返回:文件名称序列<names>的后缀序列,假设文件没有后缀,则返回空字符。
样例:
1
|
$(suffix /foo .c /bar .c
|
返回值:".c .c "
<4>basename
$(basename <names...>)
名称:取前缀函数----basename
功能:从文件名称序列<names>中取出各个文件名称的前缀部分。
返回:文件名称序列<names>的前缀序列,假设文件没有前缀,则返回空字符。
样例:
1
|
$( basename src /foo .c /bar .c
|
返回值:"src/foo src-1.0/bar hacks"。
<5>addsuffix
$(addsuffix <suffix> , <names...>)
名称:加前缀函数----addsuffix
返回:加过后缀的文件名称序列。
样例:
1
|
$(addsuffix
|
返回值:“foo.c bar.c ”
<6>addprefix
$(addprefix <prefix> , <names...>)
名称:加前缀函数----addprefix
功能:把前缀<prefix>加在<names>的每一个单词后面。
返回:加过前缀的文件名称序列。
样例:
1
|
$(addprefix
|
返回:"src/foo src/bar "
<7>join
$(join <list1> , <list2>)
名称:连接函数
功能:把<list2>中的单词相应的增加到<list1>的单词的后面。
假设<list1>的单词比<list2>要多,那么<list1>中多出来的单词将保持原样。
假设<list2>的单词比<list1>多,则<list2>多出来的单词将会被拷贝到<list2>中。
样例:
1
|
$( join aaa
|
返回:"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>中的单词。
样例:
1
2
3
|
names
files
|
则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函数的返回值。
样例:
1
2
3
|
reverse
foo
|
那么foo的值就是"a b"当然,參数的次序能够自有定义。不一定是顺序的。
样例:
1
2
3
|
reverse
foo
|
那么,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命令。它和反引號" ‘ "是同样的功能。
样例:
1
2
3
|
contents cat foo)
files
|
注意。这个函数会生成还有一个shell程序运行命令,所以必须注意其运行性能。假设你的Makefile中有一个复杂的规则,并大量利用了这个函数。那么对你的系统是有害的。特别是Makefile的隐晦规则可能让你的shell函数运行次数比你想象的要多。
控制Makefile的函数:
make提供了一下函数控制make的执行。通常,你须要检測一些执行Makefile时的执行信息。而且依据这个信息来决定,你是让make继续执行,还是停止。
(1)error
$(error <text.....>)
产生一个致命错误,<text...>是错误信息。注意。error函数不会在一被使用就产生错误信息,所以假设你把其定义在某个变量中,并在兴许脚本中使用了这个变量,那么,能够这样:
范例一:
1
2
3
4
5
|
$ifdef
$(error
endif
|
范例二:
1
2
3
4
5
|
ERR
.PHONY:err
err
|
(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面目全非。然后"$*"它是空的值。