makefile的编写

合集下载

c语言makefile编写实例

c语言makefile编写实例

c语言makefile编写实例Makefile是用来管理程序编译的工具,可以方便地管理程序的编译过程。

使用Makefile可以大大简化程序的编译过程,提高程序的可维护性。

Makefile的语法比较简单,主要由目标、依赖和命令三部分组成。

下面我们以一个简单的C程序为例,来介绍如何使用Makefile进行编译。

假设我们有一个名为hello.c的程序,代码如下:```c#include <stdio.h>int main(){printf("Hello, world!\n");return 0;}```我们需要使用gcc编译器将其编译成可执行文件。

下面是一个简单的Makefile:```makefilehello: hello.cgcc -o hello hello.c```这个Makefile很简单,它定义了一个名为hello的目标,该目标依赖于hello.c文件,并使用gcc命令将其编译成可执行文件。

如果我们在终端中输入make命令,Makefile会自动执行编译过程:```$ makegcc -o hello hello.c```Makefile还可以定义多个目标,每个目标可以有多个依赖和多个命令。

下面是一个稍微复杂一些的Makefile:```makefileCC=gccCFLAGS=-Wall -gall: hello goodbyehello: hello.o$(CC) $(CFLAGS) -o hello hello.ogoodbye: goodbye.o$(CC) $(CFLAGS) -o goodbye goodbye.ohello.o: hello.c$(CC) $(CFLAGS) -c hello.cgoodbye.o: goodbye.c$(CC) $(CFLAGS) -c goodbye.cclean:rm -f *.o hello goodbye```这个Makefile定义了两个目标:all和clean。

交叉编译makefile编写

交叉编译makefile编写

交叉编译makefile编写交叉编译Makefile编写在软件开发中,我们通常会遇到需要在不同平台上编译程序的情况。

当我们需要在一台主机上编译运行另一种架构的程序时,就需要进行交叉编译。

而Makefile作为一种构建工具,可以帮助我们自动化编译过程,提高开发效率。

本文将介绍如何编写适用于交叉编译的Makefile,以实现在不同平台上的程序构建。

一、了解交叉编译概念交叉编译是指在一台主机上编译生成另一种架构的可执行文件。

通常情况下,我们在本机上编写并编译程序,然后在本机上运行。

但是,当我们需要在不同的平台上运行程序时,由于不同平台的指令集、库文件等差异,我们就需要使用交叉编译来生成适用于目标平台的可执行文件。

二、Makefile的基本结构Makefile是一种用于描述程序构建过程的文件,它包含了一系列规则(rules),每个规则由一个或多个目标(target)和依赖项(dependencies)组成。

当某个目标的依赖项发生变化时,Make工具会根据规则自动更新目标文件。

一个基本的Makefile结构如下所示:```target: dependenciescommand```其中,target表示目标文件,dependencies表示目标文件的依赖项,command表示生成目标文件的命令。

三、交叉编译的Makefile编写在编写交叉编译的Makefile之前,我们需要了解目标平台的相关信息,如架构、编译器、库文件等。

以ARM架构为例,我们可以使用arm-linux-gnueabi-gcc作为交叉编译器。

我们需要定义一些变量,用于指定交叉编译工具链和相关参数:```CC = arm-linux-gnueabi-gccCFLAGS = -Wall -O2```其中,CC表示编译器,CFLAGS表示编译参数。

接下来,我们可以定义目标文件和依赖项:```TARGET = myprogramSRCS = main.c foo.c bar.cOBJS = $(SRCS:.c=.o)```其中,TARGET表示目标文件,SRCS表示源文件列表,OBJS表示目标文件列表。

makefile编写规则

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。

windows makefile编写规则

windows makefile编写规则

Windows Makefile编写规则1. 简介Makefile是一种用于自动化构建和管理项目的工具,它为程序员提供了一种简单的方式来定义和组织项目的编译和链接规则。

在Windows操作系统上,我们可以使用GNU Make工具来解析和执行Makefile文件,实现自动化构建。

2. Makefile的基本语法Makefile由一系列规则组成,每个规则包含一个或多个目标、依赖和命令。

当目标所依赖的文件发生变化时,Make工具会根据规则中定义的命令来重新构建目标。

2.1 目标目标是Makefile中的主要元素,它表示需要构建的文件或操作。

目标可以是一个文件名,也可以是一个伪目标,用于执行一系列命令而不产生任何文件。

