第33讲：Makefile的变量

make -f MakefileTest

# 创建一个非默认名称的 Makefile
cat > mybuild.mk << 'EOF'
hello:
	@echo "Hello from mybuild.mk"
EOF

# 用 -f 指定它
make -f mybuild.mk hello
# 输出：Hello from mybuild.mk

# 不加 -f 会失败（因为没有 Makefile）
make hello
# 输出：make: *** No rule to make target 'hello'.  Stop.

# 同时也可以指定目标
make -f mybuild.mk clean

# 切换到 subdir 目录，然后找 Makefile 执行
make -C subdir

# 等价于：
cd subdir && make

# 结合 -f 使用：
make -C subdir -f custom.mk target_name

# 测试系统变量
test:
	@echo "CC   = $(CC)"
	@echo "CXX  = $(CXX)"
	@echo "AS   = $(AS)"
	@echo "AR   = $(AR)"
	@echo "MAKE = $(MAKE)"
	@echo "RM   = $(RM)"

make -f MakefileTest test
# 输出：
# CC   = cc
# CXX  = g++
# AS   = as
# AR   = ar
# MAKE = make
# RM   = rm -f

# 使用预置编译选项变量的典型 Makefile 开头
CC      = gcc
CFLAGS  = -Wall -g -O2
LDFLAGS = -L./lib
LDLIBS  = -lm

# 隐含规则自动使用上述变量
# 即使你不写规则，make 也能编译简单的 C 程序

# 临时换成交叉编译器（ARM）
make CC=arm-linux-gnueabihf-gcc

# 开启调试符号
make CFLAGS="-g -O0"

# 多个变量同时覆盖
make CC=clang CFLAGS="-Wall -Wextra"

A = 123    # 延时赋值
B = $(A)   # B 此时不取值，只是记住了 "A" 这个引用
A = 456    # 修改 A

test:
	@echo "B = $(B)"   # 输出：B = 456 （取的是 A 的最新值）

# 深入理解：延时赋值的嵌套行为
BAR = $(FOO)         # BAR 记住了 "FOO" 这个名字
FOO = hello
# 此时 $(BAR) 展开为 "hello"

FOO = world
# 此时 $(BAR) 展开为 "world"   (每次展开都重新取值)

test_nested:
	@echo "FOO = $(FOO)"          # world
	@echo "BAR = $(BAR)"          # world

# 错误示例：自己引用自己
VAR = $(VAR) suffix   # 展开时陷入死循环

test:
	@echo $(VAR)
# 执行结果：make 报错
# Makefile:X: *** Recursive variable 'VAR' references itself (eventually).  Stop.

A = 123    # 延时赋值
B := $(A)  # 立即赋值，此时 B = 123
A = 456    # 修改 A，不影响 B

test:
	@echo "B = $(B)"   # 输出：B = 123 （定义时已固定）

# 使用 := 获取当前目录（只执行一次）
CUR_DIR := $(shell pwd)

# 如果用 = ，每次引用都会执行 pwd 命令
# BAD_DIR = $(shell pwd)   # 每次展开都执行 shell，浪费性能

show_dir:
	@echo "Current dir: $(CUR_DIR)"

