linux 编译构建工具

1
2
3
4

arch   # 'ɑːrtʃ
vendor # 'vendə(r)
eabi   # Embedded Application Binary Interface
       # ɪm'bedɪd            'baɪnəri

1
2
3
4
5
6
7
8

wget https://launchpad.net/gcc-arm-embedded/5.0/5-2016-q3-update/+download/gcc-arm-none-eabi-5_4-2016q3-20160926-linux.tar.bz2 #下载交叉编译器压缩包
sudo tar -xjvf gcc-arm-none-eabi-5_4-2016q3-20160926-linux.tar.bz2 -C /usr/lib/gcc #将交叉编译器压缩包解压到：/usr/lib/gcc
sudo gedit /etc/profile             #打开环境变量,在文件最后添加内容：export PATH=$PATH:/usr/lib/gcc/gcc-arm-none-eabi-5_4-2016q3/bin
source /etc/profile                 #使能环境变量。
sudo apt-get install lsb-core       #64位操作系统需要安装32位依赖库：lsb-core     （arm-none-eabi-gcc 用到）
sudo apt-get install lib32ncurses5  #64位操作系统需要安装32位依赖库：lib32ncurses5（arm-none-eabi-gdb 用到）
arm-none-eabi-gcc -v                #查看版本(验证是否安装成功)
#arm-none-eabi-gcc hello.c -o hello #编译一个程序例子

1
2
3
4
5
6
7
8

wget http://www.codesourcery.com/sgpp/lite/arm/portal/package4571/public/arm-none-linux-gnueabi/arm-2014.05-29-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 #下载交叉编译器压缩包  
sudo tar -xjvf arm-2014.05-29-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2 -C /usr/lib/gcc #将交叉编译器压缩包解压到：/usr/lib/gcc  
sudo gedit /etc/profile             #打开环境变量,在文件最后添加内容：export PATH=$PATH:/usr/lib/gcc/arm-2014.05/bin 
source /etc/profile                 #使能环境变量。
sudo apt-get install lsb-core       #64位操作系统需要安装32位依赖库：lsb-core     （arm-none-eabi-gcc 用到）
sudo apt-get install lib32ncurses5  #64位操作系统需要安装32位依赖库：lib32ncurses5（arm-none-eabi-gdb 用到）
arm-none-linux-gnueabi-gcc -v       #查看版本(验证是否安装成功)
#arm-none-linux-gnueabi-gcc hello.c -o hello #编译一个程序例子

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

target: prerequisites   # 目标: 依赖(可多个文件)。（注：只要声明目标，则表明新的语段开始）
	command             # 命令，前面必须加【tab键】
	command1 ; command2 # 命令，同一[shell]执行命令，可继承前面命令结果（典型例子：cd ~/123/ ; pwd 则结果是 ~/123/，否则是原目录下！）
	command3   command4 # 命令，前后命令各自运行（多行命令也是如此！）（实质就是各自启动一个新 shell 运行命令，所以互不关联！）
	                    # 注意(1)：上面是一个整体语段，中间不能插入诸如“xxx=abc”变量定义等非命令语句!!!
	                    # 注意(2)：不建议在语句后面加注释，因为会影响语句表达，强烈建议在独立行编写注释!!
	                    # ！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
备注：
(1) 代码行后面加入注释，是为了解释每行语句的作用，实际编写 Makefile 脚本时不应
    这样注释，因为可能会影响语句表达甚至出错，所以建议测试例子时把代码行注释删掉。
(2) 实际上 Makefile 脚本语法要求要尽量避免每行文本代码后面存在空格等，因为可能
    会影响语句表达甚至出错，特别变量行尾，因为判断语句判断变量时后面空格一同判断。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

####【生成多个中间文件】####
objects = a.o b.o       # 备注：UNIX 中间文件为`.o`文件，在 Windows 则是`.obj`文件。
.PHONY:oobj             # (1) 表明 oobj 是一个伪目标，不是目标文件！
oobj: $(objects)        # (2) 因为 oobj 是一个伪目标，所以最终得到是其依赖：a.o b.o 中间文件【多个文件】。
$(objects): %.o: %.c    # 静态的多目标语句，展开后目标与依赖为【一对一】关系！
	gcc -c $< -o $@     # 逐一将依赖(`.c`文件)编译为目标(`.o`文件)（目标为：a.o b.o，依赖为：a.c b.c）
	@echo "$@ $^"       # 打印出目标与依赖（因上面是静态模式，所以 $^ 全部依赖只有一个对象）