target: dependenciescommand2.2 依赖依赖表示目标所依赖的文件或目标。

当依赖的文件发生变化时,Make工具会重新构建目标。

target: dependency1 dependency2command2.3 命令命令是Makefile中的具体操作,用于构建目标或执行其他任务。

命令必须以Tab键开头,否则Make工具无法正确解析。

target:command1command23. Windows下的Makefile在Windows操作系统下,我们可以使用GNU Make工具来执行Makefile文件。

为了能够在Windows上使用Make工具,我们需要安装MinGW或Cygwin等工具集,以提供类Unix环境的支持。

3.1 安装MinGWMinGW是一个Windows上的开发工具集,它提供了一系列的GNU工具,包括GCC编译器和Make工具。

我们可以通过以下步骤来安装MinGW:1.下载MinGW安装程序,可以从官方网站或镜像站点下载。

2.运行安装程序,选择需要安装的组件,包括GCC编译器和Make工具。

3.设置安装路径,并完成安装。

3.2 编写Makefile在Windows下编写Makefile与在Unix系统下基本相同,只是需要注意路径的表示方式。

makefile编写规则 ifeq

makefile编写规则 ifeq

makefile编写规则 ifeq什么是makefile?makefile是一种用于自动化构建程序的工具,它能够根据文件之间的依赖关系,自动决定哪些文件需要重新编译。

makefile由一系列规则组成,每个规则定义了如何生成一个或多个目标文件。

make命令会根据这些规则来执行相应的操作,从而实现自动化构建的功能。

ifeq规则的作用在makefile中,ifeq是一种条件语句,用于判断某个条件是否为真。

它的基本语法如下:ifeq (condition, value)# 条件为真时执行的操作else# 条件为假时执行的操作endifcondition是一个条件表达式,可以使用各种比较运算符来进行比较。

value是一个字符串,用于与condition进行比较。

如果condition和value相等,则条件为真,执行ifeq后面的操作;否则条件为假,执行else后面的操作。

ifeq规则的使用场景ifeq规则在makefile中的使用场景很多,下面列举了几个常见的用法:1. 根据不同的操作系统执行不同的操作在跨平台开发中,可能需要根据不同的操作系统执行不同的操作。

可以使用ifeq 规则来判断当前的操作系统,然后执行相应的操作。

ifeq ($(OS),Windows_NT)# Windows系统下的操作CC = clelse# 非Windows系统下的操作CC = gccendif上面的示例中,如果当前操作系统是Windows,则将CC变量设置为cl;否则,将CC变量设置为gcc。

2. 根据变量的值执行不同的操作有时候需要根据某个变量的值来执行不同的操作。

可以使用ifeq规则来判断变量的值,然后执行相应的操作。

ifeq ($(DEBUG),1)# 调试模式下的操作CFLAGS = -gelse# 非调试模式下的操作CFLAGS =endif上面的示例中,如果DEBUG变量的值为1,则将CFLAGS变量设置为-g;否则,将CFLAGS变量设置为空。

sv中 makefile文件的写法

sv中 makefile文件的写法

很高兴接到您的指示,让我来帮助您撰写关于sv中makefile文件的文章。

让我们来深入了解一下makefile文件的概念和作用。

1. 什么是makefile文件?在SV(SystemVerilog)编程中,makefile文件是用来组织和管理编译工程中的各个源文件和依赖关系的文件。

它定义了编译规则和指令,用于自动化编译和构建整个项目。

2. makefile文件的基本结构在编写makefile文件时,通常会包含以下基本元素:- 变量定义:定义编译器、编译选项、源文件列表等变量。

- 规则定义:定义编译规则,包括目标文件、依赖文件和编译指令。

- 依赖关系:明确指出各个源文件之间的依赖关系,以便make工具能够正确地进行编译。

3. sv中makefile文件的写法在SV项目中,编写makefile文件需要特别关注以下几点:- 定义变量:可以通过定义变量来指定编译器、编译选项、原文件列表等信息,使得makefile文件更加灵活和可维护。

- 设置规则:需要设置好编译规则,包括目标文件、依赖文件和编译指令。

这些规则应该准确反映出SV项目的结构和依赖关系。

- 定义依赖:在makefile文件中,需要清晰地定义各个源文件之间的依赖关系,以确保make工具能够正确地进行增量编译,提高编译效率。

4. 个人观点和理解在我看来,编写高质量的makefile文件对于SV项目的管理和维护至关重要。

