Makefile编写

Makefile编写

注：本文主要参考学习《跟我一起写Makefile》做的一些笔记，也会参考网上的相关资料做一些补充及案例的讲解。

一 概述

一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile 定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile 就像一个 Shell 脚本一样，其中也可以执行操作系统的命令。 makefile 带来的好处就是——“自动化编译”，一旦写好，只需要一个 make 命令，整个工程完全自动编译，极大的提高了软件开发的效率。make 是一个命令工具，是一个解释 makefile 中指令的命令工具 。

Makefile 文件注意要点：

（1）在工程目录下创建名为“Makefile”的文件，文件名一定要叫做“Makefile”！！！区分大小写。

（2）所有行首需要空出来的地方一定要使用“TAB”键！不要使用空格键！这是Makefile 的语法要求。

一般建立工程的方法有以下三点：

（1）makefile：
优点：使用非常广泛，通用性强，可跨平台。
缺点：语法比较蛋疼。要写出一个通用，便于管理，且兼容性强的makefile比较困难。

（2）cmake：
优点：简单易用，使用较广泛，方便管理，可跨平台。
缺点：自动生成的makefile太臃肿。

（3）sh脚本：
优点：自由，高度定制。简单易用，可操作性强。方便维护。（甚至还可以生成makefile）
缺点：sh建的工程太少（估计没人这么搞）

二 关于程序的编译和链接

源文件首先会生成中间目标文件，再由中间目标文件生成执行文件。在编译时，编译器只检测程序语法，和函数、变量是否被声明。如果函数未被声明，编译器会给出一个警告，但可以生成 Object File。而在链接程序时，链接器会在所有的 Object File 中找寻函数的实现，如果找不到，那到就会报链接错误码（Linker Error），在 VC 下，这种错误一般是：Link 2001 错误，意思说是说，链接器未能找到函数的实现。你需要指定函数的Object File 。

三 Makefile介绍

在 Makefile 中，目标文件（target）包含：执行文件 edit 和中间目标文件（*.o），依赖文件（prerequisites）就是冒号后面的那些 .c 文件和 .h 文件。每一个 .o 文件都有一组依赖文件，而这些 .o 文件又是执行文件 edit 的依赖文件。依赖关系的实质上就是说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。

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

make 并不管命令是怎么工作的，他只管执行所定义的命令。make 会比较 targets 文件和 prerequisites 文件的修改日期，如果 prerequisites 文件的日期要比 targets 文件的日期要新，或者 target 不存在的话，那么，make 就会执行后续定义的命令。

这里要说明一点的是，clean 不是一个文件，它只不过是一个动作名字，有点像 C 语言中的 lable 一样，其冒号后什么也没有，那么，make 就不会自动去找文件的依赖性，也就不会自动执行其后所定义的命令。要执行其后的命令，就要在 make 命令后明显得指出这个lable 的名字。这样的方法非常有用，我们可以在一个 makefile 中定义不用的编译或是和编译无关的命令，比如程序的打包，程序的备份，等等。

3.1 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 了。

这就是整个 make 的依赖性，make 会一层又一层地去找文件的依赖关系，直到最终编译 出第一个目标文件。在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make 就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make 根本不理。

3.2 makefile 中使用变量

objects = main.o kbd.o command.o display.o 
insert.o search.o files.o utils.o

于是，我们就可以很方便地在我们的 makefile 中以“$(objects)”的方式来使用这个变量了。

反斜杠（）是换行符的意思。这样比较便于 Makefile 的易读 。

3.3 让 make 自动推导

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

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是个伪目标文件。 **

3.4 清空目标文件的规则

每个 Makefile 中都应该写一个清空目标文件（.o 和执行文件）的规则，这不仅便于重编译，也很利于保持文件的清洁。

一般的风格都是：

clean:
rm edit $(objects)

更为稳健的做法是：

.PHONY : clean
clean :
-rm edit $(objects)

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

四 Makefile总述 4.1 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]键开始。

4.2 Makefile 的文件名

默认的情况下，make 命令会在当前目录下按顺序找寻文件名为“GNUmakefile”、“makefile”、“Makefile”的文件，找到了解释这个文件。在这三个文件名中，最好使用“Makefile”这个文件名，因为，这个文件名第一个字符为大写，这样有一种显目的感觉。最好不要用“GNUmakefile”，这个文件是 GNU 的 make 识别的。有另外一些 make 只对全小写的“makefile”文件名敏感，但是基本上来说，大多数的 make 都支持“makefile”和“Makefile”这两种默认文件名。

