Make 命令教程

Make 命令教程

代码变成可执行文件，叫做编译（compile）；先编译这个，还是先编译那个（即编译的安排），叫做构建（build）。

Make是最常用的构建工具，诞生于1977年，主要用于C语言的项目。但是实际上 ，任何只要某个文件有变化，就要重新构建的项目，都可以用Make构建。

本文介绍Make命令的用法，从简单的讲起，不需要任何基础，只要会使用命令行，就能看懂。我的参考资料主要是Isaac Schlueter的《Makefile文件教程》和《GNU Make手册》。

 

（题图来自 appstorm.net）

一、Make的概念

Make这个词，英语的意思是"制作"。Make命令直接用了这个意思，就是要做出某个文件。比如，要做出文件a.txt，就可以执行下面的命令。



    

  1. $ make a.txt
    2. 



但是，如果你真的输入这条命令，它并不会起作用。因为Make命令本身并不知道，如何做出a.txt，需要有人告诉它，如何调用其他命令完成这个目标。


比如，假设文件 a.txt 依赖于 b.txt 和 c.txt ，是后面两个文件连接（cat命令）的产物。那么，make 需要知道下面的规则。




    

  1. a.txt: b.txt c.txt
    2. 

  2. cat b.txt c.txt > a.txt
    3. 



也就是说，make a.txt 这条命令的背后，实际上分成两步：第一步，确认 b.txt 和 c.txt 必须已经存在，第二步使用 cat 命令 将这个两个文件合并，输出为新文件。


像这样的规则，都写在一个叫做Makefile的文件中，Make命令依赖这个文件进行构建。Makefile文件也可以写为makefile， 或者用命令行参数指定为其他文件名。




    

  1. $ make -f rules.txt
    2. 

  2. # 或者
    3. 

  3. $ make --file=rules.txt
    4. 



上面代码指定make命令依据rules.txt文件中的规则，进行构建。


总之，make只是一个根据指定的Shell命令进行构建的工具。它的规则很简单，你规定要构建哪个文件、它依赖哪些源文件，当那些文件有变动时，如何重新构建它。


二、Makefile文件的格式


构建规则都写在Makefile文件里面，要学会如何Make命令，就必须学会如何编写Makefile文件。


2.1 概述


Makefile文件由一系列规则（rules）构成。每条规则的形式如下。




    

  1. <target> : <prerequisites>
    2. 

  2. [tab]  <commands>
    3. 



上面第一行冒号前面的部分，叫做"目标"（target），冒号后面的部分叫做"前置条件"（prerequisites）；第二行必须由一个tab键起首，后面跟着"命令"（commands）。


"目标"是必需的，不可省略；"前置条件"和"命令"都是可选的，但是两者之中必须至少存在一个。


每条规则就明确两件事：构建目标的前置条件是什么，以及如何构建。下面就详细讲解，每条规则的这三个组成部分。


2.2 目标（target）


一个目标（target）就构成一条规则。目标通常是文件名，指明Make命令所要构建的对象，比如上文的 a.txt 。目标可以是一个文件名，也可以是多个文件名，之间用空格分隔。


除了文件名，目标还可以是某个操作的名字，这称为"伪目标"（phony target）。




    

  1. clean:
    2. 

  2. rm *.o
    3. 



上面代码的目标是clean，它不是文件名，而是一个操作的名字，属于"伪目标 "，作用是删除对象文件。




    

  1. $ make  clean
    2. 



但是，如果当前目录中，正好有一个文件叫做clean，那么这个命令不会执行。因为Make发现clean文件已经存在，就认为没有必要重新构建了，就不会执行指定的rm命令。


为了避免这种情况，可以明确声明clean是"伪目标"，写法如下。




    

  1. .PHONY: clean
    2. 

  2. clean:
    3. 

  3. rm *.o temp
    4. 



声明clean是"伪目标"之后，make就不会去检查是否存在一个叫做clean的文件，而是每次运行都执行对应的命令。像.PHONY这样的内置目标名还有不少，可以查看手册。


如果Make命令运行时没有指定目标，默认会执行Makefile文件的第一个目标。




    

  1. $ make
    2. 



上面代码执行Makefile文件的第一个目标。


2.3 前置条件（prerequisites）


