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)

# 以下の2つの変数を追加する必要はありません
EXTRA_CFLAGS  := 
CFLAGS_view.o := 

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

make -f custom.mk       #エントリーメイクファイルを指定する

make -s           #コマンドをサイレント実行

-------------------前のコマンドの結果を次のコマンドに適用するには、これらの2つのコマンドをセミコロンで区切ります。改行して書くと、前のコマンドの効果は保持されません
.RECIPEPREFIX = >
exec:
>  cd /home/hchen; pwd
# /home/hchenを印刷

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

————————エラーを無視し、makeの実行を中止しない
clean:
    -rm -f *.o           #コマンドの前にマイナスを追加

.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

-------例
.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>

#例
.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    # frobsを置くディレクトリ

-----------------+=  変数値を追加します。元の変数が:=で定義されている場合、+=は即時代入となります；変数が=で定義されている場合、+=は再帰的代入となります
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>
#例：全体の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)

#例：パターンルールを使用して組み込みの.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に置き換え、その依存関係を含めます

.INTERMEDIATE: mid         #midファイルを中間ターゲットとして明示的に宣言します。makeはそれを最終ターゲットとして処理しません。midファイルが生成された後、自動的に削除されません
.SECONDARY: sec            #secファイルは中間ターゲットですが、makeは最終ターゲットが生成された後に削除しません
.PRECIOUS: %.o             # すべての.oファイルを保持するようにmakeに指示します。中間ターゲットであっても

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

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

ifeq ($(foo),bar)
>  echo "fooはbarです"
endif

ifneq ($(foo),baz)
>  echo "fooはbazではありません"
endif

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

ifdef foo
>  echo "fooは定義されています"
else
>  echo "fooは定義されていません"
endif

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

#<function>は関数名；<arguments>は引数で、カンマで区切ります；関数名と引数の間は空白で区切ります

$(subst <from>,<to>,<text>)   # 文字列置換：文字列<text>の中の<from>を<to>に置き換えます；戻り値を返します
#例： $(subst ee,EE,feet on the street) 

$(patsubst <pattern>,<replacement>,<text>)   # 文字列置換：文字列<text>の中の<pattern>を<replacement>に置き換えます；戻り値を返します
#例： $(patsubst %.c,%.o,x.c.c bar.c) 

$(strip <string>)   # 文字列の先頭と末尾の空白を削除します
#例： $(strip  a b c  ) 

$(findstring <sub_text>,<text>)   # 文字列<text>の中で部分文字列<sub_text>を探します
#例： $(findstring a,a b c) # 戻り値：a

$(filter <pattern...>,<text>)   # <text>の中から<pattern...>に一致する部分をフィルタリングします
#例： $(filter %.c %.s,bar.c baz.s ugh.h) 

$(filter-out <pattern...>,<text>)   # <text>の中から<pattern...>に一致しない部分をフィルタリングします
#例： $(filter-out main1.o main2.o,main1.o foo.o main2.o) 

$(sort <list>)   # ソートして重複を削除します
#例： $(sort foo bar lose foo) 

$(word <n>,<text>)   # <text>の中から第n単語を抽出します
#例： $(word 2,foo bar baz)  # barを取得しました

$(wordlist <start>,<end>,<text>)   # 単語範囲を抽出します
#例： $(wordlist 2,3,foo bar baz)  # 戻り値：bar baz

$(words <text>)   # 単語数をカウントします
#例： $(words foo bar baz)    # 戻り値：3

$(firstword <text>)   #  最初の単語を取得します
#例： $(firstword foo bar) 

$(dir <path...>)            #ディレクトリ部分を抽出します
#例： $(dir src/foo.c hacks) # 戻り値：src/ ./

$(notdir <path...>)      #非ディレクトリ部分を抽出します
#例： $(notdir src/foo.c hacks)      # 戻り値：foo.c hacks

$(suffix <names...>)      # ファイルのサフィックスを抽出します
#例： $(suffix src/foo.c src-1.0/bar.c hacks) # 戻り値：.c .c

$(basename <names...>)      # ファイル名のプレフィックスを抽出します
#例： $(basename src/foo.c src-1.0/bar.c hacks)    # 戻り値：src/foo src-1.0/bar hacks

$(addsuffix <suffix>,<names...>)      # <names...>のファイルにサフィックス<suffix>を追加します
#例： $(addsuffix .c,foo bar)          # 戻り値：foo.c bar.c

$(addprefix <prefix>,<names...>)      # プレフィックスを追加します
#例： $(addprefix src/,foo bar)        # 戻り値：src/foo src/bar

$(join <list1>,<list2>)      # 2つのリストを結合します
#例： $(join aaa bbb,111 222 333)     # 戻り値：aaa111 bbb222 333

