Linux注意到Makefile

规则:

目标 : 依靠

命令

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 
temp

静态模式:

静态模式能够更加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
= foo.o bar.o
 
all
= $(objects)
 
$(objects):%.o:%.c
 
$(cc)
-c $(CFLAGS) $< -o $@

指明了我们的目标从$(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 
:  foo.cc
 
$(cc) 
-c  $(CFLAGS)  foo.c  -0  foo.o
 
bar.o
: bar.c
 
$(cc)
-c   $(CFLAGS)   bar.c  -o  bar.c

假设"%.o"有几百个。那么这样的简单的"静态模式规则"能够写完一大堆的规则,效率非常高。

命令出错:

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

有时候,命令的出错并不代表就是错误的,比如mkdir。假设当前文件夹不存在须要创建的文件,就会成功执行。可是假设。当前文件夹中有一个这种同名文件,那么就会出错二终止规则的执行。为了忽略出错,我们能够再Makefile的命令行前面加一个减号“-”(在TAB键之后),标记为无论命令是否出错都觉得是成功的。

比如:

1
2
3
clean:
 
-rm -f
*.o

以下定义一个变量。其值为空格:

1
2
3
nullstring
:=
 
space
:= $(nullstring) 
#end
of line

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
 
run-yacc 
$(firstword s^)
 
mv y.tab.c 
$@

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

变量:

(1)变量基础

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

比如:

1
2
3
4
5
6
7
objects
= program.o   foo.o   utils.objects
 
program
: $(objects)
 
cc
-o program $(objects)
 
$(objects)
: defs.h

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

比如:

1
2
3
4
5
foo
= c
 
prog.o
: prog.$(foo)
 
$(foo)$(foo) 
-$(foo)  prog.$(foo)

展开后成为:

1
2
3
prog.o 
: prog.cc
 
cc
-c prog.c

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

(2)变量中的变量

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

<1>使用"="

"=“左边是变量,右边是其它变量。且右側的其它变量也试试文件里的不论什么一处,也就是说。右側的值不一定是已经定义好的值 。也能够使用后面定义的值。

比如:

1
2
3
4
5
6
7
8
9
foo
= $(bar)
 
bar
= $(ugh)
 
ugh
= Huh?

 
all:
 
echo :
$(foo)

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

这样的方法有优点也有坏处,比方递归定义时:

1
2
3
a
= $(b)
 
b
= $(a)

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

<2>使用":="

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

比如:

1
2
3
y
:=  $(x)  bar
 
x
:= foo

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

技巧:怎样定义一个值为空格的变量

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

nullstring是一个Empty变量,当中什么都没有。而我们space值为空格。由于在操作符右边非常难去描写叙述一个空格,这里的技术非常管用。先使用一个Empty的变量来表明变量的開始,而后面採用"#"凝视来表明变量定义的终止,这样,我们就能够定义出一个值为空格的变量。

(3)变量的高级使用方法

<1>变量值的替换

a.能够替换变量*同拥有的部分。

格式为

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

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

比如:

1
2
3
foo
:=  a.o b.o c.o
 
bar
:= $(foo:.o=.c)

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

b.第二种变量替换的技术以"静态模式"定义。

比如:

1
2
3
foo
:= a.o b.o c.o
 
bar
:= $(foo:%.o=%.c)

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

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

比如:

1
2
3
4
5
x
= y
 
y
= z
 
a:=$($(x))

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

这样的方式中,还能够使用多个变量组成一个变量的名字,然后取值:

比如:

1
2
3
4
5
6
7
first_second
= hello
 
a
= first
 
b
= second
 
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 
define foo
 
bar
 
endef

多行变量:

使用definekeyword设置变量的值能够换行。这有利于一系列的命令(前面的"命令包"就利用这样的keyword)。

define指示符后面跟的是变量的名字,重起一行是变量的值。定义以endefkeyword结束。

工作方式和"="同样。

比如:

1
2
3
4
5
6
7
define
two-lines
 
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
: 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"。

模式变量:

在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
= -l gnu
 
normal_libs
=
 
 
 
foo
: $( objects)
 
ifeq($(cc)
, gcc)
 
$(cc)
-o  $(objects)  $(libs_for_gnu)
 
else
 
$(cc)
-o  $(objects)  $(normal-libs)
 
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
= -l gnu
 
normal_libs
=
 
 
 
ifeq($(cc)
, gcc)
 
libs
= $(libs_for_gcc)
 
else
 
libs
= $(normal_libs)
 
endif
 
 
 
foo:
$(objects)
 
$(cc)
-o  foo $(objects)  $(libs)

语法:

<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
ee,EE,feet  on  the street)

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

<2>patsubst

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

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

功能:查找<text>中的单词(单词以“空格”、“TAB”或者“回车”、“换行”分隔)是否符合模式<pattern>,假设匹配,则以<replacement>替换。

这里的<pattern>能够使通配符"%"。表示随意长度的字串,假设<replacement>中冶包括"%",那么,<replacement>中的这个"%"将是<pattern>里的"%"所代表的字串。