一个良好的makefile文件可以提高项目的编译效率,简化编译过程,并且便于团队协作和代码管理。

在编写makefile文件时,应该注重规范和细节,以确保项目的可维护性和稳定性。

总结回顾通过编写这篇文章,我深入了解了sv中makefile文件的写法,并且通过我的个人观点和理解对这个主题进行了探讨。

在文章中多次提及了主题文字,并采用了从简到繁、由浅入深的方式来探讨主题,以便您能更深入地理解。

希望这篇文章能够对您有所帮助。

以上是我为您准备的关于sv中makefile文件的文章,希望能够满足您的要求。

python makefile编写规则

Python Makefile编写规则随着Python语言的流行和应用范围的不断扩大,开发人员在日常工作中经常会用到Makefile来管理代码的编译和部署过程。

Makefile 是一个用于组织代码编译和部署流程的工具,它可以帮助开发人员自动化代码构建的过程,提高工作效率。

在Python项目中,编写规范的Makefile可以帮助开发人员管理项目中繁杂的编译和部署过程,本文将介绍Python Makefile编写的规则和技巧。

一、Makefile简介Makefile是一个包含一系列规则的文件,用于指定代码的编译和部署过程。

它通常由一系列规则、依赖关系和命令组成,它告诉make命令如何编译和信息代码。

Makefile通常用于C/C++项目的编译,但在Python项目中同样有着广泛的应用。

二、Python Makefile编写规则1. 定义变量在编写Python Makefile时,首先需要定义一些变量,这些变量可以用于存储编译器、编译选项、源文件目录、目标文件目录等。

下面是一个简单的Python Makefile示例:```MakefileCC = pythonCFLAGS = -O2SRC_DIR = srcOBJ_DIR = obj```2. 定义规则在Makefile中,可以定义一系列规则来指定如何编译和信息代码。

在Python项目中,通常会定义编译规则、信息规则和清理规则。

下面是一个简单的Python Makefile示例:```Makefileall: $(OBJ_DIR)/m本人n.o$(CC) $(CFLAGS) $(OBJ_DIR)/m本人n.o -o app$(OBJ_DIR)/m本人n.o: $(SRC_DIR)/m本人n.py$(CC) $(CFLAGS) -c $(SRC_DIR)/m本人n.py -o $(OBJ_DIR)/m本人n.oclean:rm -f $(OBJ_DIR)/*.o app```在上面的示例中,定义了三个规则:all规则用于编译信息代码生成可执行文件,$(OBJ_DIR)/m本人n.o规则用于编译源文件生成目标文件,clean规则用于清理生成的目标文件和可执行文件。

C++Makefile文件编写

C++Makefile⽂件编写
对现有的⼀个C++动态库⽂件和调⽤程序,分别编写Makefile⽂件,从零开始,这⾥把⾃⼰弄明⽩的⼀些东西分享给⼤家。

1、必须明确Linux下,C++的编译器是g++,C语⾔的是gcc。

⽹上⼤多数⼜是以.c⽂件编写的makefile⽰例,所⽤的编译器是gcc,如果
C++写成了gcc,C语⾔中没有类,会显⽰class未知的定义错误。

2、当有⼀个或多个动态库时,应该为每个动态库都写⼀个Makefile⽂件,为调⽤动态库的程序写⼀个Makefile⽂件,⽽不是写在⼀起,这样才⽅便之后的修改维护。

3、Makefile的基本语句是确定的,当我们要使其易修改时,会预先定义⼀些变量,代表⽂件所在的路径,其实路径是可以组合的,我们要写的就是让编译器能找到需要的⽂件。

介绍我需要写makefile⽂件时的情况。

⼀个动态库⽂件,动态库⽂件中引⽤了外部的头⽂件。

Makefile⽂件执⾏编译的时候,先将.cpp⽂件转换成.o⽂件,在这个构成中依赖.cpp⽂件(源⽂件),以及.cpp中引⽤了的头⽂件。

⼀句句解释上⾯这个为动态库⽂件写的Makefile⽂件:
1' CC指定编译器是g++,代表C++编译器,后⾯出现的CC都表⽰g++;
2' INCLUDE指定头⽂件路径,⼀般的,程序⾃⼰写的头⽂件⽤相对路径,如果不是把动态库⽂件的头⽂件复制到⾃⼰写的⼯程⽂件中的话,就⽤绝对路径指向动态库⽂件的头⽂件;有多个头⽂件路径需要添加时,在路径前添加-I,不要有空格;
3' DLL_OBJ代表要⽣成的动态库⽂件
4' 5' 设定⽬录。

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的基本使用方法如下: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文件中的规则和依赖关系来编译源代码文件并生成目标文件和可执行文件。

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

