Chinaunix首页 | 论坛 | 博客
  • 博客访问: 544009
  • 博文数量: 99
  • 博客积分: 4010
  • 博客等级: 上校
  • 技术积分: 1117
  • 用 户 组: 普通用户
  • 注册时间: 2009-06-23 15:17
文章分类

全部博文(99)

文章存档

2011年(4)

2010年(13)

2009年(82)

我的朋友

分类: LINUX

2009-11-30 22:45:36

跟我一起写 Makefile(四)收藏
书写规则
————
 
规则包含两个部分,一个是依赖关系,一个是生成目标的方法。
 
在Makefile中,规则的顺序是很重要的,因为,Makefile中只应该有一个最终目标,其它的目标都是被这个目标所连带出来的,所以一定要让make知道你的最终目标是什么。一般来说,定义在Makefile中的目标可能会有很多,但是第一条规则中的目标将被确立为最终的目标。如果第一条规则中的目标有很多个,那么,第一个目标会成为最终的目标。make所完成的也就是这个目标。
 
好了,还是让我们来看一看如何书写规则。
 
 
一、规则举例
 
   foo.o : foo.c defs.h       # foo模块
           cc -c -g foo.c
 
看到这个例子,各位应该不是很陌生了,前面也已说过,foo.o是我们的目标,foo.c和defs.h是目标所依赖的源文件,而只有一个命令“cc -c -g foo.c”(以Tab键开头)。这个规则告诉我们两件事:
 
   1、文件的依赖关系,foo.o依赖于foo.c和defs.h的文件,如果foo.c和defs.h的文件日期要比foo.o文件日期要新,或是foo.o不存在,那么依赖关系发生。
   2、如果生成(或更新)foo.o文件。也就是那个cc命令,其说明了,如何生成foo.o这个文件。(当然foo.c文件include了defs.h文件)
 
 
二、规则的语法
 
     targets : prerequisites
       command
       ...
 
     或是这样:
 
     targets : prerequisites ; command
           command
           ...
 
targets是文件名,以空格分开,可以使用通配符。一般来说,我们的目标基本上是一个文件,但也有可能是多个文件。
 
command是命令行,如果其不与“target:prerequisites”在一行,那么,必须以[Tab键]开头,如果和prerequisites在一行,那么可以用分号做为分隔。(见上)
 
prerequisites也就是目标所依赖的文件(或依赖目标)。如果其中的某个文件要比目标文件要新,那么,目标就被认为是“过时的”,被认为是需要重生成的。这个在前面已经讲过了。
 
如果命令太长,你可以使用反斜框(‘\’)作为换行符。make对一行上有多少个字符没有限制。规则告诉make两件事,文件的依赖关系和如何成成目标文件。
 
一般来说,make会以UNIX的标准Shell,也就是/bin/sh来执行命令。
 
 
三、在规则中使用通配符
 
如果我们想定义一系列比较类似的文件,我们很自然地就想起使用通配符。make支持三各通配符:“*”,“?”和“[...]”。这是和Unix的B-Shell是相同的。
 
波浪号(“~”)字符在文件名中也有比较特殊的用途。如果是“~/test”,这就表示当前用户的$HOME目录下的test目录。而“~hchen/test”则表示用户hchen的宿主目录下的test目录。(这些都是Unix下的小知识了,make也支持)而在Windows或是MS-DOS下,用户没有宿主目录,那么波浪号所指的目录则根据环境变量“HOME”而定。
 
通配符代替了你一系列的文件,如“*.c”表示所以后缀为c的文件。一个需要我们注意的是,如果我们的文件名中有通配符,如:“*”,那么可以用转义字符“\”,如“\*”来表示真实的“*”字符,而不是任意长度的字符串。
 
好吧,还是先来看几个例子吧:
 
   clean:
        rm -f *.o
 
   上面这个例子我不不多说了,这是操作系统Shell所支持的通配符。这是在命令中的通配符。
 
   print: *.c
        lpr -p $?
        touch print
 
   上面这个例子说明了通配符也可以在我们的规则中,目标print依赖于所有的[.c]文件。其中的“$?”是一个自动化变量,我会在后面给你讲述。
 
   objects = *.o
 
   上面这个例子,表示了,通符同样可以用在变量中。并不是说[*.o]会展开,不!objects的值就是“*.o”。Makefile中的变量其实就是C/C++中的宏。如果你要让通配符在变量中展开,也就是让objects的值是所有[.o]的文件名的集合,那么,你可以这样:
 
   objects := $(wildcard *.o)
 
这种用法由关键字“wildcard”指出,关于Makefile的关键字,我们将在后面讨论。
 
 
四、文件搜寻
 
在一些大的工程中,有大量的源文件,我们通常的做法是把这许多的源文件分类,并存放在不同的目录中。所以,当make需要去找寻文件的依赖关系时,你可以在文件前加上路径,但最好的方法是把一个路径告诉make,让make在自动去找。
 
Makefile文件中的特殊变量“VPATH”就是完成这个功能的,如果没有指明这个变量,make只会在当前的目录中去找寻依赖文件和目标文件。如果定义了这个变量,那么,make就会在当当前目录找不到的情况下,到所指定的目录中去找寻文件了。
 
   VPATH = src:../headers
 
上面的的定义指定两个目录,“src”和“../headers”,make会按照这个顺序进行搜索。目录由“冒号”分隔。(当然,当前目录永远是最高优先搜索的地方)
 