当 然 ， 你 可 以 使 用 别 的 文 件 名 来 书 写 Makefile ， 比 如 ： “ Make.Linux” ，
“Make.Solaris”，“Make.AIX”等，如果要指定特定的 Makefile，你可以使用 make 的
“-f”和“–file”参数，如：

make -f Make.Linux 

或

make --file Make.AIX

4.3 引用其它的 Makefile

在 Makefile 使用 include 关键字可以把别的 Makefile 包含进来，这很像 C 语言的#include，被包含的文件会原模原样的放在当前文件的包含位置。include 的语法是：

include 

filename 可以是当前操作系统 Shell 的文件模式（可以保含路径和通配符） 在 include前面可以有一些空字符，但是绝不能是[Tab]键开始。include 和可以用一个或多个空格隔开。举个例子，你有这样几个 Makefile：a.mk、b.mk、c.mk，还有一个文件叫foo.make，以及一个变量$(bar)，其包含了 e.mk 和 f.mk，那么，下面的语句：

include foo.make *.mk $(bar)

等价于：

include foo.make a.mk b.mk c.mk e.mk f.mk

make 命令开始时，会把找寻 include 所指出的其它 Makefile，并把其内容安置在当前的位置。就好像 C/C++的#include 指令一样。如果文件都没有指定绝对路径或是相对路径的话，make 会在当前目录下首先寻找，如果当前目录下没有找到，那么，make 还会在下面的几个目录下找：

1、如果 make 执行时，有“-I”或“–include-dir”参数，那么 make 就会在这个参数所指定的目录下去寻找。

2、如果目录/include（一般是：/usr/local/bin 或/usr/include）存在的话，make 也会去找。如果有文件没有找到的话，make 会生成一条警告信息，但不会马上出现致命错误。它会继续载入其它的文件，一旦完成 makefile 的读取，make 会再重试这些没有找到，或是不能读取的文件，如果还是不行，make 才会出现一条致命信息。如果你想让 make不理那些无法读取的文件，而继续执行，你可以在 include 前加一个减号“-”。

如：

-include   

4.4 环境变量 MAKEFILES

如果你的当前环境中定义了环境变量 MAKEFILES，那么，make 会把这个变量中的值做一个类似于 include 的动作。这个变量中的值是其它的 Makefile，用空格分隔。只是， 它和 include不同的是，从这个环境变中引入的 Makefile 的“目标”不会起作用，如果环境变量中定义的文件发现错误，make 也会不理。

建议不要使用这个环境变量，因为只要这个变量一被定义，那么当你使用 make 时， 所有的 Makefile 都会受到它的影响，也许有时候你的 Makefile 出现了怪事，那么你可以看看当前环境中有没有定义这个变量 。

4.5 make 的工作方式

GNU 的 make 工作时的执行步骤入下：

1、读入所有的 Makefile。
2、读入被 include 的其它 Makefile。
3、初始化文件中的变量。
4、推导隐晦规则，并分析所有规则。
5、为所有的目标文件创建依赖关系链。
6、根据依赖关系，决定哪些目标要重新生成。
7、执行生成命令。

五 Makefile书写规则

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

在 Makefile 中，规则的顺序是很重要的，因为，Makefile 中只应该有一个最终目标，其它的目标都是被这个目标所连带出来的，所以一定要让 make 知道你的最终目标是什么。

一般来说，定义在 Makefile 中的目标可能会有很多，但是第一条规则中的目标将被确立为最终的目标。

5.1 规则语法

targets : prerequisites
	command
...

#或是这样：

targets : prerequisites ; command
	command
...

targets 是文件名，以空格分开，可以使用通配符。一般来说，我们的目标基本上是一个文件，但也有可能是多个文件。

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

prerequisites也就是目标所依赖的文件（或依赖目标）。如果其中的某个文件要比目标文件要新，那么，
目标就被认为是“过时的”，被认为是需要重生成的。

如果命令太长，你可以使用反斜框（‘’）作为换行符。make 对一行上有多少个字符没有限制。规则告诉 make 两件事，文件的依赖关系和如何成成目标文件。

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

5.2 在规则中使用通配符

make 支持三各通配符： “*”，“?”和“[…]”。

波浪号（“_{”）字符在文件名中也有比较特殊的用途。如果是“}/test”，这就表示当前用户的$HOME 目录下的 test 目录。而“~hchen/test”则表示用户 hchen 的宿主目录下的 test 目录。