前置条件通常是一组文件名，之间用空格分隔。它指定了"目标"是否重新构建的判断标准：只要有一个前置文件不存在，或者有过更新（前置文件的last-modification时间戳比目标的时间戳新），"目标"就需要重新构建。




    

  1. result.txt: source.txt
    2. 

  2. cp source.txt result.txt
    3. 



上面代码中，构建 result.txt 的前置条件是 source.txt 。如果当前目录中，source.txt 已经存在，那么make result.txt可以正常运行，否则必须再写一条规则，来生成 source.txt 。




    

  1. source.txt:
    2. 

  2. echo "this is the source" > source.txt
    3. 



上面代码中，source.txt后面没有前置条件，就意味着它跟其他文件都无关，只要这个文件还不存在，每次调用make source.txt，它都会生成。




    

  1. $ make result.txt
    2. 

  2. $ make result.txt
    3. 



上面命令连续执行两次make result.txt。第一次执行会先新建 source.txt，然后再新建 result.txt。第二次执行，Make发现 source.txt 没有变动（时间戳晚于 result.txt），就不会执行任何操作，result.txt 也不会重新生成。


如果需要生成多个文件，往往采用下面的写法。




    

  1. source: file1 file2 file3
    2. 



上面代码中，source 是一个伪目标，只有三个前置文件，没有任何对应的命令。




    

  1. $ make source
    2. 



执行make source命令后，就会一次性生成 file1，file2，file3 三个文件。这比下面的写法要方便很多。




    

  1. $ make file1
    2. 

  2. $ make file2
    3. 

  3. $ make file3
    4. 



2.4 命令（commands）


命令（commands）表示如何更新目标文件，由一行或多行的Shell命令组成。它是构建"目标"的具体指令，它的运行结果通常就是生成目标文件。


每行命令之前必须有一个tab键。如果想用其他键，可以用内置变量.RECIPEPREFIX声明。




    

  1. .RECIPEPREFIX = >
    2. 

  2. all:
    3. 

  3. > echo Hello, world
    4. 



上面代码用.RECIPEPREFIX指定，大于号（>）替代tab键。所以，每一行命令的起首变成了大于号，而不是tab键。


需要注意的是，每行命令在一个单独的shell中执行。这些Shell之间没有继承关系。




    

  1. var-lost:
    2. 

  2. export foo=bar
    3. 

  3. echo "foo=[$$foo]"
    4. 



上面代码执行后（make var-lost），取不到foo的值。因为两行命令在两个不同的进程执行。一个解决办法是将两行命令写在一行，中间用分号分隔。




    

  1. var-kept:
    2. 

  2. export foo=bar; echo "foo=[$$foo]"
    3. 



另一个解决办法是在换行符前加反斜杠转义。




    

  1. var-kept:
    2. 

  2. export foo=bar; \
    3. 

  3. echo "foo=[$$foo]"
    4. 



最后一个方法是加上.ONESHELL:命令。




    

  1. .ONESHELL:
    2. 

  2. var-kept:
    3. 

  3. export foo=bar;
    4. 

  4. echo "foo=[$$foo]"
    5. 




三、Makefile文件的语法


3.1 注释


井号（#）在Makefile中表示注释。




    

  1. # 这是注释
    2. 

  2. result.txt: source.txt
    3. 

  3. # 这是注释
    4. 

  4. cp source.txt result.txt # 这也是注释
    5. 



3.2 回声（echoing）


正常情况下，make会打印每条命令，然后再执行，这就叫做回声（echoing）。




    

  1. test:
    2. 

  2. # 这是测试
    3. 



执行上面的规则，会得到下面的结果。




    

  1. $ make test
    2. 

  2. # 这是测试
    3. 



在命令的前面加上@，就可以关闭回声。




    

  1. test:
    2. 

  2. @# 这是测试
    3. 



现在再执行make test，就不会有任何输出。


由于在构建过程中，需要了解当前在执行哪条命令，所以通常只在注释和纯显示的echo命令前面加上@。




    

  1. test:
    2. 

  2. @# 这是测试
    3. 

  3. @echo TODO
    4. 



3.3 通配符


通配符（wildcard）用来指定一组符合条件的文件名。Makefile 的通配符与 Bash 一致，主要有星号（*）、问号（？）和 [...] 。比如， *.o 表示所有后缀名为o的文件。




    

  1. clean:
    2. 

  2. rm -f *.o
    3. 



3.4 模式匹配