####【伪目标的典型应用】####
.PHONY:clean            # 为了避免出错，使用【.PHONY】说明【clean】是一个伪目标（PHONY 读音 ˈfəʊni）
clean:
	rm -f *.i *.s *.o   # 删除编译生成的文件

1
2

make oobj               # 运行命令，当前文件夹下的 a.c b.c 源文件编译为中间目标文件！（备注：要事先创建 a.c b.c 这两个文件，它们可以是空白文件）
make clean              # 运行命令，当前文件夹下扩展名为 *.i *.s *.o 的文件被删除！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

cd subdir && $(MAKE) tag     # 调用文件，父 makefile 调用子 makefile 文件。具体：进入 subdir 目录，运行`make tag`命令，完成后返回原目录！
-include out/a.d             # 包含文件，导入依赖信息。备注：包含文件还会执行规则！
VPATH = src:hard/board       # 增加 make 文件搜索目录。备注：可用冒号或者空格隔开！

objs = out/a.o out/b.o       # 变量定义(赋值)，还有":="、"?="、"+="，以及修饰符"override"和"export"。

main.o: main.c main.h        # 单目标多依赖语句，最常规的目标依赖语句。

main.o main.d: main.c main.h # 多目标多依赖语句，表示几个目标具有相同的依赖(集)，只要依赖有变动，则几个目标都要更新与执行命令。

$(objs:.o=.c)                # 替换变量所有字段，将变量所有字段尾部的".o"替换为".c"。
$(objs:%.o=%.c)              # 同上
$(@:%.o=%.c)                 # 同上，对象为自动变量(目标)
                             　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 ┌→必定是【$(objs)】指定的文件，【out/%.o】与【$(objs)】的路径必须是一样！
$(objs): out/%.o: %.c        # 静态的多目标语句，展开后目标与依赖为【一对一】关系！目标为指定目录[out/]的指定".d"，依赖为 Makefile [搜索目录]中与目标[同名称]的".c"文件。
$(objs): out/%.o: src/%.c    # 同上，只是依赖也是指定路径！
                             　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 ┌→必定是 Makefile【依赖关系链】中的文件，从【上级依赖】中获得！
out/%.d: %.c                 # 动态的多目标语句，展开后目标与依赖为【一对一】关系！目标为指定目录[out/]的某个".d"，依赖为 Makefile [搜索目录]中与目标[同名称]的".c"文件。
out/%.d: src/%.c             # 同上，只是依赖也是指定路径！
                             　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 ┌→必定是 Makefile【依赖关系链】中的文件，从【上级依赖】中获得！
%.d: %.c                     # 动态的多目标语句，展开后目标与依赖为【一对一】关系！目标为[当前根目录]中的某个".d"，依赖为 Makefile [搜索目录]中与目标[同名称]的".c"文件。
%.d: %.c | mkdir_target      # 同上，并且在其〖所有操作前执行一次〗mkdir_target 目标的操作。这个对于操作前创建文件夹非常有用，它一般定义为伪目标，它下面命令为创建文件夹。

$(objs): $(objs:.o=.c)       # 多目标多依赖语句，展开后目标与依赖为【一对多】关系！目标为".o"文件，依赖为".c"文件。备注：每个目标具有相同的依赖(集)！

$(func arg1,arg2...)         # 操作函数，"func"为函数，"arg1"第一个参数，"arg2"第二个参数……

$(MAKECMDGOALS)              # make 命令的输入参数（例如：`make clean`命令，则输入参数为`clean`）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

####################################################
# 方法一：
# 【动态的多目标语句】编译出多个目标文件，特点如下：
# 1、[目标文件]须【指出路径】，否则就是当前目录下；
# 2、[目标文件]从【上级依赖】中获得；
# 3、[依赖文件]从【搜索目录】下寻找；
# 4、[目标文件]与[依赖文件]为【同名】的不同类型文件；
# 5、[目标文件]与[依赖文件]为【一对一】关系。
####################################################
all: out/main.o out/foo.o