而在 Windows 或是 MS-DOS 下，用户没有宿主目录，那么波浪号所指的目录则根据环境变量“HOME”而定。

通配符代替了你一系列的文件，如“*.c”表示所以后缀为 c 的文件。一个需要我们注意的是，如果我们的文件名中有通配符，如：“*”，那么可以用转义字符“”，如“*”来表示真实的“*”字符，而不是任意长度的字符串。

Makefile 中的变量其实就是 C/C++中的宏。如果你要让通配符在变量中展开，也就是让 objects 的值是所有[.o]的文件名的集合，那么，你可以这样：

objects := $(wildcard *.o)

这种用法由关键字“wildcard”指出 。

5.3 文件搜寻

在一些大的工程中，有大量的源文件，我们通常的做法是把这许多的源文件分类，并存放在不同的目录中。所以，当 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 语句的先后顺序来执行搜索。如：

#其表示“.c”结尾的文件，先在“foo”目录，然后是“blish”，最后是“bar”目录。
vpath %.c foo
vpath % blish
vpath %.c bar

#而上面的语句则表示“.c”结尾的文件，先在“foo”目录，然后是“bar”目录，最后才是“blish”目录。
vpath %.c foo:bar
vpath % blish

5.4 伪目标

clean:
rm *.o temp

因为，我们并不生成“clean”这个文件。“伪目标”并不是一个文件，只是一个标签，由于“伪目标”不是文件，所以 make 无法生成它的依赖关系和决定它是否要执行。我们只有通过显示地指明这个“目标”才能让其生效。当然，“伪目标”的取名不能和文件名重名，不然其就失去了“伪目标”的意义了。

为了避免和文件重名的这种情况，我们可以使用一个特殊的标记“.PHONY”来显示地指明一个目标是“伪目标”，向 make 说明，不管是否有这个文件，这个目标就是“伪目标”。

.PHONY : clean

伪目标一般没有依赖的文件。但是，我们也可以为伪目标指定所依赖的文件。 Makefile 中的第一个目标会被作为其默认目标，由于伪目标的特性是，总是被执行的。

5.5 多目标

有可能我们的多个目标同时依赖于一个文件，并且其生成的命令大体类似。于是我们就能把其合并起来。 例如：

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

5.6 静态模式

静态模式可以更加容易地定义多目标的规则，可以让我们的规则变得更加的有弹性和灵活 。

#语法
: : 

....

#targets 定义了一系列的目标文件，可以有通配符。是目标的一个集合。
#target-parrtern 是指明了 targets 的模式，也就是的目标集模式。
#prereq-parrterns 是目标的依赖模式，它对 target-parrtern 形成的模式再进行一次依赖目标的定义。

我们的“目标模式”或是“依赖模式”中都应该有“%”这个字符，如果你的文件名中有“%”那么你可以使用反斜杠“”进行转义，来标明真实的“%”字符

#例子

objects = foo.o bar.o

#指明了我们的目标从$object 中获取
all: $(objects)

#“%.o”表明要所有以“.o”结尾的目标，也就是“foo.o bar.o”，也就是变量$object 集合的模式
#而依赖模式“%.c”则取模式“%.o”的“%”，也就是“foo bar”，并为其加下“.c”的后缀，
#于是，我们的依赖目标就是“foo.c bar.c”。
$(objects): %.o: %.c

#命令中的“$<”和“$@”则是自动化变量，“$<”表示所有的依赖目标集（也就是“foo.c bar.c”），
#“$@”表示目标集（也就是“foo.o bar.o”）。
$(CC) -c $(CFLAGS) $< -o $@

#例子

files = foo.elc bar.o lose.o

#表示调用 Makefile 的 filter 函数，过滤“$filter”集，只要其中模式为“%.o”的内容。
$(filter %.o,$(files)): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
$(filter %.elc,$(files)): %.elc: %.el
emacs -f batch-byte-compile $<

5.7 自动生成依赖性

如果是一个比较大型的工程，你必需清楚哪些 C 文件包含了哪些头文件，并且，你在加入或删除头文件时，也需要小心地修改 Makefile，这是一个很没有维护性的工作。为了避免这种繁重而又容易出错的事情，我们可以使用 C/C++编译的一个功能。大多数的C/C++编译器都支持一个“-M”的选项，即自动找寻源文件中包含的头文件，并生成一个依赖关系。

如果你使用 GNU 的 C/C++编译器，你得用“-MM”参数，不然，“-M”参数会把一些标准库的头文件也包含进来。

