怎样使用Makefile

合集下载

makefile中make指令传入的参数

makefile中make指令传入的参数

makefile中make指令传入的参数Makefile中make指令传入的参数是指在执行make命令时,可以通过命令行传入的参数。

这些参数可以用于控制程序的编译、运行等行为,使得程序更加灵活和可配置。

在Makefile中,我们可以通过在命令行中输入make和参数来执行相应的操作。

参数可以是任意的字符串,可以用于指定编译选项、目标文件、源文件等等。

下面我将结合一些实际的例子,来详细讲解一下如何使用make指令传入的参数。

我们需要在Makefile中定义一些变量,用于存储传入的参数。

可以通过在命令行中使用“变量名=参数值”的方式来传入参数。

例如,我们可以定义一个变量CC,用于存储编译器的路径:```CC = gcc```在命令行中执行make命令时,可以通过“make CC=/usr/local/bin/gcc”来传入参数,将编译器的路径设置为“/usr/local/bin/gcc”。

接下来,我们可以在Makefile中使用这些参数。

例如,我们可以使用$(CC)来表示编译器的路径:```$(CC) -o target source.c```在执行make命令时,make会将$(CC)替换为实际的参数值,然后执行相应的命令。

这样,我们就可以通过命令行传入不同的编译器路径,来编译源文件。

除了编译器的路径,还可以通过命令行传入其他的参数。

例如,我们可以定义一个变量CFLAGS,用于存储编译选项:```CFLAGS = -Wall -O2```在命令行中执行make命令时,可以通过“make CFLAGS=-g”来传入参数,将编译选项设置为“-g”。

然后,我们可以在Makefile中使用这些参数。

例如,我们可以在编译命令中加入$(CFLAGS):```$(CC) $(CFLAGS) -o target source.c```在执行make命令时,make会将$(CFLAGS)替换为实际的参数值,然后执行相应的命令。

Makefile变量使用条件及判断使用

Makefile变量使用条件及判断使用

Makefile变量使用条件及判断使用使用变量————在Makefile中的定义的变量,就像是C/C++语言中的宏一样,他代表了一个文本字串,在Makefile中执行的时候其会自动原模原样地展开在所使用的地方。

其与C/C++所不同的是,你可以在Makefile中改变其值。

在Makefile中,变量可以使用在“目标”,“依赖目标”,“命令”或是Makefile的其它部分中。

变量的命名字可以包含字符、数字,下划线(可以是数字开头),但不应该含有“:”、“#”、“=”或是空字符(空格、回车等)。

变量是大小写敏感的,“foo”、“Foo”和“FOO”是三个不同的变量名。

传统的Makefile的变量名是全大写的命名方式,但我推荐使用大小写搭配的变量名,如:MakeFlags。

这样可以避免和系统的变量冲突,而发生意外的事情。

有一些变量是很奇怪字串,如“$<”、“$@”等,这些是自动化变量,我会在后面介绍。

一、变量的基础变量在声明时需要给予初值,而在使用时,需要给在变量名前加上“$”符号,但最好用小括号“()”或是大括号“{}”把变量给包括起来。

如果你要使用真实的“$”字符,那么你需要用“$$”来表示。

变量可以使用在许多地方,如规则中的“目标”、“依赖”、“命令”以及新的变量中。

先看一个例子:objects = program.o foo.o utils.oprogram : $(objects)cc -o program $(objects)$(objects) : defs.h变量会在使用它的地方精确地展开,就像C/C++中的宏一样,例如:foo = cprog.o : prog.$(foo)$(foo)$(foo) -$(foo) prog.$(foo)展开后得到:prog.o : prog.ccc -c prog.c当然,千万不要在你的Makefile中这样干,这里只是举个例子来表明Makefile中的变量在使用处展开的真实样子。

python makefile 用法

python makefile 用法

python makefile 用法Python Makefile可用于自动化编译,构建和测试Python项目。

它是一个命令脚本,帮助程序员在不同的操作系统上拥有相同的构建环境,减少了跨平台应用的开发难度。

本文将详细介绍Python Makefile的使用方法,包括如何创建,配置和使用Makefile,以及常见的Makefile命令和技巧。

