Detaillierte Erläuterung des Prinzips der Verwendung von Autoconf und Automake zum Generieren von Makefiles unter Linux

Als Programmentwickler unter Linux müssen Sie auf Makefile gestoßen sein. Es ist in der Tat sehr praktisch, den Befehl make zum Kompilieren des von Ihnen geschriebenen Programms zu verwenden. Unter normalen Umständen schreibt jeder ein einfaches Makefile von Hand. Es ist nicht so einfach, ein Makefile zu schreiben, das den Konventionen für freie Software entspricht. In diesem Artikel stellen wir vor, wie wir die beiden Tools Autoconf und Automake verwenden, um automatisch ein Makefile zu erstellen Makefile, das den Konventionen für freie Software entspricht, sodass Sie das Programm genau wie gängige GNU-Programme mithilfe von „./configure“, „make“ und „make install“ im Linux-System installieren können. Dies eignet sich besonders für Programmentwickler, die Open-Source-Software erstellen möchten, oder wenn Sie nur selbst ein paar kleine Toy-Programme schreiben, dann wird Ihnen dieser Artikel ebenfalls eine große Hilfe sein.

1. Einführung in Makefile

Makefile wird für die automatische Kompilierung und Verknüpfung verwendet. Änderungen in jeder Datei führen dazu, dass das Projekt neu verknüpft wird Das Makefile zeichnet die Dateiinformationen auf. Beim Erstellen wird entschieden, welche Dateien beim Verknüpfen neu kompiliert werden müssen.

Der Zweck von Makefile besteht darin, dem Compiler mitzuteilen, auf welche anderen Dateien er angewiesen sein muss, um eine Datei zu kompilieren. Wenn sich diese Abhängigkeitsdateien ändern, stellt der Compiler automatisch fest, dass die endgültig generierte Datei veraltet ist, und kompiliert das entsprechende Modul neu.

Die Grundstruktur von Makefile ist nicht sehr kompliziert, aber wenn ein Programmentwickler anfängt, Makefile zu schreiben, zweifelt er oft daran, ob das, was er schreibt, der Konvention entspricht, und das von ihm geschriebene Makefile wird oft mit seiner eigenen Entwicklung in Verbindung gebracht Umgebung Nachdem sich die Systemumgebungsvariablen oder -pfade geändert haben, muss das Makefile möglicherweise entsprechend geändert werden. Dies hat beim manuellen Schreiben von Makefiles viele Probleme verursacht, und Automake kann uns dabei helfen, diese Probleme sehr gut zu lösen.

Mit Automake müssen Programmentwickler nur einige einfache Dateien schreiben, die vordefinierte Makros enthalten. Autoconf generiert die Konfiguration basierend auf einer Makrodatei, Automake generiert Makefile.in basierend auf einer anderen Makrodatei und verwendet dann die Konfiguration basierend auf der Makefile. in, um ein herkömmliches Makefile zu generieren. Im Folgenden stellen wir die Automake-Generierungsmethode von Makefile im Detail vor.

2. Verwendete Umgebung

Das in diesem Artikel erwähnte Programm basiert auf der Linux-Distributionsversion: Fedora Core Release 1, die die Autoconf und Automake enthält, die wir verwenden möchten.

3. Beginnen Sie mit helloworld

Beginnen wir mit helloworld, dem am häufigsten verwendeten Beispielprogramm.

Vereinfacht ausgedrückt ist der folgende Prozess:

Erstellen Sie drei Dateien:

helloworld.c　　configure.in　　Makefile.am

Führen Sie sie dann nacheinander aus:

autoscan; aclocal; autoconf; automake --add-missing; ./configure; make; ./helloworld;

Sie können sehen, dass das Makefile generiert wurde und helloworld.c kompiliert und übergeben werden kann. Es ist ganz einfach, mit nur wenigen Befehlen ein herkömmliches Makefile zu erstellen. Lassen Sie uns nun den detaillierten Prozess vorstellen:

1. Erstellen Sie ein Verzeichnis

Erstellen Sie ein Helloworld-Verzeichnis in Ihrem Arbeitsverzeichnis. Wir verwenden es, um das Helloworld-Programm und zugehörige Dateien zu speichern, z. B. in /home / Unter my/build:

$ mkdir helloword
$ cd helloworld

