美文网首页
makefile相关

makefile相关

作者: 小y同学hh | 来源:发表于2020-11-13 11:49 被阅读0次

    Makefile的规则

    在讲述这个Makefile之前,还是让我们先来粗略地看一看Makefile的规则。

    target ... : prerequisites

    ...

    command

    ...

    ...

    target也就是一个目标文件,可以是Object File,也可以是执行文件。还可以是一个标签(Label),对于标签这种特性,在后续的“伪目标”章节中会有叙述。

    prerequisites就是,要生成那个target所需要的文件或是目标。

    command也就是make需要执行的命令。(任意的Shell命令)

    例:

    edit : main.o kbd.o command.o display.o

    cc -o edit main.o kbd.o command.o display.o

    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

    clean:

    rm edit main.o kbd.o command.o display.o

    通用makefile模板

    CC=gcc #指定编译方式

    CFLAGS=-Wall #显示所有警告

    LIBS = -lm

    TARGET=main #目标文件

    #当前文件夹所有.c文件

    SRCS = $(wildcard *.c)

    #对应.o

    OBJS = $(SRCS:.c=.o)

    #目标:依赖

    $(TARGET):$(OBJS)

    #$@:目标文件$^:所有依赖文件

        $(CC) -o $@ $^ $(LIBS)

    clean:

        rm -rf $(TARGET)$(OBJS)

    %.o:%.c

    #所有目标依赖对应,$<只对应第一个依赖

        $(CC) $(CFLAGS) -o $@-c $<

    在这个makefile中,目标文件(target)包含:执行文件edit和中间目标文件(*.o),依赖文件(prerequisites)就是冒号后面的那些.c 文件和.h 文件。

    每一个.o 文件都有一组依赖文件,而这些.o 文件又是执行文件edit 的依赖文件。

    在定义好依赖关系后,后续的那一行定义了如何生成目标文件的操作系统命令,一定要以一个Tab键作为开头。

    make会比较targets文件和prerequisites文件的修改日期,如果prerequisites文件的日期要比targets文件的日期要新,或者target不存在的话,那么,make就会执行后续定义的命令。

    make的工作流程

    在默认的方式下,也就是我们只输入make命令。那么,

    1、make会在当前目录下找名字叫“Makefile”或“makefile”的文件。

    2、如果找到,它会找文件中的第一个目标文件(target),在上面的例子中,他会找到“edit”这个文件,并把这个文件作为最终的目标文件。

    3、如果edit文件不存在,或是edit所依赖的后面的.o 文件的文件修改时间要比edit这个文件新,那么,他就会执行后面所定义的命令来生成edit这个文件。

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

    5、当然,你的C文件和H文件是存在的啦,于是make会生成.o文件,然后再用.o 文件生命make的终极任务,也就是执行文件edit了。

    通过上述分析,我们知道,像clean这种,没有被第一个目标文件直接或间接关联,那么它后面所定义的命令将不会被自动执行,不过,我们可以显示要make执行。即命令——“make clean”,以此来清除所有的目标文件,以便重编译。

    于是在我们编程中,如果这个工程已被编译过了,当我们修改了其中一个源文件,比如file.c,那么根据我们的依赖性,我们的目标file.o会被重编译(也就是在这个依性关系后面所定义的命令),于是file.o的文件也是最新的啦,于是file.o的文件修改时间要比edit要新,所以edit也会被重新链接了(详见edit目标文件后定义的命令)。

    makefile中使用变量$(objects)

    对于重复出现的[.o]文件,我们声明一个变量,叫objects,OBJECTS,objs,OBJS,obj或是OBJ,我们在makefile一开始就定义:

    objects = main.o kbd.o command.o display.o

    于是,在makefile中以$(objects)的方式来使用这个变量,于是makefile可以写成:

    objects = main.o kbd.o command.o display.o

        edit:$(objects)

        cc –o edit $(objects)

        …

        clean:

           rm edit $(objects)

    于是如果有新的.o文件加入,只需要简单修改一下objects变量。

    make自动推导

    GNU的make很强大,它可以自动推导文件以及文件依赖关系后面的命令。于是我们就没必要去在每一个[.o]文件后都写上类似的命令,因为,我们的make会自动识别,并自己推导命令。

    只要make看到一个[.o]文件,它就会自动的把[.c]文件加在依赖关系中,如果make找到一个whatever.o,那 么whatever.c,就会是whatever.o的依赖文件。并且cc -c whatever.c 也会被推导出来,于是,我们的makefile再也不用写得这么复杂。我们的是新的makefile又出炉了。

    objects = main.o kbd.o command.o display.o \

    insert.o search.o files.o utils.o

    edit : $(objects)

    cc -o edit $(objects)

    main.o : defs.h

    kbd.o : defs.h command.h

    command.o : defs.h command.h

    display.o : defs.h buffer.h

    insert.o : defs.h buffer.h

    search.o : defs.h buffer.h

    files.o : defs.h buffer.h command.h

    utils.o : defs.h

    .PHONY : clean

    clean :

    rm edit $(objects)

    这种方法,也就是make的“隐晦规则”。上面文件内容中,“.PHONY”表示,clean是个伪目标文件。

    即然我们的make可以自动推导命令,那么我看到那堆[.o]和[.h]的依赖就有点不爽,那么多的重复的[.h],能不能把其收拢起来

    objects = main.o kbd.o command.o display.o \

    insert.o search.o files.o utils.o

    edit : $(objects)

    cc -o edit $(objects)

    $(objects) : defs.h

    kbd.o command.o files.o : command.h

    display.o insert.o search.o files.o : buffer.h

    .PHONY : clean

    clean :

    rm edit $(objects)

    清空目标文件的规则

    更为稳健的做法是:

    .PHONY :

    clean

    clean :

    -rm edit $(objects)

    前面说过,.PHONY 意思表示clean是一个“伪目标”,。而在rm命令前面加了一个小减号的意思就是,也许某些文件出现问题,但不要管,继续做后面的事。当然,clean的规则不要放在文件的开头,不然,这就会变成make的默认目标,相信谁也不愿意这样。不成文的规矩是——“clean从来都是放在文件的最后”。

    makefile的组成

    Makefile里主要包含了五个东西:显式规则、隐晦规则、变量定义、文件指示和注释。

    1、显式规则。显式规则说明了,如何生成一个或多的的目标文件。这是由Makefile的书写者明显指出,要生成的文件,文件的依赖文件,生成的命令。

    2、隐晦规则。由于我们的make有自动推导的功能,所以隐晦的规则可以让我们比较粗糙地简略地书写Makefile,这是由make所支持的。

    3、变量的定义。在Makefile中我们要定义一系列的变量,变量一般都是字符串,这个有点你C语言中的宏,当Makefile被执行时,其中的变量都会被扩展到相应的引用位置上。

    4、文件指示。其包括了三个部分,一个是在一个Makefile中引用另一个Makefile,就像C语言中的include一样;另一个是指根据某些情况指定Makefile中的有效部分,就像C语言中的预编译#if一样;还有就是定义一个多行的命令。有关这一部分的内容,我会在后续的部分中讲述。

    5、注释。Makefile中只有行注释,和UNIX的Shell脚本一样,其注释是用“#”字符,这个就像C/C++中的“//”一样。如果你要在你的Makefile中使用“#”字符,可以用反斜框进行转义,如:“\#”。

    最后,还值得一提的是,在Makefile中的命令,必须要以[Tab]键开始。

    Makefile的文件名

    默认的情况下,make命令会在当前目录下按顺序找寻文件名为“GNUmakefile”、

    “makefile”、“Makefile”的文件,找到了解释这个文件。在这三个文件名中,最好使用“Makefile”这个文件名,因为,这个文件名第一个字符为大写,这样有一种显目的感觉。

    引用其他的makefile

    在Makefile使用include关键字可以把别的Makefile包含进来,这很像C语言的#include,被包含的文件会原模原样的放在当前文件的包含位置,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的工作方式

    GNU的make工作时的执行步骤入下:(想来其它的make也是类似)

    1、读入所有的Makefile。

    2、读入被include的其它Makefile。

    3、初始化文件中的变量。

    4、推导隐晦规则,并分析所有规则。

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

    6、根据依赖关系,决定哪些目标要重新生成。

    7、执行生成命令。

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

    makefile书写规则

    规则包含两个部分,一个是依赖关系,一个是生成目标的方法。

    command是命令行,如果其不与“target:prerequisites”在一行,那么,必须以[Tab键]开头,如果和prerequisites在一行,那么可以用分号做为分隔。

    如果命令太长,你可以使用反斜框(‘\’)作为换行符。

    一般来说,make会以UNIX的标准Shell,也就是/bin/sh来执行命令。

    makefile规则中使用通配符

    make支持三各通配符:“*”,“?”和“[...]”。这是和Unix的B-Shell是相同的。

    objects = *.o

    并不是说[*.o]会展开,不!objects的值就是“*.o”。Makefile中的变量其实就是C/C++中的宏。如果你要让通配符在变量中展开,也就是让objects的值是所有[.o]的文件名的集合,那么,你可以这样:

    objects := $(wildcard *.o)

    makefile文件搜寻

    当make需要去找寻文件的依赖关系时,你可以在文件前加上路径,但最好的方法是把一个路径告诉make,让make在自动去找。

    VPATH =

    src:../headers

    上面的的定义指定两个目录,“src”和“../headers”,make会按照这个顺序进行搜索。目录由“冒号”分隔。(当然,当前目录永远是最高优先搜索的地方)

    另一个设置文件搜索路径的方法是使用make的“vpath”关键字(注意,它是全小写的),这不是变量,这是一个make的关键字,这和上面提到的那个VPATH变量很类似,但是它更为灵活。

    # Makefile VPATH用法

    CC      = gcc

    OBJ     = main.o foo.obar.o

    CFLAGS  = -Iinclude

    VPATH   =src:include

    prog:$(OBJ)

        $(CC) -o $@ $(OBJ)

    %.o:%.c

        $(CC) $(CFLAGS) -c$<

    main.o:foo.h bar.h

    .PHONY:clean

    clean:

        -rm -f prog $(OBJ)

    # Makefile vpath用法

    CC      = gcc

    OBJ     = main.o foo.obar.o

    CPPFLAGS= -Iinclude

    #VPATH  = src:include

    vpath %.h include

    vpath %.c src

    prog:$(OBJ)

        $(CC) -o $@ $(OBJ)

    %.o:%.c

        $(CC) $(CPPFLAGS) -c$<

    main.o:foo.h bar.h

    .PHONY:clean

    clean:

        -rm -f prog $(OBJ)

    注:将CFLAGS改为CPPFLAGS,因为-I选项应该是预编译中的选项,而不是编译选项。

    伪目标

    最早先的一个例子中,我们提到过一个“clean”的目标,这是一个“伪目标”

    clean:

    rm *.o temp

    我们并不生成“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”的伪目标,其依赖于其它三个目标。

    多目标

    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,后面的为参数。关于函数,将在后面讲述。这里的这个函数是截取字符串的意思,“$@”表示目标的集合,就像一个数组,“$@”依次取出目标,并执于命令。

    subst用法

    原型

    $(subst ;,;,;)

        名称:字符串替换函数——subst。

        功能:把字串;中的;字符串替换成;。

        返回:函数返回被替换过后的字符串。

    例子

       现在有一个变量CONF值为[MacRelease,MacDebug],现在要把Mac去掉.

       代码为: ${substr Mac,,${CONF}}

       结果是:Release或Debug

    静态模式

    静态模式可以更加容易地定义多目标的规则,可以让我们的规则变得更加的有弹性和灵活。我们还是先来看一下语法:

    <targets ...>: <target-pattern>:

    <prereq-patterns ...>

    <commands>

    ...

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

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

    prereq-parrterns是目标的依赖模式,它对target-parrtern形成的模式再进行一次依赖目标的定义。

    如果我们的<target-parrtern>定义成“%.o”,意思是我们的<target>集合中都是以“.o”结尾的,而如果我们的<prereq-parrterns>定义成“%.c”,意思是对<target-parrtern>所形成的目标集进行二次定义,其计算方法是,取<target-parrtern>模式中的“%”(也就是去掉了[.o]这个结尾),并为其加上[.c]这个结尾,形成的新集合。

    看一个例子:

    objects = foo.o bar.o

    all: $(objects)

    $(objects): %.o: %.c

    $(CC) -c $(CFLAGS) $< -o $@

    上面的例子中,指明了我们的目标从$object中获取,“%.o”表明要所有以“.o”结尾的目标,也就是“foo.o bar.o”,也就是变量$object集合的模式,而依赖模式“%.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

    试想,如果我们的“%.o”有几百个,那种我们只要用这种很简单的“静态模式规则”就可以写完一堆规则,实在是太有效率了。“静态模式规则”的用法很灵活,如果用得好,那会一个很强大的功能。

    自动生成依赖性

    大多数的C/C++编译器都支持一个“-M”的选项,即自动找寻源文件中包含的头文件,并生成一个依赖关系。

    于是由编译器自动生成的依赖关系,这样一来,你就不必再手动书写若干文件的依赖关系,而由编译器自动生成了。需要提醒一句的是,如果你使用GNU的C/C++编译器,你得用“-MM”参数,不然,“-M”参数会把一些标准库的头文件也包含进来。

    GNU组织建议把编译器为每一个源文件的自动生成的依赖关系放到一个文件中,为每一个“name.c”的文件都生成一个“name.d”的Makefile文件,[.d]文件中就存放对应[.c]文件的依赖关系。

    我们可以写出[.c]文件和[.d]文件的依赖关系,并让make自动更新或自成[.d]文件,并把其包含在我们的主Makefile中,这样,我们就可以自动化地生成每个文件的依赖关系了。

    这里,我们给出了一个模式规则来产生[.d]文件:

    %.d: %.c

    @set -e; rm -f $@; \

    $(CC) -M $(CPPFLAGS) $< > $@.$$$$; \

    sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \

    rm -f $@.$$$$

    所有的[.d]文件依赖于[.c]文件

    “rm -f $@”的意思是删除所有的目标,也就是[.d]文件,第二行的意思是,为每个依赖文件“$<”,也就是[.c]文件生成依赖文件,“$@”表示模式“%.d”文件,如果有一个C文件是name.c,那么“%”就是“name”,“$$$$”意为一个随机编号,第二行生成的文件有可能是“name.d.12345”

        第三行使用sed命令做了一个替换,关于sed命令的用法请参看相关的使用文档。

        第四行就是删除临时文件。

    总而言之,这个模式要做的事就是在编译器生成的依赖关系中加入[.d]文件的依赖,即把依

    赖关系:

    main.o : main.c defs.h

    转成:

    main.o main.d : main.c defs.h

    于是,我们的[.d]文件也会自动更新了,并会自动生成了,当然,你还可以在这个[.d]文件中加入的不只是依赖关系,包括生成的命令也可一并加入,让每个[.d]文件都包含一个完赖的规则。

        一旦我们完成这个工作,接下来,我们就要把这些自动生成的规则放进我们的主Makefile中。我们可以使用Makefile的“include”命令,来引入别的Makefile文件(前面讲过),例如:

    sources = foo.c bar.c

    include $(sources:.c=.d)

    上述语句中的“$(sources:.c=.d)”中的“.c=.d”的意思是做一个替换,把变量$(sources)所有[.c]的字串都替换成[.d],关于这个“替换”的内容,在后面我会有更为详细的讲述。当然,你得注意次序,因为include是按次来载入文件,最先载入的[.d]文件中的目标会成为默认目标。

    sed函数

    例:

    sed 's,\(main\)\.o[ :]*,\1.o main.d : ,g' < main.d.temp >

    main.d

    其中:

    sed 's,main\.o[ :]*,\1.o main.d : ,g',是sed命令。

     < main.d.temp,指示sed命令从临时文件main.d.temp读取输入,作为命令的来源字符串。

     > main.d,把行内替换结果输出到最终文件main.d。

    这条sed命令的结构是s/match/replace/g。有时为了清晰,可以把每个/写成逗号,即这里的格式s,match,replace,g。

    该命令表示把源串内的match都替换成replace,s指示match可以是正则表达式。

    g表示把每行内所有match都替换,如果去掉g,则只有每行的第1处match被替换(实际上不需要g,因为一个.d文件中,只会在开头有一个main.o:)。

    总体来说match用来匹配'main.o :'这样的串。

    这里的replace是\1.o main.d

    :,其中\1会被替换为前面第1个和括起的内容,即main,这样replace值为main.o

    main.d :

    这样该sed命令就实现了把main.o :替换为main.o main.d :的目的。

    这两行实现了把临时文件main.d.temp的内容main.o : main.c command.h改为main.o main.d :

    main.c command.h,并存入main.d文件的功能。

    书写命令

    每条规则中的命令和操作系统Shell的命令行是一致的。make会一按顺序一条一条的执行命令,每条命令的开头必须以[Tab]键开头,除非,命令是紧跟在依赖规则后面的分号后的。在命令行之间中的空格或是空行会被忽略,但是如果该空格或空行是以Tab键开头的,那么make会认为其是一个空命令。

    makefile显示命令

    通常,make会把其要执行的命令行在命令执行前输出到屏幕上。当我们用“@”字符在命令行前,那么,这个命令将不被make显示出来,最具代表性的例子是,我们用这个功能来像屏幕显示一些信息。如:

    @echo 正在编译XXX模块......

    当make执行时,会输出“正在编译XXX模块......”字串,但不会输出命令,如果没有“@”,那么,make将输出:

    echo 正在编译XXX模块......

    正在编译XXX模块......

    makefile命令执行

    Makefile文件中内容:

    exec:

        cd /home/lqc;pwd

    执行”make exec”, cd就起作用了,pwd会打印出“/home/lqc”。

    exec:

        @ cd /home/lqc;pwd

    不输出执行命令过程。

    makefile命令出错

    为了做到这一点,忽略命令的出错,我们可以在Makefile的命令行前加一个减号“-”(在Tab键之后),标记为不管命令出不出错都认为是成功的。如:

    clean:

    -rm -f *.o

    还有一个全局的办法是,给make加上“-i”或是“--ignore-errors”参数,那么,Makefile中所有命令都会忽略错误。而如果一个规则是以“.IGNORE”作为目标的,那么这个规则中的所有命令将会忽略错误。这些是不同级别的防止命令出错的方法,你可以根据你的不同喜欢设置。

    嵌套执行make

    在一些大的工程中,我们会把我们不同模块或是不同功能的源文件放在不同的目录中,我们可以在每个目录中都书写一个该目录的Makefile,这有利于让我们的Makefile变得更加地简洁,而不至于把所有的东西全部写在一个Makefile中,这样会很难维护我们的Makefile,这个技术对于我们模块编译和分段编译有着非常大的好处。

    例如,我们有一个子目录叫subdir,这个目录下有个Makefile文件,来指明了这个目录下文件的编译规则。那么我们总控的Makefile可以这样书写:

    subsystem:

    cd subdir && $(MAKE)

    其等价于:

    subsystem:

    $(MAKE) -C subdir

    定义$(MAKE)宏变量的意思是,也许我们的make需要一些参数,所以定义成一个变量比较利于维护。这两个例子的意思都是先进入“subdir”目录,然后执行make命令。

    如果你要传递变量到下级Makefile中,那么你可以使用这样的声明:

    export <variable ...>

    如果你不想让某些变量传递到下级Makefile中,那么你可以这样声明:

    unexport <variable ...>

    需要注意的是,有两个变量,一个是SHELL,一个是MAKEFLAGS,这两个变量不管你是否export,其总是要传递到下层Makefile中,特别是MAKEFILES变量,其中包含了make的参数信息,如果我们执行“总控Makefile”时有make参数或是在上层Makefile中定义了这个变量,那么MAKEFILES变量将会是这些参数,并会传递到下层Makefile中,这是一个系统级的环境变量。

    还有一个在“嵌套执行”中比较有用的参数,“-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使用变量

    传统的Makefile的变量名是全大写的命名方式,但我推荐使用大小写搭配的变量名,如:MakeFlags。这样可以避免和系统的变量冲突,而发生意外的事情。

    变量在声明时需要给予初值,而在使用时,需要给在变量名前加上“$”符号,但最好用小括号“()”或是大括号“{}”把变量给包括起来。如果你要使用真实的“$”字符,那么你需要用“$$”来表示。

    另外,给变量加上括号完全是为了更加安全地使用这个变量。

    foo = $(bar)

    bar = $(ugh)

    ugh = Huh?

    all:

    echo $(foo)

    我们执行“make all”将会打出变量$(foo)的值是“Huh?”($(foo)的值是$(bar),$(bar)的值是$(ugh),$(ugh)的值是“Huh?”)可见,变量是可以使用后面的变量来定义的。

    A = $(B)

    B = $(A)

    这会让make陷入无限的变量展开过程中去,当然,我们的make是有能力检测这样的定义,并会报错。

    为了避免上面的这种方法,我们可以使用make中的另一种用变量来定义变量的方法。这种方法使用的是“:=”操作符,如:

    x := foo

    y := $(x) bar

    x := later

    其等价于:

    y := foo bar

    x := later

    值得一提的是,这种方法,前面的变量不能使用后面的变量,只能使用前面已定义好了的变量。如果是这样:

    y := $(x) bar

    x := foo

    那么,y的值是“bar”,而不是“foo bar”。

    makefile :=

    := 意思就是

    如果这个变量是空的或者未赋初值,则对其进行赋值. 否则, 就不赋值.

    makefile ?=

    FOO?=bar

    其含义是,如果FOO没有被定义过,那么变量FOO的值就是“bar”,如果FOO先前被定义过,那么这条语将什么也不做,其等价于:

    ifeq ($(origin FOO), undefined)

    FOO = bar

    endif

    makefile变量的替换

    我们可以替换变量中的共有的部分,其格式是“$(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)”)

    first_second = Hello

    a = first

    b = second

    all = $($a_$b)

    这里的“$a_$b”组成了“first_second”,于是,$(all)的值就是“Hello”

    makefile追加变量值

    我们可以使用“+=”操作符给变量追加值,如:

    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被追加进去了)

    makefile多行命令

    还有一种设置变量值的方法是使用define关键字。使用define关键字设置变量的值可以有换行,这有利于定义一系列的命令

    define指示符后面跟的是变量的名字,而重起一行定义变量的值,定义是以endef关键字结束。其工作方式和“=”操作符一样。变量的值可以包含函数、命令、文字,或是其它变量。因为命令需要以[Tab]键开头,所以如果你用define定义的命令变量中没有以[Tab]键开头,那么make就不会把其认为是命令。

    define two-lines

    echo foo

    echo $(bar)

    endef

    makefile define关键字

    make解释器提供了一系列的函数供makefile调用

    在makefile中支持自定义函数实现,并调用执行

    通过define关键字实现自定义函数

    bar = too

    define two-lines

        echo foo

        echo $(bar)

    endef

    exec:

        $(call two-lines)

    执行:make exec

    lqc@lqc-vm:cppProj$ make exec

    echo foo

    foo

    echo too

    too

    makefile环境变量

    make运行时的系统环境变量可以在make开始运行时被载入到Makefile文件中,但是如果Makefile中已定义了这个变量,或是这个变量由make命令行带入,那么系统的环境变量的值将被覆盖。

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

    makefile目标变量

    我们同样可以为某个目标设置局部变量,这种变量被称为“Target-specific Variable”,它可以和“全局变量”同名,因为它的作用范围只在这条规则以及连带规则中,所以其值也只在作用范围内有效。而不会影响规则链以外的全局变量的值。

    其语法是:

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

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

    <variable-assignment>可以是前面讲过的各种赋值表达式,如“=”、“:=”、“+=”或是“?=”。第二个语法是针对于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”

    makefile模式变量

    在GNU的make中,还支持模式变量(Pattern-specific Variable),通过上面的目标变量中,我们知道,变量可以定义在某个目标上。模式变量的好处就是,我们可以给定一种“模式”,可以把变量定义在符合这种模式的所有目标上。

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

    %.o : CFLAGS = -O

    同样,模式变量的语法和“目标变量”一样:

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

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

    override同样是针对于系统环境传入的变量,或是make命令行指定的变量。

    makefile使用条件判断

    例:

    下面的例子,判断$(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

        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

    其中<conditional-directive>表示条件关键字,如“ifeq”。这个关键字有四个。

    第一个是我们前面所见过的“ifeq”

    ifeq (, ) 

    第二个条件关键字是“ifneq”。语法是:

    ifneq (, ) 

    第三个条件关键字是“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 <variable-name>

    这个我就不多说了,和“ifdef”是相反的意思。

    在<conditional-directive>这一行上,多余的空格是被允许的,但是不能以[Tab]键做为开始(不然就被认为是命令)。而注释符“#”同样也是安全的。“else”和“endif”也一样,只要不是以[Tab]键开始就行了。

    makefile 使用函数

    函数调用,很像变量的使用,也是以“$”来标识的,其语法如下:

    $(<function> <arguments>)

    或是

    ${<function> <arguments>}

    这里,<function>就是函数名,make支持的函数不多。<arguments>是函数的参数,参数间以逗号“,”分隔,而函数名和参数之间以“空格”分隔。函数调用以“$”开头,以圆括号或花括号把函数名和参数括起。感觉很像一个变量,是不是?函数中的参数可以使用变量,为了风格的统一,函数和变量的括号最好一样,如使用“$(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”。

    makefile字符串处理函数

    $(subst ,,) 

    名称:字符串替换函数——subst。

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

    返回:函数返回被替换过后的字符串。

    $(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 ,,) 

    名称:取单词串函数——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>)。

    makefile文件名操作函数

    $(dir ) 

    名称:取目录函数——dir。

    功能:从文件名序列<names>中取出目录部分。目录部分是指最后一个反斜杠(“/”)之前的部分。如果没有反斜杠,那么返回“./”。

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

    示例:$(dir src/foo.c hacks)返回值是“src/ ./”。

    $(notdir ) 

    名称:取文件函数——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 ,) 

    名称:加前缀函数——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”。

    makefile foreach函数

    $(foreach <var>,<list>,<text>)

    这个函数的意思是,把参数<list>中的单词逐一取出放到参数<var>所指定的变量中,然后再执行<text>所包含的表达式。每一次<text>会返回一个字符串,循环过程中,<text>的所返回的每个字符串会以空格分隔,最后当整个循环结束时,<text>所返回的每个字符串所组成的整个字符串(以空格分隔)将会是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中的<var>参数是一个临时的局部变量,foreach函数执行完后,参数<var>的变量将不在作用,其作用域只在foreach函数当中。

    makefile call函数

    call函数是唯一一个可以用来创建新的参数化的函数。你可以写一个非常复杂的表达式,这个表达式中,你可以定义许多参数,然后你可以用call函数来向这个表达式传递参数。其语法是:

    $(call

    <expression>,<parm1>,<parm2>,<parm3>...)

    当make执行这个函数时,<expression>参数中的变量,如$(1),$(2),$(3)等,会被参数<parm1>,<parm2>,<parm3>依次取代。而<expression>的返回值就是call函数的返回值。

    例如:

    reverse = $(1) $(2)

    foo = $(call reverse,a,b)

    那么,foo的值就是“a b”。当然,参数的次序是可以自定义的,不一定是顺序的,如:

    reverse = $(2) $(1)

    foo = $(call reverse,a,b)

    此时的foo的值就是“b a”。

    makefile origin函数

    origin函数不像其它的函数,他并不操作变量的值,他只是告诉你你的这个变量是哪里来的?其语法是:

    $(origin <variable>)

    注意,<variable>是变量的名字,不应该是引用。所以你最好不要在<variable>中使用“$”字符。Origin函数会以其返回值来告诉你这个变量的“出生情况”

    makefile之override

    override指示符

    通常在执行 make 时,如果通过命令行定义了一个变量,那么它将替代在 Makefile中出现的同名变量的定义。就是说,对于一个在 Makefile 中使用常规方式(使用“=”、“:=”或者“define”)定义的变量,我们可以在执行 make 时通过命令行方式重新指定这个变量的值,命令行指定的值将替代出现在 Makefile 中此变量的值。如果不希望命令行指定的变量值替代在 Makefile 中的变量定义,那么我们需要在 Makefile 中使用指示符“override”来对这个变量进行声明。

    override作用

    [if !supportLists]1.  [endif]保护makefile中定义的变量的值;

    [if !supportLists]2.  [endif]提供一种在makefile中增加或者修改命令行参数的方式;

    实际情况下,我们经常会有这种需求:通过命令行指定一些附加的参数选项,对于一些通用的参数选项在makefile中指定.

    1 保护makefile中定义变量值示例

    1.1 没有使用override的情况

    make命令行指定的变量值将会覆盖makefile中定义的同名的变量值

    SRCS := A.c B.c C.c

    all:

            @echo "SRCS: " $(SRCS)

    1.2 使用override的情况

    make命令行指定的变量值将不会覆盖makefile中定义的同名的变量值,所以override有保护makefile中变量值不被命令行参数修改的作用。

    override SRCS := A.c B.c C.c

    all:

            @echo "SRCS: " $(SRCS)

    2修改makefile中定义变量值的示例

    #使用override进行追加的变量的原来指定的值不会被命令行参数覆盖,而且会追加命令行指定的值

    override CFLAGS += -g

    all:

            @echo $(CFLAGS)

    makefile shell函数

    shell函数也不像其它的函数。顾名思义,它的参数应该就是操作系统Shell的命令。它和反引号“`”是相同的功能。这就是说,shell函数把执行操作系统命令后的输出作为函数返回。于是,我们可以用操作系统命令以及字符串处理命令awk,sed等等命令来生成一个变量,如:

    contents := $(shell cat foo)

    files := $(shell echo *.c)

    注意,这个函数会新生成一个Shell程序来执行命令,所以你要注意其运行性能,如果你的Makefile中有一些比较复杂的规则,并大量使用了这个函数,那么对于你的系统性能是有害的。特别是Makefile的隐晦的规则可能会让你的shell函数执行的次数比你想像的多得多。

    make的运行

    make命令执行后有三个退出码:

    0 —— 表示成功执行。

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

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

    例如,我们有个makefile的名字是“hchen.mk”,那么,我们可以这样来让make来执行这个文件:

    make –f hchen.mk

    如果在make的命令行是,你不只一次地使用了“-f”参数,那么,所有指定的makefile将会被连在一起传递给make执行。

    指定目标

    一般来说,make的最终目标是makefile中的第一个目标,而其它目标一般是由这个目标连带出来的。这是make的默认行为。当然,一般来说,你的makefile中的第一个目标是由许多个目标组成,你可以指示make,让其完成你所指定的目标。要达到这一目的很简单,需在make命令后直接跟目标的名字就可以完成(如前面提到的“make clean”形式)

    有一个make的环境变量叫“MAKECMDGOALS”,这个变量中会存放你所指定的终极目标的列表,如果在命令行上,你没有指定目标,那么,这个变量是空值。这个变量可以让你使用在一些比较特殊的情形下。比如下面的例子:

    sources = foo.c bar.c

    ifneq ( $(MAKECMDGOALS),clean)

    include $(sources:.c=.d)

    endif

    基于上面的这个例子,只要我们输入的命令不是“make

    clean”,那么makefile会自动包含“foo.d”和“bar.d”这两个makefile。

    使用指定终极目标的方法可以很方便地让我们编译我们的程序,例如下面这个例子:

    .PHONY: all

    all: prog1 prog2 prog3 prog4

    从这个例子中,我们可以看到,这个makefile中有四个需要编译的程序——“prog1”,“prog2”,“prog3”和“prog4”,我们可以使用“make all”命令来编译所有的目标(如果把all置成第一个目标,那么只需执行“make”),我们也可以使用“make prog2”来单独编译目标“prog2”。

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

    “all”

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

    “clean”

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

    “install”

    这个伪目标功能是安装已编译好的程序,其实就是把目标执行文件拷贝到指定的目标中去。

    “print”

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

    “tar”

    这个伪目标功能是把源程序打包备份。也就是一个tar文件。

    “dist”

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

    “TAGS”

    这个伪目标功能是更新所有的目标,以备完整地重编译使用。

    “check”和“test”

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

    makefile隐含规则

    “隐含规则”也就是一种惯例,make会按照这种“惯例”心照不喧地来运行,那怕我们的Makefile中没有书写这样的规则。例如,把[.c]文件编译成[.o]文件这一规则,你根本就不用写出来,make会自动推导出这种规则,并生成我们需要的[.o]文件。

    “隐含规则”会使用一些我们系统变量,我们可以改变这些系统变量的值来定制隐含规则的运行时的参数。如系统变量“CFLAGS”可以控制编译时的编译器参数。

    如果要使用隐含规则生成你需要的目标,你所需要做的就是不要写出这个目标的规则。那么,make会试图去自动推导产生这个目标的规则和命令,如果make可以自动推导生成这个目标的规则和命令,那么这个行为就是隐含规则的自动推导。当然,隐含规则是make事先约定好的一些东西。例如,我们有下面的一个Makefile:

    foo : foo.o bar.o

    cc –o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)

    我们可以注意到,这个Makefile中并没有写下如何生成foo.o和bar.o这两目标的规则和命令。因为make的“隐含规则”功能会自动为我们自动去推导这两个目标的依赖目标和生成命令。

    make会在自己的“隐含规则”库中寻找可以用的规则,如果找到,那么就会使用。如果找不到,那么就会报错。在上面的那个例子中,make调用的隐含规则是,把[.o]的目标的依赖文件置成[.c],并使用C的编译命令“cc –c

    $(CFLAGS) [.c]”来生成[.o]的目标。也就是说,

    我们完全没有必要写下下面的两条规则:

    foo.o : foo.c

    cc –c foo.c $(CFLAGS)

    bar.o : bar.c

    cc –c bar.c $(CFLAGS)

    因为,这已经是“约定”好了的事了,make和我们约定好了用C编译器“cc”生成[.o]文件的规则,这就是隐含规则。

    还有,在make的“隐含规则库”中,每一条隐含规则都在库中有其顺序,越靠前的则是越被经常使用的,所以,这会导致我们有些时候即使我们显示地指定了目标依赖,make也不会管。

    相关文章

      网友评论

          本文标题:makefile相关

          本文链接:https://www.haomeiwen.com/subject/ttuvbktx.html