Makefile 工作原理 | 使用示例 | 教程

原创 已于 2024-12-03 23:24:12 修改 · 1k 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Makefile

于 2024-12-02 00:38:58 首次发布

注：本文为 “Makefile 工作原理及使用”的相关文章合辑。

Makefile 及其工作原理

作者： Sachin Patil 译者： LCTT Zafiry

| 2018-09-11 10:06

用make 工具来更有效的运行和编译你的程序。

当你需要在一些源文件改变后运行或更新一个任务时，通常会用到 make 工具。make 工具需要读取一个 Makefile（或 makefile）文件，在该文件中定义了一系列需要执行的任务。你可以使用 make 来将源代码编译为可执行程序。大部分开源项目会使用 make 来实现最终的二进制文件的编译，然后使用 make install 命令来执行安装。

本文将通过一些基础和进阶的示例来展示 make 和 Makefile 的使用方法。在开始前，请确保你的系统中安装了 make。

基础示例

依然从打印 “Hello World” 开始。首先创建一个名字为 myproject 的目录，目录下新建 Makefile 文件，文件内容为：

say_hello:
        echo "Hello World"

在 myproject 目录下执行 make，会有如下输出：

$ make
echo "Hello World"
Hello World

在上面的例子中，“say_hello” 类似于其他编程语言中的函数名。这被称之为目标target。在该目标之后的是预置条件或依赖。为了简单起见，我们在这个示例中没有定义预置条件。echo ‘Hello World' 命令被称为步骤recipe。这些步骤基于预置条件来实现目标。目标、预置条件和步骤共同构成一个规则。

总结一下，一个典型的规则的语法为：

目标: 预置条件
<TAB> 步骤

作为示例，目标可以是一个基于预置条件（源代码）的二进制文件。另一方面，预置条件也可以是依赖其他预置条件的目标。

final_target: sub_target final_target.c
        Recipe_to_create_final_target
        
sub_target: sub_target.c
        Recipe_to_create_sub_target

目标并不要求是一个文件，也可以只是步骤的名字，就如我们的例子中一样。我们称之为“伪目标”。

再回到上面的示例中，当 make 被执行时，整条指令 echo "Hello World" 都被显示出来，之后才是真正的执行结果。如果不希望指令本身被打印处理，需要在 echo 前添加 @。

say_hello:
        @echo "Hello World"

重新运行 make，将会只有如下输出：

$ make
Hello World

接下来在 Makefile 中添加如下伪目标：generate 和 clean：

say_hello:
        @echo "Hello World"
generate:
        @echo "Creating empty text files..."
        touch file-{1..10}.txt
clean:
        @echo "Cleaning up..."
        rm *.txt

随后当我们运行 make 时，只有 say_hello 这个目标被执行。这是因为Makefile 中的第一个目标为默认目标。通常情况下会调用默认目标，这就是你在大多数项目中看到 all 作为第一个目标而出现。all 负责来调用它他的目标。我们可以通过 .DEFAULT_GOAL 这个特殊的伪目标来覆盖掉默认的行为。

在 Makefile 文件开头增加 .DEFAULT_GOAL：

.DEFAULT_GOAL := generate

make 会将 generate 作为默认目标：

$ make
Creating empty text files...
touch file-{1..10}.txt

顾名思义，.DEFAULT_GOAL 伪目标仅能定义一个目标。这就是为什么很多 Makefile 会包括 all 这个目标，这样可以调用多个目标。

下面删除掉 .DEFAULT_GOAL，增加 all 目标：

all: say_hello generate
say_hello:
        @echo "Hello World"
generate:
        @echo "Creating empty text files..."
        touch file-{1..10}.txt
clean:
        @echo "Cleaning up..."
        rm *.txt

运行之前，我们再增加一些特殊的伪目标。.PHONY 用来定义这些不是文件的目标。make 会默认调用这些伪目标下的步骤，而不去检查文件名是否存在或最后修改日期。完整的 Makefile 如下：

.PHONY: all say_hello generate clean
all: say_hello generate
say_hello:
        @echo "Hello World"
generate:
        @echo "Creating empty text files..."
        touch file-{1..10}.txt
