uatomake实例应用研究大学论文.doc

目录

1 Aotumake概论 1
2 使用Automake前的准备工作 2
3 Automake使用指南 2
3.1 autotools的工作原理 2
3.2 编写Makefile.am 3
3.2.1 Makefile.am规则 3
3.2.2 库的生成 5
3.2.3 可执行文件的生成 6
3.3 编写configure.in文件 6
3.3.1 在configure.in中定义外部变量 6
3.3.2 给configure配置自定义参数 7
4 Automake的应用——使用Automake生成Makefile 8
4.1 Makefile的用处 8
4.2 使用Automake生成Makefile的优势 8
4.3 Automake应用实例 9
4.3.3 执行 aclocal 和 Autoconf 10
4.3.4 编辑 Makefile.am 文件  10
4.3.5 执行 Automake 10
4.3.6 执行 ./configure 10
4.4 使用已定义好的宏生成Makefile 12
4.4.1 编辑 configure.in 文件 14
4.4.2 编辑 Makefile.am 文件 15
5 结束语 17

1 Aotumake概论
在 Unix 上写程式的人大概都碰过 Makefile，尤其是用 C 来开发程式的人。用 make 来开发和编译程式的确很方便，可是要写出一个 Makefile 就不简单了。偏偏介绍 Makefile 的文件不多，GNU Make 那份印出来要几百页的文件，光看完 Overview 就快阵亡了，难怪许多人闻 Unix 色变。本文将介绍如何利用 GNU Autoconf 及 Automake 这两套软件来协助我们『自动』产生 Makefile 档，并且让开发出来的软件可以像 Apache，MySQL 和常见的GNU 软件一样，只要会 ./configure，make，make install 就可以把程式安装到系统中。
如果您有心开发 OpenSource 的软件，或只是想在 Unix 系统下写写程式。希望这份介绍文件能帮助您轻松地进入Unix Programming 的殿堂。
Makefile 基本上就是『目标』(target)，『关连』(dependencies) 和『动作』三者所组成的一连串规则。而 make 就会根据 Makefile 的规则来决定如何编译 (compile) 和连结 (link) 程式。实际上make 可做的不只是编译和连结程式，例如FreeBSD 的port collection 中，Makefile 还可以做到自动下载原始程式套件，解压缩 (extract)，修补(patch)，设定，然后编译，安装至系统中。
Makefile 基本构造虽然简单，但是妥善运用这些规则就也可以变出许多不同的花招。却也因此，许多刚开始学习写 Makefile 时会感到没有规范可循，每个人写出来的 Makefile 长得都不太一样，不知道从何下手，而且常常会受限於自己的开发环境，只要环境变数不同或路径改一下，可能Makefile 就得跟着修改。虽然有 GNU Makefile Conventions (GNUMakefile惯例)订出一些使用 GNU 程式设计时撰写 Makefile 的一些标准和规范，但是内容很长而且很复杂，并且经常做些调整，为了减轻程式设计师维护Makefile的负担，因此有Automake。
程式设计师只需写一些预先定义好的巨集 (macro)，交给 Automake 处理後会产生一个可供Autoconf 使用的 Makefile.in 档。再配合利用Autoconf 产生的自动设定档 configure 即可产生一份符合 GNU Makefile 惯例的 Makeifle 了。
2 使用Automake前的准备工作
在开始试着用Automake之前，请先确认你的系统已经安装以下的软件：
1. GNU Automake
2. GNU Autoconf
3. GNU m4
4. perl
5. GNU Libtool (如果你需要产生 shared library)
我会建议你最好也使用 GNU C/C++ 编译器、GNU Make 以及其它 GNU 的工具程式来做为开发的环境，这些工具都是属于 Open Source Software 不仅免费而且功能强大。如果你是使用 Red Hat Linux 可以找到所有上述软件的 rpm 档，FreeBSD 也有现成的 package 可以直接安装，或着你也可以自行下载这些软件的原始档回来 DIY。以下的范例是在 Red Hat Linux 5.2 + CLE2 的环境下所完成的。
3.Automake使用指南
Automake主要通过编辑Makefile.am来控制它的行为，下面就常用的三个Makefile.am配置做出说明。
3.1 autotools的工作原理
autotools最终是为了生成Makefile，为此，需要使用到autotools系列工具的如下几个命令：
lautoscan
laclocal
lautoheader
lautoconf
lAutomake
另外，还需要有两类输入文件：configure.in和Makefile.am。其中，configure.in是用来生成configure脚本的，configure脚本的作用主要有两个：检测系统的环境，生成Makefile。而Makefile.am则是生成Makefile的参数，它们之间是一一对应的。一般来说，在一个工程中每个目录下都会有一个Makefile来管理当前目录下的文件。所以，基本上每个目录中都需要编写一个Makefile.am，来描述当前目录下生成的Makefile的行为。
有了生成工具和输入文件，下面来看一下生成Makefile的流程，如下图所示：

