makefile 中文手册第六章 _ Makefile中的变量

合集下载

makefile中的特殊符号及关键字

makefile中的特殊符号及关键字1.常见⾃动变量和含义* ：表⽰⽬标⽂件的名称，不包含⽬标⽂件的扩展名。

+ ：表⽰所有的依赖⽂件，这些依赖⽂件之间以空格分开，按照出现的先后为顺序，其中可能包含重复的依赖⽂件。

< ：表⽰依赖项中第⼀个依赖⽂件的名称：依赖项中，所有⽬标⽂件时间戳晚的⽂件（表⽰修改过），依赖⽂件间以空格分开@ ：⽬标项中⽬标⽂件的名称^ ：依赖项中，所有不重复的依赖⽂件，以空格分开。

2.预定义变量Makefile中常⽤的变量及含义AR⽣成静态库库⽂件的程序名称arAS汇编编译器的名称asCC C语⾔编译器的名称ccCPP C语⾔预编译器的名称$(CC) -ECXX C++语⾔编译器的名称g++FC FORTRAN语⾔编译器的名称f77RM删除⽂件程序的名称rm -fARFLAGS⽣成静态库库⽂件程序的选项⽆默认值ASFLAGS汇编语⾔编译器的编译选项⽆默认值CFLAGS C语⾔编译器的编译选项⽆默认值CPPFLAGS C语⾔预编译器的编译选项⽆默认值CXXFLAGS C++语⾔编译器的编译选项⽆默认值FFLAGS FORTRAN语⾔编译器的编译选项⽆默认值3.设置搜索路径指定需要搜索的⽬录， make 会⾃动找到指定⽂件的⽬录并添加到⽂件上。

VPATH = path1:path2:...4.递归make对于规模⽐较⼤的程序，需要多个⼈在多个⽬录下进⾏开发。

如果只⽤⼀个 Makefile 来维护就会⽐较⿇烦，因此可以在每个⽬录下建⽴⾃⼰的 Makefile ，然后在总控 Makefile 中调⽤⼦⽬录的 Makefile ⽂件。