clean:
        @echo "Cleaning up..."
        rm *.txt

make 命令会调用 say_hello 和 generate：

$ make
Hello World
Creating empty text files...
touch file-{1..10}.txt

clean 不应该被放入 all 中，或者被放入第一个目标中。clean 应当在需要清理时手动调用，调用方法为 make clean。

$ make clean
Cleaning up...
rm *.txt

现在你应该已经对 Makefile 有了基础的了解，接下来我们看一些进阶的示例。

进阶示例

变量

在之前的实例中，大部分目标和预置条件是已经固定了的，但在实际项目中，它们通常用变量和模式来代替。

定义变量最简单的方式是使用 = 操作符。例如，将命令 gcc 赋值给变量 CC：

CC = gcc

这被称为递归扩展变量，用于如下所示的规则中：

hello: hello.c
    ${CC} hello.c -o hello

你可能已经想到了，这些步骤将会在传递给终端时展开为：

gcc hello.c -o hello

${CC} 和 $(CC) 都能对 gcc 进行引用。但如果一个变量尝试将它本身赋值给自己，将会造成死循环。让我们验证一下：

CC = gcc
CC = ${CC}
all:
    @echo ${CC}

此时运行 make 会导致：

$ make
Makefile:8: *** Recursive variable 'CC' references itself (eventually).  Stop.

为了避免这种情况发生，可以使用 := 操作符（这被称为简单扩展变量）。以下代码不会造成上述问题：

CC := gcc
CC := ${CC}
all:
    @echo ${CC}

模式和函数

下面的 Makefile 使用了变量、模式和函数来实现所有 C 代码的编译。我们来逐行分析下：

# Usage:
# make        # compile all binary
# make clean  # remove ALL binaries and objects
.PHONY = all clean
CC = gcc                        # compiler to use
LINKERFLAG = -lm
SRCS := $(wildcard *.c)
BINS := $(SRCS:%.c=%)
all: ${BINS}
%: %.o
        @echo "Checking.."
        ${CC} ${LINKERFLAG} $< -o $@
%.o: %.c
        @echo "Creating object.."
        ${CC} -c $<
clean:
        @echo "Cleaning up..."
        rm -rvf *.o ${BINS}

  • 以 # 开头的行是评论。

  • .PHONY = all clean 行定义了 all 和 clean 两个伪目标。

  • 变量 LINKERFLAG 定义了在步骤中 gcc 命令需要用到的参数。

  • SRCS := $(wildcard *.c)：$(wildcard pattern) 是与文件名相关的一个函数。在本示例中，所有 “.c”后缀的文件会被存入 SRCS 变量。

  • BINS := $(SRCS:%.c=%)：这被称为替代引用。本例中，如果 SRCS 的值为 'foo.c bar.c'，则 BINS的值为 'foo bar'。

  • all: ${BINS} 行：伪目标 all 调用 ${BINS} 变量中的所有值作为子目标。

  • 规则：

    %: %.o  @echo "Checking.."  ${CC} ${LINKERFLAG} $&lt; -o $@

    下面通过一个示例来理解这条规则。假定 foo 是变量 ${BINS} 中的一个值。% 会匹配到 foo（%匹配任意一个目标）。下面是规则展开后的内容：

    foo: foo.o  @echo "Checking.."  gcc -lm foo.o -o foo

    如上所示，% 被 foo 替换掉了。$< 被 foo.o 替换掉。$<用于匹配预置条件，$@ 匹配目标。对 ${BINS} 中的每个值，这条规则都会被调用一遍。

  • 规则：

    %.o: %.c  @echo "Creating object.."  ${CC} -c $&lt;

    之前规则中的每个预置条件在这条规则中都会都被作为一个目标。下面是展开后的内容：

    foo.o: foo.c  @echo "Creating object.."  gcc -c foo.c

  • 最后，在 clean 目标中，所有的二进制文件和编译文件将被删除。

下面是重写后的 Makefile，该文件应该被放置在一个有 foo.c 文件的目录下：