详细解读Makefile文件(续)
clean: rm -rf *.o helloworld #当用户输入make clean命令时,会执行rm指令,其功能是删 除*.o 和helloworld文 件。 写好Makefile文件,在命令行中直接键入make命令,就会执 行Makefile中的内容了
返回
确。对于声明,通常需要你告诉编译器头文件所在的位 置(头文件中应该只是声明,而定义应该放在源文件中 ),只要所有的语法正确,编译器就可以编译出中间目 标文件。一般来说,每个源文件可以生成一个中间目标 文件(.o文件或是.obj文件)。
关于程序的编译和链接
链接时,主要是找到函数和全局变量的定义。
链接器并不管函数所在的源文件,只管函数的中间目标 文件(Object File)。在大多数时候,由于源文件太多 ,编译生成的目标文件太多,而在链接时需要明显地指 出中间目标文件名,这对于编译很不方便,所以,我们 要给中间目标文件打个包,在Windows下这种包叫“库 文件”(Library File),也就是 .lib 文件,在UNIX下, 是Archive File,也就是 .a 文件 或.so 下面是一个包含三个文件的工程
返回Biblioteka 准备文件file2.h#ifndef FILE2_H_ #define FILE2_H_ #include<stdio.h> void File2Print(); #endif
返回
8.1.4Makefile里的主要规则
target ... : prerequisites ... command ...
Makefile编写
目的:掌握 make 的基本语法,使用make编译程序。
8.1.1Make 概述
makefile定义整个工程的编译规则
一个工程中的源文件不计数,其按类型、功能、模块分 别放在若干个目录中,makefile定义了一系列的规则来指定, 哪些文件需要先编译,哪些文件需要后编译,哪些文件需要 重新编译,甚至于进行更复杂的功能操作。
使用变量
取得变量值的方式:$(变量名)或 ${变量名}
定义变量 = 使用时展开 := 定义时即展开(只能使用已经定义好的变量) += 变量追加 ?= 若未定义则定义,若已定义则不执行此定义 例如: 例如: objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o 于是,我们就可以很方便地在我们的makefile中以“$(objects)”的方 式来使用这个变量了
假设一个工程有3个头文件,和8个源文件,我们按照那 三个规则写出的makefile应该是下面的这个样子的。
edit :main.o kbd.o command.o display.o \ insert.o search.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 kbd.o : kbd.c defs.h command.h cc -c kbd.c command.o : command.c defs.h command.h cc -c command.c
8.1.2关于程序的编译和链接
无论是C、C++,首先要把源文件编译成中间代码文件 ,在Windows下是 .obj 文件,UNIX下是 .o 文件,即目 标文件,这个动作叫做编译(compile)。 然后再把大量的目标文件链接成执行文件,这个动作叫 作链接(link)。
编译时,编译器检查语法,函数与变量的声明是否正
详细解读Makefile文件(续)
file1.o : file1.c file2.h gcc -c file1.c -o file1.o file1.o依赖file1.c 和file2.h这两个文件,编译出file1.o文件。 若依赖文件中有任意一个文件不存在或比file1.o新,都会 重新执行下面的gcc命令。 -c表示gcc 只把给它的文件编译成.o文件,用源码文件的 文件名命名但把其后缀由“.c” 变成“.o”。在这句中,可 以省略-o file1.o,编译器默认生成file1.o文件,这就是-c的 作用。 file2.o : file2.c file2.h gcc -c file2.c -o file2.o 返回 这两句的功能同上。
display.o : display.c defs.h buffer.h cc -c display.c insert.o : insert.c defs.h buffer.h cc -c insert.c search.o : search.c defs.h buffer.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 clean : rm edit main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o
在这个makefile中, 目标文件(target)包含:执行文件edit和中间目 标文件(*.o)。依赖文件(prerequisites)就是 冒号后面的那些 .c 文件和 .h文件。 每一个 .o 文件都有一组依赖文件,而这些 .o 文 件又是执行文件 edit 的依赖文件。 依赖关系的实质上就是说明了目标文件是由哪 些文件生成的,换言之,目标文件是哪些文件 更新的。
1. target是一个目标文件,可以是Object File,也可以是执行文 件。还可以是一个标签(伪目标) 。 2. prerequisites是要生成那个target所需要的文件或是目标。 3. command也就是make需要执行的命令。(任意的Shell命令)
文件的依赖关系,也就是说,target……是需要生成的一个或多个 文件,它们依赖于 prerequisites......中列出的文件,通过执行 command来生成target.....。 一个规则可以有多个命令行,每一条命令占一行。 注意:每一个 命令行必须以[Tab]字符开始,[Tab]字符告诉 make 此行是一个命令 行。make按照命令完成相应的动作。这也是书写 Makefile 中容易 产生,而且比较隐蔽的错误。
make如何工作
这就是整个make的依赖性,make会一层又一层地去找文 件的依赖关系,直到最终编译出第一个目标文件。 在找寻的过程中,如果出现错误,比如最后被依赖的文 件找不到,那么make就会直接退出,并报错,而对于所 定义的命令的错误,或是编译不成功,make根本不理。 通过上述分析,我们知道,像clean这种,没有被第一个 目标文件直接或间接关联,那么它后面所定义的命令将 不会被自动执行,不过,我们可以显示要make执行。即 命令——“make clean”,以此来清除所有的目标文件, 以便重编译。
变量基础
objects = program.o foo.o utils.o program : $(objects) cc -o program $(objects)
或者:cc $^ -o $@ $^和$@属于自动化变量
①$@ 表示规则中的目标文件集。在模式规则中,如果有多个目 标,那么,"$@"就是匹配于目标中模式定义的集合。这里是 program ②$^所有的依赖目标的集合。以空格分隔。如果在依赖目标中 有多个重复的,那个这个变量会去除重复的依赖目标,只保 留一份。 这里是$(objects)
自动化编译
只需要一个make命令,整个工程完全自动编译 ; make是一个命令工具,是一个解释makefile中指令的命 令工具;一般来说,大多数的IDE都有这个命令,比如: Delphi的make,Visual C++的nmake,Linux下GNU的make。 可见,makefile都成为了一种在工程方面的编译方法。
这就是Makefile的规则,也是Makefile中最核心的内容。
编写Makefile文件
helloworld:file1.o file2.o gcc file1.o file2.o -o helloworld file1.o:file1.c file2.h gcc -c file1.c -o file1.o file2.o:file2.c file2.h gcc -c file2.c -o file2.o clean: rm -rf *.o helloworld
make如何工作
在默认的方式下,也就是我们只输入make命令。那么: 1、make会在当前目录下找名字叫“Makefile”或“makefile” 的文件。 2、默认的情况下,make执行的是Makefile中的第一个规则。 此规则的第一个目标称之为“最终目的”或者“终极目标” 。在上面的例子中,它会找文件中的第一个目标文件(target ),即“edit”这个文件,并把这个文件作为最终的目标文件 。 3、如果edit文件不存在,或是edit所依赖的后面的 .o 文件的 文件修改时间要比edit这个文件新,那么,他就会执行后面所 定义的命令来生成edit这个文件。 4、如果edit所依赖的.o文件也不存在,那么make会在当前文 件中找目标为该.o文件的依赖规则,如果找到则再根据那一 个规则生成.o文件。(这有点像一个栈的过程) 5、前提你的.c文件和.h文件是存在
Makefile里主要有什么
显式规则、隐晦规则、变量定义、文件指示和注释。
1、显式规则。显式规则说明了,如何生成一个或多的的目标文件。这是由Makefile 的书写者明显指出,要生成的文件,文件的依赖文件,生成的命令。 2、隐晦规则。由于我们的make有自动推导的功能,所以隐晦的规则可以让我们比 较粗糙地简略地书写Makefile,这是由make所支持的。 3、变量的定义。在Makefile中我们要定义一系列的变量,变量一般都是字符串,这 个有点你C语言中的宏,当Makefile被执行时,其中的变量都会被扩展到相应的引用 位置上。 4、文件指示。其包括了三个部分,一个是在一个Makefile中引用另一个Makefile, 就像C语言中的include一样;另一个是指根据某些情况指定Makefile中的有效部分, 就像C语言中的预编译#if一样;还有就是定义一个多行的命令。有关这一部分的内 容,我会在后续的部分中讲述。 5、注释。Makefile中只有行注释,和UNIX的Shell脚本一样,其注释是用“#”字符 。如果你要在你的Makefile中使用“#”字符,可以用反斜框进行转义,如:“\#”。
相关文档
最新文档