命令教程,跟着走快点

引言  - 从"HelloWorld"开始

代码变成可执行文件,叫做编译(compile);先编译这个,还是先编译那个(即编译的安排),叫做构建(build)。

一、简介

  Makefile 是Linux C 程序开发最重要的基本功. 代表着整个项目编译和最终生成过程.本文重点是带大家了解真实项目中那些简易的Makefile规则构建.

Make是最常用的构建工具,诞生于1977年,主要用于C语言的项目。但是实际上 ,任何只要某个文件有变化,就要重新构建的项目,都可以用Make构建。

make命令执行时,需要一个 Makefile 文件,以告诉make命令需要怎么样的去编译和链接程序(简单将:管理工程的文件,决定先编译哪些文件,编译顺序)。

本文参照资料

本文介绍Make命令的用法,从简单的讲起,不需要任何基础,只要会使用命令行,就能看懂。我的参考资料主要是Isaac Schlueter的《Makefile文件教程》和《GNU Make手册》。

二、编写规则:

   GNU make   -    

(题图:摄于博兹贾阿达岛,土耳其,2013年7月)

目标1:目标依赖  然后回车 tab键
 命令;

   跟我一起写Makefile 

 

   入门基础Makefile概述  - 

 

推荐需要简单看看上面资料. 特别是第三个入门教程, 了解基础make语法.  看完后那我们扩展之路开始了, 先hello world 讲起. 素材 mian.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

#define ALEN(arr) (sizeof(arr)/sizeof(*arr))

/*
 * 简单的demo测试
 */
int main(int argc, char * argv[]) {
    int i;
    const char * strs[] = {
        "走着走着,就散了,回忆都淡了",
        "看着看着,就累了,星光也暗了;",
        "听着听着,就醒了,开始埋怨了;",
        "回头发现,你不见了,突然我乱了。",
    };

    srand((unsigned)time(NULL));
    for(;;) {
        /*
         *    e[ 或 \033[ 是 CSI,用来操作屏幕的。
         *    e[K 表示从光标当前位置起删除到 EOL (行尾)
         *    e[NX 表示将光标往X方向移动N,X = A(上) / B(下) / C(左) / D(右),e[1A 就是把光标向上移动1行
         */
        printf("\033[1A\033[K"); //先回到上一行, 然后清除这一行  

        // 随机输出一段话
        i = rand()%ALEN(strs);
        puts(strs[i]);

        sleep(3);
    }    

    return 0;
}

编译上面程序的第一个Makefile 文件内容如下

main.out:main.c
    gcc -g -Wall -o $@ $^

执行过程就是通过shell执行make, 我们简单翻译一下上面写法的含义.

  目标 main.out  依赖 main.c ;  main.c 已经存在(因为是存在的文件) 那就执行规则 (gcc -g -Wall -o $@ $^).

  其中 $@ 表示所有目标, $^表示所有依赖. 

是不是很简单.当然上面Makefile还存在一些潜规则.

  所有执行规则都是以t开始; 第一个目标就是make过程唯一执行的起点;

 

再讲之前我们再扯一点gcc 相关的积累知识. 否则写Makefile都是无米之炊. 

# 中间插入一段关于gcc 的前戏
gcc –E –o main.i mian.c    # -E是预处理展开宏,生成详细c文件, -o是输出
gcc –S –o main.s main.i    # -S 是编译阶段, 将c文件生成汇编语言
gcc –c –o main.o main.s    # -c 是汇编阶段, 生成机器码
gcc –o main.exe main.o     # 链接阶段, -o 生成目标执行程序

gcc –g      # 编译中加入调试信息, 方便gdb调试, 还有-ggdb3 支持宏调试等
gcc –Wall    # 输出所有警告信息
gcc –O2        # 开启调优, O2等级调优

gcc –I(i大写)            # 导入头文件目录,方便 *.h文件查找
gcc –L(l 大写)          # 导入库文件目录,方便 *.so和*.a文件查找
gcc –l(l 小写)           # 导入库文件, 例如-lpthread, 相当于依次查找导入 libpthread.so/libpthread.a 文件
gcc –static –l(l 小写)   # 指定只查找 静态库 lib*.a 文件, linux约定库文件都是 lib开头


ar rc libheoo.a hello.o world.o                    # 将*.o 文件打包成 libheoo.a 静态库
gcc –fPIC –shared –o libheoo.so hello.o world.o    # 将*.o 文件打包成 libheoo.so 动态库

到这里储备方面的讲完毕了.   --<-<-<@

 

前言  -  介绍一下实际例子中语法套路

   首先升级一下上面Makefile文件, 如下(如果你复制没法执行, 请检查规则开头字符是t)

# 构建全局编译操作宏
CC = gcc 
CFLAGS = -g -Wall -O2 
RUNE = $(CC) $(CFLAGS) -o $@ $^
RUNO = $(CC) -o $@ $<