创建Python Makefile要创建Python Makefile,您需要使用任何文本编辑器创建一个Makefile文件。

Makefile文件通常命名为Makefile或makefile,并位于项目根目录中。

在Makefile文件中,您需要定义一组规则,以指定每个目标的依赖关系,命令和操作。

以下是一个简单的Makefile示例,用于编译和执行名为myapp.py的Python 应用程序。

```make # Makefile for the myapp Python application# Define the application file APPNAME = myapp.py # Define the Python interpreter PYTHON = python3all: $(PYTHON) $(APPNAME)# Define the clean rule clean: rm -f *.pyc ```在上面的Makefile中,我们定义了两个规则,一个是`all`,另一个是`clean`。

`all`规则定义如何构建我们的应用程序,`clean`规则定义如何清理构建期间生成的文件。

配置Python Makefile在编写Python Makefile时,您需要配置Python解释器和其他环境变量。

以下是一些常见的Makefile变量和用法:- **PYTHON**:Python解释器的命令。

在大多数情况下,它需要设置为python3。

- **PYFLAGS**:Python解释器的选项和参数,例如“-O”(优化),“-m”(运行包的主模块)等。

goland makefile 使用

goland makefile 使用

goland makefile 使用Goland是一款非常强大的集成开发环境(IDE),专门针对Go语言开发。

它提供了一系列的功能和工具,能够帮助开发者更高效地进行Go语言项目的开发和调试。

而Makefile,则是一种用来自动化构建和编译程序的工具。

在使用Goland进行Go语言开发时,我们可以结合使用Makefile 来简化一些繁琐的操作,提高开发效率。

下面我将介绍一些在Goland中使用Makefile的方法和技巧。

我们需要创建一个名为Makefile的文件,并将其放置在项目根目录下。

Makefile是一个文本文件,其中包含一系列的规则(rules),每个规则都定义了一组命令,用于构建和编译程序。

在Makefile文件中,我们可以定义一些常用的操作和命令,比如编译程序、运行测试、清理临时文件等。

下面是一个简单的示例:```Makefile# 编译程序build:go build -o myapp# 运行测试test:go test ./...# 清理临时文件clean:rm -f myapp# 安装依赖deps:go mod download```在上面的示例中,我们定义了四个规则,分别用于编译程序、运行测试、清理临时文件和安装依赖。

其中,`build`规则使用`go build`命令来编译程序,`test`规则使用`go test`命令来运行测试,`clean`规则使用`rm -f`命令来删除生成的可执行文件,`deps`规则使用`go mod download`命令来安装依赖。

在Goland中,我们可以通过终端或者Goland的内置终端来执行Makefile中定义的规则。

首先,我们需要打开终端,然后进入到项目的根目录下。

接下来,我们可以使用`make`命令来执行Makefile 中的规则。

比如,如果我们想要编译程序,只需要在终端中执行`make build`命令即可。

如果我们想要运行测试,只需要执行`make test`命令即可。

linux vscode makefile语法

linux vscode makefile语法

linux vscode makefile语法在Linux 系统中,如果您想使用VSCode 编写Makefile 相关的项目,可以参考以下步骤进行安装和配置:1. 首先,确保已经正确安装了Visual Studio Code。

如果尚未安装,可以参考[1] 中的教程进行安装。

2. 安装Makefile 插件。

打开VSCode,转到“扩展”选项卡(快捷键:Ctrl+Shift+X),搜索“Makefile”,找到名为“Makefile Support”的插件,点击“安装”。

3. 创建一个新的Makefile 项目。