# Usage:
# make        # compile all binary
# make clean  # remove ALL binaries and objects
.PHONY = all clean
CC = gcc                        # compiler to use
LINKERFLAG = -lm
SRCS := foo.c
BINS := foo
all: foo
foo: foo.o
        @echo "Checking.."
        gcc -lm foo.o -o foo
foo.o: foo.c
        @echo "Creating object.."
        gcc -c foo.c
clean:
        @echo "Cleaning up..."
        rm -rvf foo.o foo

关于 Makefile 的更多信息，GNU Make 手册提供了更完整的说明和实例。

重新发现 make： 规则背后的力量

作者： Roberto Dip 译者： LCTT Liwen Jiang

| 2019-04-04 11:10

我过去认为 makefile 只是一种将一组组的 shell 命令列出来的简便方法；过了一段时间我了解到它们是有多么的强大、灵活以及功能齐全。这篇文章带你领略其中一些有关规则的特性。

备注：这些全是针对 GNU Makefile 的，如果你希望支持 BSD Makefile ，你会发现有些新的功能缺失。感谢 zge 指出这点。

规则

规则rule是指示 make 应该如何并且何时构建一个被称作为目标target的文件的指令。目标可以依赖于其它被称作为前提prerequisite的文件。

你会指示 make 如何按步骤recipe构建目标，那就是一套按照出现顺序一次执行一个的 shell 命令。语法像这样：

target_name : prerequisites    recipe

一但你定义好了规则，你就可以通过从命令行执行以下命令构建目标：

$ make target_name

目标一经构建，除非前提改变，否则 make 会足够聪明地不再去运行该步骤。

关于前提的更多信息

前提表明了两件事情：

  • 当目标应当被构建时：如果其中一个前提比目标更新，make 假定目的应当被构建。
  • 执行的顺序：鉴于前提可以反过来在 makefile 中由另一套规则所构建，它们同样暗示了一个执行规则的顺序。

如果你想要定义一个顺序但是你不想在前提改变的时候重新构建目标，你可以使用一种特别的叫做“唯顺序order only”的前提。这种前提可以被放在普通的前提之后，用管道符（|）进行分隔。

样式

为了便利，make 接受目标和前提的样式。通过包含 % 符号可以定义一种样式。这个符号是一个可以匹配任何长度的文字符号或者空隔的通配符。以下有一些示例：

  • %：匹配任何文件
  • %.md：匹配所有 .md 结尾的文件
  • prefix%.go：匹配所有以 prefix 开头以 .go 结尾的文件

特殊目标

有一系列目标名字，它们对于 make 来说有特殊的意义，被称作特殊目标special target。

你可以在这个文档发现全套特殊目标。作为一种经验法则，特殊目标以点开始后面跟着大写字母。

以下是几个有用的特殊目标：

  • .PHONY：向 make 表明此目标的前提可以被当成伪目标。这意味着 make 将总是运行，无论有那个名字的文件是否存在或者上次被修改的时间是什么。
  • .DEFAULT：被用于任何没有指定规则的目标。
  • .IGNORE：如果你指定 .IGNORE 为前提，make 将忽略执行步骤中的错误。

替代

当你需要以你指定的改动方式改变一个变量的值，替代 substitution 就十分有用了。

替代的格式是 $(var:a=b)，它的意思是获取变量 var 的值，用值里面的 b 替代词末尾的每个 a 以代替最终的字符串。例如：

foo := a.obar : = $(foo:.o=.c) # sets bar to a.c

注意：特别感谢 Luis Lavena 让我们知道替代的存在。

档案文件

档案文件是用来一起将多个数据文档（类似于压缩文件的概念）收集成一个文件。它们由 ar Unix 工具所构建。ar 可以用于为任何目的创建档案，但除了静态库，它已经被 tar 大量替代。

在 make 中，你可以使用一个档案文件中的单独一个成员作为目标或者前提，就像这样：

archive(member) : prerequisite     recipe

最后的想法

关于 make 还有更多可探索的，但是至少这是一个起点，我强烈鼓励你去查看文档，创建一个笨拙的 makefile 然后就可以探索它了。

一文入门 Makefile

作者： 良许linux

| 2019-03-10 22:32

