Makefile中嵌入一段shell脚本及函数列表 |

Makefile中需要在编译前进行一些处理，shell可以方便完成。以下为在Makefile中使用shell需要注意的一些事项：

makefile和shell区别

变量引用

shell中所有引用以$打头的变量其后要加{},而在Makefile中的变量是以$打头的后加()。如下：

Makefile
PATH="/data/"
SUBPATH=$(PATH)

Shell
PATH="/data/"
SUBPATH=${PATH}

引用shell变量

Makefile中所有以$打头的单词都会被解释成Makefile中的变量。
如果需要调用shell中的变量（或者正则表达式中锚定句位$），都需要加两个$符号（$$）。如下：

PATH="/data/"
all:
    echo $(PATH)
    echo $$PATH

第一个$(PATH)引用的是Makefile中的变量，而不是shell中的PATH环境变量，后者引用的是Shell中的PATH环境变量。

通配符区别

shell 中通配符*表示所有的字符；Makefile 中通配符%表示所有的字符

打印输出

在Makefile中只能在target中调用Shell脚本，其他地方是不能输出的。比如如下代码就是没有任何输出：

VAR="Hello"
echo "$VAR"
all:

以上代码任何时候都不会输出，没有在target内，如果上述代码改为如下：

VAR="Hello"
all:
    echo "$VAR"

以上代码，在make all的时候将会执行echo命令。

代码片段

Makefile中的shell，每一行是一个进程，不同行之间变量值不能传递。所以，Makefile中的shell不管多长也要写在一行
在Makefile中执行shell命令，一行创建一个进程来执行。
不同行之间变量值不能传递。
这也是为什么很多Makefile中有很多行的末尾都是“;\”，
以此来保证代码是一行而不是多行，这样Makefile可以在一个进程中执行，例如：

SUBDIR=src example
all:
    @for subdir in $(SUBDIR); \     #shell代码开始
    do\
        echo "building "; \
    done

上述可以看出for循环中每行都是以”; \”结尾的。

shell代码范围

在Makefile文件的目标项冒号后的另起一行的代码才是shell代码。

xx = xx1       #这里时makefile代码
yy：xx = xx2   #这是是makefile代码，makefile允许变量赋值时，'='号两边留空格
yy：
    xx=xx3     #只有这里是shell代码 ，shell不允许‘=’号两边有空格哦。

有一个例外：
xx=$(shell 这里的代码也是shell代码)