(也能够使用"'\"来转义,用"\%"表示)。

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

样例:

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

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

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

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

相当于:

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

<3>strip

$(strip <string>)

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

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

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

样例:

1
$(strip  
a  b   c  )

返回结果是:"a b c"

<4>findstring

$(findstring <find>,<in>)

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

样例:

1
2
3
$(findstring 
a,a b c)
 
$(findstring 
a ,b c)

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

<5>filter

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

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

功能:以<pattern>模式过滤<text>字符串的单词,保留符合模式<pattern>的单词。

能够有多个模式。

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

样例:

1
2
3
4
5
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

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

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

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

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

样例:

1
2
3
4
5
objects
= main1.o  foo.o  main2.o  bar.o
 
mains
= main1.o  main2.o
 
$(filter-out-out 
$(mains),$(objects))

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

<7>sort

$(sort<list>)

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

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

返回:排序后的字符串

样例:

1
$(sort  foo
bar  lose)

返回结果为: "bar  foo  lose"

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

<8>word

$(word  <n>,<text>)

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

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

返回:字符串<text>的第<n>个单词。

假设<n>比<text>中的单词数要大,那么返回空字符串。

样例:

1
$(word
2 , foo bar  baz )

返回:"bar"

<9>wordlist

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

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

功能:从字符串<text>中取从<s>開始到<e>的单词,<s>和<e>都是数字。

返回:返回字符串<text>中从<s>到<e>的单词。假设<s>比<text>的单词数要打,那么返回空字符串,假设<e>大于<text>的单词数。那么返回<s>開始,到<text>结束的单词。

样例:

1
$(wordlist
2,3  ,foo bar  baz)

返回:"bar  baz"

<10>works

$(words <text>)

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

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

返回:<text>中的单词数

样例:

1
$(words
,foo bar  baz)

返回值是"3".

备注:假设我们要提取<text>最后一个单词。能够这样:

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

<11>firstword

$(firstword <text>)

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

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

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

样例:

1
$(firstword 
foo bar )

返回值:"foo"。

备注:这个函数还能够用word实现:

$(word  1,<text>)

文件名称操作函数:

<1>dir

$(dir  <names...>)

名称:取文件夹函数----dir

功能:从文件名称序列<name>中取出文件夹部分。

文件夹部分是值最后一个反斜杠"/"之前的部分。假设没有反斜杠。就返回"./"。

返回:返回文件名称序列<name>的文件夹部分。

样例:

1
$(dir  src/soo.c 
hacks)

返回值:"src/   ./"

<2>notdir

$(notdir  <names...>)

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

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

返回:文件名称序列<names>的非文件夹部分。

样例:

1
$(notdir 
src
/foo.c 
hacks )

返回:"foo.c  hacks"

<3>suffix

$(suffix <names>)

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

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

返回:文件名称序列<names>的后缀序列,假设文件没有后缀,则返回空字符。

样例:

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

返回值:".c  .c "

<4>basename

$(basename <names...>)

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

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

返回:文件名称序列<names>的前缀序列,假设文件没有前缀,则返回空字符。

样例:

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

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

<5>addsuffix

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

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

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

样例:

1
$(addsuffix 
.c , foo  bar)

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

<6>addprefix

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

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

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

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

样例:

1
$(addprefix
src/,foo  bar)

返回:"src/foo  src/bar "

<7>join

$(join  <list1> , <list2>)

名称:连接函数

功能:把<list2>中的单词相应的增加到<list1>的单词的后面。

假设<list1>的单词比<list2>要多,那么<list1>中多出来的单词将保持原样。

假设<list2>的单词比<list1>多,则<list2>多出来的单词将会被拷贝到<list2>中。

样例:

1
$(join  aaa 
bbb  ,111  222  333)

返回:"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
:= a b c d
 
files    
:= $(foreach  n, $(names),$(n).o)

则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
= $(1)  $(2)
 
foo
= $(call reverse,a,b)

那么foo的值就是"a b"当然,參数的次序能够自有定义。不一定是顺序的。

样例:

1
2
3
reverse
= $(2)  $(1)
 
foo
= $(call reverse,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命令。它和反引號" ‘ "是同样的功能。

样例:

1
2
3
contents
:= $(shell  
cat foo)
 
files
:= $(shell  eccho *.c)

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

控制Makefile的函数:

make提供了一下函数控制make的执行。通常,你须要检測一些执行Makefile时的执行信息。而且依据这个信息来决定,你是让make继续执行,还是停止。

(1)error

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

产生一个致命错误,<text...>是错误信息。注意。error函数不会在一被使用就产生错误信息,所以假设你把其定义在某个变量中,并在兴许脚本中使用了这个变量,那么,能够这样:

范例一:

1
2
3
4
5
$ifdef 
ERROR_001
 
$(error
error is $(ERROR_001))
 
endif

范例二:

1
2
3
4
5
ERR
= $(error found an error !)
 
.PHONY:err
 
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面目全非。然后"$*"它是空的值。

上一篇:02 如何创建线程 线程并发与synchornized


下一篇:c#接口与虚函数的实验报告