需要说明的是autoscan工具的使用，autoscan检测当前目录下的所有文件，生成一个configure.scan，这个文件可以作为configure.in文件的雏形，在它的基础上稍做修改就可以作为configure.in文件来使用。所以，autoscan工具只需要在工程创建时运行一次即可。
下面就来具体介绍两个输入文件的编写规则：
3.2 编写Makefile.am
3.2.1 Makefile.am规则
Makefile.am写起来相对简单，有共有5类规则，如下表
表3.2.1 Makefile.am中的规则
文件类型
书写格式
可执行文件
bin_PROGRAMS = foo
foo_SOURCES = xxx.c xxxx.c
foo_LDADD =
foo_LDFLAGS =
foo_DEPENDENCIES =
静态库
lib_LIBRARIES = foo.a
foo_a_SOURCES = xxx.c xxxx.c
foo_a_LDADD =
foo_a_LIBADD =
foo_a_LDFLAGS =
动态库
lib_LTLIBRARIES = foo.la
foo_la_SOURCES = xxx.c xxxx.c
foo_la_LDADD =
foo_la_LIBADD =
foo_la_LDFLAGS =
头文件
include_HEADERS = foo.h
noinst_HEADERS = foo2.h
数据文件
data_DATA = data1 data2

其中，生成动态库的同时还会自动生成一个静态库，所以在一般情况下都不直接使用静态库规则。
Makefile.am中还有一些可以直接使用的全局变量，表示所有目标所共享的一些属性，见下表：
表3.2.2 Makefile.am中的变量
变量
含义
INCLUDES
编译时所需头文件
LDADD
链接时所需链接的库文件
LDFLAGS
链接时的选项
AM_CXXFLAGS
编译.cpp文件时的选项
AM_CFLAGS
编译.c文件时的选项
EXTRA_DIST
除源代码和一些默认的文件以外，其它需要打如发布包.tar.gz中的文件
SUBDIRS
在处理本目录之前要递归处理的子目录
top_srcdir
工程源码的最顶层目录
top_builddir
工程目标文件的最顶层目录
有了以上的规则和变量，我们可以完成最基本的Makefile.am编写，但在某些情况下，我们需要定义一些变量来控制工程中某些目标的生成：比如库的版本号是不断变化的，需要定义一个变量来指代。Makefile.am可以使用宏替换来实现这种功能，可以通过以下方式来引用一个宏：
@宏名@
这个宏的的定义是在configure.in中的，现在Makefile.am中所需要了解的规则和语法已经介绍完了，下面介绍一下如何使用这些规则来具体生成一个库和可执行程序。
3.2.2 库的生成
要生成一个库，需要在Makefile.am中加入一套动态库规则(见表3.2.1)，如现在要用hello1.cpp和hello2.cpp两个源文件生成动态库libhello.so，库的版本为1.0.10，库需要额外连接一个叫做libworld.so的库，我们可以这样写：
lib_LTLIBRARIES = hello.la
hello_la_SOURCES = hello1.cpp hello2.cpp
hello_la_LIBADD = -lworld
hello_la_LDFLAGS = -version-info 1.0.10
可以看到，在LIBADD规则中链接库文件的方法与使用g++编译时的相同。但LDFLAGS规则中的属性就没有见过了。实际上，这个参数是传给libtool生成库时使用的，除了version-info这个参数之外，LDFLAGS编译库时还会经常使用下面两个参数：
l-avoid-version 生成不带版本号的库
l-all-static 生成为静态库
3.2.3 可执行文件的生成
要生成一个可执行文件，需要加入一套可执行文件的规则(见表3.2.1)，与生成动态库的规则很类似。下面我们要使用源文件main.cpp生成可执行文件main，该可执行文件需要链接上面生成的库libhello.so，我们可以这样写：
bin_PROGRAMS = main
main_ SOURCES = main.cpp
main_ LDADD = -lhello
main_LDFLAGS = -I./include
3.3 编写configure.in文件
与Makefile.am相比，configure.in文件写起来更复杂，因为configure.in文件中可以使用的资源要远多与Makefile.am。但通常情况下，我们都可以借助autoscan工具帮助我们生成一个configure.in的模版，在此基础上再完善就可以了。所以，实际上我们只需要在configure.in中修改以下两个参数就可以了：
AC_INIT(package_name， package_version， owner_email)
AC_CONFIG_FILES([makefile1_path
makefile2_path])
AC_INIT()选项中指明了工程的名字，当前工程的版本号，工程所有者的邮箱。
AC_CONFIG_FILES()中指明了所有要生成的Makefile的相对路径，由于每个Makefile都需要一个Makefile.am作参数，所以该选项中Makefile的数量和路径应与当前工程中Makefile.am的状态一致。
在经过上面的修改之后，一个configure.in文件就基本可以使用了，但通常情况下，我们需要对它进行更多的配置。
3.3.1 在configure.in中定义外部变量
在configure.in中定义变量与写shell脚本时定义变量的语法相同，如我们要定义一个值为nihao的变量hello，我们可以这样写：
hello=nihao
但使用这个变量的方法就有些不同了，比如我们要将hello这个变量赋给hi这个变量，我们可以这样写：
hi=”$hello”
如果这个变量需要被外部引用的话(如在3.2.1节中提到的Makefile.am引用configure.in中定义的变量)，需要一个额外的选项来完成，如我们要将hello定义为外部变量，可以写成：
AC_SUBST(hello)
而Makefile.am中也就可以通过对它的引用来完成对某些可变因子的替换，在Makefile.am中的引用方法见32.1节。
3.3.2 给configure配置自定义参数
对于一个已经生成好的configure，执行./configure --help命令可以看到该脚本所支持的所有参数，其中大部分是其自带的。同样，我们可以通过对configure.in的配置来给它添加新的参数。可以配置的参数种类有很多种，常用的有以下2种格式：
--enable-xxx 和 --disable-xxx
--with-xxx 和 --with-out-xxx
可以分别通过以下2个宏来定义这两个参数：
AC_ENABLE (feature， action-if-given， [action-if-not-given])
AC_ARG_WITH (package， help-string， [action-if-given]， [action-if-not-given])
这两种格式基本上可以互换，下面就以AC_ARG_WITH()为例，说明如何给configure加上一个自定义参数。
假设我们要增加一个选项表示是否需要编译一个名为agent的模块，可以这样写：
BUILD_AGENT=no
AC_ARG_WITH([agent]，
[AS_HELP_STRING([--with-agent]，
[build agent(default is no)])]，
[BUILD_AGENT=yes]，
[BUILD_AGENT=no])
if test "x$BUILD_AGENT" = "xyes";then #判断是否加上了该参数
#做出相应动作
fi
这样 ./configure就新添了两个选项--with-agent和--with-out-agent，通过这两个选项可以控制变量BUILD_AGENT的值，然后做出相应的动作。
4 Automake的应用——使用Automake生成Makefile
 4.1 Makefile的用处