out/%.o: %.c
	gcc -c $< -o $@

####################################################
# 方法二：（--前提：make 的版本 3.81 或更高版本--）
# 【动态代码】生成多段编译语句，每段编译一个文件：
# 1、使用 define      实现一个伪函数体；(变量用 $$)
# 2、使用 $(call )    实现调用一个伪函数并传递参数；
# 3、使用 $(eval )    将表达式(字符串)转为脚本代码；
# 4、使用 $(foreach ) 从一串字符串中依次取出一个字
#    段作为入口参数并运行伪函数体。
####################################################
define FUNC
$1: $2
	gcc -c -o $$@ $$<
endef

SRCS_F := app/main.c usr/foo.c
all: $(addprefix out/,$(notdir $(SRCS_F:%.c=%.o)))

$(foreach v,$(SRCS_F),$(eval $(call FUNC,$(addprefix out/,$(notdir $(v:%.c=%.o))),$(v))))

1
2
3

AA = abc    # 定义变量 AA （如果改用 := 表示定义的当前目标变量就固定下来，之后不会跟随其引用的变量变化而变化）
$(AA)       # $(AA) 代表 abc。（注意：`AA = abc`定义后面不能有任何多余字符，包括空格、注释等，否则影响执行！）
${AA}       # 同上。            ！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 特别注意：！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
# 下面的`a = first`、`b = second`、`xx1 = a`、`xx2 = 1`后面不能有空格等，否则影响结果！

####【直接代替】####
CC = gcc                      # 定义变量 CC，则 $(CC) 代表 gcc（注：$(CC) 可以写成 ${CC}）
objs := a.o b.o               # 定义变量 objs，则 $(objs) 代表 a.o b.o 
all: $(objs)                  # 这句告诉 make 工具：最终得到 a.o b.o 中间文件
$(objs): %.o: %.c             # 从 $(objects) 变量中制作出【一对一】关系的目标(`.o`文件)和依赖(`.c`文件)
	$(CC) -O2 $< -o $@        # 逐一将依赖(`.c`文件)编译为目标(`.o`文件)（目标为：a.o b.o，依赖为：a.c b.c）

####【变量追加】####
objs += fff.o                 # 追加变量，则此时最新变量就是 a.o b.o fff.o


####【字段替换】####
obj3  := a.o b.o c.o d.s      # 下面替换的最终结果为：a.c b.c c.c d.s
src2 := $(obj3:.o=.c)         # 将变量 $(obj3)【全部】定义的文件名称尾部的".o"替换为".c" 并取出传递给 src2
src1 := $(obj3:%.o=%.c)       # 将变量 $(obj3)【全部】定义的文件名称尾部的".o"替换为".c" 并取出传递给 src1

####【字符替换】####
first_second = Hello
a = first
b = second
src3 = $($a_$b)               # 则“$a_$b”组成了“first_second”，于是 $(src3) 的值就是“Hello”
                              # 注意：变量定义后面不能有任何字符（包括空格、注释等），否则这些字符也被替换进去!!!
                              # ！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
a_objs := a.o b.o c.o
1_objs := 1.o 2.o 3.o
xx1 = a
xx2 = 1
src4 := $($(xx1)_objs:.o=.c)  # 表示将目标 a_objs 的源文件名称尾部的 .o 替换为 .c 并传给 src4
src5 := $($(xx2)_objs:.o=.c)  # 表示将目标 1_objs 的源文件名称尾部的 .o 替换为 .c 并传给 src5
                              # 注意：变量定义后面不能有任何字符（包括空格、注释等），否则这些字符也被替换进去!!!
                              # ！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
test:
	@echo "objs: $(objs)"     # 打印信息为 objs: a.o b.o fff.o （如果 @echo 改为 echo 则表示本行字符命令也打印出来）
	@echo "src1: $(src1)"     # 打印信息为 src1: a.c b.c c.c d.s
	@echo "src2: $(src2)"     # 打印信息为 src2: a.c b.c c.c d.s
	@echo "src3: $(src3)"     # 打印信息为 src3: Hello
	@echo "src4: $(src4)"     # 打印信息为 src4: a.c b.c c.c
	@echo "src5: $(src5)"     # 打印信息为 src5: 1.c 2.c 3.c

