Fortran含Module情况下Makefile文件书写

合集下载

fortran中makefile的编写

fortran中makefile的编写fortran程序中使用多个文件的方法：（一）：使用 include 'file',结果相当于将 'file' 添加到程序中一样。

（二）：使用 makefile 文件。

makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。

make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。

可见，makefile都成为了一种在工程方面的编译方法。

一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在 Windows 下也就是 .obj 文件，UNIX下是 .o 文件，即 Object File，这个动作叫做编译（compile）。

然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。

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

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

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

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

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

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

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

makefile 写法

makefile 写法makefile是一种用于自动化构建的工具，它可以帮助开发者管理项目中的源代码、依赖关系以及构建过程。

本文将详细介绍makefile的基本语法和使用方法，以及如何根据项目需求编写一个高效的makefile。

在这篇文章中，我们将一步一步回答关于makefile写法的问题。

第一步：什么是makefile及其作用？Makefile是一种文本文件，其中包含一系列的规则，告诉make命令如何编译和链接代码。

它能够根据源代码文件的修改日期来判断哪些文件需要重新编译，从而提高代码的构建效率。

通过makefile，我们可以定义编译器的参数、编译顺序和目标文件等信息，使得项目的构建过程更加简化、自动化。

第二步：makefile的基本语法是什么？Makefile由一系列的规则组成，每个规则都包含目标文件、依赖文件和命令。

下面是一个简单的示例：makefiletarget: dependency1 dependency2command1command2其中，`target`是要生成的目标文件，`dependency1`和`dependency2`是`target`所依赖的文件，`command1`和`command2`是执行的命令。

第三步：如何编写一个最基本的makefile？首先，我们需要确定项目的目标文件和依赖关系。

比如，我们的项目中有两个源代码文件`main.c`和`utility.c`，它们都依赖于一个头文件`utility.h`。

我们的目标是生成一个可执行文件`main`。

makefile# 目标文件main: main.o utility.ogcc -o main main.o utility.o# 依赖关系main.o: main.c utility.hgcc -c main.cutility.o: utility.c utility.hgcc -c utility.c第四步：如何使用变量和函数来简化makefile的编写？在makefile中，我们可以使用变量和函数来简化代码的编写。

make命令与makefile文件的写法

什么是mak‎e file？或许很多Wi‎n odws的‎程序员都不知‎道这个东西，因为那些Wi‎n dows的‎I DE都为你‎做了这个工作‎，但我觉得要作‎一个好的和p‎r ofess‎i onal的‎程序员，makefi‎l e还是要懂‎。

这就好像现在‎有这么多的H‎T ML的编辑‎器，但如果你想成‎为一个专业人‎士，你还是要了解‎H TML的标‎识的含义。

特别在Uni‎x下的软件编‎译，你就不能不自‎己写make‎f ile了，会不会写ma‎k efile‎，从一个侧面说‎明了一个人是‎否具备完成大‎型工程的能力‎。

因为，makefi‎l e关系到了‎整个工程的编‎译规则。

一个工程中的‎源文件不计数‎，其按类型、功能、模块分别放在‎若干个目录中‎，makefi‎l e定义了一‎系列的规则来‎指定，哪些文件需要‎先编译，哪些文件需要‎后编译，哪些文件需要‎重新编译，甚至于进行更‎复杂的功能操‎作，因为make‎f ile就像‎一个Shel‎l脚本一样，其中也可以执‎行操作系统的‎命令。

makefi‎l e带来的好‎处就是——“自动化编译”，一旦写好，只需要一个m‎a ke命令，整个工程完全‎自动编译，极大的提高了‎软件开发的效‎率。

make是一‎个命令工具，是一个解释m‎a kefil‎e中指令的命‎令工具，一般来说，大多数的ID‎E都有这个命‎令，比如：Delphi‎的make，V isu al‎C++的nmake‎，Linux下‎G NU的ma‎k e。

可见，makefi‎l e都成为了‎一种在工程方‎面的编译方法‎。

现在讲述如何‎写makef‎i le的文章‎比较少，这是我想写这‎篇文章的原因‎。