# 另一个典型场景：获取 git 版本号
GIT_HASH := $(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")

build:
	@echo "Building version: $(GIT_HASH)"

# = 可以引用后面定义的变量
MAIN_DEPS = main.o $(EXTRA_DEPS)   # 允许 EXTRA_DEPS 在后面定义
EXTRA_DEPS = math.o utils.o
# $(MAIN_DEPS) 展开为 "main.o math.o utils.o"

# := 不能引用后面定义的变量（展开时还不存在）
MAIN_DEPS2 := main.o $(EXTRA_DEPS)   # EXTRA_DEPS 此时为空
EXTRA_DEPS = math.o utils.o
# $(MAIN_DEPS2) 展开为 "main.o"（丢失了 math.o utils.o）

A ?= 123   # A 为空，赋值成功
A ?= 456   # A 已存在，赋值无效

test:
	@echo "A = $(A)"   # 输出：A = 123

# 用户不指定 CC，Makefile 里 CC ?= gcc 生效 → 用 gcc
make

# 用户指定了 CC，Makefile 里 CC ?= gcc 不生效 → 用 clang
make CC=clang

# 典型用法：给编译选项设置默认值，但允许外部覆盖
CC      ?= gcc
CFLAGS  ?= -Wall -O2
PREFIX  ?= /usr/local

# 这样用户可以通过以下方式定制：
# make CC=arm-linux-gnueabihf-gcc PREFIX=/opt/myapp

A = 123
A += 456   # 追加

test:
	@echo "A = $(A)"   # 输出：A = 123 456

# 情况1：基础是 =  → 追加后保持延时特性
A = hello
A += world
# A 仍然是延时展开

# 情况2：基础是 := → 追加后保持立即特性
B := hello
B += world
# B 仍然是立即展开

# 情况3：从未定义 → += 视为 =
C += hello   # 等价于 C = hello

# 构建 CFLAGS：逐步添加选项
CFLAGS  = -Wall
CFLAGS += -g
CFLAGS += -O2
CFLAGS += -I./include
# 最终 CFLAGS = -Wall -g -O2 -I./include

# 构建对象文件列表
OBJS  = main.o
OBJS += sub.o
OBJS += math.o
OBJS += utils.o
# 最终 OBJS = main.o sub.o math.o utils.o

build:
	gcc $(CFLAGS) -o app $(OBJS)

# 编译 .c → .o 时，.c 文件就是第一个依赖
%.o: %.c
	gcc -c $< -o $@
# 等价于：gcc -c foo.c -o foo.o （第一个依赖 = foo.c）

# 多依赖场景：$< 只取第一个
app: main.o lib.o util.o
	gcc -o $@ $^       # 全部依赖
	@echo "First dep: $<"   # 只输出 main.o

# $^ 包含所有依赖，自动去除重复项
app: main.o math.o main.o   # main.o 出现两次
	gcc -o $@ $^
# 等价于：gcc -o app main.o math.o   (自动去重)

# $@ 在命令行中代表当前规则的目标
app: main.o
	gcc -o $@ $^
# 等价于：gcc -o app main.o

# 多个目标的规则中，$@ 分别代表每个目标
all: target_a target_b target_c
	echo "Building $@..."
# 这不是你想象的行为——make 只为 all 构建依赖，$@ 始终是 all

# 只重新编译"变化了"的文件
libmylib.a: a.o b.o c.o
	ar r $@ $?   # 只更新那些比 libmylib.a 新的 .o 文件

# 模式规则中 % 匹配的部分
%.o: %.c
	gcc -c $< -o $@
# 当用于 foo.o 时：$* = foo, $@ = foo.o, $< = foo.c

# $(@D) 和 $(@F) 的实际应用
# 目标文件在子目录中
build/subdir/app.bin: src/main.c
	mkdir -p $(@D)              # 创建 build/subdir 目录
	gcc -o $@ $<

# 综合展示所有常用自动变量
CC      = gcc
CFLAGS  = -Wall
TARGET  = app
OBJS    = main.o sub.o math.o

$(TARGET): $(OBJS)
	@echo "目标:        $@"       # app
	@echo "所有依赖:    $^"       # main.o sub.o math.o
	@echo "第一个依赖:  $<"       # main.o
	@echo "变化的依赖:  $?"       # 变化的那些 .o 文件
	@echo "目标目录:    $(@D)"    # .
	@echo "目标文件名:  $(@F)"    # app
	$(CC) -o $@ $^

%.o: %.c
	@echo "编译: $< → $@  (主干: $*)"
	$(CC) $(CFLAGS) -c $< -o $@

.PHONY: clean
clean:
	rm -f $(TARGET) $(OBJS)

$<  →  左尖括号  →  第一个（它在最左边）
$^  →  上尖括号  →  所有（它盖住上面全部）
$@  →  at 符号   →  目标（@某人 = 指定目标）
$?  →  问号      →  哪些变了？
$*  →  星号      →  通配符匹配的主干

app3: main.o sub.o
	gcc -o app3 main.o sub.o

main.o: main.c
	gcc -c main.c -o main.o

sub.o: sub.c
	gcc -c sub.c -o sub.o

.PHONY: clean
clean:
	rm -f app3 main.o sub.o

CC = gcc
TARGET = app3
OBJS = main.o sub.o

$(TARGET): $(OBJS)
	$(CC) -o $@ $^

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

.PHONY: clean
clean:
	rm -f $(TARGET) $(OBJS)

# 编译器与选项
CC      = gcc
CFLAGS  = -Wall -g -O2
LDFLAGS =
LDLIBS  =

# 目标与源文件
TARGET  = app3
SRCS   := $(wildcard *.c)        # 自动发现所有 .c 文件
OBJS   := $(SRCS:.c=.o)          # 对应替换为 .o 列表

# 链接
$(TARGET): $(OBJS)
	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS)

# 编译（模式规则）
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

# 生成依赖关系
depend:
	$(CC) -MM $(SRCS) > .depend

-include .depend

.PHONY: clean
clean:
	rm -f $(TARGET) $(OBJS)

# ===== 项目配置 =====
TARGET   = app
BUILD_DIR = build

# ===== 编译器与选项 =====
CC       = gcc
CFLAGS   = -Wall -g -O2 -I./include
LDFLAGS  =
LDLIBS   = -lm

