Makefile学习

Makefile

1 Makefile基础

Makfile的原则

1）.如果这个工程没有编译过，那么我们的所有C文件都要编译并被链接。2）.如果这个工程的某几个C文件被修改，那么我们只编译被修改的C文件，并链接目标程序。

3）.如果这个工程的头文件被改变了，那么我们需要编译引用了这几个头文件的C文件，并链接目标程序。

target... : prerequisites ...

command

...

...

target也就是一个目标文件，可以是Object File，也可以是执行文件。还可以是一个标签（Label），对于标签这种特性，在后续的―伪目标‖章节中会有叙述。prerequisites就是，要生成那个target所需要的文件或是目标。

command也就是make需要执行的命令。（任意的Shell命令）

这是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖

于prerequisites中的文件，其生成规则定义在command 中。说白一点就是说，prerequisites中如果有一个以上的文件比target文件要新的话，command所定义

的命令就会被执行。这就是Makefile的规则。也就是Makefile中最核心的内容。

在定义好依赖关系后，后续的那一行定义了如何生成目标文件的操作系统命令，一定要以一个Tab键作为开头。记住，make并不管命令是怎么工作的，他只管执行所定义的命令。make会比较targets文件和prerequisites文件的修改日期，如果prerequisites文件的日期要比targets文件的日期要新，或者target不存在的话，那么，make就会执行后续定义的命令。

make自动推导

GNU的make很强大，它可以自动推导文件以及文件依赖关系后面的命令，于是我们就没必要去在每一个[.o]文件后都写上类似的命令，因为，我们的make会自动识别，并自己推导命令。

只要make看到一个[.o]文件，它就会自动的把[.c]文件加在依赖关系中，如果make找到一个whatever.o，那么whatever.c，就会是whatever.o的依赖文件。并且cc -c whatever.c 也会被推导出来

清空目标文件的规则

每个Makefile中都应该写一个清空目标文件（.o和执行文件）的规则，这不仅便于重编译，也很利于保持文件的清洁。一般的风格都是：

clean:

rm obj $(objects)

更为稳健的做法是：

.PHONY : clean

clean :

-rm obj $(objects)

.PHONY意思表示clean是一个―伪目标‖。而在rm命令前面加了一个小减号的意思就是，也许某些文件出现问题，但不要管，继续做后面的事。当然，clean 的规则不要放在文件的开头，不然，这就会变成make的默认目标。不成文的规矩是——―clean从来都是放在文件的最后‖。

2 Makefile 总述

Makefile里主要包含了五个东西：显式规则、隐晦规则、变量定义、文件指示和注释。

1.显式规则。显式规则说明了，如何生成一个或多的的目标文件。这是由

Makefile的书写者明显指出，要生成的文件，文件的依赖文件，生成的命令。

2.隐晦规则。由于make有自动推导的功能，所以隐晦的规则可以让我们比

较粗糙地简略地书写Makefile，这是由make所支持的。

3.变量的定义。在Makefile中我们要定义一系列的变量，变量一般都是字符

串，这个有点像C语言中的宏，当Makefile被执行时，其中的变量都会被扩展到相应的引用位置上。

4.文件指示。其包括了三个部分，一个是在一个Makefile中引用另一个

Makefile，就像C语言中的include一样；另一个是指根据某些情况指定Makefile中的有效部分，就像C语言中的预编译#if一样；还有就是定义一个多行的命令。

5.注释。Makefile中只有行注释，和UNIX的Shell脚本一样，其注释是用

―#‖字符，这个就像C/C++中的―//‖一样。如果你要在你的Makefile中使用―#‖字符，可以用反斜框进行转义，如：―\#‖。

在Makefile使用include关键字可以把别的Makefile包含进来，这很像C语言的#include，被包含的文件会原模原样的放在当前文件的包含位置。include的语法是：

自动生成依赖性

在Makefile中，我们的依赖关系可能会需要包含一系列的头文件，比如，如果我们的main.c中有一句―#include "defs.h"‖，那么我们的依赖关系应该是：

main.o : main.c defs.h

但是，如果是一个比较大型的工程，你必需清楚哪些C文件包含了哪些头文件，并且，你在加入或删除头文件时，也需要小心地修改Makefile，这是一个很没有维护性的工作。为了避免这种繁重而又容易出错的事情，我们可以使用C/C++编译的一个功能。大多数的C/C++编译器都支持一个―-M‖的选项，即自动找寻源文件中包含的头文件，并生成一个依赖关系。例如，如果我们执行下面的命令： cc -M main.c

其输出是：

main.o : main.c defs.h

条件关键字

1 ―ifdef‖。语法是：

ifdef

如果变量的值非空，那到表达式为真。否则，表达式为假。当然，同样可以是一个函数的返回值。注意，ifdef只是测试一个变量是否有值，其并不会把变量扩展到当前位置。还是来看两个例子：

示例一：

bar =

foo = $(bar)

ifdef foo #foo 在这里没有进行扩展，所以此时值为true

endif

示例二：

foo =

ifdef foo #false

endif为了避免混乱，make不允许把整个条件语句分成两部分放在不同的文件中。

2 “ifeq”，语法是

ifeq (arg1,arg2) / ifeq ―arg1‖‖arg2‖ / if ?arg1‘?arg2‘

;