1
2
3
4
5
6
7

make test                     # 运行命令，结果如下：
objs: a.o b.o fff.o
src1: a.c b.c c.c d.s
src2: a.c b.c c.c d.s
src3: Hello
src4: a.c b.c c.c
src5: 1.c 2.c 3.c

1
2
3
4
5
6
7
8
9

######普通变量######
src1 := a.c b.c c.c
all1:
	@echo "src1: $(src1)"

######变量覆盖######
override src2 := a.c b.c c.c
all2:                    # 上行`override`是变量强制覆盖关键字！！！！！！！！
	@echo "src2: $(src2)"

1
2
3
4
5
6
7

######普通变量######
make all1 src1=abc       # 运行命令，
src1: abc                # 运行结果（Makefile 变量无法覆盖 shell 命令行变量[src1]）。

######变量覆盖######
make all2 src2=abc       # 运行命令，
src2: a.c b.c c.c        # 运行结果（Makefile 变量[src2]强制覆盖 shell 命令行变量）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

define AA             # 定义 AA 变量为代码块
command               # 命令，备注：前面无须加【tab键】
endef                 # 注意：多行定义里面不能有条件判断语句，否则make工具直接抛出错误！

$(AA)                 # $(AA) 代表 代码块

# 特别用途-------------
define LFTAB          # 定义 LFTAB 为【换行+Tab格】，辅助将一行字符串转换为多行字符串命令（替换或插入操作）！


endef

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 定义删除命令
define RUN_RM
rm -f $(objects)
rm -f 1.o 2.o
endef

# make操作目标
objects = a.o b.o
.PHONY:clean
clean:
	$(RUN_RM)

1

make clean              # 运行命令，当前文件夹下的 a.o b.o 1.o 2.o 文件被删除！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

ifeq (arg1,arg2)      # 判断 arg1 与 arg2 是否相同
else
endif

ifneq (arg1,arg2)     # 判断 arg1 与 arg2 是否不相同
else
endif

ifdef arg             # 判断 如果定义了变量 arg
else
endif

ifndef arg            # 判断 如果没有定义变量 arg
else
endif

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 特别注意：！！！！！！！！！！！！！！！！！！！！
# 下面的`CC = gcc`后面不能有空格等，否则影响结果！
CC = gcc
objects = a.o b.o
.PHONY:clean          # 为了避免出错，使用【.PHONY】说明【clean】是一个伪目标
clean:                # ！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
ifeq ($(CC),gcc)      # 判断 $(CC) == gcc（注意：`CC = gcc`定义后面不能有任何多余字符，包括空格、注释等！！）
ifdef objects         # 等同 ifneq ($(objects),)
	rm -f $(objects)  # 删除编译生成的中间文件
endif
else
ifdef objects 
	rm -f $(objects:.o=.obj)
endif
endif

1

make clean              # 运行命令，当前文件夹下的 a.o b.o 文件被删除！

1
2
3

$(func arg1,arg2…)             # 函数名和参数之间以“空格”分隔，参数与参数之间以“逗号”分隔。 
${func arg1,arg2…}             # 同上

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

# --------------------------------------------------------------------------------------------------------
# 一、字符串/字符段操作函数 ------------------------------------------------------------------------------
# --------------------------------------------------------------------------------------------------------

# 01.〖字符串:查找〗函数       （★注意：输入参数的“%”只作为“普通字符”★）
$(findstring find_str,str)      # 在“str”字串中查找“find_str”字符串，如果找到则返回“find_str”原字符串（表示“真”的意思），否则返回空字符（表示“假”的意思）
                                # $(findstring a b,a b c) 在“a b c”字串中查找“a b”字串，返回“a b”->“真”
                                # $(findstring a b,b c)   在“b c”  字串中查找“a b”字串，返回“”---->“假”（空字符）

