Zein

# 伪目标
PHONY := __build
__build:             #空操作
 
# 清空需要的变量
obj-y :=            #需要编译的目标文件列表
subdir-y :=          #子目录列表
EXTRA_CFLAGS :=      #额外编译选项
 
# 包含同级目录Makefile
include Makefile
 
# 获取当前 Makefile 需要编译的子目录的目录名
# obj-y := a.o b.o c/ d/
# $(filter %/, $(obj-y))   : c/ d/
# __subdir-y  : c d
# subdir-y    : c d
__subdir-y  := $(patsubst %/,%,$(filter %/, $(obj-y)))
subdir-y  += $(__subdir-y)
 
# 生成各子目录的目标文件列表：要编译的子目录下目标文件都打包成了dir/built-in.o
subdir_objs := $(foreach f,$(subdir-y),$(f)/built-in.o)
 
# 过滤 obj-y，得到当前目录下需要编进程序的文件名作为，并写为目标
# a.o b.o
cur_objs := $(filter-out %/, $(obj-y))
# 使修改头文件 .h 后，重新make后可以重新编译（重要）
dep_files := $(foreach f,$(cur_objs),.$(f).d)
# 包含所有依赖文件
dep_files := $(wildcard $(dep_files))
ifneq ($(dep_files),)        #不为空（即存在依赖文件），则执行下一步操
  include $(dep_files)  #Make 工具会读取这些依赖文件，从而确保 Makefile 知道源文件与头文件之间的正确依赖关系，当头文件修改后可以重新编译受影响的源文件
endif


PHONY += $(subdir-y)
# 第一个目标
__build : $(subdir-y) built-in.o
# 优先编译 子目录的内容;-C切换到子目录执行$(TOPDIR)/Makefile.build
$(subdir-y):
  make -C $@ -f $(TOPDIR)/Makefile.build 
 
# 把subdir的built-in.o和cur_objs链接成 总的built-in.o目标
built-in.o : $(cur_objs) $(subdir_objs)
  $(LD) -r -o $@ $^

dep_file = [email protected]
 
# 生成 cur_objs 目标
%.o : %.c
  $(CC) $(CFLAGS) $(EXTRA_CFLAGS) $(CFLAGS_$@) -Wp,-MD,$(dep_file) -c -o $@ $<
  
.PHONY : $(PHONY)

# 可以不添加下面两个变量
EXTRA_CFLAGS  := 
CFLAGS_view.o := 

obj-y += $(patsubst %.c,%.o,$(shell ls *.c))
# obj-y += subdir/

make -f custom.mk       #指定入口makefile文件

make -s           #静默执行command

-------------------让上一条命令的结果应用在下一条命令时，用分号分隔这两条命令。分行写，则前一命令的效果不会保留
.RECIPEPREFIX = >
exec:
>  cd /home/hchen; pwd
# 打印 /home/hchen

.RECIPEPREFIX = >
exec:
>  cd /home/hchen
>  pwd
# 打印 /home

————————忽略错误，不终止 make 的执行
clean:
    -rm -f *.o           #command前加减号

.IGNORE: clean           #特殊目标.IGNORE指定clean规则忽略错误，不终止 make 的执行
clean:
    rm -f *.o

make -i                  #用 -i 或 --ignore-errors 参数选项
make --ignore-errors

————————只跳过当前失败的规则，继续执行其它规则，不会终止 make 执行
make -k
make --keep-going

make -p                # 输出所有的规则和变量。
make -n                # 打印将要执行的规则和命令，但不执行
make --debug=verbose   #
make -t                # 相当于UNIX touch，把目标的修改日期变成最新的，相当于假编译，只是把目标变成已编译状态
make -q                # 检查target是否存在，返回码指示结果（0=需更新，2=错误）。
make -W <file>         # 一般指定源文件（或依赖文件），Make根据规则推导运行依赖于这个文件的命令，一般和-n一同使用查看此文件所发生的规则命令