GNU 组织建议把编译器为每一个源文件的自动生成的依赖关系放到一个文件中，为每一个“name.c”的文件都生成一个“name.d”的 Makefile 文件，[.d]文件中就存放对应[.c]文件的依赖关系。于是，我们可以写出[.c]文件和[.d]文件的依赖关系，并让 make 自动更新或自成[.d]文件，并把其包含在我们的主 Makefile 中，这样，我们就可以自动化地生成每个文件的依赖关系了。这里，我们给出了一个模式规则来产生[.d]文件：

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

#“rm -f $@”的意思是删除所有的目标，也就是[.d]文件
@set -e; rm -f $@; 

#为每个依赖文件“$<”，也就是[.c]文件生成依赖文件，“$@”表示模式“ %.d” 文件，“$$$$”意为一个随机编号
$(CC) -M $(CPPFLAGS) $< > $@.$$$$; 

#使用 sed 命令做了一个替换
sed 's,($*).o[ :]*,1.o $@ : ,g' < $@.$$$$ > $@; 

#删除临时文件
rm -f $@.$$$$

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

main.o : main.c defs.h
转成：
main.o main.d : main.c defs.h

使用 Makefile 的“include”命令，来引入别的 Makefile 文件

#.c=.d”的意思是做一个替换，把变量$(sources)所有[.c]的字串都替换成[.d]
sources = foo.c bar.c
include $(sources:.c=.d)

include 是按次来载入文件，最先载入的[.d]文件中的目标会成为默认目标。

…待补充

七 使用变量 7.1 变量赋值

Makefile 的变量的四种基本赋值方式：

简单赋值 ( := ) 编程语言中常规理解的赋值方式，只对当前语句的变量有效。
递归赋值 ( = ) 赋值语句可能影响多个变量，所有目标变量相关的其他变量都受影响。
条件赋值 ( ?= ) 如果变量未定义，则使用符号中的值定义变量。如果该变量已经赋值，则该赋值语句无效。
追加赋值 ( += ) 原变量用空格隔开的方式追加一个新值。

Makefile 文件中定义变量的基本语法如下：

变量的名称=值列表

Makefile 中的变量的使用其实非常的简单，因为它并没有像其它语言那样定义变量的时候需要使用数据类型。变量的名称可以由大小写字母、阿拉伯数字和下划线构成。等号左右的空白符没有明确的要求，因为在执行 make 的时候多余的空白符会被自动的删除。至于值列表，既可以是零项，又可以是一项或者是多项。如：

SUBDIRS := arch lib service driver soc app/$(APP)

#其中，arch、lib、service、、driver、soc、soc、app是顶层目录下的同级目录文件夹

调用变量的时候可以用 “ ( V A L U E L I S T ) " 或 者 是 " (VALUE_LIST)" 或者是 " (VALUEL​IST)"或者是"{VALUE_LIST}” 来替换，这就是变量的引用。实例：

OBJ=main.o test.o test1.o test2.o
test:$(OBJ)
      gcc -o test $(OBJ)

这就是引用变量后的 Makefile 的编写，比我们之前的编写方式要简单的多。当要添加或者是删除某个依赖文件的时候，我们只需要改变变量 “OBJ” 的值就可以了。

特殊变量：

$@ : 目标文件
$< : 第一个依赖
$^ : 所有的依赖

7.2 条件判断

日常使用 Makefile 编译文件时，可能会遇到需要分条件执行的情况，比如在一个工程文件中，可编译的源文件很多，但是它们的类型是不相同的，所以编译文件使用的编译器也是不同的。手动编译去操作文件显然是不可行的（每个文件编译时需要注意的事项很多），所以 make 为我们提供了条件判断来解决这样的问题。

条件语句的作用：条件语句可以根据一个变量的值来控制 make 执行或者时忽略 Makefile 的特定部分，条件语句可以是两个不同的变量或者是常量和变量之间的比较。

注意：条件语句只能用于控制 make 实际执行的 Makefile 文件部分，不能控制规则的 shell 命令执行的过程。

7.2.1 条件判断中使用到的一些关键字

关键字	功能
ifeq	判断参数是否不相等，相等为 true，不相等为 false。
ifneq	判断参数是否不相等，不相等为 true，相等为 false。
ifdef	判断是否有值，有值为 true，没有值为 false。
ifndef	判断是否有值，没有值为 true，有值为 false。
else	判断条件不满足时执行的部分，不是所有条件语句都需要此部分
endif	表示一个条件语句的结束，任何一个条件表达式都必须以“endif”结束