# 02.〖字符串:替换〗函数       （★注意：输入参数的“%”只作为“普通字符”★）
$(subst from,to,str)            # 把“str”中的“from”字符串替换为“to”，返回替换后的字符串
                                # $(subst is i,IS I,this is a dog) “this is a dog”替换后为“thIS Is a dog”

# -------------------------------

# 03.【字符段:替换】函数       （★注意：同一控制参数的第一个`%`为通配符，后面的`%`都是普通字符★）
$(patsubst from,to,str)         # 把“str”中的“from”字段替换为“to”，返回替换后的字符串
                                # $(patsubst %.c,%.o,x.c.c aaa.c) “x.c.c aaa.c”替换后为“x.c.o aaa.o”（只能使用“%”通配符）

# 04.【字符段:筛选】函数       （★注意：同上★）
$(filter pat1 par2 ...,str)     # 从“str”中过滤掉【非“pat1”“par2”...】字段
                                # $(filter %.c %.s,aaa.c bbb.c ccc.s ddd.h) “aaa.c bbb.c ccc.s ddd.h”筛选后返回“aaa.c bbb.c ccc.s”

# 05.【字符段:过滤】函数       （★注意：同上★）
$(filter-out pat1 par2 ...,str) # 从“str”中过滤掉【“pat1”“par2”...】字段
                                # $(filter-out %.c %.s,aaa.c bbb.c ccc.s ddd.h) “aaa.c bbb.c ccc.s ddd.h”过滤后返回“ddd.h”

# -------------------------------

# 06.取出【首个字段】函数
$(firstword str)                # 取出“str”字符串中的首个字段
                                # $(firstword aaa bbb)返回值是“aaa”

# 07.取出【某个字段】函数
$(word n,str)                   # 取出“str”字符串中第【n】个字段
                                # $(word 2, aaa bbb ccc)返回值是“bbb”

# 08.取出【多个字段】函数
$(wordlist s,e,str)             # 取出“str”字符串中第【s~e】个字段
                                # $(wordlist 2, 3, aaa bbb ccc)返返回值是“bbb ccc”

# 09.统计【字段个数】函数
$(words str)                    # 统计“str”字符串中的字段个数
                                # $(words, aaa bbb ccc)返回值是“3”

# 10.排序【全部字段】函数
$(sort str)                     # 给“str”多个字段排序，返回排序后的字符串，同时去除相同字段！！！
                                # $(sort bbb bbb aaa ccc) 返回“aaa bbb ccc”

# 11.整理【全部字段】函数      （★备注：去除多余空字符，空字符包括空格、[Tab]等不可显示字符★）
$(strip str)                    # 把“str”字串中【多余空字符】格式化为各一个【空格】分隔
                                # $(strip a 	b % c ) “a 	b % c ”去除多余的空格，结果是“a b % c”

# 12.合并【纵向字段】函数
$(join str1,str2)               # 把“str1”和“str2”字符串的全部字段进行纵向合并
                                # $(join aaa	bbb , 111 222 333) 返回“aaa111 bbb222 333”

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# --------------------------------------------------------------------------------------------------------
# 二、文件路径/名称操作函数 ------------------------------------------------------------------------------
# --------------------------------------------------------------------------------------------------------

# 13.取【路径】函数
$(dir str)                      # 取出“str”字符串各个字段的路径
                                # $(dir src/aaa.c bbb.c) 返回“src/ ./”

# 14.取【除路径】函数
$(notdir str)                   # 取出“str”字符串各个字段的除去路径内容
                                # $(notdir src/aaa.c bbb) 返回“aaa.c bbb”

# 15.取【扩展名】函数
$(suffix str)                   # 取出“str”字符串各个字段的扩展名（包括除“.”）
                                # $(suffix src/aaa.c bbb.c fff) 返回“.c .c”

# 16.取【除扩展名】函数
$(basename str)                 # 取出“str”字符串各个字段的除去扩展名内容（不取“.”）
                                # $(basename src/aaa.c bbb) 返回“src/aaa bbb”

# 17.加【前缀】函数
$(addprefix prefix,str)         # 加入“str”字符串各个字段的前缀（例如：加路径）
                                # $(addprefix src/,fff/aaa.c bbb) 返回“src/fff/aaa.c src/bbb”

