第36讲：Makefile的常用函数

$(函数名 参数1, 参数2, 参数3, ...)
# 或者用花括号
${函数名 参数1, 参数2, 参数3, ...}

# 正确：三个参数
$(patsubst %.c, %.o, foo.c bar.c)

# 错误：逗号位置不对
$(patsubst,%.c,%.o,foo.c bar.c)   # 多了逗号

# 正确：参数本身可以含空格
$(patsubst %.c, %.o, foo.c bar.c baz.c)
#                    ^^^^^^^^^^^^^^^^ 这是一个参数（包含空格）

# 将 foo.c bar.c 替换为 foo.o bar.o
OBJS = $(patsubst %.c, %.o, foo.c bar.c)
# OBJS = foo.o bar.o

test:
	@echo $(patsubst %.c, %.o, foo.c bar.c)
# 输出: foo.o bar.o

# % 匹配了 "main"，然后用 "main" 替换 replacement 中的 %
$(patsubst src/%.c, build/%.o, src/main.c)
# 结果: build/main.o

# 匹配多个文件
$(patsubst src/%.c, build/%.o, src/main.c src/init.c src/util.c)
# 结果: build/main.o build/init.o build/util.o

# 给文件名添加前缀
$(patsubst %, lib%, math.c string.c)
# 结果: libmath.c libstring.c

# 替换目录中间的部分
$(patsubst app/v%/src, lib/v%/obj, app/v1/src app/v2/src)
# 结果: lib/v1/obj lib/v2/obj

# subst：精确字符串替换（不支持 % 通配符）
$(subst .c,.o, foo.c bar.c)
# 结果: foo.o bar.o

# patsubst：模式匹配替换（支持 % 通配符）
$(patsubst %.c, %.o, foo.c bar.c)
# 结果: foo.o bar.o

# 典型用例对比

# 场景一：统一路径分隔符（Windows ↔ Linux）
WIN_PATH = $(subst /,\,src/module/file.c)    # src\module\file.c

# 场景二：替换文件后缀
OBJS = $(patsubst %.c, %.o, $(SRCS))          # 只能用 patsubst

NAME = $(notdir src/main.c)
# NAME = main.c

test:
	@echo $(notdir src/main.c src/sub.c)
# 输出: main.c sub.c

# 多层嵌套路径
$(notdir a/b/c/d/file.txt)       # file.txt

# 多个路径同时处理
$(notdir src/main.c lib/util.c include/config.h)
# 结果: main.c util.c config.h

# 如果已经是纯文件名，不做任何改变
$(notdir main.c)                  # main.c

# 场景：源码在子目录中，但 .o 文件要统一放到 build/ 目录
SRCS = $(wildcard src/*.c lib/*.c)
# SRCS = src/main.c src/init.c lib/util.c

# 去掉路径，只剩文件名
OBJ_NAMES = $(notdir $(SRCS))
# OBJ_NAMES = main.c init.c util.c

# 再替换后缀并加目录前缀
OBJS = $(patsubst %.c, build/%.o, $(OBJ_NAMES))
# OBJS = build/main.o build/init.o build/util.o

# 实际操作示例
PATH = src/app/main.c

$(notdir $(PATH))     # main.c       ← 只要文件名
$(dir $(PATH))        # src/app/     ← 只要目录（注意末尾的 /）
$(basename $(PATH))   # src/app/main ← 去掉后缀
$(suffix $(PATH))     # .c           ← 只要后缀

SRC_FILES = $(wildcard *.c)
# 假设当前目录有 main.c sub.c，则 SRC_FILES = main.c sub.c

# 错误写法：Makefile 中直接写通配符不会展开
SRCS = *.c          # SRCS 的值是字面量 "*.c"，不是文件列表！

# 正确写法：必须用 wildcard 函数
SRCS = $(wildcard *.c)   # SRCS = main.c util.c ...

# 为什么？因为 Make 处理变量赋值时不会展开通配符
# 通配符展开是 shell 的特性，make 需要显式调用 wildcard 函数

# * 匹配任意字符串（不含路径分隔符）
$(wildcard *.c)           # main.c util.c

# ? 匹配单个字符
$(wildcard file?.txt)     # file1.txt fileA.txt（不匹配 file10.txt）

# [字符集] 匹配指定范围内的字符
$(wildcard [a-z]*.c)      # 以小写字母开头的 .c 文件

# 子目录中的通配符
$(wildcard src/*.c)       # src/main.c src/util.c
$(wildcard */*.c)         # module1/mid.c module2/main.c（一级子目录）