Make命令允许对文件名，进行类似正则运算的匹配，主要用到的匹配符是%。比如，假定当前目录下有 f1.c 和 f2.c 两个源码文件，需要将它们编译为对应的对象文件。




    

  1. %.o: %.c
    2. 



等同于下面的写法。




    

  1. f1.o: f1.c
    2. 

  2. f2.o: f2.c
    3. 



使用匹配符%，可以将大量同类型的文件，只用一条规则就完成构建。


3.5 变量和赋值符


Makefile 允许使用等号自定义变量。




    

  1. txt = Hello World
    2. 

  2. test:
    3. 

  3. @echo $(txt)
    4. 



上面代码中，变量 txt 等于 Hello World。调用时，变量需要放在 $( ) 之中。


调用Shell变量，需要在美元符号前，再加一个美元符号，这是因为Make命令会对美元符号转义。




    

  1. test:
    2. 

  2. @echo $$HOME
    3. 



有时，变量的值可能指向另一个变量。




    

  1. v1 = $(v2)
    2. 



上面代码中，变量 v1 的值是另一个变量 v2。这时会产生一个问题，v1 的值到底在定义时扩展（静态扩展），还是在运行时扩展（动态扩展）？如果 v2 的值是动态的，这两种扩展方式的结果可能会差异很大。


为了解决类似问题，Makefile一共提供了四个赋值运算符 （=、:=、？=、+=），它们的区别请看StackOverflow。




    

  1. VARIABLE = value
    2. 

  2. # 在执行时扩展，允许递归扩展。
    3. 

  3.  
    4. 

  4. VARIABLE := value
    5. 

  5. # 在定义时扩展。
    6. 

  6.  
    7. 

  7. VARIABLE ?= value
    8. 

  8. # 只有在该变量为空时才设置值。
    9. 

  9.  
    10. 

  10. VARIABLE += value
    11. 

  11. # 将值追加到变量的尾端。
    12. 

  12.  
    13. 



3.6 内置变量（Implicit Variables）


Make命令提供一系列内置变量，比如，$(CC) 指向当前使用的编译器，$(MAKE) 指向当前使用的Make工具。这主要是为了跨平台的兼容性，详细的内置变量清单见手册。




    

  1. output:
    2. 

  2. $(CC) -o output input.c
    3. 



3.7 自动变量（Automatic Variables）


Make命令还提供一些自动变量，它们的值与当前规则有关。主要有以下几个。


（1）$@


$@指代当前目标，就是Make命令当前构建的那个目标。比如，make foo的 $@ 就指代foo。




    

  1. a.txt b.txt:
    2. 

  2. touch $@
    3. 



等同于下面的写法。




    

  1. a.txt:
    2. 

  2. touch a.txt
    3. 

  3. b.txt:
    4. 

  4. touch b.txt
    5. 



（2）$<


$< 指代第一个前置条件。比如，规则为 t: p1 p2，那么$< 就指代p1。




    

  1. a.txt: b.txt c.txt
    2. 

  2. cp $< $@
    3. 



等同于下面的写法。




    

  1. a.txt: b.txt c.txt
    2. 

  2. cp b.txt a.txt
    3. 



（3）$?


$? 指代比目标更新的所有前置条件，之间以空格分隔。比如，规则为 t: p1 p2，其中 p2 的时间戳比 t 新，$?就指代p2。


（4）$^


$^ 指代所有前置条件，之间以空格分隔。比如，规则为 t: p1 p2，那么 $^ 就指代 p1 p2 。


（5）$*


$* 指代匹配符 % 匹配的部分， 比如% 匹配 f1.txt 中的f1 ，$* 就表示 f1。


（6）$(@D) 和 $(@F)


$(@D) 和 $(@F) 分别指向 $@ 的目录名和文件名。比如，$@是 src/input.c，那么$(@D) 的值为 src ，$(@F) 的值为 input.c。


（7）$(<D) 和 $(<F)


$(<D) 和 $(<F) 分别指向 $< 的目录名和文件名。


所有的自动变量清单，请看手册。下面是自动变量的一个例子。




    

  1. dest/%.txt: src/%.txt
    2. 

  2. @[ -d dest ] || mkdir dest
    3. 

  3. cp $< $@
    4. 