当然，不同产商的m‎a ke各不相‎同，也有不同的语‎法，但其本质都是‎在“文件依赖性”上做文章，这里，我仅对GN U‎的make进‎行讲述，我的环境是R‎e dHat Linux 8.0，make的版‎本是3.80。

makefile文件的写法

Makefile是一个文本文件，用于自动化编译和构建项目。

它包含一系列规则和指令，用于指定如何将源代码编译成可执行文件或库文件。

以下是一个简单的Makefile示例，用于编译一个C语言程序：makefileCC=gccCFLAGS=-Wall -gall: programprogram: main.o utility.o$(CC) $(CFLAGS) main.o utility.o -o programmain.o: main.c utility.h$(CC) $(CFLAGS) -c main.cutility.o: utility.c utility.h$(CC) $(CFLAGS) -c utility.cclean:rm -f *.o programMakefile的写法包括以下部分：变量定义：Makefile允许定义变量，用于简化编译过程中的参数传递。

例如，上述Makefile 中定义了CC和CFLAGS两个变量，分别表示编译器和编译器选项。

规则：Makefile中的规则用于指定如何将源文件编译成目标文件。

规则以目标文件名称为开头，以源文件名称为结尾，中间用冒号分隔。

例如，上述Makefile中的规则指定了如何将main.c和utility.c编译成可执行文件program。

指令：Makefile中的指令用于执行特定的任务，例如编译源文件、链接目标文件等。

例如，上述Makefile中使用(CC)(CFLAGS)命令来编译源文件。

伪目标：Makefile中的伪目标是一种特殊的规则，用于指定一组目标文件的构建顺序。

例如，上述Makefile中的all伪目标指定了所有目标文件的构建顺序。

注释：Makefile中的注释以“#”开头，用于解释规则和指令的含义。

makefile的编写

makefile的编写Makefile是一种文本文件，它描述了如何编译和链接源文件来构建程序。

它包含规则、变量和命令，用于指示编译器怎样工作。

Makefile通常用于编译大型项目，以确保能够快速构建和生成目标文件。

下面我们将分步骤阐述如何编写一个Makefile。

第一步：定义变量在编写Makefile时，我们首先需要定义变量。

变量可以用于存储文件名、目录名、选项、标志等信息。

在Makefile中，为了提高可读性和可维护性，最好把常量值都定义成变量。

变量的定义格式为：变量名=变量值。

例如：```CC = g++CFLAGS = -Wall -O2```上述代码中，CC变量定义为编译器g++，CFLAGS变量定义为编译选项-Wall -O2。

这样，我们在Makefile中就可以直接使用这些变量，而不用每次都输入完整的命令。

第二步：编写规则Makefile中的规则描述了如何生成目标文件。

一般来说，每一条规则包含两部分：目标（target）和依赖关系（dependencies）。

目标是指要生成的文件，依赖关系是指这个文件所依赖的其他文件。