else / 也可以没有else

;

endif

关于变量

1 多行变量

还有一种设置变量值的方法是使用define 关键字。使用define 关键字设置变量的值可以有换行，这有利于定义一系列的命令（前面我们讲过―命令包‖的技术就是利用这个关键字）。define 指示符后面跟的是变量的名字，而重起一行定义变量的值，定义是以endef 关键字结束。其工作方式和―=‖操作符一样。变量的

值可以包含函数、命令、文字，或是其它变量。因为命令需要以[Tab]键开头，所以如果你用define 定义的命令变量中没有以[Tab]键开头，那么make 就不会

把其认为是命令。

下面的这个示例展示了define 的用法：

define two-lines

echo foo

echo $(bar)

endef

2 变量的高级用法

我们可以替换变量中的共有的部分，其格式是―$(var:a=b)‖或是―${var:a=b}‖，其意思是，把变量―var‖中所有以―a‖字串―结尾‖的―a‖替换成―b‖字串。这里的―结尾‖意思是―空格‖或是―结束符‖。

如：

foo := a.o b.o c.o

bar := $(foo:.o=.c)

这个示例中，我们先定义了一个―$(foo)‖变量，而第二行的意思是把―$(foo)‖中所有以―.o‖字串―结尾‖全部替换成―.c‖，所以我们的―$(bar)‖的值就是―a.c b.c c.c‖

3 当make 嵌套调用时（参见前面的―嵌套调用‖章节），上层Makefile 中定义的变量会以系统环境变量的方式传递到下层的Makefile 中。当然，默认情况下，只有通过命令行设置的变量会被传递。而定义在文件中的变量，如果要向下层Makefile 传递，则需要使用exprot关键字来声明。

Makefile 中include 的用法

include 类似于c语言中的#include，是将指定的makefile文件包含进来，格式如下：include filename –》在当前路径下找要包含的mk文件。

或者（include filepath/filename 指定路径），或者命令行选项―-I‖或者

―--include-dir‖如果找到指定的文件,则使用这个文件;否则依此搜索以下几个目录(如果存在) ―/usr/gnu/include‖―/usr/local/include‖和―/usr/include‖。当在这些目录下都没有找到―include‖指定的文件时,make将会提示一个包含文件未找到的告警提示, 但是不会立刻退出此时，如果在指定的路径下没有要包含的mk文件。

如果在指定或者当前目录下没有找到指定的mk文件，当前总控makefile 会继续处理其他的内容，当读取整个makefile后，再次试图使用规则来创建通过指示符“include”指定的但未找到的文件，当不能创建它时（没有创建这个文件的规则），make将提示致命错误并退出。

Makefile中可使用“-include”来代替“include”，来忽略由于包含文件不存在或者无法创建时的错误提示。在进行make时不会出现错误，更不会停止。

include 的意义：（自己学习理解）先看如下code：

当前目录下包含a、b两个目录，a、b中分别包含a.c b.c两个文件，

1 test:main.o a.o b.o

2 cc -o test main.o a.o b.o

3 -include /home/jaychen/test/make/b/Makefile （或直接为b/Makefile）

4 -include /home/jaychen/test/make/a/Makefile

clean:

rm *.o test –f

当我在写这个的时候，先看了网上的资料，解释说3 和4 两行需要放在1行前面，然后我试了，发现只会运行b的mk，后面的停止了。然后我又将code 调为现在的样子，发现就好了。于是，我就反思，makefile中第一行中如果有类似目标:依赖格式的将作为这个mk的最终目标，当3、4两行在前面，也就是3行在第一行，那么就作为最终目标，然后就运行cc -c b.c (b mk中的内容)，因为

没有其他的依赖性，就不会进行make自动推导，所以就会停止，当code如上时，test 会依赖a.o 、b.o，就会进行自动推导，就会在include包含进来的mk中查找。。。然后就行了。

a 的makefile 为：

a.o:a/a.c

cc -c a/a.c

其中需要注意的是，这里在引用a.c或b.c时需要指明路径，因为a、b两个的mk是被包含在了当前目录中的mk中，相当于把两个mk的内容写到了当前目录的mk中，并在这个mk中执行。

嵌套执行makefile

假定一个目录为other_path下面有makefile文件，

