前言
在windows下,编译、链接工作就是一个按钮的事情,IDE帮你把大部分工作都做了。这当然非常方便,但是如果你对背后的工作原理不了解,就经常会出现一些自己无法解决的、莫名其妙的编译、链接错误。
在linux下,离开了IDE,要编译一个大型工程,就需要借助makefile了。makefile定义了一系列的规则来指定,哪些文件需要先编译,哪些文件需要后编译,哪些文件需要重新编译,甚至于进行更复杂的功能操作,makefile就像一个Shell脚本一样,其中也可以执行操作系统的命令。
makefile带来的好处就是——“自动化编译”,一旦写好,只需要一个make命令,整个工程完全自动编译,极大的提高了软件开发的效率。make是一个命令工具,是一个解释makefile中指令的命令工具,一般来说,大多数的IDE都有这个命令,比如:Delphi的make,Visual C++的nmake,Linux下GNU的make。
关于编译链接
编译、链接这一块在之前的文章中也提过不少,因此这里仅简单再回顾下。
我们常说的编译,事实上包括了编译和链接两大步。
首先,编译器将源文件编译成中间代码文件,Windows下是 .obj 文件,UNIX下是 .o 文件,即 Object File,这个动作叫做编译(compile)。然后链接器再把大量的Object File合成执行文件,这个动作叫作链接(link)。
编译时,编译器需要的是语法的正确,函数与变量的声明的正确。对于后者,通常是你需要告诉编译器头文件的所在位置(头文件中应该只是声明,而定义应该放在C/C++文件中),只要所有的语法正确,编译器就可以编译出中间目标文件。一般来说,每个源文件都应该对应于一个中间目标文件(O文件或是OBJ文件)。
链接时,主要是链接函数和全局变量,所以,我们可以使用这些中间目标文件(O文件或是OBJ文件)来链接我们的应用程序。链接器并不管函数所在的源文件,只管函数的中间目标文件(Object File),在大多数时候,由于源文件太多,编译生成的中间目标文件太多,而在链接时需要明显地指出中间目标文件名,这对于编译很不方便,所以,我们要给中间目标文件打个包,在Windows下这种包叫“库文件”(Library File),也就是 .lib 文件,在UNIX下,是Archive File,也就是 .a 文件。
总结一下,源文件首先会生成中间目标文件,再由中间目标文件生成执行文件。在编译时,编译器只检测程序语法,和函数、变量是否被声明。如果函数未被声明,编译器会给出一个警告,但可以生成Object File。而在链接程序时,链接器会在所有的Object File中找寻函数的实现,如果找不到,那到就会报链接错误码(Linker Error)。
Makefile知识备忘
首先说明一下,本文不对基础知识做详细地介绍,只作为个人备忘。
详细入门知识请参考:
http://www.chinaunix.net/old_jh/23/408225.html
1. make命令
我们通常会编写一个名字叫makefile或者Makefile的文件,然后在编译的时候执行命令make。那么make命令和makefile文件到底是什么关系?
在默认的方式下,也就是我们只输入以下命令:
$ make
那么,
- make命令会在当前目录下找名字叫“Makefile”或“makefile”的文件。
- 如果找到,它会找文件中的第一个目标文件(target),并把这个文件作为最终的目标文件,我们假设该目标文件是edit。
- 如果edit文件不存在,或是edit所依赖的后面的 .o 文件的文件修改时间要比edit这个文件新,那么,他就会执行后面所定义的命令来生成edit这个文件。
- 如果edit所依赖的.o文件也不存在,那么make会在当前文件中找该.o文件的依赖性,如果找到则再根据那一个规则生成.o文件。(这有点像一个堆栈的过程)
- 根据你的C文件和H文件,make会生成 .o 文件,然后再用 .o 文件生成make的终极任务,也就是执行文件edit了。
第一点的意思是,make是一个命令,在没有指定makefile文件的情况下,它会默认找当前目录下名为[Mm]akefile的文件作为makefile文件。如果你想指定makefile文件,则可通过-f参数指定:
$ make -f makefile.myfile
第二点的意思是,在没有指定目标的情况下,他会找到文件中第一个目标作为最终目标。如果你想指定目标,则在命令行中指定,比如想指定目标clean:
$ make clean
后面几点的意思是,make会一层又一层地去找文件的依赖关系,直到最终编译出第一个目标文件。在找寻的过程中,如果出现错误,比如最后被依赖的文件找不到,那么make就会直接退出,并报错,而对于所定义的命令的错误,或是编译不成功,make根本不理。make只管文件的依赖性,即,如果在我找了依赖关系之后,冒号后面的文件还是不在,那么对不起,我就不工作啦。
于是在我们编程中,如果这个工程已被编译过了,当我们修改了其中一个源文件,比如file.c,那么根据我们的依赖性,我们的目标file.o会被重编译(也就是在这个依性关系后面所定义的命令),于是file.o的文件也是最新的啦,于是file.o的文件修改时间要比edit要新,所以edit也会被重新链接了。
2. makefile规则示例
objects = main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
# objects 是一个变量,反斜杠(\)是换行符的意思
edit : $(objects)
cc -o edit $(objects)
# 执行文件edit 是第一个目标(target),因此被当作最终的目标
# edit 依赖objects变量的值中的.o文件
# 下面一行是根据依赖的.o目标文件来生成最终的edit的命令,必须以TAB开头
main.o : main.c defs.h
cc -c main.c
kbd.o : kbd.c defs.h command.h
cc -c kbd.c
command.o : command.c defs.h command.h
cc -c command.c
display.o : display.c defs.h buffer.h
cc -c display.c
insert.o : insert.c defs.h buffer.h
cc -c insert.c
search.o : search.c defs.h buffer.h
cc -c search.c
files.o : files.c defs.h buffer.h command.h
cc -c files.c
utils.o : utils.c defs.h
cc -c utils.c
clean :
rm edit $(objects)
# 以上是非第一个的目标,因此不一定会用到
# make会从edit开始,根据依赖关系来一层层地执行所需要的目标
假设我们键入如下命令:
$ make
则make先找到目录下的makefile文件,然后找到第一个目标edit。第一个目标依赖变量object的值即目标main.o kbd.o command.o display.o insert.o search.o files.o utils.o,因此会先执行这些目标,比如main.o,它又依赖main.c defs.h,这两个文件是源文件已经存在了,于是会执行命令cc -c main.c,根据main.c defs.h来生成main.o,当所有.o都生成了,再通过命令cc -o edit $(objects)生成最终目标edit。
依赖关系的实质上就是说明了目标文件是由哪些文件生成的,换言之,目标文件是通过哪些文件更新的。
在定义好依赖关系后,后续的那一行定义了如何生成目标文件的操作系统命令,一定要以一个Tab键作为开头。make并不管命令是怎么工作的,他只管执行所定义的命令。make会比较targets文件和其依赖文件的修改日期,如果依赖文件的日期要比targets文件的日期要新,或者target不存在的话,那么,make就会执行后续定义的命令。
3. make自动推导
只要make看到一个[.o]文件,它就会自动的把[.c]文件加在依赖关系中,如果make找到一个whatever.o,那么whatever.c,就会是whatever.o的依赖文件。并且 cc -c whatever.c 也会被推导出来。
因此以下写法可以简化:
main.o : main.c defs.h
cc -c main.c
–>
main.o : defs.h
4. 伪目标
每个Makefile中都应该写一个清空目标文件(.o和执行文件)的规则,这不仅便于重编译,也很利于保持文件的清洁。一般的风格都是:
clean:
rm edit $(objects)
更为稳健的做法是:
.PHONY : clean
clean :
-rm edit $(objects)
.PHONY表示clean是一个“伪目标”。而在rm命令前面加了一个小减号的意思就是,也许某些文件出现问题,但不要管,继续做后面的事。当然,clean的规则不要放在文件的开头,不然,这就会变成make的默认目标,相信谁也不愿意这样。
5. 引用其他的makefile
类似C语言的#include,Makefile使用include关键字把别的Makefile包含进来,被包含的文件会原样展开。include的语法是:
include filename;
filename可以是当前操作系统Shell的文件模式(可包含路径和通配符)
在include前面可以有一些空字符,但是绝不能是[Tab]键开始。include和filename可以用一个或多个空格隔开。举个例子,你有这样几个Makefile:a.mk、b.mk、c.mk,还有一个文件叫foo.make,以及一个变量$(bar),其包含了e.mk和f.mk,那么,下面的语句:
include foo.make *.mk $(bar)
等价于:
include foo.make a.mk b.mk c.mk e.mk f.mk
make命令开始时,会先把include的文件内容展开。如果文件都没有指定绝对路径或是相对路径的话,make会在当前目录下首先寻找,如果当前目录下没有找到,那么,make还会在下面的几个目录下找:
1、如果make执行时,有“-I”或“–include-dir”参数,那么make就会在这个参数所指定的目录下去寻找。
2、如果目录include(一般是:/usr/local/bin或/usr/include)存在的话,make也会去找。
如果有文件没有找到的话,make会生成一条警告信息,但不会马上出现致命错误。它会继续载入其它的文件,一旦完成makefile的读取,make会再重试这些没有找到,或是不能读取的文件,如果还是不行,make才会出现一条致命信息。如果你想让make不理那些无法读取的文件,而继续执行,你可以在include前加一个减号“-”。如:
-include <filename>;
其表示,无论include过程中出现什么错误,都不要报错继续执行。
6. 通配符
例子1:
clean:
rm -f *.o
以上的通配符是命令中的通配符,由shell所支持。
例子2:
print: *.c
lpr -p $?
touch print
以上的通配符在规则中,属于make所支持的,表示目标print依赖于所有的[.c]文件。其中的“$?”是一个自动化变量。
需要注意的是,以下的写法:
objects = *.o
上面的写法中,* 并不作为通配符,而是表示objects的值就是字符串“*.o”,即变量中的通配符不会被展开。
**如果想让objects的值是所有[.o]的文件名的集合,那么需要这样写:
objects := $(wildcard *.o)
7. 多目标
Makefile的规则支持多目标,有可能我们的多个目标同时依赖于一个文件,并且其生成的命令大体类似。于是我们就能把其合并起来,我们可以使用自动化变量“$@”,这个变量表示着目前规则中所有的目标的集合。
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,后面的为参数。这个函数是截取字符串的意思,“$@”表示目标的集合,就像一个数组,“$@”依次取出目标,并执行命令。
8. 静态模式
例子1:
objects = foo.o bar.o
all: $(objects)
$(objects): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
上面的例子中,指明了我们的目标从 $object 中获取(即目标是foo.o和bar.o),“% .o”表示所有以“.o”结尾的目标,也就是“foo.o bar.o”。
“%.o: %.c ”表示取“%.o”的“%”,也就是“foo bar”,并为其加上“.c”后缀,于是,我们的依赖目标就是“foo.c bar.c”。
而命令中的“$<”和“$@”则是自动化变量,“$<”表示所有的依赖目标集(也就是“foo.c bar.c”),“$@”表示目标集(也就是“foo.o bar.o”)。于是,上面的规则展开后等价于下面的规则:
foo.o : foo.c
$(CC) -c $(CFLAGS) foo.c -o foo.o
bar.o : bar.c
$(CC) -c $(CFLAGS) bar.c -o bar.o
例子2:
files = foo.elc bar.o lose.o
$(filter %.o,$(files)): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
$(filter %.elc,$(files)): %.elc: %.el
emacs -f batch-byte-compile $<
$(filter %.o,$(files))表示调用Makefile的filter函数,过滤“$files”集,只要其中模式为“%.o”的内容作为目标集,然后再通过静态模式将.o替换为.c后缀作为依赖集。
9. 变量
变量在声明时需要给予初值,而在使用时,需要给在变量名前加上“$”符号,最好用小括号“()”或是大括号“{}”把变量给包括起来。如果你要使用真实的“$”字符,那么你需要用“$$”来表示。
变量的值也可以作为变量:
foo = $(bar)
bar = $(ugh)
ugh = Huh?
# “=”左侧是变量,右侧是变量的值,右侧变量的值可以定义在文件的**任何**一处
all:
echo $(foo)
我们执行“make all”将会打出变量$(foo)的值是“Huh?”( $(foo)的值是$(bar),$(bar)的值是$(ugh),$(ugh)的值是“Huh?”)可见,变量是可以使用后面的变量来定义的。这种情况下,make会将整个makefile展开后,再决定变量的值。也就是说,变量的值将会是整个makefile中最后被指定的值。
为了避免上面的方法出现递归定义,我们可以使用make中的另一种用变量来定义变量的方法。这种方法使用的是“:=”操作符,如:
x := foo
y := $(x) bar
x := later
其等价于:
y := foo bar
x := later
这种方法,前面的变量不能使用后面的变量,只能使用前面已定义好了的变量。如果是这样:
y := $(x) bar
x := foo
那么,y的值是“bar”,而不是“foo bar”。这种情况下,变量的值决定于它在makefile中的位置,而不是整个makefile展开后的最终值。
注意注释符“#”的使用,如果我们这样定义一个变量:
dir := /foo/bar # directory to put the frobs in
dir这个变量的值是“/foo/bar”,后面还跟了4个空格,如果我们使用这样的变量来指定别的目录——“$(dir)/file”那么就完蛋了,空格会算在dir里面。
还有一个比较有用的操作符是“?=”:
FOO ?= bar
其含义是,如果FOO没有被定义过,那么变量FOO的值就是“bar”,如果FOO先前被定义过,那么这条语将什么也不做,其等价于:
ifeq ($(origin FOO), undefined)
FOO = bar
endif
再看一个例子:
VAR = MY_VAR="$(MY_VAR)"
MY_VAR = TRUE
上面的最终结果是,变量MY_VAR的值为字符串“TRUE”,变量VAR的值为字符串“MY_VAR=”TRUE””。
10. 嵌套执行make
当我们的工程比较大时,为清晰起见,我们会把不同模块放在不同目录中,然后为每个目录书写一个makefile,让我们的Makefile变得更加地简洁,而不至于把所有的东西全部写在一个Makefile中,这样会很难维护我们的Makefile,这个技术对于我们模块编译和分段编译有着非常大的好处。
例如,我们有一个子目录叫subdir,这个目录下有个Makefile文件,来指明了这个目录下文件的编译规则。那么我们总控的Makefile可以这样书写:
subsystem:
cd subdir && $(MAKE)
其等价于:
subsystem:
$(MAKE) -C subdir
定义$(MAKE)宏变量的意思是,也许我们的make需要一些参数,所以定义成一个变量比较利于维护。这两个例子的意思都是先进入“subdir”目录,然后执行make命令。
我们把这个Makefile叫做“总控Makefile”,总控Makefile的变量可以传递到下级的Makefile中(如果你显示的声明),但是不会覆盖下层的Makefile中所定义的变量,除非指定了“-e”参数。
如果你要传递变量到下级Makefile中,那么你可以使用这样的声明:
export <variable ...>;
如果你不想让某些变量传递到下级Makefile中,那么你可以这样声明:
unexport <variable ...>;
如:
示例一:
export variable = value
其等价于:
variable = value
export variable
其等价于:
export variable := value
其等价于:
variable := value
export variable
示例二:
export variable += value
其等价于:
variable += value
export variable
如果你要传递所有的变量,那么,只要一个export就行了。后面什么也不用跟,表示传递所有的变量。
需要注意的是,有两个变量,一个是SHELL,一个是MAKEFLAGS,这两个变量不管你是否export,其总是要传递到下层Makefile中,特别是MAKEFILES变量,其中包含了make的参数信息,如果我们执行“总控Makefile”时有make参数或是在上层Makefile中定义了这个变量,那么MAKEFILES变量将会是这些参数,并会传递到下层Makefile中,这是一个系统级的环境变量。
但是make命令中的有几个参数并不往下传递,它们是“-C”,“-f”,“-h”“-o”和“-W”(有关Makefile参数的细节将在后面说明),如果你不想往下层传递参数,那么,你可以这样来:
subsystem:
cd subdir && $(MAKE) MAKEFLAGS=
如果你定义了环境变量MAKEFLAGS,那么你得确信其中的选项是大家都会用到的,如果其中有“-t”,“-n”,和“-q”参数,那么将会有让你意想不到的结果,或许会让你异常地恐慌。
还有一个在“嵌套执行”中比较有用的参数,“-w”或是“–print-directory”会在make的过程中输出一些信息,让你看到目前的工作目录。比如,如果我们的下级make目录是“/home/hchen/gnu/make”,如果我们使用“make -w”来执行,那么当进入该目录时,我们会看到:
make: Entering directory `/home/hchen/gnu/make'.
而在完成下层make后离开目录时,我们会看到:
make: Leaving directory `/home/hchen/gnu/make'
当你使用“-C”参数来指定make下层Makefile时,“-w”会被自动打开的。如果参数中有“-s”(“–slient”)或是“–no-print-directory”,那么,“-w”总是失效的。
另外一种传递参数的方式,就是在make命令之后进行赋值:
$(MAKE) PARAM=$(param)
不过有一些小区别,第二种方式传递的参数,是一个常量而不是变量,也就是说,你不能修改PARAM的值。
例子:
#父makefile
MAKE=make
VAR=Hello
export VAR
mytest:
-$(MAKE) -C ./makeTest VAR2=HI
#子makefile,位于目录./makeTest下
VAR += HI
VAR2 += HELLO
target:
echo $(VAR);echo $(VAR2);
执行结果:
make -C ./makeTest VAR2=HI
make[1]: Entering directory '/home/jiange/makeTest'
echo Hello HI ;echo HI;
Hello HI
HI
make[1]: Leaving directory '/home/jiange/makeTest'
另外,如果变量中包含有空格字符,那么需要额外小心,具体情况遇到自己分析下,这里我就不具体展开了。
11. 条件判断
使用条件判断,可以让make根据运行时的不同情况选择不同的执行分支。条件表达式可以是比较变量的值,或是比较变量和常量的值。
下面的例子,判断$(CC)变量是否“gcc”,如果是的话,则使用GNU函数编译目标。
libs_for_gcc = -lgnu
normal_libs =
foo: $(objects)
ifeq ($(CC),gcc)
$(CC) -o foo $(objects) $(libs_for_gcc)
else
$(CC) -o foo $(objects) $(normal_libs)
endif
可见,在上面示例的这个规则中,目标“foo”可以根据变量“$(CC)”值来选取不同的函数库来编译程序。
我们可以从上面的示例中看到三个关键字:ifeq、else和endif。
ifeq的意思表示条件语句的开始,并指定一个条件表达式,表达式包含两个参数,以逗号分隔,表达式以圆括号括起。
else表示条件表达式为假的情况。
endif表示一个条件语句的结束,任何一个条件表达式都应该以endif结束。
当然,我们还可以把上面的那个例子写得更简洁一些:
libs_for_gcc = -lgnu
normal_libs =
ifeq ($(CC),gcc)
libs=$(libs_for_gcc)
else
libs=$(normal_libs)
endif
foo: $(objects)
$(CC) -o foo $(objects) $(libs)
条件表达式的语法为:
<conditional-directive>;
<text-if-true>;
endif
以及:
<conditional-directive>;
<text-if-true>;
else
<text-if-false>;
endif
其中;表示条件关键字,如“ifeq”。这个关键字有四个。
第一个是我们前面所见过的“ifeq”
ifeq (<arg1>;, <arg2>;)
ifeq '<arg1>;' '<arg2>;'
ifeq "<arg1>;" "<arg2>;"
ifeq "<arg1>;" '<arg2>;'
ifeq '<arg1>;' "<arg2>;"
比较参数“arg1”和“arg2”的值是否相同。当然,参数中我们还可以使用make的函数。如:
ifeq ($(strip $(foo)),)
<text-if-empty>;
endif
这个示例中使用了“strip”函数,如果这个函数的返回值是空(Empty),那么;就生效。
第二个条件关键字是“ifneq”。语法是:
ifneq (<arg1>;, <arg2>;)
ifneq '<arg1>;' '<arg2>;'
ifneq "<arg1>;" "<arg2>;"
ifneq "<arg1>;" '<arg2>;'
ifneq '<arg1>;' "<arg2>;"
其比较参数“arg1”和“arg2”的值是否相同,如果不同,则为真。和“ifeq”类似。
第三个条件关键字是“ifdef”。语法是:
ifdef <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”。
第四个条件关键字是“ifndef”。其语法是:
ifndef <variable-name>;
这个我就不多说了,和“ifdef”是相反的意思。
在;这一行上,多余的空格是被允许的,但是不能以[Tab]键做为开始(不然就被认为是命令)。而注释符“#”同样也是安全的。“else”和“endif”也一样,只要不是以[Tab]键开始就行了。
特别注意的是,make是在读取Makefile时就计算条件表达式的值,并根据条件表达式的值来选择语句,所以,你最好不要把自动化变量(如“$@”等)放入条件表达式中,因为自动化变量是在运行时才有的。
而且,为了避免混乱,make不允许把整个条件语句分成两部分放在不同的文件中。
12.函数
在Makefile中可以使用函数来处理变量,函数调用后,函数的返回值可以当做变量来使用。
函数调用,很像变量的使用,也是以“$”来标识的,其语法如下:
$(<function> <arguments>)
或是
${<function> <arguments>}
这里,< function >就是函数名,make支持的函数不多。< arguments >是函数的参数,参数间以逗号“,”分隔,而函数名和参数之间以“空格”分隔。函数调用以“ $ ”开头,以圆括号或花括号把函数名和参数括起。函数中的参数可以使用变量,为了风格的统一,函数和变量的括号最好一样。
示例:
comma:= ,
empty:=
space:= $(empty) $(empty)
foo:= a b c
bar:= $(subst $(space),$(comma),$(foo))
在这个示例中,$(comma)的值是一个逗号。$(space)使用了$(empty)定义了一个空格,$(foo)的值是“a b c”,$(bar)的定义调用了函数“subst”,这是一个替换函数,这个函数有三个参数,第一个参数是被替换字串,第二个参数是替换字串,第三个参数是替换操作作用的字串。这个函数也就是把 (foo)中的空格替换成逗号,所以 (bar)的值是“a,b,c”。
字符串处理函数
$(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.o bar.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”。
$(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”。
$(words <text>;)
名称:单词个数统计函数——words。
功能:统计<text>;中字符串中的单词个数。
返回:返回<text>;中的单词数。
示例:$(words, foo bar baz)返回值是“3”。
备注:如果我们要取<text>;中最后的一个单词,我们可以这样:$(word $(words <text>;),<text>;)。
$(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搜索头文件路径的参数。
文件名操作函数
下面我们要介绍的函数主要是处理文件名的。每个函数的参数字符串都会被当做一个或是一系列的文件名来对待。
$(dir <names...>;)
名称:取目录函数——dir。
功能:从文件名序列<names>;中取出目录部分。目录部分是指最后一个反斜杠(“/”)之前的部分。如果没有反斜杠,那么返回“./”。
返回:返回文件名序列<names>;的目录部分。
示例: $(dir src/foo.c hacks)返回值是“src/ ./”。
$(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”。
origin函数
origin函数不像其它的函数,他并不操作变量的值,他只是告诉你你的这个变量是哪里来的?其语法是:
$(origin <variable>;)
注意,;是变量的名字,不应该是引用。所以你最好不要在;中使用“$”字符。Origin函数会以其返回值来告诉你这个变量的“出生情况”,下面,是origin函数的返回值:
“undefined”:如果;从来没有定义过,origin函数返回这个值“undefined”。
“default”:如果;是一个默认的定义,比如“CC”这个变量。
“environment”: 如果;是一个环境变量,并且当Makefile被执行时,“-e”参数没有被打开。
“file”:如果;这个变量被定义在Makefile中。
“command line”: 如果;这个变量是被命令行定义的。
“override”:如果;是被override指示符重新定义的。
“automatic”:如果;是一个命令运行中的自动化变量。
这些信息对于我们编写Makefile是非常有用的,例如,假设我们有一个Makefile其包了一个定义文件Make.def,在Make.def中定义了一个变量“bletch”,而我们的环境中也有一个环境变量“bletch”,此时,我们想判断一下,如果变量来源于环境,那么我们就把之重定义了,如果来源于Make.def或是命令行等非环境的,那么我们就不重新定义它。于是,在我们的Makefile中,我们可以这样写:
ifdef bletch
ifeq "$(origin bletch)" "environment"
bletch = barf, gag, etc.
endif
endif
shell函数
shell函数也不像其它的函数。顾名思义,它的参数应该就是操作系统Shell的命令。它和反引号“`”是相同的功能。这就是说,shell函数把执行操作系统命令后的输出作为函数返回。于是,我们可以用操作系统命令以及字符串处理命令awk,sed等等命令来生成一个变量,如:
contents := $(shell cat foo)
files := $(shell echo *.c)
注意,这个函数会新生成一个Shell程序来执行命令,所以你要注意其运行性能,如果你的Makefile中有一些比较复杂的规则,并大量使用了这个函数,那么对于你的系统性能是有害的。特别是Makefile的隐晦的规则可能会让你的shell函数执行的次数比你想像的多得多。