另一个设置文件搜索路径的方法是使用make的“vpath”关键字(注意,它是全小写的),这不是变量,这是一个make的关键字,这和上面提到的那个VPATH变量很类似,但是它更为灵活。它可以指定不同的文件在不同的搜索目录中。这是一个很灵活的功能。它的使用方法有三种:
 
   1、vpath
 
   为符合模式的文件指定搜索目录
 
   2、vpath
 
   清除符合模式的文件的搜索目录。
 
   3、vpath
 
   清除所有已被设置好了的文件搜索目录。
 
vapth使用方法中的需要包含“%”字符。“%”的意思是匹配零或若干字符,例如,“%.h”表示所有以“.h”结尾的文件。指定了要搜索的文件集,而则指定了的文件集的搜索的目录。例如:
 
   vpath %.h ../headers
 
该语句表示,要求make在“../headers”目录下搜索所有以“.h”结尾的文件。(如果某文件在当前目录没有找到的话)
 
我们可以连续地使用vpath语句,以指定不同搜索策略。如果连续的vpath语句中出现了相同的,或是被重复了的,那么,make会按照vpath语句的先后顺序来执行搜索。如:
 
   vpath %.c foo
   vpath %   blish
   vpath %.c bar
 
其表示“.c”结尾的文件,先在“foo”目录,然后是“blish”,最后是“bar”目录。
 
   vpath %.c foo:bar
   vpath %   blish
 
而上面的语句则表示“.c”结尾的文件,先在“foo”目录,然后是“bar”目录,最后才是“blish”目录。
 
 
五、伪目标
 
最早先的一个例子中,我们提到过一个“clean”的目标,这是一个“伪目标”,
 
   clean:
           rm *.o temp
 
正像我们前面例子中的“clean”一样,即然我们生成了许多文件编译文件,我们也应该提供一个清除它们的“目标”以备完整地重编译而用。 (以“make clean”来使用该目标)
 
因为,我们并不生成“clean”这个文件。“伪目标”并不是一个文件,只是一个标签,由于“伪目标”不是文件,所以make无法生成它的依赖关系和决定它是否要执行。我们只有通过显示地指明这个“目标”才能让其生效。当然,“伪目标”的取名不能和文件名重名,不然其就失去了“伪目标”的意义了。
 
当然,为了避免和文件重名的这种情况,我们可以使用一个特殊的标记“.PHONY”来显示地指明一个目标是“伪目标”,向make说明,不管是否有这个文件,这个目标就是“伪目标”。
 
   .PHONY : clean
 
只要有这个声明,不管是否有“clean”文件,要运行“clean”这个目标,只有“make clean”这样。于是整个过程可以这样写:
 
    .PHONY: clean
   clean:
           rm *.o temp
 
伪目标一般没有依赖的文件。但是,我们也可以为伪目标指定所依赖的文件。伪目标同样可以作为“默认目标”,只要将其放在第一个。一个示例就是,如果你的Makefile需要一口气生成若干个可执行文件,但你只想简单地敲一个make完事,并且,所有的目标文件都写在一个Makefile中,那么你可以使用“伪目标”这个特性:
 
   all : prog1 prog2 prog3
   .PHONY : all
 
   prog1 : prog1.o utils.o
           cc -o prog1 prog1.o utils.o
 
   prog2 : prog2.o
           cc -o prog2 prog2.o
 
   prog3 : prog3.o sort.o utils.o
           cc -o prog3 prog3.o sort.o utils.o
 
我们知道,Makefile中的第一个目标会被作为其默认目标。我们声明了一个“all”的伪目标,其依赖于其它三个目标。由于伪目标的特性是,总是被执行的,所以其依赖的那三个目标就总是不如“all”这个目标新。所以,其它三个目标的规则总是会被决议。也就达到了我们一口气生成多个目标的目的。“.PHONY : all”声明了“all”这个目标为“伪目标”。
 
随便提一句,从上面的例子我们可以看出,目标也可以成为依赖。所以,伪目标同样也可成为依赖。看下面的例子:
 
   .PHONY: cleanall cleanobj cleandiff
 
   cleanall : cleanobj cleandiff
           rm program
 
   cleanobj :
           rm *.o
 
   cleandiff :
           rm *.diff
 
“make clean”将清除所有要被清除的文件。“cleanobj”和“cleandiff”这两个伪目标有点像“子程序”的意思。我们可以输入“make cleanall”和“make cleanobj”和“make cleandiff”命令来达到清除不同种类文件的目的。
 
 
跟我一起写 Makefile(六)收藏
书写命令
————
 
每条规则中的命令和操作系统Shell的命令行是一致的。make会一按顺序一条一条的执行命令,每条命令的开头必须以[Tab]键开头,除非,命令是紧跟在依赖规则后面的分号后的。在命令行之间中的空格或是空行会被忽略,但是如果该空格或空行是以Tab键开头的,那么make会认为其是一个空命令。
 
我们在UNIX下可能会使用不同的Shell,但是make的命令默认是被“/bin/sh”——UNIX的标准Shell解释执行的。除非你特别指定一个其它的Shell。Makefile中,“#”是注释符,很像C/C++中的“//”,其后的本行字符都被注释。
 
一、显示命令
 
通常,make会把其要执行的命令行在命令执行前输出到屏幕上。当我们用“@”字符在命令行前,那么,这个命令将不被make显示出来,最具代表性的例子是,我们用这个功能来像屏幕显示一些信息。如:
 
   @echo 正在编译XXX模块......
 
当make执行时,会输出“正在编译XXX模块......”字串,但不会输出命令,如果没有“@”,那么,make将输出:
 
   echo 正在编译XXX模块......
   正在编译XXX模块......
 
如果make执行时,带入make参数“-n”或“--just-print”,那么其只是显示命令,但不会执行命令,这个功能很有利于我们调试我们的Makefile,看看我们书写的命令是执行起来是什么样子的或是什么顺序的。
 