other_path= */*/* (目录的最后一个*为makefile的所在目录)

可以有两种方式

1 $(MAKE) –C other_path

2 cd other_path && $(MAKE) $(MAKE)就是make

如果想要在make时显示信息到屏幕中，可以这样：

all:dis_begin test dis_end （我经过实践，makefile中，各个伪目标执行的顺序是从左到右）

.PHONY:all

dis_begin:

@echo ------- begin bulid ---------

dis_end:

@echo -------- end bulid ----------

如果要嵌套执行make clean 或其他的命令，格式如下

1 $(MAKE) clean –C other_path （或者将clean 置于句末）

2 cd other_path && $(MAKE) clean

我们把这个Makefile 叫做―总控Makefile‖，总控Makefile 的变量可以传递到下级的Makefile中（如果你显示的声明），但是不会覆盖下层的Makefile 中所定义的变量，除非指定了―-e‖参数。如果你要传递变量到下级Makefile 中，那么你可以使用这样的声明：

export ;

如果你不想让某些变量传递到下级Makefile 中，那么你可以这样声明：unexport ;

如：

export variable = value

其等价于：

variable = value

export variable

Makefile 动态库和静态库

1 动态库

Linux下的动态库以.so为后缀，在Linux下使用动态库。动态库在程序运行时被链接。

第一步：编写Linux程序库

动态库实现文件test.c

第二步：编译生成动态库

gcc test.c -shared -o –fPIC -o libtest.so

由以上命令生成动态库libtest.so，为了不需要动态加载动态库，在命令时需以lib开头以.so为后缀。

–fPIC：表示编译为位置独立的代码，不用此选项的话编译后的代码是位置相关的所以动态载入时是通过代码拷贝的方式来满足不同进程的需要，而不能达到真正代码段共享的目的。

–shared：指明编译成动态库。

第三步：使用动态库

文件main.c .动态库使用文件test.c。使用动态库libtest.so,

编译命令：

gcc test.c –L . –ltest –o test

–L：指明动态库所在的目录

-l：指明动态库的名称，该名称是处在头lib和后缀.so中的名称，如上动态库libtest.so的l参数为-l test。

测试：

ldd test

ldd 测试可执行文件所使用的动态库

编译时指定动态库加载路径命令：

gcc test.c -L . -ltest -o test -Wl,-rpath=./

gcc编译链接动态库时，很有可能编译通过，但是执行时，找不到动态链接库，那是因为-L选项指定的路径只在编译时有效，编译出来的可执行文件不知道-L选项后面的值，当然找不到。可以用ldd 看看是不有?not found‘在你链接的库后面，解决方法是通过-Wl,rpath=，使得execute 记住链接库的位置

2 静态库

链接静态库其实从某种意义上来说也是一种粘贴复制，只不过它操作的对象是目标代码而不是源码。

创建静态库：

第一步：生成目标文件并归档。

gcc -c pathname/test.c (在makefile中这一步可由make自动推导)

ar r libtest.a pathname/test.o(pathname/test2.o)

libtest.a就是生成的静态库。

第二步：链接静态库

gcc main.c -L . -ltest -static-o main

比链接动态库时多了一个static。

函数以及调用

1 函数的调用语法

函数调用，很像变量的使用，也是以―$‖来标识的，其语法如下：

$(; )

或是

${; ;}

2 字符串处理函数

$(subst ,, )

名称：字符串替换函数——subst。

功能：用字串来替换中的字符串。

返回：函数返回被替换过后的字符串。

$(patsubst ,, )

名称：模式字符串替换函数——patsubst。

功能：查找中的单词（单词以―空格‖、―Tab‖或―回车‖―换行‖分隔）是否符合模式，如果匹配的话，则以替换。这里，可以包括通配符―%‖，表示任意长度的字串。如果中也包含―%‖，那么，中的这个―%‖将是中的那个―%‖所代表的字串。（可以用―\‖来转义，以―\%‖来表示真实含义的―%‖字符）返回：函数返回被替换过后的字符串。

$(strip )

名称：去空格函数——strip。

功能：去掉字串中开头和结尾的空字符。

返回：返回被去掉空格的字符串值。

$(findstring , )

名称：查找字符串函数——findstring。

功能：在字串中查找字串。

返回：如果找到，那么返回，否则返回空字符串。

$(filter , )

名称：过滤函数——filter。

功能：以模式过滤字符串中的单词，保留符合模式的单词。可以有多个模式。

返回：返回符合模式的字串。

$(wordlist ,, )

名称：取单词串函数——wordlist。

功能：从字符串中取从开始到的单词串。和是一个数字。

返回：返回字符串中从到的单词字串。如果比中的单词数要大，那么返回空字符串。如果大于的单词数，那么返回从开始，到结束的单词串。

$(foreach ,, )

这个函数的意思是，把参数中的单词逐一取出放到参数所指定的变量中，然后再执行 所包含的表达式。每一次会返回一个字符串，循环过程中，的所返回的每个字符串会以空格分隔，最后当整个循环结

束时，所返回的每个字符串所组成的整个字符串（以空格分隔）将会是foreach函数的返回值。

$(if , )

或是

$(if ,, )

call函数

call函数是唯一一个可以用来创建新的参数化的函数。你可以写一个非常复杂的表达式，这个表达式中，你可以定义许多参数，然后你可以用call函数来向这个表达式传递参数。其语法是

$(call ,,,...)

当make执行这个函数时，参数中的变量，如$(1)，$(2)，$(3)等，会被参数，，依次取代。而的返回值就是call函数的返回值。例如：

reverse = $(1) $(2)

foo = $(call reverse,a,b)

那么，foo的值就是―a b‖。当然，参数的次序是可以自定义的，不一定是顺序的，如：

reverse = $(2) $(1)

foo = $(call reverse,a,b)

此时的foo的值就是―b a‖。

origin函数

不像其它的函数，他并不操作变量的值，他只是告诉你你的这个变量是哪里来的？其语法是：

$(origin )

shell函数

它的参数应该就是操作系统Shell的命令。shell函数把执行操作系统命令后的输出作为函数。

contents := $(shell cat foo)

files := $(shell echo *.c)

PWD:= $(shell pwd)

跟我一起写Makefile

跟我一起写Makefile 陈皓 1 概述 什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。 因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。 makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。 现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。当然，不同产商的make各不相同，也有不同的语法，但其本质都是在“文件依赖性”上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0，make的版本是3.80。必竟，这个make是应用最为广泛的，也是用得最多的。而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。 在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX下的GCC和CC。 2 关于程序的编译和链接 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在Windows下也就是.obj 文件，UNIX下是.o 文件，即Object File，这个动作叫做编译（compile）。然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。 编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ 文件）。 链接时，主要是链接函数和全局变量，所以，我们可以使用这些中间目标文件（O文件或是OBJ文件）来链接我们的应用程序。链接器并不管函数所在的源文件，只管函数的中间目标文件（Object File），在大多数时候，由于源文件太多，编译生成的中间目标文件太多，而在链接时需要明显地指出中间目标文件名，这对于编译很不方便，所以，我们要给中间目标文件打个包，在Windows下这种包叫“库文件”（Library File)，也就是.lib 文件，在UNIX下，是Archive File，也就是.a 文件。 总结一下，源文件首先会生成中间目标文件，再由中间目标文件生成执行文件。在编译时，编译器只检测程序语法，和函数、变量是否被声明。如果函数未被声明，编译器会给出一个警告，但可以生成Object File。而在链接程序时，链接器会在所有的Object File中找寻函数的实现，如果找不到，那到就会报链接错

makefile新手教程

makefile新手教程 2013-11-08 本文翻译自https://www.wendangku.net/doc/e111791287.html,/tutorials/ Makefiles --通过示例说明 编译源代码是沉闷的，尤其是当你想要include一些源代码，却又每次都需要手动敲编译命令的时候。 恩，我有个好消息告诉你...你用手敲命令行去编译的日子（基本上）一去不复返了，因为你将会学习如何编写Makefile。Makefile是配合make命令使用的特殊文件，make命令则会帮助你自动地、神奇般地管理你的工程。 这里你需要先准备以下文件： main.cpp

hello.cpp factorial.cpp functions.cpp 我建议你新建一个空的目录，然后将上述4个文件放入其中。

注意：我使用g++命令编译。你完全可以换成别的编译器 make工具 如果你运行make 它会去寻找当前目录下名字为makefile的文件，并按里面的内容执行。 如果你有很多makefile文件，那么可以用这个命令来执行： 当然还有其他的参数来使用make工具，详情请man make。 构建过程 1.编译器编译源代码文件，输出到目标文件 2.链接器将目标文件链接，并创建可执行文件 手动编译 手动编译并获得可执行文件，是一种琐碎的方式： 基本的Makefile

基本的makefile文件组成如下： 将此语法应用到我们的例子中，就是: all: g++ main.cpp hello.cpp factorial.cpp -o hello 我们将此文件保存为Makefile-1。要运行此makefile，则输入：make -f Makefile-1 在这个例子中可以看到，我们的target叫做all。这是makefile中的默认target。若无指定参数，make工具将按这个target 执行。 我们同时发现，这个例子中的target，也就是all，没有dependencies（依赖文件），因此make会安全地执行后续的system commands（系统命令）。 最后，make根据我们设定的命令完成了编译。 使用依赖文件 有时候使用多个不同的target会很有用，因为当你只修改了工程中的一个文件时，不必重新编译所有代码，只需要编译修改过的部分。比如：

Makefile规则

目录 1.简介 3 1.1.准备工作 3 1.2.Makefile介绍 3 1.3.规则简介 4 1.4.make工作原理 4 1.5.使用变量 5 1.6.简化命令 6 1.7.另一种风格 6 1.8.清理 7 2.Makefile 7 2.1.makefile名字 7 2.2.包含 8 2.3.‘MAKEFILE’变量 8 2.4.怎么重新生成makefile 8 2.5.重载makefile 9 3.规则 9 3.1.例子 9 3.2.规则的语法 9 3.3.通配符 10 3.3.1.通配符的缺陷 10 3.3.2.wildcard函数 11 3.4.目录搜索 11 3.4.1.‘VPATH’ 11 3.4.2.选择性搜索 12 3.4.3.使用自动变量 12 3.4.4.目录搜索和隐含规则 12 3.5.PHONY目标 13 3.6.FORCE目标 14 3.7.空目标 14 3.8.内建的特别目标 14 3.9.一个规则多个目标 15 3.10.一个目标多条规则 15 3.11.静态模式规则 16 3.11.1.语法 16 3.11.2.静态模式规则和隐式规则 17 3.12.双冒号规则 17 3.13.自动生成依赖关系 17 4.编写命令 18 4.1.回显 18 4.2.执行 19 4.3.并行执行 19 4.4.错误 19 4.5.中断make 20 4.6.递归使用 20 4.6.1.‘MAKE’变量 20 4.6.2.传递变量到子make 21 5.命令行参数 21 6.参考 25

6.1.指令 25 6.2.函数 26 6.3.自动变量 27 6.4.特别变量 29 GNU 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.o insert.o serach.o files.o utils.o cc ?o edit main.o kbd.o command.o display.o insert.o search.o files.o utils.o main.o : main.c defs.h cc ?c main.c kdb.o : kbd.c defs.h command.h cc ?c kbd.c command.o : command.c defs.h command.h cc -c command.c display.o : display.c defs.h buffer.h cc -c display.c insert.o : insert.c defs.hbuffer.h cc -c insert.c search.o : search.c defs.hbuffer.h cc -c search.c files.o : files.c defs.h buffer.h command.h cc -c files.c utils.o : utils.c defs.h cc -c utils.c

windows下的makefile教程

windows下的makefile教程 https://www.wendangku.net/doc/e111791287.html,/mirror_hc/archive/2008/03/26/2221117.aspx joeliu 制作4/19/2011 22:10:29 1. 先说几句废话 以前看书时经常遇到makefile，nmake这几个名词，然后随之而来的就是一大段莫名其妙的代码，把我看得云里雾里的。在图书馆和google上搜了半天，也只能找到一些零零星星的资料，把我一直郁闷得不行。最近因缘巧合，被我搞到了一份传说中的MASM6手册，终于揭开了NMAKE的庐山真面目。想到那些可能正遭受着同样苦难的同志以及那些看到E文就头晕的兄弟，所以就写了这篇文章。假如大家觉得有帮助的话，记得回复一下，当作鼓励！如果觉得很白痴,也请扔几个鸡蛋.本文是总结加翻译，对于一些关键词以及一些不是很确定的句子，保留了英文原版，然后再在括号里给出自己的理解以作参考。由于水平有限，加上使用NMAKE的经验尚浅，有不对的地方大家记得要指正唷。MASM6手册在AOGO（好像是）可以download，在我的BLOG上有到那的链接。 2. 关于NMAKE Microsoft Program Maintenance Utility，外号NMAKE，顾名思义，是用来管理程序的工具。其实说白了，就是一个解释程序。它处理一种叫做makefile的文件（以mak为后缀），解释里面的语句并执行相应的指令。我们编写makefile文件，按照规定的语法描述文件之间的依赖关系，以及与该依赖关系相关联的一系列操作。然后在调用NMAKE时，它会检查所有相关的文件，如果目标文件（target file，下文简称target，即依赖于其它文件的文件）的time stamp（就是文件最后一次被修改的时间，一个32位数，表示距离1980年以来经过的时间，以2秒为单位）小于依赖文件（dependent file，下文简称dependent，即被依赖的文件）的time stamp，NMAKE就执行与该依赖关系相关联的操作。请看下面这个例子：foo.exe : first.obj second.obj link first.obj,second.obj 第一行定义了依赖关系，称为dependency line；第二行给出了与该依赖关系相关联的操作，称为command line。因为foo.exe由first.obj和second.obj连接而成，所以说foo.exe依赖于first.ogj和second.obj，即foo.exe为target，first.obj和second.obj为dependent。如果first.obj和second.obj中的任何一个被修改了（其time stamp更大），则调用link.exe，重新连接生成foo.exe。这就是NMAKE的执行逻辑。 综上，NMAKE的核心就是这3个家伙——依赖关系，操作和判定逻辑（target.timestamp < dependent.timestamp，如果为true，就执行相应操作）。 3. MAKEFILE的语法 现在详细讨论一下makefile的语法。makefile就像一个玩具型的程序语言，麻雀虽小，但五脏具全。makefile的组成部分包括：描述语句（description block），推导规则（inference rules），宏和指令（directive）。 描述语句就是dependent lines和command lines的组合；推导规则就是预先定义好的或用户自己定义的依赖关系和关联命令；宏就不用说了吧；指令就是内定的一些可以被NMAKE识别的控制命令，提供了很多有用的功能。 3.1 特殊符号

synopsis VCS makefile编写

SYNOPSYS VCS Makefile文件编写与研究 SYNOPSYS VCS Makefile文件编写与研究 这个Makefile是synopsys提供的模板，看上去非常好用，你只要按部就班提供实际项目的参数就可以了。我们来看这个文件的头部说明： makefile 其实完全可以用csh或其他脚本来编写，只是VCS使用的linux内置的make命令定义了一个标准的仿真脚本，make命令是专门用来 做项目的源文件管理和编译控制的命令。这篇文章重点看synpsys的标准仿真脚本都做了哪些操作，然后使用其他脚本来实现。这里主要是自己 写的一点东西，有些地方是猜测的或者不准确。 #--------------------------------------------------------------------------------------------------------------------------- # SYNOPSYS CONFIDENTIAL - This is an unpublished, proprietary work of # Synopsys, Inc., and is fully protected under copyright and trade secret # laws. You may not view, use, disclose, copy, or distribute this file or # any information contained herein except pursuant to a valid written # license from Synopsys. # SYNOPSYS公司的版权声明，没有权限不可使用 #----------------------------------------------------------------------------------------------------------------------------- # Filename : $Id: Makefile,v 1.0 2006/07/18 23:59:59 vangundy Exp $ # Created by : Synopsys Inc. 07/17/2006 # $Author : vangundy $ # Description : Demonstrates Verilog DUT and SVTB using VCS # makefile文件头 #--------------------------------------------------------------------------------------------------------------------------- # The Makefile works on two seperate flows. The DEBUG flow is intended to be used # During debugging of a testcase and/or the DUT. The REGRESSION flow is used # During regression runs and collects coverage data. #该makefile模版包括两部分流程，debug（查错）流程和regress（回归测试）流程，两个

Makefile两个实验

实验十四Makefile工程管理器 14.1 编写包含多文件的Makefile 【实验内容】 编写一个包含多文件的Makefile。 【实验目的】 通过对包含多文件的Makefile的编写，熟悉各种形式的Makefile，并且进一步加深对Makefile中用户自定义变量、自动变量及预定义变量的理解。 【实验平台】 PC机、CentOS 5 操作系统、gcc等工具。 【实验步骤】 1.用vi在同一目录下编辑两个简单的Hello程序，如下所示： #hello.c #include "hello.h" int main() { printf("Hello everyone!\n"); } #hello.h #include 2.仍在同一目录下用vim编辑Makefile，不使用变量替换，用一个目标体实现（即直接将 hello.c和hello.h编译成hello目标体）。并用make验证所编写的Makefile是否正确。 3.将上述Makefile使用变量替换实现。同样用make验证所编写的Makefile是否正确 4.用编辑另一Makefile，取名为Makefile1，不使用变量替换，但用两个目标体实现（也 就是首先将hello.c和hello.h编译为hello.o，再将hello.o编译为hello），再用make 的‘-f’选项验证这个Makefile1的正确性。 5.将上述Makefile1使用变量替换实现 【详细步骤】 1.用vi打开上述两个代码文件…hello.c?和…hello.h? 2.在shell命令行中用gcc尝试编译，使用命令：…gcc hello.c -o hello?，并运行hello可执 行文件查看结果。 3.删除此次编译的可执行文件：rm –rf hello 4.用vim编辑Makefile，如下所示： hello:hello.c hello.h gcc hello.c -o hello 5.退出保存，在shell中键入：make查看结果 6.再次用vim打开Makefile，用变量进行替换，如下所示： OBJS :=hello.o CC :=gcc hello:$(OBJS) $(CC) $^ -o $@ 7.退出保存，在shell中键入：make查看结果

Linux如何写makefile文件

Linux如何写makefile文件 关于程序的编译和链接 —————————— 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，即 Object File，这个动作叫做编译（compile）。然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。 编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在 C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ文 件）。 链接时，主要是链接函数和全局变量，所以，我们可以使用这些中间目标文件（O文件或是OBJ文件）来链接我们的应用程序。链接器并不管函数所在的源文件， 只管函数的中间目标文件（Object File），在大多数时候，由于源文件太多，编译生成的中间目标文件太多，而在链接时需要明显地指出中间目标文件名，这对于编译很不方便，所以，我们要给 中间目标文件打个包，在Windows 下这种包叫“库文件”（Library File)，也就是 .lib 文件，在UNIX下，是Archive File，也就是 .a 文件。 总结一下，源文件首先会生成中间目标文件，再由中间目标文件生成执行文件。在编译时，编译器只检测程序语法，和函数、变量是否被声明。如果函数未被声明， 编译器会给出一个警告，但可以生成Object File。而在链接程序时，链接器会在所有的Object File中找寻函数的实现，如果找不到，那到就会报链接错误码（Linker Error），在VC下，这种错误一般是：Link 2001错误，意思说是说，链接器未能找到函数的实现。你需要指定函数的Object File. 好，言归正传，GNU的make有许多的内容，闲言少叙，还是让我们开始吧。 Makefile 介绍 ——————— make命令执行时，需要一个 Makefile 文件，以告诉make命令需要怎么样的去编译和链接程序。 首先，我们用一个示例来说明Makefile的书写规则。以便给大家一个感兴认识。这个示例来源于GNU的make使用手册，在这个示例中，我们的工程有 8

Makefile超强经典教程

Makefile经典教程 0 Makefile概述 (2) 0.1关于程序的编译和链接 (2) 1 Makefile介绍 (3) 1.1 Makefile的规则 (4) 1.2一个示例 (4) 1.3 make是如何工作的 (6) 1.4 makefile中使用变量 (7) 1.5让make自动推导 (8) 1.6另类风格的makefile (9) 1.7清空目标文件的规则 (10) 2 Makefile总述 (11) 2.1 Makefile里有什么？ (11) 2.2Makefile的文件名 (12) 2.3引用其它的Makefile (12) 2.4环境变量MAKEFILES (13) 2.5 make的工作方式 (13) 3 Makefile书写规则 (14) 3.1规则举例 (14) 3.2规则的语法 (14) 3.3在规则中使用通配符 (15) 3.4文件搜寻 (16) 3.5伪目标 (17) 3.6多目标 (19) 3.7静态模式 (20) 3.8自动生成依赖性 (22) 4 Makefile书写命令 (24) 4.1显示命令 (24) 4.2命令执行 (25) 4.3命令出错 (25) 4.4嵌套执行make (26) 4.5定义命令包 (29) 1

0 Makefile概述 什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。 因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。 makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。 现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。当然，不同产商的make各不相同，也有不同的语法，但其本质都是在“文件依赖性”上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0，make的版本是3.80。必竟，这个make是应用最为广泛的，也是用得最多的。而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。 在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX下的GCC和CC。 0.1关于程序的编译和链接 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在Windows下也就是.obj 文件，UNIX

3-Makefile书写规则

3 Makefile书写规则 规则包含两个部分，一个是依赖关系，一个是生成目标的方法。 在Makefile中，规则的顺序是很重要的，因为，Makefile中只应该有一个最终目标，其它的目标都是被这个目标所连带出来的，所以一定要让make知道你的最终目标是什么。一般来说，定义在Makefile中的目标可能会有很多，但是第一条规则中的目标将被确立为最终的目标。如果第一条规则中的目标有很多个，那么，第一个目标会成为最终的目标。make所完成的也就是这个目标。 好了，还是让我们来看一看如何书写规则。 3.1 规则举例 foo.o : foo.c defs.h # foo模块 cc -c -g foo.c 看到这个例子，各位应该不是很陌生了，前面也已说过，foo.o是我们的目标，foo.c和defs.h是目标所依赖的源文件，而只有一个命令“cc -c - g foo.c”（以Tab键开头）。这个规则告诉我们两件事： 1. 文件的依赖关系，foo.o依赖于foo.c和defs.h的文件，如果foo.c 和defs.h的文件日期要比foo.o文件日期要新，或是foo.o不存 在，那么依赖关系发生。 2. 如果生成（或更新）foo.o文件。也就是那个cc命令，其说明 了，如何生成foo.o这个文件。（当然foo.c文件include了defs.h 文件） 3.2 规则的语法 targets : prerequisites command

... 或是这样： targets : prerequisites ; command command ... targets是文件名，以空格分开，可以使用通配符。一般来说，我们的目标基本上是一个文件，但也有可能是多个文件。 command是命令行，如果其不与“target:prerequisites”在一行，那么，必须以[Tab键]开头，如果和prerequisites在一行，那么可以用分号做为分隔。（见上） prerequisites也就是目标所依赖的文件（或依赖目标）。如果其中的某个文件要比目标文件要新，那么，目标就被认为是“过时的”，被认为是需要重生成的。这个在前面已经讲过了。 如果命令太长，你可以使用反斜框（‘\’）作为换行符。make对一行上有多少个字符没有限制。规则告诉make两件事，文件的依赖关系和如何成成目标文件。 一般来说，make会以UNIX的标准Shell，也就是/bin/sh来执行命令。3.3 在规则中使用通配符 如果我们想定义一系列比较类似的文件，我们很自然地就想起使用通配符。make支持三各通配符：“*”，“?”和“[...]”。这是和Unix的B-Shell是相同的。 波浪号（“~”）字符在文件名中也有比较特殊的用途。如果是“~/test”，这就表示当前用户的$HOME目录下的test目录。而“~hchen/test”则表示用户hchen的宿主目录下的test目录。（这些都是Unix下的小知识了，make也支持）而在Windows或是MS-DOS下，用户没有宿主目录，那么波浪号所指的目录则根据环境变量“HOME”而定。

Linux下Makefile简单教程

目录 一：Makefile基本规则 1.1示例 1.2 隐式规则 1.3 伪目标 1.4 搜索源文件 二：变量 2.1使用变量定义变量值 2.2追加变量 三：条件判断 四：函数

Linux下Makefile总结 ——一步 MakeFile可以看做是一种简单的编程语言，其诞生的本质目的是实现自动化编译。 以Linux下gcc-c编译器为例，编译一个c语言程序需要经过以下几个步骤： 1.将c语言源程序预处理，生成.i文件； 2.预处理后的.i语言编译成汇编语言，生成.s文件； 3.汇编语言经过汇编，生成目标文件.o文件； 4.将各个模块的.o文件链接起来，生成一个可执行程序文件。 我们知道，在Visual C++6.0中，可以新建一个工程，在一个工程当中能够包含若干个c语言文件，则编译的时候直接编译整个工程便可。Linux下无法为多个c语言文件新建工程，但可以通过MakeFile实现它们的整合编译。 如上gcc-c编译步骤，如果使用Makefile则过程为： .C文件——>.o文件——>可执行文件 当然，Makefile中也加入了自己的设置变量方法与集成了一些函数，能够更有效地方便用户使用。 /**************************分隔符********************************/