$(foreach <var>,<list>,<text>)            # リストをループ処理します：<list>から順に単語を取り出し、<var>に代入し、式<text>を計算し、最終的に各計算結果を空白で連結した文字列を返します
#例： files := $(foreach n,a b c d,$(n).o)     # 戻り値：a.o b.o c.o d.o

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

$(call <expression>,<parm1>,<parm2>,...)      #ユーザー定義関数の呼び出し：プレースホルダ$(1)、$(2)などでパラメータを示し、<expression>を計算して戻り値を返します
#例： 
reverse = $(2) $(1)
foo = $(call reverse,a,b) 
# 戻り値：b a

$(origin <variable>)      # 変数の由来を確認します
#戻り値：
undefined：    未定義
default：      デフォルト定義
environment：  環境変数
file：         Makefile定義
command line： コマンドライン定義
override：     override定義
automatic：    自動変数

$(shell <command>)      #シェルコマンドを実行します
#例： files := $(shell echo *.c) 

$(error <text...>)      # makeの実行を終了し、指定されたエラーメッセージを表示します
#例： 変数が空であるかどうかを確認します
MY_VAR :=

ifeq ($(MY_VAR),)
$(error MY_VARは未定義または空です)
endif

$(warning <text...>)      #警告を出力しますが、ビルドプロセスを中断しません
#例： デバッグ情報を出力します
MY_VAR :=

ifeq ($(MY_VAR),)
$(warning MY_VARは未定義または空です)
endif

#例：すべての.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 = >
# -------------------------------
# 一般設定
# -------------------------------
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

# -------------------------------
# コンパイラとフラグ
# -------------------------------
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)

# -------------------------------
# トップレベルファイル
# -------------------------------
SRCS := $(shell find $(SRC_DIR) -name '*.c')
OBJS := $(patsubst $(SRC_DIR)/%.c, $(BUILD_DIR)/%.o, $(SRCS))
DEPS := $(OBJS:.o=.d)

# -------------------------------
# ターゲット
# -------------------------------
.PHONY: all clean install print tar dist TAGS test $(SUBMODULES) #関連ツールがインストールされているかどうかを確認するターゲットも追加すべきです

all: $(PROJECT_NAME)

# メインターゲット実行可能ファイルをビルド
$(PROJECT_NAME): $(OBJS) $(SUBMODULES)
> $(CC) $(OBJS) -o $(BIN_DIR)/$@ $(LDFLAGS) $(LIBS)

# サブモジュールをビルド：サブモジュールをループし、そこに入ってmakeを実行します；Makefileが見つからない場合は、スキップを印刷します
$(SUBMODULES):
> @$(foreach submodule, $(SUBMODULES), \
    $(MAKE) -C $(submodule) || echo "Skipping $(submodule)";)

# 自動的に依存ファイルを生成します
-include $(DEPS)

# クリーンターゲット：ビルドアーティファクトを削除します
clean:
> rm -rf $(BUILD_DIR) $(BIN_DIR) $(LIB_DIR) $(TAR_FILE)
> $(foreach submodule, $(SUBMODULES), $(MAKE) -C $(submodule) clean || echo "Skipping $(submodule)";)

# インストールターゲット：プログラムをインストールします
install: all
> install -m 755 $(BIN_DIR)/$(PROJECT_NAME) $(INSTALL_DIR)

# 印刷ターゲット：変更されたソースファイルをリストします
print:
> @echo "最後のビルド以来変更されたソースファイル："
> @find $(SRC_DIR) -type f -newer $(BIN_DIR)/$(PROJECT_NAME) -print || echo "変更されたソースファイルはありません。"

# タールボールターゲット：ソースタールボールを作成します
tar:
> tar -cvzf $(TAR_FILE) $(SRC_DIR) $(INC_DIR) $(LIB_DIR) Makefile $(SUBMODULES)

# distターゲット：タールボールを圧縮します
dist: tar
> gzip $(TAR_FILE)

# TAGSターゲット：ctagsまたはetagsを生成します
TAGS:
> ctags -R $(SRC_DIR) $(INC_DIR) $(SUBMODULES)

# テストターゲット：ユニットテストを実行します（別のテストスイートを想定）
test:
> @echo "テストを実行中..."
> $(MAKE) -C $(TEST_DIR)

# -------------------------------
# コンパイルルール
# -------------------------------
# オブジェクトファイルを作成するルール。ここでの妙は.c.hが更新されると.oが更新される；.oが更新されるとこのルールが参照され、.dも更新される
$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c
> @mkdir -p $(@D)
> $(CC) $(CFLAGS) -MD -MP -c $< -o $@

# すべての依存ファイルを含める
-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)