makefile总的反引号`

反引号括起来的字符串被shell解释为命令行，
在执行时，shell首先执行该命令行，并以它的标准输出结果取代整个反引号（包括两个反引号）部分

PATH=`pwd`
TODAY=`date`

#等同于
PATH=$(shell pwd)
TODAY=$(shell date)

实例

获取当前目录

TOPDIR:=$(shell pwd)

获取日期

DATE:=$(shell date +%Y%m%d)

获取源文件列表

SRC += $(shell find . -iname "*.c"  | grep -v "./opensource/*")
SRC += $(shell find . -iname "*.cpp")

PRE_SRC=$(shell find -name "*.c" | xargs grep "HANDLER" | awk -F ':' '{print $$1}' | sort -u) #注意awk中使用的是 $$1

Makefile打印输出

print_version:
    @echo $(BR2_VERSION_FULL)

Makefile嵌入脚本

env:                                                                                                                                
    sh $(SRC_PATH)/scripts/connect.sh
    find $(SRC_PATH) -name "sysinfo.o" | xargs rm -f

signalpre:                                                                                                                          
    sed -i 's/HANDLER/HANDLER HANDLERX/g' $(LIB_PATH)/include/core.h
    @mkdir -p $(SRC_PATH)/output/signalpres
    @echo "\033[031msignale handler processor...\033[0m"
    @for f in $(PRE_SRC); do \
        OBJ=$(SRC_PATH)/output/signalpres/`basename $$f|sed -e 's/\.c/\.i/'`; \
        $(CC) $(CFLAGS) -E $$f -o $$OBJ;\
        echo -n ".";\
    done
    sed -i 's/HANDLER HANDLERX/HANDLER/g' $(LIB_PATH)/include/core.h
    echo "\n"

prepare_config:
    @chmod +x scripts/proj.sh
    @scripts/proj.sh
    @chmod +x scripts/theme.sh
    @scripts/theme.sh

Makefile中的exec执行脚本

format:
    @echo "Makeing format...";
    @find -name "*.c" -exec dos2unix -qU 2>d2utmp1 {} \;
    @find -name "*.h" -exec dos2unix -qU 2>d2utmp1 {} \; 
#   @find -name "*.c" -exec indent -npro -kr -i8 -sob -l120 -ss -ncs  {} \;
    @find -name "*~" -exec rm {} \;
    @find -name "d2utmp*" -exec rm {} \;
    @find -name "deps*" -exec rm {} \;

循环处理文件行

cat config_tmp | while read line
do
    echo "${line}"

    MACRO=$(echo ${line} | awk -F ' ' '{print $2}')
    VALUE=$(echo ${line} | awk -F ' ' '{print $3}')
    echo "Macro: $MACRO Value: $VALUE\n"

    #cat "$SIGNALE_HANDLER_FILE" | sed -e "s/$MACRO/$VALUE/g" > signal_tmp
    sed -i "s/$MACRO/$VALUE/g" ${SIGNALE_HANDLER_FILE}
done

grep反选

cat $CONFIG_FILE | sed -s '/^$/d' | grep -v -e "LangName" -e "__CONFIG_H__" -e "#endif" -e "//" > config_tmp

Makefile依赖规则

OBJS=$(addprefix $(SRC_PATH)/objects/, $(addsuffix .o, $(basename $(notdir $(SRC)))))

deps: $(SRC)
    @-rm -f deps;
    @for f in $(SRC); do \
        OBJ=$(SRC_PATH)/objects/`basename $$f|sed -e 's/\.c/\.o/'`; \
        echo $$OBJ: $$f>> deps; \
        echo '  @echo -e "compiling \033[032m[$(CC)]\033[0m": ' $$f >> deps; \
        echo '  $(CC) $$(CFLAGS) -c -o $$@ $$^'>> deps; \
    done

Makefile模式规则

%.d: %.c
    @set -e; rm -f $@; \
    $(CC) -M $(CPPFLAGS) $< > $@.$$$$; \
    sed 's,\($*\)\.o[ : ]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
    rm -f $@.$$$$

这个规则的意思是，所有的[.d]文件依赖于[.c]文件，“rm -f $@”的意思是删除所有的目标，也就是[.d]文件，
第二行的意思是，为每个依赖文件“$<”，也就是[.c]文件生成依赖文件，“$@”表示模式“%.d”文件，
如果有一个C文件是name.c，那么“%”就是 “name”，“$$$$”意为一个随机编号，
第二行生成的文件有可能是“name.d.12345”，
第三行使用sed命令做了一个替换，关于sed命令的用法请参看相关的使用文档。
第四行就是删除临时文件。

变量值的替换

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

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

变量.o替换为.c

makefile函数列表

函数调用，很像变量的使用，也是以“$”来标识的，其語法如下：

$(<function> <arguments>)

或是

${<function> <arguments>}

这里，<function>就是函数名，make支持的函数不多。
<arguments>为函数的参数，参数间以逗号“,”分隔，而函数名和参数之间以“空格”分隔。
函数调用以“$”开头，以圆括号或花括号把函数名和参数括起。
感觉很像一个变量，是不是？函数中的参数可以使用变量，为了风格的统一，函数和变量的括号最好一样，
如使用“$(subst a,b,$(x))”这样的形式，而不是“$(subst a,b, ${x})”的形式。
因为统一会更清楚，也会减少一些不必要的麻烦。

字符串处理函数

$(subst <from>,<to>,<text>), 字符串替换函数
$(patsubst <pattern>,<replacement>,<text>), 模式字符串替换函数
$(strip <string>), 去空格函数,字串中开头和结尾的空字符
$(findstring <find>,<in>), 查找字符串函数
$(filter <pattern…>,<text>), 以<pattern>模式过滤<text>字符串中的单词，保留符合模式<pattern>的单词。可以有多个模式
$(filter-out <pattern…>,<text>), 以<pattern>模式过滤<text>字符串中的单词，去除符合模式<pattern>的单词。可以有多个模式
$(sort <list>), 给字符串<list>中的单词排序（升序）。
$(word <n>,<text>), 取字符串<text>中第<n>个单词。（从一开始）
$(wordlist <ss>,<e>,<text>), 从字符串<text>中取从<ss>开始到<e>的单词串。<ss>和<e>是一个数字
$(words <text>), 统计<text>中字符串中的单词个数
$(firstword <text>), 取字符串<text>中的第一个单词

搭配使用：

override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH)))

如果我们的“$(VPATH)”值是“src:../headers”，
那么“$(patsubst %,-I%,$(subst :, ,$(VPATH)))”将返回“-Isrc -I../headers”，这正是cc或gcc搜索头文件路径的参数

文件名操作函数

$(dir <names…>), 从文件名序列<names>中取出目录部分。目录部分是指最后一个反斜杠（“/”）之前的部分。如果没有反斜杠，那么返回“./”
$(notdir <names…>), 从文件名序列<names>中取出非目录部分。非目录部分是指最後一个反斜杠（“/”）之后的部分
$(suffix <names…>) , 从文件名序列<names>中取出各个文件名的后缀
$(basename <names…>), 从文件名序列<names>中取出各个文件名的前缀部分
$(addsuffix <suffix>,<names…>), 把后缀<suffix>加到<names>中的每个单词后面
$(addprefix <prefix>,<names…>), 把前缀<prefix>加到<names>中的每个单词后面
$(join <list1>,<list2>), 把<list2>中的单词对应地加到<list1>的单词后面。
如果<list1>的单词个数要比<list2>的多，那么，<list1>中的多出来的单词将保持原样。
如果<list2>的单词个数要比<list1>多，那么，<list2>多出来的单词将被复制到<list1>中

$(join aaa bbb , 111 222 333)返回值是“aaa111 bbb222 333”

foreach 函数

foreach函数和别的函数非常的不一样。
因为这个函数是用来做循环用的，
Makefile中的foreach函数几乎是仿照于Unix标准 Shell（/bin/sh）中的for语句，
或是C-Shell（/bin/csh）中的foreach语句而构建的。它的语法是：

$(foreach   <var>,<list>,<text>)

这个函数的意思是，把参数<list>中的单词逐一取出放到参数<var>所指定的变量中，
然后再执行< text>所包含的表达式。
每一次<text>会返回一个字符串，循环过程中，<text>的所返回的每个字符串会以空格分隔，
最后当整个循环结束时，
<text>所返回的每个字符串所组成的整个字符串（以空格分隔）将会是foreach函数的返回值。

所以，<var>最好是一个变量名，<list>可以是一个表达式，而<text>中一般会使用<var>这个参数来依次枚举<list>中的单词。举个例子：

names := a b c d
files := $(foreach n,$(names),$(n).o)

上面的例子中，$(name)中的单词会被挨个取出，并存到变量“n”中，“$(n).o”每次根据“$(n)”计算出一个值，
这些值以空格分隔，最后作为foreach函数的返回，所以，$(files)的值是“a.o b.o c.o d.o”。

注意，foreach中的<var>参数是一个临时的局部变量，foreach函数执行完后，参数<var>的变量将不在作用，其作用域只在foreach函数当中。

if 函数

if函数很像GNU的make所支持的条件语句——ifeq，if函数的语法是：

$(if <condition>,<then-part>)

或是

$(if <condition>,<then-part>,<else-part>)

call函数

call函数是唯一一个可以用来创建新的参数化的函数。
你可以写一个非常复杂的表达式，这个表达式中，你可以定义许多参数，然后你可以用call函数来向这个表达式传递参数。其语法是：

$(call <expression>;,<parm1>;,<parm2>;,<parm3>;...)

当make执行这个函数时，<expression>;参数中的变量，
如$(1)，$(2)，$(3)等，会被参数< parm1>;，<parm2>;，<parm3>;依次取代。
而<expression>;的返回值就是 call函数的返回值。例如：

reverse =  $(1) $(2)
foo = $(call reverse,a,b)

那么，foo的值就是“a b”。当然，参数的次序是可以自定义的，不一定是顺序的，如：

reverse =  $(2) $(1)
foo = $(call reverse,a,b)

此时的foo的值就是“b a”。

origin函数

origin函数不像其它的函数，他并不操作变量的值，他只是告诉你你的这个变量是哪里来的？其语法是：

$(origin <variable>;)

注意，<variable>;是变量的名字，不应该是引用。
所以你最好不要在<variable>;中使用“$”字符。
Origin函数会以其返回值来告诉你这个变量的“出生情况”，下面，是origin函数的返回值:

“undefined” 如果<variable>;从来没有定义过，origin函数返回这个值“undefined”。
“default” 如果<variable>;是一个默认的定义，比如“CC”这个变量，这种变量我们将在后面讲述。
“environment” 如果<variable>;是一个环境变量，并且当Makefile被执行时，“-e”参数没有被打开。
“file” 如果<variable>;这个变量被定义在Makefile中。
“command line” 如果<variable>;这个变量是被命令行定义的。
“override” 如果<variable>;是被override指示符重新定义的。
“automatic” 如果<variable>;是一个命令运行中的自动化变量。关于自动化变量将在后面讲述。

这些信息对于我们编写Makefile是非常有用的，
例如，假设我们有一个Makefile其包了一个定义文件Make.def，
在 Make.def中定义了一个变量“bletch”，而我们的环境中也有一个环境变量“bletch”，
此时，我们想判断一下，如果变量来源于环境，那么我们就把之重定义了，
如果来源于Make.def或是命令行等非环境的，那么我们就不重新定义它。于是，在我们的Makefile中，我们可以这样写：

ifdef bletch
    ifeq "$(origin bletch)" "environment"
        bletch = barf, gag, etc.
    endif
endif

shell函数

它的参数应该就是操作系统Shell的命令。它和反引号`是相同的功能。
这就是说，shell函数把执行操作系统命令后的输出作为函数返回。
于是，我们可以用操作系统命令以及字符串处理命令awk，sed等等命令来生成一个变量，如：

