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。

vscode makefile语法

vscode makefile语法

vscode makefile语法Visual Studio Code (VSCode) 支持多种编程语言的语法高亮和智能代码补全,包括 Makefile。

在 VSCode 中,你可以使用以下步骤来配置 Makefile 的语法高亮和智能代码补全:1. 打开 VSCode。

2. 在左侧的资源管理器中,找到并打开你的 Makefile 文件。

3. 点击顶部菜单栏中的 "查看",然后选择 "命令面板"。

4. 在命令面板中输入 "Color Theme",然后选择一个你喜欢的颜色主题。

5. 确保你的 Makefile 文件已经保存,然后按下 `F5` 键,VSCode 将自动检测 Makefile 的语法并启用语法高亮。

6. 在编写 Makefile 时,VSCode 会自动提供智能代码补全功能。

你可以按下 `Ctrl+Space` 键来触发代码补全提示。

如果你想要更深入地自定义 VSCode 的 Makefile 语法高亮和智能代码补全功能,你可以参考以下步骤:1. 打开 VSCode 的设置。

你可以按下 `Ctrl+,` 键来打开设置,或者在左侧的资源管理器中右键点击一个文件或文件夹,然后选择 "Open Settings"。

2. 在设置中,搜索 "Files: Language Mode"。

3. 在 "Files: Language Mode" 设置中,选择 "Editor Config" 或 "File Association"。

如果你选择了 "Editor Config",VSCode 将使用 Editor Config 文件来决定如何解析和显示 Makefile 文件。

如果你选择了 "File Association",VSCode 将使用文件关联来决定如何解析和显示 Makefile 文件。

clion makefile编译

clion makefile编译

clion makefile编译使用CLion进行Makefile编译是一种方便且高效的方式,它可以帮助开发者轻松管理和构建复杂的项目。

CLion是一款功能强大的集成开发环境,专为C和C++开发而设计,它提供了许多有用的功能,包括代码编辑、调试和版本控制等。

我们需要在CLion中创建一个新的项目。

选择“File”->“New Project”菜单,然后选择“C Executable”或“C++ Executable”项目类型。

接下来,我们需要设置项目的名称和位置,并选择所需的编译器。

一旦项目创建完成,我们可以在CLion的项目窗口中看到项目的结构。

在项目窗口中,我们可以添加源文件、头文件和其他资源文件。

只需右键单击项目文件夹,选择“New”菜单,然后选择“C/C++ Source File”或“Header File”选项。

完成了源文件和头文件的添加后,我们可以开始编写Makefile。

Makefile是一个文本文件,用于指定如何构建项目。

它包含了一系列规则,每个规则指定了一个目标文件以及生成该目标文件所需的源文件和依赖文件。

下面是一个简单的Makefile示例:```CC = gccCFLAGS = -Wall -gSRC = main.c foo.c bar.cOBJ = $(SRC:.c=.o)TARGET = myprogram$(TARGET): $(OBJ)$(CC) $(CFLAGS) -o $@ $^%.o: %.c$(CC) $(CFLAGS) -c $< -o $@.PHONY: cleanclean:rm -f $(OBJ) $(TARGET)```在这个示例中,我们首先定义了编译器和编译选项的变量。

然后,我们定义了源文件、目标文件和最终生成的可执行文件的变量。

接下来,我们定义了一个规则来生成目标文件。

这个规则使用通配符来匹配所有的源文件,并使用编译器将它们编译成目标文件。

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 中的命令和目标。

NDS开发入门教程-MakeFile文件解析

NDS开发入门教程-MakeFile文件解析

Makefile文件解析在我写教程之前,我先感谢一下libnds的开发人员以及维护人员。

他们给我们提供了十分方便的开发库libnds,让我们能够更加快捷简单的开发NDS程序。

下面我们进入正题。

注:以下绿色为文件的原注释,紫色是我后来添加的注释方便大家理解。