在VSCode 中,创建一个新的文件夹,然后在该文件夹中打开终端(快捷键:Ctrl+`)。

4. 编写Makefile 语法。

在项目根目录下创建一个名为“Makefile”的文件,然后编写相应的Makefile 语法。

以下是一个简单的示例:```make# 设置变量MY_PROJECT_NAME = MyProjectMY_PROJECT_VERSION = 1.0# 设置目标all: build# 构建目标build:echo "Building $MY_PROJECT_NAME $MY_PROJECT_VERSION"# 在这里添加您的构建命令,例如:cmake、make等# 清理目标clean:echo "Cleaning $MY_PROJECT_NAME"# 在这里添加您的清理命令,例如:rm -rf build/# 默认执行构建目标default: build```5. 保存Makefile 文件并按F5 键运行项目。

VSCode 将会自动使用内置的终端执行Makefile 中的命令。

6. 如果需要使用GPU 加速构建,可以在Makefile 中添加相应的NVIDIA CUDA 或者AMD OpenCL 命令。

例如,如果您使用的是NVIDIA GPU,可以添加以下命令:```makebuild_gpu:echo "Building $MY_PROJECT_NAME $MY_PROJECT_VERSION using GPU"# 在这里添加您的GPU 构建命令,例如:nvcc、cuda编译器等```7. 按照项目需求修改Makefile 中的命令和目标。

python makefile 用法

python makefile 用法

python makefile 用法在使用Python编写程序时,我们通常需要编译和运行代码,这就需要用到makefile。

makefile是一种可以自动化地构建程序的工具,它可以根据代码修改的情况自动判断哪些文件需要重新编译,从而提高程序的编译效率。

使用makefile的基本步骤如下:1. 创建一个名为makefile的文件,通常放在程序的根目录下。

2. 在makefile中定义一些变量,如编译器、编译选项等。

3. 定义一些规则,如编译规则、目标规则等。

4. 运行make命令,根据makefile的规则进行编译和链接。

下面是一个简单的makefile示例:```# 定义编译器和编译选项CC=gccCFLAGS=-Wall -g# 定义编译规则%.o: %.c$(CC) $(CFLAGS) -c $< -o $@# 定义目标规则main: main.o sub.o$(CC) $(CFLAGS) main.o sub.o -o main# 清除中间文件clean:rm -f *.o main```在这个示例中,我们定义了两个变量CC和CFLAGS,分别表示编译器和编译选项。

接着定义了一个编译规则,表示将.c文件编译成.o文件的过程。

其中,$<表示依赖文件(即输入文件),$@表示目标文件(即输出文件)。

最后定义了一个目标规则,表示将main.o和sub.o链接成可执行文件main。

最后,我们定义了一个清除中间文件的规则,可以通过运行make clean来清除中间文件。

可以通过运行make命令来编译和链接程序。

例如,如果你有一个名为main.c和sub.c的源文件,并想将它们编译成可执行文件main,可以在终端中输入以下命令:```$ make main```这将根据makefile中定义的规则自动编译和链接程序,并生成可执行文件main。

总之,makefile是一个非常有用的编译工具,可以帮助我们自动化地构建程序,提高编译效率。

makefile -d 用法

makefile -d 用法

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 选项输出了规则的详细信息。

make makefile 的参数

make makefile 的参数

make makefile 的参数make命令是一款非常强大的工具,可以帮助我们自动化构建项目,特别是在大型项目中,make命令可以极大地提高开发效率。

makefile是make命令的配置文件,可以用来指定构建项目的规则和依赖关系,下面我们将介绍makefile的参数以及其用法。

1. -f-f参数可以用来指定makefile文件的名称,如果不指定,则默认使用当前目录下的makefile文件或Makefile文件。

例如,我们可以使用以下命令来指定makefile文件的名称:make -f mymakefile2. -C-C参数可以用来指定make命令的工作目录,即make命令将在指定目录下执行构建操作。

例如,我们可以使用以下命令来指定工作目录:make -C /path/to/project3. -n-n参数可以用来显示make命令将要执行的动作,但并不真正执行。

这个参数在调试makefile文件时非常有用,可以帮助我们检查makefile文件的正确性。

例如,我们可以使用以下命令来显示make 命令将要执行的动作:make -n4. -B-B参数可以用来强制执行make命令,即使目标文件已经是最新的了。

这个参数通常在我们需要重新构建项目时使用。

例如,我们可以使用以下命令来强制执行make命令:make -B5. -j-j参数可以用来指定make命令并行执行的任务数,可以加快构建速度。

这个参数通常在大型项目中使用,可以充分利用计算机的多核处理能力。

例如,我们可以使用以下命令来指定make命令并行执行的任务数:make -j46. --debug--debug参数可以用来打开make命令的调试模式,可以帮助我们更好地理解make命令的执行过程。

例如,我们可以使用以下命令来打开make命令的调试模式:make --debug7. --version--version参数可以用来显示make命令的版本信息。

makefile编译流程

makefile编译流程

makefile编译流程Makefile是一种用于自动化编译的工具,它可以根据源代码文件的依赖关系自动编译出目标文件。

Makefile的编写需要遵循一定的规则和语法,下面将介绍Makefile的编译流程。

1. 编写Makefile文件Makefile文件是一个文本文件,其中包含了编译的规则和依赖关系。

在编写Makefile文件时,需要遵循一定的语法规则,如使用TAB键缩进、使用变量和函数等。

2. 执行make命令在Makefile文件所在的目录下执行make命令,make会自动读取Makefile文件,并根据其中的规则和依赖关系进行编译。

如果Makefile文件中没有指定目标,则默认编译第一个目标。

3. 分析依赖关系在执行make命令时,make会先分析Makefile文件中的依赖关系,确定哪些文件需要重新编译。

如果某个源文件被修改了,那么与之相关的目标文件也需要重新编译。

4. 编译源文件在确定需要重新编译的文件后,make会依次编译每个源文件,生成对应的目标文件。

编译过程中,make会根据Makefile文件中的规则和命令进行编译。

5. 链接目标文件在所有的源文件都编译完成后,make会将所有的目标文件链接起来,生成最终的可执行文件。

链接过程中,make会根据Makefile文件中的规则和命令进行链接。

6. 完成编译当所有的源文件都编译完成并链接成功后,make会输出编译成功的信息,并生成最终的可执行文件。

如果编译过程中出现错误,make会输出错误信息并停止编译。

总之,Makefile编译流程是一个自动化的过程,它可以大大提高编译的效率和准确性。

在编写Makefile文件时,需要注意语法规则和依赖关系,以确保编译过程的正确性。

makefile条件语嵌套使用 -回复

makefile条件语嵌套使用 -回复

makefile条件语嵌套使用-回复问题的具体步骤如下:第一步:什么是makefile?在开始讨论makefile条件语嵌套的使用之前,我们先了解一下什么是makefile。

Makefile是一个包含一系列规则和命令的文本文件,它描述了源文件之间的依赖关系,以及如何编译和链接这些源文件。

通过makefile,我们可以在一个命令中一次性构建复杂的项目,而不需要手动编译每个源文件。

第二步:条件语的基本概念在makefile中,条件语可以根据一定的条件执行不同的命令或者规则。

条件语的基本语法如下:ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则else# 参数1和参数2不相等时执行的命令或规则endif通过if语句中的参数1和参数2的比较,可以决定不同条件下的执行逻辑。

第三步:条件语嵌套的基本概念与其他编程语言类似,makefile也支持条件语的嵌套使用。

通过条件语的嵌套,我们可以实现更加复杂的逻辑判断和命令执行。

例如,我们可以通过以下的方式嵌套使用if语句:ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则ifeq (参数3, 参数4)# 参数3和参数4相等时执行的命令或规则else# 参数3和参数4不相等时执行的命令或规则endifelse# 参数1和参数2不相等时执行的命令或规则endif通过条件语嵌套,我们可以实现更加复杂的逻辑判断和流程控制。

第四步:条件语嵌套的实际应用接下来,我们来看一些实际的例子,以更好地理解条件语嵌套的使用。

假设我们有一个项目,该项目可以在不同的操作系统上编译和运行。

我们可以通过条件语嵌套来实现根据操作系统的不同选择不同的编译命令。

首先,我们可以定义一个变量来表示当前操作系统的类型:OS := (shell uname -s)然后,我们可以使用条件语嵌套来根据操作系统的类型选择不同的编译命令:ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则ifeq ((OS), Linux)# 在Linux系统上执行的命令或规则else ifeq ((OS), Windows)# 在Windows系统上执行的命令或规则else ifeq ((OS), Darwin)# 在Darwin (MacOS)系统上执行的命令或规则else# 其他操作系统上执行的命令或规则endifelse# 参数1和参数2不相等时执行的命令或规则endif通过以上的例子,我们可以看到,通过条件语嵌套,我们可以根据不同的操作系统类型选择不同的编译命令,从而实现在不同操作系统上的构建和运行。

makefile基本使用方法

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 gcc编译

makefile gcc编译

makefile gcc编译
Makefile 是一个用来组织代码编译的工具,而 GCC 是一个常用的 C 和 C++ 编译器。

在 Makefile 中使用 GCC 进行编译可以通过以下步骤完成:
1. 创建一个名为 "Makefile" 的文本文件,并确保它位于你的项目根目录下。

2. 在 Makefile 中定义你的编译规则。

例如,假设你有一个名为 "main.c" 的源文件需要编译成可执行文件 "app",你可以这样编写 Makefile:
make.
app: main.c.
gcc -o app main.c.
在这个例子中,我们定义了一个名为 "app" 的目标,它依赖于"main.c" 这个源文件。

当你运行 "make" 命令时,Make 工具会根
据这个规则来执行编译。

3. 打开终端,进入到包含 Makefile 的项目目录下。

4. 运行命令 "make"。

Make 工具会读取 Makefile 文件,并执行其中定义的编译规则。

在这个例子中,它会使用 GCC 编译器来编译 "main.c" 并生成可执行文件 "app"。

需要注意的是,Makefile 可以包含更复杂的规则和变量定义,以及支持多个源文件的编译。

你可以根据你的项目需求来进一步扩展和定制 Makefile 文件。

总之,通过合理编写 Makefile 并结合使用 GCC 编译器,你可以高效地组织和管理你的代码编译过程。

Makefile使用总结

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 命令行参数
2. -C选项
-C选项可以指定Makefile所在的路径。如果我们在当前路径下执行make命令,但是Makefile文件不在当前路径下,那么就需要使用-C选项来指定Makefile所在的路径。例如:
make -C /path/to/Makefile
3. -f选项
-f选项可以指定要使用的Makefile文件名。如果我们有多个Makefile文件,那么就可以使用-f选项来指定要使用哪个Makefile文件。例如:
makefile 命令行参数
Makefile是一种用来管理代码编译的工具,它可以自动化执行编译任务,帮助程序员更高效地管理代码。在Makefile中,可以定义一系列规则来指定如何编译代码。在使用Makefile时,我们可以通过命令行参数来控制编译过程的行为。本文将详细介绍makefile命令行参数的使用方法。项
-j选项可以指定并行编译时所使用的线程数。如果我们有多个CPU核心,并且要编译大型项目,那么就可以使用-j选项来加速编译过程。例如:
make -j4
5. --dry-run选项
--dry-run选项可以模拟执行make命令,并输出将要执行的命令列表,但是并不会真正地执行这些命令。这个功能非常实用,因为我们可以预先查看将要执行的命令,确保它们是正确的。例如:
这样做的好处是,我们可以在不修改Makefile的情况下,通过命令行参数来控制编译过程的行为。
四、总结
本文介绍了Makefile命令行参数的用法,包括make命令、-C选项、-f选项、-j选项、--dry-run选项和--print-data-base选项。同时,本文还介绍了一些Makefile常用技巧,包括使用变量来存储编译选项、使用通配符来自动生成目标文件列表和使用命令行参数来控制编译过程。希望本文能够对大家理解和学习Makefile有所帮助。

qtcreator通过makefile编译项目

qtcreator通过makefile编译项目

qtcreator通过makefile编译项目一、引言Qt Creator是一款流行的跨平台集成开发环境,广泛应用于开发Qt应用程序。

在Qt Creator中,通过Makefile进行项目编译是一种常见的做法。

通过Makefile,开发者可以更好地控制编译过程,提高编译效率。

本篇文档将详细介绍如何使用Qt Creator和Makefile来编译项目。

二、准备工作1. 确保已安装Qt Creator并配置好Qt环境。

2. 准备一个包含Makefile的项目文件,确保Makefile结构正确。

3. 确保项目中包含了必要的源代码文件。

三、编译流程1. 打开Qt Creator,选择你要编译的项目。

2. 在项目窗口中,展开"Projects"菜单,选择"Run"->"Build"或"Rebuild"。

4. 如果编译过程中出现错误,可以通过调试窗口查看错误信息,并针对性地进行修改和重新编译。

四、Makefile结构Makefile是用来定义编译规则的文件,它描述了如何将源文件编译成可执行文件。

一个基本的Makefile结构如下:```arduino# Makefile for myprojectTARGET := myproject # 目标文件或可执行文件的名字.CFLAGS := -Wall # 编译参数.CXXFLAGS := $(CFLAGS) # 如果有C++源文件的话.SOURCES := main.cpp # 源文件列表.OBJECTS := $(SOURCES:.cpp=.o) # 将源文件扩展名改为.o进行编译.all: $(TARGET)$(TARGET): $(OBJECTS)$(Q)g++ -o $(TARGET) $(OBJECTS)```上述Makefile中,各个部分的意义如下:* `TARGET`:目标文件或可执行文件的名称。

makefile 语法

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函数的语法与使⽤使⽤函数:在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编译多个文件(.c,.cpp,.h等)

使用makefile编译多个文件(.c,.cpp,.h等)

使⽤makefile编译多个⽂件(.c,.cpp,.h等)有时候我们要⼀次运⾏多个⽂件,这时候我们可以使⽤Makefile◊make是什么? make是⼀个命令⼯具,是⼀个解释makefile中指令的命令⼯具。

它可以简化编译过程⾥⾯所下达的指令,当执⾏make 时,make 会在当前的⽬录下搜寻 Makefile (or makefile) 这个⽂本⽂件,执⾏对应的操作。

make 会⾃动的判别原始码是否经过变动了,⽽⾃动更新执⾏档。

◊为什么要使⽤make? 假设,现在⼀个项⽬⾥⾯包含了100个程序⽂件,如果要对这个项⽬进⾏编译,那么光是编译指令就有100条。

如果要重新进⾏编译,那么就⼜得像之前⼀样重新来⼀遍。

这样重复且繁琐的⼯作实在是让我们很不爽啊。

所以,⽤make来进⾏操作,间接调⽤gcc岂不是很⽅便?如果我们更动过某些原始码档案,则 make 也可以主动的判断哪⼀个原始码与相关的⽬标⽂件档案有更新过,并仅更新该档案。

这样可以减少重新编译所需要的时间,也会更加⽅便。

◊makefile⼜是⼲什么的? makefile其实就是⼀个⽂档,⾥⾯定义了⼀系列的规则指定哪些⽂件需要先编译,哪些⽂件需要后编译,哪些⽂件需要重新编译,它记录了原始码如何编译的详细信息! makefile⼀旦写好,只需要⼀个make命令,整个⼯程完全⾃动编译,极⼤的提⾼了软件开发的效率。

先看⼀下makefile的规则: ⽬标(target):⽬标⽂件1 ⽬标⽂件2 <Tab>gcc -o 欲建⽴的执⾏⽂件⽬标⽂件1 ⽬标⽂件2先举⼀个运⾏多个c语⾔⽂件。

⾸先下⾯是⼀个完整的 c语⾔⽂件,实现了统计⽤户输⼊的字符串中⼤⼩写字母的个数#include<unistd.h>#include<sys/types.h>#include<sys/wait.h>void test(){char str[50]={0};scanf("%s",str);int m=0;int n=0;pid_t p=fork();if(p<0){printf("fork failed");}if(p == 0){for(int i=0;i<sizeof(str);i++){if( str[i]<='Z'&& str[i]>='A'){m++;}}printf("⼤写字母⼀共有");printf("%d",m);printf("个");}if(p>0){for(int i=0;i<sizeof(str);i++){if(str[i]>='a' && str[i]<='z'){n++;}}printf("⼩写字母⼀共有");printf("%d",n);printf("个");}}int main(){test();return 0;}此时我们可以把该⽂件拆成三份,⼀份是.h⽂件,⽤来放头⽂件等信息,另外两个是.c⽂件,⼀个⽤来放main⽅法,⼀个放声明的函数,如下三图则在终端进⾏⼀下操作成功运⾏多个⽂件下⾯介绍运⾏cpp⽂件,⼤致步骤相同。

makefile pushd用法

makefile pushd用法

makefile pushd用法摘要:1.makefile 概述2.pushd 用法简介3.makefile 与pushd 结合使用实例4.总结正文:1.makefile 概述Makefile 是一种用于自动化构建和编译软件的脚本文件,常见于Unix 和类Unix 系统中。

它通常包含一系列的规则和指令,用于描述如何编译源代码、链接目标文件、创建可执行文件等。

Makefile 的编写可以大大简化软件开发过程中的重复性工作,提高开发效率。

2.pushd 用法简介`pushd`是一个Shell 命令,用于将当前工作目录切换到指定的目录。

在Makefile 中,`pushd`命令可以用于改变执行特定规则时的工作目录,这对于处理多目录结构的项目尤为重要。

`pushd`的基本语法如下:```pushd <目录>```其中,`<目录>`是要切换到的目录。

在Makefile 中,可以使用`popd`命令将工作目录切换回之前的目录。

3.makefile 与pushd 结合使用实例假设我们有一个简单的多目录结构项目,其结构如下:```project/├──src/│└── main.c└──build/└── main.o```我们需要编写一个Makefile,使得在编译`main.c`时,工作目录位于`src`目录,以便正确链接目标文件和可执行文件。

可以使用以下Makefile:```makefileall: mainmain: main.ot@mkdir -p buildtcd srctgcc main.c -o build/main.otpopdclean:trm -rf build```在这个Makefile 中,我们使用`pushd`命令将工作目录切换到`src`目录,然后编译`main.c`。

编译完成后,我们使用`popd`命令将工作目录切换回上级目录。

在执行`make`命令时,会自动调用`all`规则,完成编译和链接操作。

makefile 冒号的用法

makefile 冒号的用法

Makefile 冒号的用法
在Makefile中,冒号(:)主要有两种用法:
规则中的冒号:在Makefile的规则中,冒号用于分隔目标文件和依赖项。

规则的格式为“目标文件:依赖项1 依赖项2 ... 命令”。

其中,目标文件是规则要生成的文件,依赖项是目标文件所依赖的其他文件,命令是用于生成目标文件的命令。

例如,下面的规则表示当目标文件“foo.o”发生变化时,执行命令“gcc -c foo.c”来重新生成它:
makefile
foo.o: foo.c
gcc -c foo.c
双冒号规则中的冒号:在Makefile中,双冒号规则是一种特殊的规则,用于指定当多个文件具有相同的依赖项时,如何执行不同的命令来生成目标文件。

双冒号规则的格式为“目标文件:: 依赖项1 依赖项2 ... 命令”。

例如,下面的规则表示当“foo.c”或“bar.c”发生变化时,分别执行不同的命令来重新生成“Newprog”目标文件:
makefile
Newprog :: foo.c $(CC) $(CFLAGS) $< -o $@
Newprog :: bar.c $(CC) $(CFLAGS) $< -o $@
在双冒号规则中,当同一个目标出现在多个规则中时,会按照规则的书写顺序执行。

因此,在上面的例子中,如果“foo.c”发生变化,将执行第一个规则重新生成“Newprog”,然后执行第二个规则重新生成“Newprog”,因为“bar.c”没有被修改。

总结起来,冒号在Makefile中有两种主要用法:一种是用于分隔目标文件
和依赖项的普通规则中的冒号,另一种是用于指定多个规则中如何执行不同命令的双冒号规则中的冒号。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

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)。