上面代码将 src 目录下的 txt 文件，拷贝到 dest 目录下。首先判断 dest 目录是否存在，如果不存在就新建，然后，$< 指代前置文件（src/%.txt）， $@ 指代目标文件（dest/%.txt）。


3.8 判断和循环


Makefile使用 Bash 语法，完成判断和循环。




    

  1. ifeq ($(CC),gcc)
    2. 

  2. libs=$(libs_for_gcc)
    3. 

  3. else
    4. 

  4. libs=$(normal_libs)
    5. 

  5. endif
    6. 



上面代码判断当前编译器是否 gcc ，然后指定不同的库文件。




    

  1. LIST = one two three
    2. 

  2. all:
    3. 

  3. for i in $(LIST); do \
    4. 

  4. echo $$i; \
    5. 

  5. done
    6. 

  6.  
    7. 

  7. # 等同于
    8. 

  8.  
    9. 

  9. all:
    10. 

  10. for i in one two three; do \
    11. 

  11. echo $i; \
    12. 

  12. done
    13. 

  13.  
    14. 



上面代码的运行结果。




    

  1. one
    2. 

  2. two
    3. 

  3. three
    4. 



3.9 函数


Makefile 还可以使用函数，格式如下。




    

  1. $(function arguments)
    2. 

  2. # 或者
    3. 

  3. ${function arguments}
    4. 



Makefile提供了许多内置函数，可供调用。下面是几个常用的内置函数。


（1）shell 函数


shell 函数用来执行 shell 命令




    

  1. srcfiles := $(shell echo src/{00..99}.txt)
    2. 



（2）wildcard 函数