规则的格式为：```target: dependenciescommands```例如：main: main.cpp func.cpp$(CC) $(CFLAGS) -o main main.cpp func.cpp```这条规则表示将main.cpp和func.cpp编译成可执行文件main。

当我们使用make命令时，Makefile会检查main.cpp和func.cpp是否有修改，如果有修改，则重新编译目标文件main。

第三步：定义伪目标伪目标（phony target）用于定义一些没有实际文件对应的操作，例如清理、安装等。

伪目标的语法格式为：```.PHONY: target```例如：```.PHONY: cleanclean:rm -f *.o main```这个规则定义了一个名为clean的伪目标，用于删除所有的目标文件和可执行文件。

Fortran含Module情况下Makefile文件书写

Fortran含Module情况下Makefile文件书写Fortran含Module情况下Makefile文件书写解决方法：1.把含Module的文件命名为.module文件，且module名字和文件名相同，一个文件里只写一个Module。

2.编译时要用-x f95来说明它是fortran 95格式，而编译其它文件f90文件到.o目标文件时，只编译依赖的f90文件（不然会有warning，反正我不喜欢有这个东西）特此发博文记录下（注意红色部分）：#Compiler and Compile optionsFC=gfortranCFLAGS = -O2#Source code files, Object files and Target(Executable) file defineSRCS = $(wildcard *.f90)OBJS = $(SRCS:.f90=.o)TARGET = apiMODSRCS = $(wildcard *.module)MODOBJS = $(MODSRCS:.module=.o)MODS = $(MODSRCS:.module=.mod)#Debug purpose.#all:# @echo $(SRCS)# @echo $(MODOBJS)#Generate Target file using Object files$(TARGET): $(OBJS) $(MODOBJS)$(FC) $(CFLAGS) $^ -o $@#Generate Object files using Source code files%.o: %.f90 $(MODS)$(FC) $(CFLAGS) -c $<$(MODS) $(MODOBJS): $(MODSRCS)$(FC) $(CFLAGS) -x f95 -c $^##Use "make run" can run the Target filerun:@./$(TARGET)#Clean the Object filesclean:rm $(OBJS) $(MODOBJS) $(wildcard *.mod)#Clean both the Object files and Target fileclean-all:rm $(TARGET) $(OBJS) $(MODOBJS) $(wildcard *.mod)（如果你要复制上面的代码，记得把编译规则（:的下一行）前面的加Tab）中间用到通配符，变量，搜索一类文件的功能，还有变量替换。

makefile写法

MakefileZheda Innovation Technology CO.LTD2009-7-22目录1概述 (3)2作用 (3)3规则 (3)3.1M AKEFILE规则 (3)3.2简单例子 (4)4MAKE工作方式 (4)Revision History1概述makefile关系到了整个工程的编译规则。

一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。

makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make 命令，整个工程完全自动编译，极大的提高了软件开发的效率。

2作用Makefile的作用，简单说来，就是制定编译(compile)和链接(link)规则，告诉make命令如何编译和链接程序。

Makefile来告诉make命令如何编译和链接这几个文件。

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

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

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

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

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

还可以是一个标签（Label）。

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

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

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

fortran程序makefile

fortran程序makefile原文来自http://marjan.fesb.hr/~psarajce/makefiles.html这是一片介绍fortran程序makefile文件编写的文章。

正文：假设有四个文件，分别是：main.f90global.f90function1.f90subroutine1.f90其中main.f90中包括主程序。

它调用函数和子程序；global.f90中用module定义一些全局变量(过程)，这个module 被main.f90以及function1.f90中的function1函数调用；function1.f90中包括一个函数function1，它被main.f90调用；subroutine1.f90中包括一个过程subroutine1,它也被main.f90调用；1.直接生成可执行文件假如我们手头上有一个intel的fortran编译器进行编译，就要采用如下命令：ifort global.f90 main.f90 function1.f90 subrouine1.f90这样会自动生成文件a.out，这是一个可执行文件。

因为编译器将上述四个文件编译(compile)后生成目标文件(***.o),并将这几个目标文件自动连接起来(link)。

同时我们会发现当前目录下多了如下几个文件：global.oglobal.modmain.ofunction1.osubroutine1.o如果想让生成的可执行程序有一个名字，将命令改成ifort -o execname global.f90 main.f90 function1.f90 subrouine1.f90即可。

输入命令./execname即可执行该程序。

2.分步进行Build=Compile+Link。

所以我们也可以不直接生成程序，而是先编译文件以产生目标文件（即不连接）。

例：ifort -c function1.f90这个命令会生成与源程序(Source)function.f90相对应的目标文件(Object file)。

makefile写法

makefile写法Makefile 是代码构建和自动化构建的重要工具，它可以帮助我们高效、准确地管理和构建程序。

在本文中，我将和大家分享几种常见的Makefile 写法，以及一些有用的技巧和注意事项。

1. Makefile 的基本结构Makefile 中包含了以下基本结构：```target: dependencies<tab> command```其中，target 表示目标文件或目标任务名称；dependencies 表示该目标文件或任务所依赖的文件或任务；command 表示需要执行的命令。

比如，下面是一个简单的 Makefile 例子：```all: testtest: main.o func.o<tab> gcc main.o func.o -o testmain.o: main.c<tab> gcc -c main.c -o main.ofunc.o: func.c func.h<tab> gcc -c func.c -o func.o```其中，目标文件 all 是 Makefile 的默认目标，执行 make 命令时会自动执行 all 目标中所列出的任务。

在本例中，all 的唯一任务是test。

test 任务需要依赖 main.o 和 func.o，如果这两个文件不被更新，则 test 任务不会被重新构建。

2. Makefile 的变量在 Makefile 中，我们可以定义变量来方便地管理代码中的重复部分。

变量可以在任何位置使用，使得代码更加清晰易读，同时也方便了维护。

变量的定义格式是：```变量名 = 值```例如：```CC = gccCFLAGS = -Wall -g```在 Makefile 内使用变量的格式是 $+变量名。

例如：```all: testtest: main.o func.o<tab> $(CC) main.o func.o -o test $(CFLAGS)main.o: main.c<tab> $(CC) -c main.c -o main.o $(CFLAGS)func.o: func.c func.h<tab> $(CC) -c func.c -o func.o $(CFLAGS)```在本例中，我们定义了两个变量，CC 和 CFLAGS。

如何写makefile及makefile文件的执行

如何写makefile及makefile⽂件的执⾏******************************************************makefile有什么作⽤呢?它可以⽤来做什么呢?makefile有很⼤的功能，可以帮助你完成⼀些⼤型的⼯程。

要想成为专业的⼈⼠，makefile的编写是必须会的。

makefile关系到了整个系统的编译规则。

⼀个⼯程中的源⽂件很多，按类型功能等，放在了不同的⽂件夹中，makedfile就定义了⼀系列的规则，指定哪些⽂件先编译，哪些⽂件后编译，哪些⽂件重新编译等等⼀系列的功能操作。

makefile还有⼀个好处就是能进⾏⾃动化编译，⼀旦makefile写好了之后，只要⼀个make命令，整个⼯程就可以完全⾃动化编译，⼤⼤提⾼了⼯作的效率。

**************************************⼀、Makefile的简单编写**************************************在执⾏make命令时，当前⽂件夹中需要有⼀个makefile⽂件，makefile中编写了怎么去编译和链接这个程序的语句。

makefile的规则：target ... : prerequisites ...command......target是⽬标⽂件，可以是后边编译后⽣成的执⾏⽂件，可以只是⼀个标签。

prerequisites是⽣成target所需要的⽂件或⽬标，就是依赖。

command就是在shell中输⼊make后执⾏的命令这就是⼀个⽂件依赖关系，target依赖于prerequisites中的⽂件，其⽣成规则定义在command中。

target⼀定要⽐prerequisites新，不然的话command多定义的命令就会被执⾏，这就是Makefile的规则，也是Makefile最核⼼的内容。

************举例*************编写add.c、sub.c、mul.c、div.c四个函数，⽤test.c将四个函数实现，然后编写⼀个Makefile编译函数math⽂件夹中的⽂件包括：编写Makefile⽂件：编写完后，make⼀下，观察过程：这时，⽂件夹中的⽂件为：以长列表的形式观察个⽂件：观察可知：target⽂件test之所有⽂件中最新的，如果它不为新，那么在执⾏make命令时，test将会被更新。

大型项目makefile写法

大型项目makefile写法1. 介绍在大型软件项目中，为了方便管理和构建代码，通常会使用makefile 来编写构建规则。

makefile是用于告诉make命令如何编译和信息程序的文件，它包含了一系列的规则和依赖关系，可以帮助开发人员自动化地构建项目。

2. makefile的基本语法在编写makefile时，需要了解其基本语法。

makefile由一系列规则组成，每个规则包括一个目标、一个或多个依赖项和一组命令。

其中，目标是规则的执行目标，依赖项是目标的依赖文件或者其他目标，命令是执行规则时需要执行的命令。

3. makefile的变量和函数makefile中可以定义变量和函数，以方便代码的重用和管理。

变量可以用来存储一些常量或者路径，函数可以用来进行一些复杂的操作。

在大型项目中，合理使用变量和函数可以使makefile更加清晰易读。

4. makefile的高级用法除了基本的规则、变量和函数外，makefile还支持一些高级用法，比如模式匹配、自动变量等。

这些高级用法可以进一步简化构建规则的编写，提高代码的复用性和可维护性。

5. 大型项目makefile的最佳实践在大型项目中，makefile的写法需要遵循一些最佳实践，比如分模块编写、合理使用变量和函数、注意依赖关系的确定等。

这些实践可以帮助开发人员更好地管理和构建项目，减少出错的可能性。

6. 总结通过合理编写makefile，可以使大型项目的管理和构建变得更加高效和可靠。

在编写makefile时，需要注意其基本语法、变量和函数的使用，以及一些高级用法和最佳实践，从而使makefile更加清晰易读、易于维护。

7. makefile的模块化编写大型项目通常包含多个模块，每个模块都有自己的依赖关系和构建规则。

为了更好地组织makefile，可以将每个模块的构建规则分别写在不同的文件中，然后在主makefile中引入这些文件。

这样做可以使makefile更加清晰，便于维护。

makefile 的编写及应用

makefile 的编写及应用Makefile是一种用来管理编译程序的工具，它提供了一种自动化编译的方式，可以根据文件的依赖关系来自动编译相关的文件，从而提高编译的效率。

Makefile的编写通常包括以下几个部分：目标、依赖关系、命令和变量。

一般来说，一个Makefile文件中可以包含多个规则，每个规则由一个或多个目标、依赖关系和命令组成。

其中目标是需要生成的文件，依赖关系是生成目标所需要依赖的其他文件，命令则是生成目标所执行的命令。

一个简单的Makefile示例如下：```# 定义变量CC = gccCFLAGS = -Wall -Wextra# 定义目标和依赖关系target: main.o func.o$(CC) $(CFLAGS) -o target main.o func.omain.o: main.c func.h$(CC) $(CFLAGS) -c main.cfunc.o: func.c func.h$(CC) $(CFLAGS) -c func.c# 定义清理操作clean:rm -f target main.o func.o```在上述示例中，我们定义了两个目标：target和clean。