1、什么是 Makefile

一个企业级项目，通常会有很多源文件，有时也会按功能、类型、模块分门别类的放在不同的目录中，有时候也会在一个目录里存放了多个程序的源代码。

这时，如何对这些代码的编译就成了个问题。Makefile 就是为这个问题而生的，它定义了一套规则，决定了哪些文件要先编译，哪些文件后编译，哪些文件要重新编译。

整个工程通常只要一个 make 命令就可以完成编译、链接，甚至更复杂的功能。可以说，任何一个 Linux 源程序都带有一个Makefile 文件。

2、Makefile 的优点

  1. 管理代码的编译，决定该编译什么文件，编译顺序，以及是否需要重新编译；
  2. 节省编译时间。如果文件有更改，只需重新编译此文件即可，无需重新编译整个工程；
  3. 一劳永逸。Makefile 通常只需编写一次，后期就不用过多更改。

3、命名规则

一般来说将 Makefile 命名为 Makefile 或 makefile 都可以，但很多源文件的名字是小写的，所以更多程序员采用的是 Makefile 的名字，因为这样可以将 Makefile 居前显示。

如果将 Makefile 命为其它名字，比如 Makefile_demo，也是允许的，但使用的时候应该采用以下方式：

make -f Makefile_demo

4、基本规则

Makefile 的基本格式为：

目标: 依赖(tab)规则
  • 目标 --> 需要生成的目标文件
  • 依赖 --> 生成该目标所需的一些文件
  • 规则 --> 由依赖文件生成目标文件的手段
  • tab --> 每条规则必须以 tab 开头，使用空格不行

例如我们经常写的 gcc test.c -o test，使用 Makefile 可以写成：

test: test.c    gcc test.c -o test

其中，第一行中的 test 就是要生成的目标，test.c 就是依赖，第二行就是由 test.c 生成 test 的规则。

Makefile 中有时会有多个目标，但 Makefile 会将第一个目标定为终极目标。

5、工作原理

目标的生成

  1. 检查规则中的依赖文件是否存在；
  2. 若依赖文件不存在，则寻找是否有规则用来生成该依赖文件。

img

比如上图中，生成 calculator 的规则是 gcc main.o add.o sub.o mul.o div.o -o，Makefile 会先检查 main.o、add.o、sub.o、 mul.o、 div.o 是否存在，如果不存在，就会再寻找是否有规则可以生成该依赖文件。

比如缺少了 main.o 这个依赖，Makefile 就会在下面寻找是否有规则生成 main.o。当它发现 gcc main.c -o main.o这条规则可以生成 main.o 时，它就利用此规则生成 main.o，然后再生成终极目标 calculator。

整个过程是向下寻找依赖，再向上执行命令，生成终极目标。

目标的更新

  1. 检查目标的所有依赖，任何一个依赖有更新时，就重新生成目标；
  2. 目标文件比依赖文件时间晚，则需要更新。

img

比如，修改了 main.c，则 main.o 目标会被重新编译，当 main.o 更新时，终极目标 calculator 也会被重新编译。其它文件的更新也是类推。

6、命令执行

make：使用此命令即可按预定的规则生成目标文件。 如果 Makefile 文件的名字不为 Makefile 或 makefile，则应加上 -f 选项，比如：

make -f Makefile_demo

make clean：清除编译过程中产生的中间文件（.o文件）及最终目标文件。

如果当前目录下存在名为 clean 的文件，则该命令不执行。

解决办法是伪目标声明：.PHONY:clean。

特殊符号：

  • - ：表示此命令即使执行出错，也依然继续执行后续命令。如：-rm a.o build/
  • @：表示该命令只执行，不回显。一般规则执行时会在终端打印出正在执行的规则，而加上此符号后将只执行命令，不回显执行的规则。如：@echo $(SOURCE)

7、普通变量

变量定义及赋值：

变量直接采用赋值的方法即可完成定义，如：

INCLUDE = ./include/

变量取值：

用括号括起来再加个美元符，如：

FOO = $(OBJ)

系统自带变量：

通常都是大写，比如 CC、PWD、CFLAG，等等。

