使用make

来源：互联网发布：金融数据挖掘导论编辑：程序博客网时间：2024/05/26 02:52

第五章:使用make

[]什么是make?

Unix(Linux)是一个天生的开发平台,我为此感到高兴.make是一个强力的工具.它能自动跟踪相互依赖的源代码块并组成一程序,使得很容易建立一可执行程序.Make就是这种有依赖关系的部分和代码之间所作的规格说明.


[]   所有的程序都要使用make?
是的.尽管你只有几个简单的模块,但你需要有一种结构来支持它从简单走向复杂.除非你的程序已经盖棺定论.

[]Makefile由哪些组成?
Makefile由以下几个部分组成:

注释.
^^^^
使用#符号插入.make将忽略#之后的任何内容以及其后的RETURN键.

变量.
^^^^
make允许定义与SHELL变量类似的有名变量.比如,你定义了SOURCES=prog.c,那么该变量的值$(SCOURES)就包含了源文件名.

依赖关系.
^^^^^^^^
左边是目标模块，后接一冒号.再接与该模块有依赖关系的模块.

命令.
^^^^
以TAB键开始(即使用相同数量的空格也不能代替它).


[]Makefile示例
下面介绍一个简单的示例来说明make的用法.假设你的程序有两个源文件main.c和myc.c,一个位於子目录include下的头文件myhead.h,一个库由三个源文件myrout1.c,myrout2.c,myrout3.c产生.
其makefile文件为:
#一个基本的MAKEFILE文件.
#其中包括个人的头文件和个人库.
HEADERS=include/myhead.h
SOURCES=main.c   myc.c
PRODUCT=$(HOME)/bin/tool
LIB=myrout.a
LIBSOURES=myrout1.c   myrout2.c   myrout3.c
CC=cc
CFLAGS=-g
all:$(PRODUCT)
$(PRODUCT):$(SOURCES)
$(CC)$(CFLAGS)   -o   $(PRODUCT)$(SOURCES)
lint:$(PRODUCT)
lint   $(SOURCES)$(LIBSOURCES)
哈哈,挺象SHELL编程的.如果你与我一样使用LINUX下的gcc,那么只要把上面的CC=cc改为CC=gcc即可.怎么样,想来一个更复杂点的吗?

[]一个更为复杂的Makefile
你是否注意到,在上例中,只要启动make,就会重新编译所有源代码.
如果你能看懂以下的makefile,恭喜恭喜,你通关了.
#一个更为复杂的makefile
HEADERS=include/myhead.h
SOURES=main.c   myc.c
OBJECTS=main.c   myc.c
PRODUCT=$(HOME)/bin/tool
LIB=myrout.a
LIBSOURCES=myrout1.c   myrout2.c   myrout3.c
LIBOBJECTS=$(LIB)(myrout1.o)$(LIB)(myrout2.o)$(LIB)(myrout3.o)
INCLUDE=include
CC=cc
CFLAGS=-g   -Xc
LINT=lint
LINTFLAGS=-Xc
all:$(PRODUCT)
$(PRODUCT):$(OBJECTS)$(LIB)
$(CC)(CFLAGS)-o$(PRODUCT)$(OBJECTS)$(LIB)
.c.o:   $(HEADERS)
$(CC)$(CFLAGS)   -c   I$(INCLUDE)$<
$(LIB):$(HEADERS)$(LIBSOURCES)
$(CC)   $(CFLAGS)   -c   $(?:.o=.c)
ar   rv   $(LIB)   $?
rm   $?
.c.c:;
lint:   $(PRODUCT)
$(LINT)$(LINIFLAGS)$(SOURCES)$LIBSOURCES)

2.Makefile的编写
假设我们有下面这样的一个程序,源代码如下:

/*   main.c   */
#include   "mytool1.h"
#include   "mytool2.h"

int   main(int   argc,char   **argv)
{
mytool1_print("hello");
mytool2_print("hello");
}

/*   mytool1.h   */
#ifndef   _MYTOOL_1_H
#define   _MYTOOL_1_H

void   mytool1_print(char   *print_str);

#endif

/*   mytool1.c   */
#include   "mytool1.h"
void   mytool1_print(char   *print_str)
{
printf("This   is   mytool1   print   %s/n",print_str);
}

/*   mytool2.h   */
#ifndef   _MYTOOL_2_H
#define   _MYTOOL_2_H

void   mytool2_print(char   *print_str);

#endif

/*   mytool2.c   */
#include   "mytool2.h"
void   mytool2_print(char   *print_str)
{
printf("This   is   mytool2   print   %s/n",print_str);
}