其中，target这个目标所依赖的是main.o和func.o两个文件，生成目标的命令是使用gcc编译这两个文件，最后生成一个名为target的可执行文件。

clean这个目标用来清理生成的文件。

应用Makefile可以帮助我们自动地完成编译、链接和清理等操作，提高了开发的效率。

可以在命令行中执行`make`命令来根据Makefile文件来生成目标程序，执行`make clean`命令可以清理生成的文件。

总结起来，Makefile的编写及应用包括以下几个步骤：1. 定义变量，用来保存编译器和编译选项等信息；2. 定义目标和依赖关系，用来描述生成文件之间的依赖关系；3. 编写命令，用来执行生成目标的操作；4. 可选地定义清理操作，用来清理生成的文件；5. 在命令行中执行make命令来根据Makefile文件来自动编译生成目标程序。

简述Makefile文件的格式

简述Makefile文件的格式Makefile文件是一种常见的文本文件，用于描述一个项目中各个文件之间的依赖关系和编译规则。

Makefile文件通常由一系列规则组成，每个规则由一个目标、依赖关系和命令组成。

Makefile文件的格式如下：1. 目标(Target)目标是指需要生成的文件或者执行的操作。

在Makefile中，目标通常是一个可执行程序或者一个库文件。

目标的格式为：target: dependenciescommand其中，target表示目标名称，dependencies表示该目标所依赖的其他文件或者操作，command表示生成该目标所需要执行的命令。