一：Makefile基本规则 1.1示例 target ... : prerequisites ... command ... ... target也就是一个目标文件，可以是Object File，也可以是执行文件。prerequisites就是，要生成那个target所需要的文件或是目标。command也就是make需要执行的命令。（任意的Shell命令） 为了方便理解，我们来看一个示例： /*Makefile示例*/ edit : main.o kbd.o command.o display.o / insert.o search.o files.o utils.o gcc -o edit main.o kbd.o command.o display.o / insert.o search.o files.o utils.o main.o : main.c defs.h #生成main.o gcc -c main.c

跟我一起写Makefile(可以注释版)

跟我一起写 Makefile 作者：陈皓 整理：祝冬华

第一部分、概述 (6) 第二部分、关于程序的编译和链接 (6) 第三部分、Makefile 介绍 (7) 一、Makefile的规则 (7) 二、一个示例 (8) 三、make是如何工作的 (9) 四、makefile中使用变量 (10) 五、让make自动推导 (11) 六、另类风格的makefile (12) 七、清空目标文件的规则 (13) 第四部分、Makefile 总述 (13) 一、Makefile里有什么？ (13) 1、显式规则。 (14) 2、隐晦规则。 (14) 3、变量的定义。 (14) 4、文件指示。 (14) 5、注释。 (14) 二、Makefile的文件名 (15) 三、引用其它的Makefile (15) 四、环境变量 MAKEFILES (16) 五、make的工作方式 (16) 第五部分、书写规则 (17) 一、规则举例 (17) 二、规则的语法 (17) 三、在规则中使用通配符 (18) 四、文件搜寻 (19) 五、伪目标 (20) 六、多目标 (22) 七、静态模式 (22) 八、自动生成依赖性 (24) 第六部分书写命令 (25) 一、显示命令 (26) 二、命令执行 (26) 三、命令出错 (27) 四、嵌套执行make (28) 五、定义命令包 (30) 第七部分使用变量 (30) 一、变量的基础 (31) 二、变量中的变量 (32) 三、变量高级用法 (34) 四、追加变量值 (37) 五、override 指示符 (37) 六、多行变量 (38)

