zoukankan      html  css  js  c++  java
  • 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面目全非。然后"$*"它是空的值。


  • 相关阅读:
    C++笔记(2018/2/6)
    2017级面向对象程序设计寒假作业1
    谁是你的潜在朋友
    A1095 Cars on Campus (30)(30 分)
    A1083 List Grades (25)(25 分)
    A1075 PAT Judge (25)(25 分)
    A1012 The Best Rank (25)(25 分)
    1009 说反话 (20)(20 分)
    A1055 The World's Richest(25 分)
    A1025 PAT Ranking (25)(25 分)
  • 原文地址:https://www.cnblogs.com/hrhguanli/p/4573067.html
Copyright © 2011-2022 走看看