# 构建伪命令
.PHONY:all clean cleanall

# 第一个标签, 是make的开始
all:main.out

main.out:main.c
    $(RUNE)

# 清除操作
clean:
    -rm -rf *.i *.s *.o *~
cleanall:clean
   -rm -rf *.out *.out *.a *.so

我们先说一下Makefile中变量的使用, 就是上面 "="那种基础语法说明.

 

关于Makefile 变量总结如下

关于上面变量的使用这里做一个总结. 

a. = 声明变量
加入存在下面场景
…
CC = cc
…
CC = gcc

那么make的时候, $(CC) 就是 gcc, 会全局替换. 
对于 = 声明的可以认为是一个全局递归替换宏. 

b. := 声明变量

… 
srcdir := ./coroutine
tardir := ./Debug
… 
上面就是一般语言中普通变量. 

c. ?= 声明变量

Foo ?= bar

上面意思是 $(foo)不存在, 那就将 bar 给它. 等同于
ifeq ($(origin FOO), undefined)
  FOO = bar
endif

d.  = 声明变量

objects = main.o foo.o bar.o utils.o
objects  = another.o
等同于

objects = main.o foo.o bar.o utils.o
objects := $(objects) another.o

趁着热度举个例子, 先不解惑. 

CC = cc
FOO := foo 
BAR ?= bar 
HEO := heo 

all :
    echo $(CC)
    echo $(FOO)
    echo $(BAR)
    echo $(HEO) 

HEO  = world
FOO := FOO 
CC = gcc 

执行结果如下, 如下图 . 通过Demo外加上下面运行结果图, 应该会有收获.

图片 1

通过上面我们可以发现 := 和 = 声明的变量都是最终全局替换之后的结果. 他们二者细微差别, 我还是通过例子来说吧.

图片 2

一切都在不言中, 那么关于Makefile变量中语法讲解完毕. 顺带说一些小细节吧,

  1). Makefile 中 一切从简单开始, 能用 = 就不要用 :=

  2). 变量具备全部作用域 , 推荐全部用大写命名

  3). 多查最开始我推荐的资料

 

接着变量往后讲,继续分析其它例子

上面 .PHONY 是 Makefile中伪命令. 默认套路写法. 定义命令名称, 可以通过 make 命令名称调用.

其中 all 是Makefile第一个运行目标,  从它入口. clean , cleanall 伪命令 通过 make clean ; make cleanall 执行.

主要是清除生成的中间文件. 希望你能明白, 自己演示一下, 是不是这样的.

这里我们开始一个新的例子了. 具体参照

  C协程库的编译文件 

# 全局替换变量
CC = gcc 
CFLAGS = -g -Wall -O2 
RUNE = $(CC) $(CFLAGS) -o $@ $^

# 声明路径变量
SRC_PATH := ./coroutine
TAR_PATH := ./Debug

# 构建伪命令
.PHONY:all clean cleanall

# 第一个标签, 是make的开始
all:$(TAR_PATH)/main.out

$(TAR_PATH)/main.out:main.o scoroutine.o
    $(CC) $(CFLAGS) -o $@ $(addprefix $(TAR_PATH)/, $^ )

$(TAR_PATH):
    mkdir $@

%.o:$(SRC_PATH)/%.c | $(TAR_PATH)
    $(CC) $(CFLAGS) -c -o $(TAR_PATH)/$@ $<