target: prerequisites; command; command
    command
    command

.RECIPEPREFIX = >
#如果当前 make 在最外层执行（MAKELEVEL= 0）；定义一些与系统相关的变量，
ifeq (0,${MAKELEVEL})
    cur-dir   := $(shell pwd)
    whoami    := $(shell whoami)  #当前用户
    host-type := $(shell arch)    #架构
    MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}
endif

.PHONY: all subsystem

all: subsystem   #all依赖于subsystem 

subsystem:
>  $(MAKE) -C subdir MAKEFLAGS= VAR=value     # -C subdir 表示在指定目录中执行 make
#或>  cd subdir && $(MAKE)

.PHONY: all

all:
    echo "Received VAR = $(VAR)"

make: Entering directory `subdir'
Received VAR = value
make: Leaving directory `subdir'

define <命令包名>
<command1>
<command2>
...
endef

-------eg
.RECIPEPREFIX = >

define run-yacc
yacc $(firstword $^)    # $(firstword $^) 会获取 $^ 中的第一个依赖文件。
mv y.tab.c $@           # 将生成的 y.tab.c 文件重命名为 foo.c
endef

foo.c : foo.y
>  $(run-yacc)

#使命令前缀变为 >，而不是默认的制表符（tab）
.RECIPEPREFIX = >
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: main.c defs.h
    cc -c main.c
kbd.o: kbd.c defs.h command.h
    cc -c kbd.c
# 其他 .o 文件的规则...

.RECIPEPREFIX = >
bigoutput littleoutput: text.g
>  generate text.g -$(subst output,,$@) > $@              # 参数替换：$(subst output,,$@) 表示替换 $@ 中的 output 为空字符串

#等价于上
.RECIPEPREFIX = >
bigoutput: text.g
>  generate text.g -big > bigoutput

littleoutput: text.g
>  generate text.g -little > littleoutput

-------------------------------------静态模式规则
.RECIPEPREFIX = >
<targets ...> : <target-pattern> : <prereq-patterns ...>
>  <commands>

#eg
.RECIPEPREFIX = >
objects = foo.o bar.o

all: $(objects)

$(objects): %.o: %.c                    #匹配 %.o格式 的目标文件，由$@逐个取出；匹配目标集的 依赖集文件格式为%.c ，由$< 逐个取出
>  $(CC) -c $(CFLAGS) $< -o $@

#等同于上
foo.o: foo.c
>  $(CC) -c $(CFLAGS) foo.c -o foo.o

bar.o: bar.c
>  $(CC) -c $(CFLAGS) bar.c -o bar.o

# Makefile
all:
    echo $(CFLAGS)      #传递进来了-O2 -Wall
    echo $(CC)

export                       # 传递所有变量
export variable += value;    # 传递变量variable到下级Makefile
unexport variable := value;  #不想让变量variable传递到下级Makefile

-----------------=  递归赋值：以递归的方式展开依赖的变量值；这种赋值方法灵活，可推迟变量的定义,缺点是可以写出无限递归赋值，而且每次依赖的变量重新赋值都要重新计算
all:
    echo $(foo)
    
foo = $(bar)
bar = $(ugh)
ugh = Huh?

-----------------:=  立即赋值：在赋值时展开右侧表达式，并将结果存储到变量中，比递归赋值性能更高。更安全
x := foo
y := $(x) bar    # foo bar；由于立即展开了，下面一句不影响y的值
x := later

-----------------?=  条件赋值：只有未定义变量，赋值才生效；已定义变量则什么也不做，而非覆盖原定义
FOO ?= bar

-----------------# 不仅能用来注释，还可用来标示变量定义的结束位置
dir := /foo/bar    # directory to put the frobs in

-----------------+=  追加变量值,原变量用 := 定义，则 +=为立即赋值;变量用 = 定义，则 +=为递归赋值
objects = main.o foo.o bar.o utils.o
objects += another.o             #相当于objects = $(objects) another.o