有些有默认值，有些没有。比如常见的几个：

  • CPPFLAGS : 预处理器需要的选项 如：-I
  • CFLAGS：编译的时候使用的参数 –Wall –g -c
  • LDFLAGS ：链接库使用的选项 –L -l

变量的默认值可以修改，比如 CC 默认值是 cc，但可以修改为 gcc：CC=gcc

8、自动变量

常用自动变量：

Makefile 提供了很多自动变量，但常用的为以下三个。这些自动变量只能在规则中的命令中使用，其它地方使用都不行。

  • $@ --> 规则中的目标
  • $< --> 规则中的第一个依赖条件
  • $^ --> 规则中的所有依赖条件

例如：

app: main.c func1.c fun2.c gcc $^ - o $@

其中：$^ 表示 main.c func1.c fun2.c，$< 表示 main.c，$@ 表示 app。

模式规则：

模式规则是在目标及依赖条件中使用 % 来匹配对应的文件，比如在目录下有 main.c、func1.c、func2.c 三个文件，对这三个文件的编译可以由一条规则完成：

%.o:%.c  $(CC) –c $< -o $@

这条模式规则表示：

main.o 由 main.c 生成， func1.o 由 func1.c 生成， func2.o 由 func2.c 生成。

这就是模式规则的作用，可以一次匹配目录下的所有文件。

9、函数

Makefile 也为我们提供了大量的函数，同样经常使用到的函数为以下两个。需要注意的是，Makefile 中所有的函数必须都有返回值。在以下的例子中，假如目录下有 main.c、func1.c、func2.c 三个文件。

通配符：

用于查找指定目录下指定类型的文件，跟的参数就是目录+文件类型，比如：