# 19.加【后缀】函数
$(addsuffix suffix,str)         # 加入“str”字符串各个字段的后缀（例如：加扩展名）
                                # $(addsuffix .c,src/aaa bbb.) 返回“src/aaa.c bbb..c”

# 19.列出【路径+文件】函数
$(wildcard str1,str2,...)       # 列出“str1”“str2”… 路径下的对应文件（需要通配符`*`配合使用）
                                # $(wildcard *.c ./src/*.c) 返回“aaa.c bbb.c ./src/ccc.c”
# 20.得到【绝对路径】函数
$(realpath path)                # 将【相对路径】转换成【绝对路径】，会判断文件和目录是否存在，如果不存在，则返回空。
$(abspath path)                 # 将【相对路径】转换成【绝对路径】，不判断文件和目录是否存在。
                                # $(realpath .) 返回当前路径的绝对路径，例如“/home/o2ospring/Downloads/makefile_demo”
                                # $(abspath .)  返回当前路径的绝对路径，例如“/home/o2ospring/Downloads/makefile_demo”

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

# --------------------------------------------------------------------------------------------------------
# 三、相关扩展/控制操作函数 ------------------------------------------------------------------------------
# --------------------------------------------------------------------------------------------------------

# 21.【调用shell命令】函数
$(shell shell_cmd)              # 调用 shell 命令“shell_cmd”运行并将返回信息传递给 Makefile 脚本（因要启动另一个 shell，会影响系统性能!!!）
                                # mk_val = $(shell pwd)   结果“/home/xiaomin/test”（当前所在目录）信息传递给 Makefile 变量 mk_val
                                # $(shell gcc -MM main.c) 结果“main.o: main.c main.h”

# 22.【变量参数化】函数
var = $(1) $(2) ...             # $(1)表示取第一个参数“str1”，$(2)表示取第二个参数“str2”，……
$(call var,str1,str2,...)       # 将 var 视为函数(调用)，将 str1 视为第一个参数，将 str2 视为第二个参数，则将上行表达式视为函数体！
                                # v3 = $(3) $(1) $(2)
                                # $(call v3,bb bb,cc,aa)  结果“aa bb bb cc”（注意：bb bb 是一个参数，因为没有用逗号分开！）
                                # $(call v3,$(shell pwd)) 结果“/home/xiaomin/test”（因其它两个参数为空,即只会得出一个参数）
# 23.【条件判断】函数
$(if true,true_str1)            # 如果“true”为非空字符(真)，则返回“true_str1”表态式，否则返回“空”
$(if true,true_str1,false_str2) # 如果“true”为非空字符(真)，则返回“true_str1”表态式，否则返回“false_str2”表态式
                                # v1 = 0
                                # $(if v1,$(shell pwd))   结果“/home/xiaomin/test”
                                # $(if v1,if ...,else..)  结果“if ...”
                                # $(if $(strip $(SRCS_F)),,$(error No source files)) 表示如果源文件没定义则提示出错信息并停止运行
# 24.【循环处理】函数
$(foreach v,str,text)           # 将“str”中的字段逐次取出缓存到“v”再传给“text”表达式处理，最后返回整串字符串（其中 v 为临时变量）
                                # $(foreach v,a b c,$(v).o) 结果“a.o b.o c.o”

# 25.【动态代码】函数
$(eval text)                    # 将“text”的内容将作为 makefile 的一部分而被 make 解析和执行。（注意：text 中应要使用 $$ 来表示 make 的变量符 $）
                                # 通过 $(eval ) $(call ) $(foreach ) 可实现更加灵活地生成 make 代码，并且可实现向生成代码传递参数！！！
                                # define FUNC
                                # OBJ_PATH := out
                                # obj = $$(OBJ_PATH)/$(strip $1)
                                # $$(obj): $2
                                # 	gcc $$< -o $$@
                                # endef
                                # 
                                # all : out/foo
                                # 
                                # $(eval $(call FUNC,foo,main.c))    # FUNC 宏就像是函数，foo 为第一个参数，main.c 第二个参数，在代码内分别用 $1 $2 来表示。
# -------------------------------