# 陷阱：在规则中重复调用 wildcard
FILES = $(wildcard *.c)    # 此时扫描目录

all:
	@echo $(FILES)

# 问题：如果在 make 运行期间新增了 .c 文件，FILES 不会更新
# 因为 wildcard 在变量赋值时执行，而不是在规则执行时

# 解决方法：在规则内部直接调用 wildcard
all:
	@echo $(wildcard *.c)   # 每次执行规则时重新扫描

# 一级子目录
SRCS = $(wildcard */*.c)
# module1/mid.c module2/main.c

# 两级子目录
SRCS = $(wildcard */*/*.c)
# module1/sub/file.c

# 配合 foreach 递归多级目录（见 2.4 节）

$(foreach var, list, text)

DIRS = module1 module2
SRCS = $(foreach dir, $(DIRS), $(wildcard $(dir)/*.c))
# 等价于：wildcard module1/*.c + wildcard module2/*.c
# 返回两个目录下所有 .c 文件

第1次遍历：var=module1 → 执行 wildcard module1/*.c
第2次遍历：var=module2 → 执行 wildcard module2/*.c
结果拼接：.../module1/*.c .../module2/*.c

# 每次迭代的结果用空格拼接
$(foreach n, 1 2 3, $(n).txt)
# 结果: 1.txt 2.txt 3.txt

# shell 中的 for 循环（bash）
for dir in module1 module2; do
    ls $dir/*.c
done

# Makefile 中的 foreach（功能类似，但写法不同）
$(foreach dir, module1 module2, $(wildcard $(dir)/*.c))

# 二维遍历：模块 × 文件类型
MODULES = core net ui
TYPES = .c .h

FILES = $(foreach m, $(MODULES), \
           $(foreach t, $(TYPES), $(m)/*$(t)))
# 结果: core/*.c core/*.h net/*.c net/*.h ui/*.c ui/*.h

# 模式1：遍历目录列表收集文件
SRCS = $(foreach dir, $(SRC_DIRS), $(wildcard $(dir)/*.c))

# 模式2：为每个模块生成编译规则
RULES = $(foreach mod, $(MODULES), $(mod).rule)

# 模式3：批量添加前缀
INCLUDES = $(foreach dir, $(INC_DIRS), -I$(dir))
# INCLUDES = -Iinclude -Isrc -Ilib
# 注意：这里 -I 和 $(dir) 之间没有空格，这是 gcc 能接受的格式
# gcc 同时支持 -I dir 和 -Idir 两种写法

INC_DIRS = include src lib

# 方式A：addprefix 函数（推荐）
CFLAGS += $(addprefix -I, $(INC_DIRS))
# 结果: -Iinclude -Isrc -Ilib

# 方式B：foreach 手动拼接
CFLAGS += $(foreach d, $(INC_DIRS), -I$(d))
# 结果: -Iinclude -Isrc -Ilib

# 两种方式结果相同。gcc 接受 -Iinclude（无空格）和 -I include（有空格）

# 错误示例：试图在 foreach 中修改变量
# 不要这样写！foreach 中的变量展开在 Make 解析阶段，不是运行时

# 正确：foreach 只用于生成文本，不要用于"累加"操作
NAMES = $(foreach n, 1 2 3, file_$(n))
# NAMES = file_1 file_2 file_3

# 只保留 .c 文件
SRCS = $(filter %.c, main.c util.h config.c readme.txt)
# SRCS = main.c config.c

# 只保留特定目录下的文件
SRC_FILES = $(filter src/%, src/main.c lib/util.c src/init.c)
# SRC_FILES = src/main.c src/init.c

# 排除 .o 文件，获取其他文件列表
NON_OBJ = $(filter-out %.o, main.o util.c data.txt app.o)
# NON_OBJ = util.c data.txt

# 实用场景：从所有文件中排除不需要编译的文件
ALL_SRCS = $(wildcard *.c)
EXCLUDE = test_main.c skip_this.c
SRCS = $(filter-out $(EXCLUDE), $(ALL_SRCS))

# 排序 + 去重
$(sort c b a b c)
# 结果: a b c

# 实用场景：去重头文件搜索路径
INC_DIRS = $(sort include lib include src lib)
# INC_DIRS = include lib src
# 去掉了重复的 include 和 lib，按字母排序

$(word 2, apple banana cherry)
# 结果: banana

$(word 1, apple banana cherry)
# 结果: apple

# 索引超出范围返回空字符串（不是错误）
$(word 10, a b c)
# 结果: （空）

$(wordlist 2, 4, a b c d e f)
# 结果: b c d

# 起点大于终点 → 返回空
$(wordlist 4, 2, a b c d e f)
# 结果: （空）

# 对应 Python 中的 text.split()[s-1:e]

TEXT = apple banana cherry date

$(words $(TEXT))       # 4（单词数量）
$(firstword $(TEXT))   # apple
$(lastword $(TEXT))    # date

$(dir src/main.c)
# 结果: src/

$(dir src/foo/bar.txt lib/util.h)
# 结果: src/foo/ lib/

# 注意：返回值末尾有 /

# 去掉后缀
$(basename src/main.c)
# 结果: src/main

# 取后缀
$(suffix src/main.c)
# 结果: .c

# 多个文件
$(basename a.tar.gz b.txt)
# 结果: a.tar b

$(suffix a.tar.gz b.txt)
# 结果: .gz .txt
# 注意：suffix 只取最后一个 . 之后的部分，不是 .tar.gz

# 添加后缀
$(addsuffix .o, main util)
# 结果: main.o util.o

# 添加前缀
$(addprefix build/, main.o util.o)
# 结果: build/main.o build/util.o

# 与 patsubst 配合使用的典型模式
OBJS = $(addprefix $(BUILD_DIR)/, $(patsubst %.c, %.o, $(notdir $(SRCS))))
# 先替换后缀 .c→.o，再加 build/ 前缀

$(join a b c, .c .h .o)
# 结果: a.c b.h c.o

# 两个列表长度不同时，多出的部分原样保留
$(join a b, 1 2 3 4)
# 结果: a1 b2 3 4

# 获取当前日期
BUILD_DATE = $(shell date +%Y-%m-%d)

# 获取 git 版本号
GIT_VER = $(shell git describe --tags --always 2>/dev/null || echo "unknown")

# 自动检测操作系统
UNAME_S = $(shell uname -s)
ifeq ($(UNAME_S), Linux)
    PLATFORM = linux
else ifeq ($(UNAME_S), Darwin)
    PLATFORM = macos
endif

# info：打印信息（不中断）
$(info === 开始编译，目标平台: $(PLATFORM) ===)

# warning：打印警告（不中断）
ifndef CC
    $(warning CC 未定义，使用默认编译器 gcc)
    CC = gcc
endif

# error：打印错误并中断 make 执行
ifndef CROSS_COMPILE
    $(error 交叉编译前缀 CROSS_COMPILE 未定义！)
endif

# 定义一个"函数"：将源文件编译为目标文件
define compile_module
    $(CC) $(CFLAGS) -c $(1) -o $(2)
endef

# 调用该"函数"
module.o: module.c
	$(call compile_module, $<, $@)
# 展开为: gcc -Wall -c module.c -o module.o

# 更实用的例子：为每个模块生成编译规则
define MODULE_TEMPLATE
$(1)_OBJS = $$(patsubst %.c, build/%.o, $$(notdir $$(wildcard $(1)/*.c)))
$(1)_target: $$($(1)_OBJS)
	$$(CC) -o $$@ $$^
endef

MODULES = core net ui
$(foreach m, $(MODULES), $(eval $(call MODULE_TEMPLATE, $(m))))

# 动态为每个 .c 文件生成编译规则
SRCS = main.c util.c
define GEN_RULE
$(patsubst %.c, %.o, $(1)): $(1)
	$(CC) -c $$< -o $$@
endef

$(foreach src, $(SRCS), $(eval $(call GEN_RULE, $(src))))

# 展开后等价于：
# main.o: main.c
# 	$(CC) -c $< -o $@
# util.o: util.c
# 	$(CC) -c $< -o $@

app3/
├── Makefile
├── module1/
│   └── mid.c
├── module2/
│   └── main.c
└── build/          ← 自动生成，存放编译产物
    ├── app3        ← 可执行文件
    ├── mid.o
    └── main.o

CC = gcc
TARGET = app3

# 源码目录列表
SRC_DIR = module1 module2

# 构建输出目录
BUILD_DIR = build

# ★ 关键：告诉 make 在哪些目录中搜索源文件
# 没有这行，模式规则中的 %.c 无法在子目录中找到源文件
VPATH = $(SRC_DIR)

# 遍历所有源码目录，收集所有 .c 文件
SRCS = $(foreach dir, $(SRC_DIR), $(wildcard $(dir)/*.c))

# 去除路径，只保留文件名，再替换 .c → .o
OBJS = $(patsubst %.c, $(BUILD_DIR)/%.o, $(notdir $(SRCS)))

# 指定头文件搜索路径
INC_DIR = $(SRC_DIR)

# 默认目标
$(BUILD_DIR)/$(TARGET): $(OBJS) | $(BUILD_DIR)
	$(CC) -o $@ $^

# 模式规则：编译 .c → .o（make 会通过 VPATH 找到源文件）
$(BUILD_DIR)/%.o: %.c | $(BUILD_DIR)
	$(CC) -c $(addprefix -I, $(INC_DIR)) $< -o $@

# 创建输出目录（伪目标）
$(BUILD_DIR):
	mkdir -p $@

.PHONY: clean
clean:
	rm -rf $(BUILD_DIR)

$ make
mkdir -p build
cc -c -I module1 -I module2 module1/mid.c -o build/mid.o
cc -c -I module1 -I module2 module2/main.c -o build/main.o
cc -o build/app3 build/mid.o build/main.o

$ ./build/app3
Hello World!

SRC_DIR = module1 module2
SRCS = $(foreach dir, $(SRC_DIR), $(wildcard $(dir)/*.c))

foreach 第1次: dir=module1 → wildcard module1/*.c → module1/mid.c
foreach 第2次: dir=module2 → wildcard module2/*.c → module2/main.c
拼接结果: SRCS = module1/mid.c module2/main.c

# 输入
SRCS = module1/mid.c module2/main.c

# 处理
$(notdir $(SRCS))
# 输出: mid.c main.c

OBJS = $(patsubst %.c, $(BUILD_DIR)/%.o, $(notdir $(SRCS)))
# 等价于:
# OBJS = $(patsubst %.c, build/%.o, mid.c main.c)
# 结果: build/mid.o build/main.o

# 不能这样写（错误示范）：
OBJS = $(patsubst %.c, build/%.o, $(SRCS))
# 结果: build/module1/mid.o build/module2/main.o
# 问题：obj 文件嵌套在 build/module1/、build/module2/ 下，不是扁平结构

VPATH = $(SRC_DIR)   # VPATH = module1 module2

# VPATH 的工作原理示意
#  build/mid.o 需要 mid.c
#  → 当前目录: mid.c? 不存在
#  → VPATH[0]=module1: module1/mid.c? 找到！
#  → $< 自动变为 module1/mid.c（含完整路径）

$(BUILD_DIR)/$(TARGET): $(OBJS) | $(BUILD_DIR)
#                               ^
#                          order-only 前提

CC = gcc
CFLAGS = -Wall -MMD -MP       # -MMD: 生成 .d 依赖文件；-MP: 为每个头文件生成空规则
BUILD_DIR = build

SRCS = $(wildcard *.c)
OBJS = $(patsubst %.c, $(BUILD_DIR)/%.o, $(SRCS))
DEPS = $(patsubst %.c, $(BUILD_DIR)/%.d, $(SRCS))   # 对应的 .d 文件列表

$(BUILD_DIR)/app: $(OBJS)
	$(CC) -o $@ $^

# -MMD 会自动生成 build/main.d 文件，内容类似：
# build/main.o: main.c header.h common.h

$(BUILD_DIR)/%.o: %.c | $(BUILD_DIR)
	$(CC) $(CFLAGS) -c $< -o $@

$(BUILD_DIR):
	mkdir -p $@

# ★ 关键：引入自动生成的 .d 文件
# -include 表示文件不存在也不报错
-include $(DEPS)

.PHONY: clean
clean:
	rm -rf $(BUILD_DIR)

# build/main.d 的内容（由 gcc -MMD 自动生成）
build/main.o: main.c common.h types.h config.h

# 方案A：配合 shell find 命令
SRCS = $(shell find src -name "*.c")
# 注意：shell 函数在 make 启动时执行，后续新增文件不会被检测到

# 方案B：使用 wildcard 嵌套（需要知道层级深度）
SRCS = $(wildcard src/*.c src/*/*.c src/*/*/*.c)
# 缺点：层级深度固定，不够灵活