⽬录结构如下：.├── add│├── add_float.c│├── add.h│├── add_int.c│└── Makefile├── main.c├── Makefile└── sub├── Makefile├── sub_float.c├── sub.h└── sub_int.c1.递归调⽤的⽅式add：cd add && $(MAKE)它等价于add：$(MAKE) -C add2.总控MakefileCC = gccCFLAGS = -O2TARGET = cacuexport OBJSDIR = $(shell pwd)/objs$(TARGET):$(OBJSDIR) main.o$(MAKE) -C add$(MAKE) -C sub$(CC) -o $(TARGET) $(OBJSDIR)/*.o$(OBJSDIR):mkdir -p $@main.o:%.o:%.c$(CC) -c $< -o $(OBJSDIR)/$@ $(CFLAGS) -Iadd -Isubclean:-$(RM) $(TARGET)-$(RM) $(OBJSDIR)/*.o如果总控 Makefile 中的⼀些变量需要传递给下层的 Makefile，可以使⽤ export 命令。

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中make指令传入的参数

makefile中make指令传入的参数Makefile中make指令传入的参数是指在执行make命令时，可以通过命令行传入的参数。

这些参数可以用于控制程序的编译、运行等行为，使得程序更加灵活和可配置。

在Makefile中，我们可以通过在命令行中输入make和参数来执行相应的操作。

参数可以是任意的字符串，可以用于指定编译选项、目标文件、源文件等等。

下面我将结合一些实际的例子，来详细讲解一下如何使用make指令传入的参数。

我们需要在Makefile中定义一些变量，用于存储传入的参数。

可以通过在命令行中使用“变量名=参数值”的方式来传入参数。

例如，我们可以定义一个变量CC，用于存储编译器的路径：```CC = gcc```在命令行中执行make命令时，可以通过“make CC=/usr/local/bin/gcc”来传入参数，将编译器的路径设置为“/usr/local/bin/gcc”。

接下来，我们可以在Makefile中使用这些参数。

例如，我们可以使用$(CC)来表示编译器的路径：```$(CC) -o target source.c```在执行make命令时，make会将$(CC)替换为实际的参数值，然后执行相应的命令。

这样，我们就可以通过命令行传入不同的编译器路径，来编译源文件。

除了编译器的路径，还可以通过命令行传入其他的参数。

例如，我们可以定义一个变量CFLAGS，用于存储编译选项：```CFLAGS = -Wall -O2```在命令行中执行make命令时，可以通过“make CFLAGS=-g”来传入参数，将编译选项设置为“-g”。

然后，我们可以在Makefile中使用这些参数。

例如，我们可以在编译命令中加入$(CFLAGS)：```$(CC) $(CFLAGS) -o target source.c```在执行make命令时，make会将$(CFLAGS)替换为实际的参数值，然后执行相应的命令。

整理后的makefile中文手册

本文比较完整的讲述GNU make工具，涵盖GNU make的用法、语法。

同时重点讨论如何为一个工程编写Makefile。

作为一个Linux程序员，make工具的使用以及编写Makefile是必需的。

系统、详细讲述make的中文资料比较少，出于对广大中文Linuxer 的支持，本人在工作之余，花了18个多月时间完成对‚info make‛的翻译整理，完成这个中文版手册。

本书不是一个纯粹的语言翻译版本，其中对GNU make的一些语法和用法根据我个人的工作经验进行了一些详细分析和说明，也加入了一些个人的观点和实践总结。

本书的所有的例子都可以在支持V3.8版本的GNU make的系统中正确执行。

由于个人水平限制，本文在一些地方存在描述不准确之处。

恳请大家在阅读过程中，提出您宝贵的意见，也是对我个人的帮助。

我的个人电子邮箱地址：xhbdahai@。

非常愿意和大家交流！共同学习。

阅读本书之前，读者应该对GNU的工具链和Linux的一些常用编程工具有一定的了解。

诸如：gcc、as、ar、ld、yacc等；同时在书写Makefile时，需要能够进行一些基本的shell编程。

这些工具是维护一个工程的基础。

如果大家对这些工具的用法不是很熟悉，可参考项目资料。

阅读本文的几点建议：1.如果之前你对GNU make没有了解、当前也不想深入的学习GNU make的读者。

可只阅读本文各章节前半部分的内容（作为各章节的基础知识）。

2.如果你已经对GNU make比较熟悉，你更需要关心此版本的新增特点、功能、和之前版本不兼容之处；也可以作为开发过程过程的参考手册。

3.之前你对GNU make没有概念、或者刚开始接触，本身又想成为一个Linux下的专业程序员，那么建议：完整学习本文的各个章节，包括了基础知识和高级用法、技巧。

GNU Make 中文手册v3.8 学习

∙这个手册翻译整理: 徐海兵, 先表示一些尊敬. “本人在工作之余，花了18个多月时间完成对“info make”的翻译整理，完成这个中文版手册”, 工夫不负有心人.∙链接器将.o文件中使用的函数和其它.o或者库文件中的相关符号进行合并，对所有文件中的符号进行重新安排（重定位），并链接系统相关文件（程序启动文件等）最终生成可执行程序。

∙Linux中，共享库文件格式通常为“ELF”格式。

共享库已经具备了可执行条件。

∙模块中各个成员的地址（变量引用和函数调用）都是相对地址。

使用此共享库的程序在运行时，共享库被动态加载到内存并和主程序在内存中进行连接。

多个可执行程序可共享库文件的代码段（多个程序可以共享的使用库中的某一个模块，共享代码，不共享数据）。

另外共享库的成员对象可被执行（由libdl.so提供支持）。

∙在make读取Makefile以后会建立一个编译过程的描述数据库。

此数据库中记录了所有各个文件之间的相互关系，以及它们的关系描述(要是我能"看"到这个数据库，就能使用程序trace，你知道一个大型的project 的makefile有多复杂)∙当使用make工具进行编译时，工程中以下几种文件在执行make时将会被编译（重新编译）：1. 所有的源文件没有被编译过，则对各个C源文件进行编译并进行链接，生成最后的可执行程序；2. 每一个在上次执行make之后修改过的C源代码文件在本次执行make时将会被重新编译；3. 头文件在上一次执行make之后被修改。

则所有包含此头文件的C源文件在本次执行make时将会被重新编译。

(这就是为什么头文件修改后，很多文件都会被重新compile的原因)∙首先书写时，可以将一个较长行使用反斜线（\）来分解为多行，这样可以使我们的Makefile书写清晰、容易阅读理解。

但需要注意：反斜线之后不能有空格（这也是大家最容易犯的错误，错误比较隐蔽）∙编译.c源文件规则的命令可以不用明确给出。

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规则：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。

gnu make中文手册【word版】76p

参考info ld了解更加详细的关于ld的说明和用法。
2
make在执行时，需要一个命名为Makefile的文件。这个文件告诉make以何种方式编译源代码和链接程序。典型地，可执行文件可由一些.o文件按照一定的顺序生成或者更新。如果在你的工程中已经存在一个活着多个正确的Makefile。当对工程中的若干源文件修改以后，需要根据修改来更新可执行文件或者库文件，正如前面提到的你只需要在shell下执行“make”。make会自动根据修改情况完成源文件的对应.o文件的更新、库文件的更新、最终的可执行程序的更新。
Once you have a precise problem you can report it in one of two ways.Either send electronic mail to:
or use our Web-based project management tool, at:
In addition to the information above, please be careful to include the version number of `make' you are using. You can get this information with the command `make --version'. Be sure also to include the type of machine and operating system you are using. One way to obtain this information is by looking at the final lines of output from the command

【重要】调用makefile(多目录嵌套调用、变量使用)

obj1 = main1.o lib.o
obj2 = main2.o lib.o
all : edit1 edit2
edit1 : $(obj1)
gcc -o./main1/edit1 ./main1/main1.o lib.o
main1.o : main1.c
$(MAKE) -C./main1
gcc -csub2.c
都很简单对吧，就一条正常的编译命令，最后是根目录下的makefile：
VPATH=./sub1 ./sub2
obj=main.o sub1.o sub2.o
edit : $(obj)
gcc -oedit main.o ./sub1/sub1.o ./sub2/sub2.o
$(MAKE) -C$(s1)
lib.o : lib.c
gcc -clib.c
edit2 : $(ob2)/main2.o lib.o
main2.o : $(s2)/main2.c
$(MAKE) -C$(s2)
main1.c和main2.c里都有主函数，需要调用lib.c里的求和函数，只是所传递的参数值不同。要求通过根目录下的makefile嵌套调用子目录下的makefile来编译，最后链接生成可执行文件edit1和edit2，最后执行edit1和edit2应该能得到两个不同的值（也就是lib.c所求得的和）。
好了，我就不贴三个源文件的C代码了，大家自己写用来测试，我就直接贴makefile的编写了。
首先是子目录sub1下的makefile：
sub1.o : sub1.c
gcc-c sub1.c
接下来是子目录sub2下的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 运算

makefile 运算
在Makefile中，可以使用一些内置的操作符和函数进行一些运算。

下面是一些常用的运算方式：1. 变量运算：- 赋值运算：使用`=` 或`:=` 进行变量赋值。

- 字符串拼接：使用`(var1)(var2)` 进行字符串拼接。

2. 算术运算：- 加法：`(shell expr (var1) + (var2))`，使用`expr`命令进行加法运算。

- 减法：`(shell expr (var1) - (var2))`，使用`expr`命令进行减法运算。

- 乘法：`(shell expr (var1) \* (var2))`，使用`expr`命令进行乘法运算。

- 除法：`(shell expr (var1) / (var2))`，使用`expr`命令进行除法运算。

3. 逻辑运算：- 比较运算：可以使用内置的条件函数`ifeq`、`ifneq`、`ifdef` 和`ifndef` 进行比较运算，返回一个条件判断结果作为变量的值。

- 逻辑运算符：可以使用逻辑运算符`&&` 和` ` 进行逻辑运算。

4. 条件判断：- 条件判断语句：使用`ifeq`、`ifneq`、`ifdef` 和`ifndef` 来进行条件判断。

- 条件赋值：可以使用条件判断来动态赋值变量。

这些是在Makefile中常用的一些运算方式，可以根据具体的需求和场景来选择合适的运算方式。

makefile 命令行参数

2. -C选项
-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四则运算标题：深入理解Makefile中的四则运算在软件开发过程中，Makefile是一个非常重要的工具，它主要用于自动化编译和链接程序。

而在Makefile中，我们可以使用一些特殊的语法进行数学运算，包括四则运算（加、减、乘、除）。

本文将详细解析Makefile 中的四则运算，帮助你更好地理解和使用这一功能。

一、Makefile中的变量与赋值在开始四则运算之前，我们首先需要了解Makefile中的变量和赋值。

在Makefile中，我们可以使用"="或者":="来为变量赋值。

其中"="表示延迟赋值，会在需要时才进行计算；而":="表示立即赋值，会在定义时就进行计算。

例如：VAR1 = 10VAR2 := 20在这段代码中，VAR1被赋值为10，VAR2被赋值为20。

二、Makefile中的四则运算在Makefile中，我们可以使用"(shell expr ...)"命令来进行四则运算。

这个命令会执行shell命令expr，并将结果返回。

以下是一些基本的四则运算示例：1. 加法：makefileSUM := (shell expr (VAR1) + (VAR2))在这个例子中，SUM会被赋值为VAR1和VAR2的和，即30。

2. 减法：makefileDIFF := (shell expr (VAR1) - (VAR2))在这个例子中，DIFF会被赋值为VAR1和VAR2的差，即-10。

3. 乘法：makefilePRODUCT := (shell expr (VAR1) \* (VAR2))注意，由于"*"在Makefile中有特殊含义，所以我们需要使用"\*"来表示乘法。

在这个例子中，PRODUCT会被赋值为VAR1和VAR2的乘积，即200。

makefile语法

# Do not:
# o use make's built-in rules and variables
#
(this increases performance and avoid hard-to-debug behavour);
# o print "Entering directory ...";
# -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.

Makefile中ifeqifneq等用法

Makefile中ifeqifneq等⽤法（1）ifeq的⽤法ifeq ($（变量名），变量值 )........else ifeq ($(..), ..).........else.........endif（2）最近在学习makefile的过程中遇到需要⽤ifeq进⾏逻辑与判断，但是ifeq并没有像其他编程语⾔那样有逻辑或（||）逻辑与（&&）的符号可⽤。

这时候需要变通⼀下。

1）逻辑与变通实现：举例说明：⽐如需要判断两个变量 VALUE1 和 VALUE2 的值都存在才执⾏某个动作，这需要逻辑与的判断C语⾔的逻辑： if ( VALUE1 && VALUE2){do something....}没有&&符号，我们可以这样变通：将两个变量链接起来再判断ifneq ($(VALUE1)$(VALUE2),)do something....endif如果变量 VALUE1 和 VALUE2 都有具体的值，⽐如需要进⾏这样的判断： VALUE1 == V1 && VALUE2 == V2, 可以按如下的写法;ifeq ($(VALUE1)_$(VALUE2), V1_V2) ### 当然中间的下划线 "_" 可以⽤其他字符代替do something....endif2）逻辑或变通实现，同样是上⾯的两个变量if( VALUE1 == V1 || VALUE2 == V2 ) {...} 可以⽤findstring函数做如下变通实现：#如果VALUE1或者VALUE2为V1或V2，则findstring 不会返回空。

ifneq ($(findstring $(VALUE1)$(VALUE2), V1 V2),)do something...endif。

makefile 中的语法和bat语法

makefile 中的语法和bat语法makefile是一种用于自动化构建程序的工具，常用于编译、链接和打包项目。

它的语法相对复杂，以下是一些常用的语法元素：1. 定义变量：VAR_NAME = value2. 定义规则：target: dependenciesaction3. 规则目标可以是文件或伪目标（即不对应任何文件），例如： clean:rm -rf $(OBJ_DIR)/*4. 使用变量：$(VAR_NAME)5. 使用命令：@command -option arg6. 依赖关系：target: dependency1 dependency2action7. 通配符：*.c 代表所有以.c为扩展名的文件bat是Windows平台上的批处理脚本语言，用于批量执行一系列Windows命令。

以下是一些常用的bat语法元素：1. 命令：command arg1 arg22. 注释：REM comment3. 变量：set VAR_NAME=value4. 变量使用：%VAR_NAME%5. 读取用户输入：set /p VAR_NAME=Prompt6. 条件语句：if condition (command1) else (command2)7. 循环语句：for %%var in (set) do (command)8. 调用其他bat文件：call other_file.bat以上是makefile和bat语法的简要说明，更详细的语法规则和用法可以参考相关的文档或教程。

makefile文件中ldflags参数的用法

makefile文件中ldflags参数的用法在Makefile文件中，`LDFLAGS`是一个用于传递链接器选项的变量。

它用于指定链接时所需的库文件、库路径和其他链接器选项。

`LDFLAGS`变量的用法如下：1. 指定库文件：LDFLAGS = -l<library_name>例如，要链接`libfoo.so`库文件，可以使用`LDFLAGS = -lfoo`。

2. 指定库路径：LDFLAGS = -L<path_to_library>例如，要指定`/usr/local/lib`作为库文件的路径，可以使用`LDFLAGS = -L/usr/local/lib`。

3. 指定多个库文件和库路径：LDFLAGS = -l<library_name1> -l<library_name2> -L<path_to_library1> -L<path_to_library2>例如，要链接`libfoo.so`和`libbar.so`两个库文件，并指定`/usr/local/lib`和`/usr/lib`作为库路径，可以使用`LDFLAGS = -lfoo -lbar -L/usr/local/lib -L/usr/lib`。

4. 指定其他链接器选项：LDFLAGS = <linker_option1> <linker_option2>例如，要指定链接器标志`-static`，可以使用`LDFLAGS = -static`。

需要注意的是，`LDFLAGS`变量的值会被传递给链接器来进行链接操作。

在Makefile文件中，链接器通常使用`$(LDFLAGS)`来引用`LDFLAGS`变量的值。

例如：$(CC) $(LDFLAGS) -o output_file input_file1input_file2其中，`$(CC)`表示C编译器，`-o output_file`指定输出文件名，`input_file1 input_file2`表示输入文件。

makefile 常用符号

makefile 常用符号Makefile是一种用于自动化构建和部署软件的工具，它使用规则和宏来描述项目的结构和编译过程。

以下是一些常用的Makefile符号：1. 目标（Targets）：Makefile中的命令执行目标。

例如，`all`、`clean`、`build`等。

2. 依赖（Dependencies）：目标所需的文件或目标。

可以使用`依赖目标`来表示一个目标依赖于另一个目标。

3. 命令（Commands）：用于生成或构建目标的命令。

可以包含多个命令，用分号分隔。

4. 通配符（Patterns）：用于匹配文件或目录的名称。

例如，`src/*.c`表示所有以`.c`结尾的文件位于`src`目录。

5. 函数（Functions）：Makefile中的自定义功能。

可以通过`定义函数名`来定义一个函数，并在需要时调用它。

6. 变量（Variables）：Makefile中的数据存储单元。

可以使用`变量名=值`的方式来定义变量，并在需要时引用它们。

7. 规则（Rules）：用于描述如何生成目标的规则。

规则由左边的目标、冒号、右边的命令和可选的`phony：`组成。

8. phony目标（Phony targets）：虚拟目标，用于绕过Makefile中的正常构建过程。

可以在phony目标后跟一个冒号，然后是实际的命令。

9. 自动变量（Automatic variables）：在构建过程中自动计算的变量。

常见的自动变量有`$@`（所有目标）、`$^`（所有依赖文件）、`$?`（已改变的依赖文件）等。

10. 模式变量（Pattern variables）：用于根据文件名匹配值来设置变量。

例如，`OBJS := obj/*.o`，这将把所有以`.o`结尾的文件编译为目标。

11. 隐含规则（Implicit rules）：Makefile中用于自动生成目标的一种机制。

当一个目标没有显式规则时，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 8.0，make的版本是3.80。

必竟，这个make是应用最为广泛的，也是用得最多的。

而且其还是最遵循于IEEE1003.2-1992标准的（POSIX.2）。

在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。