-----------------指定makefile中定义的某些变量有最高优先级，不会被make选项传入的命令行变量覆写
override <variable> := <value>
override <variable> += <more text>
override <variable> = <value>

-----------------多行变量定义：跟命令包一样
define <variable>
<value>
endef

-----------------简单替换
${var:a=b}   #将变量 var 中以 a 结尾的部分替换为 b

foo := a.o b.o c.o
bar := $(foo:.o=.c) 

-----------------模式替换
$(var:%.suffix1=%.suffix2)   # 将变量var中 %.suffix1 替换为 %.suffix2

foo := a.o b.o c.o
bar := $(foo:%.o=%.c)

-----------------------------------------变量表达式只对特定目标<target>及其依赖有效
<target> : <variable-assignment>              # 变量表达式只对特定目标<target>及其依赖有效
<target> : override <variable-assignment>
#eg:不论全局 CFLAGS 的值是什么，prog 目标及其相关的目标（prog.o、foo.o、bar.o）会使用 CFLAGS = -g
prog : CFLAGS = -g
prog : prog.o foo.o bar.o
    $(CC) $(CFLAGS) prog.o foo.o bar.o

prog.o : prog.c
    $(CC) $(CFLAGS) prog.c

foo.o : foo.c
    $(CC) $(CFLAGS) foo.c

bar.o : bar.c
    $(CC) $(CFLAGS) bar.c

---------------------------变量表达式只对特定格式目标有效
<pattern ...>; : <variable-assignment>;
<pattern ...>; : override <variable-assignment>;
%.o : CFLAGS = -O2           #变量表达式只对.o结尾的目标有效