Makefile 基本上就是『目标』(target)， 『关联』(dependencies) 和『动作』三者所组成的一系列规则。而 make 就是根据 Makefile 的规则决定如何编译 (compile) 和连接 (link) 程序或者其它动作。当然，Makefile可做的不只是编译和连接程序，例如 FreeBSD 的 port collection 中，Makefile还可以做到自动下载远程程序，解压缩 (extract)，打补丁 (patch)，设定，然后编译，安装到系统中。
4.2 使用Automake生成Makefile的优势
Makefile 基本结构虽然很简单，但是妥善运用这些规则就可以变换出许多不同的花样。却也因为这样，许多人刚开始学写Makefile 时会觉得没有规范可以遵循，每个人写出来的Makefile都不大一样，不知道从哪里下手，而且常常会受到开发环境的限制，只要环境参数不同或者路径更改，可能 Makefile 就得跟着修改。虽然有GNU Makefile Conventions (GNU Makefile惯例)制订出一些在进行 GNU 程序设计时写 Makefile 的一些标准和规范，但是其内容很长而且很复杂，并且经常作一些调整，为了减轻程序开发人员维护Makefile 的负担，就出现了Automake。
利用Automake，编程者只需要写一些预先定义好的宏 (macro)，提交给Automake处理，就会产生一个可以供 Autoconf 使用的 Makefile.in文件。再配合使用 Autoconf产生的自动配置文件 configure 即可产生一份符合 GNU Makefile 惯例的 Makeifle 了。
4.3 Automake应用实例
Automake 所产生的 Makefile 除了可以做到程序的编译和连接，也可以用来生成文档(如 manual page， info 文件等)，还可以有把源码文件包装起来以供发布，所以程序源代码所存放的目录结构最好符合GNU 的标准惯例，接下来就用一个hello.c 來做为例子。
在工作目录下建立一个新的子目录devel，再在 devel 下建立一个"hello"'' 的子目录，这个目录将作为存放 hello这个程序及其相关文件的地方：
% mkdir devel;cd devel;mkdir hello;cd hello
用编辑器写一个hello.c文件，
#include