八、目标变量 (39) 九、模式变量 (40) 第八部分使用条件判断 (40) 一、示例 (40) 二、语法 (42) 第九部分使用函数 (43) 一、函数的调用语法 (44) 二、字符串处理函数 (44) 1、subst (44) 2、patsubst (45) 3、strip (45) 4、findstring (46) 5、filter (46) 6、filter-out (46) 7、sort (47) 8、word (47) 9、wordlist (47) 10、words (47) 11、firstword (48) 12、字符串函数实例 (48) 三、文件名操作函数 (48) 1、dir (48) 2、notdir (48) 3、suffix (49) 4、basename (49) 5、addsuffix (49) 6、addprefix (49) 7、join (50) 四、foreach 函数 (50) 五、if 函数 (50) 六、call函数 (51) 七、origin函数 (51) “undefined” (52) “default” (52) “file” (52) “command line” (52) “override” (52) “automatic” (52) 八、shell函数 (53) 九、控制make的函数 (53) 1、error (53) 2、warning (54) 第十部分 make 的运行 (54)

MAKEfile教程

概述 —— 什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE 都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML 的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。 因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。 makefile带来的好处就是——―自动化编译‖，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。 现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。当然，不同产商的make 各不相同，也有不同的语法，但其本质都是在―文件依赖性‖上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0，make的版本是3.80。必竟，这个make 是应用最为广泛的，也是用得最多的。而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。 在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX 下的GCC和CC。 关于程序的编译和链接 —————————— 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，即Object File，这个动作叫做编译（compile）。然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。 编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ文件）。