#---------------------------------------------------------------------------------.SUFFIXES:#---------------------------------------------------------------------------------ifeq ($(strip $(DEVKITARM)),)$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")endifinclude $(DEVKITARM)/ds_rules#---------------------------------------------------------------------------------# TARGET 输出名称# BUILD 生成文件夹名称,对象文件以及中间文件将会被放在这个文件夹中。

# SOURCES 包含源文件的目录列表# INCLUDES 包含外部头文件的目录列表# DATA 包含二进制数据的目录列表# GRAPHICS 用grit处理文件的目录列表# AUDIO 包含用mmutil来处理的文件的文件目录# SOUNDBANK_NAME maxmod生成的soundbank的名称#MUSIC 外部音频文件目录## 所有的文件必须在与项目相关的能够找到makefile文件的文件目录下。

#---------------------------------------------------------------------------------TARGET := $(notdir $(CURDIR))BUILD := buildSOURCES := sourceINCLUDES := includeMUSIC := maxmod_data#---------------------------------------------------------------------------------# 以上部分相当于编程语言中的宏定义部分,通过:=给宏定义的变量名成进行赋值# 在以下的代码中有使用到这些宏定义。

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编译流程

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的基本使用方法如下: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经典教程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++的编译的知识,相关于这方面的内容,还请各位查看相关的编译器的文档。

简单制作Makefile方法

简单制作Makefile方法

