makefile下$(wildcard $^),$^,$@,$?,$<,$(@D),$(@F) 含义

makefile下$(wildcard $^),$^,$@,$?,$<,$(@D),$(@F)代表的不同含义

$(filter-out $(PHONY) $(wildcard $^),$^)
常用用法为$(wildcard *.c)
表示列举当前目录下的所有.c文件
这里$^因为会包含依赖的文件名,如果包含的该文件存在,那么将返回其含路径的文件名
所以$(wildcard $^)就是用来过滤$^包含的所有文件并且该文件确实在本地存在.

自动化变量$?代表依赖文件列表中被改变过的所有文件。
自动化变量$^代表所有通过目录搜索得到的依赖文件的完整路径名(目录 + 一般文件名)列表。
自动化变量$@代表规则的目标。
自动化变量$<代表规则中通过目录搜索得到的依赖文件列表的第一个依赖文件。
自动化变量$(@D)
The directory part of the file name of the target,
with the trailing slash removed. If the value of ‘$@’ is dir/foo.o
then ‘$(@D)’ is dir. This value is . if ‘$@’ does not contain a slash.
http://www.gnu.org/software/make/manual/make.html
自动化变量$(@F)
The file-within-directory part of the file name of
the target. If the value of ‘$@’ is dir/foo.o then ‘$(@F)’ is foo.o.
‘$(@F)’ is equivalent to ‘$(notdir $@)’.

4.12 静态模式
静态模式规则是这样一个规则:
规则存在多个目标,
并且不同的目标可以根据目标
文件的名字来自动构造出依赖文件。
静态模式规则比多目标规则更通用,
它不需要多个
目标具有相同的依赖。
但是静态模式规则中的依赖文件必须是相类似的而不是完全相同
的。
4.12.1
静态模式规则的语法
首先,我们来看一下静态模式规则的基本语法:
TARGETS ...: TARGET-PATTERN: PREREQ-PATTERNS ...
COMMANDS
...
“TAGETS”
列出了此规则的一系列目标文件。
像普通规则的目标一样可以包含通
配符。关于通配符的使用可参考 4.4 文件名使用通配符 一节
“TAGET-PATTERN”和“PREREQ-PATTERNS”说明了如何为每一个目标文件
生成依赖文件。从目标模式(TAGET-PATTERN)的目标名字中抽取一部分字符串(称
为“茎”。使用“茎”替代依赖模式(PREREQ-PATTERNS)中的相应部分来产生对
)
应目标的依赖文件。下边详细介绍这一替代的过程。
首 先 在目标模式和依赖模式中 ,一般需要包含模式字符“% ”
。在目标模式
(TAGET-PATTERN)中“%”可以匹配目标文件的任何部分,模式字符“%”匹配的
部分就是“茎”
。目标文件和目标模式的其余部分必须精确的匹配。看一个例子:目标
“foo.o”符合模式“%.o”
,其“茎”为“foo”
。而目标“foo.c”和“foo.out”就不符
合此目标模式。
每一个目标的依赖文件是使用此目标的“茎”代替依赖模式
(PREREQ-PATTERNS)中的模式字符“%”而得到。例如:上边的例子中依赖模式
(PREREQ-PATTERNS)为“%.c”
,那么使用“茎”
“foo”替代依赖模式中的“%”
得到的依赖文件就是“foo.c”
。需要明确的一点是:在模式规则的依赖列表中使用不包
含模式字符“%”也是合法的。代表这个文件是所有目标的依赖文件。
在模式规则中字符‘%’可以用前面加反斜杠“\”方法引用。引用“%”的反斜杠
也可以由更多的反斜杠引用。引用“%”“\”的反斜杠在和文件名比较或由“茎”代
、
替它之前会从模式中被删除。反斜杠不会因为引用“%”而混乱。如,模式
“the\%weird\\%pattern\\”是“the%weird\”+“%”+“pattern\\”构成。最后的两个
反斜杠由于没有任何转义引用“%”所以保持不变。
我们来看一个例子,它根据相应的.c 文件来编译生成“foo.o”和“bar.o”文件:
objects = foo.o bar.o
all: $(objects)
$(objects): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
例子中,规则描述了所有的.o文件的依赖文件为对应的.c文件,对于目标“foo.o”
,取
其茎“foo”替代对应的依赖模式“%.c”中的模式字符“%”之后可得到目标的依赖文
件“foo.c”
。这就是目标“foo.o”的依赖关系“foo.o: foo.c”
,规则的命令行描述了如
何完成由“foo.c”编译生成目标“foo.o”
。命令行中“$<”和“$@”是自动化变量,
“$<”
表示规则中的第一个依赖文件,
“$@”
表示规则中的目标文件
(可参考 10.5.3 自
动化变量 一小节)
。上边的这个规则描述了以下两个具体的规则:
foo.o : foo.c
$(CC) -c $(CFLAGS) foo.c -o foo.o
bar.o : bar.c
$(CC) -c $(CFLAGS) bar.c -o bar.o
在使用静态模式规则时,指定的目标必须和目标模式相匹配,否则执行make时将
会得到一个错误提示。
如果存在一个文件列表,
其中一部分符合某一种模式而另外一部
分符合另外一种模式,这种情况下我们可以使用“filter”函数(可参考 第八章 make
的内嵌函数)来对这个文件列表进行分类,在分类之后对确定的某一类使用模式规则。
例如:
files = foo.elc bar.o lose.o
$(filter %.o,$(files)): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
$(filter %.elc,$(files)): %.elc: %.el
emacs -f batch-byte-compile $<
其中;$(filter %.o,$(files))的结果为“bar.o lose.o”“filter”函数过滤不符合“%.o”
。
模式的文件名而返回所有符合此模式的文件列表。
第一条静态模式规则描述了这些目标
文件是通过编译对应的.c 源文件来重建的。同样第二条规则也是使用这种方式。
我们通过另外一个例子来看一下自动环变量“$*”在静态模式规则中的使用方法:
bigoutput littleoutput : %output : text.g
generate text.g -$* > $@
当执行此规则的命令时,
自动环变量
“$*”
被展开为
“茎” 在这里就是
。
“big” “little”
和
。
静态模式规则对一个较大工程的管理非常有用。
它可以对整个工程的同一类文件的
重建规则进行一次定义,而实现对整个工程中此类文件指定相同的重建规则。比如,可
以用来描述整个工程中所有的.o 文件的依赖规则和编译命令。通常的做法是将生成同
一类目标的模式定义在一个 make.rules 的文件中。在工程各个模块的 Makefile 中包含
此文件。

