Makefile规则
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 静态模式规则
makefile 静态模式规则摘要：1.Makefile 简介2.静态模式规则的概念3.静态模式规则的语法4.静态模式规则的实例5.静态模式规则的应用场景6.静态模式规则的注意事项正文：Makefile 是Linux 和Unix 系统中最常用的构建工具，它可以自动化执行编译、链接、安装等操作。
在Makefile 中，静态模式规则是一种特殊的规定，用于描述目标文件与依赖文件之间的关系。
静态模式规则使得Makefile 更加简洁和高效。
静态模式规则的概念是指在Makefile 中，用简洁的文本描述目标文件和依赖文件之间的依赖关系。
这种规则通常以“:”或“=”作为分隔符，将目标文件和依赖文件分开。
例如，如果目标文件“target”依赖于文件“dependency”，可以使用如下静态模式规则表示：```target: dependency```静态模式规则的语法包括两部分：目标文件和依赖文件。
目标文件是Makefile 要生成的文件，依赖文件是生成目标文件所需要的文件。
目标文件和依赖文件之间用冒号（:）或等号（=）分隔。
静态模式规则的实例可以帮助我们更好地理解这一概念。
例如，假设我们有一个名为“main.o”的目标文件，它依赖于“main.c”和“header.h”两个文件。
在Makefile 中，我们可以使用静态模式规则表示为：```main.o: main.c header.h```静态模式规则的应用场景包括编译、链接和安装等操作。
在编译过程中，Makefile 可以根据静态模式规则自动生成目标文件；在链接过程中，Makefile 可以根据静态模式规则自动链接目标文件和依赖文件；在安装过程中，Makefile 可以根据静态模式规则自动安装目标文件。
在实际使用静态模式规则时，需要注意以下几点：1.依赖文件必须在Makefile 中显式地声明，以确保Makefile 可以找到依赖文件。
2.静态模式规则中的依赖文件必须是绝对路径，以避免在不同目录下出现同名文件的问题。
makefile正则表达式
makefile正则表达式makefile是一种常用的工具，可以用于自动化构建和管理项目。
在makefile中，正则表达式是一个强大的工具，可以帮助我们更方便地匹配和处理文本内容。
makefile中常用的正则表达式包括：1. ^（起始符）：匹配字符串的开头。
2. $（结束符）：匹配字符串的结尾。
3. .（点号）：匹配除了换行符外的任意一个字符。
4. *（星号）：匹配前面的字符出现0个或多个。
5. +（加号）：匹配前面的字符出现1个或多个。
6. ?（问号）：匹配前面的字符出现0个或1个。
7. [ ]（中括号）：匹配中括号中任意一个字符。
8. [^ ]（中括号取反）：匹配不在中括号中的任意一个字符。
9. ( )（圆括号）：将括号中的内容视为一个整体，可以和其他正则表达式一起使用。
除了这些常用的正则表达式外，还有一些特殊的符号和语法可以帮助我们更精确地匹配文本内容，比如：1. （反斜杠）：转义符，可以将特殊字符转义为普通字符。
2. |（竖线）：或运算符，可以匹配多个表达式中的一个。
3. { }（花括号）：重复次数符号，可以指定一个字符或表达式的重复次数。
在使用正则表达式时，我们需要注意一些事项，比如：1. 正则表达式是区分大小写的。
2. 正则表达式中的空格和换行符也会被匹配。
3. 正则表达式可能会匹配到我们不需要的内容，因此需要通过进一步筛选和处理来达到我们的目的。
总之，正则表达式在makefile中的应用非常广泛，可以帮助我们更方便地编写自动化构建和管理脚本。
熟练掌握正则表达式的使用方法，可以极大地提高我们的工作效率。
makefile文件的显示规则
makefile文件的显示规则Makefile文件是用于构建和管理软件项目的工具，它定义了一系列规则，用来指导如何编译、链接和安装软件。
在本文中，我们将详细介绍Makefile文件中的显示规则。
一、目标规则(T arget Rule)目标规则是Makefile中最常见的一种规则，它用来指定如何生成一个目标文件。
一个目标规则由目标、依赖和命令组成。
目标是我们要生成的文件，依赖是生成目标文件所需要的其他文件，而命令则是生成目标文件的具体步骤。
例如，我们可以定义一个目标规则来生成一个名为"hello"的可执行文件：```hello: main.o func.ogcc -o hello main.o func.o```在这个例子中，"hello"是目标文件，"main.o"和"func.o"是依赖文件，而命令"gcc -o hello main.o func.o"则是生成目标文件的具体步骤。
二、伪目标规则(Phony T arget Rule)伪目标规则用来指定一些特殊的目标，它们并不是真正的文件，而是一些需要执行的命令。
伪目标规则的目标名前面通常会加上一个"phony"修饰符，以便与真正的文件区分开来。
例如，我们可以定义一个伪目标规则来清理编译生成的文件：```.PHONY: cleanclean:rm -f hello *.o```在这个例子中，".PHONY"表示这是一个伪目标规则，"clean"是目标名，而命令"rm -f hello *.o"则是清理编译生成的文件的具体步骤。
三、模式规则(Pattern Rule)模式规则是一种更加抽象的规则，它可以匹配多个目标文件。
模式规则使用通配符来表示目标和依赖中的文件名模式，并使用"%"来表示匹配的部分。
makefile编写规则
makefile编写规则⼀、makefile 规则：⼀般开头都是 Tab ，不能空格， include 前⾯不能是 Tab； 1、如果没编译过，将所有的（.c）⽂件编译并且链接； 2、如果有其中的（.c）⽂件改变，编译并链接改变的⽂件； 3、如果（.h）⽂件被修改，编译引⽤相应的（.c）⽂件, 链接； 4、在随意修改时间的情况下，会导致编译过程中⽣成的（.o 中间⽂件）与可执⾏⽂件时间不⼀致，此时会编译相应的⽂件，并链接，最终编译成可执⾏⽂件；⼆、第⼀版 makefile： 例如有2个 .h ⽂件（utils.h, player.h, actor.h）和 3个 .c ⽂件( main.c, player.c, actor.c)需要编译链接：/*****main.c*********/#include "utils.h"#include "player.h"void main() {// do something}/*******player.c**********/#include "utils.h"#include "actor.h"bool create_player() {// do something}/****actor.c************/#include "utils.h"bool create_actor() {// do something}/********* makefile *****************/test : main.o actor.occ -o test main.o actor.omain.o : main.c utils.h player.h actor.hcc -c main.cpalyer.o: player.c player.h actor.h utils.hcc -c player.cactor.o: actor.h utils.hcc -c actor.cclean:rm test ain.o player.o actor.o 优点：可毒性很强，思路清晰明了； 缺点：⿇烦，重复的依赖过多，当需要编译⼤量⽂件时容易出错；第⼆版：利⽤ makefile 的变量；/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较，唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉main.o : main.c utils.h player.h actor.hcc -c main.cpalyer.o: player.c player.h actor.h utils.hcc -c player.cactor.o: actor.h utils.hcc -c actor.c .PHONY : clean // 伪⽬标，避免：如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ) // 前⾯的（-）表⽰，执⾏过程中不 care 出错；第三版：利⽤ GUN make 的⾃动推导规则 当 make 看到（.o ）⽂件，他会⾃动把（.c）⽂件加上依赖关系，包括执⾏的语句（cc -c xx.c）;/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较，唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉main.o : utils.h player.h actor.hpalyer.o: player.h actor.h utils.hactor.o: actor.h utils.h .PHONY : clean // 伪⽬标，避免：如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ)第四版：对第三版的整理（有⼀些重复的 .h） 公共的⼀起依赖，单独的单独依赖/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较，唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉$(OBJ) : utils.h actor.omain.o player.o .PHONY : clean // 伪⽬标，避免：如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ)优点：简洁缺点：不好理解以上的makefike⽂件的基本写法；或许你也发现了，如果有⼏百个源⽂件咋整呢，光是⽬录就要晕死，下⾯就是针对这种情况来说⼀下⼤型⼯程 makefile 的编写设计⼆、⼤型项⽬makefile编写： Makefile 同样也有像 c / c++ 类似的include功能； 例如我们有⼀堆 a.mk , b.mk以及 foo.make和⼀个变量 $（bar），其包含了 e.mk,f.mk, 那么 include foo.make *.mk $(bar) ------- 等价-------》 include foo.make a.mk b.mk e.mk f.mk。
Makefile
MakefileMake的基本规则：Target [属性] 分隔符 [依赖文件] [;命令行 ]{Tab 命令行}注：命令行间可以加入任意多个空行，但空行也要以tab开头。
Cat –v -t -e Makefile会使Makefile文件中tab以^]显示，行尾以$显示。
注：命令过长，用\来连接多行成一行。
注释以#开头，如果#要用作字符符号，―#‖。
分隔符：：：目标有多个规则。
哪条规则中的依赖文件比目标新，执行哪条规则。
如果多条规则的依赖文件都比目标新，多条规则都执行。
由于后面的规则可能覆盖前面规则的执行结构，所以规则顺序不同，执行结构也不同。
：^把本规则依赖文件和目标文件已有的依赖文件合起来，生成目标新的依赖文件列表。
：-清除目标已有依赖文件，把本规则依赖文件作为目标依赖文件列表。
：！对每个更新过的依赖文件都执行一次命令菜单。
：|内部规则专用。
如：file.o ：file.cfile.o ：^ filef.c现依赖文件为file.c filef.cfile.o ：- filef.c现依赖文件为 filef.c令行属性：- 若本命令的执行错误，忽略掉，继续向下执行。
（不加该标志，make会停止）+ 始终执行本命令，即使make参数使用了-n-q-t。
（前提是本规则中依赖文件新与目标文件，命令行需要执行）@ 本命令行不在标准输出显示。
Target属性：指定多个目标文件属性：属性属性…… ：目标目标……规则中指定单个目标属性：目标属性：[依赖文件] ……·IGNORE 类似与命令行属性-·SILENT 类似与命令行属性@·PRECIOUS 保留中间文件·LIBRARY 目标是一个库。
如果make发现目标是lib(member)或lib((entry))形式，会自动给名为lib的目标加上该属性。
·LIBRARYM 目标是库的一个成员。
如果make发现目标是lib（member）形式，会自动给lib目标加上·LIBRARY，被member目标加上·LIBRARYM。
makefile 隐式规则
makefile 隐式规则Makefile是一种用于自动化构建程序的工具，它可以根据源代码文件的修改情况，自动地编译、链接和生成可执行文件。
Makefile中的隐式规则是指在没有明确指定规则的情况下，Makefile会自动根据文件的后缀名来推断编译规则。
在Makefile中，隐式规则的格式如下：```<目标文件>: <依赖文件><命令>```其中，目标文件是要生成的文件，依赖文件是生成目标文件所需要的文件，命令是生成目标文件的具体操作。
例如，我们要编译一个C语言程序，可以使用以下的隐式规则：```.c.o:gcc -c $< -o $@```这个规则的意思是，将所有的.c文件编译成.o文件，使用gcc编译器进行编译，$<表示依赖文件，$@表示目标文件。
另外，Makefile中还有一些内置的隐式规则，例如：- .c.o：将C语言源文件编译成目标文件- .cpp.o：将C++语言源文件编译成目标文件- .f.o：将Fortran语言源文件编译成目标文件- .y.c：将Yacc源文件生成C语言源文件- .l.c：将Lex源文件生成C语言源文件除了以上的内置规则外，我们还可以自定义隐式规则，例如：```.SUFFIXES: .txt .html.txt.html:pandoc $< -o $@```这个规则的意思是，将所有的.txt文件转换成.html文件，使用pandoc工具进行转换，$<表示依赖文件，$@表示目标文件。
总之，Makefile中的隐式规则可以大大简化编译过程，提高编译效率，是一个非常重要的功能。
在编写Makefile时，我们应该充分利用隐式规则，减少重复的代码，提高代码的可维护性和可读性。
c语言makefile编写规则
c语言makefile编写规则C语言Makefile编写规则什么是MakefileMakefile是一种用于管理和构建软件项目的文件，通常被用于编译和链接C语言程序。
Makefile中包含了一系列的规则和指令，用于告诉编译器如何编译程序中的各个部分，并最终生成可执行文件。
Makefile的基本结构Makefile的基本结构由多个规则组成，每个规则由一个目标（target）和一个或多个依赖（dependencies）组成。
目标指明了要生成的文件或要执行的操作，依赖指明了目标所依赖的文件或操作。
一个简单的Makefile规则的语法如下：target: dependenciescommand其中，target是生成的文件或要执行的操作，dependencies是目标所依赖的文件或操作，command是执行的命令。
每个规则的命令必须以一个tab键开始。
Makefile的应用场景Makefile广泛应用于C语言项目的构建中，它可以自动化执行编译、链接和清理等操作。
通过Makefile，我们可以方便地管理源代码文件、头文件和库文件之间的关系，从而提高项目的可维护性和可扩展性。
Makefile的编写规则1.目标和依赖应该使用合适的命名方式，能够清晰地表达其作用以及所依赖的内容。
避免使用中文、空格和特殊字符，使用下划线和英文字母进行命名。
2.命令行命令应该以tab键开始，而不是空格。
这是Makefile的语法要求，且使用tab键可以提高代码的可读性。
3.注意规则的顺序，确保前置依赖在目标之前。
Makefile会按照规则的声明顺序进行构建，如果前置依赖在目标之后，可能导致构建失败。
4.使用变量来定义重复使用的内容，如编译器选项、源文件列表等。
这样可以提高代码的可维护性，并方便进行后续的修改和维护。
5.使用通配符来表示一类文件，如使用*.c表示所有的C语言源文件，使用$(wildcard pattern)函数来获取符合某种模式的文件列表。
makefile基本使用方法
makefile基本使用方法makefile是一种用来管理和自动化构建程序的工具。
它可以根据源代码文件的依赖关系和编译规则来自动构建目标文件和可执行文件。
makefile的基本使用方法如下：1. 创建makefile文件：在项目的根目录下创建一个名为makefile 的文件。
2. 定义变量：在makefile中，可以使用变量来存储一些常用的参数和路径，以便于后续的使用。
例如，可以定义一个名为CC的变量来指定编译器的名称，如：CC=gcc。
3. 编写规则：在makefile中，可以使用规则来指定如何编译源代码文件和生成目标文件。
一个规则由两部分组成：目标和依赖。
目标是要生成的文件，依赖是生成目标文件所需要的源代码文件。
例如，可以编写以下规则：```target: dependency1 dependency2command1command2```其中，target是目标文件，dependency1和dependency2是依赖的源代码文件，command1和command2是生成目标文件所需要执行的命令。
4. 编写默认规则：在makefile中，可以使用一个默认规则来指定如何生成最终的可执行文件。
默认规则的目标通常是可执行文件，依赖是所有的源代码文件。
例如，可以编写以下默认规则：```all: target1 target2```其中，target1和target2是生成的目标文件。
5. 编写clean规则：在makefile中，可以使用clean规则来清理生成的目标文件和可执行文件。
例如，可以编写以下clean规则： ```clean:rm -f target1 target2```其中，target1和target2是要清理的目标文件。
6. 运行make命令：在命令行中，使用make命令来执行makefile 文件。
make命令会自动根据规则和依赖关系来编译源代码文件和生成目标文件。
例如，可以运行以下命令：``````make命令会根据makefile文件中的规则和依赖关系来编译源代码文件并生成目标文件和可执行文件。
makefile 中文手册 第四章 _ Makefile的规则
第四章：Makefile的规则本章我们将讨论Makefile的一个重要内容，规则。
熟悉规则对于书写Makefile至关重要。
Makefile中，规则描述了在何种情况下使用什么命令来重建一个特定的文件，此文件被称为规则“目标”（通常规则中的目标只有一个）。
规则中出目标之外的罗列的其它文件称为“目标”的依赖，而规则的命令是用来更新或者创建此规则的目标。
除了makefile的“终极目标”所在的规则以外，其它规则的顺序在makefile文件中没有意义。
“终极目标”就是当没有使用make 命令行指定具体目标时，make默认的更新的哪一个目标。
它是makefile文件中第一个规则的目标。
如果在makefile中第一个规则有多个目标的话，那么多个目标中的第一个将会被作为make的“终极目标”。
有两种情况的例外：1. 目标名以点号“.”开始的并且其后不存在斜线“/”（“./”被认为是当前目录；“../”被认为是上一级目录）；2. 模式规则的目标。
当这两种目标所在的规则是Makefile的第一个规则时，它们并不会被作为“终极目标”。
“终极目标”是执行make的唯一目的，其所在的规则作为第一个被执行的规则。
而其它的规则是在完成重建“终极目标”的过程中被连带出来的。
所以这些目标所在规则在Makefile中的顺序无关紧要。
因此，我们书写的makefile的第一个规则应该就是重建整个程序或者多个程序的依赖关系和执行命令的描述。
4.1 一个例子我们来看一个规则的例子：foo.o : foo.c defs.h # module for twiddling the frobscc -c -g foo.c这是一个典型的规则。
看到这个例子，大家应该能够说出这个规则的各个部分之间的关系。
不过我们还是要把这个例子拿出来讨论。
目的是让我们更加明确地理解Makefile的规则。
本例第一行中，文件“foo.o”是规则需要重建的文件，而“foo.c”和“defs.h”是重建“foo.o”所要使用的文件。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录1.简介 31.1.准备工作 31.2.Makefile介绍 31.3.规则简介 41.4.make工作原理 41.5.使用变量 51.6.简化命令 61.7.另一种风格 61.8.清理 72.Makefile 72.1.makefile名字 72.2.包含 82.3.‘MAKEFILE’变量 82.4.怎么重新生成makefile 82.5.重载makefile 93.规则 93.1.例子 93.2.规则的语法 93.3.通配符 103.3.1.通配符的缺陷 103.3.2.wildcard函数 113.4.目录搜索 113.4.1.‘VPATH’ 113.4.2.选择性搜索 123.4.3.使用自动变量 123.4.4.目录搜索和隐含规则 123.5.PHONY目标 133.6.FORCE目标 143.7.空目标 143.8.内建的特别目标 143.9.一个规则多个目标 153.10.一个目标多条规则 153.11.静态模式规则 163.11.1.语法 163.11.2.静态模式规则和隐式规则 173.12.双冒号规则 173.13.自动生成依赖关系 174.编写命令 184.1.回显 184.2.执行 194.3.并行执行 194.4.错误 194.5.中断make 204.6.递归使用 204.6.1.‘MAKE’变量 204.6.2.传递变量到子make 215.命令行参数 216.参考 256.1.指令 256.2.函数 266.3.自动变量 276.4.特别变量 29GNU Make使用Make 程式最初设计是为了维护C程式文件防止不必要的重新编译。
在使用命令行编译器的时候，修改了一个工程中的头文件，怎么确保包含这个头文件的所有文件都得到编译？目前10机的版本生成是使用批处理程式，编译那些文件依赖于程式的维护者，在模块之间相互引用头文件的情况下，要将所有需要重新编译的文件找出来是一件痛苦的事情；在找到这些文件之后，修改批处理进行编译。
实际上这些工作能让make程式来自动完成，make工具对于维护一些具有相互依赖关系的文件特别有用，他对文件和命令的联系（在文件改动时调用来更新其他文件的程式）提供一套编码方法。
Make工具的基本概念类似于Proglog语言，你告诉make需要做什么，提供一些规则，make来完成剩下的工作。
1.简介make工作自动确定工程的哪部分需要重新编译，执行命令去编译他们。
虽然make多用于C程式，然而只要提供命令行的编译器，你能将其用于所有语言。
实际上，make工具的应用范围不仅于编程，你能描述任和一些文件改动需要自动更新另一些文件的任务来使用他。
1.1.准备工作如果要使用make，你必须写一个叫做“makefile”的文件，这个文件描述工程中文件之间的关系，提供更新每个文件的命令。
典型的工程是这样的：可执行文件靠目标文件来更新，目标文件靠编译源文件来更新。
Makefile写好之后，每次更改了源文件后，只要执行make就足够了，所有必要的重新编译将执行。
Make程式利用makefile中的数据库和文件的最后修改时间来确定那个文件需要更新；对于需要更新的文件，make执行数据库中记录的命令。
能提供命令行参数给make来控制那个文件需要重新编译。
1.2.Makefile介绍Makefile文件告诉make做什么，多数情况是怎样编译和链接一个程式。
这里有一个简单的makefile，描述怎么编译链接由8个C文件和3个头文件组成的一个编辑器：edit : main.o kbd.o command.o display.oinsert.o serach.o files.o utils.occ ?o edit main.o kbd.o command.o display.oinsert.o search.o files.o utils.omain.o : main.c defs.hcc ?c main.ckdb.o : kbd.c defs.h command.hcc ?c kbd.ccommand.o : command.c defs.h command.hcc -c command.cdisplay.o : display.c defs.h buffer.hcc -c display.cinsert.o : insert.c defs.hbuffer.hcc -c insert.csearch.o : search.c defs.hbuffer.hcc -c search.cfiles.o : files.c defs.h buffer.h command.hcc -c files.cutils.o : utils.c defs.hcc -c utils.cclean :rm edit main.o kbd.o command.o display.oinsert.o search.o files.o utils.o将长行用分开便于阅读，这和使用一个长行的作用是相同的。
使用这个makefile创建可执行文件“edit”时运行make就能了；如果要将可执行文件和目标文件删除，执行make clean make重新编译这个编辑器时，每个更改的C文件必须重新编译；如果头文件更改了，每个包含头文件的C文件必须重新编译；每次编译产生一个对应于原文件的目标文件。
最终，目标文件链接在一起产生新的可执行文件。
1.3.规则简介makefile中的规则是这样的：TARGET … : DEPENDENCIES…COMMAND…目标（TARGET）程式产生的文件，如可执行文件和目标文件；目标也能是要执行的动作，如“clean”。
依赖（DEPENDENCIES）是用来产生目标的输入文件，一个目标通常依赖于多个文件。
命令（COMMAND）是make执行的动作，一个能有多个命令，每个占一行。
注意：每个命令行的起始字符必须为TAB字符！有依赖关系规则中的命令通常在依赖文件变化时负责产生target文件，make执行这些命令更新或产生target。
规则能没有依赖关系，如包含target “clean”的规则。
规则解释怎么和何时重做该规则中的文件，make根据依赖关系执行产生或更新目标；规则也说明怎么和何时执行动作。
有的规则看起来非常复杂，但都符合上述模式。
1.4.make工作原理缺省make从第一个target开始（第一个非’.’ 开始的target），这称作缺省目标。
在上述的makefile中，缺省目标是更新执行程式’edit’，将这个目标置于最前面。
当执行make的时候，make程式从当前目录读入makefile开始处理第一个规则；在例子中，这个规则是重新链接’edit’；在make处理这个规则之前，必须处理’edit’所依赖的那些文件的规则，例子中是目标文件。
这些文件按照他们自己的规则处理：通过编译源文件来更新每个’.o’文件；当依赖关系中的源文件或头文件比目标文件新，或目标文件不存在时，必须重新编译。
其他的规则被处理是因为他们的target是目标的依赖，和目标没有依赖关系的规则不会被处理，除非指定make处理（如make clean）。
在重新编译目标文件之前，make会试图更新他的依赖：源文件和头文件。
例子中的makefile 对源文件和头文件未指定所有操作：’.c’和’.h’文件不是所有规则的目标。
确认所有的目标文件都是最新的之后，make决定是否重新链接’edit’：如果’edit’不存在，或所有一个目标文件都比他新，则链接工作将进行。
这样，如果我们改动insert.c运行make，make会编译这个文件来更新’insert.o’，然后链接’edit’；如果修改了’command.h’运行make，’kbd.o’，’command.o’，’files.o’会重新生成，链接’edit’。
1.5.使用变量在例子中，在规则’edit’中，目标文件被列出来两次：edit : main.o kbd.o command.o display.oinsert.o search.o files.o utils.occ -o edit main.o kbd.o command.o display.oinsert.o search.o files.o utils.o这样的重复容易出错：假设工程中加入了一个新的目标文件，可能只将其加入了一个列表中；通过使用变量能消除这种风险：变量允许一个预定义的字符串在多个地方被替换。
在makefile中，能写这样一行来定义’object’变量：objects = main.o kbd.o command.o display.oinsert.o search.o files.o utils.o于是在需要目标文件名列表的地方，使用$(object) 来代替变量的值。
以下是使用了变量以后的makefile：objects = main.o kbd.o command.o display.oinsert.o search.o files.o utils.oedit : $(objects)cc -o edit $(objects)main.o : main.c defs.hcc -c main.ckbd.o : kbd.c defs.h command.hcc -c kbd.ccommand.o : command.c defs.h command.hcc -c command.cdisplay.o : display.c defs.h buffer.hcc -c display.cinsert.o : insert.c defs.hbuffer.hcc -c insert.csearch.o : search.c defs.hbuffer.hcc -c search.cfiles.o : files.c defs.h buffer.h command.hcc -c files.cutils.o : utils.c defs.hcc -c utils.cclean :rm edit $(objects)1.6.简化命令为每个文件写出编译命令不是必要的，因为make能自己来做；以’.c’文件更新’.o’文件有一个隐含的规则，使用’cc -c’命令。
Make将利用’cc ?c main.c?o main.o’来将main.c编译为main.o，因此在生成目标文件的规则中，能省略命令。
当’.c’文件以这样的方式使用时，将自动加入到依赖关系中；由是在省略命令的前提下，能将’.c’文件从依赖关系中省略。
以下是简化过的makefile：objects = main.o kbd.o command.o display.oinsert.o search.o files.o utils.oedit : $(objects)cc -o edit $(objects)main.o : defs.hkbd.o : defs.h command.hcommand.o : defs.h command.hdisplay.o : defs.h buffer.hinsert.o : defs.h buffer.hsearch.o : defs.h buffer.hfiles.o : defs.h buffer.h command.hutils.o : defs.h.PHONY : cleanclean :-rm edit $(objects)1.7.另一种风格如果makefile中的目标都是以隐含规则生成，能将规则按照依赖关系分组：objects = main.o kbd.o command.o display.oinsert.o search.o files.o utils.oedit : $(objects)cc -o edit $(objects)$(objects) : defs.hkbd.o command.o files.o : command.hdisplay.o insert.o search.o files.o : buffer.h这里’defs.h’作为所有目标文件的依赖。