而make参数“-s”或“--slient”则是全面禁止命令的显示。
 
 
 
二、命令执行
 
当依赖目标新于目标时,也就是当规则的目标需要被更新时,make会一条一条的执行其后的命令。需要注意的是,如果你要让上一条命令的结果应用在下一条命令时,你应该使用分号分隔这两条命令。比如你的第一条命令是cd命令,你希望第二条命令得在cd之后的基础上运行,那么你就不能把这两条命令写在两行上,而应该把这两条命令写在一行上,用分号分隔。如:
 
   示例一:
       exec:
               cd /home/hchen
               pwd
 
   示例二:
       exec:
               cd /home/hchen; pwd
 
当我们执行“make exec”时,第一个例子中的cd没有作用,pwd会打印出当前的Makefile目录,而第二个例子中,cd就起作用了,pwd会打印出“/home/hchen”。
 
make一般是使用环境变量SHELL中所定义的系统Shell来执行命令,默认情况下使用UNIX的标准Shell——/bin/sh来执行命令。但在MS-DOS下有点特殊,因为MS-DOS下没有SHELL环境变量,当然你也可以指定。如果你指定了UNIX风格的目录形式,首先,make会在SHELL所指定的路径中找寻命令解释器,如果找不到,其会在当前盘符中的当前目录中寻找,如果再找不到,其会在PATH环境变量中所定义的所有路径中寻找。MS-DOS中,如果你定义的命令解释器没有找到,其会给你的命令解释器加上诸如“.exe”、“.com”、“.bat”、“.sh”等后缀。
 
 
 
三、命令出错
 
每当命令运行完后,make会检测每个命令的返回码,如果命令返回成功,那么make会执行下一条命令,当规则中所有的命令成功返回后,这个规则就算是成功完成了。如果一个规则中的某个命令出错了(命令退出码非零),那么make就会终止执行当前规则,这将有可能终止所有规则的执行。
 
有些时候,命令的出错并不表示就是错误的。例如mkdir命令,我们一定需要建立一个目录,如果目录不存在,那么mkdir就成功执行,万事大吉,如果目录存在,那么就出错了。我们之所以使用mkdir的意思就是一定要有这样的一个目录,于是我们就不希望mkdir出错而终止规则的运行。
 
为了做到这一点,忽略命令的出错,我们可以在Makefile的命令行前加一个减号“-”(在Tab键之后),标记为不管命令出不出错都认为是成功的。如:
 
  clean:
           -rm -f *.o
 
还有一个全局的办法是,给make加上“-i”或是“--ignore-errors”参数,那么,Makefile中所有命令都会忽略错误。而如果一个规则是以“.IGNORE”作为目标的,那么这个规则中的所有命令将会忽略错误。这些是不同级别的防止命令出错的方法,你可以根据你的不同喜欢设置。
 
还有一个要提一下的make的参数的是“-k”或是“--keep-going”,这个参数的意思是,如果某规则中的命令出错了,那么就终目该规则的执行,但继续执行其它规则。
 
 
 
四、嵌套执行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
 
如果你不想让某些变量传递到下级Makefile中,那么你可以这样声明:
 
   unexport
 
如:
    
   示例一:
 
       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”总是失效的。
 
 
 
五、定义命令包
 
如果Makefile中出现一些相同命令序列,那么我们可以为这些相同的命令序列定义一个变量。定义这种命令序列的语法以“define”开始,以“endef”结束,如:
 
   define run-yacc
   yacc $(firstword $^)
   mv y.tab.c $@
   endef
 
这里,“run-yacc”是这个命令包的名字,其不要和Makefile中的变量重名。在“define”和“endef”中的两行就是命令序列。这个命令包中的第一个命令是运行Yacc程序,因为Yacc程序总是生成“y.tab.c”的文件,所以第二行的命令就是把这个文件改改名字。还是把这个命令包放到一个示例中来看看吧。
 
   foo.c : foo.y
           $(run-yacc)
 
我们可以看见,要使用这个命令包,我们就好像使用变量一样。在这个命令包的使用中,命令包“run-yacc”中的“$^”就是“foo.y”,“$@”就是“foo.c”(有关这种以“$”开头的特殊变量,我们会在后面介绍),make在执行命令包时,命令包中的每个命令会被依次独立执行。
 
跟我一起写 Makefile(七)收藏
使用变量
————
 
在Makefile中的定义的变量,就像是C/C++语言中的宏一样,他代表了一个文本字串,在Makefile中执行的时候其会自动原模原样地展开在所使用的地方。其与C/C++所不同的是,你可以在Makefile中改变其值。在Makefile中,变量可以使用在“目标”,“依赖目标”,“命令”或是Makefile的其它部分中。
 
变量的命名字可以包含字符、数字,下划线(可以是数字开头),但不应该含有“:”、“#”、“=”或是空字符(空格、回车等)。变量是大小写敏感的,“foo”、“Foo”和“FOO”是三个不同的变量名。传统的Makefile的变量名是全大写的命名方式,但我推荐使用大小写搭配的变量名,如:MakeFlags。这样可以避免和系统的变量冲突,而发生意外的事情。
 
有一些变量是很奇怪字串,如“$<”、“$@”等,这些是自动化变量,我会在后面介绍。
 
一、变量的基础
 
变量在声明时需要给予初值,而在使用时,需要给在变量名前加上“$”符号,但最好用小括号“()”或是大括号“{}”把变量给包括起来。如果你要使用真实的“$”字符,那么你需要用“$$”来表示。
 
变量可以使用在许多地方,如规则中的“目标”、“依赖”、“命令”以及新的变量中。先看一个例子:
 
   objects = program.o foo.o utils.o
   program : $(objects)
           cc -o program $(objects)
 
   $(objects) : defs.h
 