编译时,编译器需要的是语法的正确,函数与变量的声明的正确。

对于后者,通常是你需要告诉编译器头文件的所在位置(头文件中应该只是声明,而定义应该放在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个C文件,和3个头文件,我们要写一个Makefile来告诉make命令如何编译和链接这几个文件。

我们的规则是:1)如果这个工程没有编译过,那么我们的所有C文件都要编译并被链接。

2)如果这个工程的某几个C文件被修改,那么我们只编译被修改的C文件,并链接目标程序。

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

只要我们的Makefile写得够好,所有的这一切,我们只用一个make命令就可以完成,make命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译,从而自己编译所需要的文件和链接目标程序。

一、Makefile的规则在讲述这个Makefile之前,还是让我们先来粗略地看一看Makefile的规则。

target ... : prerequisites ...command......target也就是一个目标文件,可以是Object File,也可以是执行文件。

还可以是一个标签(Label),对于标签这种特性,在后续的“伪目标”章节中会有叙述。

prerequisites就是,要生成那个target所需要的文件或是目标。

command也就是make需要执行的命令。

(任意的Shell命令)这是一个文件的依赖关系,也就是说,target这一个或多个的目标文件依赖于prerequisites中的文件,其生成规则定义在command中。

说白一点就是说,prerequisites 中如果有一个以上的文件比target文件要新的话,command所定义的命令就会被执行。