怎样使用Makefile

Mak k e f ile 跟我一 我一起起写Ma 陈皓 (CSDN) 概 述 什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows 的IDE都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。 因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能 操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。 makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个 解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。 现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。当然，不同产商的make各不相同，也有不同的语法，但其本质都是在“文件依赖性”上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0，make的版本是3.80。必竟，这个make是应用最为广泛的，也是用得最多的。而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。 在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX下的GCC和CC。 关于程序的编译和链接 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，即 Object File，这个动作叫做编译（compile）。然后再把大量的Object File 合成执行文件，这个动作叫作链接（link）。

Make命令完全详解教程

Make命令完全详解教程 无论是在Linux还是在Unix环境中，make都是一个非常重要的编译命令。不管是自己进行项目开发还是安装应用软件，我们都经常要用到make或make install。利用make工具，我们可以将大型的开发项目分解成为多个更易于管理的模块，对于一个包括几百个源文件的应用程序，使用make和makefile工具就可以简洁明快地理顺各个源文件之间纷繁复杂的相互关系。而且如此多的源文件，如果每次都要键入gcc命令进行编译的话，那对程序员来说简直就是一场灾难。而make工具则可自动完成编译工作，并且可以只对程序员在上次编译后修改过的部分进行编译。因此，有效的利用make和makefile工具可以大大提高项目开发的效率。同时掌握make和makefile之后，您也不会再面对着Linux下的应用软件手足无措了。