当然由于这个程序是很短的我们可以这样来编译
gcc   -c   main.c
gcc   -c   mytool1.c
gcc   -c   mytool2.c
gcc   -o   main   main.o   mytool1.o   mytool2.o
这样的话我们也可以产生main程序,而且也不时很麻烦.但是如果我们考虑一下如果有一天我们修改了其中的一个文件(比如说mytool1.c)那么我们难道还要重新输入上面的命令?也许你会说,这个很容易解决啊,我写一个SHELL脚本,让她帮我去完成不就可以了.是的对于这个程序来说,是可以起到作用的.但是当我们把事情想的更复杂一点,如果我们的程序有几百个源程序的时候,难道也要编译器重新一个一个的去编译?
为此,聪明的程序员们想出了一个很好的工具来做这件事情,这就是make.我们只要执行以下make,就可以把上面的问题解决掉.在我们执行make之前,我们要先编写一个非常重要的文件.--Makefile.对于上面的那个程序来说,可能的一个Makefile的文件是:
#   这是上面那个程序的Makefile文件
main:main.o   mytool1.o   mytool2.o
gcc   -o   main   main.o   mytool1.o   mytool2.o
main.o:main.c   mytool1.h   mytool2.h
gcc   -c   main.c
mytool1.o:mytool1.c   mytool1.h
gcc   -c   mytool1.c
mytool2.o:mytool2.c   mytool2.h
gcc   -c   mytool2.c

有了这个Makefile文件,不过我们什么时候修改了源程序当中的什么文件,我们只要执行make命令,我们的编译器都只会去编译和我们修改的文件有关的文件,其它的文件她连理都不想去理的.
下面我们学习Makefile是如何编写的.
在Makefile中也#开始的行都是注释行.Makefile中最重要的是描述文件的依赖关系的说明.一般的格式是:
target:   components
TAB   rule

第一行表示的是依赖关系.第二行是规则.
比如说我们上面的那个Makefile文件的第二行
main:main.o   mytool1.o   mytool2.o
表示我们的目标(target)main的依赖对象(components)是main.o   mytool1.o   mytool2.o   当倚赖的对象在目标修改后修改的话,就要去执行规则一行所指定的命令.就象我们的上面那个Makefile第三行所说的一样要执行   gcc   -o   main   main.o   mytool1.o   mytool2.o   注意规则一行中的TAB表示那里是一个TAB键
Makefile有三个非常有用的变量.分别是$@,$^,$<代表的意义分别是:
$@--目标文件,$^--所有的依赖文件,$<--第一个依赖文件.
如果我们使用上面三个变量,那么我们可以简化我们的Makefile文件为:
#   这是简化后的Makefile
main:main.o   mytool1.o   mytool2.o
gcc   -o   $@   $^
main.o:main.c   mytool1.h   mytool2.h
gcc   -c   $<
mytool1.o:mytool1.c   mytool1.h
gcc   -c   $<
mytool2.o:mytool2.c   mytool2.h
gcc   -c   $<

经过简化后我们的Makefile是简单了一点,不过人们有时候还想简单一点.这里我们学习一个Makefile的缺省规则
.c.o:
gcc   -c   $<

这个规则表示所有的   .o文件都是依赖与相应的.c文件的.例如mytool.o依赖于mytool.c这样Makefile还可以变为:
#   这是再一次简化后的Makefile
main:main.o   mytool1.o   mytool2.o
gcc   -o   $@   $^
.c.o:
gcc   -c   $<

Linux   C编程   --   make命令的使用
小鸟
在开发一个系统时，一般是将一个系统分成几个模块，这样做提高了系统的可维护性，但由于各个模块间不可避免存在关联，所以当一个模块改动后，其他模块也许会有所更新，当然对小系统来说，手工编译连接是没问题，但是如果是一个大系统，存在很多个模块，那么手工编译的方法就不适用了。为此，在Linux系统中，专门提供了一个make命令来自动维护目标文件，与手工编译和连接相比，make命令的优点在于他只更新修改过的文件（在Linux中，一个文件被创建或更新后有一个最后修改时间，make命令就是通过这个最后修改时间来判断此文件是否被修改），而对没修改的文件则置之不理，并且make命令不会漏掉一个需要更新的文件。
文件和文件间或模块或模块间有可能存在倚赖关系，make命令也是依据这种依赖关系来进行维护的，所以我们有必要了解什么是依赖关系；打个最比喻：如果我们想玩游戏，必须有游戏光碟和电脑（这两者间存在依赖关系），而有游戏光碟和电脑的前提条件是必须经济条件允许，另外当你有了游戏光碟后还要根据你的心情来选择是玩哪种游戏；如下图：
------------------------------------
玩游戏
/
/
游戏光碟   电脑
/   /
/   /
心情   经济情况
------------------------------------
make命令当然不会自己知道这些依赖关系，而需要程序员将这些依赖关系写入一个叫makefile的文件中。Makefile文件中包含着一些目标，通常目标就是文件名，对每一个目标，提供了实现这个目标的一组命令以及和这个目标有依赖关系的其他目标或文件名，以下是一个简单的Makefile的简单例子：