变量会在使用它的地方精确地展开,就像C/C++中的宏一样,例如:
 
   foo = c
   prog.o : prog.$(foo)
           $(foo)$(foo) -$(foo) prog.$(foo)
 
展开后得到:
 
   prog.o : prog.c
           cc -c prog.c
 
当然,千万不要在你的Makefile中这样干,这里只是举个例子来表明Makefile中的变量在使用处展开的真实样子。可见其就是一个“替代”的原理。
 
另外,给变量加上括号完全是为了更加安全地使用这个变量,在上面的例子中,如果你不想给变量加上括号,那也可以,但我还是强烈建议你给变量加上括号。
 
 
二、变量中的变量
 
在定义变量的值时,我们可以使用其它变量来构造变量的值,在Makefile中有两种方式来在用变量定义变量的值。
 
先看第一种方式,也就是简单的使用“=”号,在“=”左侧是变量,右侧是变量的值,右侧变量的值可以定义在文件的任何一处,也就是说,右侧中的变量不一定非要是已定义好的值,其也可以使用后面定义的值。如:
 
   foo = $(bar)
   bar = $(ugh)
   ugh = Huh?
 
   all:
           echo $(foo)
 
我们执行“make all”将会打出变量$(foo)的值是“Huh?”( $(foo)的值是$(bar),$(bar)的值是$(ugh),$(ugh)的值是“Huh?”)可见,变量是可以使用后面的变量来定义的。
 
这个功能有好的地方,也有不好的地方,好的地方是,我们可以把变量的真实值推到后面来定义,如:
 
   CFLAGS = $(include_dirs) -O
   include_dirs = -Ifoo -Ibar
 
当“CFLAGS”在命令中被展开时,会是“-Ifoo -Ibar -O”。但这种形式也有不好的地方,那就是递归定义,如:
 
   CFLAGS = $(CFLAGS) -O
 
   或:
 
   A = $(B)
   B = $(A)
 
这会让make陷入无限的变量展开过程中去,当然,我们的make是有能力检测这样的定义,并会报错。还有就是如果在变量中使用函数,那么,这种方式会让我们的make运行时非常慢,更糟糕的是,他会使用得两个make的函数“wildcard”和“shell”发生不可预知的错误。因为你不会知道这两个函数会被调用多少次。
 
为了避免上面的这种方法,我们可以使用make中的另一种用变量来定义变量的方法。这种方法使用的是“:=”操作符,如:
 
   x := foo
   y := $(x) bar
   x := later
 
其等价于:
 
   y := foo bar
   x := later
 
值得一提的是,这种方法,前面的变量不能使用后面的变量,只能使用前面已定义好了的变量。如果是这样:
 
   y := $(x) bar
   x := foo
 
那么,y的值是“bar”,而不是“foo bar”。
 
上面都是一些比较简单的变量使用了,让我们来看一个复杂的例子,其中包括了make的函数、条件表达式和一个系统变量“MAKELEVEL”的使用:
 
   ifeq (0,${MAKELEVEL})
   cur-dir   := $(shell pwd)
   whoami    := $(shell whoami)
   host-type := $(shell arch)
   MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}
   endif
 
关于条件表达式和函数,我们在后面再说,对于系统变量“MAKELEVEL”,其意思是,如果我们的make有一个嵌套执行的动作(参见前面的“嵌套使用make”),那么,这个变量会记录了我们的当前Makefile的调用层数。
 
下面再介绍两个定义变量时我们需要知道的,请先看一个例子,如果我们要定义一个变量,其值是一个空格,那么我们可以这样来:
 
   nullstring :=
   space := $(nullstring) # end of the line
 
nullstring是一个Empty变量,其中什么也没有,而我们的space的值是一个空格。因为在操作符的右边是很难描述一个空格的,这里采用的技术很管用,先用一个Empty变量来标明变量的值开始了,而后面采用“#”注释符来表示变量定义的终止,这样,我们可以定义出其值是一个空格的变量。请注意这里关于“#”的使用,注释符“#”的这种特性值得我们注意,如果我们这样定义一个变量:
 
   dir := /foo/bar    # directory to put the frobs in
 
dir这个变量的值是“/foo/bar”,后面还跟了4个空格,如果我们这样使用这样变量来指定别的目录——“$(dir)/file”那么就完蛋了。
 
还有一个比较有用的操作符是“?=”,先看示例:
 
   FOO ?= bar
 
其含义是,如果FOO没有被定义过,那么变量FOO的值就是“bar”,如果FOO先前被定义过,那么这条语将什么也不做,其等价于:
 
   ifeq ($(origin FOO), undefined)
     FOO = bar
   endif
 
 
三、变量高级用法
 
这里介绍两种变量的高级使用方法,第一种是变量值的替换。
 
我们可以替换变量中的共有的部分,其格式是“$(var:a=b)”或是“${var:a=b}”,其意思是,把变量“var”中所有以“a”字串“结尾”的“a”替换成“b”字串。这里的“结尾”意思是“空格”或是“结束符”。
 
还是看一个示例吧:
 
   foo := a.o b.o c.o
   bar := $(foo:.o=.c)
 
这个示例中,我们先定义了一个“$(foo)”变量,而第二行的意思是把“$(foo)”中所有以“.o”字串“结尾”全部替换成“.c”,所以我们的“$(bar)”的值就是“a.c b.c c.c”。
 
另外一种变量替换的技术是以“静态模式”(参见前面章节)定义的,如:
 
   foo := a.o b.o c.o
   bar := $(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)”)
 
我们还可以使用更多的层次:
 
   x = y
   y = z
   z = u
   a := $($($(x)))
 