2. 依赖关系(Dependencies)依赖关系指该目标所依赖的其他文件或者操作。

在Makefile中，可以通过在目标后面加上冒号(:)来定义该目标所依赖的其他文件或者操作。

多个依赖关系之间可以使用空格或者Tab键来进行分隔。

3. 命令(Command)命令是指生成该目标所需要执行的具体操作。

在Makefile中，可以通过在每个规则后面添加一行以Tab键开头的命令来定义具体操作。

4. 变量(Variables)变量是指用于存储各种编译参数和路径等信息的变量。

在Makefile中，可以通过使用$()符号来引用变量，并使用=符号来进行赋值操作。

例如：CFLAGS = -Wall -O2CC = gcctarget: dependencies$(CC) $(CFLAGS) -o target dependencies5. 注释(Comments)注释是指用于对Makefile中各个规则进行解释说明的文本。

在Makefile中，可以使用#符号来进行注释，#符号后面的内容将被忽略。

总之，Makefile文件是一个非常重要的工具，在项目开发过程中起到了至关重要的作用。

掌握Makefile文件的格式和编写方法，可以帮助我们更加高效地管理和组织项目代码，并提高项目开发效率。

MAKEFILE的编写

MAKEFILE的编写第一章Makefile简介什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows 的IDE都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。