静态模式makefile中$(cobjs): $(obj)/%.o: $(src)/%.c

http://www.gnu.org/software/make/manual/make.html
4.12.1 Syntax of Static Pattern Rules

Here is the syntax of a static pattern rule:

     targets ...: target-pattern: prereq-patterns
...
             recipe
             ...

The targets list specifies the targets that the rule applies 
to. The targets can contain wildcard characters, just like the targets of ordinary rules
(see Using Wildcard Characters 
in File Names).

The target-pattern 
and prereq-patterns say how 
to compute the prerequisites of each target.
Each target is matched against the target-pattern
to extract a part of the target name, called the stem. This stem
is substituted into 
each of the prereq-patterns 
to make the prerequisite names (one from
each prereq-pattern).

Each pattern normally contains the character ‘%’ just once. When the target-pattern matches a target,
 the ‘%’ can match any part of the target name; this part
is called the stem. The rest of the pattern must match exactly.
For example, the target foo.o matches the pattern ‘%.o’,
 with ‘foo’ as the stem. The targets foo.c
and foo.out
do not match that pattern.

The prerequisite names for 
each target are made by substituting the stem 
for the ‘%’ 
in each prerequisite pattern.
For example,
if one prerequisite pattern 
is %.c,
then substitution of the stem ‘foo’ gives the prerequisite name foo.c. It
is legitimate to write a prerequisite pattern that does
not contain ‘%’;
then this prerequisite 
is the same for all targets.

‘%’ characters 
in pattern rules can be quoted with preceding backslashes 
(‘\’). Backslashes that would otherwise quote ‘%’ characters can be quoted with more backslashes.
 Backslashes that quote ‘%’ characters 
or other backslashes are removed from the pattern before it 
is compared to file names 
or has a stem substituted into it. Backslashes that are
not in danger of quoting ‘%’ characters go unmolested.
For example, the pattern the\%weird\\%pattern\\
 has ‘the%weird\’ preceding the operative ‘%’ character,
and ‘pattern\\’ following it. The final two backslashes are
left alone because they cannot affect any ‘%’ character.

Here is an example, which compiles
each of foo.o
and bar.o from the corresponding
.c file:

     objects = foo.o bar.o

     all: $(objects)

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

Here ‘$<’ is the automatic variable that holds the name of the prerequisite
and ‘$@’ is the automatic variable that holds the name of the target; see Automatic Variables.

Each target specified must match the target pattern; a warning
is issued for
each target that does 
not. If you have a list of files, only some of which will match the pattern, you can use the
filter function
to remove nonmatching file names 
(see Functions for 
String Substitution and Analysis):

     files = foo.elc bar.o lose.o

     $(filter
%.o,$(files)):
%.o:
%.c
             $(CC)
-c $(CFLAGS) $<
-o $@
     $(filter
%.elc,$(files)):
%.elc:
%.el
             emacs -f batch-byte-compile $<

In this example the result of ‘$(filter
%.o,$(files))’
is bar.o lose.o,
and the first static pattern rule causes 
each of these object files to be updated by compiling the corresponding C source file. The result of ‘$(filter
%.elc,$(files))’
is foo.elc, so that file
is made from foo.el.

Another example shows how to use $*
in static pattern rules:

     bigoutput littleoutput : 
%output : text.g
             generate text.g 
-$* 
> $@

When the generate command is run, $* will expand
to the stem, either ‘big’
or ‘little’.