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命令，包括编译、链接、拷贝等操作。

linux makefile编写规则（原创实用版）目录一、Makefile 简介二、Makefile 的规则1.目标文件2.依赖文件3.命令三、Makefile 中的变量1.通用变量2.局部变量四、Makefile 中的路径1.源文件路径2.目标文件路径3.库文件路径五、Makefile 编写实例六、总结正文一、Makefile 简介Makefile 是一个用于自动化构建和编译软件的脚本文件，通常在Linux 系统中使用。

它可以帮助开发者管理源代码，以及确定哪些文件需要编译，如何编译，以及编译后的文件如何链接。

通过编写 Makefile，开发者可以轻松地构建和维护复杂的软件项目。

Makefile 主要包括三类规则：目标文件、依赖文件和命令。

1.目标文件目标文件是 Makefile 中要生成的文件，可以是对象文件、库文件或执行文件。

在 Makefile 中，目标文件通常以“target”关键字开头，后面跟要生成的文件名。

例如：“target = main.o”。

2.依赖文件依赖文件是 Makefile 中要生成目标文件所需要的其他文件，通常是源代码文件。

在 Makefile 中，依赖文件通常以“prerequisites”关键字开头，后面跟要依赖的文件名。

例如：“prerequisites = a.c b.c”。

3.命令命令是用来生成目标文件的命令，通常是编译器或链接器。

在Makefile 中，命令通常以“command”关键字开头，后面跟要执行的命令。

例如：“command = gcc -o main.o a.c b.c”。

三、Makefile 中的变量Makefile 中的变量可以用于存储常量值，以便在 Makefile 中多次使用。

变量分为通用变量和局部变量。

1.通用变量通用变量是在整个 Makefile 中都可以使用的变量。

通用变量通常在Makefile 的开头定义，使用“define”关键字。

windows下makefile命令详解1. 如果已经有vc6的dsp⼯程，可直接导出nmake脚本⽂件(.mak)“Project - Export Makefile...”nmake -f nMakeTest.mak CFG="nMakeTest - Win32 Debug"nmake -f nMakeTest.mak CFG="nMakeTest - Win32 Debug" allnmake -f nMakeTest.mak CFG="nMakeTest - Win32 Release" clean注：如果未指定/F选项，则使⽤当前⽬录下的名为makefile的⽂件【nmake /?】获取更多帮助！ vc6：【D:\program files\Microsoft Visual Studio\VC98\Bin】vs2008：【D:\program files\Microsoft Visual Studio 9.0\VC\bin】为了能正确地使⽤命令⾏⼯具及vc6或vs2008下的函数库，需要对⼀些环境变量进⾏设置，最快捷地⽅式是通过如下⽅式打开命令⾏窗⼝（以vs2008为例）：2. vs的c++⼯程没有提供导出nmake脚本⽂件的功能，我们只有借助⼯具或⼿动编写nmake脚本⽂件了++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++3. rc.exe 【将.rc资源⽂本转变成.res⼆进制⽂件】/l 0x804 // 默认语⾔ID(⼗六进制数表⽰) 0x804:简体中⽂ 0x409:美国/fo"nMakeTest.res" // 指定rc⽂件输出的res名称例：rc.exe /l 0x804 /fo"nMakeTest.res" /d "_DEBUG" /d "_AFXDLL" “nMakeTest.rc”4. cl.exe 常见选项【将.c，.cpp，.cxx编译成obj⽂件】/nologo // 不打印版权申明信息/I "../include" // 添加头⽂件查找路径（如果路径中带有空格，⼀定要⽤引号括起来）/DWIN32 // 预编译宏定义(win32程序)/D_CONSOLE // 预编译宏定义（控制台程序）/D "_DEBUG" // 预编译宏定义（Debug版本）/D_CRT_SECURE_NO_DEPRECATE // 预编译宏定义（关闭C4996警告。

Linux 2.6 （PC）简单驱动Makefile详解ifneq ($(KERNELRELEASE),)module-objs := book.oobj-m := book.oelseKERNELDIR ?= /lib/modules/$(shell uname -r)/buildPWD := $(shell pwd)modules:$(MAKE) -C $(KERNELDIR) M=$(PWD) modulesendifclean:rm -rf *.o *~core.depend.*.cmd *.ko *.mod.c.tmp versionsKERNELRELEASE 内核顶层目录Makefile的一个变量。