这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。

特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。

因为，makefile关系到了整个工程的编译规则。

makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。

make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。

可见，makefile都成为了一种在工程方面的编译方法。

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

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

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

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

make使用方法以及makefile的编写

make使用方法以及makefile的编写make是一个常用的构建工具，通过解析Makefile文件来完成代码的编译、链接和打包等操作。

下面是make的使用方法以及Makefile的编写方法：使用方法：1. 创建一个名为Makefile的文件，并在该文件中定义编译规则。

2. 在命令行中进入到Makefile所在的目录。

3. 执行make命令即可开始编译。

4. make根据Makefile文件中的规则来判断哪些文件需要重新编译，然后执行相应的编译命令。

Makefile的编写：1. 编写规则格式如下：target: dependencies<tab> command其中，target是规则的目标文件，dependencies是依赖的文件，command 是执行的命令。

2. 使用变量来简化编写过程，例如：CC=gccCFLAGS=-Walltarget: dependencies(CC) (CFLAGS) -o target source.c这里的CC是编译器，CFLAGS是编译选项。

3. 使用通配符（如"%"）来表示一组文件或者目录，例如：objects := (patsubst %.c, %.o, (wildcard *.c))target: (objects)(CC) (CFLAGS) -o target (objects)这里使用wildcard获取所有的.c文件，然后使用patsubst将.c替换为.o。

4. 可以定义伪目标（phony target）来执行一些特殊的命令，例如：.PHONY: cleanclean:rm -f target (objects)这里的clean是一个伪目标，rm命令会删除目标文件以及所有的依赖文件。

5. 可以使用条件语句来根据不同的条件执行不同的命令，例如：ifdef DEBUGCFLAGS += -gendiftarget: dependencies(CC) (CFLAGS) -o target source.c这里的ifdef DEBUG表示只有在定义了DEBUG宏的情况下才启用-g（调试）选项。

makefile的规则和编写方法

makefile的规则和编写方法Makefile是一种文本文件，它包含了一系列规则和命令，用于描述源代码的编译和构建过程。

Makefile的规则和编写方法对于项目的管理和维护非常重要。

下面是关于Makefile规则和编写方法的一些要点：1. 目标（Targets）：每个Makefile中都应该定义一个或多个目标。

目标通常代表项目中的某个文件、可执行程序或者一个任务。

在Makefile中，目标的名称应该在冒号（:）后面给出，并且每个目标都应该独占一行。

2. 依赖（Dependencies）：在Makefile中，每个目标通常都会依赖于其他文件或目标。

依赖关系表示了一个文件或目标的生成所依赖的其他文件或目标。

依赖关系可以使用冒号（:）来表示，冒号前是目标名称，冒号后是该目标所依赖的文件或目标。

3. 命令（Commands）：在Makefile中，每个目标都需要定义一个或多个命令，用于生成该目标所描述的文件或任务。

每个命令需要以制表符（Tab）开头，紧随其后的是具体的操作指令，如编译命令、链接命令等。

命令之间可以使用换行符进行分隔。

4. 变量（Variables）：在Makefile中，可以使用变量来存储常用的数值、目录路径或者编译器选项等信息。

变量可以使用等号（=）或冒号等号（:=）进行赋值。

通过使用变量，可以大大简化Makefile的编写和维护过程。

5. 注释（Comments）：注释用于解释Makefile中的规则和命令，以提高代码的可读性。

在Makefile 中，可以使用井号（#）表示注释，井号后的内容会被忽略。