7.2.2 ifeq 和 ifneq

条件判断的使用方式如下：

ifeq (ARG1, ARG2)
ifeq 'ARG1' 'ARG2'
ifeq "ARG1" "ARG2"
ifeq "ARG1" 'ARG2'
ifeq 'ARG1' "ARG2"

7.2.3 ifdef 和 ifndef

使用方式如下：

ifdef VARIABLE-NAME

关键字“ifdef”用来判断一个变量是否已经定义。

ifdef 只是测试一个变量是否有值，
不会对变量进行替换展开来判断变量的值是否为空。
对于变量“VARIABLE-NAME” ，除了
“VARIABLE-NAME=”这种情况以外，使用其它方式对它的定义都会使“ifdef”返回真。
就是说，即使我们通过其它方式（比如，定义它的值引用了其它的变量）给它赋了一个空值， “ifdef”也会返回真。

当我们需要判断一个变量的值是否为空的时候需要使用“ifeq" 而不是“ifdef”。

注意：在 make 读取 Makefile 文件时计算表达式的值，并根据表达式的值决定判断语句中的哪一个部分作为此 Makefile 所要执行的内容。因此在条件表达式中不能使用自动化变量，自动化变量在规则命令执行时才有效，更不能将一个完整的条件判断语句分卸在两个不同的 Makefile 的文件中。在一个 Makefile 中使用指示符 “include” 包含另一个 Makefile 文件。

7.3 export的用法

在实际的项目中，总不会是只有一个 Makefile 文件，我们会在 Makefile 中调用另外的 Makefile 文件，呈现出 Makefile 的层级结构。

上层 make 过程要将所执行的 Makefile 中的变量传递给子 make 过程，需要明确地指出。

在 GNU make 中，实现此功能的指示符是 export。当一个变量使用 export 进行声明后，变量和它的值将被加入到当前工作的环境变量中，以后在 make 执行的所有规则的命令都可以使用这个变量。

1、在（parent，上层的）makefile中export出来变量，子makefile（sub make）中，是可以访问的。

2、而同一级别的makefile（可通过makefile中内置变量MAKELEVEL查看得知当前makefile的levlel），是无法通过export来传递变量的，即一个makefile中export出来一个变量，同一级的另外一个makefile中，是无法访问/得到的。

3、makefile中的export是导出变量到子makfile，而目标对应执行的动作中的export，是属于shell中的export，其作用是导出变量到当前shell。此两个export的作用是不同的。

7.4 include的用法

Makefile的include类似C的#include预处理指令，会将被include的文件内容原封不动的追加到当前文件。

当 make 读取到 “include” 关键字的时候，会暂停读取当前的 Makefile，而是去读 “include” 包含的文件，读取结束后再继读取当前的 Makefile 文件。“include” 使用的具体方式如下：

include 

其中，filenames 是 shell 支持的文件名（可以使用通配符表示的文件）。

注意：“include” 关键字所在的行首可以包含一个或者是多个的空格（读取的时候空格会被自动的忽略），但是不能使用 Tab 开始，否则会把 “include” 当作式命令来处理。包含的多个文件之间要使用空格分隔开。使用 “include” 包含进来的 Makefile 文件中，如果存在函数或者是变量的引用，它们会在包含的 Makefile 中展开。

include 通常使用在以下的场合：

• 在一个工程文件中，每一个模块都有一个独立的 Makefile 来描述它的重建规则。它们需要定义一组通用的变量定义或者是模式规则。通用的做法是将这些共同使用的变量或者模式规则定义在一个文件中，需要的时候用 “include” 包含这个文件。
• 当根据源文件自动产生依赖文件时，我们可以将自动产生的依赖关系保存在另一个文件中。然后在 Makefile 中包含这个文件。

注意：如果使用 “include” 包含文件的时候，指定的文件不是文件的绝对路径或者是为当前文件下没有这个文件，make 会根据文件名会在以下几个路径中去找：

首先我们在执行 make 命令的时候可以加入选项 “-I” 或 “–include-dir” 后面添加上指定的路径，如果文件存在就会被使用

如果文件不存在将会在其他的几个路径中搜索：“usr/gnu/include”、“usr/local/include” 和 “usr/include”。

如果在上面的路径没有找到 “include” 指定的文件，make 将会提示一个文件没有找到的警示提示，但是不会退出，而是继续执行 Makefile 的后续的内容。当完成读取整个 Makefile 后，make 将试图使用规则来创建通过 “include” 指定但不存在的文件。当不能创建的时候，文件将会保存退出。