KERNELDIR ?= /lib/modules/$(shell uname -r)/build内核源码树目录。

该Makefile 共读取两次，在输入Makefile时，$(KERNELDIR) 第一次读取KERNELRELEASE并没有被定义，然后就开始读取内核源码的目录，开始定义KERNELRELEASE，然后到当前模块的目录里面，M=$(PWD) 进入该Makefile时KERNELRELEAS已经被定义了，读取要编译的模块，然后再返回到modules编译完成，产生.KO文件Linux 2.6 （ARM）简单驱动Makefile详解ifneq ($(KERNELRELEASE),)obj-m := fgpio011.oelseKDIR := /dsw/8126/arm-linux-2.6.28/linux-2.6.28-fa/all:make -C $(KDIR) M=$(PWD) modules ARCH=armCROSS_COMPILE=arm-none-linux-gnueabi-clean:rm -f *.ko *.o *.mod.o *.mod.c *.symversendif注释：KDIR := /dsw/8126/arm-linux-2.6.28/linux-2.6.28-fa/ KDIR 指定开发板内核所在目录。

makefile中ifdef的用法题目: makefile中的ifndef的用法一、什么是makefile？Makefile是一种用来管理和构建项目的文件，它由一系列的规则组成，指定了如何编译和链接源代码以生成最终的可执行文件或库文件。

Makefile通常用于源代码非常复杂或需要跨平台构建的项目。

二、makefile的条件编译在编写makefile时，我们经常需要根据不同的条件执行特定的编译选项或构建命令。

条件编译是通过使用预处理指令来实现的。

makefile支持两种常用的条件编译指令：ifdef和ifndef。

三、ifndef指令的用法ifndef是"if not defined"的缩写，用于检查某个变量是否已定义。

如果该变量未定义，就执行ifdef指令中的一组命令。

在makefile中，我们可以使用ifndef指令来检查环境变量、宏定义或其他makefile中定义的变量是否已定义。

如果未定义，我们可以执行一组命令来设置默认值或终止构建。

以下是ifndef指令的基本语法：ifndef variable_namecommand1command2...endif四、ifndef指令的示例下面以一个简单的示例来说明ifndef指令的用法。

假设我们正在构建一个C语言项目，并且希望根据操作系统的类型设置不同的编译选项。

在这种情况下，我们可以使用ifndef指令来检查操作系统的环境变量，并根据其值设置不同的编译选项。

以下是一个makefile的示例：ifndef OS(error The OS variable is not defined!)endififeq ((OS), Windows)CC = gccCFLAGS = Wall DWINDOWSelse ifeq ((OS), Linux)CC = gccCFLAGS = Wall DLINUXelse ifeq ((OS), Mac)CC = clangCFLAGS = Wall DMACelse(error Unsupported operating system: (OS))endifall:(CC) (CFLAGS) main.c o my_program在这个示例中，我们首先使用ifndef指令检查OS变量是否已定义。

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变量设置为空。

make的主要用法Make是一个常用的构建工具，它可以自动化地编译程序、生成文档、打包发布等操作。

Make最初是Unix系统下的一个工具，现在已经被广泛地应用于各种平台和语言中。

一、Make的基本概念1.1 MakefileMakefile是Make的配置文件，它描述了如何构建目标文件。

Make会根据Makefile中的规则来判断哪些文件需要重新编译，以及如何编译它们。

1.2 目标文件目标文件是指要生成的文件，可以是可执行程序、静态库、动态库等。

在Makefile中，每个目标都有一个对应的规则来描述如何生成它。

1.3 依赖关系依赖关系指的是目标文件与源文件之间的关系。

如果一个目标文件依赖于另外一个文件，那么在生成这个目标文件之前必须先生成它所依赖的那个文件。

1.4 规则规则描述了如何从源代码生成目标代码。

规则由三部分组成：目标、依赖和命令。

其中，目标表示要生成的文件，依赖表示该目标所依赖的其他文件，命令表示如何从依赖中生成目标。

二、Makefile语法2.1 变量定义变量可以用来存储一些常用的值，比如编译器、编译选项等。

变量的定义格式为：变量名=变量值。