dir = foo
$(dir)_sources := $(wildcard $(dir)/*.c)        #$(dir)_sources定义为$(dir)目录下所有c文件
define $(dir)_print                             #甚至是动态定义命令包
lpr $($(dir)_sources)                           #打印$(dir)_sources的值
endef

-----------------定义包含空格的变量
nullstring :=
space := $(nullstring)

VPATH = src:../headers       # 现在当前目录下寻找。再去src，以及../headers找

vpath <pattern> <directories>
vpath %.h ../headers     #当前目录没找到时；在../headers"目录下搜索所有以 .h 结尾的文件；..上级目录
vpath %.c foo            #.c 文件，按"foo""blish""bar"目录顺序搜索
vpath %   blish
vpath %.c bar

objects := $(wildcard *.o)                        # 展开通配符*.o通配符,列出所有 .o 文件

$(patsubst %.c,%.o,$(wildcard *.c))               # 将%.c字符串替换为%.o字符串，列出所有.c文件对应的 .o 文件

objects := $(patsubst %.c,%.o,$(wildcard *.c))    # 编译并链接所有 .c 和 .o 文件
foo : $(objects)
>  cc -o foo $(objects)

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

edit: $(objects)
    cc -o edit $(objects)

# 自动推导规则，make 会推导出这些规则
main.o: defs.h
kbd.o: defs.h command.h
command.o: defs.h command.h
# 其他规则...

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

edit: $(objects)
    cc -o edit $(objects)

# 将多个文件的依赖合并
$(objects): defs.h
kbd.o command.o files.o: command.h
display.o insert.o search.o files.o: buffer.h

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

#eg:用Pattern Rules重载内建隐含的.c构建.o规则
%.o : %.c
    $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@

%.o : %.s    #取消内建的隐含规则，只要不在后面写命令就行

-include other.make *.mk $(othermake)         #可以是文件名，也可用通配符

sinclude other.make *.mk $(othermake)         #同上

.RECIPEPREFIX = >
.PHONY: cleanall cleanobj cleandiff

cleanall: cleanobj cleandiff
>  rm -f program

cleanobj:
>  rm -f *.o

cleandiff:
>  rm -f *.diff

.RECIPEPREFIX = >

sources = foo.c bar.c

%.d: %.c
>  @set -e; rm -f $@; \                                     # @set -e 设置脚本一旦遇到错误（命令返回值非零）立即退出；rm -f $@删除已存在的中间文件
    $(CC) -M $(CPPFLAGS) $< > $@.$$$$; \                    # 由%.c逐个构建依赖关系，重定向到一个临时文件$@.$$$$，相当于%.d.$$$$
    sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \   # < $@.$$$$表示从文件 %.d.$$$$ 中读取输入；替换后的内容输出到%.d；这一步是为子.d自动更新
    rm -f $@.$$$$
    
include $(sources:.c=.d)            #  把变量 $(sources) 所有 .c 的字串都替换成 .d；然后把依赖关系include进来

.INTERMEDIATE: mid         #显式声明mid文件是中间目标。make不会把它当最终目标处理,当生成mid文件后不会被自动删除
.SECONDARY: sec            #sec 文件是一个中间目标，但 make 不会在生成最终目标后删除它
.PRECIOUS: %.o             #告诉 make 保留所有 .o 文件，即使它们是中间目标

<conditional-directive>
<text-if-true>             #
else
<text-if-false>
endif

-----------------ifeq 和 ifneq
.RECIPEPREFIX = >
foo = bar

ifeq ($(foo),bar)
>  echo "foo is bar"
endif

ifneq ($(foo),baz)
>  echo "foo is not baz"
endif

-----------------ifdef 和 ifndef
.RECIPEPREFIX = >
foo = bar

ifdef foo
>  echo "foo is defined"
else
>  echo "foo is not defined"
endif

$(<function> <arguments>)
${<function> <arguments>}

#<function> 是函数名;<arguments> 是参数，用逗号分隔;函数名和参数之间用空格隔开

$(subst <from>,<to>,<text>)   # 字符串替换:把字符串<text>中的<from>替换为<to>；并返回
#eg: $(subst ee,EE,feet on the street) 

$(patsubst <pattern>,<replacement>,<text>)   # 字符串替换：把字符串<text>中的<pattern>替换为<replacement>；并返回
#eg: $(patsubst %.c,%.o,x.c.c bar.c) 

$(strip <string>)   # 去掉字符串开头和结尾的空格
#eg: $(strip  a b c  ) 

$(findstring <sub_text>,<text>)   # 在字符串<text>中查找子串<sub_text>
#eg: $(findstring a,a b c) # 返回值：a

$(filter <pattern...>,<text>)   # 过滤出<text>中符合格式 <pattern...>的部分
#eg: $(filter %.c %.s,bar.c baz.s ugh.h) 

$(filter-out <pattern...>,<text>)   # 过滤出<text>中不符合格式 <pattern...>的部分
#eg: $(filter-out main1.o main2.o,main1.o foo.o main2.o) 

$(sort <list>)   # 排序并去重
#eg: $(sort foo bar lose foo) 

$(word <n>,<text>)   # 提取<text>中第n个单词
#eg: $(word 2,foo bar baz)  #取出了bar

$(wordlist <start>,<end>,<text>)   # 提取单词范围
#eg: $(wordlist 2,3,foo bar baz)  # 返回值：bar baz

$(words <text>)   # 统计单词数
#eg: $(words foo bar baz)    # 返回值：3

$(firstword <text>)   #  获取第一个单词
#eg: $(firstword foo bar) 

$(dir <path...>)            #提取目录部分
#eg: $(dir src/foo.c hacks) # 返回值：src/ ./

$(notdir <path...>)      #提取非目录部分
#eg: $(notdir src/foo.c hacks)      # 返回值：foo.c hacks

$(suffix <names...>)      # 提取文件后缀
#eg: $(suffix src/foo.c src-1.0/bar.c hacks) # 返回值：.c .c

$(basename <names...>)      # 提取文件名前缀
#eg: $(basename src/foo.c src-1.0/bar.c hacks)    # 返回值：src/foo src-1.0/bar hacks

$(addsuffix <suffix>,<names...>)      # 给<names...>中的文件添加后缀<suffix>
#eg: $(addsuffix .c,foo bar)          # 返回值：foo.c bar.c

$(addprefix <prefix>,<names...>)      #添加前缀
#eg: $(addprefix src/,foo bar)        # 返回值：src/foo src/bar

$(join <list1>,<list2>)      #连接两个列表
#eg: $(join aaa bbb,111 222 333)     # 返回值：aaa111 bbb222 333

$(foreach <var>,<list>,<text>)            # 循环处理列表:从<list>依次取出单词赋值给<var>，然后用表达式<text>进行计算，最终返回由每次计算结果用空格连起来的字符串
#eg: files := $(foreach n,a b c d,$(n).o)     # 返回值：a.o b.o c.o d.o

$(if <condition>,<then-part>,<else-part>)      #条件判断  
#eg: $(if 1,yes,no)     #yes

$(call <expression>,<parm1>,<parm2>,...)      #自定义函数调用:用占位符 $(1)、$(2) 等表示参数,传递到<expression>计算并返回
#eg: 
reverse = $(2) $(1)
foo = $(call reverse,a,b) 
# 返回值：b a

$(origin <variable>)      #检查变量来源
#返回值：
undefined：    未定义
default：      默认定义
environment：  环境变量
file：         Makefile 定义
command line： 命令行定义
override：     override定义
automatic：    自动变量

$(shell <command>)      #执行Shell命令
#eg: files := $(shell echo *.c) 

$(error <text...>)      #终止 make 的执行，并显示指定的错误消息
#eg: 检查变量是否为空
MY_VAR :=

ifeq ($(MY_VAR),)
$(error MY_VAR is not defined or is empty)
endif

$(warning <text...>)      #输出警告，但不会中断构建过程
#eg: 输出调试信息
MY_VAR :=

ifeq ($(MY_VAR),)
$(warning MY_VAR is not defined or is empty)
endif

#eg:将所有的 .o 文件打包成 foolib 函数库
foolib(*.o) : *.o
    ar cr foolib *.o

<PROJECT_NAME >/
├── build/          # 存放编译生成的目标文件、依赖文件等
├── bin/            # 存放最终生成的可执行文件
├── inc/            # 存放头文件
├── lib/            # 存放库文件
├── src/            # 存放源代码文件 (.c)
├── tests/          # 存放测试代码
├── submodule1/     # 第一个子模块
│   └── Makefile    # 子模块的 Makefile
├── submodule2/     # 第二个子模块
│   └── Makefile    # 子模块的 Makefile
├── Makefile        # 顶层 Makefile
└── <其他文件>      # 可能包括其他文档、配置文件等

.RECIPEPREFIX = >
# -------------------------------
# General settings
# -------------------------------
PROJECT_NAME := 
VERSION := 1.0.0

INC_DIR := inc
SRC_DIR := src
LIB_DIR := lib
BIN_DIR := bin
TEST_DIR := tests
BUILD_DIR := build
SUBMODULES := submodule1 submodule2
INSTALL_DIR := /usr/local/bin
TAR_FILE := $(PROJECT_NAME)-$(VERSION).tar.gz

# -------------------------------
# Compiler and flags
# -------------------------------
CC := cc
CXX := g++
AR := ar
AS := as
CO := co
CPP := $(CC) -E
LEX := lex
YACC := yacc
MAKEINFO := makeinfo
      
CFLAGS := -Wall -Wextra -Og
LIBS := 
ARFLAGS := rv
ASFLAGS := 
CXXFLAGS := 
COFLAGS := 
CPPFLAGS := 
LDFLAGS := 
LFLAGS := 
YFLAGS :=

# -------------------------------
# 非独立构建加载子模块Makefile（即把子模块当静态库和源代码用）；各模块独立构建则不需要
# -------------------------------
#-include $(foreach submodule, $(SUBMODULES), $(submodule)/Makefile)

# -------------------------------
# top level Files
# -------------------------------
SRCS := $(shell find $(SRC_DIR) -name '*.c')
OBJS := $(patsubst $(SRC_DIR)/%.c, $(BUILD_DIR)/%.o, $(SRCS))
DEPS := $(OBJS:.o=.d)

# -------------------------------
# Targets
# -------------------------------
.PHONY: all clean install print tar dist TAGS test $(SUBMODULES) #还应该加个检查是否安装相关工具的目标

all: $(PROJECT_NAME)

# Build the main target executable
$(PROJECT_NAME): $(OBJS) $(SUBMODULES)
> $(CC) $(OBJS) -o $(BIN_DIR)/$@ $(LDFLAGS) $(LIBS)

# 构建子模块:遍历子模块，进入其中执行make；如果找不到makefile，就打印skip
$(SUBMODULES):
> @$(foreach submodule, $(SUBMODULES), \
    $(MAKE) -C $(submodule) || echo "Skipping $(submodule)";)

# Automatically generate dependency files
-include $(DEPS)

# Clean target: remove build artifacts
clean:
> rm -rf $(BUILD_DIR) $(BIN_DIR) $(LIB_DIR) $(TAR_FILE)
> $(foreach submodule, $(SUBMODULES), $(MAKE) -C $(submodule) clean || echo "Skipping $(submodule)";)

# Install target: install the program
install: all
> install -m 755 $(BIN_DIR)/$(PROJECT_NAME) $(INSTALL_DIR)

# Print target: list modified source files
print:
> @echo "Modified source files since last build:"
> @find $(SRC_DIR) -type f -newer $(BIN_DIR)/$(PROJECT_NAME) -print || echo "No modified source files."

# Tarball target: create a source tarball
tar:
> tar -cvzf $(TAR_FILE) $(SRC_DIR) $(INC_DIR) $(LIB_DIR) Makefile $(SUBMODULES)

# Dist target: compress the tarball
dist: tar
> gzip $(TAR_FILE)

# TAGS target: generate ctags or etags
TAGS:
> ctags -R $(SRC_DIR) $(INC_DIR) $(SUBMODULES)

# Test target: run unit tests (assuming a separate test suite)
test:
> @echo "Running tests..."
> $(MAKE) -C $(TEST_DIR)

# -------------------------------
# Compilation rules
# -------------------------------
# Rule to create object files，这里妙在.c.h更新，则.o更新；.o更新引用这条规则，.d也更新
$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c
> @mkdir -p $(@D)
> $(CC) $(CFLAGS) -MD -MP -c $< -o $@

# Include all dependency files
-include $(DEPS)

.RECIPEPREFIX = >

# 子模块配置
MODULE_NAME := submodule1
SRC_DIR := src
INC_DIR := inc
BUILD_DIR := build
LIB_DIR := ../lib

CC := cc
CFLAGS := -Wall -Wextra -Og -I$(INC_DIR)
AR := ar
ARFLAGS := rv

SRCS := $(shell find $(SRC_DIR) -name '*.c')
OBJS := $(patsubst $(SRC_DIR)/%.c, $(BUILD_DIR)/%.o, $(SRCS))
LIB := $(LIB_DIR)/lib$(MODULE_NAME).a
DEPS := $(OBJS:.o=.d)

.PHONY: all clean

# 默认目标
all: $(LIB)

# 生成静态库
$(LIB): $(OBJS)
> @mkdir -p $(LIB_DIR)
> $(AR) $(ARFLAGS) $@ $^

# 编译规则
$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c
> @mkdir -p $(@D)
> $(CC) $(CFLAGS) -MMD -MP -c $< -o $@

# 清理规则
clean:
> rm -rf $(BUILD_DIR) $(LIB)

# 自动包含依赖文件
-include $(DEPS)