# 26.【错误控制】函数
$(error msg)                    # 显示“msg”错误信息及强行停止 Makefile 运行
                                # $(error error message!) 结果“error message!.  Stop.”错误信息显示及停止运行


# 27.【警告控制】函数
$(warning msg)                  # 显示“msg”警告信息但不会停止 Makefile 运行
                                # $(warning warning message!) 结果“warning message!”警告信息显示

备注：make 命令执行后有三个退出码：
0 -- 表示成功执行，则返回【0】。
1 -- 如果 make 运行时出现任何错误，则返回【1】。
2 -- 如果你使用了make的“-q”选项，并且 make 使得一些目标不需要更新，则返回【2】。

# -------------------------------  

# 28.【变量来源】函数
val_in_file := test_file
override val_override := test_override

$(origin not_define)    # 结果“undefined”    变量没有定义!!!!!
$(origin PATH)          # 结果“environment”  shell  的环境变量
$(origin val_in_cmd)    # 结果“command line” make 命令参数变量（补充：运行命令为 make val_in_cmd=val_cmd）
$(origin val_in_file)   # 结果“file”         Makefile 用户变量
$(origin CC)            # 结果“default”      Makefile 默认变量
$(origin val_override)  # 结果“override”     Makefile 中使用 override 重新定义的变量
$(origin @)             # 结果“automatic”    Makefile 自动变量（如：$(@)）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 注意：include 前【绝不能】用[Tab键]开始
include file    # 把其它 Makefile 包含进来，file 是包含进来的文件（可多个文件，也可包括路径）
                # 注意:【包含】不但是把其它 Makefile 代码拷贝过来，还会执行固有的规则！

关于 include 有两项动作：
(1) 包含：把别的 Makefile 代码拷贝过来，相当于在自身编写这些代码一样。
(2) 规则：搜索与包含文件同路径同名称的目标并尝试运行规则！具体有如下：
    只有当【包含文件存在】并且【没找到对应目标 或 对应目标无依赖 或 
	对应实目标新于依赖】才放弃运行规则，否则必定尝试运行规则(它优先在
    用户操作的所有目标前执行：尝试创建或更新包含文件，并执行同路径同
    名称目标命令)。除上面情形外，当出现包含文件不存在、或找不到对应目
    标都会抛出错误！

1
2
3
4
5
6
7
8

####包含子Makefile文件####
include ./subdir/Subfile

aaaa = 1.i 2.i
.PHONY:clean
clean: clean_1 clean_2
clean_1:
	rm -f x.c y.c              # 删除 x.c y.c 文件 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

############################
# 此文件在`subdir`子文件夹下
############################

all_1: a.c b.c
	gcc $^ -o $@
	                           # 编译 a.c b.c 为 all_1 执行文件
.PHONY:clean_2 
clean_2:  
	rm -f *.o $(aaaa)          # 删除编译的中间文件

1
2
3

make clean                     # 运行命令，
                               # 结果：删除【当前文件夹】下的 x.c y.c 1.i 2.i 文件及扩展名为 *.o 的文件！
                               # 注意：命令`rm -f *.o $(aaaa)`并不是对`subdir`子文件夹操作！

1
2
3

# 注意：调用其实就是直接运行命令，所以行首记得加[Tab]键
	cd subdir && $(MAKE) tag  # 表示进入 subdir 目录，并且运行`$(MAKE) tag`命令（默认命令是`make`，即 `make tag`）
	$(MAKE) tag -C subdir     # 同上

1
2
3
4
5
6
7
8
9

all_1:
	cd subdir && $(MAKE) all_1
	                           # 表示调用下级目录 subdir 的 Makefile 文件，执行其目标 all_1
	                           # $(MAKE) 为当前使用的 make 命令工具（默认命令是`make`）（等同 cd subdir && make all_1）
all_2:
	$(MAKE) clean_2 -C subdir
	                           # 表示调用下级目录 subdir 的 Makefile 文件，执行其目标 clean_2
	                           # $(MAKE) 为当前使用的 make 命令工具（默认命令是`make`）（等同 make clean_2 -C subdir）
	rm -f x.c y.c              # 同时删除当前父级文件夹下的 x.c y.c 文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

############################
# 此文件在`subdir`子文件夹下
############################