2.2 目标规则目标规则描述了如何生成一个目标文件。

目标规则的格式为：目标: 依赖命令其中，目标表示要生成的文件，依赖表示该目标所依赖的其他文件，命令表示如何从依赖中生成目标。

2.3 伪目标伪目标是指不对应任何实际文件的目标，它们通常用来描述一些特殊的操作，比如清空临时文件、打包发布等。

伪目标的名称前面要加上一个“.”号。

2.4 函数Make提供了一些内置函数来方便我们编写Makefile。

常用的函数有：$(wildcard pattern)、$(patsubst pattern,replacement,text)、$(subst from,to,text)等。

三、Makefile实例下面是一个简单的Makefile示例：CC=gccCFLAGS=-Wall -gLDFLAGS=-lmall: hello_world.exehello_world.exe: hello_world.o$(CC) $(LDFLAGS) $< -o $@hello_world.o: hello_world.c$(CC) $(CFLAGS) -c $< -o $@clean:rm -f *.o *.exe这个Makefile定义了三个变量：CC表示编译器，CFLAGS表示编译选项，LDFLAGS表示链接选项。

MakeFile 文件的作用makefile文件保存了编译器和连接器的参数选项,还表述了所有源文件之间的关系(源代码文件需要的特定的包含文件,可执行文件要求包含的目标文件模块及库等).创建程序(make程序)首先读取makefile文件,然后再激活编译器,汇编器,资源编译器和连接器以便产生最后的输出,最后输出并生成的通常是可执行文件.创建程序利用内置的推理规则来激活编译器,以便通过对特定CPP文件的编译来产生特定的OBJ文件.附上原文:Experienced programmers are familiar with makefiles. A makefile stores compiler and linker options and expresses all the interrelationships among source files. (A source code file needs specific include files, an executable file requires certain object modules and libraries, and so forth.) A make program reads the makefile and then invokes the compiler, assembler, resource compiler, and linker to produce the final output, which is generally an executable file. The make program uses built-in inference rules that tell it, for example, to invoke the compiler to generate an OBJ file from a specified CPP file.一、Makefile里有什么？Makefile里主要包含了五个东西：显式规则、隐晦规则、变量定义、文件指示和注释。

makefile -d 用法摘要：1.Makefile 简介2.makefile -d 用法详解a.参数含义b.使用方法c.实例演示3.makefile -d 在实际项目中的应用4.总结正文：Makefile 是一个项目管理工具，主要用于自动化构建和编译软件项目。

在Makefile 中，我们可以定义一系列的规则，用于描述软件项目各文件的依赖关系以及编译命令等。

今天，我们将详细了解一下makefile -d 的用法。

1.Makefile 简介首先，让我们简要了解一下Makefile 的基本概念。

Makefile 是一个包含一系列命令和规则的文本文件，通常位于项目的根目录下。

它告诉make 命令如何自动构建、编译和链接项目。

2.makefile -d 用法详解接下来，我们将详细解释makefile -d 的参数含义、使用方法和实例演示。

a.参数含义-d 选项是makefile 的调试模式，它会在执行规则之前输出规则的详细信息，便于开发者调试和理解Makefile 的执行过程。

b.使用方法要使用makefile -d 选项，只需在调用make 命令时添加-d 参数即可，如下所示：```make -d```c.实例演示下面，我们通过一个简单的实例来演示如何使用makefile -d。