src = $（wildcard ./src/*.c)

这句话表示：找到 ./src 目录下所有后缀为 .c 的文件，并赋给变量 src。

命令执行完成后，src 的值为：main.c func1.c fun2.c。

patsubst：

匹配替换，例如以下例子，用于从 src 目录中找到所有 .c 结尾的文件，并将其替换为 .o 文件，并赋值给 obj。

obj = $(patsubst %.c ,%.o ,$(src))

命令执行完成后，obj 的值为 main.o func1.o func2.o。

特别地，如果要把所有 .o 文件放在 obj 目录下，可用以下方法：

obj = $(patsubst ./src/%.c, ./obj/%.o, $(src))

10、小结

Makefile 其实提供了非常非常多的功能，但本文所写的对于一般的企业应用完全够用了。特别对于初学者，学习一些基础知识（如本文），再辅一些案例（如本系列的几个案例），完全可以达到企业用人标准了。正所谓要抓住事物的主要矛盾，可以先把基础知识吃透再去延伸 Makefile 的其它知识。

Make 命令教程

作者： 阮一峰

| 2015-02-24 11:17

代码变成可执行文件，叫做编译（compile）；先编译这个，还是先编译那个（即编译的安排），叫做构建（build）。

Make 是最常用的构建工具，诞生于 1977 年，主要用于 C 语言的项目。但是实际上 ，任何只要某个文件有变化，就要重新构建的项目，都可以用 Make 构建。

本文介绍 Make 命令的用法，从简单的讲起，不需要任何基础，只要会使用命令行，就能看懂。我的参考资料主要是 Isaac Schlueter的《Makefile文件教程》和《GNU Make手册》。

一、Make的概念

Make 这个词，英语的意思是"制作"。Make 命令直接用了这个意思，就是要做出某个文件。比如，要做出文件a.txt，就可以执行下面的命令。

$ make a.txt

但是，如果你真的输入这条命令，它并不会起作用。因为Make命令本身并不知道，如何做出a.txt，需要有人告诉它，如何调用其他命令完成这个目标。

比如，假设文件 a.txt 依赖于 b.txt 和 c.txt ，是后面两个文件连接（cat命令）的产物。那么，make 需要知道下面的规则。

a.txt: b.txt c.txt
    cat b.txt c.txt > a.txt

也就是说，make a.txt 这条命令的背后，实际上分成两步：第一步，确认 b.txt 和 c.txt 必须已经存在，第二步使用 cat 命令 将这个两个文件合并，输出为新文件。

像这样的规则，都写在一个叫做Makefile的文件中，Make命令依赖这个文件进行构建。Makefile文件也可以写为makefile， 或者用命令行参数指定为其他文件名。

$ make -f rules.txt
# 或者
$ make --file=rules.txt

上面代码指定make命令依据rules.txt文件中的规则，进行构建。

总之，make只是一个根据指定的Shell命令进行构建的工具。它的规则很简单，你规定要构建哪个文件、它依赖哪些源文件，当那些文件有变动时，如何重新构建它。

二、Makefile 文件的格式

构建规则都写在Makefile文件里面，要学会如何Make命令，就必须学会如何编写Makefile文件。

2.1 概述

Makefile文件由一系列规则（rules）构成。每条规则的形式如下。

<target> : <prerequisites> 
[tab]  <commands>

上面第一行冒号前面的部分，叫做"目标"（target），冒号后面的部分叫做"前置条件"（prerequisites）；第二行必须由一个tab键起首，后面跟着"命令"（commands）。

"目标"是必需的，不可省略；"前置条件"和"命令"都是可选的，但是两者之中必须至少存在一个。

每条规则就明确两件事：构建目标的前置条件是什么，以及如何构建。下面就详细讲解，每条规则的这三个组成部分。

2.2 目标（target）

一个目标（target）就构成一条规则。目标通常是文件名，指明Make命令所要构建的对象，比如上文的 a.txt 。目标可以是一个文件名，也可以是多个文件名，之间用空格分隔。

除了文件名，目标还可以是某个操作的名字，这称为"伪目标"（phony target）。

clean:
      rm *.o

上面代码的目标是clean，它不是文件名，而是一个操作的名字，属于"伪目标 "，作用是删除对象文件。

$ make  clean

但是，如果当前目录中，正好有一个文件叫做 clean，那么这个命令不会执行。因为Make发现clean文件已经存在，就认为没有必要重新构建了，就不会执行指定的 rm 命令。

为了避免这种情况，可以明确声明clean是"伪目标"，写法如下。

.PHONY: clean
clean:
        rm *.o temp

声明 clean 是"伪目标"之后，make 就不会去检查是否存在一个叫做 clean 的文件，而是每次运行都执行对应的命令。像.PHONY这样的内置目标名还有不少，可以查看手册。

如果Make命令运行时没有指定目标，默认会执行Makefile文件的第一个目标。

$ make

上面代码执行Makefile文件的第一个目标。

2.3 前置条件（prerequisites）

前置条件通常是一组文件名，之间用空格分隔。它指定了"目标"是否重新构建的判断标准：只要有一个前置文件不存在，或者有过更新（前置文件的last-modification时间戳比目标的时间戳新），"目标"就需要重新构建。

result.txt: source.txt
    cp source.txt result.txt

上面代码中，构建 result.txt 的前置条件是 source.txt 。如果当前目录中，source.txt 已经存在，那么make result.txt可以正常运行，否则必须再写一条规则，来生成 source.txt 。

source.txt:
    echo "this is the source" > source.txt

上面代码中，source.txt后面没有前置条件，就意味着它跟其他文件都无关，只要这个文件还不存在，每次调用make source.txt，它都会生成。

$ make result.txt
$ make result.txt

上面命令连续执行两次make result.txt。第一次执行会先新建 source.txt，然后再新建 result.txt。第二次执行，Make发现 source.txt 没有变动（时间戳晚于 result.txt），就不会执行任何操作，result.txt 也不会重新生成。

如果需要生成多个文件，往往采用下面的写法。

source: file1 file2 file3

上面代码中，source 是一个伪目标，只有三个前置文件，没有任何对应的命令。

$ make source

执行make source命令后，就会一次性生成 file1，file2，file3 三个文件。这比下面的写法要方便很多。

$ make file1
$ make file2
$ make file3

2.4 命令（commands）

命令（commands）表示如何更新目标文件，由一行或多行的Shell命令组成。它是构建"目标"的具体指令，它的运行结果通常就是生成目标文件。

每行命令之前必须有一个tab键。如果想用其他键，可以用内置变量.RECIPEPREFIX声明。

.RECIPEPREFIX = >
all:
> echo Hello, world

上面代码用.RECIPEPREFIX指定，大于号（>）替代tab键。所以，每一行命令的起首变成了大于号，而不是tab键。

需要注意的是，每行命令在一个单独的shell中执行。这些Shell之间没有继承关系。

var-lost:
    export foo=bar
    echo "foo=[$$foo]"

上面代码执行后（make var-lost），取不到foo的值。因为两行命令在两个不同的进程执行。一个解决办法是将两行命令写在一行，中间用分号分隔。

var-kept:
    export foo=bar; echo "foo=[$$foo]"

另一个解决办法是在换行符前加反斜杠转义。

var-kept:
    export foo=bar; \
    echo "foo=[$$foo]"

最后一个方法是加上.ONESHELL:命令。

.ONESHELL:
var-kept:
    export foo=bar; 
    echo "foo=[$$foo]"

三、Makefile文件的语法

3.1 注释

井号（#）在Makefile中表示注释。

# 这是注释
result.txt: source.txt
    # 这是注释
    cp source.txt result.txt # 这也是注释

3.2 回声（echoing）

正常情况下，make会打印每条命令，然后再执行，这就叫做回声（echoing）。

test:
# 这是测试

执行上面的规则，会得到下面的结果。

$ make test
# 这是测试

在命令的前面加上@，就可以关闭回声。

test:
    @# 这是测试

现在再执行make test，就不会有任何输出。

由于在构建过程中，需要了解当前在执行哪条命令，所以通常只在注释和纯显示的echo命令前面加上@。

test:
    @# 这是测试
    @echo TODO

3.3 通配符

通配符（wildcard）用来指定一组符合条件的文件名。Makefile 的通配符与 Bash 一致，主要有星号（*）、问号（？）和 […] 。比如， *.o 表示所有后缀名为o的文件。

clean:
        rm -f *.o

3.4 模式匹配

Make命令允许对文件名，进行类似正则运算的匹配，主要用到的匹配符是%。比如，假定当前目录下有 f1.c 和 f2.c 两个源码文件，需要将它们编译为对应的对象文件。

%.o: %.c

等同于下面的写法。

f1.o: f1.c
f2.o: f2.c

使用匹配符%，可以将大量同类型的文件，只用一条规则就完成构建。

3.5 变量和赋值符

Makefile 允许使用等号自定义变量。

txt = Hello World
test:
    @echo $(txt)

上面代码中，变量 txt 等于 Hello World。调用时，变量需要放在 $( ) 之中。

调用Shell变量，需要在美元符号前，再加一个美元符号，这是因为Make命令会对美元符号转义。

test:
    @echo $$HOME

有时，变量的值可能指向另一个变量。

v1 = $(v2)

上面代码中，变量 v1 的值是另一个变量 v2。这时会产生一个问题，v1 的值到底在定义时扩展（静态扩展），还是在运行时扩展（动态扩展）？如果 v2 的值是动态的，这两种扩展方式的结果可能会差异很大。

为了解决类似问题，Makefile一共提供了四个赋值运算符 （=、:=、？=、+=），它们的区别请看StackOverflow。

VARIABLE = value
# 在执行时扩展，允许递归扩展。
 
VARIABLE := value
# 在定义时扩展。
 
VARIABLE ?= value
# 只有在该变量为空时才设置值。
 
VARIABLE += value
# 将值追加到变量的尾端。

3.6 内置变量（Implicit Variables）

Make命令提供一系列内置变量，比如， ( C C ) 指向当前使用的编译器， (CC) 指向当前使用的编译器， (CC)指向当前使用的编译器，(MAKE) 指向当前使用的Make工具。这主要是为了跨平台的兼容性，详细的内置变量清单见手册。

output:
    $(CC) -o output input.c

3.7 自动变量（Automatic Variables）

Make命令还提供一些自动变量，它们的值与当前规则有关。主要有以下几个。

（1）$@

$@指代当前目标，就是Make命令当前构建的那个目标。比如，make foo的 $@ 就指代foo。

a.txt b.txt: 
    touch $@

等同于下面的写法。

a.txt:
    touch a.txt
b.txt:
    touch b.txt

（2）$<

< 指代第一个前置条件。比如，规则为 t : p 1 p 2 ，那么 < 指代第一个前置条件。比如，规则为 t: p1 p2，那么 <指代第一个前置条件。比如，规则为t:p1p2，那么< 就指代p1。

a.txt: b.txt c.txt
    cp $< $@

等同于下面的写法。

a.txt: b.txt c.txt
    cp b.txt a.txt

（3）$?

? 指代比目标更新的所有前置条件，之间以空格分隔。比如，规则为 t : p 1 p 2 ，其中 p 2 的时间戳比 t 新， ? 指代比目标更新的所有前置条件，之间以空格分隔。比如，规则为 t: p1 p2，其中 p2 的时间戳比 t 新， ?指代比目标更新的所有前置条件，之间以空格分隔。比如，规则为t:p1p2，其中p2的时间戳比t新，?就指代p2。

（4）$^

$^ 指代所有前置条件，之间以空格分隔。比如，规则为 t: p1 p2，那么 $^ 就指代 p1 p2 。

（5）$*

∗ 指代匹配符 * 指代匹配符 % 匹配的部分， 比如% 匹配 f1.txt 中的f1 ， ∗指代匹配符* 就表示 f1。

（6）$(@D) 和 $(@F)

$(@D) 和 $(@F) 分别指向 @ 的目录名和文件名。比如， @ 的目录名和文件名。比如， @的目录名和文件名。比如，@是 src/input.c，那么 ( @ D ) 的值为 s r c ， (@D) 的值为 src ， (@D)的值为src，(@F) 的值为 input.c。

（7）$(<D) 和 $(<F)

$(<D) 和 $(<F) 分别指向 $< 的目录名和文件名。

所有的自动变量清单，请看手册。下面是自动变量的一个例子。

dest/%.txt: src/%.txt
    @[ -d dest ] || mkdir dest
    cp $< $@

上面代码将 src 目录下的 txt 文件，拷贝到 dest 目录下。首先判断 dest 目录是否存在，如果不存在就新建，然后，$< 指代前置文件（src/%.txt）， $@ 指代目标文件（dest/%.txt）。

3.8 判断和循环

Makefile使用 Bash 语法，完成判断和循环。

ifeq ($(CC),gcc)
  libs=$(libs_for_gcc)
else
  libs=$(normal_libs)
endif

上面代码判断当前编译器是否 gcc ，然后指定不同的库文件。

LIST = one two three
all:
    for i in $(LIST); do \
        echo $$i; \
    done
 
# 等同于
 
all:
    for i in one two three; do \
        echo $i; \
    done

上面代码的运行结果。

one
two
three

3.9 函数

Makefile 还可以使用函数，格式如下。

$(function arguments)
# 或者
${function arguments}

Makefile提供了许多内置函数，可供调用。下面是几个常用的内置函数。

（1）shell 函数

shell 函数用来执行 shell 命令

srcfiles := $(shell echo src/{00..99}.txt)

（2）wildcard 函数

wildcard 函数用来在 Makefile 中，替换 Bash 的通配符。

srcfiles := $(wildcard src/*.txt)

（3）替换函数

替换函数的写法是：变量名 + 冒号 + 替换规则。

min: $(OUTPUT:.js=.min.js)

上面代码的意思是，将变量OUTPUT中的 .js 全部替换成 .min.js 。

四、Makefile 的实例

（1）执行多个目标

.PHONY: cleanall cleanobj cleandiff
 
cleanall : cleanobj cleandiff
        rm program
 
cleanobj :
        rm *.o
 
cleandiff :
        rm *.diff

上面代码可以调用不同目标，删除不同后缀名的文件，也可以调用一个目标（cleanall），删除所有指定类型的文件。

（2）编译C语言项目

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
    cc -c display.c
 
clean :
     rm edit main.o kbd.o command.o display.o
 
.PHONY: edit clean

Make命令的介绍就到这里。

via:

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值