这就是Makefile的规则。

也就是Makefile中最核心的内容。

说到底,Makefile的东西就是这样一点,好像我的这篇文档也该结束了。

呵呵。

还不尽然,这是Makefile的主线和核心,但要写好一个Makefile还不够,我会以后面一点一点地结合我的工作经验给你慢慢到来。

内容还多着呢。

:)二、一个示例正如前面所说的,如果一个工程有3个头文件,和8个C文件,我们为了完成前面所述的那三个规则,我们的Makefile应该是下面的这个样子的。

edit : main.o kbd.o command.o display.o \insert.o search.o files.o utils.occ -o edit main.o kbd.o command.o display.o \insert.o search.o files.o utils.omain.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.h buffer.hcc -c insert.csearch.o : search.c defs.h buffer.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.o \insert.o search.o files.o utils.o反斜杠(\)是换行符的意思。

这样比较便于Makefile的易读。

我们可以把这个内容保存在文件为“Makefile”或“makefile”的文件中,然后在该目录下直接输入命令“make”就可以生成执行文件edit。

如果要删除执行文件和所有的中间目标文件,那么,只要简单地执行一下“make clean”就可以了。

在这个makefile中,目标文件(target)包含:执行文件edit和中间目标文件(*.o),依赖文件(prerequisites)就是冒号后面的那些 .c 文件和 .h文件。