一、Make程序的命令行选项和参数 Make命令参数的典型序列如下所示： make [-f makefile文件名][选项][宏定义][目标] 这里用[]括起来的表示是可选的。命令行选项由破折号“–”指明，后面跟选项，如 也可以每个选项使用一个破折号，如 Make命令本身的命令行选项较多，这里只介绍在开发程序时最为常用的三个，它们是： –k： 如果使用该选项，即使make程序遇到错误也会继续向下运行；如果没有该选项，在遇到第一个错误时make程序马上就会停止，那么后面的错误情况就不得而知了。我们可以利用这个选项来查出所有有编译问题的源文件。 –n： 该选项使make程序进入非执行模式，也就是说将原来应该执行的命令输出，

而不是执行。 –f ： 指定作为makefile的文件的名称。如果不用该选项，那么make程序首先在当前目录查找名为makefile的文件，如果没有找到，它就会转而查找名为Makefile的文件。如果您在Linux下使用GNU Make的话，它会首先查找GNUmakefile，之后再搜索makefile和Makefile。按照惯例，许多Linux程序员使用Makefile，因为这样能使Makefile出现在目录中所有以小写字母命名的文件的前面。所以，最好不要使用GNUmakefile这一名称，因为它只适用于make程序的GNU版本。 当我们想构建指定目标的时候，比如要生成某个可执行文件，那么就可以在make命令行中给出该目标的名称；如果命令行中没有给出目标的话，make命令会设法构建makefile中的第一个目标。我们可以利用这一特点，将all作为makefile中的第一个目标，然后将让目标作为all所依赖的目标，这样，当命令行中没有给出目标时，也能确保它会被构建。