# 清除操作
clean:
  -rm -rf $(TAR_PATH)/*.i $(TAR_PATH)/*.s $(TAR_PATH)/*.o $(TAR_PATH)/*~
cleanall:clean
  -rm -rf $(TAR_PATH)

从头开始分析它的具体含义.

1) 开头全局变量定义部分, 个人习惯问题其实也可以用 := . 最终得到 RUNE = gcc -g -Wall -O2 -o $@ $^ .

2) 路径声明部分, 用 := 声明, 支持中间拼接. 用=也可以, 都是条条大路同罗马, 自己多检查一下. 以后我可能全部用 = 声明全局递归的字面变量声明. 

3) .PHONY 声明了 3个伪命令. 不会立即执行的命令, 依赖 make 命令名称 主动调用

4) all 依赖 于 $(TAR_PATH)/main.out 就是依赖于 ./coroutine/main.out. 刚好下面存在

$(TAR_PATH)/main.out:main.o scoroutine.o
    $(CC) $(CFLAGS) -o $@ $(addprefix $(TAR_PATH)/, $^ ) 

这条规则. 其中又依赖于 main.o 和 scoroutine.o 目标. 那么二者也会做新的目标, 就这样递归的找下去.
后面找到了 %.o, Makefile中%是匹配符, 例如 main.o % 就相当于 main部分.
其中addprefix 是GNU make内置的函数的其中一个, 需要用到的时候多查文档就行了.

为每一个可以分割的子单元上加上一个前缀, 这个前缀就是它的第一个参数.

5) 对于下面这段很实用, 通配符 | 生成必要文件的语法

%.o:$(SRC_PATH)/%.c | $(TAR_PATH)
    $(CC) $(CFLAGS) -c -o $(TAR_PATH)/$@ $<

以上是一个通用匹配规则, %.o 目标依赖于 ..../%.c 具体文件. 后面 | 跟的也是一个依赖目标. 这个目标只会在第一次不存在的时候才会被构建.

更加详细的说明可以参照第一个参照资料 "4.3 Types of Prerequisites" 部分.  这个语法用的很多, 用于构建一次生成所需的目录信息.

6) 最后就是剩余clean, cleanall伪命令. 定义清除中间文件等.

是不是想骂die, 但是上面那些都自行捣鼓了一遍, 基本就越过Makefile初级部分, 能够写出能看的编译文件O(∩_∩)O哈哈~

 

正文  - 来个小框架Makefile试试水

  先找一个特别老的, 很水的一个Makefile 试试. 具体参照

  一个控制台小项目编译文件  

C = gcc
DEBUG = -g -Wall -D_DEBUG
#指定pthread线程库
LIB = -lpthread -lm
#指定一些目录
DIR = -I./module/schead/include -I./module/struct/include
#具体运行函数
RUN = $(CC) $(DEBUG) -o $@ $^ $(LIB) $(DIR)
RUNO = $(CC) $(DEBUG) -c -o $@ $^ $(DIR)

# 主要生成的产品
all:test_cjson_write.out test_csjon.out test_csv.out test_json_read.out test_log.out
 test_scconf.out test_tstring.out

#挨个生产的产品
test_cjson_write.out:test_cjson_write.o schead.o sclog.o tstring.o cjson.o
    $(RUN)
test_csjon.out:test_csjon.o schead.o sclog.o tstring.o cjson.o
    $(RUN)
test_csv.out:test_csv.o schead.o sclog.o sccsv.o tstring.o
    $(RUN)
test_json_read.out:test_json_read.o schead.o sclog.o sccsv.o tstring.o cjson.o
    $(RUN)
test_log.out:test_log.o schead.o sclog.o
    $(RUN)
test_scconf.out:test_scconf.o schead.o scconf.o tree.o tstring.o sclog.o
    $(RUN)
test_tstring.out:test_tstring.o tstring.o sclog.o schead.o
    $(RUN)

#产品主要的待链接文件
test_cjson_write.o:./main/test_cjson_write.c
    $(RUNO)
test_csjon.o:./main/test_csjon.c
    $(RUNO)
test_csv.o:./main/test_csv.c
    $(RUNO)
test_json_read.o:./main/test_json_read.c
    $(RUNO)
test_log.o:./main/test_log.c 
    $(RUNO) -std=c99
test_scconf.o:./main/test_scconf.c
    $(RUNO)
test_tstring.o:./main/test_tstring.c
    $(RUNO)

#工具集机械码,待别人链接
schead.o:./module/schead/schead.c
    $(RUNO)
sclog.o:./module/schead/sclog.c
    $(RUNO)
sccsv.o:./module/schead/sccsv.c
    $(RUNO)
tstring.o:./module/struct/tstring.c
    $(RUNO)
cjson.o:./module/schead/cjson.c
    $(RUNO)
scconf.o:./module/schead/scconf.c
    $(RUNO)
tree.o:./module/struct/tree.c
    $(RUNO)

#删除命令
clean:
    rm -rf *.i *.s *.o *.out __* log ; ls -hl
.PHONY:clean

上面那些注释已经表达了一切了吧, 确实好水. 但是特别适合练手, 每一个生成目标都有规则对应. 费力但是最直接. 实在没有没有好讲的, 扯一点

1) GNU make 指定的编译文件是 makefile 或 Makefile. 推荐用Makefile, 是一个传统吧. 因为C项目都是小写, 用大写开头以作区分.

2) Makefile 中 同样以 来起到一整行的效果

3) 其它目标, 依赖, 规则.只要存在那么Makefile就可以自动推导. 当然它依赖文件创建时间戳, 只有它变化了Makefile才会重新生成目标.

Makefile点心结束了. 以上就是make使用本质, 生成什么, 需要什么, 执行什么. 推荐练练手, 手冷写不了代码.

 

最后来点水果

  simplec c的简易级别框架 

##################################################################################################
#                            0.前期编译辅助参数支持                                                 #
##################################################################################################
SRC_PATH         ?= ./simplec
MAIN_DIR         ?= main
SCHEAD_DIR       ?= module/schead
SERVICE_DIR      ?= module/service
STRUCT_DIR       ?= module/struct
TEST_DIR         ?= test
TAR_PATH         ?= ./Output
BUILD_DIR        ?= obj

# 指定一些目录
DIR     =    -I$(SRC_PATH)/$(SCHEAD_DIR)/include -I$(SRC_PATH)/$(SERVICE_DIR)/include 
            -I$(SRC_PATH)/$(STRUCT_DIR)/include

# 全局替换变量
CC        = gcc 
LIB       = -lpthread -lm
CFLAGS    = -g -Wall -O2 -std=gnu99

# 运行指令信息
define NOW_RUNO
$(notdir $(basename $(1))).o : $(1) | $$(TAR_PATH)
    $$(CC) $$(CFLAGS) $$(DIR) -c -o $$(TAR_PATH)/$$(BUILD_DIR)/$$@ $$<
endef

# 单元测试使用, 生成指定主函数的运行程序
RUN_TEST = $(CC) $(CFLAGS) $(DIR) --entry=$(basename $@) -nostartfiles -o 
    $(TAR_PATH)/$(TEST_DIR)/$@ $(foreach v, $^, $(TAR_PATH)/$(BUILD_DIR)/$(v))

# 产生具体的单元测试程序
define TEST_RUN
$(1) : $$(notdir $$(basename $(1))).o libschead.a $(2) | $$(TAR_PATH)
    $$(RUN_TEST) $(LIB)
endef

##################################################################################################
#                            1.具体的产品生产                                                      #
##################################################################################################
.PHONY:all clean cleanall

all : main.out
    $(foreach v, $(wildcard $(SRC_PATH)/$(TEST_DIR)/*.c), $(notdir $(basename $(v))).out)

# 主运行程序main
main.out:main.o simplec.o libschead.a libstruct.a test_sctimeutil.o
    $(CC) $(CFLAGS) $(DIR) -o $(TAR_PATH)/$@ $(foreach v, $^, $(TAR_PATH)/$(BUILD_DIR)/$(v)) $(LIB)

# !!!!! - 生成具体的单元测试程序 - 依赖个人维护 - !!!!!
$(eval $(call TEST_RUN, test_array.out, array.o))
$(eval $(call TEST_RUN, test_atom_rwlock.out))
$(eval $(call TEST_RUN, test_cjson.out, tstr.o))
$(eval $(call TEST_RUN, test_cjson_write.out, tstr.o))
$(eval $(call TEST_RUN, test_csv.out, tstr.o))
$(eval $(call TEST_RUN, test_json_read.out, tstr.o))
$(eval $(call TEST_RUN, test_log.out))
$(eval $(call TEST_RUN, test_scconf.out, tstr.o tree.o))
$(eval $(call TEST_RUN, test_scoroutine.out, scoroutine.o))
$(eval $(call TEST_RUN, test_scpthread.out, scpthread.o scalloc.o))
$(eval $(call TEST_RUN, test_sctimer.out, sctimer.o scalloc.o))
$(eval $(call TEST_RUN, test_sctimeutil.out))
$(eval $(call TEST_RUN, test_tstring.out, tstr.o))
$(eval $(call TEST_RUN, test_xlsmtojson.out, tstr.o))

##################################################################################################
#                            2.先产生所需要的所有机器码文件                                          #
##################################################################################################

# 循环产生 - 所有 - 链接文件 *.o
SRC_CS = $(wildcard
    $(SRC_PATH)/$(MAIN_DIR)/*.c
    $(SRC_PATH)/$(TEST_DIR)/*.c
    $(SRC_PATH)/$(SCHEAD_DIR)/*.c
    $(SRC_PATH)/$(SERVICE_DIR)/*.c
    $(SRC_PATH)/$(STRUCT_DIR)/*.c
)
$(foreach v, $(SRC_CS), $(eval $(call NOW_RUNO, $(v))))

# 生产 -相关- 静态库
libschead.a : $(foreach v, $(wildcard $(SRC_PATH)/$(SCHEAD_DIR)/*.c), $(notdir $(basename $(v))).o)
    ar cr $(TAR_PATH)/$(BUILD_DIR)/$@ $(foreach v, $^, $(TAR_PATH)/$(BUILD_DIR)/$(v))
libstruct.a : $(foreach v, $(wildcard $(SRC_PATH)/$(STRUCT_DIR)/*.c), $(notdir $(basename $(v))).o)
    ar cr $(TAR_PATH)/$(BUILD_DIR)/$@ $(foreach v, $^, $(TAR_PATH)/$(BUILD_DIR)/$(v))

##################################################################################################
#                            3.程序的收尾工作,清除,目录构建                                          #
##################################################################################################
$(TAR_PATH):
    -mkdir -p $@/$(BUILD_DIR)
    -mkdir -p $@/test/config
    -cp -r $(SRC_PATH)/test/config $@/test

# 清除操作
clean :
    -rm -rf $(TAR_PATH)/$(BUILD_DIR)/*

cleanall :
    -rm -rf $(TAR_PATH)

 

具体可以参照simplec 项目查看, 我们抽一部分重点讲解

define NOW_RUNO
$(notdir $(basename $(1))).o : $(1) | $$(TAR_PATH)
    $$(CC) $$(CFLAGS) $$(DIR) -c -o $$(TAR_PATH)/$$(BUILD_DIR)/$$@ $$<
endef

上面定义了一个语句块 NOW_RUNO. 其中语句块中除了要接收的参数可以用$(1), $(2) ..., 其它都是两个$$开头, 否则就被替换了. 使用方法就是

$(eval $(call NOW_RUNO, $(v)))

通过$eval(), $(call ) 这种套路调用. call NOW_RUNO, 后面添加都是 NOW_RUNO语句块的函数了.

这里说一个Makefile处理的潜在小问题, 当你传入参数是依赖项时候, 如果不是直接通过唯一一个参数传入进去,

那么解析的是当成多个依赖项处理.所以上面只有 $(1)做依赖项.

Makefile中 foreach语法也很好用等同于shell语法传参方式.

$(foreach v, $^, $(TAR_PATH)/$(BUILD_DIR)/$(v))
将第二个$^通过空格分隔成单个的v代替, 被替换为第三个中一部分. $(foreach ...)执行完毕最终返回一个拼接好的串

 

在简单补充几个函数说明 例如

$(1) => $$(notdir $$(basename $(1))).o <=> ./simplec/main/main.c => main.o

其中 nodir函数得到文件名, basename函数得到文件名不包过.和.后面部分.
wildcard 函数是得到指定匹配规则下的文件全路径拼接.
最后面 -rm 那些, 加了前缀 - 是为了当Makefile执行到这如果运行出错, 不停止继续前行.
通过上面Makefile最终跑起来后, 会生成一个Output目录, 再在内部生成 obj, test, ...
还是很有学习价值的. 有兴趣的可以试试.
希望通过上面讲解, 能够使你以后阅读其它更高级项目的编译文件不那么生疏. (* ̄(エ) ̄)

 

后记  -  突然想起了什么, 笑了笑 我自己 ...

  伽罗  -  

图片 3

 

一、Make的概念

目标2:目标依赖  然后回车 tab键
 命令;
...

Make这个词,英语的意思是"制作"。Make命令直接用了这个意思,就是要做出某个文件。比如,要做出文件a.txt,就可以执行下面的命令。

目标n:目标依赖  然后回车 tab键
 命令;

$ make a.txt

注意:命令必须是tab键开头的。

但是,如果你真的输入这条命令,它并不会起作用。因为Make命令本身并不知道,如何做出a.txt,需要有人告诉它,如何调用其他命令完成这个目标。

三、Makefile演进
1、一个项目有main.c/a.c/a.h/b.c/b.h五个文件;main.c包含a.h和b.h并使用相关函数;然后建立一个新的Makefile文件,内容如下:
main:a.o b.o
 gcc -o main a.o b.o 
a.o:a.c
 gcc -c a.c -o a.o 
b.o:b.c
 gcc -c b.c -o b.o

比如,假设文件 a.txt 依赖于 b.txt 和 c.txt ,是后面两个文件连接(cat命令)的产物。那么,make 需要知道下面的规则。

2、Makefile升级1
采用makefile变量:想用就用,没有类型,不需要定义(引用变量使用$(obj)来包含更多.o文件)
方法:obj:=a.o b.o
那么上面的Makefile程序升级如下:
obj:=a.o b.o
main:$(obj)
 gcc -o main a.o b.o 
a.o:a.c
 gcc -c a.c -o a.o 
b.o:b.c
 gcc -c b.c -o b.o

a.txt: b.txt c.txt

3、Makefile升级2
经过以上两个makefile的编译,项目执行是成功的,但是如果main.c需要引用更多文件中的函数时,是否要填写那么多的编译命令吗?显然这个方法不可取。
改进:makefile特殊变量和自动推导功能
知识点说明:
$@  代表目标名,
$^  代表依赖文件
%  代表任意字符
%.o  代表任意.o文件
%.c  代表任意.c文件

   cat b.txt c.txt > a.txt

以上Makefile升级如下:
obj:=a.o b.o
main:$(obj)
 gcc -o main $(obj) 
%.o:%c      #注释:模式通配,自动将.c文件编译成.o文件
 gcc -o $@ -c $^    #注释:通配符
clean:
 rm -rf *.o main

也就是说,make a.txt 这条命令的背后,实际上分成两步:第一步,确认 b.txt 和 c.txt 必须已经存在,第二步使用 cat 命令 将这个两个文件合并,输出为新文件。

4、Makefile升级3
exe=main      #注释:最后的编译结果名字
obj:=main.o a.o b.o c.o   #注释:依赖文件
all:$(obj)
gcc -o $(exe) $(obj)
%.o:%.c
gcc -c $^ -o $@
clean:
rm -rf $(obj) $(exe)

像这样的规则,都写在一个叫做Makefile的文件中,Make命令依赖这个文件进行构建。Makefile文件也可以写为makefile, 或者用命令行参数指定为其他文件名。

以上程序看似没有什么问题的,但是clean有点瑕疵,要是也有一个文件叫clean那怎么办?如果make clean就没办法执行这条命令。

$ make -f rules.txt

5、Makefile升级4
使用伪目标.PHONY来解决clean瑕疵问题,升级Makefile如下:
exe:=main
obj:=main.o a.o b.o c.o
all:$(obj)
 gcc -o $(exe) $(obj)
%.o:%.c
 gcc -c $^ -o $@
.PHONY:clean     #注释:声明clean是伪目标
clean:
 rm -rf $(obj) $(exe)

# 或者

注释#.PHONY:clean声明伪目标,避免当前目录存在名字为clean文件的时候命令不能执行的情况

$ make --file=rules.txt

6、Makefile升级5
有时使用的编译器可能是g 、gcc甚至是arm-linux-gcc。为了方便统一管理,最好开头定义一个变量来代表编辑器,然后在gcc命令上变成$(CC):
Makefile升级如下:
CC:=gcc    #注释:定义一个变量,表示当前编辑器为gcc
exe:=main
obj:=main.o a.o b.o c.o
all:$(obj)
 $(CC) -o $(exe) $(obj) 
%.o:%.c
 $(CC) -c $^ -o $@
.PHONY:clean
clean:
 rm -rf $(obj) $(exe)

上面代码指定make命令依据rules.txt文件中的规则,进行构建。

基本上现在的Makefie可以编辑很多普通的程序了。秩序要对Makefile的文件名适当稍加修改即可。如果在比较大型的程序里面写Makefile会相对知识点多一点,比如添加静态库、动态库、线程等等;后续再做升级。

总之,make只是一个根据指定的Shell命令进行构建的工具。它的规则很简单,你规定要构建哪个文件、它依赖哪些源文件,当那些文件有变动时,如何重新构建它。

推荐一本书:GNU make中文手册(翻译整理:徐海兵)

二、Makefile文件的格式

本文永久更新链接地址:http://www.linuxidc.com/Linux/2017-06/145306.htm

构建规则都写在Makefile文件里面,要学会如何Make命令,就必须学会如何编写Makefile文件。

图片 4

2.1 概述

Makefile文件由一系列规则(rules)构成。每条规则的形式如下。

:

[tab]

上面第一行冒号前面的部分,叫做"目标"(target),冒号后面的部分叫做"前置条件"(prerequisites);第二行必须由一个tab键起首,后面跟着"命令"(commands)。

"目标"是必需的,不可省略;"前置条件"和"命令"都是可选的,但是两者之中必须至少存在一个。

每条规则就明确两件事:构建目标的前置条件是什么,以及如何构建。下面就详细讲解,每条规则的这三个组成部分。

2.2 目标(target)

一个目标(target)就构成一条规则。目标通常是文件名,指明Make命令所要构建的对象,比如上文的 a.txt 。目标可以是一个文件名,也可以是多个文件名,之间用空格分隔。

除了文件名,目标还可以是某个操作的名字,这称为"伪目标"(phony target)。

clean:

     rm *.o

上面代码的目标是clean,它不是文件名,而是一个操作的名字,属于"伪目标 ",作用是删除对象文件。

$ make  clean

但是,如果当前目录中,正好有一个文件叫做clean,那么这个命令不会执行。因为Make发现clean文件已经存在,就认为没有必要重新构建了,就不会执行指定的rm命令。

为了避免这种情况,可以明确声明clean是"伪目标",写法如下。

.PHONY: clean

clean:

       rm *.o temp

声明clean是"伪目标"之后,make就不会去检查是否存在一个叫做clean的文件,而是每次运行都执行对应的命令。像.PHONY这样的内置目标名还有不少,可以查看手册。

如果Make命令运行时没有指定目标,默认会执行Makefile文件的第一个目标。

$ make

上面代码执行Makefile文件的第一个目标。

2.3 前置条件(prerequisites)

前置条件通常是一组文件名,之间用空格分隔。它指定了"目标"是否重新构建的判断标准:只要有一个前置文件不存在,或者有过更新(前置文件的last-modification时间戳比目标的时间戳新),"目标"就需要重新构建。

result.txt: source.txt

   cp source.txt result.txt

上面代码中,构建 result.txt 的前置条件是 source.txt 。如果当前目录中,source.txt 已经存在,那么make result.txt可以正常运行,否则必须再写一条规则,来生成 source.txt 。

source.txt:

   echo "this is the source" > source.txt

上面代码中,source.txt后面没有前置条件,就意味着它跟其他文件都无关,只要这个文件还不存在,每次调用make source.txt,它都会生成。

$ make result.txt

$ make result.txt

上面命令连续执行两次make result.txt。第一次执行会先新建 source.txt,然后再新建 result.txt。第二次执行,Make发现 source.txt 没有变动(时间戳晚于 result.txt),就不会执行任何操作,result.txt 也不会重新生成。

如果需要生成多个文件,往往采用下面的写法。

source: file1 file2 file3

上面代码中,source 是一个伪目标,只有三个前置文件,没有任何对应的命令。

$ make source

执行make source命令后,就会一次性生成 file1,file2,file3 三个文件。这比下面的写法要方便很多。

$ make file1

$ make file2

$ make file3

2.4 命令(commands)

命令(commands)表示如何更新目标文件,由一行或多行的Shell命令组成。它是构建"目标"的具体指令,它的运行结果通常就是生成目标文件。

每行命令之前必须有一个tab键。如果想用其他键,可以用内置变量.RECIPEPREFIX声明。

.RECIPEPREFIX = >

all:

> echo Hello, world

上面代码用.RECIPEPREFIX指定,大于号(>)替代tab键。所以,每一行命令的起首变成了大于号,而不是tab键。

需要注意的是,每行命令在一个单独的shell中执行。这些Shell之间没有继承关系。

var-lost:

   export foo=bar

   echo "foo=[$$foo]"

上面代码执行后(make var-lost),取不到foo的值。因为两行命令在两个不同的进程执行。一个解决办法是将两行命令写在一行,中间用分号分隔。

var-kept:

   export foo=bar; echo "foo=[$$foo]"

另一个解决办法是在换行符前加反斜杠转义。

var-kept:

   export foo=bar;

   echo "foo=[$$foo]"

最后一个方法是加上.ONESHELL:命令。

.ONESHELL:

var-kept:

   export foo=bar;

echo "foo=[$$foo]"

三、Makefile文件的语法

3.1 注释

井号(#)在Makefile中表示注释。

# 这是注释

result.txt: source.txt

   # 这是注释

   cp source.txt result.txt # 这也是注释

3.2 回声(echoing)

正常情况下,make会打印每条命令,然后再执行,这就叫做回声(echoing)。

test:

   # 这是测试

执行上面的规则,会得到下面的结果。

$ make test

# 这是测试

在命令的前面加上@,就可以关闭回声。

test:

   @# 这是测试

现在再执行make test,就不会有任何输出。

由于在构建过程中,需要了解当前在执行哪条命令,所以通常只在注释和纯显示的echo命令前面加上@。

test:

   @# 这是测试

   @echo TODO

3.3 通配符

通配符(wildcard)用来指定一组符合条件的文件名。Makefile 的通配符与 Bash 一致,主要有星号(*)、问号(?)和 [...] 。比如, *.o 表示所有后缀名为o的文件。

clean:

       rm -f *.o

3.4 模式匹配

Make命令允许对文件名,进行类似正则运算的匹配,主要用到的匹配符是%。比如,假定当前目录下有 f1.c 和 f2.c 两个源码文件,需要将它们编译为对应的对象文件。

%.o: %.c

等同于下面的写法。

f1.o: f1.c

f2.o: f2.c

使用匹配符%,可以将大量同类型的文件,只用一条规则就完成构建。

3.5 变量和赋值符

Makefile 允许使用等号自定义变量。

txt = Hello World

test:

   @echo $(txt)

上面代码中,变量 txt 等于 Hello World。调用时,变量需要放在 $( ) 之中。

调用Shell变量,需要在美元符号前,再加一个美元符号,这是因为Make命令会对美元符号转义。

test:

   @echo $$HOME

有时,变量的值可能指向另一个变量。

v1 = $(v2)

上面代码中,变量 v1 的值是另一个变量 v2。这时会产生一个问题,v1 的值到底在定义时扩展(静态扩展),还是在运行时扩展(动态扩展)?如果 v2 的值是动态的,这两种扩展方式的结果可能会差异很大。

为了解决类似问题,Makefile一共提供了四个赋值运算符 (=、:=、?=、 =),它们的区别请看StackOverflow。

VARIABLE = value

# 在执行时扩展,允许递归扩展。

VARIABLE := value

# 在定义时扩展。

VARIABLE ?= value

# 只有在该变量为空时才设置值。

VARIABLE = value

# 将值追加到变量的尾端。

3.6 内置变量(Implicit Variables)

Make命令提供一系列内置变量,比如,$(CC) 指向当前使用的编译器,$(MAKE) 指向当前使用的Make工具。这主要是为了跨平台的兼容性,详细的内置变量清单见手册。

output:

   $(CC) -o output input.c

3.7 自动变量(Automatic Variables)

Make命令还提供一些自动变量,它们的值与当前规则有关。主要有以下几个。

(1)$@

$@指代当前目标,就是Make命令当前构建的那个目标。比如,make foo的 $@ 就指代foo。

a.txt b.txt:

touch $@

等同于下面的写法。

a.txt:

   touch a.txt

b.txt:

   touch b.txt

(2)$<

$< 指代第一个前置条件。比如,规则为 t: p1 p2,那么$< 就指代p1。

a.txt: b.txt c.txt

   cp $< $@

等同于下面的写法。

a.txt: b.txt c.txt

   cp b.txt a.txt

(3)$?

$? 指代比目标更新的所有前置条件,之间以空格分隔。比如,规则为 t: p1 p2,其中 p2 的时间戳比 t 新,$?就指代p2。

(4)$^

$^ 指代所有前置条件,之间以空格分隔。比如,规则为 t: p1 p2,那么 $^ 就指代 p1 p2 。

(5)$*

$* 指代匹配符 % 匹配的部分, 比如% 匹配 f1.txt 中的f1 ,$* 就表示 f1。

(6)$(@D) 和 $(@F)

$(@D) 和 $(@F) 分别指向 $@ 的目录名和文件名。比如,$@是 src/input.c,那么$(@D) 的值为 src ,$(@F) 的值为 input.c。

(7)$(

$(

所有的自动变量清单,请看手册。下面是自动变量的一个例子。

dest/%.txt: src/%.txt

   @[ -d dest ] || mkdir dest

   cp $< $@

上面代码将 src 目录下的 txt 文件,拷贝到 dest 目录下。首先判断 dest 目录是否存在,如果不存在就新建,然后,$< 指代前置文件(src/%.txt), $@ 指代目标文件(dest/%.txt)。

3.8 判断和循环

Makefile使用 Bash 语法,完成判断和循环。

ifeq ($(CC),gcc)

 libs=$(libs_for_gcc)

else

 libs=$(normal_libs)

endif

上面代码判断当前编译器是否 gcc ,然后指定不同的库文件。

LIST = one two three

all:

   for i in $(LIST); do

       echo $$i;

   done

# 等同于

all:

   for i in one two three; do

       echo $i;

   done

上面代码的运行结果。

one

two

three

3.9 函数

Makefile 还可以使用函数,格式如下。

$(function arguments)

# 或者

${function arguments}

Makefile提供了许多内置函数,可供调用。下面是几个常用的内置函数。

(1)shell 函数

shell 函数用来执行 shell 命令

srcfiles := $(shell echo src/{00..99}.txt)

(2)wildcard 函数

wildcard 函数用来在 Makefile 中,替换 Bash 的通配符。

srcfiles := $(wildcard src/*.txt)

(3)subst 函数

subst 函数用来文本替换,格式如下。

$(subst from,to,text)

下面的例子将字符串"feet on the street"替换成"fEEt on the strEEt"。

$(subst ee,EE,feet on the street)

下面是一个稍微复杂的例子。

comma:= ,

empty:=

# space变量用两个空变量作为标识符,当中是一个空格

space:= $(empty) $(empty)

foo:= a b c

bar:= $(subst $(space),$(comma),$(foo))

# bar is now `a,b,c'.

(4)patsubst函数

patsubst 函数用于模式匹配的替换,格式如下。

$(patsubst pattern,replacement,text)

下面的例子将文件名"x.c.c bar.c",替换成"x.c.o bar.o"。

$(patsubst %.c,%.o,x.c.c bar.c)

(5)替换后缀名

替换后缀名函数的写法是:变量名 冒号 后缀名替换规则。它实际上patsubst函数的一种简写形式。

min: $(OUTPUT:.js=.min.js)

上面代码的意思是,将变量OUTPUT中的后缀名 .js 全部替换成 .min.js 。

四、Makefile 的实例

(1)执行多个目标

.PHONY: cleanall cleanobj cleandiff

cleanall : cleanobj cleandiff

       rm program

cleanobj :

       rm *.o

cleandiff :

       rm *.diff

上面代码可以调用不同目标,删除不同后缀名的文件,也可以调用一个目标(cleanall),删除所有指定类型的文件。

(2)编译C语言项目

edit : main.o kbd.o command.o display.o

cc -o edit main.o kbd.o command.o display.o

main.o : main.c defs.h

   cc -c main.c

kbd.o : kbd.c defs.h command.h

   cc -c kbd.c

command.o : command.c defs.h command.h

   cc -c command.c

display.o : display.c defs.h

   cc -c display.c

clean :

    rm edit main.o kbd.o command.o display.o

.PHONY: edit clean

今天,Make命令的介绍就到这里。下一篇文章我会介绍,如何用 Make 来构建 Node.js 项目。

(完)

本文由星彩网app下载发布于计算机编程,转载请注明出处:命令教程,跟着走快点

TAG标签: 星彩网app下载
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。