2. helloworld.c

Verwenden Sie dann Ihren bevorzugten Editor, um eine hellowrold.c-Datei zu schreiben, z. B. den Befehl: vi helloworld.c. Verwenden Sie den folgenden Code als Inhalt von helloworld.c.

int main(int argc, char** argv)
{
    printf("Hello, Linux World! ");
    return 0;
}

Speichern und nach Abschluss beenden. Nun sollte im Verzeichnis helloworld eine von Ihnen geschriebene helloworld.c vorhanden sein.

3. „Configure“ generieren

Wir verwenden den Autoscan-Befehl, um eine „configure.in“-Vorlagendatei basierend auf dem Quellcode im Verzeichnis zu generieren.

Befehl:

$ autoscan
$ ls
configure.scan helloworld.c

Nach der Ausführung wird eine Datei im hellowrold-Verzeichnis generiert: configure.scan, die wir als Blaupause für configure.in verwenden können.

4, configure.in generieren

Benennen Sie nun configure.scan in configure.in um und bearbeiten Sie es wie folgt, entfernen Sie irrelevante Anweisungen:

Code
============================configure.in内容开始=========================================
# -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.
AC_INIT(helloworld.c)
AM_INIT_AUTOMAKE(helloworld, 1.0)
# Checks for programs.
AC_PROG_CC
# Checks for libraries.
# Checks for header files.
# Checks for typedefs, structures, and compiler characteristics.
# Checks for library functions.
AC_OUTPUT(Makefile)
============================configure.in内容结束=========================================

5 Führen Sie aclocal aus und autoconf

Führen Sie dann die Befehle aclocal und autoconf aus, wodurch zwei Dateien aclocal.m4 bzw. configure generiert werden:

$ aclocal
$ls
aclocal.m4 configure.in helloworld.c
$ autoconf
$ ls
aclocal.m4 autom4te.cache configure configure.in helloworld.c

Sie können den Inhalt von configure.in sehen. Es handelt sich um einige Makrodefinitionen Nach der Verarbeitung durch autoconf werden diese Makros zu Shell-Skripten, die die für die Software erforderlichen Systemeigenschaften, Umgebungsvariablen und Parameter überprüfen.

autoconf 是用来生成自动配置软件源代码脚本（configure）的工具。configure脚本能独立于autoconf运行，且在运行的过程中，不需要用户的干预。

要生成configure文件，你必须告诉autoconf如何找到你所用的宏。方式是使用aclocal程序来生成你的aclocal.m4。

aclocal根据configure.in文件的内容，自动生成aclocal.m4文件。aclocal是一个perl 脚本程序，它的定义是：“aclocal - create aclocal.m4 by scanning configure.ac”。

autoconf从configure.in这个列举编译软件时所需要各种参数的模板文件中创建configure。

autoconf需要GNU m4宏处理器来处理aclocal.m4，生成configure脚本。

m4是一个宏处理器。将输入拷贝到输出，同时将宏展开。宏可以是内嵌的，也可以是用户定义的。除了可以展开宏，m4还有一些内建的函数，用来引用文件，执行命令，整数运算，文本操作，循环等。m4既可以作为编译器的前端，也可以单独作为一个宏处理器.

6、新建Makefile.am

新建Makefile.am文件，命令：$ vi Makefile.am

内容如下:

AUTOMAKE_OPTIONS=foreign
bin_PROGRAMS=helloworld
helloworld_SOURCES=helloworld.c

automake会根据你写的Makefile.am来自动生成Makefile.in。Makefile.am中定义的宏和目标,会指导automake生成指定的代码。例如，宏bin_PROGRAMS将导致编译和连接的目标被生成。

7、运行automake

命令：

$ automake --add-missing
configure.in: installing `./install-sh'
configure.in: installing `./mkinstalldirs'
configure.in: installing `./missing'
Makefile.am: installing `./depcomp'

automake会根据Makefile.am文件产生一些文件，包含最重要的Makefile.in。

8、执行configure生成Makefile