wildcard 函数用来在 Makefile 中，替换 Bash 的通配符。




    

  1. srcfiles := $(wildcard src/*.txt)
    2. 



（3）替换函数


替换函数的写法是：变量名 + 冒号 + 替换规则。




    

  1. min: $(OUTPUT:.js=.min.js)
    2. 



上面代码的意思是，将变量OUTPUT中的 .js 全部替换成 .min.js 。


四、Makefile 的实例


（1）执行多个目标




    

  1. .PHONY: cleanall cleanobj cleandiff
    2. 

  2.  
    3. 

  3. cleanall : cleanobj cleandiff
    4. 

  4. rm program
    5. 

  5.  
    6. 

  6. cleanobj :
    7. 

  7. rm *.o
    8. 

  8.  
    9. 

  9. cleandiff :
    10. 

  10. rm *.diff
    11. 



上面代码可以调用不同目标，删除不同后缀名的文件，也可以调用一个目标（cleanall），删除所有指定类型的文件。


（2）编译C语言项目




    

  1. edit : main.o kbd.o command.o display.o
    2. 

  2. cc -o edit main.o kbd.o command.o display.o
    3. 

  3.  
    4. 

  4. main.o : main.c defs.h
    5. 

  5. cc -c main.c
    6. 

  6. kbd.o : kbd.c defs.h command.h
    7. 

  7. cc -c kbd.c
    8. 

  8. command.o : command.c defs.h command.h
    9. 

  9. cc -c command.c
    10. 

  10. display.o : display.c defs.h
    11. 

  11. cc -c display.c
    12. 

  12.  
    13. 

  13. clean :
    14. 

  14. rm edit main.o kbd.o command.o display.o
    15. 

  15.  
    16. 

  16. .PHONY: edit clean
    17. 



今天，Make命令的介绍就到这里。下一篇文章我会介绍，如何用 Make 来构建 Node.js 项目。


----------------------------------------------------------------------------------------------------------------------------


原文发布时间：2015-02-24


本文来自云栖合作伙伴“linux中国”
				


				
时间： 2024-10-28 06:14:14

		
		


		


	

	
	

		


		
Make 命令教程的相关文章


						

		

			

                Docker 命令教程（附中文解释）_docker
			

		

		

									

				Docker 命令教程 Docker自从诞生以来就一直备受追捧,学习Docker是一件很炫酷.很有意思的事情.我希望通过这篇文章能够让大家快速地入门Docker,并有一些学习成果来激发自己的学习兴趣.我也只是一个在Docker这条巨鲸上玩耍的小孩,全文如有不明确.不正确的地方,还请斧正. # docker --help Usage: docker [OPTIONS] COMMAND [arg...] docker daemon [ --help | ... ] docker [ -h | --h			

		

	

						

		

			

                【转】CMD命令教程
			

		

		

									

				from: http://tieba.baidu.com/f?kz=114846499 在网上找到的.  gpedit.msc-----组策略   sndrec32-------录音机   Nslookup-------IP地址侦测器   explorer-------打开资源管理器   logoff---------注销命令   tsshutdn-------60秒倒计时关机命令   lusrmgr.msc----本机用户和组   services.msc---本地服务设置   oobe/ms			

		

	

				

		

			

                常用git命令教程
			

		

		

									

				  常用的git命令: 安装之后第一步安装 Git 之后,你要做的第一件事情就是去配置你的名字和邮箱,因为每一次提交都需要这些信息: git config --global user.name "bukas" git config --global user.email "bukas@gmail.com" 获取Git配置信息,执行以下命令: git config --list 创建版本库什么是版本库呢?版本库又名仓库,英文名repository,你可以简单理解成一个			

		

	

				

		

			

                思科路由器配置命令教程
			

		

		

									

				  enable:进入特权命令状态 configterminal:进入全局设置状态 end:退出全局设置状态 interfacetypeslot/number:进入端口设置状态 exit:退出局部设置状态 hostnamename:设置交换机名 showversion:查看版本及引导信息 showrunning-config:查看运行设置 showvlan:查看VLAN设置 showinterfacetypeslot/number:显示端口信息 pinghostname|IPaddress:网络			

		

	

				

		

			

                Mac显示隐藏文件命令教程
			

		

		

									

				  第一步:打开「终端」应用程序. 第二步:输入如下命令: defaults write com.apple.finder AppleShowAllFiles -boolean true ; killall Finder 第三步:按下「Return」键确认. 现在你将会在 Finder 窗口中看到那些隐藏的文件和文件夹了. 如果你想再次隐藏原本的隐藏文件和文件夹的话,将上述命令替换成 defaults write com.apple.finder AppleShowAllFiles -boole			

		

	

				

		

			

                常用svn命令教程
			

		

		

									

				  常用的svn命令: 首先你可以通过svn help/h来查看帮助信息. 开始工作 检出(checkout)服务器数据到本地 你刚入职一家公司,或新加入某个团队,立马参与到一个项目中,那么就得获取项目代码,开始你的项目生涯.这个时候一般你需要检出项目代码: svn checkout/co [directory] project(本地目录名,可选) // 检出版本3 svn checkout/co –revision/r 3 [directory] project(本地目录名,可选) 接着你就可			

		

	

				

		

			

                windows批处理命令教程_DOS/BAT
			

		

		

									

				批处理文件是无格式的文本文件,它包含一条或多条命令.它的文件扩展名为 .bat 或 .cmd.在命令提示下键入批处理文件的名称,或者双击该批处理文件,系统就会调用Cmd.exe按照该文件中各个命令出现的顺序来逐个运行它们.使用批 处理文件(也被称为批处理程序或脚本),可以简化日常或重复性任务.当然我们的这个版本的主要内容是介绍批处理在入侵中一些实际运用,例如我们后面要提到 的用批处理文件来给系统打补丁.批量植入后门程序等.下面就开始我们批处理学习之旅吧. 一.简单批处理内部命令简介 1.echo			

		

	

				

		

			

                Make 命令构建网站教程及示例
			

		

		

									

				一.Make的优点 首先解释一下,为什么要用Make. 目前,网站项目(尤其是Node.js项目)有三种构建方案.         方案一:基于Node.js的专用构建工具(Grunt.Gulp.Brunch.Broccoli.Mimosa)        方案二:npm run命令(教程1.2.3)        方案三:make命令 我觉得,make是大型项目的首选方案.npm run可以认为是make的简化形式,只适用于简单项目,而Grunt.Gulp那样的工具,有很多问题. (1)插件问			

		

	

				

		

			

                Linux网络统计工具/命令
			

		

		

									

				我在Linux(基于CentOS 或者 Debian 的发行版)中该如何查看当前网络端口吞吐量的统计信息?在Linux操作系统中如何查看当前内核snmp计数器以及网络端口的统计信息? 你可以使用以下任何一个命令: nstat 命令 : 网络统计工具 键入以下命令: # nstat 输出样例: #kernel IpInReceives 133243 0.0 IpInDelivers 133243 0.0 IpOutRequests 92904 0.0 IcmpOutErrors 97 0.0 Ic