int main(int argc， char** argv)
{
printf(“Hello， GNU!n”);
return 0;
}
接下来就要用 Autoconf 及 Automake 來产生 Makefile 文件
4.3.1 用 autoscan 产生configure.in 的原型
执行autoscan 后会产生一个configure.scan 的文件，可以用它作为 configure.in文件的蓝本。
　 % autoscan
     % ls
     configure.scan hello.c
4.3.2 编辑 configure.scan文件
dnl Process this file with Autoconf to produce a configure script.
AC_INIT(hello.c)
AM_INIT_Automake(hello， 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)
4.3.3 执行 aclocal 和 Autoconf
分別会产生 aclocal.m4 及 configure 两个文件
% aclocal
% Autoconf
% ls
aclocal.m4 configure configure.in hello.c
4.3.4 编辑 Makefile.am 文件 
Automake_OPTIONS= foreign
bin_PROGRAMS= hello
hello_SOURCES= hello.c
  4.3.5 执行 Automake
add-missing，Automake 会根据Makefile.am 文件产生一些文件，包含最重要的Makefile.in
% Automake --add-missing
Automake: configure.in: installing `./install-sh''
Automake: configure.in: installing `./mkinstalldirs''
Automake: configure.in: installing `./missing''
 4.3.6 执行 ./configure:
% ./configure
creating cache ./config.cache
checking for a BSD compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking whether make sets ${MAKE}... yes
checking for working aclocal... found
checking for working Autoconf... found
checking for working Automake... found
checking for working autoheader... found
checking for working makeinfo... found
checking for gcc... gcc
checking whether the C compiler (gcc ) works... yes
checking whether the C compiler (gcc ) is a cross-compiler... no
checking whether we are using GNU C... yes
checking whether gcc accepts -g... yes
updating cache ./config.cache
creating ./config.status
creating Makefile
$ ls
Makefile aclocal.m4 config.status hello.c mkinstalldirs
Makefile.am config.cache configure install-sh
Makefile.in config.log configure.in missing
在目录下已经产生了一个 Makefile 文件，输入make指令就可以编译 hello.c 了
% make
gcc -DPACKAGE="hello" -DVERSION="1.0" -I. -I. -g -O2 -c hello.c
gcc -g -O2 -o hello hello.o

你还可以试试 “make clean“，”make install“，”make dist“：
[root@localhost hello]# make clean
test z "hello " || rm -f hello
rm -f *.o core *.core
[root@localhost hello]# make install
gcc -DPACKAGE="hello" -DVERSION="1.0" -I. -I. -g -O2 -c hello.c
gcc -g -O2 -o hello hello.o
make[1]: Entering directory `/home/joe/devel/hello''
/bin/sh ./mkinstalldirs /usr/local/bin
/usr/bin/install -c hello /usr/local/bin/hello
make[1]: Nothing to be done for `install-data-am''.
make[1]: Leaving directory `/home/joe/devel/hello''
[root@localhost hello]# make dist
rm -rf hello-1.0
mkdir hello-1.0
chmod 777 hello-1.0
here=cd.&& pwd;
top_distdir=`cd hello-1.0 && pwd`;
distdir=`cd hello-1.0 && pwd`;
cd .
&& Automake --include-deps --build-dir=$here --srcdir-name=. --output-dir=$top_distdir --foreign Makefile
chmod -R a+r hello-1.0
GZIP=--best gtar chozf hello-1.0.tar.gz hello-1.0
rm -rf hello-1.0
一切工作正常运行，在make install时由于需要向系统目录拷贝文件，需要有root权限。
4.4 使用已定义好的宏生成Makefile
上述产生Makefile 的过程和以往自行编写的方式非常不一样，使用Automake 只需用到一些已经定义好的宏就可以了。我们把宏及目标 (target)写在Makefile.am 文件内，Automake 读入 Makefile.am 文件后会把这一串已经定义好的宏展开并产生相对应的Makefile.in 文件，然后再由configure这个 shell script 根据 Makefile.in 产生合适的Makefile。
具体流程如下所示：
代码 --> [autoscan*] --> [configure.scan] --> configure.in
configure.in --. .------> Autoconf* -----> configure
+---+
[aclocal.m4] --+ `---.
[acsite.m4] ---'' |
+--> [autoheader*] -> [config.h.in]
[acconfig.h] ----. | +-----''
[config.h.top] --+
[config.h.bot] --''
Makefile.am --? [Autoconf*] -------> Makefile.in
.-------------> config.cache
configure* ------------+-------> config.log
|
[config.h.in] -. v .-> [config.h] -.
+--> config.status* -+ +--> make*
Makefile.in ---'' `-> Makefile ---''
上图表示在整个过程中要使用的文件及产生出来的文件，有星号 (*)代表可执行文件。在此示例中可由 Autoconf及Automake 工具所产生的额外文件有 configure.scan、aclocal.m4、configure、Makefile.in，需要加入设置的有configure.in 及 Makefile.am。 开发者要书写的文件集中为confiugre.in和Makefile.am，在minigui项目中，我们把一系列的命令集中到一个批处理文件中：autogen.sh:
#!/bin/sh
aclocal
autoheader
Automake --add-missing
Autoconf
只要执行该批处理文件，结合configure.in和Makefile.am，就可以生成需要的Makefile了。
4.4.1编辑 configure.in 文件
Autoconf 是用来产生configure文件的工具。configure是一个 shell script，它可以自动设定一些编译参数使程序能够条件编译以符合各种不同平台的Unix 系统。Autoconf会读取configure.in 文件然后产生''configure'' 这个 shell script。
configure.in 文件内容是一系列GNU m4 的宏，这些宏经Autoconf处理后会变成检查系统特性的shell scripts。 configure.in文件中宏的顺序并没有特别的规定，但是每一个configure.in 文件必须在所有其它宏前加入 AC_INIT 宏，然后在所有其它宏的最后加上 AC_OUTPUT宏。一般可先用 autoscan 扫描原始文件以产生一个 configure.scan 文件，再对 configure.scan 做些修改成 configure.in 文件。在例子中所用到的宏如下：
dnl 
这个宏后面的内容不会被处理，可以视为注释AC_INIT(FILE) 
该宏用来检查源代码所在路径，autoscan 会自动产生，一般无须修改它。
AM_INIT_Automake(PACKAGE，VERSION) 
这个是使用 Automake 所必备的宏，PACKAGE 是所要产生软件的名称，VERSION 是版本编号。
AC_PROG_CC
检查系统可用的C编译器，若源代码是用C写的就需要这个宏。
AC_OUTPUT(FILE) 
设置 configure 所要产生的文件，若是Makefile，configure 便会把它检查出来的结果填充到Makefile.in 文件后产生合适的 Makefile。实际上，在使用Automake时，还需要一些其他的宏，这些额外的宏我们用aclocal来帮助产生。执行 aclocal会产生aclocal.m4 文件，如果没有特别的用途，不需要修改它，用 aclocal 所产生的宏会告诉 Automake如何动作。有了 configure.in 及 aclocal.m4两个文件以后，便可以执行 Autoconf来产生configure 文件了。
4.4.2 编辑Makefile.am 文件
接下来要编辑Makefile.am 文件，Automake 会根据 configure.in 中的宏并在perl的帮助下把Makefile.am 转成 Makefile.in 文件。 Makefile.am 文件定义所要产生的目标：
Automake_OPTIONS 
设置 Automake 的选项。Automake 主要是帮助开发 GNU 软件的人员来维护软件，所以在执行Automake 时，会检查目录下是否存在标准 GNU 软件中应具备的文件，例如 NEWS、AUTHOR、ChangeLog 等文件。设置为foreign 时，Automake 会改用一般软件的标准来检查。
bin_PROGRAMS 
定义要产生的执行文件名。如果要产生多个执行文件，每个文件名用空白符隔开。
hello_SOURCES 
定义 hello这个执行程序所需要的原始文件。如果 hello这个程序是由多个原始文件所产生，
必须把它所用到的所有原始文件都列出来，以空白符隔开。假设 hello 还需要
hello_SOURCES= hello.c main.c hello.h 