假设我们有一个名为`example.mk`的Makefile，其内容如下：```all: main.occ main.o -o mainmain.o: main.ccc main.c -o main.o```现在，我们使用make -d 命令来执行Makefile：```make -d```执行结果如下：```make: Entering directory `."main.mk:3: recipe for target "all"main.mk:3: cc main.o -o mainmake: Leaving directory `."```从输出结果中，我们可以看到makefile -d 选项输出了规则的详细信息。

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生成依赖关系的方法。

二、什么是makefilemakefile是一个包含规则和命令的文本文件，用来描述软件项目的编译过程。

它告诉make工具，如何去利用源文件生成目标文件。

makefile通常包含了以下内容：1. 目标（target）：表示要生成的文件，可以是可执行文件、中间文件或其他类型的文件。

2. 依赖（dependencies）：表示目标文件所依赖的源文件或其他文件。

3. 命令mands）：表示生成目标文件的具体操作，通常是编译、信息等。

三、makefile生成依赖关系的原理在编译过程中，一个源文件可能会依赖于其他源文件或头文件，当这些依赖关系发生变化时，我们需要重新编译相关的文件。

makefile 生成依赖关系的原理就是通过分析源文件中的#include语句，自动识别出文件之间的依赖关系，并生成相应的规则。

1. 使用gcc的-M选项gcc是一个非常流行的编译器，在编译过程中，它提供了-M选项来生成依赖关系。

例如：```make.o: .cgcc -c $< -o $ -MMD -MF $*.d```这里，-MMD选项表示生成依赖关系文件，-MF选项指定了依赖关系文件的名称。

通过这样的makefile规则，gcc能够自动生成每个源文件的依赖关系。

2. 使用自定义脚本除了使用gcc的-M选项外，我们也可以编写一个自定义的脚本来生成依赖关系。

这样能够更加灵活地控制依赖关系的生成过程。

五、makefile生成依赖关系的优势1. 自动化：makefile能够自动分析源文件之间的依赖关系，不需要手动维护依赖关系。

2. 灵活性：makefile生成依赖关系的方法非常灵活，可以根据实际需要选择不同的生成方式。

makefile的工作原理Makefile是软件开发中常用的构建工具，它可以根据项目中的依赖关系和规则来自动化构建和管理项目。

下面是Makefile的工作原理的详细解释，分为以下步骤：1. 读取Makefile：Makefile是一个文本文件，记录了项目中的目标、依赖关系和构建规则。

在使用make命令时，系统会读取当前目录下的Makefile文件。

2. 解析目标和依赖关系：Makefile中的每一行都由目标和依赖关系组成。

解析器会解析这些目标和依赖关系，并将它们保存在内部数据结构中，以便后续使用。

3. 检查目标是否需要重新构建：构建过程中，Makefile会检查目标文件和依赖文件的时间戳，来确定是否需要重新构建。

如果目标文件不存在、依赖文件的时间戳比目标文件新，或者依赖文件有更新，则需要重新构建目标。

4. 构建目标：如果目标需要重新构建，Makefile会执行相关的构建规则。

构建规则由一系列命令组成，用于编译源代码、链接目标文件等。

Makefile会按照规则中定义的顺序依次执行这些命令，完成目标的构建。

5. 更新目标的时间戳：构建完成后，Makefile会更新目标文件的时间戳，以便下一次构建时进行比较。

6. 检查下游目标：构建完成一个目标后，Makefile会检查该目标是否是其他目标的依赖。

如果是，则会重复步骤3-5，以构建下游目标。

7. 构建完成：当所有目标都构建完成后，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.am详解实战Makefile.amMakefile.am是⼀种⽐Makefile更⾼层次的规则。

只需指定要⽣成什么⽬标，它由什么源⽂件⽣成，要安装到什么⽬录等构成。

表⼀列出了可执⾏⽂件、静态库、头⽂件和数据⽂件，四种书写Makefile.am⽂件个⼀般格式。

表 1Makefile.am⼀般格式对于可执⾏⽂件和静态库类型，如果只想编译，不想安装到系统中，可以⽤noinst_PROGRAMS代替bin_PROGRAMS，noinst_LIBRARIES代替lib_LIBRARIES。

Makefile.am还提供了⼀些全局变量供所有的⽬标体使⽤：表 2 Makefile.am中可⽤的全局变量在Makefile.am中尽量使⽤相对路径，系统预定义了两个基本路径：表 3Makefile.am中可⽤的路径变量在上⽂中我们提到过安装路径，automake设置了默认的安装路径：1)标准安装路径默认安装路径为：$(prefix) = /usr/local，可以通过./configure --prefix=的⽅法来覆盖。

其它的预定义⽬录还包括：bindir = $(prefix)/bin, libdir = $(prefix)/lib, datadir = $(prefix)/share, sysconfdir = $(prefix)/etc等等。

2) 定义⼀个新的安装路径⽐如test, 可定义testdir = $(prefix)/test, 然后test_DATA =test1 test2，则test1，test2会作为数据⽂件安装到$(prefix)/ /test⽬录下。

我们⾸先需要在⼯程顶层⽬录下（即project/）创建⼀个Makefile.am来指明包含的⼦⽬录：SUBDIRS=src/lib src/ModuleA/apple/shell src/ModuleA/apple/coreCURRENTPATH=$(shell /bin/pwd)INCLUDES=-I$(CURRENTPATH)/src/include -I$(CURRENTPATH)/src/ModuleA/apple/includeexport INCLUDES由于每个源⽂件都会⽤到相同的头⽂件，所以我们在最顶层的Makefile.am中包含了编译源⽂件时所⽤到的头⽂件，并导出，见蓝⾊部分代码。

详解Makefile函数的语法与使⽤使⽤函数:在Makefile中可以使⽤函数来处理变量，从⽽让我们的命令或是规则更为的灵活和具有智能。

make所⽀持的函数也不算很多，不过已经⾜够我们的操作了。

函数调⽤后，函数的返回值可以当做变量来使⽤。

⼀、函数的调⽤语法函数调⽤，很像变量的使⽤，也是以“$”来标识的，其语法如下：$(<function> <arguments> )或是${<function> <arguments>}这⾥，<function>就是函数名，make⽀持的函数不多。

<arguments>是函数的参数，参数间以逗号“,”分隔，⽽函数名和参数之间以“空格”分隔。

函数调⽤以“”开头，以圆括号或花括号把函数名和参数括起。

感觉很像⼀个变量，是不是？函数中的参数可以使⽤变量，为了风格的统⼀，函数和变量的括号最好⼀样，如使⽤“(subst a,b,(x))”这样的形式，⽽不是“(subst a,b,${x})”的形式。

因为统⼀会更清楚，也会减少⼀些不必要的⿇烦。

还是来看⼀个⽰例：comma:= ,empty:=space:= (empty) (empty)foo:= a b cbar:= (subst (space),(comma),(foo))在这个⽰例中，(comma)的值是⼀个逗号。

(space)使⽤了(empty)定义了⼀个空格，(foo)的值是“a b c”，(bar)的定义⽤，调⽤了函数“subst”，这是⼀个替换函数，这个函数有三个参数，第⼀个参数是被替换字串，第⼆个参数是替换字串，第三个参数是替换操作作⽤的字串。

这个函数也就是把(foo)中的空格替换成逗号，所以$(bar)的值是“a,b,c”。

⼆、字符串处理函数$(subst <from>,<to>,<text> )名称：字符串替换函数——subst。

makefile语法详解Makefile 是一种构建自动化工具，它用于管理源代码的编译顺序和依赖关系。

Makefile 使得程序员能够简化构建过程、自动处理依赖关系、并增强项目的可读性和可理解性。

Makefile 使用一些特定语法来实现这些功能，这篇文章将带领大家逐步学习 Makefile 的语法。

1. 行尾分隔符在 Makefile 中，行尾的分隔符是一个反斜杠（ \ ）。

这个符号可以将一行的内容分成多行，在下一行继续编写。

这样做不会改变命令的含义，但会使命令更易读。

2. 变量定义Makefile 中的变量可以定义用于存储字符串。

这些变量可以在整个 Makefile 中使用，方便地重用代码。

定义变量的语法是使用美元符号（ $）和括号（ ()）包含变量的名字。

例如：``` CFLAGS = -Wall -g CC = gcc ```在这个例子中，我们定义了两个变量，一个用于存储编译器选项（CFLAGS），另一个用于存储编译器名称（CC）。

3. 条件语句Makefile 支持条件语句来控制项目的编译方式。

条件语句的语法基于 ifeq、ifdef、ifndef、endif 等关键字。

例如，下面的代码段将根据目标平台指定编译器选项：``` ifndef PLATFORM $(error "You must define PLATFORM") endififeq ($(PLATFORM), WINDOWS) CFLAGS += -DWIN32 endif ```4. 函数Makefile 中的函数是一个有用的工具，可以实现在Makefile 中执行某些任务。

这些函数在规则和命令中使用，语法主要是通过 $() 实现的。

例如，$(wildcard) 函数，可以用于扩展通配符，例如：``` SOURCE_FILES = $(wildcard *.c) ```5. 模式规则Makefile 中的模式规则是一种将一类文件与另一类文件匹配的规则。