makefile基本规则
make makefile 的参数
make makefile 的参数make是一个常用的构建工具,用于自动化编译和构建软件项目。
makefile是make工具的配置文件,用于描述项目的构建规则和依赖关系。
本文将介绍makefile的参数,包括常用的参数及其用法。
一、常用参数及其用法1. -f 文件名:指定makefile的文件名,默认为"makefile"或"Makefile"。
通过该参数,可以使用其他名称的makefile文件。
2. -C 目录:指定make命令的工作目录。
在执行make命令时,会切换到指定的目录,并在该目录下查找makefile文件进行构建。
3. -n:显示执行make命令时的操作,但不实际执行。
通过该参数,可以预览make命令的执行过程,检查构建规则是否正确。
4. -p:显示make命令的内置变量和规则。
通过该参数,可以查看make命令的内部工作机制,了解makefile文件的编写规则和使用方法。
5. -B:强制重新构建目标文件。
通过该参数,可以忽略文件的时间戳,强制重新执行构建规则,生成新的目标文件。
6. -j 并发数:指定make命令的并发执行数。
通过该参数,可以提高构建速度,同时执行多个任务。
7. -s:静默模式,不显示执行的命令。
通过该参数,可以减少输出信息,使构建过程更加清晰。
二、makefile的构建规则makefile由一系列构建规则组成,每个规则定义了目标文件、依赖文件和构建命令。
make命令根据构建规则,自动判断需要更新的文件,并执行相应的构建命令。
构建规则的基本格式如下:目标文件: 依赖文件构建命令其中,目标文件是要生成的文件,依赖文件是目标文件依赖的文件,构建命令是生成目标文件的命令。
构建规则中的目标文件和依赖文件可以是文件名,也可以是变量。
通过使用变量,可以提高makefile的可维护性和灵活性。
构建命令可以是任意的Shell命令,包括编译、链接、拷贝等操作。
makefile 静态模式规则
makefile 静态模式规则摘要:1.Makefile 简介2.静态模式规则的概念3.静态模式规则的语法4.静态模式规则的实例5.静态模式规则的应用场景6.静态模式规则的注意事项正文:Makefile 是Linux 和Unix 系统中最常用的构建工具,它可以自动化执行编译、链接、安装等操作。
在Makefile 中,静态模式规则是一种特殊的规定,用于描述目标文件与依赖文件之间的关系。
静态模式规则使得Makefile 更加简洁和高效。
静态模式规则的概念是指在Makefile 中,用简洁的文本描述目标文件和依赖文件之间的依赖关系。
这种规则通常以“:”或“=”作为分隔符,将目标文件和依赖文件分开。
例如,如果目标文件“target”依赖于文件“dependency”,可以使用如下静态模式规则表示:```target: dependency```静态模式规则的语法包括两部分:目标文件和依赖文件。
目标文件是Makefile 要生成的文件,依赖文件是生成目标文件所需要的文件。
目标文件和依赖文件之间用冒号(:)或等号(=)分隔。
静态模式规则的实例可以帮助我们更好地理解这一概念。
例如,假设我们有一个名为“main.o”的目标文件,它依赖于“main.c”和“header.h”两个文件。
在Makefile 中,我们可以使用静态模式规则表示为:```main.o: main.c header.h```静态模式规则的应用场景包括编译、链接和安装等操作。
在编译过程中,Makefile 可以根据静态模式规则自动生成目标文件;在链接过程中,Makefile 可以根据静态模式规则自动链接目标文件和依赖文件;在安装过程中,Makefile 可以根据静态模式规则自动安装目标文件。
在实际使用静态模式规则时,需要注意以下几点:1.依赖文件必须在Makefile 中显式地声明,以确保Makefile 可以找到依赖文件。
2.静态模式规则中的依赖文件必须是绝对路径,以避免在不同目录下出现同名文件的问题。
makefile正则表达式
makefile正则表达式makefile是一种常用的工具,可以用于自动化构建和管理项目。
在makefile中,正则表达式是一个强大的工具,可以帮助我们更方便地匹配和处理文本内容。
makefile中常用的正则表达式包括:1. ^(起始符):匹配字符串的开头。
2. $(结束符):匹配字符串的结尾。
3. .(点号):匹配除了换行符外的任意一个字符。
4. *(星号):匹配前面的字符出现0个或多个。
5. +(加号):匹配前面的字符出现1个或多个。
6. ?(问号):匹配前面的字符出现0个或1个。
7. [ ](中括号):匹配中括号中任意一个字符。
8. [^ ](中括号取反):匹配不在中括号中的任意一个字符。
9. ( )(圆括号):将括号中的内容视为一个整体,可以和其他正则表达式一起使用。
除了这些常用的正则表达式外,还有一些特殊的符号和语法可以帮助我们更精确地匹配文本内容,比如:1. (反斜杠):转义符,可以将特殊字符转义为普通字符。
2. |(竖线):或运算符,可以匹配多个表达式中的一个。
3. { }(花括号):重复次数符号,可以指定一个字符或表达式的重复次数。
在使用正则表达式时,我们需要注意一些事项,比如:1. 正则表达式是区分大小写的。
2. 正则表达式中的空格和换行符也会被匹配。
3. 正则表达式可能会匹配到我们不需要的内容,因此需要通过进一步筛选和处理来达到我们的目的。
总之,正则表达式在makefile中的应用非常广泛,可以帮助我们更方便地编写自动化构建和管理脚本。
熟练掌握正则表达式的使用方法,可以极大地提高我们的工作效率。
makefile编写规则
makefile编写规则⼀、makefile 规则:⼀般开头都是 Tab ,不能空格, include 前⾯不能是 Tab; 1、如果没编译过,将所有的(.c)⽂件编译并且链接; 2、如果有其中的(.c)⽂件改变,编译并链接改变的⽂件; 3、如果(.h)⽂件被修改,编译引⽤相应的(.c)⽂件, 链接; 4、在随意修改时间的情况下,会导致编译过程中⽣成的(.o 中间⽂件)与可执⾏⽂件时间不⼀致,此时会编译相应的⽂件,并链接,最终编译成可执⾏⽂件;⼆、第⼀版 makefile: 例如有2个 .h ⽂件(utils.h, player.h, actor.h)和 3个 .c ⽂件( main.c, player.c, actor.c)需要编译链接:/*****main.c*********/#include "utils.h"#include "player.h"void main() {// do something}/*******player.c**********/#include "utils.h"#include "actor.h"bool create_player() {// do something}/****actor.c************/#include "utils.h"bool create_actor() {// do something}/********* makefile *****************/test : main.o actor.occ -o test main.o actor.omain.o : main.c utils.h player.h actor.hcc -c main.cpalyer.o: player.c player.h actor.h utils.hcc -c player.cactor.o: actor.h utils.hcc -c actor.cclean:rm test ain.o player.o actor.o 优点:可毒性很强,思路清晰明了; 缺点:⿇烦,重复的依赖过多,当需要编译⼤量⽂件时容易出错;第⼆版:利⽤ makefile 的变量;/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较,唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉main.o : main.c utils.h player.h actor.hcc -c main.cpalyer.o: player.c player.h actor.h utils.hcc -c player.cactor.o: actor.h utils.hcc -c actor.c .PHONY : clean // 伪⽬标,避免:如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ) // 前⾯的(-)表⽰,执⾏过程中不 care 出错;第三版:利⽤ GUN make 的⾃动推导规则 当 make 看到(.o )⽂件,他会⾃动把(.c)⽂件加上依赖关系,包括执⾏的语句(cc -c xx.c);/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较,唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉main.o : utils.h player.h actor.hpalyer.o: player.h actor.h utils.hactor.o: actor.h utils.h .PHONY : clean // 伪⽬标,避免:如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ)第四版:对第三版的整理(有⼀些重复的 .h) 公共的⼀起依赖,单独的单独依赖/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较,唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉$(OBJ) : utils.h actor.omain.o player.o .PHONY : clean // 伪⽬标,避免:如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ)优点:简洁缺点:不好理解以上的makefike⽂件的基本写法;或许你也发现了,如果有⼏百个源⽂件咋整呢,光是⽬录就要晕死,下⾯就是针对这种情况来说⼀下⼤型⼯程 makefile 的编写设计⼆、⼤型项⽬makefile编写: Makefile 同样也有像 c / c++ 类似的include功能; 例如我们有⼀堆 a.mk , b.mk以及 foo.make和⼀个变量 $(bar),其包含了 e.mk,f.mk, 那么 include foo.make *.mk $(bar) ------- 等价-------》 include foo.make a.mk b.mk e.mk f.mk。
windows makefile编写规则
Windows Makefile编写规则1. 简介Makefile是一种用于自动化构建和管理项目的工具,它为程序员提供了一种简单的方式来定义和组织项目的编译和链接规则。
在Windows操作系统上,我们可以使用GNU Make工具来解析和执行Makefile文件,实现自动化构建。
2. Makefile的基本语法Makefile由一系列规则组成,每个规则包含一个或多个目标、依赖和命令。
当目标所依赖的文件发生变化时,Make工具会根据规则中定义的命令来重新构建目标。
2.1 目标目标是Makefile中的主要元素,它表示需要构建的文件或操作。
目标可以是一个文件名,也可以是一个伪目标,用于执行一系列命令而不产生任何文件。
target: dependenciescommand2.2 依赖依赖表示目标所依赖的文件或目标。
当依赖的文件发生变化时,Make工具会重新构建目标。
target: dependency1 dependency2command2.3 命令命令是Makefile中的具体操作,用于构建目标或执行其他任务。
命令必须以Tab键开头,否则Make工具无法正确解析。
target:command1command23. Windows下的Makefile在Windows操作系统下,我们可以使用GNU Make工具来执行Makefile文件。
为了能够在Windows上使用Make工具,我们需要安装MinGW或Cygwin等工具集,以提供类Unix环境的支持。
3.1 安装MinGWMinGW是一个Windows上的开发工具集,它提供了一系列的GNU工具,包括GCC编译器和Make工具。
我们可以通过以下步骤来安装MinGW:1.下载MinGW安装程序,可以从官方网站或镜像站点下载。
2.运行安装程序,选择需要安装的组件,包括GCC编译器和Make工具。
3.设置安装路径,并完成安装。
3.2 编写Makefile在Windows下编写Makefile与在Unix系统下基本相同,只是需要注意路径的表示方式。
makefile编写规则 ifeq
makefile编写规则 ifeq什么是makefile?makefile是一种用于自动化构建程序的工具,它能够根据文件之间的依赖关系,自动决定哪些文件需要重新编译。
makefile由一系列规则组成,每个规则定义了如何生成一个或多个目标文件。
make命令会根据这些规则来执行相应的操作,从而实现自动化构建的功能。
ifeq规则的作用在makefile中,ifeq是一种条件语句,用于判断某个条件是否为真。
它的基本语法如下:ifeq (condition, value)# 条件为真时执行的操作else# 条件为假时执行的操作endifcondition是一个条件表达式,可以使用各种比较运算符来进行比较。
value是一个字符串,用于与condition进行比较。
如果condition和value相等,则条件为真,执行ifeq后面的操作;否则条件为假,执行else后面的操作。
ifeq规则的使用场景ifeq规则在makefile中的使用场景很多,下面列举了几个常见的用法:1. 根据不同的操作系统执行不同的操作在跨平台开发中,可能需要根据不同的操作系统执行不同的操作。
可以使用ifeq 规则来判断当前的操作系统,然后执行相应的操作。
ifeq ($(OS),Windows_NT)# Windows系统下的操作CC = clelse# 非Windows系统下的操作CC = gccendif上面的示例中,如果当前操作系统是Windows,则将CC变量设置为cl;否则,将CC变量设置为gcc。
2. 根据变量的值执行不同的操作有时候需要根据某个变量的值来执行不同的操作。
可以使用ifeq规则来判断变量的值,然后执行相应的操作。
ifeq ($(DEBUG),1)# 调试模式下的操作CFLAGS = -gelse# 非调试模式下的操作CFLAGS =endif上面的示例中,如果DEBUG变量的值为1,则将CFLAGS变量设置为-g;否则,将CFLAGS变量设置为空。
makefile文件语法
makefile文件语法Makefile是一种用于自动化构建过程的工具,它使用一种特定的语法来定义构建规则和依赖关系。
下面是一些Makefile的基本语法规则:1. 目标(Target):目标是指要构建的程序或文件。
它通常以冒号(:)开头,后面跟着一个或多个依赖项(dependencies)。
```makefiletarget: dependenciescommands```2. 依赖项(Dependencies):依赖项是指要构建目标所必需的文件或目标。
在Makefile中,依赖项以空格分隔。
3. 命令(Commands):命令是指在构建目标时执行的命令行指令。
这些命令可以是编译、链接或其他任何必要的操作。
4. 变量(Variables):Makefile允许使用变量来存储值,以便在构建过程中重复使用。
变量以符号开头,后面跟着变量名。
```makefileVAR = value```5. 模式规则(Pattern Rules):模式规则允许根据文件模式匹配来构建目标。
它们使用通配符来匹配文件名,并在匹配的文件上执行相应的命令。
```makefiletargets : patterncommands```6. 条件语句(Conditionals):Makefile支持条件语句,可以根据条件执行不同的命令或规则。
条件使用ifdef、ifndef、ifeq等关键字定义。
7. 注释(Comments):Makefile使用井号()作为注释标记,任何在该符号之后的内容都会被视为注释,并被忽略。
8. 自动变量(Automatic Variables):Makefile提供了一些自动变量,可以在命令中使用,以获取有关目标、依赖项或文件名的信息。
例如,$表示当前目标,$<表示第一个依赖项等。
这些是Makefile的一些基本语法规则,但还有更多高级特性和用法,可以参考Make工具的文档或相关教程进行深入学习。
Makefile
MakefileMake的基本规则:Target [属性] 分隔符 [依赖文件] [;命令行 ]{Tab 命令行}注:命令行间可以加入任意多个空行,但空行也要以tab开头。
Cat –v -t -e Makefile会使Makefile文件中tab以^]显示,行尾以$显示。
注:命令过长,用\来连接多行成一行。
注释以#开头,如果#要用作字符符号,―#‖。
分隔符:::目标有多个规则。
哪条规则中的依赖文件比目标新,执行哪条规则。
如果多条规则的依赖文件都比目标新,多条规则都执行。
由于后面的规则可能覆盖前面规则的执行结构,所以规则顺序不同,执行结构也不同。
:^把本规则依赖文件和目标文件已有的依赖文件合起来,生成目标新的依赖文件列表。
:-清除目标已有依赖文件,把本规则依赖文件作为目标依赖文件列表。
:!对每个更新过的依赖文件都执行一次命令菜单。
:|内部规则专用。
如:file.o :file.cfile.o :^ filef.c现依赖文件为file.c filef.cfile.o :- filef.c现依赖文件为 filef.c令行属性:- 若本命令的执行错误,忽略掉,继续向下执行。
(不加该标志,make会停止)+ 始终执行本命令,即使make参数使用了-n-q-t。
(前提是本规则中依赖文件新与目标文件,命令行需要执行)@ 本命令行不在标准输出显示。
Target属性:指定多个目标文件属性:属性属性…… :目标目标……规则中指定单个目标属性:目标属性:[依赖文件] ……·IGNORE 类似与命令行属性-·SILENT 类似与命令行属性@·PRECIOUS 保留中间文件·LIBRARY 目标是一个库。
如果make发现目标是lib(member)或lib((entry))形式,会自动给名为lib的目标加上该属性。
·LIBRARYM 目标是库的一个成员。
如果make发现目标是lib(member)形式,会自动给lib目标加上·LIBRARY,被member目标加上·LIBRARYM。
makefile 隐式规则
makefile 隐式规则Makefile是一种用于自动化构建程序的工具,它可以根据源代码文件的修改情况,自动地编译、链接和生成可执行文件。
Makefile中的隐式规则是指在没有明确指定规则的情况下,Makefile会自动根据文件的后缀名来推断编译规则。
在Makefile中,隐式规则的格式如下:```<目标文件>: <依赖文件><命令>```其中,目标文件是要生成的文件,依赖文件是生成目标文件所需要的文件,命令是生成目标文件的具体操作。
例如,我们要编译一个C语言程序,可以使用以下的隐式规则:```.c.o:gcc -c $< -o $@```这个规则的意思是,将所有的.c文件编译成.o文件,使用gcc编译器进行编译,$<表示依赖文件,$@表示目标文件。
另外,Makefile中还有一些内置的隐式规则,例如:- .c.o:将C语言源文件编译成目标文件- .cpp.o:将C++语言源文件编译成目标文件- .f.o:将Fortran语言源文件编译成目标文件- .y.c:将Yacc源文件生成C语言源文件- .l.c:将Lex源文件生成C语言源文件除了以上的内置规则外,我们还可以自定义隐式规则,例如:```.SUFFIXES: .txt .html.txt.html:pandoc $< -o $@```这个规则的意思是,将所有的.txt文件转换成.html文件,使用pandoc工具进行转换,$<表示依赖文件,$@表示目标文件。
总之,Makefile中的隐式规则可以大大简化编译过程,提高编译效率,是一个非常重要的功能。
在编写Makefile时,我们应该充分利用隐式规则,减少重复的代码,提高代码的可维护性和可读性。
makefile基本使用方法
makefile基本使用方法makefile是一种用来管理和自动化构建程序的工具。
它可以根据源代码文件的依赖关系和编译规则来自动构建目标文件和可执行文件。
makefile的基本使用方法如下:1. 创建makefile文件:在项目的根目录下创建一个名为makefile 的文件。
2. 定义变量:在makefile中,可以使用变量来存储一些常用的参数和路径,以便于后续的使用。
例如,可以定义一个名为CC的变量来指定编译器的名称,如:CC=gcc。
3. 编写规则:在makefile中,可以使用规则来指定如何编译源代码文件和生成目标文件。
一个规则由两部分组成:目标和依赖。
目标是要生成的文件,依赖是生成目标文件所需要的源代码文件。
例如,可以编写以下规则:```target: dependency1 dependency2command1command2```其中,target是目标文件,dependency1和dependency2是依赖的源代码文件,command1和command2是生成目标文件所需要执行的命令。
4. 编写默认规则:在makefile中,可以使用一个默认规则来指定如何生成最终的可执行文件。
默认规则的目标通常是可执行文件,依赖是所有的源代码文件。
例如,可以编写以下默认规则:```all: target1 target2```其中,target1和target2是生成的目标文件。
5. 编写clean规则:在makefile中,可以使用clean规则来清理生成的目标文件和可执行文件。
例如,可以编写以下clean规则: ```clean:rm -f target1 target2```其中,target1和target2是要清理的目标文件。
6. 运行make命令:在命令行中,使用make命令来执行makefile 文件。
make命令会自动根据规则和依赖关系来编译源代码文件和生成目标文件。
例如,可以运行以下命令:``````make命令会根据makefile文件中的规则和依赖关系来编译源代码文件并生成目标文件和可执行文件。
makefile 中文手册 第四章 _ Makefile的规则
第四章:Makefile的规则本章我们将讨论Makefile的一个重要内容,规则。
熟悉规则对于书写Makefile至关重要。
Makefile中,规则描述了在何种情况下使用什么命令来重建一个特定的文件,此文件被称为规则“目标”(通常规则中的目标只有一个)。
规则中出目标之外的罗列的其它文件称为“目标”的依赖,而规则的命令是用来更新或者创建此规则的目标。
除了makefile的“终极目标”所在的规则以外,其它规则的顺序在makefile文件中没有意义。
“终极目标”就是当没有使用make 命令行指定具体目标时,make默认的更新的哪一个目标。
它是makefile文件中第一个规则的目标。
如果在makefile中第一个规则有多个目标的话,那么多个目标中的第一个将会被作为make的“终极目标”。
有两种情况的例外:1. 目标名以点号“.”开始的并且其后不存在斜线“/”(“./”被认为是当前目录;“../”被认为是上一级目录);2. 模式规则的目标。
当这两种目标所在的规则是Makefile的第一个规则时,它们并不会被作为“终极目标”。
“终极目标”是执行make的唯一目的,其所在的规则作为第一个被执行的规则。
而其它的规则是在完成重建“终极目标”的过程中被连带出来的。
所以这些目标所在规则在Makefile中的顺序无关紧要。
因此,我们书写的makefile的第一个规则应该就是重建整个程序或者多个程序的依赖关系和执行命令的描述。
4.1 一个例子我们来看一个规则的例子:foo.o : foo.c defs.h # module for twiddling the frobscc -c -g foo.c这是一个典型的规则。
看到这个例子,大家应该能够说出这个规则的各个部分之间的关系。
不过我们还是要把这个例子拿出来讨论。
目的是让我们更加明确地理解Makefile的规则。
本例第一行中,文件“foo.o”是规则需要重建的文件,而“foo.c”和“defs.h”是重建“foo.o”所要使用的文件。
makefile规则
makefile规则makefile规则是指在编译和链接源程序时使用的指令说明集合,它主要实现对源程序进行编译和链接操作。
makefile规则通常包括定义、变量( macro )、条件语句、文件名模式、关系性质,以及各种命令的执行。
定义是指在 makefile 中定义一些环境变量,这样可以同时供make 命令和源程序使用。
变量就是把变量名称定义为字符内容或者字符串。
条件语句是指在 makefile 中可以使用 if-then-else 语句条件判断,实现对不同平台的兼容和不同编译器的支持。
文件名模式是指在 makefile 中,可以使用文件名模式来精确针对特定文件和目录,完成不同操作。
关系性质是指 makefile 支持多个文件之间的依赖关系,即如果文件 A 依赖于文件 B,当文件 B 的内容发生变化时,系统自动执行文件 A 的操作。
makefile 还支持各种命令的执行,包括编译、链接、拷贝、安装等操作。
通过这些命令的执行,可以非常方便地把源程序编译和链接,实现最终的编译和链接结果。
通常,makefile 规则是由多个项目构成的,每一项都有一个名称,每一个项目都可以包含一些变量,关系和命令等,用于指定 make 命令的行为。
每个规则以一个制表符开头,然后是目标文件、依赖文件、变量名和命令,分别以冒号、逗号、空格和分号等符号隔开。
每个 makefile 都有一个默认的目标,如果在编译和链接时没有指定特定的目标,则 make 命令会执行默认的目标。
因此,完整的makefile 是必须设置默认目标的,才能在执行 make 命令时得到正确的结果。
简述Makefile文件的格式
简述Makefile文件的格式Makefile文件是一种常见的文本文件,用于描述一个项目中各个文件之间的依赖关系和编译规则。
Makefile文件通常由一系列规则组成,每个规则由一个目标、依赖关系和命令组成。
Makefile文件的格式如下:1. 目标(Target)目标是指需要生成的文件或者执行的操作。
在Makefile中,目标通常是一个可执行程序或者一个库文件。
目标的格式为:target: dependenciescommand其中,target表示目标名称,dependencies表示该目标所依赖的其他文件或者操作,command表示生成该目标所需要执行的命令。
2. 依赖关系(Dependencies)依赖关系指该目标所依赖的其他文件或者操作。
在Makefile中,可以通过在目标后面加上冒号(:)来定义该目标所依赖的其他文件或者操作。
多个依赖关系之间可以使用空格或者Tab键来进行分隔。
3. 命令(Command)命令是指生成该目标所需要执行的具体操作。
在Makefile中,可以通过在每个规则后面添加一行以Tab键开头的命令来定义具体操作。
4. 变量(Variables)变量是指用于存储各种编译参数和路径等信息的变量。
在Makefile中,可以通过使用$()符号来引用变量,并使用=符号来进行赋值操作。
例如:CFLAGS = -Wall -O2CC = gcctarget: dependencies$(CC) $(CFLAGS) -o target dependencies5. 注释(Comments)注释是指用于对Makefile中各个规则进行解释说明的文本。
在Makefile中,可以使用#符号来进行注释,#符号后面的内容将被忽略。
总之,Makefile文件是一个非常重要的工具,在项目开发过程中起到了至关重要的作用。
掌握Makefile文件的格式和编写方法,可以帮助我们更加高效地管理和组织项目代码,并提高项目开发效率。
Makefile使用总结
Makefile使⽤总结1. Makefile 简介Makefile 是和 make 命令⼀起配合使⽤的.很多⼤型项⽬的编译都是通过 Makefile 来组织的, 如果没有 Makefile, 那很多项⽬中各种库和代码之间的依赖关系不知会多复杂. Makefile的组织流程的能⼒如此之强, 不仅可以⽤来编译项⽬, 还可以⽤来组织我们平时的⼀些⽇常操作. 这个需要⼤家发挥⾃⼰的想象⼒.本篇博客是基于⽽整理的, 有些删减, 追加了⼀些⽰例.⾮常感谢 gunguymadman_cu 提供如此详尽的Makefile介绍, 这正是我⼀直寻找的Makefile中⽂⽂档.1.1 Makefile 主要的 5个部分 (显⽰规则, 隐晦规则, 变量定义, ⽂件指⽰, 注释)Makefile基本格式如下:target ... : prerequisites ...command......其中,target - ⽬标⽂件, 可以是 Object File, 也可以是可执⾏⽂件prerequisites - ⽣成 target 所需要的⽂件或者⽬标command - make需要执⾏的命令 (任意的shell命令), Makefile中的命令必须以 [tab] 开头1. 显⽰规则 :: 说明如何⽣成⼀个或多个⽬标⽂件(包括⽣成的⽂件, ⽂件的依赖⽂件, ⽣成的命令)2. 隐晦规则 :: make的⾃动推导功能所执⾏的规则3. 变量定义 :: Makefile中定义的变量4. ⽂件指⽰ :: Makefile中引⽤其他Makefile; 指定Makefile中有效部分; 定义⼀个多⾏命令5. 注释 :: Makefile只有⾏注释 "#", 如果要使⽤或者输出"#"字符, 需要进⾏转义, "\#"1.2 GNU make 的⼯作⽅式1. 读⼊主Makefile (主Makefile中可以引⽤其他Makefile)2. 读⼊被include的其他Makefile3. 初始化⽂件中的变量4. 推导隐晦规则, 并分析所有规则5. 为所有的⽬标⽂件创建依赖关系链6. 根据依赖关系, 决定哪些⽬标要重新⽣成7. 执⾏⽣成命令2. Makefile 初级语法2.1 Makefile 规则2.1.1 规则语法规则主要有2部分: 依赖关系和⽣成⽬标的⽅法.语法有以下2种:target ... : prerequisites ...command...或者target ... : prerequisites ; commandcommand...*注* command太长, 可以⽤ "\" 作为换⾏符2.1.2 规则中的通配符* :: 表⽰任意⼀个或多个字符:: 表⽰任意⼀个字符[...] :: ex. [abcd] 表⽰a,b,c,d中任意⼀个字符, [^abcd]表⽰除a,b,c,d以外的字符, [0-9]表⽰ 0~9中任意⼀个数字~ :: 表⽰⽤户的home⽬录2.1.3 路径搜索当⼀个Makefile中涉及到⼤量源⽂件时(这些源⽂件和Makefile极有可能不在同⼀个⽬录中),这时, 最好将源⽂件的路径明确在Makefile中, 便于编译时查找. Makefile中有个特殊的变量VPATH就是完成这个功能的.指定了VPATH之后, 如果当前⽬录中没有找到相应⽂件或依赖的⽂件, Makefile 回到VPATH指定的路径中再去查找.. VPATH使⽤⽅法:vpath <directories> :: 当前⽬录中找不到⽂件时, 就从<directories>中搜索vpath <pattern> <directories> :: 符合<pattern>格式的⽂件, 就从<directories>中搜索vpath <pattern> :: 清除符合<pattern>格式的⽂件搜索路径vpath :: 清除所有已经设置好的⽂件路径# ⽰例1 - 当前⽬录中找不到⽂件时, 按顺序从 src⽬录 ../parent-dir⽬录中查找⽂件VPATH src:../parent-dir# ⽰例2 - .h结尾的⽂件都从 ./header ⽬录中查找VPATH %.h ./header# ⽰例3 - 清除⽰例2中设置的规则VPATH %.h# ⽰例4 - 清除所有VPATH的设置VPATH2.2 Makefile 中的变量2.2.1 变量定义 ( = or := )OBJS = programA.o programB.oOBJS-ADD = $(OBJS) programC.o# 或者OBJS := programA.o programB.oOBJS-ADD := $(OBJS) programC.o其中 = 和 := 的区别在于, := 只能使⽤前⾯定义好的变量, = 可以使⽤后⾯定义的变量测试 =# Makefile内容OBJS2 = $(OBJS1) programC.oOBJS1 = programA.o programB.oall:@echo $(OBJS2)# bash中执⾏make, 可以看出虽然 OBJS1 是在 OBJS2 之后定义的, 但在 OBJS2中可以提前使⽤$ makeprogramA.o programB.o programC.o测试 :=# Makefile内容OBJS2 := $(OBJS1) programC.oOBJS1 := programA.o programB.oall:@echo $(OBJS2)# bash中执⾏make, 可以看出 OBJS2 中的 $(OBJS1) 为空$ makeprogramC.o2.2.2 变量替换# Makefile内容SRCS := programA.c programB.c programC.cOBJS := $(SRCS:%.c=%.o)all:@echo "SRCS: " $(SRCS)@echo "OBJS: " $(OBJS)# bash中运⾏make$ makeSRCS: programA.c programB.c programC.cOBJS: programA.o programB.o programC.o2.2.3 变量追加值 +=# Makefile内容SRCS := programA.c programB.c programC.cSRCS += programD.call:@echo "SRCS: " $(SRCS)# bash中运⾏make$ makeSRCS: programA.c programB.c programC.c programD.c2.2.4 变量覆盖 override作⽤是使 Makefile中定义的变量能够覆盖 make 命令参数中指定的变量语法:override <variable> = <value>override <variable> := <value>override <variable> += <value>下⾯通过⼀个例⼦体会 override 的作⽤:# Makefile内容 (没有⽤override)SRCS := programA.c programB.c programC.call:@echo "SRCS: " $(SRCS)# bash中运⾏make$ make SRCS=nothingSRCS: nothing################################################## Makefile内容 (⽤override)override SRCS := programA.c programB.c programC.call:@echo "SRCS: " $(SRCS)# bash中运⾏make$ make SRCS=nothingSRCS: programA.c programB.c programC.c2.2.5 ⽬标变量作⽤是使变量的作⽤域仅限于这个⽬标(target), ⽽不像之前例⼦中定义的变量, 对整个Makefile都有效.语法:<target ...> :: <variable-assignment><target ...> :: override <variable-assignment> (override作⽤参见变量覆盖的介绍)⽰例:# Makefile 内容SRCS := programA.c programB.c programC.ctarget1: TARGET1-SRCS := programD.ctarget1:@echo "SRCS: " $(SRCS)@echo "SRCS: " $(TARGET1-SRCS)target2:@echo "SRCS: " $(SRCS)@echo "SRCS: " $(TARGET1-SRCS)# bash中执⾏make$ make target1SRCS: programA.c programB.c programC.cSRCS: programD.c$ make target2 <-- target2中显⽰不了 $(TARGET1-SRCS)SRCS: programA.c programB.c programC.cSRCS:2.3 Makefile 命令前缀Makefile 中书写shell命令时可以加2种前缀 @ 和 -, 或者不⽤前缀.3种格式的shell命令区别如下:不⽤前缀 :: 输出执⾏的命令以及命令执⾏的结果, 出错的话停⽌执⾏前缀 @ :: 只输出命令执⾏的结果, 出错的话停⽌执⾏前缀 - :: 命令执⾏有错的话, 忽略错误, 继续执⾏⽰例:# Makefile 内容 (不⽤前缀)all:echo"没有前缀"cat this_file_not_existecho"错误之后的命令" <-- 这条命令不会被执⾏# bash中执⾏make$ makeecho"没有前缀" <-- 命令本⾝显⽰出来没有前缀 <-- 命令执⾏结果显⽰出来cat this_file_not_existcat: this_file_not_exist: No such file or directorymake: *** [all] Error 1############################################################ Makefile 内容 (前缀 @)all:@echo "没有前缀"@cat this_file_not_exist@echo "错误之后的命令" <-- 这条命令不会被执⾏# bash中执⾏make$ make没有前缀 <-- 只有命令执⾏的结果, 不显⽰命令本⾝cat: this_file_not_exist: No such file or directorymake: *** [all] Error 1############################################################ Makefile 内容 (前缀 -)all:-echo"没有前缀"-cat this_file_not_exist-echo"错误之后的命令" <-- 这条命令会被执⾏# bash中执⾏make$ makeecho"没有前缀" <-- 命令本⾝显⽰出来没有前缀 <-- 命令执⾏结果显⽰出来cat this_file_not_existcat: this_file_not_exist: No such file or directorymake: [all] Error 1 (ignored)echo"错误之后的命令" <-- 出错之后的命令也会显⽰错误之后的命令 <-- 出错之后的命令也会执⾏2.4 伪⽬标伪⽬标并不是⼀个"⽬标(target)", 不像真正的⽬标那样会⽣成⼀个⽬标⽂件.典型的伪⽬标是 Makefile 中⽤来清理编译过程中中间⽂件的 clean 伪⽬标, ⼀般格式如下: .PHONY: clean <-- 这句没有也⾏, 但是最好加上clean:-rm -f *.o2.5 引⽤其他的 Makefile语法: include <filename> (filename 可以包含通配符和路径)⽰例:# Makefile 内容all:@echo "主 Makefile begin"@make other-all@echo "主 Makefile end"include ./other/Makefile# ./other/Makefile 内容other-all:@echo "other makefile begin"@echo "other makefile end"# bash中执⾏make$ lltotal 20K-rw-r--r-- 1 wangyubin wangyubin 125 Sep 2316:13 Makefile-rw-r--r-- 1 wangyubin wangyubin 11K Sep 2316:15 <-- 这个⽂件不⽤管drwxr-xr-x 2 wangyubin wangyubin 4.0K Sep 2316:11 other$ ll other/total 4.0K-rw-r--r-- 1 wangyubin wangyubin 71 Sep 2316:11 Makefile$ make主 Makefile beginmake[1]: Entering directory `/path/to/test/makefile'other makefile beginother makefile endmake[1]: Leaving directory `/path/to/test/makefile'主 Makefile end2.6 查看C⽂件的依赖关系写 Makefile 的时候, 需要确定每个⽬标的依赖关系.GNU提供⼀个机制可以查看C代码⽂件依赖那些⽂件, 这样我们在写 Makefile ⽬标的时候就不⽤打开C源码来看其依赖那些⽂件了.⽐如, 下⾯命令显⽰内核源码中 virt/kvm/kvm_main.c 中的依赖关系$ cd virt/kvm/$ gcc -MM kvm_main.ckvm_main.o: kvm_main.c iodev.h coalesced_mmio.h async_pf.h <-- 这句就可以加到 Makefile 中作为编译 kvm_main.o 的依赖关系2.7 make 退出码Makefile的退出码有以下3种:0 :: 表⽰成功执⾏1 :: 表⽰make命令出现了错误2 :: 使⽤了 "-q" 选项, 并且make使得⼀些⽬标不需要更新2.8 指定 Makefile,指定特定⽬标默认执⾏ make 命令时, GNU make在当前⽬录下依次搜索下⾯3个⽂件 "GNUmakefile", "makefile", "Makefile",找到对应⽂件之后, 就开始执⾏此⽂件中的第⼀个⽬标(target). 如果找不到这3个⽂件就报错.⾮默认情况下, 可以在 make 命令中指定特定的 Makefile 和特定的⽬标.⽰例:# Makefile⽂件名改为 MyMake, 内容target1:@echo "target [1] begin"@echo "target [1] end"target2:@echo "target [2] begin"@echo "target [2] end"# bash 中执⾏make$ lsMakefile$ mv Makefile MyMake$ lsMyMake$ make <-- 找不到默认的 Makefilemake: *** No targets specified and no makefile found. Stop.$ make -f MyMake <-- 指定特定的Makefiletarget [1] begintarget [1] end$ make -f MyMake target2 <-- 指定特定的⽬标(target)target [2] begintarget [2] end2.9 make 参数介绍make 的参数有很多, 可以通过 make -h 去查看, 下⾯只介绍⼏个我认为⽐较有⽤的.参数含义--debug[=<options>]输出make的调试信息, options 可以是 a, b, v-j --jobs同时运⾏的命令的个数, 也就是多线程执⾏ Makefile-r --no-builtin-rules禁⽌使⽤任何隐含规则-R --no-builtin-variabes禁⽌使⽤任何作⽤于变量上的隐含规则-B --always-make假设所有⽬标都有更新, 即强制重编译2.10 Makefile 隐含规则这⾥只列⼀个和编译C相关的.编译C时,<n>.o 的⽬标会⾃动推导为 <n>.c# Makefile 中main : main.ogcc -o main main.o#会⾃动变为:main : main.ogcc -o main main.omain.o: main.c <-- main.o 这个⽬标是隐含⽣成的gcc -c main.c2.11 隐含规则中的命令变量和命令参数变量2.11.1 命令变量, 书写Makefile可以直接写 shell时⽤这些变量.下⾯只列出⼀些C相关的变量名含义RM rm -fAR arCC ccCXX g++⽰例:# Makefile 内容all:@echo $(RM)@echo $(AR)@echo $(CC)@echo $(CXX)# bash 中执⾏make, 显⽰各个变量的值$ makerm -farccg++2.11.2 命令参数变量变量名含义ARFLAGS AR命令的参数CFLAGS C语⾔编译器的参数CXXFLAGS C++语⾔编译器的参数⽰例: 下⾯以 CFLAGS 为例演⽰# test.c 内容#include <stdio.h>int main(int argc, char *argv[]){printf ("Hello Makefile\n");return 0;}# Makefile 内容test: test.o$(CC) -o test test.o# bash 中⽤make来测试$ lltotal 24K-rw-r--r-- 1 wangyubin wangyubin 69 Sep 2317:31 Makefile-rw-r--r-- 1 wangyubin wangyubin 14K Sep 2319:51 <-- 请忽略这个⽂件-rw-r--r-- 1 wangyubin wangyubin 392 Sep 2317:31 test.c$ makecc -c -o test.o test.ccc -o test test.o <-- 这个是⾃动推导的$ rm -f test test.o$ make CFLAGS=-Wall <-- 命令中加的编译器参数⾃动追加⼊下⾯的编译中了cc -Wall -c -o test.o test.ccc -o test test.o2.12 ⾃动变量Makefile 中很多时候通过⾃动变量来简化书写, 各个⾃动变量的含义如下:⾃动变量含义$@⽬标集合$%当⽬标是函数库⽂件时, 表⽰其中的⽬标⽂件名$<第⼀个依赖⽬标. 如果依赖⽬标是多个, 逐个表⽰依赖⽬标$?⽐⽬标新的依赖⽬标的集合$^所有依赖⽬标的集合, 会去除重复的依赖⽬标$+所有依赖⽬标的集合, 不会去除重复的依赖⽬标$*这个是GNU make特有的, 其它的make不⼀定⽀持3. Makefile ⾼级语法3.1 嵌套Makefile在 Makefile 初级语法中已经提到过引⽤其它 Makefile的⽅法. 这⾥有另⼀种写法, 并且可以向引⽤的其它 Makefile 传递参数.⽰例: (不传递参数, 只是调⽤⼦⽂件夹 other 中的Makefile)# Makefile 内容all:@echo "主 Makefile begin"@cd ./other && make@echo "主 Makefile end"# ./other/Makefile 内容other-all:@echo "other makefile begin"@echo "other makefile end"# bash中执⾏make$ lltotal 28K-rw-r--r-- 1 wangyubin wangyubin 104 Sep 2320:43 Makefile-rw-r--r-- 1 wangyubin wangyubin 17K Sep 2320:44 <-- 这个⽂件不⽤管drwxr-xr-x 2 wangyubin wangyubin 4.0K Sep 2320:42 other$ ll other/total 4.0K-rw-r--r-- 1 wangyubin wangyubin 71 Sep 2316:11 Makefile$ make主 Makefile beginmake[1]: Entering directory `/path/to/test/makefile/other'other makefile beginother makefile endmake[1]: Leaving directory `/path/to/test/makefile/other'主 Makefile end⽰例: (⽤export传递参数)# Makefile 内容export VALUE1 := export.c <-- ⽤了 export, 此变量能够传递到 ./other/Makefile 中VALUE2 := no-export.c <-- 此变量不能传递到 ./other/Makefile 中all:@echo "主 Makefile begin"@cd ./other && make@echo "主 Makefile end"# ./other/Makefile 内容other-all:@echo "other makefile begin"@echo "VALUE1: " $(VALUE1)@echo "VALUE2: " $(VALUE2)@echo "other makefile end"# bash中执⾏make$ make主 Makefile beginmake[1]: Entering directory `/path/to/test/makefile/other'other makefile beginVALUE1: export.c <-- VALUE1 传递成功VALUE2: <-- VALUE2 传递失败other makefile endmake[1]: Leaving directory `/path/to/test/makefile/other'主 Makefile end*补充* export 语法格式如下:export variable = valueexport variable := valueexport variable += value3.2 定义命令包命令包有点像是个函数, 将连续的相同的命令合成⼀条, 减少 Makefile 中的代码量, 便于以后维护.语法:define <command-name>command...endef⽰例:# Makefile 内容define run-hello-makefile@echo -n "Hello"@echo " Makefile!"@echo "这⾥可以执⾏多条 Shell 命令!"endefall:$(run-hello-makefile)# bash 中运⾏make$ makeHello Makefile!这⾥可以执⾏多条 Shell 命令!3.3 条件判断条件判断的关键字主要有 ifeq ifneq ifdef ifndef语法:<conditional-directive><text-if-true>endif# 或者<conditional-directive><text-if-true>else<text-if-false>endif⽰例: ifeq的例⼦, ifneq和ifeq的使⽤⽅法类似, 就是取反# Makefile 内容all:ifeq ("aa", "bb")@echo "equal"else@echo "not equal"endif# bash 中执⾏make$ makenot equal⽰例: ifdef的例⼦, ifndef和ifdef的使⽤⽅法类似, 就是取反# Makefile 内容SRCS := program.call:ifdef SRCS@echo $(SRCS)else@echo "no SRCS"# bash 中执⾏make$ makeprogram.c3.4 Makefile 中的函数Makefile 中⾃带了⼀些函数, 利⽤这些函数可以简化 Makefile 的编写.函数调⽤语法如下:$(<function> <arguments>)# 或者${<function> <arguments>}<function> 是函数名<arguments> 是函数参数3.4.1 字符串函数字符串替换函数: $(subst <from>,<to>,<text>)功能: 把字符串<text> 中的 <from> 替换为 <to>返回: 替换过的字符串# Makefile 内容all:@echo $(subst t,e,maktfilt) <-- 将t替换为e# bash 中执⾏make$ makemakefile模式字符串替换函数: $(patsubst <pattern>,<replacement>,<text>)功能: 查找<text>中的单词(单词以"空格", "tab", "换⾏"来分割) 是否符合 <pattern>, 符合的话, ⽤ <replacement> 替代.返回: 替换过的字符串# Makefile 内容all:@echo $(patsubst %.c,%.o,programA.c programB.c)# bash 中执⾏make$ makeprogramA.o programB.o去空格函数: $(strip <string>)功能: 去掉 <string> 字符串中开头和结尾的空字符返回: 被去掉空格的字符串值# Makefile 内容VAL := " aa bb cc "all:@echo "去除空格前: " $(VAL)@echo "去除空格后: " $(strip $(VAL))# bash 中执⾏make去除空格前: aa bb cc去除空格后: aa bb cc查找字符串函数: $(findstring <find>,<in>)功能: 在字符串 <in> 中查找 <find> 字符串返回: 如果找到, 返回 <find> 字符串, 否则返回空字符串# Makefile 内容VAL := " aa bb cc "all:@echo $(findstring aa,$(VAL))@echo $(findstring ab,$(VAL))# bash 中执⾏make$ makeaa过滤函数: $(filter <pattern...>,<text>)功能: 以 <pattern> 模式过滤字符串 <text>, *保留* 符合模式 <pattern> 的单词, 可以有多个模式返回: 符合模式 <pattern> 的字符串# Makefile 内容all:@echo $(filter %.o %.a,program.c program.o program.a)# bash 中执⾏make$ makeprogram.o program.a反过滤函数: $(filter-out <pattern...>,<text>)功能: 以 <pattern> 模式过滤字符串 <text>, *去除* 符合模式 <pattern> 的单词, 可以有多个模式返回: 不符合模式 <pattern> 的字符串# Makefile 内容all:@echo $(filter-out %.o %.a,program.c program.o program.a)# bash 中执⾏make$ makeprogram.c排序函数: $(sort <list>)功能: 给字符串 <list> 中的单词排序 (升序)返回: 排序后的字符串# Makefile 内容all:@echo $(sort bac abc acb cab)# bash 中执⾏make$ makeabc acb bac cab取单词函数: $(word <n>,<text>)功能: 取字符串 <text> 中的第<n>个单词 (n从1开始)返回: <text> 中的第<n>个单词, 如果<n> ⽐ <text> 中单词个数要⼤, 则返回空字符串# Makefile 内容all:@echo $(word 1,aa bb cc dd)@echo $(word 5,aa bb cc dd)@echo $(word 4,aa bb cc dd)# bash 中执⾏make$ makeaadd取单词串函数: $(wordlist <s>,<e>,<text>)功能: 从字符串<text>中取从<s>开始到<e>的单词串. <s>和<e>是⼀个数字.返回: 从<s>到<e>的字符串# Makefile 内容all:@echo $(wordlist 1,3,aa bb cc dd)@echo $(word 5,6,aa bb cc dd)@echo $(word 2,5,aa bb cc dd)# bash 中执⾏make$ makeaa bb ccbb单词个数统计函数: $(words <text>)功能: 统计字符串 <text> 中单词的个数返回: 单词个数# Makefile 内容all:@echo $(words aa bb cc dd)@echo $(words aabbccdd)@echo $(words )# bash 中执⾏make$ make41⾸单词函数: $(firstword <text>)功能: 取字符串 <text> 中的第⼀个单词返回: 字符串 <text> 中的第⼀个单词# Makefile 内容all:@echo $(firstword aa bb cc dd)@echo $(firstword aabbccdd)@echo $(firstword )# bash 中执⾏make$ makeaaaabbccdd3.4.2 ⽂件名函数取⽬录函数: $(dir <names...>)功能: 从⽂件名序列 <names> 中取出⽬录部分返回: ⽂件名序列 <names> 中的⽬录部分# Makefile 内容all:@echo $(dir /home/a.c ./bb.c ../c.c d.c)# bash 中执⾏make$ make/home/ ./ ../ ./取⽂件函数: $(notdir <names...>)功能: 从⽂件名序列 <names> 中取出⾮⽬录部分返回: ⽂件名序列 <names> 中的⾮⽬录部分# Makefile 内容all:@echo $(notdir /home/a.c ./bb.c ../c.c d.c)# bash 中执⾏make$ makea.c bb.cc.cd.c取后缀函数: $(suffix <names...>)功能: 从⽂件名序列 <names> 中取出各个⽂件名的后缀返回: ⽂件名序列 <names> 中各个⽂件名的后缀, 没有后缀则返回空字符串# Makefile 内容all:@echo $(suffix /home/a.c ./b.o ../c.a d)# bash 中执⾏make$ make.c .o .a取前缀函数: $(basename <names...>)功能: 从⽂件名序列 <names> 中取出各个⽂件名的前缀返回: ⽂件名序列 <names> 中各个⽂件名的前缀, 没有前缀则返回空字符串# Makefile 内容all:@echo $(basename /home/a.c ./b.o ../c.a /home/.d .e)# bash 中执⾏make$ make/home/a ./b ../c /home/加后缀函数: $(addsuffix <suffix>,<names...>)功能: 把后缀 <suffix> 加到 <names> 中的每个单词后⾯返回: 加过后缀的⽂件名序列# Makefile 内容all:@echo $(addsuffix .c,/home/a b ./c.o ../d.c)# bash 中执⾏make$ make/home/a.c b.c ./c.o.c ../d.c.c加前缀函数: $(addprefix <prefix>,<names...>)功能: 把前缀 <prefix> 加到 <names> 中的每个单词前⾯返回: 加过前缀的⽂件名序列# Makefile 内容all:@echo $(addprefix test_,/home/a.c b.c ./d.c)# bash 中执⾏make$ maketest_/home/a.c test_b.c test_./d.c连接函数: $(join <list1>,<list2>)功能: <list2> 中对应的单词加到 <list1> 后⾯返回: 连接后的字符串# Makefile 内容all:@echo $(join a b c d,1234)@echo $(join a b c d,12345)@echo $(join a b c d e,1234)# bash 中执⾏make$ makea1 b2 c3 d4a1 b2 c3 d4 5a1 b2 c3 d4 e3.4.3 foreach语法:$(foreach <var>,<list>,<text>)⽰例:# Makefile 内容targets := a b c dobjects := $(foreach i,$(targets),$(i).o)all:@echo $(targets)@echo $(objects)# bash 中执⾏make$ makea b c da.ob.oc.od.o3.4.4 if这⾥的if是个函数, 和前⾯的条件判断不⼀样, 前⾯的条件判断属于Makefile的关键字语法:$(if <condition>,<then-part>)$(if <condition>,<then-part>,<else-part>)⽰例:# Makefile 内容val := aobjects := $(if $(val),$(val).o,nothing)no-objects := $(if $(no-val),$(val).o,nothing)all:@echo $(objects)@echo $(no-objects)# bash 中执⾏make$ makea.onothing3.4.5 call - 创建新的参数化函数语法:$(call <expression>,<parm1>,<parm2>,<parm3>...)⽰例:# Makefile 内容log = "====debug====" $(1) "====end===="all:@echo $(call log,"正在 Make")# bash 中执⾏make$ make====debug==== 正在 Make ====end====3.4.6 origin - 判断变量的来源语法:$(origin <variable>)返回值有如下类型:类型含义undefined<variable> 没有定义过default<variable> 是个默认的定义, ⽐如 CC 变量environment<variable> 是个环境变量, 并且 make时没有使⽤ -e 参数file<variable> 定义在Makefile中command line<variable> 定义在命令⾏中override<variable> 被 override 重新定义过automatic<variable> 是⾃动化变量⽰例:# Makefile 内容val-in-file := test-fileoverride val-override := test-overrideall:@echo $(origin not-define) # not-define 没有定义@echo $(origin CC) # CC 是Makefile默认定义的变量@echo $(origin PATH) # PATH 是 bash 环境变量@echo $(origin val-in-file) # 此Makefile中定义的变量@echo $(origin val-in-cmd) # 这个变量会加在make的参数中@echo $(origin val-override) # 此Makefile中定义的override变量@echo $(origin @) # ⾃动变量, 具体前⾯的介绍# bash 中执⾏make$ make val-in-cmd=val-cmdundefineddefaultenvironmentfilecommand lineoverrideautomatic3.4.7 shell语法:$(shell <shell command>)它的作⽤就是执⾏⼀个shell命令, 并将shell命令的结果作为函数的返回.作⽤和 `<shell command>` ⼀样, ` 是反引号3.4.8 make 控制函数产⽣⼀个致命错误: $(error <text ...>)功能: 输出错误信息, 停⽌Makefile的运⾏# Makefile 内容all:$(error there is an error!)@echo "这⾥不会执⾏!"# bash 中执⾏make$ makeMakefile:2: *** there is an error!. Stop.输出警告: $(warning <text ...>)功能: 输出警告信息, Makefile继续运⾏# Makefile 内容all:$(warning there is an warning!)@echo "这⾥会执⾏!"# bash 中执⾏make$ makeMakefile:2: there is an warning!这⾥会执⾏!3.5 Makefile中⼀些GNU约定俗成的伪⽬标如果有过在Linux上, 从源码安装软件的经历的话, 就会对 make clean, make install ⽐较熟悉.像 clean, install 这些伪⽬标, ⼴为⼈知, 不⽤解释就⼤家知道是什么意思了.下⾯列举⼀些常⽤的伪⽬标, 如果在⾃⼰项⽬的Makefile合理使⽤这些伪⽬标的话, 可以让我们⾃⼰的Makefile看起来更专业, 呵呵 :)伪⽬标含义all所有⽬标的⽬标,其功能⼀般是编译所有的⽬标clean删除所有被make创建的⽂件install安装已编译好的程序,其实就是把⽬标可执⾏⽂件拷贝到指定的⽬录中去print列出改变过的源⽂件tar把源程序打包备份. 也就是⼀个tar⽂件dist创建⼀个压缩⽂件, ⼀般是把tar⽂件压成Z⽂件. 或是gz⽂件TAGS更新所有的⽬标, 以备完整地重编译使⽤check 或 test⼀般⽤来测试makefile的流程。
makefile 命令行参数
-C选项可以指定Makefile所在的路径。如果我们在当前路径下执行make命令,但是Makefile文件不在当前路径下,那么就需要使用-C选项来指定Makefile所在的路径。例如:
make -C /path/to/Makefile
3. -f选项
-f选项可以指定要使用的Makefile文件名。如果我们有多个Makefile文件,那么就可以使用-f选项来指定要使用哪个Makefile文件。例如:
makefile 命令行参数
Makefile是一种用来管理代码编译的工具,它可以自动化执行编译任务,帮助程序员更高效地管理代码。在Makefile中,可以定义一系列规则来指定如何编译代码。在使用Makefile时,我们可以通过命令行参数来控制编译过程的行为。本文将详细介绍makefile命令行参数的使用方法。项
-j选项可以指定并行编译时所使用的线程数。如果我们有多个CPU核心,并且要编译大型项目,那么就可以使用-j选项来加速编译过程。例如:
make -j4
5. --dry-run选项
--dry-run选项可以模拟执行make命令,并输出将要执行的命令列表,但是并不会真正地执行这些命令。这个功能非常实用,因为我们可以预先查看将要执行的命令,确保它们是正确的。例如:
这样做的好处是,我们可以在不修改Makefile的情况下,通过命令行参数来控制编译过程的行为。
四、总结
本文介绍了Makefile命令行参数的用法,包括make命令、-C选项、-f选项、-j选项、--dry-run选项和--print-data-base选项。同时,本文还介绍了一些Makefile常用技巧,包括使用变量来存储编译选项、使用通配符来自动生成目标文件列表和使用命令行参数来控制编译过程。希望本文能够对大家理解和学习Makefile有所帮助。
makefile编写规则 ifeq
makefile编写规则 ifeq【实用版】目录1.Makefile 简介2.Makefile 编写规则3.ifeq 函数的作用4.ifeq 函数的语法5.ifeq 函数的实例6.结论正文1.Makefile 简介Makefile 是一种用于自动化构建和编译软件的脚本文件。
它通常包含一系列的规则,用于指定如何构建和编译源代码。
Makefile 的主要目的是为了简化和自动化构建过程,以便开发者能够更专注于编写代码。
2.Makefile 编写规则在 Makefile 中,编写规则通常遵循以下格式:```目标:依赖文件t命令```其中,目标表示要构建的文件,依赖文件表示构建目标所需的输入文件,命令表示用于构建目标的命令。
例如,要编译一个名为“main.c”的源文件,可以编写如下规则:```main.o: main.ctgcc -c main.c```3.ifeq 函数的作用ifeq 函数是 Makefile 中的一种条件函数,用于根据某个条件决定是否执行相应的命令。
它可以帮助开发者根据不同的环境或配置选择性地执行代码。
4.ifeq 函数的语法ifeq 函数的语法如下:```ifeq (条件)ttrue-casetfalse-caseelsetelse-caseendif```其中,条件是一个逻辑表达式,true-case 和 false-case 分别表示条件为真和假时执行的命令。
else-case 是可选的,用于表示条件不满足时执行的命令。
5.ifeq 函数的实例假设我们希望根据不同的操作系统选择不同的编译器选项,可以编写如下 Makefile 规则:```%.o: %.ctifeq ($(OS), Linux)ttgcc -o $@ $< -std=gnu99telsettgcc -o $@ $< -std=ansitendif```在这个例子中,我们使用 ifeq 函数根据当前操作系统($(OS))选择不同的编译器选项。
makefile路径规则
makefile路径规则
在Makefile中,路径的书写主要有两种方式:绝对路径和相对路径。
1. 绝对路径:从文件系统的根目录开始的路径。
例如`/home/user/`就是一个绝对路径。
在Makefile中,绝对路径通常是从构建系统的根目录开始的。
2. 相对路径:相对于当前工作目录的路径。
在Makefile中,通常使用`./`表示当前目录,`../`表示上级目录。
选择使用绝对路径还是相对路径取决于你
的项目结构和开发者的偏好。
一般来说,推荐使用相对路径,因为它们更灵活,可以适应不同的项目目录结构。
在书写路径时,还有一些规范和最佳实践需要遵循:
1. 文件名:文件名应该简洁明了,不要使用空格或其他特殊字符。
避免使用长文件名或难以理解的文件名。
2. 目录分隔符:在Linux系统中,路径的分隔符是反斜杠(`\`)。
当路径包含多个目录时,需要使用两个反斜杠(`\\` 或 `/`)。
在Makefile中,推荐使用
正斜杠(`/`),因为它在所有平台上都是通用的。
3. 自动更新:在Makefile中,可以使用`$(wildcard)`函数来匹配目录中的
文件。
例如,`$(wildcard source/.c)`将匹配source目录下的所有C源文件。
4. 构建系统根目录:在Makefile中,通常使用构建系统的根目录作为路径的起点。
这可以通过变量来实现,例如`ROOT := /path/to/build`。
makefile的基本用法以及yolov3的makefile解析
makefile的基本用法以及yolov3的makefile解析Makefile的基本用法以及YOLOv3的Makefile解析Makefile是一种用于自动化构建的文件,它定义了一系列规则和依赖关系,用于编译、链接和生成可执行文件等操作。
Makefile通常用于C/C++项目中,但它也可以用于其他编程语言。
一、Makefile的基本用法1. 规则(Rule)Makefile中的规则定义了如何生成目标文件和如何根据依赖关系重新生成目标文件。
一个规则通常由以下几部分组成:target: prerequisites[tab] command- target:目标文件,即要生成的文件。
- prerequisites:目标文件的依赖文件。
- command:生成目标文件的命令。
2. 变量(Variable)Makefile中的变量用于存储值,可以在规则中引用。
常见的变量有以下几种:- CC:C/C++编译器。
- CFLAGS:编译选项。
- LDFLAGS:链接选项。
- RM:删除文件的命令。
可以通过在Makefile中定义变量来方便地修改编译和链接参数,使构建过程更加灵活。
3. 默认规则(Default Rule)Makefile中可以定义一个默认规则,当使用make命令时,会自动执行默认规则中定义的命令。
默认规则的语法如下:.PHONY: allall: target- .PHONY:伪目标,表示该规则是一个伪目标。
- all:默认规则的名字。
- target:默认规则要生成的目标文件。
4. 命令行变量在执行make命令时,可以通过命令行参数传递变量的值。
例如,make CC=gcc可以将CC变量的值设置为gcc。
5. clean规则clean规则用于删除生成的目标文件和其他中间文件,以便重新构建项目。
通常的写法是:clean:[tab] (RM) target这里的(RM)是一个预定义变量,表示删除文件的命令(通常为rm -f)。
makefile编写规则 ifeq
makefile编写规则 ifeqifeq是Makefile中的一个条件语句,用于判断给定的两个参数是否相等,如果相等则执行后续的指令。
ifeq语句的基本语法如下:ifeq (参数1, 参数2)指令1else指令2endif其中,参数1和参数2可以是任意字符串或者变量。
一般来说,参数1可以是一个Makefile变量的值,参数2可以是一个常量或者字符串。
ifeq语句在Makefile中非常有用,它可以根据不同的条件执行相应的动作,例如选择不同的编译器、设置不同的编译选项等。
下面是一个具体的例子,展示了如何使用ifeq语句:```Makefileifeq ($(CC), gcc)CFLAGS += -std=c99elseCFLAGS += -std=c11endififeq ($(OS), Windows_NT)RM = del /f /qelseRM = rm -fendifall:$(CC) $(CFLAGS) -o program program.cclean:$(RM) program```在上面的例子中,我们使用ifeq语句判断变量$(CC)的值是否为"gcc",如果是则给变量CFLAGS添加编译选项"-std=c99",否则添加"-std=c11"。
这样就能根据不同的编译器选择不同的编译选项。
另外,我们还使用ifeq语句判断变量$(OS)的值是否为"Windows_NT",如果是则将删除文件的命令设置为"del /f /q",否则设置为"rm -f"。
这样就能在不同的操作系统上使用相应的删除命令。
最后,我们定义了两个目标,分别是"all"和"clean"。
"all"目标使用$(CC)编译$(CFLAGS)选项将program.c文件编译为可执行程序"program";"clean"目标使用$(RM)命令删除"program"文件。
makefile 语法
makefile 语法Makefile是一种常用的构建工具,用于自动化构建和管理软件项目。
它是一种文本文件,包含一系列规则,用于指定如何编译、链接和构建源代码。
本文将介绍 Makefile 的语法和使用方法。
一、Makefile 的基本语法Makefile 文件由一系列规则组成,每个规则由一个目标和一个或多个依赖项组成。
目标是要生成的文件名,依赖项是生成目标所需要的文件或命令。
当目标文件不存在或依赖项的时间戳比目标文件的时间戳更晚时,Makefile 将自动执行规则中的命令,生成目标文件。
一个简单的 Makefile 示例:```hello: main.cgcc -o hello main.c```这个 Makefile 包含了一个规则,目标是 hello,依赖项是main.c。
当 main.c 文件的时间戳比 hello 文件的时间戳更晚时,Makefile 将执行 gcc 命令编译 main.c 文件,并生成可执行文件hello。
Makefile 的规则语法如下:```target: dependenciescommand1command2...```其中,target 是规则的目标,dependencies 是规则的依赖项,command1、command2 等是要执行的命令。
命令必须以一个制表符或多个空格开头,否则 Makefile 将无法识别。
二、Makefile 的变量Makefile 中可以定义变量,用于存储常用的值或命令。
变量以$ 符号开头,可以在规则中使用。
变量的定义语法如下:```VARNAME = value```或者```VARNAME := value```其中,等号和冒号加等号的区别在于,等号定义的变量是递归展开的,而冒号加等号定义的变量是简单展开的。
递归展开的变量可以包含其他变量的引用,而简单展开的变量只能包含直接的值。
示例:```CC = gccCFLAGS = -Wall -O2hello: main.c$(CC) $(CFLAGS) -o hello main.c```这个 Makefile 中定义了两个变量 CC 和 CFLAGS,用于存储编译器和编译选项。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
记住,make并不管命令是怎么工作的,他只管执行所定义的命令。
make会比较targets文件和prerequisites文件的修改日期,如果prerequisites文件的日期要比targets文件的日期要新,
另一个设置文件搜索路径的方法是使用make的“vpath”关键字(注意,它是全小写的),这不是变量,这是一个make的关键字,
这和上面提到的那个VPATH变量很类似,但是它更为灵活。它可以指定不同的文件在不同的搜索目录中。这是一个很灵活的功能。它的使用方法有三种:
1、vpath <pattern> <directories> 为符合模式<pattern>的文件指定搜索目录<directories>。
2、读入被include的其它Makefile。
3、初始化文件中的变量。
4、推导隐晦规则,并分析所有规则。
5、为所有的目标文件创建依赖关系链。
6、根据依赖关系,决定哪些目标要重新生成。
7、执行生成命令。
1-5步为第一个阶段,6-7为第二个阶段。第一个阶段中,如果定义的变量被使用了,那么,make会把其展开在使用的位置。
6.4 伪目标
最早先的一个例子中,我们提到过一个“clean”的目标,这是一个“伪目标”,
波浪号(“~”)字符在文件名中也有比较特殊的用途。如果是“~/test”,这就表示当前用户的$HOME目录下的test目录。
objects = *.o 上面这个例子说明通符同样可以用在变量中,但并不是说[*.o]会展开,不!objects的值就是“*.o”。
Makefile中的变量其实就是C/C++中的宏。如果要让通配符在变量中展开,也就是让objects的值是所有[.o]的文件名的集合,
vpath %.h ../headers
该语句表示,要求make在“../headers”目录下搜索所有以“.h”结尾的文件。(如果某文件在当前目录没有找到的话)
我们可以连续地使用vpath语句,以指定不同搜索策略。如果连续的vpath语句中出现了相同的<pattern>,
或是被重复了的<pattern>,那么,make会按照vpath语句的先后顺序来执行搜索。如:
1、如果make执行时,有“-I”或“--include-dir”参数,那么make就会在这个参数所指定的目录下去寻找。
2、如果目录<prefix>/include(一般是:/usr/local/bin或/usr/include)存在的话,make也会去找。
如果有文件没有找到的话,make会生成一条警告信息,但不会马上出现致命错误。它会继续载入其它的文件,一旦完成makefile的读取,make会再重试这些没有找到,或是不能读取的文件,如果还是不行,make才会出现一条致命信息。如果你想让make不理那些无法读取的文件,而继续执行,你可以在include前加一个减号“-”。如:
如果命令太长,你可以使用反斜框(‘\’)作为换行符。make对一行上有多少个字符没有限制。规则告诉make两件事,文件的依赖关系和如何成成目标文件。
一般来说,make会以UNIX的标准Shell,也就是/bin/sh来执行命令
6.2 在规则中使用通配符
make支持三各通配符:“*”,“?”和“[...]”。这是和Unix的B-Shell是相同的。
或者target不存在的话,那么,make就会执行后续定义的命令。
clean:
rm *.o,*.log
clean不是一个文件,它只不过是一个动作名字,有点像C语言中的lable一样,其冒号后什么也没有,
make就不会自动去找文件的依赖性,也就不会自动执行其后所定义的命令。
要执行其后的命令,就要在make命令后明显得指出这个lable的名字,比如make clean
target ... : prerequisites ...
command
target也就是一个目标文件,可以是Object File,也可以是执行文件。
prerequisites就是,要生成那个target所需要的文件或是目标。
command也就是make需要执行的命令。(任意的Shell命令)
三、引用其它的Makefile
在Makefile使用include关键字可以把别的Makefile包含进来,这很像C语言的#include,被包含的文件会原模原样的放在当前文件的包含位置。include的语法是:
include <filename>
filename可以是当前操作系统Shell的文件模式(可以保含路径和通配符)
clean :
-rm edit $(objects)
前面说过,.PHONY意思表示clean是一个“伪目标”。而在rm命令前面加了一个小减号的意思就是,也许某些文件出现问题
但不要管,继续做后面的事。当然,clean的规则不要放在文件的开头,不然会变成make的默认目标。
不成文的规矩是——“clean从来都是放在文件的最后
在include前面可以有一些空字符,但是绝不能是[Tab]键开始。include和<filename>可以用一个或多个空格隔开。举个例子,你有这样几个Makefile:a.mk、b.mk、c.mk,还有一个文件叫foo.make,以及一个变量$(bar),其包含了e.mk和f.mk,那么,下面的语句:
make的工作过程:
1、make会在当前目录下找名字叫“Makefile”或“makefile”的文件。
2、如果找到,它会找文件中的第一个目标文件(target)
3、如果target文件不存在,或是target所依赖的后面的 .o 文件的文件修改时间要比target这个文件新,
那么,他就会执行后面所定义的命令来生成target这个文件。
那么,你可以这样:objects := $(wildcard *.o),这种用法由关键字“wildcard”指出,关于Makefile的关键字
6.3 文件搜寻路径
在一些大的工程中,有大量的源文件,我们通常的做法是把这许多的源文件分类,并存放在不同的目录中。所以,当make需要去找寻文件的依赖关系时,你可以在文件前加上路径,但最好的方法是把一个路径告诉make,让make在自动去找。
那么whatever.c,就会是whatever.o的依赖文件。并且 cc -c whatever.c 也会被推导出来
类似:main.o : main.c defs.h
cc -c main.c 这样的编译就可以不用写,让make自动推导
.PHONY : clean
建议不要使用这个环境变量,因为只要这个变量一被定义,那么当你使用make时,所有的Makefile都会受到它的影响,有时候Makefile出现了怪事,可以看看当前环境中有没有定义这个变量。
五、make的工作方式
GNU的make工作时的执行步骤入下:(想来其它的make也是类似)
1、读入所有的Makefile。
include foo.make *.mk $(bar) 等价于:include foo.make a.mk b.mk c.mk e.mk f.mk
make命令开始时,会把找寻include所指出的其它Makefile,并把其内容安置在当前的位置。就好像C/C++的#include指令一样。如果文件都没有指定绝对路径或是相对路径的话,make会在当前目录下首先寻找,如果当前目录下没有找到,那么,make还会在下面的几个目录下找:
-include <filename>
其表示,无论include过程中出现什么错误,都不要报错继续执行。和其它版本make兼容的相关命令是sinclude,其作用和这一个是一样的。
四、环境变量 MAKEFILES
如果你的当前环境中定义了环境变量MAKEFILES,那么,make会把这个变量中的值做一个类似于include的动作。这个变量中的值是其它的Makefile,用空格分隔。只是,它和include不同的是,从这个环境变中引入的Makefile的“目标”不会起作用,如果环境变量中定义的文件发现错误,make也会不理。vpath %.c f源自ovpath % blish
vpath %.c bar
其表示“.c”结尾的文件,先在“foo”目录,然后是“blish”,最后是“bar”目录。
vpath %.c foo:bar
vpath % blish
而上面的语句则表示“.c”结尾的文件,先在“foo”目录,然后是“bar”目录,最后才是“blish”目录。
所以一定要让make知道你的最终目标是什么。一般来说,定义在Makefile中的目标可能会有很多,但是第一条规则中的目标将被
确立为最终的目标。如果第一条规则中的目标有很多个,那么,第一个目标会成为最终的目标。
6.1 规则的语法
targets : prerequisites
command
或是这样:
2、vpath <pattern> 清除符合模式<pattern>的文件的搜索目录。
3、vpath 清除所有已被设置好了的文件搜索目录。
vapth使用方法中的<pattern>需要包含“%”字符。“%”的意思是匹配零或若干字符,例如,“%.h”表示所有以“.h”结尾的文件。<pattern>指定了要搜索的文件集,而<directories>则指定了<pattern>的文件集的搜索的目录。例如:
makefile的注释:
Makefile中只有行注释,和UNIX的Shell脚本一样,其注释是用“#”字符,这个就像C/C++中的“//”一样。