Makefile常用语法与快速扫盲
Makefile 语法学习
Makefile 语法学习有稍稍在Linux 下碰过程序设计的开发者应该会知道,make 是用来将程序代码、函式库、头文件及其它资源文件build 成最终成果(即:最终的应用程序)的超强力辅助工具。
当然了,并不是非得动用到make 才能build 程序,或许有什么程序设计魔人喜欢什么都自己手动进行;但利用make 及其参考档(输入档案)Makefile 将会让整个编译工作轻松许多。
若您曾经打包过Debian Package,那么应该会发现debuan/rule 这个档案的语法和Makefile 几乎是一模一样,所以学习Makefile 的语法对于Debian Package Maintainer 而言也是一门必要的功课。
Makefile语法:以下为Makefile 的基本语法,批注:以# 开头的即为批注。
变量宣告:(有人称之为宏)语法:MACRO = value注意到,在=前后必须加上空白,而变量名称为大小写相异。
利用MACRO = 来取消该变数。
在惯例上,Makefile 内部使用的变量名称使用小写;而使用者很可能从命令行自行另外指定数值的变量,像是CFLAGS,则是使用大写。
在Makefile 中,可利用$(MACRO) 或${MACRO} 来存取已定义的变量。
例:tragets = foo$(targets): common.hgcc -o $(targets) foo.c效果等同:foo: common.hgcc -o foo foo.c:=语法注意到,make 会将整个Makefile 展开后,再决定变数的值。
也就是说,变量的值将会是整个Mackfile 中最后被指定的值。
例:x = fooy = $(x) barx = xyz# y 的值为xyz bar在上例中,y 的值将会是xyz bar,而不是foo bar。
您可以利用:= 来避开这个问题。
:= 表示变量的值决定于它在Makefile 中的位置,而不是整个Makefile 展开后最终的值。
Makefile 语法分析
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程序。
makefile的用法
makefile的用法Makefile是一种用于自动化编译程序的工具,它可以根据源代码文件的依赖关系,自动编译出最终的可执行文件。
Makefile的使用可以大大提高程序的开发效率和可维护性,下面我们来详细了解一下Makefile的用法。
一、Makefile的基本语法Makefile的基本语法由一系列规则组成,每个规则由以下几部分组成:1. 目标(Target):表示需要生成的文件名或者是一个伪目标,如clean。
2. 依赖(Prerequisites):表示生成目标所依赖的文件或者是其他目标。
3. 命令(Command):表示生成目标的具体命令。
例如,下面是一个简单的Makefile规则:```hello: main.o hello.ogcc -o hello main.o hello.omain.o: main.cgcc -c main.chello.o: hello.cgcc -c hello.c```这个Makefile规则表示需要生成一个名为hello的可执行文件,它依赖于main.o和hello.o两个目标文件。
生成hello文件的具体命令是gcc -o hello main.o hello.o。
同时,main.o和hello.o两个目标文件分别依赖于main.c和hello.c两个源代码文件,生成它们的具体命令是gcc -c main.c和gcc -c hello.c。
二、Makefile的常用命令1. make:执行Makefile文件,生成目标文件。
2. make clean:删除所有生成的目标文件。
3. make install:将生成的目标文件安装到指定的目录中。
4. make uninstall:卸载已经安装的目标文件。
5. make help:显示Makefile文件中定义的所有规则。
三、Makefile的高级用法1. 变量Makefile中可以定义变量,用于存储一些常用的参数或者路径。
makefile的语法规则
Makefile的语法规则Makefile是GNU构建系统(GNU Build System,简称GNU Make),GNU Make是一个自动化构建工具,用于构建编译程序。
Makefile由一系列语法规则构成,这些规则定义了如何从源文件生成可执行文件或其他目标文件。
基本语法目标:目标是makefile要达到的最终目的,可以是一个可执行程序、一个库文件、一个文档文件等。
依赖:依赖是目标文件所依赖的其他文件,当依赖文件发生变化时,目标文件也需要重新生成。
命令:命令是生成目标文件所需的具体操作,可以是编译、链接、拷贝等。
示例:目标:hello依赖:hello.c命令:gcc -o hello hello.c这条规则定义了如何从源文件hello.c生成可执行文件hello。
当hello.c发生变化时,make会自动执行gcc -o hello hello.c命令重新生成hello可执行文件。
变量变量用于存储信息,变量名以开头,例如:CFLAGS = -Wall -O2这条代码定义了一个名为CFLAGS的变量,值为"-Wall -O2"。
变量可以在命令中使用,例如:目标:hello依赖:hello.c命令:gcc CFLAGS -o hello hello.c这条规则中,CFLAGS变量的值被用在了gcc命令中。
函数函数用于执行特定的任务,函数名以(开头,例如:(info 目标文件是 (TARGET))这条代码定义了一个名为info的函数,当make执行这条代码时,会输出“目标文件是(TARGET)”的信息。
目標:hello依賴:hello.c命令:(CC) (CFLAGS) -o hello hello.cCC = gccCFLAGS = -Wall -O2这条规则重写了上面两个规则。
CC和CFLAGS被定义为变量,并且在命令中使用了这些变量。
当make执行这条规则时,会使用gcc编译器和-Wall -O2编译标志来编译hello.c文件,并将输出的可执行文件命名为hello。
makefile文件语法
makefile文件语法Makefile是一种用于自动化构建过程的工具,它使用一种特定的语法来定义构建规则和依赖关系。
下面是一些Makefile的基本语法规则:1. 目标(Target):目标是指要构建的程序或文件。
它通常以冒号(:)开头,后面跟着一个或多个依赖项(dependencies)。
```makefiletarget: dependenciescommands```2. 依赖项(Dependencies):依赖项是指要构建目标所必需的文件或目标。
在Makefile中,依赖项以空格分隔。
3. 命令(Commands):命令是指在构建目标时执行的命令行指令。
这些命令可以是编译、链接或其他任何必要的操作。
4. 变量(Variables):Makefile允许使用变量来存储值,以便在构建过程中重复使用。
变量以符号开头,后面跟着变量名。
```makefileVAR = value```5. 模式规则(Pattern Rules):模式规则允许根据文件模式匹配来构建目标。
它们使用通配符来匹配文件名,并在匹配的文件上执行相应的命令。
```makefiletargets : patterncommands```6. 条件语句(Conditionals):Makefile支持条件语句,可以根据条件执行不同的命令或规则。
条件使用ifdef、ifndef、ifeq等关键字定义。
7. 注释(Comments):Makefile使用井号()作为注释标记,任何在该符号之后的内容都会被视为注释,并被忽略。
8. 自动变量(Automatic Variables):Makefile提供了一些自动变量,可以在命令中使用,以获取有关目标、依赖项或文件名的信息。
例如,$表示当前目标,$<表示第一个依赖项等。
这些是Makefile的一些基本语法规则,但还有更多高级特性和用法,可以参考Make工具的文档或相关教程进行深入学习。
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版本和工具而有所不同。
linux makefile语法
linux makefile语法Makefile 是一种用于构建和管理项目的文件,特别适用于C/C++等编程语言。
下面是 Makefile 的一些常见语法:1. 变量定义:变量可以通过 `变量名 = 值` 的形式定义。
例如:`CC = gcc`。
在后续的规则中,可以通过`$(变量名)` 的形式引用变量的值。
2. 目标规则:目标规则指定了 Makefile 中的一个目标以及其依赖关系和命令。
一般的语法为:```目标: 依赖[tab]命令```其中,目标是一个文件或一个动作的名字,依赖是目标所依赖的其他文件或目标,命令是执行的操作。
命令必须以一个TAB 字符开始。
3. 通配符:在 Makefile 中,可以使用通配符来表示一组文件。
例如,`*.c` 表示所有以 `.c` 结尾的文件。
4. 伪目标:伪目标是一种特殊的目标,它不代表一个文件,而是代表一组操作。
伪目标一般用于执行一些特殊的操作,如清理文件、生成文档等。
在 Makefile 中,可以通过 `.PHONY` 关键字来定义伪目标:```.PHONY: cleanclean:[tab]rm -f *.o```5. 函数:Makefile 中也支持函数的使用。
常见的函数有:- `$(shell command)`:执行 command 命令,并返回输出结果。
- `$(wildcard pattern)`:返回符合 pattern 模式的文件列表。
- `$(patsubst pattern,replacement,text)`:将 text 中符合 pattern 模式的部分替换为 replacement。
- `$(foreach variable,list,text)`:对 list 中的每个元素,在 text 中进行替换操作。
这些只是 Makefile 的一部分语法,具体使用还需要根据具体情况和需求来灵活应用。
makefile 语法
makefile 语法makefile是一种常用的自动化构建工具,它可以帮助我们将源代码编译、链接、打包等一系列操作自动化完成。
在软件开发中,makefile 已经成为了不可或缺的工具之一。
本文将介绍 makefile的语法及其用法,希望能够帮助读者更好地理解和使用 makefile。
一、makefile 的基本语法makefile 的基本语法包括目标、依赖、命令三个要素。
下面我们来逐一介绍。
1. 目标目标是指要生成的文件,也就是 makefile 的最终输出。
目标通常是一个可执行文件、一个库文件或者一个归档文件。
在 makefile 中,目标通常以文件名的形式出现。
例如:```app: main.c func.c```这里的“app”就是目标。
2. 依赖依赖是指生成目标所需要的文件或者其他目标。
在 makefile 中,依赖通常以文件名的形式出现。
例如:```app: main.c func.c```这里的“main.c”和“func.c”就是依赖。
3. 命令命令是指生成目标所需要执行的命令。
在 makefile 中,命令通常以“TAB”键开头,并且必须与目标或者依赖之间有一个空格。
例如:```app: main.c func.cgcc main.c func.c -o app```这里的命令是“gcc main.c func.c -o app”。
二、makefile 的实例了解了 makefile 的基本语法后,我们来看一个简单的makefile 实例:```app: main.c func.cgcc main.c func.c -o app```这个 makefile 的作用是将“main.c”和“func.c”编译成一个可执行文件“app”。
如果我们在命令行中执行“make”命令,make 就会自动根据 makefile 中的规则来生成目标文件“app”。
三、makefile 的高级语法除了基本语法之外,makefile 还有一些高级语法,如变量、函数、条件语句等。
makefile笔记
makefile笔记Makefile是一个用来组织和管理程序编译和链接的工具。
通过定义一系列规则和命令,我们可以使用Makefile来自动化构建和管理大型项目的编译过程。
本文将介绍Makefile的基本语法和常用命令,以及如何编写一个简单的Makefile文件。
一、Makefile基本语法1. 标准格式Makefile由一系列规则组成,每个规则包含了一个目标(target)、我们想要生成的文件名,以及生成目标所需要的依赖关系(prerequisites)和命令(recipe)。
通常一个规则的基本格式如下:```makefiletarget: prerequisitesrecipes```其中,target是需要生成的文件名,prerequisites是依赖文件,recipes是生成目标所需要执行的命令。
2. 规则的执行原则- 如果target不存在或者target的依赖文件比target更新,那么执行recipes中的命令。
- 如果target的依赖文件有更新,那么也会执行recipes中的命令。
3. 空格和Tab键缩进在Makefile中,空格和Tab键具有不同的含义。
空格用来分隔目标、依赖和命令,而Tab键则用来标识命令行。
因此,在Makefile中,必须使用Tab键来缩进每条命令。
二、Makefile常用命令1. makemake命令是用来执行Makefile中的规则的。
通过运行make命令,可以自动编译和链接项目。
```shellmake target```2. make cleanclean是一个常用的命令,用于清除编译生成的文件。
在Makefile中,我们可以定义一个clean规则,然后通过运行make clean命令来执行清除操作。
```makefileclean:rm -f target```3. make allall是另一个常用的命令,在Makefile中可以定义一个all规则,用于执行整个项目的编译和生成。
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是一种文本文件,它用来定义一组规则来指明编译软件项目所需要完成的步骤。
它也是构建、编译以及安装一个软件项目必不可少的一部分。
Makefile可以帮助开发者,其中一项重要的原因是它可以在编译软件时降低开发者的工作量,使其能够更快更轻松地解决编译软件的问题。
Makefile语法规则可以分为两类:基本语法规则和特殊语法规则。
基本语法规则涉及Makefile文件中每行需要遵守的语法,而特殊语法规则涉及到Makefile中使用的自定义变量或函数。
下面将详细介绍这两类规则。
1.本语法规则基本语法规则是Makefile文件核心的部分,其定义了文件每一行的正确格式。
下面我们将介绍几条基本语法规则:a)Makefile文件中,每行以冒号开头的一行代表一条规则,并且冒号前面必须是一个有效的标识符,比如变量名或是函数名。
b) Makefile文件中,每行以Tab键开头的一行代表一个操作,这个操作会被执行以完成一个特定的任务c)有以#开头的行都会被忽略,因为它表示一行注释,用来解释Makefile语句的内容d)Makefile文件中,变量与函数的定义必须放在Makefile文件的开头,才能在 Makefile件内部使用它们e)一行末尾需要加上一个分号,这样才能表达出每条规则被终止的意思,以避免 Makefile现错误2.特殊语法规则特殊语法规则涉及到 Makefile件中使用的自定义变量或是函数。
该规则是用来控制 Makefile件中定义的任务如何被执行。
a)量:变量是一种使用字符来代表值的方法,变量使用美元符号($)来表示。
它可以被声明在 Makefile文件的开头,也可以在Makefile件的某一行中使用。
b)数:函数是一种在 Makefile件中独立运行的代码块,它可以接受参数,并且返回一个字符串或者一组字符串。
使用函数有助于提高 Makefile件的整体性和可维护性,并且可以多次使用,以减少重复的工作。
makefile的基本用法以及yolov3的makefile解析
makefile的基本用法以及yolov3的makefile解析Makefile的基本用法以及YOLOv3的Makefile解析Makefile是一种用于自动化构建的文件,它定义了一系列规则和依赖关系,用于编译、链接和生成可执行文件等操作。
Makefile通常用于C/C++项目中,但它也可以用于其他编程语言。
一、Makefile的基本用法1. 规则(Rule)Makefile中的规则定义了如何生成目标文件和如何根据依赖关系重新生成目标文件。
一个规则通常由以下几部分组成:target: prerequisites[tab] command- target:目标文件,即要生成的文件。
- prerequisites:目标文件的依赖文件。
- command:生成目标文件的命令。
2. 变量(Variable)Makefile中的变量用于存储值,可以在规则中引用。
常见的变量有以下几种:- CC:C/C++编译器。
- CFLAGS:编译选项。
- LDFLAGS:链接选项。
- RM:删除文件的命令。
可以通过在Makefile中定义变量来方便地修改编译和链接参数,使构建过程更加灵活。
3. 默认规则(Default Rule)Makefile中可以定义一个默认规则,当使用make命令时,会自动执行默认规则中定义的命令。
默认规则的语法如下:.PHONY: allall: target- .PHONY:伪目标,表示该规则是一个伪目标。
- all:默认规则的名字。
- target:默认规则要生成的目标文件。
4. 命令行变量在执行make命令时,可以通过命令行参数传递变量的值。
例如,make CC=gcc可以将CC变量的值设置为gcc。
5. clean规则clean规则用于删除生成的目标文件和其他中间文件,以便重新构建项目。
通常的写法是:clean:[tab] (RM) target这里的(RM)是一个预定义变量,表示删除文件的命令(通常为rm -f)。
makefile 语法
makefile 语法Makefile是一种常用的构建工具,用于自动化构建和管理软件项目。
它是一种文本文件,包含一系列规则,用于指定如何编译、链接和构建源代码。
本文将介绍 Makefile 的语法和使用方法。
一、Makefile 的基本语法Makefile 文件由一系列规则组成,每个规则由一个目标和一个或多个依赖项组成。
目标是要生成的文件名,依赖项是生成目标所需要的文件或命令。
当目标文件不存在或依赖项的时间戳比目标文件的时间戳更晚时,Makefile 将自动执行规则中的命令,生成目标文件。
一个简单的 Makefile 示例:```hello: main.cgcc -o hello main.c```这个 Makefile 包含了一个规则,目标是 hello,依赖项是main.c。
当 main.c 文件的时间戳比 hello 文件的时间戳更晚时,Makefile 将执行 gcc 命令编译 main.c 文件,并生成可执行文件hello。
Makefile 的规则语法如下:```target: dependenciescommand1command2...```其中,target 是规则的目标,dependencies 是规则的依赖项,command1、command2 等是要执行的命令。
命令必须以一个制表符或多个空格开头,否则 Makefile 将无法识别。
二、Makefile 的变量Makefile 中可以定义变量,用于存储常用的值或命令。
变量以$ 符号开头,可以在规则中使用。
变量的定义语法如下:```VARNAME = value```或者```VARNAME := value```其中,等号和冒号加等号的区别在于,等号定义的变量是递归展开的,而冒号加等号定义的变量是简单展开的。
递归展开的变量可以包含其他变量的引用,而简单展开的变量只能包含直接的值。
示例:```CC = gccCFLAGS = -Wall -O2hello: main.c$(CC) $(CFLAGS) -o hello main.c```这个 Makefile 中定义了两个变量 CC 和 CFLAGS,用于存储编译器和编译选项。
详解Makefile函数的语法与使用
详解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 使用一些特定语法来实现这些功能,这篇文章将带领大家逐步学习 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 中的模式规则是一种将一类文件与另一类文件匹配的规则。
makefile语法
makefile语法
makefile是一种非常重要丶强大丶有用的编程工具,它可以通过编写少量的脚本指令来自动执行各种编译操作。
在Unix和Linux系统中,Makefile文件是用来指定源代码文件之间的关系,并利用这种关
系编译代码文件的工具。
它一般由make命令来调用,以使源程序编译,链接,安装等。
makefile语法可以分为两种:GNU makefile和BSD makefile。
makefile文件一般由多条规则(rule)构成,每条规则有下面的格式:target:prerequisites
[tab]recipe
其中target反应你正在创建的目标,prerequisites是你正在创建的target文件的依赖项,recipe是被执行的操作,可以有多条recipe指令,但一定要以tab键符号开头。
另外,你还可以对makefile文件的模式,变量,函数和嵌入式shell脚本等定义组合来执行指定的编译操作,以及将复杂的编译任务分解为一系列简单的命令。
makefile语法还可以帮助我们管理复杂的编译任务,比如编译大项目时,可以利用它来有效地跟踪依赖关系,以便在发生变化时,重
新编译所需的文件,而不用重新编译整个项目,从而节约大量的编译
时间。
如此,makefile语法能为我们提供很多益处,学习和掌握它能让你轻松地编写出自动化脚本,用以完成更多的工作,构建出高效率的
编译环境,从而让你在编译中更加顺利和有效地完成你要做的事情。
C++学习进阶之Makefile基础用法详解
$(TARGET):$(TESTOBJ) $(LIB) $(CXX) $< -o $@ $(LDFLAGS) $(LDLIBS)
$(LIB):$(OBJS) $(CXX) -shared $^ -o $@
$(TESTOBJ) $(OBJS):%.o:%.cpp $(CXX) $(CXXFLAGS) $< -o $@
makefile 文件可改为:
TARGET = simpletest OBJS = simple.o simpletest.o
$(TARGET):$(OBJS) g++ $(OBJS) -o $(TARGET)
simple.o:simple.cpp simpletest.o:simpletest.cpp clean:
绝大多数的 IDE 开发环境都会为用户自动编写 Makefile。
Make 是怎么工作的?
Make 工作的原则就是:
一个目标文件当且仅当在其依赖文件(dependencies)的更改时间戳比该目标文件的创建时间戳新时,这个目标文件才需要 被重新编译。
Make 工具会遍历所有的依赖文件,并且把它们对应的目标文件进行更新。编译的命令和这些目标文件及它们对应的依赖文件 的关系则全部储存在 Makefile 中。
Makefile 中也指定了应该如何创建,创建出怎么样的目标文件和可执行文件等信息。
除此之外,你甚至还可以在 Makefile 中储存一些你想调用的系统终端的命令,像一个 Shell 脚本一样使用它。
作用:
Makefile 文件告诉 Make 怎样编译和连接成一个程序
可用命令 dnf install make 安装make功能
makefile 语句解释
makefile 语句解释Makefile语句解释Makefile是一种用于自动化构建和管理软件项目的工具。
它包含一系列规则和指令,用于描述项目中的文件依赖关系和构建过程。
在这篇文章中,我将解释一些常见的Makefile语句。
1. `target: dependencies`这是最基本的Makefile规则语句。
它指定了一个目标(target),以及该目标所依赖的文件(dependencies)。
当目标的依赖文件发生变化时,Make工具将会执行后续的指令来更新目标。
2. `command`这是Makefile中的指令,用于执行具体的操作。
指令可以是任何可执行的命令,比如编译程序、复制文件、运行脚本等。
在Makefile中,每行指令都需要以一个Tab键开头。
3. `.PHONY: target`这是一个特殊的目标声明语句。
它告诉Make工具,目标并不是一个真实的文件名,而是一个伪目标(phony target)。
伪目标通常用于定义一些特殊的操作,比如清理文件、运行测试等。
4. `$(variable_name)`这是一个变量引用语句。
Makefile中可以定义变量,以便在后续的指令中使用。
变量可以包含字符串、文件名、目录名等信息。
$(variable_name)会被替换成对应变量的值。
5. `ifdef variable_name`这是一个条件判断语句,用于检查变量是否被定义。
如果变量已被定义,则执行后续的指令;否则跳过。
6. `$(wildcard pattern)`这是一个通配符表达式,用于匹配文件名。
这个表达式可以用于查找满足特定条件的文件,比如所有以.c结尾的文件,或者某个目录下的所有文件。
7. `ifeq ($(variable_name), value)`这是一个条件判断语句,用于检查变量的值是否等于某个特定的值。
根据判断结果,可以执行不同的指令或者设置不同的变量值。
这些是一些常用的Makefile语句和语法。
makefile逻辑
makefile逻辑什么是makefile?makefile是一种用于自动化构建软件的文件,它定义了一组规则和目标,用于描述如何将源代码编译成可执行的程序。
在软件开发过程中,makefile可以帮助开发者管理复杂的编译过程,并自动更新只有在需要时才需要重新编译的文件,提高开发效率。
makefile的作用makefile的主要作用是自动化构建软件,它可以根据源代码的依赖关系和修改时间来判断哪些文件需要重新编译,从而避免不必要的编译过程。
makefile还可以定义一些常用的命令和操作,如清理生成的文件、运行测试等,方便开发者进行日常的开发工作。
makefile的基本语法makefile的语法非常简单,主要由以下几个部分组成:1.目标(target):描述要生成的文件或执行的操作,可以是一个文件名或一个命令。
2.依赖关系(dependencies):描述目标所依赖的文件或其他目标。
3.命令(command):描述如何生成目标或执行操作的命令。
一个典型的makefile规则如下所示:target: dependenciescommand其中,target是目标,dependencies是依赖关系,command是生成目标或执行操作的命令。
makefile可以包含多个规则,每个规则独占一行。
makefile的执行过程makefile的执行过程主要分为以下几个步骤:1.解析makefile:make命令会读取指定的makefile文件,并解析其中的规则和命令。
2.检查依赖关系:make会检查每个目标的依赖关系,判断是否需要重新生成目标。
3.执行命令:如果目标需要重新生成,make会按照规则中定义的命令来生成目标。
4.更新目标:如果目标生成成功,make会更新目标的修改时间。
5.递归执行:如果目标的生成过程中生成了新的目标,make会递归执行这些新目标的规则。
makefile的变量makefile支持定义变量,以便在规则和命令中使用。
makefile基础
makefile基础Makefile是一种用于自动化编译和构建程序的工具。
它可以根据源代码的依赖关系自动编译和链接程序,从而简化了程序的构建过程。
本文将介绍Makefile的基础知识,包括Makefile的语法、变量、规则和函数等。
一、Makefile的语法Makefile的语法比较简单,它由一系列规则组成,每个规则包含一个目标、依赖和命令三部分。
例如:```target: dependency1 dependency2command1command2```其中,target表示目标文件,dependency1和dependency2表示依赖文件,command1和command2表示执行的命令。
注意,命令必须以一个Tab键开始,否则会报错。
二、Makefile的变量Makefile中可以定义变量,用于存储一些常用的值,例如编译器的路径、编译选项等。
定义变量的语法如下:```variable = value```其中,variable表示变量名,value表示变量的值。
在Makefile中使用变量的语法如下:```$(variable)```例如:```CC = gccCFLAGS = -Wall -O2target: dependency$(CC) $(CFLAGS) -o target dependency```其中,CC表示编译器的路径,CFLAGS表示编译选项,$(CC)和$(CFLAGS)表示使用变量的值。
三、Makefile的规则Makefile中的规则用于描述目标文件和依赖文件之间的关系。
常用的规则包括:1. all规则:用于指定默认的目标文件,例如:```all: target```2. clean规则:用于清除生成的目标文件,例如:```clean:rm -f target```3. .PHONY规则:用于声明一个伪目标,例如:```.PHONY: clean```四、Makefile的函数Makefile中还提供了一些函数,用于处理字符串、文件名等。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
5: 替换后缀名 替换后缀名函数的写法是:变量名 + 冒号 + 后缀名替换规则。它实际上patsubst函数的一种简写形式。
min: $(OUTPUT:.js=.min.js)
上面代码的意思是,将变量OUTPUT中的后缀名 .js 全部替换成 .min.js
等同于下面的写法-->
a.txt:
touch a.txt
b.txt:
touch b.txt
2:> $<
指代第一个前置条件。
比如: 规则为 t: p1 p2,那么$< 就指代p1。
a.txt: b.txt c.txt
cp $< $@
等同于下面的写法。
a.txt: b.txt c.txt
cp b.txt a.txt
3:> $?
指代此目标更新的所有前置条件,之间以空格分隔
比如: 规则为 t: p1 p2,其中 p2 的时间戳比 t 新,$?就指代p2。
4:> $^
$^ 指代所有前置条件,之间以空格分隔。
output:
$(CC) -o output input.c
【】自动变量(Automatic Variables): 它们的值与当前规则有关
1:> $@
指代当前目标,就是Make命令当前构建的那个目标
a.txt b.txt:
touch $@ <make foo的 $@ 就指代foo>
比如: 规则为 t: p1 p2,那么 $^ 就指代 p1 p2 。
5:> $*
$* 指代匹配符 % 匹配的部分,比如% 匹配 f1.txt 中的f1 ,$* 就表示 f1。
6:> $(@D) 和 $(@F)
$(@D) 和 $(@F) 分别指向 $@ 的目录名和文件名。
例子:
#sample Makefile
objects := $(patsubst %.c,%.o,$(wildcard *.c))
foo : $(objects)
cc -o foo $(objects)
使用了make的隐含规则来编译.c的源文件。对变量的赋值也用到了一个特殊的符号(:=)。
source.txt:
echo "this is the source" > source.txt
### source.txt后面没有前置条件,就意味着它跟其他文件都无关,只要这个文件还不存在,每次调用make source.txt,它都会生成。
生成多个文件,往往采用下面的写法:
一般我们可以使用“$(wildcard *.c)”来获取工作目录下的所有的.c文件列表
复杂用法:
“$(patsubst%.c,%.o,$(wildcard*.c))” 首先使用“wildcard”函数获取工作目录下的.c文件列表;
之后将列表中所有文件名的后缀.c替换为.o。这样我们就可以得到在当前目录可生成的.o文件列表
【】函数: 格式如下
$(function arguments)
# 或者
${function arguments}
常用的内置函数:
1: shell shell函数用来执行 shell 命令
srcfiles := $(shell echo src/{00..99}.txt)
libs=$(libs_for_gcc)
else
libs=$(normal_libs)
endif
/**************************/
LIST = one two three
all:
for i in $(LIST); do \
echo $$i; \
$(subst ee,EE,feet on the street)
例子 :
comma:= ,
empty:=
# space变量用两个空变量作为标识符,当中是一个空格
space:= $(empty) $(empty)
foo:= a b c
bar:= $(subst $(space),$(comma),$(foo))
【】2: wildcard wildcard 函数用来在Makefile中,替换 Bash 的通配符。
srcfiles := $(wildcard src/*.txt)
用法介绍:通配符会被自动展开。但在变量的定义和函数引用时,通配符将失效
此时如果需要通配符有效,使用函数“wildcard”,它的用法是:$(wildcard PATTERN...)
Makefile 文件语法:
注释: #
回声: 正常情况下,make会打印每条命令,然后再执行,这就叫做echoing
例子:
test:
# 这是测试
/****************/
执行: $ make test
# 这是测试
在命令的前面加上@,就可以关闭回声
【】通配符: wildcard用来指定一组符合条件的文件名
source: file1 file2 file3 <source 是一个伪目标,只有三个前置文件,没有任何对应的命令>
执行: make source
会一次性生成 file1,file2,file3 三个文件
【】命令: 表示如何更新目标文件,由一行或多行的Shell命令组成。它是构建"目标"的具体指令,它的运行结果通常就是生成目标文件。
每行命令在一个单独的shell中执行。这些Shell之间没有继承关系。
var-lost:
export foo=bar
echo "foo=[$$foo]"
###]\ 执行: make var-lost
获取不到foo的值。因为两行命令在两个不同的进程执行。一个解决办法是将两行命令写在一行,中间用分号分隔。
执行: make <默认会执行Makefile文件的第一个目标>
/***********/
目标:前置条件
<TAB> 命令
/********************************/
目标: 通常是文件名,指明Make命令所要构建的对象,目标还可以是某个操作的名字,这称为"伪目标"
/********************************************************************************/
综合样例: 编译C语言项目
edit : main.o kbd.o command.o display.o
cc -o edit main.o kbd.o command.o display.o (生成目标文件 edit)
done
###]\ 等同于
all:
for i in one two three; do \
echo $$i; \ <之前此处少写了$>
done
上面代码的运行结果:
one
two
three
/*************************/
只拷贝指定的文件,因此需要加上需要拷贝的文件名,例如:
all: dest/a.txt
同时还要确保src/下面有a.txt,否则也会报错。
判断和循环: 使用 Bash 语法,完成判断和循环。
例子: 判断当前编译器是否gcc ,然后指定不同的库文件。
ifeq ($(CC),gcc)
# bar is now `a,b,c'.
4: patsubst函数 patsubst 函数用于模式匹配的替换,格式如下。
$(patsubst pattern,replacement,text)
下面的例子将文件名"x.c.c bar.c",替换成"x.c.o bar.o"。
【*****************************************************************】
3: subst subst 函数用来文本替换,格式如下。
$(subst from,to,text)
DEMO: 将字符串"feet on the street"替换成"fEEt on the strEEt"。
dest/%.txt: src/%.txt
@[ -d dest ] || mkdir dest
cp $< $@
上面代码将 src 目录下的 txt 文件,拷贝到 dest 目录下。首先判断 dest 目录是否存在,如果不存在就新建,然后,$< 指代前置文件(src/%.txt), $@ 指代目标文件(dest/%.txt)。
%.o: %.c
等同于下面的写法
f1.o: f1.c
f2.o: xt = Hello World
test:
@echo $(txt)
变量 txt 等于 Hello World。调用时,变量需要放在 $( ) 之中。
/*************************/
Makefile 的通配符与 Bash 一致,主要有星号(*)、问号(?)和 [...]
比如: *.o 表示所有后缀名为o的文件
【】模式匹配: 允许对文件名,进行类似正则运算的匹配,主要用到的匹配符是%。