all_1: a.c b.c
	gcc $^ -o $@
	                           # 编译 a.c b.c 为 all_1 执行文件
.PHONY:clean_2 
clean_2:  
	rm -f *.i *.s *.o
	                           # 删除编译的中间文件

1
2
3
4

make all_1                     # 运行命令，编译【subdir】文件夹下的 a.c b.c 源文件！
make all_2                     # 运行命令，结果【subdir】文件夹下扩展名为 *.i *.s *.o 的文件被删除，
                               #             以及当前父级文件夹下的 x.c y.c 文件被删除！！！！！！！
							   

1
2
3
4
5
6

# 方式一：
VPATH = directories            # `添加`搜索目录<directories>，多个目录用冒号或者空格隔开。备注：VPATH 是`变量`！
# 方式二：
vpath pattern directories      # `添加`指定<pattern>文件类型的搜索目录为<directories>，多个目录用冒号或者空格隔开。
vpath pattern                  # `清除`指定<pattern>文件类型的搜索目录。
vpath                          # `清除所有`已被设置好了的文件搜索目录。

1
2
3
4
5

VPATH = src:hard/board   # 设置相关文件可能所在的目录"src"和"hard/board"
vpath %.c src:hard/board # 增加".c"源文件可能所在的目录"src"
vpath %.h include        # 增加".h"头文件可能所在的目录"include"
vpath % modules          # 增加"任意"文件可能所在的目录"modules"
vpath %.cpp              # 清除之前增加的".cpp"源文件全部目录

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

####################################################
# 1、本案例展示多个文件编译和链接。
# 2、无论我们写再复杂的 Makefile，最终展开所有变量和
#    脚本语句后，与本例 makefile 展示的形式都是一样，
#    不一样的只是展开的目标更多、每个目标的依赖更多、
#    每个目标的操作命令更多而已！
# 3、补充说明：脚本所有内容(包括变量、函数等)展开后
#    都是一组字符串，最终就不存在变量这类的内容了！
####################################################

.PHONY: all
all: main
main:    hello.o test.o main.o
	gcc  hello.o test.o main.o -o main  # 链接

hello.o: hello.c hello.h
hello.o: hello.c
	gcc -c hello.c -o hello.o           # 编译

test.o: test.c test.h
test.o: test.c
	gcc -c test.c -o test.o             # 编译

main.o: main.c main.h hello.h test.h
main.o: main.c
	gcc -c main.c -o main.o             # 编译
#	@echo $^                            # 如果开启打印，就会发现【$^】为【main.c main.h hello.h test.h】！

.PHONY: clean                           # 为了避免出错，使用 .PHONY 说明 clean 是一个伪目标
clean:
	rm -f main.o test.o hello.o main    # 删除编译生成的文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

####################################################
# 方法一：
# 【动态的多目标语句】编译出多个目标文件，特点如下：
# 1、[目标文件]须【指出路径】，否则就是当前目录下；
# 2、[目标文件]从【上级依赖】中获得；
# 3、[依赖文件]从【搜索目录】下寻找；
# 4、[目标文件]与[依赖文件]为【同名】的不同类型文件；
# 5、[目标文件]与[依赖文件]为【一对一】关系。
####################################################
all: out/main.o out/foo.o

out/%.o: %.c
	gcc -c $< -o $@

####################################################
# 方法二：（--前提：make 的版本 3.81 或更高版本--）
# 【动态代码】生成多段编译语句，每段编译一个文件：
# 1、使用 define      实现一个伪函数体；(变量用 $$)
# 2、使用 $(call )    实现调用一个伪函数并传递参数；
# 3、使用 $(eval )    将表达式(字符串)转为脚本代码；
# 4、使用 $(foreach ) 从一串字符串中依次取出一个字
#    段作为入口参数并运行伪函数体。
####################################################
define FUNC
$1: $2
	gcc -c -o $$@ $$<
endef

SRCS_F := app/main.c usr/foo.c
all: $(addprefix out/,$(notdir $(SRCS_F:%.c=%.o)))

$(foreach v,$(SRCS_F),$(eval $(call FUNC,$(addprefix out/,$(notdir $(v:%.c=%.o))),$(v))))