如果定义多个执行文件，则对每个执行程序都要定义相对的filename_SOURCES。
编辑好Makefile.am 文件，就可以用 Automake --add-missing来产生 Makefile.in。加上 --add-missing 选项来告诉 Automake顺便加入包装一个软件所必须的文件，如果你不使用该选项，Automake可能会抱怨缺少了什么文件。Automake产生出來的 Makefile.in 文件是完全符合 GNU Makefile 惯例的，只要执行 configure这个shell，script 便可以产生合适的 Makefile 文件了。
使用 Makefile
利用 configure 所产生的 Makefile文件有几个预先设定的目标可供使用，这里只用几个简述如下：
make all 
产生设定的目标，既范例中的可执行文件。只敲入make 也可以，此时会开始编译源代码，然后连接并产生执行文件。
make clean 
清除之前所编译的可执行文件及目标文件(object file， *.o)。
make distclean 
除了清除可执行文件和目标文件以外，也把 configure 所产生的 Makefile 清除掉。通常在发布软件前执行该命令。
make install 
将程序安装到系统中，若源码编译成功，且执行结果正确，便可以把程序安装到系统预先设定的执行文件存放路径中，若用 bin_PROGRAMS 宏的话，程序会被安装到 /usr/local/bin下。
make dist 
将程序和相关的文档包装为一个压缩文档以供发布 (distribution) 。执行完在目录下会产生一个以PACKAGE-VERSION.tar.gz 为名称的文件。PACKAGE 和 VERSION 这两个参数是根据 configure.in 文中AM_INIT_Automake(PACKAGE， VERSION) 的定义。在我们的例子中会产生 hello-1.0.tar.gz 的文件。
make distcheck 
和make dist 类似，但是加入检查包装以后的压缩文件是否正常，这个目标除了把程序和相关文档包装成 tar.gz 文件外，还会自动把这个压缩文件解开，执行configure，并执行 make all，确认编译无错误以后，方显示这个tar.gz 文件已经准备好并可以发布了。当你看到：
hello-1.0.tar.gz is ready for distribution
就可以放心地发布您的软件了，检查过关的套件，基本上可以给任何具备 GNU 开发环境的人去重新编译成功。
要注意的是，利用 Autoconf 及 Automake 所产生出來的软件套件是可以在没有安装 Autoconf 及 Automake 的环境使用的，因为 configure 是一个shell script，它己被设计为可以在一般 Unix 的 sh 这个 shell 下执行。但是如果要修改 configure.in 及 Makefile.am 文件再产生新的 configure 及 Makefile.in 文件时就一定要有 Autoconf 及 Automake 了。
5 结束语
无论是在Linux 还是在Unix 环境中，make 都是一个非常重要的编译命令。不管是自己进行项目开发还是安装应用软件，我们都经常要用到make 或 make install。利用make 工具，我们可以将大型的开发项目分解成为多个更易于管理的模块，对于一个包括几百个源文件的应用程序，使用make 和 makefile 工具就可以轻而易举的理顺各个源文件之间纷繁复杂的相互关系。但是如果通过查阅make 的帮助文档来手工编写Makefile,对任何程序员都是一场挑战。幸而有GNU 提供的Autoconf 及Automake 这两套工具使得编写makefile 不再是一个难题。
本文将介绍如何利用 GNU Autoconf 及 Automake 这两套工具来协助我们自动产生Makefile 文件，并