$ ./configure
checking for a BSD-compatible install /usr/bin/install -c
checking whether build environment is sane yes
checking for gawk gawk
checking whether make sets $(MAKE) yes
checking for gcc gcc
checking for C compiler default output a.out
checking whether the C compiler works yes
checking whether we are cross compiling no
checking for suffix of executables
checking for suffix of object files o
checking whether we are using the GNU C compiler yes
checking whether gcc accepts -g yes
checking for gcc option to accept ANSI C none needed
checking for style of include used by make GNU
checking dependency style of gcc gcc3
configure: creating ./config.status
config.status: creating Makefile
config.status: executing depfiles commands
$ ls -l Makefile
-rw-rw-r-- 1 yutao yutao 15035 Oct 15 10:40 Makefile

你可以看到，此时Makefile已经产生出来了。

9、使用Makefile编译代码

$ make
if gcc -DPACKAGE_NAME="" -DPACKAGE_TARNAME="" -DPACKAGE_VERSION="" -
DPACKAGE_STRING="" -DPACKAGE_BUGREPORT="" -DPACKAGE="helloworld" -DVERSION="1.0"
-I. -I. -g -O2 -MT helloworld.o -MD -MP -MF ".deps/helloworld.Tpo"
-c -o helloworld.o `test -f 'helloworld.c' || echo './'`helloworld.c;
then mv -f ".deps/helloworld.Tpo" ".deps/helloworld.Po";
else rm -f ".deps/helloworld.Tpo"; exit 1;
fi
gcc -g -O2 -o helloworld helloworld.o

10， 运行helloworld

$ ./helloworld
Hello, Linux World!

这样helloworld就编译出来了，你如果按上面的步骤来做的话，应该也会很容易地编译出正确的helloworld文件。你还可以试着使用一些其他的make命令，如make clean，make install，make dist，看看它们会给你什么样的效果。感觉如何？自己也能写出这么专业的Makefile，老板一定会对你刮目相看。

四、深入浅出

针对上面提到的各个命令，我们再做些详细的介绍。

1、 autoscan

autoscan是用来扫描源代码目录生成configure.scan文件的。autoscan可以用目录名做为参数，但如果你不使用参数的话，那么autoscan将认为使用的是当前目录。autoscan将扫描你所指定目录中的源文件，并创建configure.scan文件。

2、 configure.scan

configure.scan包含了系统配置的基本选项，里面都是一些宏定义。我们需要将它改名为configure.in

3、 aclocal

aclocal是一个perl 脚本程序。aclocal根据configure.in文件的内容，自动生成aclocal.m4文件。aclocal的定义是：“aclocal - create aclocal.m4 by scanning configure.ac”。

4、 autoconf

使用autoconf，根据configure.in和aclocal.m4来产生configure文件。configure是一个脚本，它能设置源程序来适应各种不同的操作系统平台，并且根据不同的系统来产生合适的Makefile，从而可以使你的源代码能在不同的操作系统平台上被编译出来。

configure.in文件的内容是一些宏，这些宏经过autoconf 处理后会变成检查系统特性、环境变量、软件必须的参数的shell脚本。configure.in文件中的宏的顺序并没有规定，但是你必须在所有宏的最前面和最后面分别加上AC_INIT宏和AC_OUTPUT宏。

在configure.ini中：

#号表示注释，这个宏后面的内容将被忽略。

AC_INIT(FILE)　这个宏用来检查源代码所在的路径。

AM_INIT_AUTOMAKE(PACKAGE, VERSION) Dieses Makro ist notwendig. Es beschreibt den Namen und die Versionsnummer des Softwarepakets, das wir generieren werden: PACKAGE ist der Name des Softwarepakets und VERSION ist die Versionsnummer. Wenn Sie den Befehl make dist verwenden, wird ein Softwareverteilungspaket ähnlich wie helloworld-1.0.tar.gz generiert, das den Namen und die Versionsnummer des entsprechenden Softwarepakets enthält.

AC_PROG_CC Dieses Makro überprüft den vom System verwendeten C-Compiler.

AC_OUTPUT(FILE) Dieses Makro ist der Name des Makefiles, das wir ausgeben möchten.

Wenn wir Automake verwenden, müssen wir tatsächlich einige andere Makros verwenden, aber wir können aclocal verwenden, um sie automatisch für uns zu generieren. Nach der Ausführung von aclocal erhalten wir die Datei aclocal.m4.

Nachdem wir die Makrodateien configure.in und aclocal.m4 generiert haben, können wir Autoconf verwenden, um die Konfigurationsdatei zu generieren.

