Makefile 语法分析
Makefile文件语法
Makefile⽂件语法概述本⽂将介绍Makefile种注释、回显、通配符、变量、循环判断、函数注释Makefile中只有单⾏注释,没有多⾏注释,注释以 # 开头。
以下Makefile注释⽚段节选⾃的Makefile# Makefile for installing Lua# See doc/readme.html for installation and customization instructions.# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================# Your platform. See PLATS for possible values.PLAT= noneechoing(回显)通常,make在执⾏命令⾏之前会把要执⾏的命令⾏进⾏输出。
我们称之为“回显”,就好像我们输⼊命令执⾏⼀样。
@如果要执⾏的命令⾏以字符“@”开始,则make在执⾏时这个命令就不会被回显。
典型的⽤法是我们在使⽤“echo”命令输出⼀些信息时。
如:@echo 开始编译XXX模块......当make执⾏时,将输出“开始编译XXX模块......”这个信息。
如果在命令⾏之前没有字符“@”,那么,make的输出就是:echo编译XXX模块......编译XXX模块......“-n”或“--just-print”如果使⽤make的命令⾏参数“-n”或“--just-print”,那么make执⾏时只显⽰所要执⾏的命令,但不会真正的去执⾏这些命令。
只有在这种情况下make才会打印出所有make需要执⾏的命令,其中也包括了使⽤“@”字符开始的命令。
这个选项对于我们调试Makefile⾮常有⽤,使⽤这个选项我们可以按执⾏顺序打印出Makefile中所有需要执⾏的命令。
“-s”或“--slient”make参数“-s”或“--slient”则是禁⽌所有执⾏命令的显⽰,就好像所有的命令⾏均使⽤“@”开始⼀样。
make用法总结
make用法总结Make是一个高级程序设计工具,通常用于源代码的自动化构建(编译、打包、测试、安装等)过程中。
它是在类Unix操作系统下使用的工具,因为所有的Unix遵循 POSIX 标准而支持make。
make被广泛用于各种编程语言,如C、C++、Java、Python等。
一、Make的基本语法在使用make前,我们需要先了解make语法中的一些基本概念:1. Target: 表示一个目标,可以是一个可执行文件、库文件、中间文件、目录等等。
2. Dependency: 表示一个目标所依赖的文件。
3. Rule: 表示如何从依赖生成目标的方法。
示例:```makefiletarget: dependency1 dependency2recipe```其中,“target”是一个目标,“dependency1”和“dependency2”是目标需要的依赖文件,“recipe”是构建目标的具体操作。
二、Makefile的生成make工具使用Makefile文件来指定构建目标及其依赖关系、构建规则和构建指令。
Makefile文件的一般格式为:```makefiletarget1: dependency1 dependency2 ...recipe1target2: dependency3 dependency4 ...recipe2...```在终端中执行make命令时,make工具会根据Makefile文件中的规则,自动分析所需的编译任务,并决定哪些任务需要重新编译。
三、Make的常见用法1. 编译make最常见的用法是编译C/C++源代码,将源代码编译为可执行文件。
下面是一个简单的Makefile,用于将main.c和io.c编译为可执行文件main:```makefileCC=gccCFLAGS=-Wall -pedantic -I./includeLDLIBS=-lmOBJ=main.o io.oEXEC=mainall: $(EXEC)$(EXEC): $(OBJ)$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@%.o: %.c$(CC) -c $(CFLAGS) $< -o $@```在Makefile中,我们首先定义了一些变量,比如CC表示编译器,CFLAGS表示编译选项,OBJ表示目标文件列表。
makefile--参数传递、条件判断、include(五)
makefile--参数传递、条件判断、include(五)在多个Makefile嵌套调⽤时,有时我们需要传递⼀些参数给下⼀层Makefile。
⽐如我们在顶层Makefile⾥⾯定义的打开调试信息变量DEBUG_SYMBOLS,我们希望在进⼊⼦⽬录执⾏⼦Makefile时该变量仍然有效,这是需要将该变量传递给⼦Makefile,那怎么传递呢?这⾥有两种⽅法:1. 在上层Makefile中使⽤”export”关键字对需要传递的变量进⾏声明。
⽐如:1 2DEBUG_SYMBOLS = TRUE export DEBUG_SYMBOLS当不希望将⼀个变量传递给⼦ make 时,可以使⽤指⽰符 “unexport”来声明这个变量。
export⼀般⽤法是在定义变量的同时对它进⾏声明。
如下:1export DEBUG_SYMBOLS = TRUE2. 在命令⾏上指定变量。
⽐如:1$(MAKE) -C xxx DEBUG_SYMBOLS = TRUE这样在进⼊⼦⽬录xxx执⾏make时该变量也有效。
像编程语⾔⼀样,Makefile也有⾃⼰的条件语句。
条件语句可以根据⼀个变量值来控制make的执⾏逻辑。
⽐较常⽤的条件语句是ifeq –else-endif、ifneq-else-endif、ifdef-else-endif。
ifeq关键字⽤来判断参数是否相等。
⽐如判断是否⽣成调试信息可以这么⽤:1 2 3 4 5 6ifeq ($(DEBUG_SYMBOLS), TRUE) >---CFLAGS += -g -Wall -Werror -O0 else>---CFLAGS += -Wall -Werror -O2 endifIfneq和ifeq作⽤相反,此关键字是⽤来判断参数是否不相等。
ifdef关键字⽤来判断⼀个变量是否已经定义。
后两个关键字⽤法和ifeq类似。
现在我们继续改进我们上⼀节的Makefile,上⼀节的Makefile完成Makefile的嵌套调⽤,每⼀个模块都有⾃⼰的Makefile。
window下makefile的使用
Windows下的makefile1. windows下nmake的使用为nmake、cl、link运行设置环境变量:把VS安装目录下的VC/bin设置到环境变量path 中。
2. windows下使用makefile的问题解决2.1 Fatal error U1052: ‘win32.mak’ not found stop在执行构建(nmake)命令时有时会出现如下错误:Fatal error U1052: ‘win32.mak’ not found stop解决方法:运行visual studio中的VC\bin\vcvars32.bat不要关闭命令窗口,然后在同一窗口中执行命令就不会出错。
3. nmake的命令行语法NMAKE的命令行语法语法:NMAKE [options] [macros] [targets]其中,options是NMAKE的选项,macros是在命令行中的宏定义,targets是NMAKE的目标文件列表。
选项(忽略大小写):1)/A强制重新构件所有与NMAKE的target相关的dependents,即使这些dependents 并没有过期;2)/B即使dependent与target有相同的time stamp,也重建该target。
大部分的OS中的time stamp是以2秒为单位的,如果一个2秒之内被修改,那么它的time stamp将不会有任何变化。
在这种情况下,你就需要使用该选项让NMAKE重建之。
为了预防万一,总是应该使用该选项,尽管可能会导致不必要的重建操作。
3)/C屏蔽掉大部分的NMAKE输出信息,包括:非致命错误信息,警告信息,time stamp和版权信息。
如果/C和/K选项同时存在,则/K发出的警告信息也会被干掉。
4)/D在NMAKE执行期间显示相关的信息。
包括每个文件的time stamp,依赖关系,以及类似于“文件不存在”之类的提示信息。
用于对makefile除错;5)/E使环境变量可以覆盖预定义宏;6)/F filename指定makefile的名字。
makefile循环语句
makefile循环语句【最新版】目录1.Makefile 简介2.Makefile 循环语句的作用3.Makefile 循环语句的语法4.Makefile 循环语句的示例5.Makefile 循环语句的注意事项正文1.Makefile 简介Makefile 是一种用于自动构建和编译计算机程序的脚本文件。
它最初被用于 Unix 系统,但现在也广泛应用于其他操作系统,如 Linux 和macOS。
Makefile 通过定义一系列的规则和依赖关系,自动化了软件开发的构建和编译过程,从而提高了开发效率。
2.Makefile 循环语句的作用在 Makefile 中,循环语句用于遍历一个列表,并执行相应的操作。
这使得 Makefile 具有了更强的灵活性和可扩展性,可以适应不同的构建需求。
3.Makefile 循环语句的语法Makefile 循环语句的基本语法如下:```foreach 变量名 in (列表) {# 循环体```其中,`变量名`是一个用户自定义的变量,用于存储列表中的每个元素;`列表`是一个由空格分隔的元素序列,可以是文件名、目录名等。
4.Makefile 循环语句的示例以下是一个 Makefile 循环语句的示例:```all: main.o file1.o file2.omain.o: main.c$(CC) $(CFLAGS) -c main.cfile1.o: file1.c$(CC) $(CFLAGS) -c file1.cfile2.o: file2.c$(CC) $(CFLAGS) -c file2.cclean:rm -f *.o *.elfforeach target in ($@) {ifneq ($(wildcard $(target).o), *) {$(target).o: $(target).c$(CC) $(CFLAGS) -c $(target).cendif}在这个示例中,`foreach` 语句遍历了所有以“.o”结尾的目标文件(如“main.o”、“file1.o”和“file2.o”),并针对每个目标文件执行相应的编译操作。
Makefile变量使用条件及判断使用
Makefile变量使用条件及判断使用使用变量————在Makefile中的定义的变量,就像是C/C++语言中的宏一样,他代表了一个文本字串,在Makefile中执行的时候其会自动原模原样地展开在所使用的地方。
其与C/C++所不同的是,你可以在Makefile中改变其值。
在Makefile中,变量可以使用在“目标”,“依赖目标”,“命令”或是Makefile的其它部分中。
变量的命名字可以包含字符、数字,下划线(可以是数字开头),但不应该含有“:”、“#”、“=”或是空字符(空格、回车等)。
变量是大小写敏感的,“foo”、“Foo”和“FOO”是三个不同的变量名。
传统的Makefile的变量名是全大写的命名方式,但我推荐使用大小写搭配的变量名,如:MakeFlags。
这样可以避免和系统的变量冲突,而发生意外的事情。
有一些变量是很奇怪字串,如“$<”、“$@”等,这些是自动化变量,我会在后面介绍。
一、变量的基础变量在声明时需要给予初值,而在使用时,需要给在变量名前加上“$”符号,但最好用小括号“()”或是大括号“{}”把变量给包括起来。
如果你要使用真实的“$”字符,那么你需要用“$$”来表示。
变量可以使用在许多地方,如规则中的“目标”、“依赖”、“命令”以及新的变量中。
先看一个例子:objects = program.o foo.o utils.oprogram : $(objects)cc -o program $(objects)$(objects) : defs.h变量会在使用它的地方精确地展开,就像C/C++中的宏一样,例如:foo = cprog.o : prog.$(foo)$(foo)$(foo) -$(foo) prog.$(foo)展开后得到:prog.o : prog.ccc -c prog.c当然,千万不要在你的Makefile中这样干,这里只是举个例子来表明Makefile中的变量在使用处展开的真实样子。
Makefile中一些特殊符号的意义
Makefile中⼀些特殊符号的意义在makefile中,有时会接触到⼀些以特殊字符打头的命令,⽐如@, -, +,如果之前没有接触过的话,会感觉⽐较奇怪,其实,多是⼀些为了实现特定⾏为模式⽽引⼊的标记符。
命令⾏以'@'打头的含义:在执⾏到的时候不回显相应的命令内容,只显⽰命令的输出。
命令⾏以'-'打头的含义:在执⾏到的时候如果发⽣错误(退出返回⾮零状态)时,不中断make过程。
命令⾏以'+'打头的含义: makefile中以+开头的命令的执⾏不受到 make的-n,-t,-q三个参数的影响。
我们知道,在make的时候,如果加上-n, -t, -q这样的参数,都是不执⾏相应命令的,⽽以'+'开头的命令,则⽆论make命令后⾯是否跟着三个参数,都会被执⾏。
附:make命令参数make的参数下⾯列举了所有GNU make 3.80版的参数定义。
其它版本和产商的make⼤同⼩异,不过其它产商的make的具体参数还是请参考各⾃的产品⽂档。
“-b”“-m”这两个参数的作⽤是忽略和其它版本make的兼容性。
“-B”“--always-make”认为所有的⽬标都需要更新(重编译)。
“-C <dir>;”“--directory=<dir>;”指定读取makefile的⽬录。
如果有多个“-C”参数,make的解释是后⾯的路径以前⾯的作为相对路径,并以最后的⽬录作为被指定⽬录。
如:“make –C ~hchen/test –C prog”等价于“make –C ~hchen/test/prog”。
“—debug[=<options>;]”输出make的调试信息。
它有⼏种不同的级别可供选择,如果没有参数,那就是输出最简单的调试信息。
下⾯是<options>;的取值:a —— 也就是all,输出所有的调试信息。
makefile编译流程
makefile编译流程Makefile是一种用于自动化编译的工具,它可以根据源代码文件的依赖关系自动编译出目标文件。
Makefile的编写需要遵循一定的规则和语法,下面将介绍Makefile的编译流程。
1. 编写Makefile文件Makefile文件是一个文本文件,其中包含了编译的规则和依赖关系。
在编写Makefile文件时,需要遵循一定的语法规则,如使用TAB键缩进、使用变量和函数等。
2. 执行make命令在Makefile文件所在的目录下执行make命令,make会自动读取Makefile文件,并根据其中的规则和依赖关系进行编译。
如果Makefile文件中没有指定目标,则默认编译第一个目标。
3. 分析依赖关系在执行make命令时,make会先分析Makefile文件中的依赖关系,确定哪些文件需要重新编译。
如果某个源文件被修改了,那么与之相关的目标文件也需要重新编译。
4. 编译源文件在确定需要重新编译的文件后,make会依次编译每个源文件,生成对应的目标文件。
编译过程中,make会根据Makefile文件中的规则和命令进行编译。
5. 链接目标文件在所有的源文件都编译完成后,make会将所有的目标文件链接起来,生成最终的可执行文件。
链接过程中,make会根据Makefile文件中的规则和命令进行链接。
6. 完成编译当所有的源文件都编译完成并链接成功后,make会输出编译成功的信息,并生成最终的可执行文件。
如果编译过程中出现错误,make会输出错误信息并停止编译。
总之,Makefile编译流程是一个自动化的过程,它可以大大提高编译的效率和准确性。
在编写Makefile文件时,需要注意语法规则和依赖关系,以确保编译过程的正确性。
makefile条件语嵌套使用 -回复
makefile条件语嵌套使用-回复问题的具体步骤如下:第一步:什么是makefile?在开始讨论makefile条件语嵌套的使用之前,我们先了解一下什么是makefile。
Makefile是一个包含一系列规则和命令的文本文件,它描述了源文件之间的依赖关系,以及如何编译和链接这些源文件。
通过makefile,我们可以在一个命令中一次性构建复杂的项目,而不需要手动编译每个源文件。
第二步:条件语的基本概念在makefile中,条件语可以根据一定的条件执行不同的命令或者规则。
条件语的基本语法如下:ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则else# 参数1和参数2不相等时执行的命令或规则endif通过if语句中的参数1和参数2的比较,可以决定不同条件下的执行逻辑。
第三步:条件语嵌套的基本概念与其他编程语言类似,makefile也支持条件语的嵌套使用。
通过条件语的嵌套,我们可以实现更加复杂的逻辑判断和命令执行。
例如,我们可以通过以下的方式嵌套使用if语句:ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则ifeq (参数3, 参数4)# 参数3和参数4相等时执行的命令或规则else# 参数3和参数4不相等时执行的命令或规则endifelse# 参数1和参数2不相等时执行的命令或规则endif通过条件语嵌套,我们可以实现更加复杂的逻辑判断和流程控制。
第四步:条件语嵌套的实际应用接下来,我们来看一些实际的例子,以更好地理解条件语嵌套的使用。
假设我们有一个项目,该项目可以在不同的操作系统上编译和运行。
我们可以通过条件语嵌套来实现根据操作系统的不同选择不同的编译命令。
首先,我们可以定义一个变量来表示当前操作系统的类型:OS := (shell uname -s)然后,我们可以使用条件语嵌套来根据操作系统的类型选择不同的编译命令:ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则ifeq ((OS), Linux)# 在Linux系统上执行的命令或规则else ifeq ((OS), Windows)# 在Windows系统上执行的命令或规则else ifeq ((OS), Darwin)# 在Darwin (MacOS)系统上执行的命令或规则else# 其他操作系统上执行的命令或规则endifelse# 参数1和参数2不相等时执行的命令或规则endif通过以上的例子,我们可以看到,通过条件语嵌套,我们可以根据不同的操作系统类型选择不同的编译命令,从而实现在不同操作系统上的构建和运行。
mk文件语法
mk文件语法
“MK文件语法”通常指的是Makefile文件的语法。
Makefile是一种用于自动化构建程序的工具,它描述了如何从源代码生成可执行文件或库文件。
Makefile文件使用特定的语法规则来定义构建规则、依赖关系和编译选项等。
Makefile的语法包括以下部分:
1.变量定义:使用VAR = value的形式定义变量,可以使用${VAR}引用变量
的值。
2.规则定义:使用target: dependencies的形式定义规则,其中target是要
生成的目标文件,dependencies是生成目标文件所需的依赖文件。
例如:hello: main.o utility.ogcc -o hello main.o utility.o
3.命令:定义规则之后可以跟一系列命令,用于生成目标文件。
命令会在执
行Makefile时顺序执行。
例如:%.o: %.cgcc -c $< -o $@
4.条件判断和循环:Makefile支持条件判断和循环结构,可以根据条件执行
不同的命令或重复执行一组命令。
例如:
ifeq ($(CC), gcc)CFLAGS += -O2elseCFLAGS += -O0endif
5.函数:Makefile还提供了一些内置函数,可以在变量、规则和命令中使用。
例如:$(warning "This is a warning message")
以上是Makefile语法的一些基本组成部分。
具体的语法规则和用法可能会根据不同的Makefile版本和工具而有所不同。
makefile中的gcc -c -o语法
文章标题:深度探讨makefile中的gcc -c -o语法在makefile中,gcc -c -o是一个非常重要的语法结构,用于编译源文件并生成目标文件。
在本文中,我将对这个语法进行深入探讨,帮助你更好地理解它的用途和功能,并运用到实际的项目中。
1. gcc -c -o的基本概念在makefile中,gcc -c -o用于将源文件编译成目标文件。
其中,-c表示编译但不信息,-o用于指定编译后生成的目标文件名。
这个语法结构在实际的项目中非常常见,尤其是在大型的软件开发过程中。
2. 深入理解gcc -c -o的作用通过gcc -c -o,我们可以将源文件编译成目标文件,然后再将多个目标文件信息起来,生成可执行文件。
这样的分步编译方式可以提高编译的效率,尤其是在一个项目中包含大量源文件的情况下。
另外,通过指定-o参数,我们可以自定义目标文件的生成规则和命名规范,让项目结构更加清晰和灵活。
3. 实际应用案例举一个实际的例子,比如我们有一个项目包含多个源文件,分别是main.c、function1.c和function2.c。
我们可以使用gcc -c -o将这些源文件分别编译成目标文件main.o、function1.o和function2.o,然后通过gcc将这些目标文件信息起来,生成可执行文件。
这样的分步编译方式可以提高项目的维护性和灵活性。
4. 对于gcc -c -o的个人观点和理解个人认为,gcc -c -o是一个非常实用的编译选项,尤其是在大型的软件开发项目中。
通过这个选项,我们可以更加灵活地管理项目的结构,提高编译效率,同时也让代码更加清晰和易于维护。
在实际的项目中,我经常使用这个选项来进行分步编译,以便更好地管理和组织代码。
5. 总结通过本文的深入探讨,相信你对makefile中的gcc -c -o语法有了更深入的理解。
这个语法不仅在软件开发中非常常见,而且也非常实用。
通过灵活运用这个选项,我们可以更好地管理和组织项目,提高代码的可维护性和开发效率。
Makefile经典教程(最掌握这部分足够---因为汇集全部精华)!!!!!!!!!!
Makefile经典教程0 Makefile概述什么是makefile?或许很多Winodws的程序员都不知道这个东西,因为那些Windows的IDE都为你做了这个工作,但我觉得要作一个好的和professional的程序员,makefile还是要懂。
这就好像现在有这么多的HTML的编辑器,但如果你想成为一个专业人士,你还是要了解HTML的标识的含义。
特别在Unix下的软件编译,你就不能不自己写makefile了,会不会写makefile,从一个侧面说明了一个人是否具备完成大型工程的能力。
因为,makefile关系到了整个工程的编译规则。
一个工程中的源文件不计数,其按类型、功能、模块分别放在若干个目录中,makefile定义了一系列的规则来指定,哪些文件需要先编译,哪些文件需要后编译,哪些文件需要重新编译,甚至于进行更复杂的功能操作,因为makefile就像一个Shell脚本一样,其中也可以执行操作系统的命令。
makefile带来的好处就是——“自动化编译”,一旦写好,只需要一个make命令,整个工程完全自动编译,极大的提高了软件开发的效率。
make是一个命令工具,是一个解释makefile中指令的命令工具,一般来说,大多数的IDE都有这个命令,比如:Delphi的make,Visual C++的nmake,Linux下GNU的make。
可见,makefile都成为了一种在工程方面的编译方法。
现在讲述如何写makefile的文章比较少,这是我想写这篇文章的原因。
当然,不同产商的make各不相同,也有不同的语法,但其本质都是在“文件依赖性”上做文章,这里,我仅对GNU的make进行讲述,我的环境是RedHat Linux 8.0,make的版本是3.80。
必竟,这个make是应用最为广泛的,也是用得最多的。
而且其还是最遵循于IEEE 1003.2-1992 标准的(POSIX.2)。
在这篇文档中,将以C/C++的源码作为我们基础,所以必然涉及一些关于C/C++的编译的知识,相关于这方面的内容,还请各位查看相关的编译器的文档。
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语法格式详解
什么是makefile?或许很多Winodws的程序员都不知道这个东西,因为那些Windows的IDE都为你做了这个工作,但我感觉要作一个好的和 professional的程序员,makefile仍是要懂。
这就仿佛此刻有这么多的HTML的编辑器,但若是你想成为一个专业人士,你仍是要了解 HTML的标识的含义。
特别在Unix下的软件编译,你就不能不自己写makefile了,会不会写makefile,从一个侧面说明了一个人是不是具有完成大型工程的能力。
因为,makefile关系到了整个工程的编译规则。
一个工程中的源文件不计数,其按类型、功能、模块分别放在若干个目录中,makefile定义了一系列的规则来指定,哪些文件需要先编译,哪些文件需要后编译,哪些文件需要重新编译,甚至于进行更复杂的功能操作,因为makefile就像一个Shell 脚本一样,其中也可以执行操作系统的命令。
makefile带来的好处就是——“自动化编译”,一旦写好,只需要一个make命令,整个工程完全自动编译,极大的提高了软件开发的效率。
make是一个命令工具,是一个解释makefile中指令的命令工具,一般来讲,大多数的IDE都有这个命令,比如:Delphi的make,Visual C++的nmake,Linux 下GNU的make。
可见,makefile都成了一种在工程方面的编译方式。
现在讲述如何写makefile的文章比较少,这是我想写这篇文章的原因。
当然,不同产商的make各不相同,也有不同的语法,但其本质都是在“文件依赖性”上做文章,这里,我仅对GNU的make进行讲述,我的环境是RedHat Linux ,make的版本是。
必竟,这个make是应用最为普遍的,也是用得最多的。
而且其还是最遵循于IEEE 标准的()。
在这篇文档中,将以C/C++的源码作为我们基础,所以必然涉及一些关于C/C++的编译的知识,相关于这方面的内容,还请各位查看相关的编译器的文档。
makefile 中的语法和bat语法
makefile 中的语法和bat语法Makefile 是一种用于自动化构建和管理代码的工具,它使用了自己的语法和规则来描述项目的编译和链接过程。
而 BAT (Batch) 是一种用于 Windows 系统的批处理文件,用于执行一系列命令来实现自动化任务。
本文将分别介绍 Makefile 中的语法和 BAT 语法。
一、Makefile 中的语法1. 目标与依赖关系在 Makefile 中,每一条规则包含一个目标和一组依赖。
目标表示要生成的文件,依赖表示生成目标所需要的文件或其他目标。
语法如下:```target: dependency1 dependency2 ...command1command2...```其中,target 和 dependency 可以是文件名或者其他目标名称。
command 表示生成目标的具体操作命令。
2. 变量Makefile 中可以定义变量,用于存储一些常用的值或路径。
语法如下:```VAR_NAME = value```变量的值可以是字符串或者路径等。
在规则中使用变量时,需要在变量前加上 $ 符号,例如:```target: dependencycommand $(VAR_NAME)```3. 函数Makefile 中提供了一些内置函数来处理变量和字符串。
常用的函数有:- $(wildcard pattern): 查找符合 pattern 的文件或目录。
- $(foreach var, list, text): 遍历 list 中的每个元素,将其赋值给 var,并将 text 应用到每个元素上。
- $(shell command): 执行 command 命令,并将标准输出作为函数返回值。
- ...4. 条件判断在 Makefile 中,可以使用条件语句来根据不同的条件执行不同的指令。
常用的条件语句有:- ifeq (arg1, arg2)...else...endif- ifdef var...else...endif- ...二、BAT 语法BAT 文件是包含一系列批处理命令的文本文件,用于在 Windows 系统中执行一系列自动化任务。
Android makefile编译系统 Android.mk 文件语法规范
Introduction:Android.mk编译文件是用来向Android NDK描述你的C,C++源代码文件的,这篇文档描述了它的语法。
在阅读下面的内容之前,假定你已经阅读了docs/OVERVIEW.TXT文件,了解了它们的脚色和用途。
一、概述一个Android.mk file用来向编译系统描述你的源代码。
具体来说:(1) 该文件是GNU Makefile的一小部分,会被编译系统解析一次或更多次的build系统。
因此,您应尽量减少您声明的变量,不要认为某些变量在解析过程中不会被定义。
(2) 这个文件的语法允许把你的源代码组织成模块,一个模块属下列类型之一:1) 静态库2) 共享库,且只有共享库将被安装/复制到您的应用软件包,虽然静态库能被用于生成共享库。
你可以在每一个Android.mk file中定义一个或多个模块,你也可以在几个模块中使用同一个源代码文件。
(1) 编译系统为你处理许多细节问题。
例如,你不需要在你的Android.mk中列出头文件和依赖文件。
NDK编译系统将会为你自动处理这些问题。
这也意味着,在升级NDK后,你应该得到新的toolchain/platform支持,而且不需要改变你的Android.mk文件。
注意,这个语法同公开发布的Android平台的开源代码很接近,然而编译系统实现他们的方式却是不同的,这是故意这样设计的,可以让程序开发人员重用外部库的源代码更容易。
在描述语法细节之前,咱们来看一个简单的"hello world"的例子,比如,下面的文件:sources/helloworld/helloworld.csources/helloworld/Android.mk'helloworld.c'是一个JNI共享库,实现返回"hello world"字符串的原生方法。
相应的Android.mk文件会象下面这样:LOCAL_PATH := $(call my-dir)include $(CLEAR_VARS)LOCAL_MODULE:= helloworldLOCAL_SRC_FILES := helloworld.cinclude $(BUILD_SHARED_LIBRARY)好,我们来解释一下这几行代码:LOCAL_PATH := $(call my-dir)一个Android.mk file首先必须定义好LOCAL_PATH变量。
makefile 条件编译
makefile 条件编译MakefileUnix/Linux译系统编写程序所必需的文件,其中包含了定义规则以及编译程序所必需的指令。
通常情况下,一个规则描述了从一个或多个源文件到一个或多个目标文件之间的变换过程。
在特定的编译环境中,定义的规则必须能够生成所有需要的目标文件及时准确的。
有时候,一个源文件或多个源文件具有不同的编译条件,此时Makefile件编译的技术就派上用场了。
这种技术可以根据指定的编译条件自动生成 Makefile则,使得编译器只有在满足编译条件时才会编译特定的源文件。
Makefile件编译基本依赖于 make令,它可以根据给定的源文件及编译条件,自动生成 Makefile则。
Make令使用 C言编写,可以从一个或多个文本文件中读取输入,比如源文件,然后根据相应的编译条件,使用 if句来生成 Makefile则。
要想理解 Makefile件编译,首先必须明白 Makefile几个基本概念。
Makefile 中有若干规则,每个规则由一个目标文件,一个或多个依赖文件,以及一系列的命令组成。
它们通常以三个元素表示: target: dependenciestcommands其中,target 代表目标文件,dependencies该目标文件的依赖文件,commands该目标文件生成所需的命令。
为了利用 Makefile件编译,可以将每个文件的编译条件定义为一个 Makefile量,这样 Make编译文件时就可以根据指定的编译条件来生成 Makefile则。
例如,对于两个源文件 A B,A编译条件为BUILD_A,B编译条件为 BUILD_B,只有当 BUILD_A 为真,A会被编译,当 BUILD_B 为真,B会被编译。
要实现 Makefile件编译,可以使用 Make 中的 if件语句:ifeq (BUILD_A,1)A: ../A.cpptg++ -o A ../A.cppendififeq (BUILD_B,1)B: ../B.cpptg++ -o B ../B.cppendif上面的 Makefile 中,对于 A B两个源文件,它们的编译条件分别是 BUILD_A BUILD_B,即 BUILD_A 为真时,A会被编译,BUILD_B 为真时,B会被编译。
Makefile
Makefile规则:target … : prerequisites…command……target就是一个目标文件,可以是Object File,也可以是可执行文件。
还可以是一个标签(Lable)。
prerequisites 就是要生成target所需要的文件或目标。
command 就是make需要执行的命令。
文件的依赖关系:target这一个或多个的目标文件依赖于prerequisites中的文件,其生成规则定义在command中。
如果prerequisites中的文件有一个以上的文件比target中的文件要新的话,则需要执行command定义的命令。
(Makefile规则)在Makefile中的反斜杠(\)表示换行的意思。
make命令解析Makefile文件。
如果要删除可执行文件和中间目标文件,只需要执行“make clean”。
edit : main.o kbd.o display.occ –o edit main.o kdb.o display.omain.o : main.c defs.hcc –c main.ckdb.o : kdb.c defs.hcc –c kdb.cdisplay.o : display.c defs.h command.hcc –c display.cclean:rm edit main.o kdb.o kdb.o在上个Makefile中,target(目标文件)包含:可执行文件edit和*.o(所有的中间目标文件)。
prerequisites(依赖文件)就是冒号后面的所有文件。
依赖关系:其实就是说明了目标文件是由哪些文件生成的,换言之,就是目标文件是哪些文件更新的。
make命令作用:比较target与prerequisites的日期,如果target日期比prerequisites新,不执行命令;否则(target日期不比prerequisites新或是target不存在),执行command命令,并更新或生成target。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Makefile 语法分析第一部分VERSION = 2# 给变量VERSION赋值PATCHLEVEL = 6# 给变量PATCHLEVEL赋值SUBLEVEL = 22# 给变量SUBLEVEL赋值EXTRAVERSION = .6# 给变量EXTRAVERSION赋值NAME = Holy Dancing Manatees, Batman!# 给变量NAME赋值# *DOCUMENTATION*# To see a list of typical targets execute "make help"# More info can be located in ./README# Comments in this file are targeted only to the developer, do not# expect to learn how to build the kernel reading this file.# Do not:# o use make's built-in rules and variables# (this increases performance and avoid hard-to-debug behavour);# o print "Entering directory ...";MAKEFLAGS += -rR --no-print-directory# 操作符“+=”的作用是给变量(“+=”前面的MAKEFLAGS)追加值。
# 如果变量(“+=”前面的MAKEFLAGS)之前没有定义过,那么,“+=”会自动变成“=”;# 如果前面有变量(“+=”前面的MAKEFLAGS)定义,那么“+=”会继承于前次操作的赋值符;# 如果前一次的是“:=”,那么“+=”会以“:=”作为其赋值符# 在执行make时的命令行选项参数被通过变量“MAKEFLAGS”传递给子目录下的make程序。
# 对于这个变量除非使用指示符“unexport”对它们进行声明,它们在整个make的执行过程中始终被自动的传递给所有的子make。
# 还有个特殊变量SHELL与MAKEFLAGS一样,默认情况(没有用“unexport”声明)下在整个make的执行过程中被自动的传递给所有的子make。
## -rR --no-print-directory# -r disable the built-in impilict rules.# -R disable the built-in variable setttings.# --no-print-directory。
# We are using a recursive build, so we need to do a little thinking# to get the ordering right.## Most importantly: sub-Makefiles should only ever modify files in# their own directory. If in some directory we have a dependency on# a file in another dir (which doesn't happen often, but it's often# unavoidable when linking the built-in.o targets which finally# turn into vmlinux), we will call a sub make in that other dir, and# after that we are sure that everything which is in that other dir# is now up to date.## The only cases where we need to modify files which have global# effects are thus separated out and done before the recursive# descending is started. They are now explicitly listed as the# prepare rule.# To put more focus on warnings, be less verbose as default# Use 'make V=1' to see the full commandsifdef Vifeq ("$(origin V)", "command line")KBUILD_VERBOSE = $(V)endifendififndef KBUILD_VERBOSEKBUILD_VERBOSE = 0endif# “ifdef”是条件关键字。
语法是ifdef <variable-name>;<text-if-true>; else <text-if-false>; endif # ifdef只检验一个变量是否被赋值,它并不会去推导这个变量,并不会把变量扩展到当前位置。
# “ifeq”与“ifdef”类似。
# “ifeq”语法是ifeq (<arg1>;, <arg2>;),功能是比较参数“arg1”和“arg2”的值是否相同。
## 函数origin并不操作变量的值,只是告诉你你的这个变量是哪里来的。
# 语法是:$(origin <variable>;)# origin函数的返回值有:# “undefined”从来没有定义过、“default”是一个默认的定义、“environment”是一个环境变量、# “file”这个变量被定义在Makefile中、“command line”这个变量是被命令行定义的、# “override”是被override指示符重新定义的、“automatic”是一个命令运行中的自动化变量## 应用变量的语法是:$(变量名)。
如KBUILD_VERBOSE = $(V)中的$(V)。
## KBUILD_VERBOSE的值根据在命令行中是否定义了变量V,# 当没有定义时,默认为V=O,输出为short version;可以用make V=1 来输出全部的命令。
## ifndef与ifdef语法类似,但功能恰好相反。
ifndef是判断变量是不是没有被赋值。
# Call a source code checker (by default, "sparse") as part of the# C compilation.## Use 'make C=1' to enable checking of only re-compiled files.# Use 'make C=2' to enable checking of *all* source files, regardless# of whether they are re-compiled or not.## See the file "Documentation/sparse.txt" for more details, including# where to get the "sparse" utility.ifdef Cifeq ("$(origin C)", "command line")KBUILD_CHECKSRC = $(C)endifendififndef KBUILD_CHECKSRCKBUILD_CHECKSRC = 0endif# ifdef是Makefile的条件关键字,其语法是:ifdef <variable-name>;# 如果变量<variable-name>;的值非空,那到表达式为真。
否则,表达式为假。
# ifndef也是Makefile的条将关键字,功能与ifdef相反,语法相似。
# Use make M=dir to specify directory of external module to build# Old syntax make ... SUBDIRS=$PWD is still supported# Setting the environment variable KBUILD_EXTMOD take precedenceifdef SUBDIRSKBUILD_EXTMOD ?= $(SUBDIRS)endififdef Mifeq ("$(origin M)", "command line")KBUILD_EXTMOD := $(M)endifendif# ifdef是Makefile的条件关键字,其语法是:ifdef <variable-name>;# 如果变量<variable-name>;的值非空,那到表达式为真。
否则,表达式为假。
## ifeq是Makefile的条件关键字,其语法是:ifeq (<arg1>;, <arg2>;),比较参数“arg1”和“arg2”的值是否相同。
## 操作符“:=”与操作符“+=”的功能相同,只是操作符“:=”后面的用来定义变量(KBUILD_EXTMOD)的变量M只能是前面定义好的,# 如果操作符“?=”前面的变量KBUILD_EXTMOD没有定义过,那么就将SUBDIRS赋给KBUILD_EXTMOD;# 如果定义过,则语句KBUILD_EXTMOD ?= $(SUBDIRS)什么也不做。
# kbuild supports saving output files in a separate directory.# To locate output files in a separate directory two syntaxes are supported.# In both cases the working directory must be the root of the kernel src.# 1) O=# Use "make O=dir/to/store/output/files/"## 2) Set KBUILD_OUTPUT# Set the environment variable KBUILD_OUTPUT to point to the directory# where the output files shall be placed.# export KBUILD_OUTPUT=dir/to/store/output/files/# make## The O= assignment takes precedence over the KBUILD_OUTPUT environment# variable.# KBUILD_SRC is set on invocation of make in OBJ directory# KBUILD_SRC is not intended to be used by the regular user (for now)ifeq ($(KBUILD_SRC),)# ifeq是Makefile的条件关键字,其语法是:ifeq (<arg1>;, <arg2>;),比较参数“arg1”和“arg2”的值是否相同。