# ===== 源文件自动发现 =====
SRCS    := $(wildcard src/*.c)
OBJS    := $(patsubst src/%.c, $(BUILD_DIR)/%.o, $(SRCS))

# ===== 构建规则 =====
$(TARGET): $(OBJS)
	@echo "Linking $@..."
	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS)
	@echo "Build complete: $(TARGET)"

$(BUILD_DIR)/%.o: src/%.c
	@mkdir -p $(@D)
	$(CC) $(CFLAGS) -c $< -o $@

# ===== 工具规则 =====
.PHONY: clean distclean
clean:
	rm -rf $(BUILD_DIR) $(TARGET)

distclean: clean
	rm -f .depend

# 两种写法等价
VAR = hello
result1 = $(VAR)    # 推荐：不容易与 shell 变量混淆
result2 = ${VAR}    # 也可以用

# 嵌套引用需要加 $$ 转义
# 单 $ 会被 make 解释，双 $$ 传递一个 $ 给 shell
show:
	@echo "shell PID: $$(pidof make)"   # $$ 传递 $ 给 shell

# 普通赋值可能被覆盖
CFLAGS = -Wall

# 加上 override 后，命令行无法覆盖
override CFLAGS += -DDEBUG   # 无论命令行传什么，都会追加 -DDEBUG

# 也可以直接覆盖：
override CC = gcc

# 即使命令行指定，override 的值仍会追加
make CFLAGS="-O2"
# 最终 CFLAGS = -O2 -DDEBUG   (override 追加的部分保留了)

# 全局编译选项
CFLAGS = -Wall -O2

# debug 目标的专属编译选项
debug: CFLAGS = -Wall -g -O0   # 仅在 debug 及其依赖中覆盖
debug: app

# release 目标的专属编译选项
release: CFLAGS = -Wall -O3 -DNDEBUG
release: app

app: main.o sub.o
	gcc $(CFLAGS) -o $@ $^

# make debug  → CFLAGS = -Wall -g -O0
# make release → CFLAGS = -Wall -O3 -DNDEBUG

# 更复杂的示例：不同子目录用不同的包含路径
CFLAGS = -Wall

# tool/ 下的文件编译时自动添加 -Itool/include
tool/%.o: CFLAGS += -Itool/include

# test/ 下的文件编译时自动添加 -Itest/include
test/%.o: CFLAGS += -Itest/include

# 导出单个变量
export CC
export CFLAGS = -Wall

# 导出所有变量（谨慎使用）
export

# 不导出（逆向操作）
unexport SECRET_VAR

# 子目录构建时自动继承导出的变量
submodule:
	$(MAKE) -C subdir

# 模式1：用 ?= 设置默认值
PREFIX ?= /usr/local

# 模式2：手动检查 origin 函数
ifeq ($(origin CC), undefined)
    CC = gcc
endif
# origin 函数能区分：未定义 / 环境变量 / Makefile / 命令行 / override

# 模式3：允许命令行覆盖，但 Makefile 提供默认
ifeq ($(origin CC), default)
    CC = gcc   # 当 CC 是默认值（来自内置规则）时覆盖
endif

# 调试：查看所有已定义的变量
list_vars:
	@echo $(.VARIABLES)

# 查看当前目标
debug_goals:
	@echo "Goals: $(MAKECMDGOALS)"

# 错误写法
VAR = $(VAR) suffix    # 展开时死循环

# 正确写法（用 := 或 +=）
VAR := suffix          # 直接赋值
VAR += more            # 追加

# 注意：等号后面的空格会被保留！
DIR = /usr/local/      # 末尾无空格 ✓
DIR = /usr/local/      # 末尾有空格（看不见但存在）⚠

# 在依赖路径中会出错
# $(DIR)/bin  →  /usr/local/ /bin  （多了一个空格）

# Makefile 变量用 $() 展开
NAME = world
hello:
	echo $(NAME)           # make 展开 → echo world ✓

# shell 变量在 Makefile 中需要 $$ 转义
list:
	for f in *.c; do \
		echo "file: $$f"; \    # $$f 传递给 shell 变成 $f
	done

# 错误示例：单 $ 被 make 当成自己的变量
list_bad:
	for f in *.c; do echo $f; done   # $f 被 make 解释，出错

# 技巧1：打印变量值
debug:
	@echo "CC      = [$(CC)]"
	@echo "CFLAGS  = [$(CFLAGS)]"
	@echo "OBJS    = [$(OBJS)]"

# 技巧2：查看变量来源（origin 函数）
debug_origin:
	@echo "CC origin: $(origin CC)"
	# 输出可能是：default / environment / file / command line / override / automatic / undefined

# 技巧3：查看变量内容（flavor 函数）
debug_flavor:
	@echo "CFLAGS flavor: $(flavor CFLAGS)"
	# 输出：simple (= 立即) 或 recursive (= 延时)

# 技巧4：make -p 打印所有规则和变量
# 在命令行执行：
# make -p -f /dev/null    → 查看内置规则和变量
# make -p                 → 查看当前 Makefile 的所有规则和变量

# 技巧5：make -n 只打印命令不执行（dry run）
# make -n    → 预览将要执行的命令