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)