# 方案C：递归 wildcard 函数（推荐，纯 Makefile 实现）
rwildcard = $(foreach d, $(wildcard $(1:=/*)), \
              $(call rwildcard, $d, $(2)) $(filter $(2), $d))
# 用法
SRCS = $(call rwildcard, src, *.c)

第1层: 扫描 src/* → 得到 src/core, src/net
      对每个子目录递归: rwildcard src/core *.c
第2层: 扫描 src/core/* → 得到 src/core/main.c, src/core/io
      src/core/main.c 匹配 *.c → 收集
      对 io 递归: rwildcard src/core/io *.c
第3层: 扫描 src/core/io/* → 得到 src/core/io/serial.c
      匹配 *.c → 收集
最终: src/core/main.c src/core/io/serial.c src/net/...

# 交叉编译工具链
CROSS_COMPILE = arm-linux-gnueabihf-
CC = $(CROSS_COMPILE)gcc

# 主机编译器（用于生成主机工具）
HOST_CC = gcc

BUILD_DIR = build
HOST_BUILD_DIR = host_build

# 目标机源码和主机工具源码分开
TARGET_SRCS = $(wildcard src/*.c)
HOST_SRCS = $(wildcard tools/*.c)

# 目标机 .o 文件
TARGET_OBJS = $(patsubst src/%.c, $(BUILD_DIR)/%.o, $(TARGET_SRCS))

# 主机工具 .o 文件
HOST_OBJS = $(patsubst tools/%.c, $(HOST_BUILD_DIR)/%.o, $(HOST_SRCS))

# ★ 主机工具使用主机编译器
$(HOST_BUILD_DIR)/codegen: $(HOST_OBJS) | $(HOST_BUILD_DIR)
	$(HOST_CC) -o $@ $^

# 主机工具 .o 编译规则
$(HOST_BUILD_DIR)/%.o: tools/%.c | $(HOST_BUILD_DIR)
	$(HOST_CC) -c $< -o $@

# 目标机程序使用交叉编译器
$(BUILD_DIR)/app: $(TARGET_OBJS) | $(BUILD_DIR)
	$(CC) -o $@ $^

$(BUILD_DIR)/%.o: src/%.c | $(BUILD_DIR)
	$(CC) -c $< -o $@

# 目标程序依赖 codegen（构建时运行代码生成器）
src/generated.c: $(HOST_BUILD_DIR)/codegen
	$(HOST_BUILD_DIR)/codegen -o $@

$(BUILD_DIR) $(HOST_BUILD_DIR):
	mkdir -p $@

.PHONY: clean
clean:
	rm -rf $(BUILD_DIR) $(HOST_BUILD_DIR)

make: *** No rule to make target 'mid.c', needed by 'build/mid.o'.  Stop.

# 方式A：全局 VPATH
VPATH = $(SRC_DIR)

# 方式B：按模式指定搜索路径（更精确）
vpath %.c $(SRC_DIR)
vpath %.h $(INC_DIR)

# 错误：试图用 subst 做模式替换
OBJS = $(subst %.c, %.o, $(SRCS))
# subst 不支持 % 通配符！它会查找字面量 "%.c"，找不到则原样返回

# 正确：用 patsubst
OBJS = $(patsubst %.c, %.o, $(SRCS))

# 这是一个常见但容易困惑的写法
SRC_DIR = module1 module2
SRCS = $(foreach dir, $(SRC_DIR), $(wildcard $(dir)/*.c))

# 在 foreach 执行时：
# 1. $(dir) 在每次迭代中替换为当前单词（module1, module2）
# 2. $(wildcard module1/*.c) 被执行
# 3. 结果用空格拼接

# 注意：foreach 中的变量（var 参数）不需要用 $() 包裹定义
# 正确: $(foreach dir, ...
# 错误: $($foreach dir, ...

# 问题场景
SRCS = $(wildcard *.c)    # ← wildcard 在这一行执行

# ... 后来用脚本生成了新的 .c 文件

all: $(SRCS)
    # SRCS 还是旧的文件列表，新文件被忽略了！

all:
	@echo $(wildcard *.c)   # 每次 make all 都重新扫描

# 陷阱1：变量末尾的额外空格
SRC_DIR = module1 module2    # 假设这里不小心多了一个空格

# $(foreach dir, $(SRC_DIR), ...) 可能迭代出一个空单词！

# 解决方法：
SRC_DIR = $(strip module1 module2)   # strip 去掉首尾和重复空格

$(foreach dir,$(DIRS),$(wildcard $(dir)/*.c))
#            ^-- 这个逗号是参数分隔符
#                 dir 和 $(DIRS) 之间没有空格也不要紧

# 自动收集多个子目录下的所有 .c 文件
SRCS = $(foreach dir, $(SRC_DIR), $(wildcard $(dir)/*.c))

# 自动生成 .o 目标列表（去掉路径 + 替换后缀 + 加输出目录前缀）
OBJS = $(patsubst %.c, build/%.o, $(notdir $(SRCS)))

CC = gcc
TARGET = app
SRC_DIR = src module1 module2    # 修改为你的源码目录
BUILD_DIR = build

VPATH = $(SRC_DIR)

SRCS = $(foreach dir, $(SRC_DIR), $(wildcard $(dir)/*.c))
OBJS = $(patsubst %.c, $(BUILD_DIR)/%.o, $(notdir $(SRCS)))
DEPS = $(patsubst %.c, $(BUILD_DIR)/%.d, $(notdir $(SRCS)))

CFLAGS = -Wall -MMD -MP $(addprefix -I, $(SRC_DIR))

$(BUILD_DIR)/$(TARGET): $(OBJS) | $(BUILD_DIR)
	$(CC) -o $@ $^

$(BUILD_DIR)/%.o: %.c | $(BUILD_DIR)
	$(CC) $(CFLAGS) -c $< -o $@

$(BUILD_DIR):
	mkdir -p $@

-include $(DEPS)

.PHONY: clean
clean:
	rm -rf $(BUILD_DIR)

# 调试技巧：在 Makefile 中插入这行来查看某个变量的值
$(info DEBUG: SRCS = $(SRCS))
$(info DEBUG: OBJS = $(OBJS))
# 运行 make 时会打印在终端