使用时，通常用 “-include” 来代替 “include” 来忽略文件不存在或者是无法创建的错误提示，使用格式如下：

-include 

使用方法和 “include” 的使用方法相同。

这两种方式之间的区别：

• 使用 “include ” ，make 在处理程序的时候，文件列表中的任意一个文件不存在的时候或者是没有规则去创建这个文件的时候，make 程序将会提示错误并保存退出。
• 使用 “-include ”，当包含的文件不存在或者是没有规则去创建它的时候，make 将会继续执行程序，只有真正由于不能完成终极目标重建的时候我们的程序才会提示错误保存退出。

7.5 链接脚本

在通过gcc/g++间接调用链接程序ld时，所有的ld选项前必须加上“-Wl,”,因为-Map是ld的选项。

所以，要让g++生成mapfile，需要增加编译参数“ -Wl,-Map,mapfile”。

7.6 ‘@’ ‘KaTeX parse error: Double superscript at position 3: ' '̲$’ ‘-’ '-n ’ 使用小结 7.6.1 ‘@’ 符号的使用

通常makefile会将其执行的命令行在执行前输出到屏幕上。如果将‘@’添加到命令行前，这个命令将不被make回显出来。

例：

#有@，屏幕输出  --compiling module----
@echo  --compiling module----;  

#没有@ 屏幕输出echo  --compiling module---- 
echo  --compiling module----; 

7.6.2 ’ - ’ 符号的使用

通常删除，创建文件如果碰到文件不存在或者已经创建，那么希望忽略掉这个错误，继续执行，就可以在命令前面添加 -，

例：

-rm dir；
-mkdir aaadir；

7.6.3 **’ $ '**符号的使用

美元符号$，主要扩展打开makefile中定义的变量

7.6.4 ’ $$ ’ 符号的使用

$$ 符号主要扩展打开makefile中定义的shell变量

如果make执行时，带入make参数“-n”或“–just-print”，那么其只是显示命令，但不会执行命令，这个功能很有利于我们调试我们的Makefile，看看我们书写的命令是执行起来是什么样子的或是什么顺序的。

而make参数“-s”或“–slient”则是全面禁止命令的显示。

补充说明自动化变量：

@ 表 示 规 则 中 的 目 标 文 件 集 。 在 模 式 规 则 中 ， 如 果 有 多 个 目 标 ， 那 么 ， " @ 表示规则中的目标文件集。在模式规则中，如果有多个目标，那么，" @表示规则中的目标文件集。在模式规则中，如果有多个目标，那么，"@“就是匹配于目标中模式定义的集合。
% 仅当目标是函数库文件中，表示规则中的目标成员名。例如，如果一个目标是"foo.a(bar.o)"，那么，" %“就是"bar.o”，”$@“就是"foo.a”。如果目标不是函数库文件（Unix下是[.a]，Windows下是[.lib]），那么，其值为空。
< 依 赖 目 标 中 的 第 一 个 目 标 名 字 。 如 果 依 赖 目 标 是 以 模 式 （ 即 " < 依赖目标中的第一个目标名字。如果依赖目标是以模式（即"%"）定义的，那么" <依赖目标中的第一个目标名字。如果依赖目标是以模式（即"<"将是符合模式的一系列的文件集。注意，其是一个一个取出来的。
$? 所有比目标新的依赖目标的集合。以空格分隔。
$^ 所有的依赖目标的集合。以空格分隔。如果在依赖目标中有多个重复的，那个这个变量会去除重复的依赖目标，只保留一份。

…待补充

十三 Makefile参数选项 13.1 -D选项更改宏定义

在Makefile中我们可以通过宏定义来控制源程序的编译。只要在Makefile中的CFLAGS中通过选项-D来指定你于定义的宏即可。

C_DEFINES += -DSK_RELEASE

用于将-D后面的SK_RELEASE传递给源代码使用，就相当于在源代码中使用：

#define SK_RELEASE		#宏定义

#Makefile文件
CC_OPTS += -DMakefle_D=2

all:testD
    echo "done"
testD:testD.c
    gcc testD.c -o testD $(CC_OPTS)

#testD.c文件
#include
int main()
{
    printf("Makefle_D = %dn", Makefle_D);
}

注：改动-DMakefle_D=2为-DMakefle_D=3或者-DMakefle_D=4，编译测试

发现改动后，testD.c并不会重新编译。所以在Makefile里面改宏定义，记得要clean