每一个 .o 文件都有一组依赖文件,而这些 .o 文件又是执行文件 edit 的依赖文件。

依赖关系的实质上就是说明了目标文件是由哪些文件生成的,换言之,目标文件是哪些文件更新的。

在定义好依赖关系后,后续的那一行定义了如何生成目标文件的操作系统命令,一定要以一个Tab键作为开头。

记住,make并不管命令是怎么工作的,他只管执行所定义的命令。

make会比较targets文件和prerequisites文件的修改日期,如果prerequisites文件的日期要比targets文件的日期要新,或者target不存在的话,那么,make就会执行后续定义的命令。

这里要说明一点的是,clean不是一个文件,它只不过是一个动作名字,有点像C语言中的lable一样,其冒号后什么也没有,那么,make就不会自动去找文件的依赖性,也就不会自动执行其后所定义的命令。

要执行其后的命令,就要在make命令后明显得指出这个lable的名字。

这样的方法非常有用,我们可以在一个makefile中定义不用的编译或是和编译无关的命令,比如程序的打包,程序的备份,等等。

三、make是如何工作的在默认的方式下,也就是我们只输入make命令。

那么,1、make会在当前目录下找名字叫“Makefile”或“makefile”的文件。

2、如果找到,它会找文件中的第一个目标文件(target),在上面的例子中,他会找到“edit”这个文件,并把这个文件作为最终的目标文件。

3、如果edit文件不存在,或是edit所依赖的后面的 .o 文件的文件修改时间要比edit这个文件新,那么,他就会执行后面所定义的命令来生成edit这个文件。

4、如果edit所依赖的.o文件也存在,那么make会在当前文件中找目标为.o文件的依赖性,如果找到则再根据那一个规则生成.o文件。

(这有点像一个堆栈的过程)5、当然,你的C文件和H文件是存在的啦,于是make会生成 .o 文件,然后再用 .o 文件生命make的终极任务,也就是执行文件edit了。

相关文档
最新文档