编写一个简单的Makefile示例：```# 定义变量CC = gccCFLAGS = -Wall -O2# 定义目标和依赖关系myprogram: main.o func1.o func2.o$(CC) $(CFLAGS) -o myprogram main.o func1.o func2.o# 生成目标的命令main.o: main.c$(CC) $(CFLAGS) -c main.cfunc1.o: func1.c$(CC) $(CFLAGS) -c func1.cfunc2.o: func2.c$(CC) $(CFLAGS) -c func2.c# 清理目标文件的命令clean:rm -f *.o myprogram```以上是一个简单的Makefile示例。

makefile文件写法解析

makefile⽂件写法解析⼀、makefile⽂件⽰例makefile⽂件并不难写，⼀个makefile模版如下所⽰，所有makefile⽂件在此基上稍微修改就可以了。

# this is a makefile #这⼀⾏是注释NAME = MemInfo.exe #下来这⼏⾏是宏定义，相当于linux的变量OBJS = $(NAME).objRES = $(NAME).resLINK_FLAG = /subsystem:windowsML_FLAG = /c /coff$(NAME): $(OBJS) $(RES) #这⼀⾏指出最终⽣成的exe⽂件依赖哪些obj和res⽂件Link $(LINK_FLAG) $(OBJS) $(RES) #这⼀⾏是⽣成exe时执⾏的链接命令；.asm.obj: #这⼀⾏表⽰.asm⽂件转成.obj⽂件要使⽤下边这个语句ml $(ML_FLAG) $< #这⼀⾏是使⽤.asm转.obj的编译命令；$<表⽰对当前⽬录下所有.asm⽂件进⾏编译且编译⽣成的.obj⽂件使⽤和原来.asm⽂件⼀样的名字.rc.res: #这⼀⾏表⽰.rc⽂件转成.res⽂件要使⽤下边这个语句rc $< #这⼀⾏是使⽤.rc转.res的编译命令；$<表⽰对当前⽬录下所有.rc⽂件进⾏编译且编译⽣成的.res⽂件使⽤和原来.rc⽂件⼀样的名字clean: #这⼀⾏表⽰最后要执⾏以下的清除命令del *.obj #删除当前⽬录下的所有.obj⽂件del *.res #删除当前⽬录下的所有.res⽂件⼆、makefile⽂件解读2.1 makefile⽂件的组成我们⼿动编译的过程是：通过rc编译资源⽂件，通过ml编译源⽂件，通过link连接程序。

makefile其实就是⽤于指导make程序完成这⼏件事，makefile就是由obj/res转exe的链接规则、asm转obj的编译规则、rc转res的编译规则和清除中间⽂件的规则等四种规则组成；不过为了⽅便还引⼊了注释和宏定义，这并不难理解。

一个简单的makefile文件的编写

一个简单的makefile文件的编写1.makefile文件的主要结构简介：makefile文件里面主要有三种内容：1.变量声明：变量声明就是一种基本的严格字符替换的操作。

比如在前面声明了：objects=program.o foo.o utils.o那么在后面出现的所有$(objects)或者${objects}都会被自动替换成上面的那个字符序列，而且是严格替换，即不带空格的。

2.映射法则3.命令：映射法则和命令通常都是联合起来组成这样的结构形式：target... : prerequisites..command可以简单地理解为通过prerequisites，也就是先决的依赖文件，采取后面描述的相应的命令（这里的命令都是linux里的shell命令）command之后（一般是）生成了文件target。

命令的前面都要按以下tab建留一段空白来表示它是命令。

有的target后面并没有先决条件，也就是后面的命令是无条件执行的。

这个结构总的作用就是告诉make，target是不是out of date，具体视它的依赖文件而定，target不存在也视为out of date。

然后就是如果过期了，那么更新，就是运行下面的命令来更新。

2.前面那篇文章emacs中我们建立了两个makefile文件，但是是空的，还没有任何内容。

现在我们填上如下内容：（这个是一个最简单的例子，不过是一个不错的入门。