这里的$(a)的值是“u”,相关的推导留给读者自己去做吧。
 
让我们再复杂一点,使用上“在变量定义中使用变量”的第一个方式,来看一个例子:
 
   x = $(y)
   y = z
   z = Hello
   a := $($(x))
 
这里的$($(x))被替换成了$($(y)),因为$(y)值是“z”,所以,最终结果是:a:=$(z),也就是“Hello”。
 
再复杂一点,我们再加上函数:
 
   x = variable1
   variable2 := Hello
   y = $(subst 1,2,$(x))
   z = y
   a := $($($(z)))
 
这个例子中,“$($($(z)))”扩展为“$($(y))”,而其再次被扩展为“$($(subst 1,2,$(x)))”。$(x)的值是“variable1”,subst函数把“variable1”中的所有“1”字串替换成“2”字串,于是,“variable1”变成“variable2”,再取其值,所以,最终,$(a)的值就是$(variable2)的值——“Hello”。(喔,好不容易)
 
在这种方式中,或要可以使用多个变量来组成一个变量的名字,然后再取其值:
 
   first_second = Hello
   a = first
   b = second
   all = $($a_$b)
 
这里的“$a_$b”组成了“first_second”,于是,$(all)的值就是“Hello”。
 
再来看看结合第一种技术的例子:
 
   a_objects := a.o b.o c.o
   1_objects := 1.o 2.o 3.o
 
   sources := $($(a1)_objects:.o=.c)
 
这个例子中,如果$(a1)的值是“a”的话,那么,$(sources)的值就是“a.c b.c c.c”;如果$(a1)的值是“1”,那么$(sources)的值是“1.c 2.c 3.c”。
 
再来看一个这种技术和“函数”与“条件语句”一同使用的例子:
 
   ifdef do_sort
   func := sort
   else
   func := strip
   endif
 
   bar := a d b g q c
 
   foo := $($(func) $(bar))
 
这个示例中,如果定义了“do_sort”,那么:foo := $(sort a d b g q c),于是$(foo)的值就是“a b c d g q”,而如果没有定义“do_sort”,那么:foo := $(sort a d b g q c),调用的就是strip函数。
 