1.在当前目录下创建一个名为hello的子目录。hello这个目录用于存放hello.c这个程序及相关文件。新建一个源程序文件hello.c
#include <stdio.h>
int main(int argc, char** argv)
{
printf("Welcome to use autoconf and automake\n");
通过以上步骤,在源代码所在目录下自动生成了Makefile文件。
configure.in文件
autoconf提用来产生"configure"文件的工具。"configure"是一个Shell脚本,它可以自动设定一些编译参数使程序能够在不同平台上进行编译。autoconf读取configure.in文件然后产生,"configure"这个Shell脚本。
如何使用产生的Makefile文件
执行configure脚本文件所产生的Makefile文件有几个预定的选项可供使用。
l make all:产生设定的目标,即生成所有的可执行文件。使用make也可以达到此目的。
l make clean:删除之前编译时生成的可执行文件及目标文件(形如*.o的中间文件)。
configure.in文件的内容是一系列GNU m4的宏,这些宏经autoconf理后会变成检查系统特性的Shell脚本。configure.in文件中宏的顺序并没有特别的规定,但是每一个configure.in文件必须以宏AC_INIT开头,以宏AC_OUTPUT结束。一般可先用autoscan这个工具扫描原始文件以产生一个configure.scan文件,再对configure.scan作些修改,从而生成configure.in文件

Makefile基础教程(重制版)

Makefile基础教程(重制版)
I
目录
Makefile 基础教程(重制版)
6.3 命令出错......................................................................................................... 29 6.4 嵌套执行 make(级联) ............................................................................... 30 6.5 定义命令包..................................................................................................... 33 第 7 章 Makefile 中变量的使用 ............................................ 34 7.1 变量的基础..................................................................................................... 34 7.2 变量中的变量................................................................................................. 35 7.3 变量的高级用法............................................................................................. 37 7.4 追加变量值..................................................................................................... 40 7.5 override 指示符 .............................................................................................. 41 7.6 多行变量......................................................................................................... 41 7.7 环境变量......................................................................................................... 42 7.8 目标变量......................................................................................................... 42 7.9 模式变量......................................................................................................... 43 第 8 章 Makefile 中的条件判断 ............................................ 44 8.1 Makefile 中的条件判断语句的示例 ............................................................. 44 8.2 Makefile 中的条件表达式的语法 ................................................................. 45 第 9 章 Makefile 中函数的使用 ............................................ 47 9.1 函数调用的语法............................................................................................. 47 9.2 字符串处理函数............................................................................................. 48 9.3 文件名操作函数............................................................................................. 52 9.4 foreach 函数.................................................................................................... 54 9.5 if 函数 ............................................................................................................. 55 9.6 call 函数 .......................................................................................................... 55 9.7 origin 函数 ...................................................................................................... 56 9.8 shell 函数 ........................................................................................................ 57 9.9 控制 make 命令的函数 .................................................................................. 58 9.10 wildcard 函数................................................................................................ 58 第 10 章 make 的运行原理 ................................................ 60 10.1 make 的退出码 ............................................................................................. 60

vivado makefile文件编写实例

vivado makefile文件编写实例

vivado makefile文件编写实例如何编写Vivado Makefile 文件。

Vivado 是一款由Xilinx 公司开发的集成电路设计工具,它提供了丰富的设计和仿真功能,可以用于设计和验证各种数字电路。

Makefile 是一种用于自动化构建和管理项目的文件,它可以定义编译、链接和运行等操作的规则。

在Vivado 中使用Makefile 可以方便地管理项目的编译和仿真过程,提高开发效率。

本文将以中括号内的内容为主题,一步一步回答如何编写Vivado Makefile 文件。

一、创建Makefile 文件首先,在Vivado 工程目录下创建一个名为Makefile 的文件。

可以使用文本编辑器或者命令行工具创建该文件。

二、Makefile 基本结构Makefile 是按照一定的规则编写的,它由一系列的规则定义组成,每个规则包含一个或多个目标、依赖和命令。

规则的语法如下:target: dependenciescommand其中,target 是规则的目标,dependencies 是目标的依赖,command 是执行的命令。

三、Vivado Makefile 常用规则1. all:编译和仿真整个工程all: build sim上述规则定义了一个名为all 的目标,它依赖于build 和sim 两个目标,执行的命令为空。

2. build:编译工程build:vivado -mode batch -source build.tcl上述规则定义了一个名为build 的目标,它执行vivado 命令,并传入-mode batch 和-source build.tcl 两个参数。

这里的build.tcl 是一个Vivado Tcl 脚本,用于自动化执行编译操作。

3. sim:仿真工程sim:vivado -mode batch -source sim.tcl上述规则定义了一个名为sim 的目标,它执行vivado 命令,并传入-mode batch 和-source sim.tcl 两个参数。

clion makefile编译

clion makefile编译

clion makefile编译在CLion 中使用Makefile 进行项目的编译,需要进行一些配置。

以下是一般的步骤:* 创建Makefile:* 在项目根目录创建名为Makefile 的文件。

在该文件中,你需要定义编译规则、源文件、目标文件等。

* 在CLion 中配置CMake:* 打开CLion,确保你的项目根目录中包含CMakeLists.txt 文件。

CMake 是CLion 的默认构建系统,它负责配置和生成Makefile。

* 在CLion 中,你可以使用File -> Open 打开项目文件夹。

* 配置Run/Debug Configurations:* 在CLion 中,点击右上角的"Run/Debug Configurations" 下拉菜单。

* 确保你选择了一个配置,如"Edit Configurations"。

* 在"Configuration" 选项卡下,选择"Make"。

* 配置Makefile 的路径:* 在"Makefile" 字段中输入Makefile 的相对路径,例如./Makefile。

* 在"Working directory" 中选择你的项目目录。

* 运行或调试项目:* 确保你选择了正确的配置,然后点击运行或调试按钮。

* 观察编译输出:* 在CLion 的"Run" 或"Debug" 窗口中,你应该能够看到Makefile 编译的输出。

请注意,确保你的Makefile 中定义了适当的编译规则,包括源文件、目标文件和编译选项。

如果你使用CMake 作为构建系统,CLion 会根据CMakeLists.txt 自动生成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`:目标文件或可执行文件的名称。

windows下makefile教程

windows下makefile教程

windows下的makefile教程先说几句废话以前看书时经常遇到makefile,nmake这几个名词,然后随之而来的就是一大段莫名其妙的代码,把我看得云里雾里的。

在图书馆和google上搜了半天,也只能找到一些零零星星的资料,把我一直郁闷得不行。

最近因缘巧合,被我搞到了一份传说中的MASM6手册,终于揭开了NMAKE的庐山真面目。

想到那些可能正遭受着同样苦难的同志以及那些看到E文就头晕的兄弟,所以就写了这篇文章。

假如大家觉得有帮助的话,记得回复一下,当作鼓励!如果觉得很白痴,也请扔几个鸡蛋.本文是总结加翻译,对于一些关键词以及一些不是很确定的句子,保留了英文原版,然后再在括号里给出自己的理解以作参考。

由于水平有限,加上使用NMAKE的经验尚浅,有不对的地方大家记得要指正唷。

MASM6手册在AOGO(好像是)可以download,在我的BLOG上有到那的链接。

关于NMAKEMicrosoft 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.objlink first.obj,second.obj第一行定义了依赖关系,称为dependency line;第二行给出了与该依赖关系相关联的操作,称为command line。

使用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⽂件,⼤致步骤相同。

cmakeqmakemakefile动态和静态库教程

cmakeqmakemakefile动态和静态库教程

cmakeqmakemakefile动态和静态库教程makefileMakefile经典教程(掌握这些⾜够)规则:makefile的基本规则就是:1. target 设定编译的target和各种的依赖⽂件已经如何从⽂件⽣成target的命令target : prerequisites ...commandtarget: 可以是object file,也可以是可执⾏⽂件,也可以是标签labelprerequisites: ⽣成target需要的⽂件或者其它的target; make 命令会检查这些依赖和上⼀次make相⽐是否有了改动,来决定这个target是否要重新更新。

command : 任何的shell命令,command⼀定要⽤Tab键开头。

对于command,GNU的make定义了⼀些隐含的规则,因此有的时候也可以不需要提供command,只提供target和依赖,GNU Make会⾃动调⽤隐含的规则(command):GNU的make很强⼤,它可以⾃动推导⽂件以及⽂件依赖关系后⾯的命令,于是我们就没必要去在每⼀个[.o]⽂件后都写上类似的命令,因为,我们的make会⾃动识别,并⾃⼰推导命令。

⽐如:a.o : a.c不需要提供command,make会⾃动使⽤gcc来⽣成以上就是最核⼼的makefile的规则。

2. 常⽤的语法(1) \ 反斜杠:换⾏符合a.c \b.c(2) 变量定义objects = a.o b.o c.o在使⽤的时候: $(objects)来调⽤这个变量(3) .PHONY : label.PHONYb表⽰后⾯的是⼀个伪⽬标,、(4) 注释 : #(5) make 命令会在当前⽬录下⾃动找: GNUmakefile, makefile, Makefile⽂件进⾏编译,如果要指定可以使⽤ “ make -f xxx”或者 make --file xxx(6) include : include可以把其他的makefile包括到当前的makefile中。

visual studio 编译 makefile

visual studio 编译 makefile

visual studio 编译makefile 在 Visual Studio 中编译 Makefile 文件通常需要一些额外的步骤,因为 Visual Studio 使用不同的构建系统。

以下是一种可能的方法:1. 使用 Visual Studio 内置工具:•打开 Visual Studio。

•在 "文件" 菜单中,选择 "打开" -> "项目/解决方案",然后选择包含 Makefile 的文件夹。

• Visual Studio 会尝试识别项目并加载。

2. 使用 "Visual Studio Code" 编辑器:•如果您使用Visual Studio Code 编辑器,可以安装"Makefile Tools" 扩展,该扩展支持在 Visual Studio Code 中使用 Makefile 进行构建。

3. 在 Visual Studio 中设置自定义生成命令:•在Visual Studio 中,您可以手动设置生成命令,以执行Makefile。

以下是一些步骤:•在 "项目" 菜单中,选择 "属性"。

•在 "配置属性" 对话框中,选择 "自定义生成步骤"。

•添加自定义命令,例如 make -f Makefile。

•在 "生成事件" 选项卡中,可以配置在生成前或生成后运行的自定义命令。

请注意,这些步骤可能需要根据您的具体情况进行调整。

确保您的项目结构、Makefile 文件和构建系统设置都正确无误。

如果项目依赖于其他库,您还需要确保这些库的头文件和库文件路径正确设置。

如果您使用的是 Visual Studio 内置的项目系统,可能需要将项目迁移到Visual Studio 的本机项目文件(例如 .vcxproj 文件),以便更好地集成 Visual Studio 的构建系统。

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

Makefile学习教程: 跟我一起写Makefile o0 Makefile概述▪0.1 关于程序的编译和链接o1 Makefile 介绍▪ 1.1 Makefile的规则▪ 1.2 一个示例▪ 1.3 make是如何工作的▪ 1.4 makefile中使用变量▪ 1.5 让make自动推导▪ 1.6 另类风格的makefile▪ 1.7 清空目标文件的规则o2 Makefile 总述▪ 2.1 Makefile里有什么?▪ 2.2Makefile的文件名▪ 2.3 引用其它的Makefile▪ 2.4 环境变量MAKEFILES▪ 2.5 make的工作方式o3 Makefile书写规则▪ 3.1 规则举例▪ 3.2 规则的语法▪ 3.3 在规则中使用通配符▪ 3.4 文件搜寻▪ 3.5 伪目标▪ 3.6 多目标▪ 3.7 静态模式▪ 3.8 自动生成依赖性o4 Makefile 书写命令▪ 4.1 显示命令▪ 4.2 命令执行▪ 4.3 命令出错▪ 4.4 嵌套执行makeMakefile概述什么是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。

1 Makefile 介绍make命令执行时,需要一个Makefile 文件,以告诉make命令需要怎么样的去编译和链接程序。

首先,我们用一个示例来说明Makefile的书写规则。

以便给大家一个感兴认识。

这个示例来源于GNU的make使用手册,在这个示例中,我们的工程有8个C文件,和3个头文件,我们要写一个Makefile来告诉make命令如何编译和链接这几个文件。

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

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

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

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

1.1 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还不够,我会以后面一点一点地结合我的工作经验给你慢慢到来。

内容还多着呢。

:)1.2 一个示例正如前面所说的,如果一个工程有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.o 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.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”或“makefil e”的文件中,然后在该目录下直接输入命令“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中定义不用的编译或是和编译无关的命令,比如程序的打包,程序的备份,等等。

1.3 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了。

这就是整个make的依赖性,make会一层又一层地去找文件的依赖关系,直到最终编译出第一个目标文件。

在找寻的过程中,如果出现错误,比如最后被依赖的文件找不到,那么make就会直接退出,并报错,而对于所定义的命令的错误,或是编译不成功,make根本不理。

make只管文件的依赖性,即,如果在我找了依赖关系之后,冒号后面的文件还是不在,那么对不起,我就不工作啦。

通过上述分析,我们知道,像clean这种,没有被第一个目标文件直接或间接关联,那么它后面所定义的命令将不会被自动执行,不过,我们可以显示要make执行。

即命令——“make clean”,以此来清除所有的目标文件,以便重编译。

于是在我们编程中,如果这个工程已被编译过了,当我们修改了其中一个源文件,比如file.c,那么根据我们的依赖性,我们的目标file.o会被重编译(也就是在这个依性关系后面所定义的命令),于是file.o的文件也是最新的啦,于是file.o的文件修改时间要比edit要新,所以edit也会被重新链接了(详见edit目标文件后定义的命令)。

相关文档
最新文档