contents := $(shell cat foo)
files := $(shell echo *.c)

注意，这个函数会新生成一个Shell程序来执行命令，所以你要注意其运行性能，
如果你的Makefile中有一些比较复杂的规则，并大量使用了这个函数，那么对于你的系统性能是有害的。
特别是Makefile的隐晦的规则可能会让你的shell函数执行的次数比你想像的多得多。

自动化变量

$@ 表示规则中的目标文件集。在模式规则中，如果有多个目标，那么，”$@”就是匹配于目标中模式定义的集合。
$% 仅当目标是函数库文件中，表示规则中的目标成员名。
例如，如果一个目标是”foo.a(bar.o)”，那么，”$%”就是 “bar.o”，”$@”就是”foo.a”。
如果目标不是函数库文件（Unix下是[.a]，Windows下是[.lib]），那么，其值为空。
$< 依赖目标中的第一个目标名字。如果依赖目标是以模式（即”%”）定义的，那么”$<”将是符合模式的一系列的文件集。
注意，其是一个一个取出来的。
$? 所有比目标新的依赖目标的集合。以空格分隔。
$^ 所有的依赖目标的集合。以空格分隔。如果在依赖目标中有多个重复的，那个这个变量会去除重复的依赖目标，只保留一份。
$+ 这个变量很像”$^”，也是所有依赖目标的集合。只是它不去除重复的依赖目标。
$* 这个变量表示目标模式中”%”及其之前的部分。如果目标是”dir/a.foo.b”，并且目标的模式是”a.%.b”，
那么，”$*“的值就是”dir/a.foo”。这个变量对于构造有关联的文件名是比较有较。如果目标中没有模式的定义，
那么”$*“也就不能被推导出，但是，如果目标文件的后缀是make所识别的，那么”$*“就是除了后缀的那一部分。
例如：如果目标是”foo.c”，因为”.c”是make所能识别的后缀名，
所以，” $*“的值就是”foo”。这个特性是GNU make的，很有可能不兼容于其它版本的make，
所以，你应该尽量避免使用”$*“，除非是在隐含规则或是静态模式中。如果目标中的后缀是make所不能识别的，那么”$*“就是空值。
当你希望只对更新过的依赖文件进行操作时，”$?”在显式规则中很有用，
例如，假设有一个函数库文件叫”lib”，其由其它几个object文件更新。那么把object文件打包的比较有效率的Makefile规则是：

lib : foo.o bar.o lose.o win.o
```
  ar r lib $?
```

在上述所列出来的自动量变量中。四个变量（$@、$<、$%、$*）在扩展时只会有一个文件，
而另三个的值是一个文件列表。

对于”$<”，为了避免产生不必要的麻烦，我们最好给$后面的那个特定字符都加上圆括号，比如，”$(<)”就要比”$<”要好一些。