当然,“把变量的值再当成变量”这种技术,同样可以用在操作符的左边:
 
   dir = foo
   $(dir)_sources := $(wildcard $(dir)/*.c)
   define $(dir)_print
   lpr $($(dir)_sources)
   endef
 
这个例子中定义了三个变量:“dir”,“foo_sources”和“foo_print”。
 
 
四、追加变量值
 
我们可以使用“+=”操作符给变量追加值,如:
 
   objects = main.o foo.o bar.o utils.o
   objects += another.o
 
于是,我们的$(objects)值变成:“main.o foo.o bar.o utils.o another.o”(another.o被追加进去了)
 
使用“+=”操作符,可以模拟为下面的这种例子:
 
   objects = main.o foo.o bar.o utils.o
   objects := $(objects) another.o
 
所不同的是,用“+=”更为简洁。
 
如果变量之前没有定义过,那么,“+=”会自动变成“=”,如果前面有变量定义,那么“+=”会继承于前次操作的赋值符。如果前一次的是“:=”,那么“+=”会以“:=”作为其赋值符,如:
 
   variable := value
   variable += more
 
等价于:
 
   variable := value
   variable := $(variable) more
 
但如果是这种情况:
 
   variable = value
   variable += more
 
由于前次的赋值符是“=”,所以“+=”也会以“=”来做为赋值,那么岂不会发生变量的递补归定义,这是很不好的,所以make会自动为我们解决这个问题,我们不必担心这个问题。
 
 
五、override 指示符
 
如果有变量是通常make的命令行参数设置的,那么Makefile中对这个变量的赋值会被忽略。如果你想在Makefile中设置这类参数的值,那么,你可以使用“override”指示符。其语法是:
 
   override =
 
   override :=
 
当然,你还可以追加:
 
   override +=
 
对于多行的变量定义,我们用define指示符,在define指示符前,也同样可以使用ovveride指示符,如:
 
   override define foo
   bar
   endef
 
跟我一起写 Makefile(八)收藏
六、多行变量
 
还有一种设置变量值的方法是使用define关键字。使用define关键字设置变量的值可以有换行,这有利于定义一系列的命令(前面我们讲过“命令包”的技术就是利用这个关键字)。
 
define指示符后面跟的是变量的名字,而重起一行定义变量的值,定义是以endef关键字结束。其工作方式和“=”操作符一样。变量的值可以包含函数、命令、文字,或是其它变量。因为命令需要以[Tab]键开头,所以如果你用define定义的命令变量中没有以[Tab]键开头,那么make就不会把其认为是命令。
 
下面的这个示例展示了define的用法:
 
   define two-lines
   echo foo
   echo $(bar)
   endef
 
 
七、环境变量
 
make运行时的系统环境变量可以在make开始运行时被载入到Makefile文件中,但是如果Makefile中已定义了这个变量,或是这个变量由make命令行带入,那么系统的环境变量的值将被覆盖。(如果make指定了“-e”参数,那么,系统环境变量将覆盖Makefile中定义的变量)
 
因此,如果我们在环境变量中设置了“CFLAGS”环境变量,那么我们就可以在所有的Makefile中使用这个变量了。这对于我们使用统一的编译参数有比较大的好处。如果Makefile中定义了CFLAGS,那么则会使用Makefile中的这个变量,如果没有定义则使用系统环境变量的值,一个共性和个性的统一,很像“全局变量”和“局部变量”的特性。
 
当make嵌套调用时(参见前面的“嵌套调用”章节),上层Makefile中定义的变量会以系统环境变量的方式传递到下层的Makefile中。当然,默认情况下,只有通过命令行设置的变量会被传递。而定义在文件中的变量,如果要向下层Makefile传递,则需要使用exprot关键字来声明。(参见前面章节)
 
当然,我并不推荐把许多的变量都定义在系统环境中,这样,在我们执行不用的Makefile时,拥有的是同一套系统变量,这可能会带来更多的麻烦。
 
 
八、目标变量
 
前面我们所讲的在Makefile中定义的变量都是“全局变量”,在整个文件,我们都可以访问这些变量。当然,“自动化变量”除外,如“$<”等这种类量的自动化变量就属于“规则型变量”,这种变量的值依赖于规则的目标和依赖目标的定义。
 
当然,我样同样可以为某个目标设置局部变量,这种变量被称为“Target-specific Variable”,它可以和“全局变量”同名,因为它的作用范围只在这条规则以及连带规则中,所以其值也只在作用范围内有效。而不会影响规则链以外的全局变量的值。
 
其语法是:
 
    :
 
    : overide
 
可以是前面讲过的各种赋值表达式,如“=”、“:=”、“+=”或是“?=”。第二个语法是针对于make命令行带入的变量,或是系统环境变量。
 
这个特性非常的有用,当我们设置了这样一个变量,这个变量会作用到由这个目标所引发的所有的规则中去。如:
 
   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
 
同样,模式变量的语法和“目标变量”一样:
 
    :
 
    : override
 
override同样是针对于系统环境传入的变量,或是make命令行指定的变量。
 
 
 
使用条件判断
——————
 
使用条件判断,可以让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结束。
 
当我们的变量$(CC)值是“gcc”时,目标foo的规则是:
 
   foo: $(objects)
           $(CC) -o foo $(objects) $(libs_for_gcc)
 
而当我们的变量$(CC)值不是“gcc”时(比如“cc”),目标foo的规则是:
 
   foo: $(objects)
           $(CC) -o foo $(objects) $(normal_libs)
 
当然,我们还可以把上面的那个例子写得更简洁一些:
 
   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)
 
 
二、语法
 
条件表达式的语法为:
 
   
   
   endif
 
以及:
 
   
   
   else
   
   endif
 
其中表示条件关键字,如“ifeq”。这个关键字有四个。
 
第一个是我们前面所见过的“ifeq”
 
   ifeq (, )
   ifeq '' ''
   ifeq "" ""
   ifeq "" ''
   ifeq '' ""
 
比较参数“arg1”和“arg2”的值是否相同。当然,参数中我们还可以使用make的函数。如:
 
   ifeq ($(strip $(foo)),)
   
   endif
 
这个示例中使用了“strip”函数,如果这个函数的返回值是空(Empty),那么就生效。
 
第二个条件关键字是“ifneq”。语法是:
 
   ifneq (, )
   ifneq '' ''
   ifneq "" ""
   ifneq "" ''
   ifneq '' ""
 
其比较参数“arg1”和“arg2”的值是否相同,如果不同,则为真。和“ifeq”类似。
 
第三个条件关键字是“ifdef”。语法是:
 
   ifdef
 
如果变量的值非空,那到表达式为真。否则,表达式为假。当然,同样可以是一个函数的返回值。注意,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
 
这个我就不多说了,和“ifdef”是相反的意思。
 
这一行上,多余的空格是被允许的,但是不能以[Tab]键做为开始(不然就被认为是命令)。而注释符“#”同样也是安全的。“else”和“endif”也一样,只要不是以[Tab]键开始就行了。
 
特别注意的是,make是在读取Makefile时就计算条件表达式的值,并根据条件表达式的值来选择语句,所以,你最好不要把自动化变量(如“$@”等)放入条件表达式中,因为自动化变量是在运行时才有的。
 
而且,为了避免混乱,make不允许把整个条件语句分成两部分放在不同的文件中。
 
 
跟我一起写 Makefile(九)收藏
使用函数
————
 
在Makefile中可以使用函数来处理变量,从而让我们的命令或是规则更为的灵活和具有智能。make所支持的函数也不算很多,不过已经足够我们的操作了。函数调用后,函数的返回值可以当做变量来使用。
 
 
一、函数的调用语法
 
函数调用,很像变量的使用,也是以“$”来标识的,其语法如下:
 
   $( )
 
或是
 
   ${ }
 
这里,就是函数名,make支持的函数不多。是函数的参数,参数间以逗号“,”分隔,而函数名和参数之间以“空格”分隔。函数调用以“$”开头,以圆括号或花括号把函数名和参数括起。感觉很像一个变量,是不是?函数中的参数可以使用变量,为了风格的统一,函数和变量的括号最好一样,如使用“$(subst a,b,$(x))”这样的形式,而不是“$(subst a,b,${x})”的形式。因为统一会更清楚,也会减少一些不必要的麻烦。
 
还是来看一个示例:
 
   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 ,,)
 
   名称:字符串替换函数——subst。
   功能:把字串中的字符串替换成
   返回:函数返回被替换过后的字符串。
 
   示例:
        
       $(subst ee,EE,feet on the street),
        
       把“feet on the street”中的“ee”替换成“EE”,返回结果是“fEEt on the strEEt”。
 
 
$(patsubst ,,)
 
   名称:模式字符串替换函数——patsubst。
   功能:查找中的单词(单词以“空格”、“Tab”或“回车”“换行”分隔)是否符合模式,如果匹配的话,则以替换。这里,可以包括通配符“%”,表示任意长度的字串。如果中也包含“%”,那么,中的这个“%”将是中的那个“%”所代表的字串。(可以用“\”来转义,以“\%”来表示真实含义的“%”字符)
   返回:函数返回被替换过后的字符串。
 
   示例:
 
       $(patsubst %.c,%.o,x.c.c bar.c)
 
       把字串“x.c.c bar.c”符合模式[%.c]的单词替换成[%.o],返回结果是“x.c.o bar.o”
 
   备注:
 
       这和我们前面“变量章节”说过的相关知识有点相似。如:
 
       “$(var:=)”
        相当于
       “$(patsubst ,,$(var))”,
 
        而“$(var: =)”
        则相当于
        “$(patsubst %,%,$(var))”。
 
        例如有:objects = foo.o bar.o baz.o,
        那么,“$(objects:.o=.c)”和“$(patsubst %.o,%.c,$(objects))”是一样的。
 
$(strip )
 
   名称:去空格函数——strip。
   功能:去掉字串中开头和结尾的空字符。
   返回:返回被去掉空格的字符串值。
   示例:
        
       $(strip a b c )
 
       把字串“a b c ”去到开头和结尾的空格,结果是“a b c”。
 
$(findstring ,)
 
   名称:查找字符串函数——findstring。
   功能:在字串中查找字串。
   返回:如果找到,那么返回,否则返回空字符串。
   示例:
 
       $(findstring a,a b c)
       $(findstring a,b c)
 
       第一个函数返回“a”字符串,第二个返回“”字符串(空字符串)
 
$(filter ,)
 
   名称:过滤函数——filter。
   功能:以模式过滤字符串中的单词,保留符合模式的单词。可以有多个模式。
   返回:返回符合模式的字串。
   示例:
 
       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 ,)
 
   名称:反过滤函数——filter-out。
   功能:以模式过滤字符串中的单词,去除符合模式的单词。可以有多个模式。
   返回:返回不符合模式的字串。
   示例:
 
       objects=main1.o foo.o main2.o bar.o
       mains=main1.o main2.o
        
       $(filter-out $(mains),$(objects)) 返回值是“foo.o bar.o”。
        
$(sort )
 
   名称:排序函数——sort。
   功能:给字符串中的单词排序(升序)。
   返回:返回排序后的字符串。
   示例:$(sort foo bar lose)返回“bar foo lose” 。
   备注:sort函数会去掉中相同的单词。
 
$(word ,)
 
   名称:取单词函数——word。
   功能:取字符串中第个单词。(从一开始)
   返回:返回字符串中第个单词。如果中的单词数要大,那么返回空字符串。
   示例:$(word 2, foo bar baz)返回值是“bar”。
 
$(wordlist ,,)  
 
   名称:取单词串函数——wordlist。
   功能:从字符串中取从开始到的单词串。是一个数字。
   返回:返回字符串中从的单词字串。如果中的单词数要大,那么返回空字符串。如果大于的单词数,那么返回从开始,到结束的单词串。
   示例: $(wordlist 2, 3, foo bar baz)返回值是“bar baz”。
 
$(words )
 
   名称:单词个数统计函数——words。
   功能:统计中字符串中的单词个数。
   返回:返回中的单词数。
   示例:$(words, foo bar baz)返回值是“3”。
   备注:如果我们要取中最后的一个单词,我们可以这样:$(word $(words ),)。
 
$(firstword )
 
   名称:首单词函数——firstword。
   功能:取字符串中的第一个单词。
   返回:返回字符串的第一个单词。
   示例:$(firstword foo bar)返回值是“foo”。
   备注:这个函数可以用word函数来实现:$(word 1,)。
 
以上,是所有的字符串操作函数,如果搭配混合使用,可以完成比较复杂的功能。这里,举一个现实中应用的例子。我们知道,make使用“VPATH”变量来指定“依赖文件”的搜索路径。于是,我们可以利用这个搜索路径来指定编译器对头文件的搜索路径参数CFLAGS,如:
 
   override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH)))
 
   如果我们的“$(VPATH)”值是“src:../headers”,那么“$(patsubst %,-I%,$(subst :, ,$(VPATH)))”将返回“-Isrc -I../headers”,这正是cc或gcc搜索头文件路径的参数。
 
 
三、文件名操作函数
 
下面我们要介绍的函数主要是处理文件名的。每个函数的参数字符串都会被当做一个或是一系列的文件名来对待。
 
$(dir )
 
   名称:取目录函数——dir。
   功能:从文件名序列中取出目录部分。目录部分是指最后一个反斜杠(“/”)之前的部分。如果没有反斜杠,那么返回“./”。
   返回:返回文件名序列的目录部分。
   示例: $(dir src/foo.c hacks)返回值是“src/ ./”。
 
$(notdir )
 
   名称:取文件函数——notdir。
   功能:从文件名序列中取出非目录部分。非目录部分是指最后一个反斜杠(“/”)之后的部分。
   返回:返回文件名序列的非目录部分。
   示例: $(notdir src/foo.c hacks)返回值是“foo.c hacks”。
 
$(suffix )
    
   名称:取后缀函数——suffix。
   功能:从文件名序列中取出各个文件名的后缀。
   返回:返回文件名序列的后缀序列,如果文件没有后缀,则返回空字串。
   示例:$(suffix src/foo.c src-1.0/bar.c hacks)返回值是“.c .c”。
 
$(basename )
 
   名称:取前缀函数——basename。
   功能:从文件名序列中取出各个文件名的前缀部分。
   返回:返回文件名序列的前缀序列,如果文件没有前缀,则返回空字串。
   示例:$(basename src/foo.c src-1.0/bar.c hacks)返回值是“src/foo src-1.0/bar hacks”。
 
$(addsuffix ,)
 
   名称:加后缀函数——addsuffix。
   功能:把后缀加到中的每个单词后面。
   返回:返回加过后缀的文件名序列。
   示例:$(addsuffix .c,foo bar)返回值是“foo.c bar.c”。
 
$(addprefix ,)
 
   名称:加前缀函数——addprefix。
   功能:把前缀加到中的每个单词后面。
   返回:返回加过前缀的文件名序列。
   示例:$(addprefix src/,foo bar)返回值是“src/foo src/bar”。
 
$(join ,)
 
   名称:连接函数——join。
   功能:把中的单词对应地加到的单词后面。如果的单词个数要比的多,那么,中的多出来的单词将保持原样。如果的单词个数要比多,那么,多出来的单词将被复制到中。
   返回:返回连接过后的字符串。
   示例:$(join aaa bbb , 111 222 333)返回值是“aaa111 bbb222 333”。
 
跟我一起写 Makefile(十)收藏
 
四、foreach 函数
 
 
foreach函数和别的函数非常的不一样。因为这个函数是用来做循环用的,Makefile中的foreach函数几乎是仿照于Unix标准Shell(/bin/sh)中的for语句,或是C-Shell(/bin/csh)中的foreach语句而构建的。它的语法是:
 
 
 
   $(foreach ,,)
 
 
 
这个函数的意思是,把参数中的单词逐一取出放到参数所指定的变量中,然后再执行所包含的表达式。每一次会返回一个字符串,循环过程中,的所返回的每个字符串会以空格分隔,最后当整个循环结束时,所返回的每个字符串所组成的整个字符串(以空格分隔)将会是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”。
 
 
 
注意,foreach中的参数是一个临时的局部变量,foreach函数执行完后,参数的变量将不在作用,其作用域只在foreach函数当中。
 
 
 
 
 
五、if 函数
 
 
if函数很像GNU的make所支持的条件语句——ifeq(参见前面所述的章节),if函数的语法是:
 
 
 
   $(if ,)
 
 
 
或是
 
 
 
   $(if ,,)
 
 
 
可见,if函数可以包含“else”部分,或是不含。即if函数的参数可以是两个,也可以是三个。参数是if的表达式,如果其返回的为非空字符串,那么这个表达式就相当于返回真,于是,会被计算,否则会被计算。
 
 
 
而if函数的返回值是,如果为真(非空字符串),那个会是整个函数的返回值,如果为假(空字符串),那么会是整个函数的返回值,此时如果没有被定义,那么,整个函数返回空字串。
 
 
 
所以,只会有一个被计算。
 
 
 
 
 
六、call函数
 
 
call函数是唯一一个可以用来创建新的参数化的函数。你可以写一个非常复杂的表达式,这个表达式中,你可以定义许多参数,然后你可以用call函数来向这个表达式传递参数。其语法是:
 
 
 
   $(call ,,,...)
 
 
 
当make执行这个函数时,参数中的变量,如$(1),$(2),$(3)等,会被参数依次取代。而的返回值就是call函数的返回值。例如:
 
   reverse =  $(1) $(2)
 
   foo = $(call reverse,a,b)
 
 
 
那么,foo的值就是“a b”。当然,参数的次序是可以自定义的,不一定是顺序的,如:
 
 
 
   reverse =  $(2) $(1)
 
   foo = $(call reverse,a,b)
 
 
 
此时的foo的值就是“b a”。
 
 
 
 
 
七、origin函数
origin函数不像其它的函数,他并不操作变量的值,他只是告诉你你的这个变量是哪里来的?其语法是:
 
 
 
   $(origin )
 
 
 
注意,是变量的名字,不应该是引用。所以你最好不要在中使用“$”字符。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
 
 
 
当然,你也许会说,使用override关键字不就可以重新定义环境中的变量了吗?为什么需要使用这样的步骤?是的,我们用override是可以达到这样的效果,可是override过于粗暴,它同时会把从命令行定义的变量也覆盖了,而我们只想重新定义环境传来的,而不想重新定义命令行传来的。
 
 
 
 
 
八、shell函数
 
 
shell函数也不像其它的函数。顾名思义,它的参数应该就是操作系统Shell的命令。它和反引号“`”是相同的功能。这就是说,shell函数把执行操作系统命令后的输出作为函数返回。于是,我们可以用操作系统命令以及字符串处理命令awk,sed等等命令来生成一个变量,如:
 
 
 
   contents := $(shell cat foo)
 
 
 
   files := $(shell echo *.c)
 
 
 
注意,这个函数会新生成一个Shell程序来执行命令,所以你要注意其运行性能,如果你的Makefile中有一些比较复杂的规则,并大量使用了这个函数,那么对于你的系统性能是有害的。特别是Makefile的隐晦的规则可能会让你的shell函数执行的次数比你想像的多得多。
 
 
 
 
 
九、控制make的函数
 
 
make提供了一些函数来控制make的运行。通常,你需要检测一些运行Makefile时的运行时信息,并且根据这些信息来决定,你是让make继续执行,还是停止。
 
 
 
$(error )
 
 
 
   产生一个致命的错误,是错误信息。注意,error函数不会在一被使用就会产生错误信息,所以如果你把其定义在某个变量中,并在后续的脚本中使用这个变量,那么也是可以的。例如:
 
 
 
   示例一:
 
   ifdef ERROR_001
 
   $(error error is $(ERROR_001))
 
   endif
 
 
 
   示例二:
 
   ERR = $(error found an error!)
 
   .PHONY: err
 
   err: ; $(ERR)
 
 
 
   示例一会在变量ERROR_001定义了后执行时产生error调用,而示例二则在目录err被执行时才发生error调用。
 
 
 
$(warning )
 
 
 
    这个函数很像error函数,只是它并不会让make退出,只是输出一段警告信息,而make继续执行。
阅读(1844) | 评论(0) | 转发(1) |
给主人留下些什么吧!~~