5. Makefile.am

Makefile.am wird zum Generieren von Makefile.in verwendet, was erfordert, dass Sie es manuell schreiben. Makefile.am definiert einige Inhalte:

AUTOMAKE_OPTIONS Dies ist die Automake-Option. Beim Ausführen von Automake wird geprüft, ob sich im Verzeichnis verschiedene Dateien befinden, die im Standard-GNU-Softwarepaket enthalten sein sollten, z. B. AUTHORS, ChangeLog, NEWS und andere Dateien. Wenn wir es auf „fremd“ setzen, verwendet Automake zur Überprüfung den Standard allgemeiner Softwarepakete.

bin_PROGRAMS Dies gibt den Dateinamen der ausführbaren Datei an, die wir generieren möchten. Wenn Sie mehrere ausführbare Dateien generieren möchten, trennen Sie die Namen durch Leerzeichen.

helloworld_SOURCES Dies gibt den Quellcode an, der zum Generieren von „helloworld“ benötigt wird. Wenn mehrere Quelldateien verwendet werden, trennen Sie diese durch Leerzeichen. Wenn Sie beispielsweise helloworld.h und helloworld.c benötigen, schreiben Sie bitte helloworld_SOURCES= helloworld.h helloworld.c.

Wenn Sie mehrere ausführbare Dateien in bin_PROGRAMS definieren, müssen für jede ausführbare Datei entsprechende Dateinamen_SOURCES definiert werden.

6. Automake

Wir verwenden Automake, um Makefile.in basierend auf configure.in und Makefile.am zu generieren.

Die Definition der Option --add-missing lautet „Fehlende Standarddateien zum Paket hinzufügen“, wodurch Automake einige für ein Standardsoftwarepaket erforderliche Dateien hinzufügen kann.

Die Makefile.in-Datei, die wir mit Automake generiert haben, entspricht der GNU-Makefile-Konvention. Als nächstes müssen wir nur das Konfigurations-Shell-Skript ausführen, um eine geeignete Makefile-Datei zu generieren.

7. Makefile

In einem Makefile, das den GNU Makefiel-Konventionen entspricht, enthält es einige grundlegende vordefinierte Operationen:

make Kompilieren Sie den Quellcode, verbinden Sie ihn und generieren Sie ihn gemäß Makefile Objektdatei, ausführbare Datei.

make clean Löscht die Objektdateien (Dateien mit dem Suffix „.o“) und ausführbaren Dateien, die durch den letzten make-Befehl generiert wurden.

make install　Installieren Sie die erfolgreich kompilierte ausführbare Datei im Systemverzeichnis, normalerweise im Verzeichnis /usr/local/bin.

make dist　 Generieren Sie Distributionspaketdateien (d. h. Distributionspaket). Dieser Befehl verpackt die ausführbare Datei und die zugehörigen Dateien in eine komprimierte tar.gz-Datei, die als Softwarepaket für die Veröffentlichung von Software verwendet wird. Es wird eine Datei mit einem Namen ähnlich „PACKAGE-VERSION.tar.gz“ im aktuellen Verzeichnis generiert. PACKAGE und VERSION sind AM_INIT_AUTOMAKE(PACKAGE, VERSION), die wir in configure.in definiert haben.

make distcheck　 Generieren Sie ein Release-Paket und testen Sie es, um die Richtigkeit des Release-Pakets festzustellen. Bei diesem Vorgang wird die komprimierte Paketdatei automatisch entpackt und anschließend der Befehl „configure“ ausgeführt, um zu bestätigen, dass keine Kompilierungsfehler vorliegen. Schließlich werden Sie aufgefordert, dass das Softwarepaket bereit ist und freigegeben werden kann.
make distclean Ähnlich wie make clean, löscht aber auch alle von configure generierten Dateien, einschließlich Makefile.

5. Prozessdarstellung

6

Durch die obige Einführung sollten Sie in der Lage sein, problemlos Ihr eigenes Makefile und die entsprechende Projektdatei zu generieren, die den GNU-Konventionen entsprechen. Wenn Sie ein komplexeres Makefile schreiben möchten, das den Konventionen entspricht, können Sie in einigen Open-Code-Projekten auf die Dateien configure.in und Makefile.am verweisen, z. B.: Embedded Database SQLite, Unit Test Cppunit.