）在/project/hello的主目录下面的makefile文件的内容如下：prefix = /usr/localexec_prefix = $(prefix)bindir = $(exec_prefix)/binexport prefixexport exec_prefixexport bindirall clean install uninstall :cd src && $(MAKE) $@.PHONY: all clean install uninstall在/project/hello/src目录下面的makefile文件内容如下：all: hellohello: main.c$(CC) -o $@ main.cclean:rm helloinstall:install -d $(bindir)install -m 0755 hello $(bindir)uninstall:rm $(bindir)/hello.PHONY: all clean install uninstall我们等下详细说明，先看下运行情况：现在makefile支持这四个命令：make，make install ，make clean和make uninstall。

fortran makefile 编译模块

fortran makefile 编译模块一个Fortran程序通常由多个模块组成。

在编译Fortran程序时，我们需要通过Makefile来指定编译的过程和依赖关系。

以下是一个用于编译Fortran模块的示例Makefile：```makefileFC = gfortranCFLAGS = -cLFLAGS = -o# 模块编译规则%.o: %.f90$(FC) $(CFLAGS) $<# 主程序编译规则main: module1.o module2.o main.o$(FC) $(LFLAGS) main.exe module1.o module2.o main.o# 清理规则clean:rm -f *.o *.mod *.exe```在这个示例中，我们使用了gfortran作为Fortran编译器。

编译器选项`-c`表示只编译代码而不进行链接，`-o`选项用于指定输出文件名。

第一个规则指定了如何编译模块文件（以.f90为扩展名）。

`%.o: %.f90`表示匹配所有以.f90为扩展名的文件，并生成对应的.o 目标文件。

通过`$<`获取依赖文件名。

第二个规则指定了如何编译主程序。

模块文件需要在主程序之前进行编译。

使用目标`main: module1.o module2.o main.o`表示生成一个名为main的可执行文件。

通过`$(LFLAGS)`指定输出文件名，`$(FC)`表示使用Fortran编译器。

最后一个规则用于清理编译生成的文件。

`clean`表示这是一个自定义的清理规则。

通过`rm -f`命令删除.o、.mod和.exe文件。

要编译Fortran程序，可以在命令行中运行`make main`命令。

将执行Makefile中的规则，生成可执行文件main.exe。

要清理编译生成的文件，可以运行`make clean`命令。

注意：以上示例中使用的是GNU Make语法。

Makefile编写指南

第 3 章 Makefile编写指南目录3.1. 相关编写规范和使用原则3.2. 操作手册3.3. 常见问题和注意事项本章主要讲述了我司NGSA的项目代码管理文件Makefile的编写指南。

3.1. 相关编写规范和使用原则陈健生3.1.1. 目录结构目录结构图 3.1. 目录结构3.1.2. 使用规则和命名要求使用规则和命名要求命名规则这里只涉及到在ngsa开发过程中，开发人员和管理者必须编写和修改的部分，由软件和脚本完成的命名则不再这里说明。

•产品名：每个产品唯一的名称，由英文字母、下划线、数字组成。

•Ngsa工程里的任何文件和目录都不得使用”_”开始的名称•配置菜单的变量名o配置菜单项对应的变量必须是以“CONFIG_”开头。

o如果是某个模块的宏定义，则必须是“CONFIG_模块名_变量名”o配置菜单的结果“.config”和“autoconf.h”被存放在project//程序/产品/conf/目录中o配置菜单的autoconf.h被拆分的.h头文件保存在project/程序/产品/conf/config目录中，其中每个模块将对应着同一个.h文件，名字为模块名.h，里面定义了这个模块所有的配置宏的定义.▪app.h 应用层▪arch.h cpu架构相关▪binarytype.h 编译的类型，main、boot、ctrl、factory▪driver.h 驱动相关▪kernel.h os内核相关▪linklayer.h 链路层▪networklayer.h 网络层▪system.h 系统相关▪target.h 产品相关•每个模块的Makefile必须遵守模块的Makefile编写规则•编译完成后，和产品相对的.o .bin .elf都在project/程序/产品下找到•Include/asm 是一个目录链接文件，指向当前编译产品cpu对应的include/asm-xxx,不同asm-xxx下的文件对外必须提供相同的文件名和函数名，否则不能适应多平台的开发。