------------------------------------
#一个简单的Makefile
prog:prog1.o   prog2.o
gcc   prog1.o   prog2.o   -o   prog
prog1.o:prog1.c   lib.h
gcc   -c   -I.   -o   prog1.o   prog1.c
prog2.o:prog2.c
gcc   -c   prog2.c
------------------------------------
以上Mamefile中定义了三个目标：prog、prog1和prog2，分号后是依赖文件列表，中间用一个分号隔开；
对于第一个目标文件prog来说，他有两个依赖文件：prog1.o和prog2.o，任何一个依赖文件更新，prog也要随之更新，命令gcc   prog1.o   prog2.o   -o   prog是生成prog的命令。make检查目标是否需要更新时采用递归的方法，递归从底层向上对过时目标进行更新，只有当一个目标所依赖的所有目标都为最新时，这个目标才会被更新。以上面的Makefile为例，我们修改了prog2.c，执行make时，由于目标prog依赖prog1.o和 prog2.o，所以要先检查prog1.o和prog2.o是否过时，目标prog1.o依赖prog1.c和lib.h，由于我们并没修改这两个文件，所以他们都没有过期，接下来再检查目标prog2.o，他依赖prog2.c，由于我们修改了prog2.c，所以prog2.c比目标文件 prog2.o要新，即prog2.o过期，而导致了依赖prog2.o的所有目标都过时；这样make会先更新prog2.o再更新prog。
如果某一行过长，已经到了文本编辑器的右边界，可用一个反斜杠（）做换行符，反斜杠所连接的所有行都会被当成一行来处理；另外在Makefile中涉及的文件名允许使用通配符（?或*）。
有时候为了简化命令的书写，可以在Makefile中定义一些宏和使用缩写，下面是几个很使用的缩写：
$@   代表该目标的全名
$*   代表已经删除了后缀的目标名
$<   代表该目标的第一个相关目标名
现在就可以使用缩写对以上Makefile做相应的修改：
------------------------------------
#使用缩写的Makefile
prog:prog1.o   prog2.o
gcc   prog1.o   prog2.o   -o   $@
prog1.o:prog1.c   lib.h
gcc   -c   -I.   -o   $@   $<
prog2.o:prog2.c
gcc   -c   $*.c
------------------------------------
在一个项目中，可能几个目标中使用同一个文件a.c，如果以后这个文件被修改，那么需要修改Makefile中所有的a.c，这样就比较麻烦，可以定义宏来解决这个问题，宏可以使Makefile更加清晰：
------------------------------------
#使用缩写和宏的Makefile
MARCO   =   prog1.o   prog2.o
prog:$(MARCO)
gcc   prog1.o   prog2.o   -o   $@
prog1.o:prog1.c   lib.h
gcc   -c   -I.   -o   $@   $<
prog2.o:prog2.c
gcc   -c   $*.c
------------------------------------
对于很大的项目来说，自己手写Makefile非常麻烦，而标准的GNU软件（如Apache）都是运行一个configure脚本文件来产生 Makefile；GNU软件automake和autoconf就是自动生成configure的工具。开发人员只需要先定义好宏，automake处理后会产生供autoconf使用的Makefine.in，再用autoconf就可以产生configure。要使用automake和 autoconf必须安装：GNU   Automake，GNU   Autoconf，GNU   m4，perl和GNU   Libtool。
假设你有一个源文件test.c，用autoscan可以产生一个configure.scan文件，编辑这个文件：
------------------------------------
dnl   Process   this   file   with   autoconf   to   produce   a   configure   script.
AC_INIT(test.c)
AC_INIT_AUTOMAKE(test,1.0)
dnl   Checks   for   programs.
AC_PROG_CC
dnl   Checks   for   libraries.

dnl   Checks   for   header   files.

dnl   Checks   for   typedefs,   structures,   and   compiler   characteristics.

dnl   Checks   for   library   functions.

AC_OUTPUT(Makefile)
------------------------------------
接着将configure.scan改名为cnfigure.in，再执行aclocal和autoconf，会产生aclocal.m4和 configure两个文件：我们再编辑Makefile.am文件，Makefile.am文件中包含了我们自己定义的宏以及目标文件，automake会读如这个文件并根据我们自己定义的宏产生相应的Makefile.in文件：
------------------------------------
AUTOMAKE_OPTIONS=foreign
run_PROG=test
test_SOURCE=test.c
------------------------------------
接下来执行automake   -a，到目前为止，configure文件已经成功生成