Linux-Mandrake: |
Guide de l'utilisateur |
et Manuel de référence |
MandrakeSoft
Janvier 2000 http://www.linux-mandrake.com
On me demande souvent comment installer un logiciel libre à partir des
sources. Compiler soi-même un logiciel est pourtant très simple, car la
plupart des étapes à passer sont les mêmes, quel que soit le logiciel à
installer.
Le but de ce document est de guider pas à pas le débutant, en essayant
d'éviter l'écueil de l'incantatoire, et en lui expliquant sommairement
la signification de chacune des manipulations. Je suppose cependant que
le lecteur possède un minimum de connaissances Unix (de type
Ce guide n'est qu'un guide, et pas un manuel de référence. C'est
pourquoi un certain nombre de pointeurs sont fournis à la fin, afin de
répondre aux questions demeurées sans réponse. Ce guide est
probablement perfectible, j'attends donc avec impatience toute remarque
ou correction sur son contenu.ls
ou mkdir
).
Ce qui différencie un logiciel libre d'un logiciel propriétaire, c'est l'accès au code source du logiciel[27]. Cela implique que les logiciels libres sont généralement distribués sous forme d'archives de fichiers sources. C'est assez déroutant pour le débutant, car l'utilisateur du logiciel doit compiler lui-même les sources du logiciel avant de pouvoir utiliser le logiciel.
Aujourd'hui, il existe des versions pré-compilées de la plupart des logiciels libres existants. L'utilisateur pressé n'a plus qu'à installer le binaire. Cependant, certains logiciels ne sont pas distribués sous cette forme, ou bien les versions les plus récentes ne sont pas encore distribuées sous cette forme. De plus, si vous utilisez un couple système d'exploitation / architecture exotique, beaucoup de logiciels libres ne seront pas déja précompilés pour vous. Par ailleurs, compiler soi-même ses logiciels permet de ne conserver que les options intéressantes ou d'étendre les fonctionnalités du logiciel en appliquant des extensions afin d'obtenir un logiciel répondant parfaitement à ses besoins.
Pour installer un logiciel libre, vous aurez besoin:
tar
),
Compiler un logiciel libre ne présente généralement pas trop de problèmes, mais si vous n'êtes pas habitué, la moindre anicroche peut vous plonger dans la confusion. Le but de ce document est justement de vous montrer comment vous sortir de ce genre de situation.
Pour passer d'une forme source à une forme binaire, il est nécessaire d'effectuer une compilation. Cette compilation est généralement effectuée sur des programmes écrits en langage C ou C++ (qui sont les plus répandus dans la communauté du logiciel libre, notamment dans le monde Unix). Certains logiciels libres sont écrits dans des langages ne nécessitant pas de compilation (par exemple Perl ou le shell), mais ils ont quand même besoin d'être configurés.
La compilation C est assurée, très logiquement, par un
compilateur qui est généralement GCC, le compilateur libre écrit
par le projet GNU (http://www.gnu.org/
). La compilation d'un
logiciel entier est une tâche complexe, qui passe par la compilation
successive de multiples fichiers sources (il est plus facile pour le
programmeur d'isoler les différentes parties de son travail dans des
fichiers distincts, pour diverses raisons). Afin de faciliter la tâche,
ces opérations répétitives sont effectuées par un utilitaire du nom de
make.
Pour bien comprendre le mécanisme de la compilation (et donc être à même de résoudre des problèmes éventuels), il faut savoir qu'elle s'effectue en quatres phases. Il s'agit d'une conversion progressive (en quatre étapes) d'un texte écrit dans un langage compréhensible par un humain entraîné (le langage C par exemple) vers un langage compréhensible par une machine (ou un humain très entraîné, et encore, dans de rares cas). GCC exécutera l'un après l'autre quatre programmes qui se chargeront chacun d'une étape:
#include
) ou de définir une macro fonction (#define
). À
la fin de cette phase, un code purement C est engendré.
.o
est généré.
.o
) et les bibliothèques
associées, et génère un exécutable.Une distribution de logiciel libre correctement structurée est généralement organisée d'une manière bien précise:
INSTALL
, qui décrit la procédure d'installation
du logiciel,
README
qui contient toutes les informations
générales relatives au programme (courte description, auteur, adresse
où le télécharger, documentation relative, pointeurs utiles, ...). Si
le fichier INSTALL
est absent, le fichier README
contient
généralement une procédure succincte d'installation,
COPYING
qui contient la licence ou décrit les
conditions de distribution du logiciel. Parfois, c'est un fichier
appelé LICENCE
qui le remplace.
CONTRIB
ou CREDITS
qui contient une liste
de personnes ayant un rapport avec le logiciel (participation active,
remarques pertinentes, logiciel tiers, etc.).
CHANGES
(ou, plus rarement, NEWS
), qui
contient les nouveautés de la version actuelle par rapport à la version
précédente et les corrections de bogues,
Makefile
(voir la section 126.0), qui
permet de compiler le logiciel (c'est un fichier nécessaire à
make). Souvent, ce fichier n'existe pas encore et sera généré
lors du processus de configuration,
configure
ou Imakefile
, qui
permettra de générer un nouveau fichier Makefile
,
src
,
doc
,
tar.gz
La norme[28] pour la compression sous Unix est le format gzip, développé par le projet GNU, et considéré comme un des meilleurs outils de compression généralistes.
gzip est souvent associé à un utilitaire nommé tar. tar est un rescapé des temps préhistoriques où les informaticiens stockaient leurs informations sur des bandes magnétiques. Aujourd'hui, les disquettes et les CD-ROM ont remplacé les bandes magnétiques, mais tar est toujours utilisé pour créer des archives. Il est par exemple possible de concaténer (mettre à la suite les uns des autres) tous les fichiers d'un répertoire dans un seul fichier grâce à tar. Ce fichier peut ensuite être facilement compressé à l'aide de gzip.
C'est pourquoi de nombreux logiciels libres sont disponibles sous la
forme d'archives tar
, compressées avec gzip. Leur
extension est donc .tar.gz
(ou encore, sous forme abrégée,
.tgz
).
Pour décompresser cette archive, on peut utiliser gzip, puis tar ensuite. Mais la version GNU de tar (tar) permet d'utiliser gzip « à la volée », et ainsi de décompresser une archive de manière transparente, sans nécessiter l'espace disque supplémentaire.
L'utilisation de tar est incantatoire:
tar <options de fichier> <fichier en .tar.gz> [<fichiers>]
L'option <fichiers>
est facultative. Dans le cas où elle est
omise, le traitement s'effectuera sur toute l'archive. Si vous voulez
extraire le contenu d'une archive .tar.gz
, alors vous n'avez
certainement pas besoin de spécifier cet argument.
Par exemple:
$ tar xvfz guile-1.3.tar.gz
-rw-r--r-- 442/1002 10555 1998-10-20 07:31 guile-1.3/Makefile.in
-rw-rw-rw- 442/1002 6668 1998-10-20 06:59 guile-1.3/README
-rw-rw-rw- 442/1002 2283 1998-02-01 22:05 guile-1.3/AUTHORS
-rw-rw-rw- 442/1002 17989 1997-05-27 00:36 guile-1.3/COPYING
-rw-rw-rw- 442/1002 28545 1998-10-20 07:05 guile-1.3/ChangeLog
-rw-rw-rw- 442/1002 9364 1997-10-25 08:34 guile-1.3/INSTALL
-rw-rw-rw- 442/1002 1223 1998-10-20 06:34 guile-1.3/Makefile.am
-rw-rw-rw- 442/1002 98432 1998-10-20 07:30 guile-1.3/NEWS
-rw-rw-rw- 442/1002 1388 1998-10-20 06:19 guile-1.3/THANKS
-rw-rw-rw- 442/1002 1151 1998-08-16 21:45 guile-1.3/TODO
...
Parmi les options à passer à tar:
v
permet de rendre tar « verbeux ».
C'est-à-dire qu'il affichera à l'écran tous les fichiers qu'il trouve
dans l'archive. Si cette option est omise, alors le traitement sera
silencieux.
f
est une option obligatoire. Sans elle, tar
essaiera d'utiliser une bande magnétique à la place d'un fichier
d'archive (c'est-à-dire le périphérique /dev/rmt0
).
z
permet de manipuler une archive compressée par
gzip (avec suffixe de nom de fichier en .gz
). Si vous
oubliez cette option lors du décompactage d'une archive compressée,
alors tar produira une erreur. Inversement, si vous êtes en
face d'une archive non compressée, n'utilisez pas cette option.
x
: cette option permet d'extraire des fichiers de
l'archive,
t
: cette option liste le contenu de l'archive.
c
: cette option permet de créer une archive, ce qui
implique de détruire son contenu actuel. Vous n'utiliserez
probablement cette option que dans le cas de votre usage personnel
(vos sauvegardes, par exemple),
r
: cette option permet d'ajouter des fichiers à la
fin de l'archive. Elle ne fonctionne pas dans le cas d'une
archive compressée.Un format de compression nommé bzip2 tend en ce moment à
remplacer gzip. bzip2 produit des archives de taille
plus petite que gzip, mais n'est pas encore une norme de fait.
On trouve donc depuis peu des archives à l'extension .tar.bz2
.
bzip2 s'utilise de la même manière que gzip par le biais
de la commande tar. Il suffit de remplacer la lettre z
par
la lettre y
. Par exemple:
$ tar xvfy toto.tar.bz2
Certaines distributions utilisent (ou ont utilisé) à la place l'option
I
:
$ tar xvfI toto.tar.bz2
Une autre possibilité (qui semble être plus portable, mais plus longue à taper!):
$ tar --use-compress-program=bzip2 -xvf toto.tar.bz2
Précisions qu'il est nécessaire que bzip2 soit installé et
inclus dans la variable 'PATH'
avant que vous n'exécutiez
tar.
Maintenant que vous êtes prêt à décompacter l'archive, n'oubliez pas
de le faire en tant qu'administrateur (root
). En effet, vous
allez avoir besoin de faire des manipulations qu'un simple utilisateur
ne peut faire, et même si ce n'est pas le cas de toutes ces
manipulations, il est plus facile d'agir en tant que root
pendant toute la durée de l'opération.
Commencez par vous rendre dans le répertoire /usr/local/src
, et
copiez l'archive dans ce répertoire. Cela vous permet de retrouver à
tout moment l'archive si vous perdez le logiciel installé. Si vous
n'avez pas beaucoup d'espace disque, alors sauvegardez l'archive sur
disquette après avoir installé le logiciel, ou effacez-la, mais
soyez sûr de pouvoir la retrouver sur le réseau à tout moment.
Normalement, le décompactage d'une archive tar devrait créer un
nouveau répertoire (détail dont vous pouvez vous être assuré grâce à
l'option t
). Rendez-vous maintenant dans ce répertoire, vous
êtes prêt à continuer.
Le système Unix (dont font partie GNU/Linux et FreeBSD) est un système sécurisé. Cela signifie que les utilisateurs normaux ne peuvent pas effectuer des opérations qui mettraient le système en danger (comme par exemple formater un disque), ni altérer les fichiers des autres utilisateurs. Dans la pratique et en particulier, cela immunise aussi le système contre les virus.
En revanche, l'utilisateur root
a le droit de tout faire, y
compris d'exécuter un programme malicieux (comme un virus). Disposer du
code source est une garantie de sécurité face aux virus, mais vous avez
tout à fait le droit d'être paranoïaque[29].
L'idée consiste à créer un utilisateur dédié à l'administration
(free
ou admin
par exemple) par le biais de la commande
adduser
. Ce compte devra avoir le droit d'écrire dans le
répertoire /usr/local/src
ainsi que dans les répertoires
/usr/local/bin
, /usr/local/lib
et toute l'arborescence de
/usr/man
(il se peut qu'il ait également besoin de copier des
fichiers ailleurs). Pour cela, je vous recommande soit de rendre cet
utilisateur propriétaire des répertoires nécessaires, soit de créer un
groupe pour lui, et de rendre ces répertoires accessibles en écriture
pour ce groupe.
Une fois que ces précautions sont prises, vous pouvez effectuer les manipulations décrites dans la section 72.0.
Un intérêt purement technique du fait de disposer des sources est le portage du logiciel. Un logiciel libre développé pour un Unix est utilisable sur tous les Unix existants (libres ou propriétaires), avec cependant quelques modifications. Ceci implique une configuration du logiciel juste avant la compilation.
Il existe plusieurs systèmes de configuration, il va falloir utiliser celui que l'auteur du logiciel a prévu (parfois, plusieurs sont au programme). Généralement, vous pouvez:
configure
existe dans le répertoire
parent de la distribution.
Imakefile
existe dans
le répertoire parent de la distribution.
install.sh
) selon ce que dit le fichier INSTALL
(ou le
fichier README
)Autoconf permet de configurer correctement un logiciel. Il crée
les fichiers nécessaires à la compilation (par exemple,
Makefile
), et modifie parfois directement les sources (comme par
le biais d'un fichier config.h.in
).
Le principe d'Autoconf est simple:
configure.in
,
en suivant une syntaxe précise.
configure.in
, un script de configuration appelé
configure
. Ce script est celui qui effectuera les tests
nécessaires à la configuration du programme.
Un exemple d'utilisation d'Autoconf:
$ ./configure
loading cache ./config.cache
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
checking for main in -lX11... yes
checking for main in -lXpm... yes
checking for main in -lguile... yes
checking for main in -lm... yes
checking for main in -lncurses... yes
checking how to run the C preprocessor... gcc -E
checking for X... libraries /usr/X11R6/lib, headers /usr/X11R6/include
checking for ANSI C header files... yes
checking for unistd.h... yes
checking for working const... yes
updating cache ./config.cache
creating ./config.status
creating lib/Makefile
creating src/Makefile
creating Makefile
Si on veut avoir un peu plus de contrôle sur ce qu'engendre la commande
configure
, on peut lui passer des options via la ligne de
commande ou des variables d'environnement. Exemple:
$ ./configure --with-gcc --prefix=/opt/GNU
ou encore (sous Bash):
$ export CC=`which gcc`
$ export CFLAGS=-O2
$ ./configure --with-gcc
ou:
$ CC=gcc CFLAGS=-O2 ./configure
Typiquement, il s'agit d'une erreur de type configure: error:
Cannot find library guile
(« configure: erreur: je
n'arrive pas à trouver la bibliothèque guile
») (cela couvre la
plupart des erreurs du script configure
).
Clairement, le script configure
n'a pas réussi à trouver une
bibliothèque (dans notre exemple, la bibliothèque guile
). Le
principe est que le script configure
compile un petit programme
de test qui utilise cette bibliothèque. S'il n'arrive pas à le
compiler, c'est qu'il n'arrivera pas à compiler le logiciel. D'où une
erreur.
config.log
, qui contient une trace de toutes les
étapes de la configuration. Le compilateur de langage C
est généralement
assez explicite dans ses messages d'erreur. Cela vous aidera pour
résoudre le problème.
configure
.
Une méthode efficace pour vérifier l'installation
est de rechercher le fichier
matérialisant la bibliothèque, qui porte invariablement le nom
lib<nom>.so
. Par exemple,
$ find / -name 'libguile*'
ou encore:
$ locate libguile
/usr/lib
, /lib
, /usr/X11R6/lib
(ou parmi ceux
spécifiés par la variable d'environnement 'LD_LIBRARY_PATH'
,
expliquée page 162.0. Vérifiez que ce fichier est
bien une bibliothèque en tapant file libguile.so
.
/usr/include
, /usr/local/include
, ou
/usr/X11R6/include
. Si vous ne savez pas de quels
fichiers d'en-têtes vous avez besoin, vérifiez que vous avez bien
installé la version de développement de la bibliothèque nécessaire
(par exemple, gtk+-devel
au lieu de libgtk
). La version
de développement de la bibliothèque est livrée avec les fichiers de
type include
(« à inclure »)
nécessaires à la compilation d'un logiciel utilisant cette bibliothèque.
configure
a besoin d'un peu de place pour des fichiers
temporaires). Utilisez la commande df -k
pour visualiser
les partitions de votre système, et ne vous préoccupez que des
partitions pleines ou presque.Si vous ne comprenez pas le message d'erreur stocké dans le fichier
config.log
, n'hésitez pas à demander aide et assistance à la
communauté du logiciel libre (voir la section 198.0).
De plus, méfiez-vous si configure
répond 100% de
No
ou s'il répond No
alors que vous êtes certain
qu'une bibliothèque existe (par exemple il serait très étrange qu'il
n'existe pas sur votre système au moins une bibliothèque
curses
). Dans de tels cas, on est probablement en présence
d'une variable 'LD_LIBRARY_PATH'
mal positionnée!
Imake permet de configurer un logiciel libre en créant un
fichier Makefile
à partir de règles simples. Ces règles
déterminent quels fichiers ont besoin d'être compilés pour construire le
binaire, et Imake engendre le Makefile
correspondant. Ces
règles sont spécifiées dans un fichier appelé Imakefile
.
Là où Imake prend tout son intérêt, c'est qu'il utilise des informations dépendantes du site (de l'architecture de la machine). C'est assez pratique dans le cas d'applications utilisant X Window System. Mais Imake est utilisé dans le cas de nombreuses autres applications.
L'utilisation la plus simple de Imake est de se rendre dans le
répertoire principal de l'archive décompactée, et ensuite d'exécuter
le script xmkmf
, qui fera appel au programme imake
:
$ xmkmf -a
imake -DUseInstalled -I/usr/X11R6/lib/X11/config
make Makefiles
Si le site est mal installé, recompiler et installer X11R6!
Lisez le fichier INSTALL
ou README
pour de plus amples
informations. Généralement, il va vous falloir exécuter un fichier de
type install.sh
ou configure.sh
. Après, soit le script
d'installation sera silencieux (et déterminera tout seul ce dont il a
besoin), soit il vous demandera des informations sur votre système (par
exemple, des chemins).
Si vous n'arrivez pas à déterminer le fichier que vous devez exécuter,
vous pouvez (sous Bash) taper ./
, et ensuite taper deux
fois la touche TAB
(touche de tabulation). Bash complètera
automatiquement par un éventuel fichier exécutable du répertoire (donc,
un éventuel script de configuration). Dans le cas où plusieurs fichiers
sont exécutables, il vous donnera une liste. Il ne vous reste plus qu'à
choisir le bon.
Un cas particulier est l'installation de modules Perl (mais pas seulement). L'installation de tels modules se fait par l'exécution d'un script de configuration lui-même écrit en Perl. La commande à effectuer est généralement:
$ perl Makefile.PL
Certaines distributions de logiciels libres sont mal organisées, surtout
lors des premières phases de développement (mais l'utilisateur est
prévenu!). Elles nécessitent parfois de retoucher « à la main »
les fichiers de configuration. Généralement, ces fichiers sont un
fichier Makefile
(voir la section 126.0) et un fichier
config.h
(mais ce nom n'est qu'une convention).
Je ne recommande ces manipulations qu'à des utilisateurs sachant ce qu'ils font. C'est un travail qui nécessite des connaissances réelles et une motivation nécessaire pour réussir. Mais c'est en forgeant qu'on devient forgeron.
Maintenant que le logiciel est correctement configuré, il ne reste plus qu'à le compiler. C'est une étape qui est généralement très simple à effectuer, et qui ne pose pas de problèmes majeurs.
L'outil préféré de la communauté du logiciel libre pour compiler des
sources est make
. L'intérêt de make
est double:
Les actions à exécuter pour arriver à une version compilée des sources
sont stockées dans un fichier nommé habituellement Makefile
, ou
GNUMakefile
. En fait, lorsque make
est invoqué, il lit
ce fichier, s'il existe, dans le répertoire courant. Si ce n'est pas le
cas, il est possible de spécifier ce fichier en passant l'option
-f
à make
.
make fonctionne selon un système de dépendances.
C'est-à-dire que pour qu'un binaire soit compilé
(« cible »), un certain nombre d'étapes doivent être
accomplies (« dépendances »). Par exemple, pour créer le binaire
(imaginaire) glloq
, on a besoin de compiler les fichiers objets
(fichiers intermédiaires de la compilation) main.o
et
init.o
, puis de les lier. Ces fichiers objets sont eux aussi des
cibles, dont les dépendances sont les fichiers sources.
Ceci n'est qu'une introduction minimale pour survivre dans le monde
impitoyable de make. Si vous voulez en savoir plus, je vous
conseille de vous rendre sur le site d'APRIL à l'adresse
http://www.april.org/groupes/doc/
pour une documentation un peu
plus détaillée sur make. Pour une documentation exhaustive,
voir Managing Projects with Make (« La
gestion de projets avec make », seconde édition, chez O'Reilly,
d'Andrew Oram et Steve
Talbott.
Généralement, l'utilisation de make obéit à plusieurs conventions. Par exemple:
make install
compile le programme (mais pas toujours),
et assure l'installation des fichiers nécessaires au bon endroit sur le
système de fichiers. Certains fichiers ne sont pas toujours installés
correctement (man
, info
), il faut alors les copier à la
main. Dans certains cas, il faut effectuer une nouvelle fois un
make install
dans des sous-répertoires. Généralement, il
s'agit de modules développés par des tiers.
make clean
efface tous les fichiers temporaires créés par
la compilation, y compris le fichier exécutable dans la majorité des
cas.La première étape est de compiler le programme, et donc de taper (exemple fictif):
$ make
gcc -c glloq.c -o glloq.o
gcc -c init.c -o init.o
gcc -c main.c -o main.o
gcc -lgtk -lgdk -lglib -lXext -lX11 -lm glloq.o init.o main.o -o glloq
Parfait, le binaire est compilé correctement. Nous sommes prêts à passer à l'étape suivante, qui est l'installation des fichiers de la distribution (binaires, fichiers de données, etc...). Voir la section 180.0.
Si vous avez la curiosité de regarder ce qu'il y a dans le fichier
Makefile
, vous y trouverez des commandes connues (rm
,
mv
, cp
, ...), mais aussi des chaînes de caractères
étranges, de la forme '$(CFLAGS)'
.
Il s'agit de variables, c'est-à-dire de chaînes qui
sont fixées généralement au début du fichier Makefile
, et qui
seront ensuite remplacées par la valeur qui leur a été associée. C'est
assez utile pour utiliser plusieurs fois de suite les mêmes options de
compilation.
Par exemple, pour afficher la chaîne « toto
» à l'écran
en tapant un make all
:
TEST = toto
all:
echo $(TEST)
La plupart du temps, les variables suivantes sont définies:
'CC'
: il s'agit du compilateur que l'on va utiliser.
Généralement il s'agit de gcc
, mais sur la plupart des
systèmes libres, le compilateur par défaut utilisé par make
(soit cc
) est un synonyme de gcc
. Dans le doute,
n'hésitez pas à mettre ici gcc
.
'LD'
: il s'agit du programme utilisé parfois pour
assurer la phase finale de la compilation (voir la
section 36.0). Par défaut, la valeur est ld
.
'CFLAGS'
: ce sont les arguments supplémentaires qu'on
passera au compilateur lors des premières phases de la compilation.
Parmi ceux-ci:
-I<chemin>
: spécifie au compilateur où chercher
des fichiers d'en-têtes supplémentaires
(ex:
-I/usr/X11R6/include
permet d'inclure les fichiers
d'en-têtes se situant dans /usr/X11R6/include
)
-D<symbole>
: définit un symbole supplémentaire,
utile dans certains programmes qui se compilent différemment selon
les symboles définis (ex: utilise le fichier string.h
si
'HAVE_STRING_H'
est défini)On trouve souvent des lignes de compilation de la forme:
$(CC) $(CFLAGS) -c toto.c -o toto.o
'LDFLAGS'
(ou 'LFLAGS'
): ce sont les arguments passés
lors de la dernière phase de la compilation. Parmi ceux-ci:
-L<chemin>
: spécifie un chemin supplémentaire où
chercher des bibliothèques (ex: -L/usr/X11R6/lib
).
-l<bibliothèque>
: spécifie une bibliothèque
supplémentaire à utiliser lors de la dernière phase de compilation.Pas de panique, cela arrive à tout le monde. Parmi les causes les plus communes:
glloq.c:16: decl.h: No such file or directory
:
(« glloq.c:16
: decl.h
: aucun fichier
ou répertoire ne porte ce nom »)
Le compilateur n'a pas réussi à trouver le fichier d'en-têtes correspondant. Pourtant, l'étape de configuration du logiciel aurait dû anticiper cette erreur. Comment résoudre ce problème:
/usr/include
,
/usr/local/include
,
/usr/X11R6/include
ou un
de leurs sous-répertoires. Si ce n'est pas le cas, recherchez-le sur tout
le disque (avec find
ou locate
),
et si vous ne le trouvez
toujours pas, alors vérifiez à deux fois que vous avez installé la
bibliothèque correspondant à cette en-tête. Vous trouverez des
exemples des commandes find
et locate
dans leurs pages
de manuel respectives.
less <chemin>/<fichier>.h
pour tester cela)
/usr/local/include
ou
/usr/X11R6/include
, il est
parfois nécessaire de passer un argument supplémentaire au
compilateur. Ouvrez le fichier Makefile
correspondant
(prenez garde à ouvrir le bon, celui qui se trouve dans le répertoire
où la compilation échoue[30]) avec votre éditeur de textes favori
(Emacs, VI, ...). Recherchez la ligne fautive, et
ajoutez la chaîne de caractères -I<path>
(où
<chemin>
est le chemin où se trouve l'en-tête en question juste
après l'appel du compilateur (gcc
, ou parfois
$(CC)
). Si vous ne savez pas où rajouter cette
option, rajoutez-la au début du fichier, à la fin de la ligne
CFLAGS=<quelquechose>
ou de la ligne
CC=<quelquechose>
.
glloq.c:28: `struct toto' undeclared (first use
this function)
:
(« glloq.c:28
: « struct toto
»
n'est pas déclarée (ceci est la première utilisation de cette
fonction) »)
Les structures sont des types de données spéciaux, que tous les programmes utilisent. Beaucoup sont définies par le système dans les fichiers d'en-têtes. Ce qui signifie que le problème vient certainement d'une en-tête manquante ou mal utilisée. La marche à suivre pour résoudre le problème est:
grep
afin de vérifier
si la structure est définie dans un des fichiers d'en-têtes.
Par exemple, après vous être rendu dans la racine de la distribution:
$ find . -name '*.h'| xargs grep 'struct toto' | less
Il est possible que plusieurs dizaines de lignes apparaissent
à l'écran (à chaque fois qu'une fonction utilisant ce type de
structure est définie, par exemple). Si elle existe, repérez
la ligne où la structure est définie en regardant le fichier
d'en-têtes obtenu par l'utilisation de grep
.
La définition d'une structure est:
struct toto {
<contenu de la structure>
};
Vérifiez si cela correspond avec ce que vous avez. Le cas
échéant, c'est que ce fichier d'en-têtes n'est pas inclus dans
le fichier .c
fautif. Deux solutions s'offrent à vous:
#include "<nom_du_fichier>.h"
au début du
fichier .c
fautif.
/usr/include
, /usr/X11R6/include
, ou
/usr/local/include
en général). Mais cette fois-ci,
utilisez la ligne
#include <<nom_du_fichier>.h>
.
INSTALL
ou README
quelles sont les bibliothèques utilisées par le programme et
la version nécessaire). Si la version dont
le programme a besoin n'est pas celle installée sur votre
système, alors effectuez une mise à jour de cette
bibliothèque.
configure
, par exemple) pour votre
architecture.parse error
: (« erreur d'analyse
syntaxique »)
C'est un problème assez compliqué à résoudre, car généralement il s'agit d'une erreur que le compilateur rencontre plus haut, mais qui ne se manifeste qu'à une certaine ligne. Parfois, il s'agit simplement d'un type de donnée qui n'est pas défini. Si vous rencontrez un message d'erreur de type:
main.c:1: parse error before `glloq_t
main.c:1: warning: data definition has no type or storage class
alors, le problème est que le type glloq_t
n'est pas défini.
La solution pour résoudre ce problème est environ la même que
pour le problème précédent.
Note: il peut y avoir une erreur de typeparse error
dans les vieilles bibliothèquescurses
si ma mémoire est bonne.
no space left on device
: (« plus de place
disponible sur le périphérique »)
Le problème est assez simple à régler: la place sur le disque
est insuffisante pour générer un binaire à partir du fichier source.
La solution consiste à libérer de la place dans la partition
abritant le répertoire d'installation (supprimez les fichiers
temporaires ou les sources, désinstallez les programmes dont vous
ne vous servez pas). Si vous l'avez décompacté dans
/tmp
, faites-le plutôt dans /usr/local/src
ce
qui évite de saturer inutilement la partition /tmp
.
Vérifiez de plus que vous n'avez pas de fichiers
core
[31]
sur le disque. Si oui, effacez-les ou faites-les effacer s'ils
appartiennent à un autre utilisateur.
/usr/bin/ld: cannot open -lglloq: No such file or
directory
: (« /usr/bin/ld
: je ne peux pas
ouvrir -lglloq
: aucun fichier ou répertoire ne porte ce nom »)
Clairement, le programme ld
(utilisé par gcc
lors de la
dernière phase de la compilation) n'a pas réussi à trouver une
bibliothèque. Il faut savoir que pour inclure une bibliothèque,
ld
va chercher un fichier dont le nom est passé par l'argument
-l<bibliothèque>
. Ce fichier porte le nom de
lib<bibliothèque>.so
. Si ld
n'arrive pas à le
trouver, alors il produit ce message d'erreur. Pour résoudre ce
problème, procédons par étapes:
locate
. Généralement, les
bibliothèques graphiques se trouvent dans
/usr/X11R6/lib
. Par exemple:
$ locate libglloq
Si cela ne produit rien, vous pouvez faire une recherche avec la
commande find
(ex: find /usr -name libglloq.so*
). Si vous ne trouvez
toujours pas la bibliothèque, alors il vous reste plus qu'à l'installer.
ld
: le fichier
/etc/ld.conf
spécifie où trouver ces bibliothèques.
Rajoutez le répertoire incriminé à la fin (il est possible que
vous ayez à réinitialiser la machine pour que cela soit pris en
compte). Il est aussi possible de rajouter ce répertoire en
modifiant le contenu de la variable d'environnement
'LD_LIBRARY_PATH'
. Par exemple, en imaginant que le
répertoire à ajouter est /usr/X11R6/lib
, tapez:
export
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/X11R6/lib
(si votre shell est Bash).
file
). Si c'est un lien symbolique, vérifiez que ce lien est
correct et ne pointe pas vers un fichier inexistant (par
exemple, en tapant nm libglloq.so
). Les permissions peuvent
de plus être incorrectes (si vous utilisez un compte autre que
root
et que la bibliothèque est protégée en lecture par
exemple).glloq.c(.text+0x34): undefined reference to
`glloq_init'
:
(« glloq.c(.text+0x34)
: référence inconnue au
symbole « glloq_init
» »)
Aïe! Aïe! Aïe! Pourquoi cette noirceur? Il s'agit d'un symbole non résolu lors de la dernière phase de la compilation. Généralement, il s'agit d'un problème de bibliothèque. A priori, plusieurs causes possibles:
gtk
, il appartient
très certainement à la bibliothèque gtk
. Si le nom de la
bibliothèque est difficilement identifiable
(comme par exemple
zorglub_gloubiboulga
), il est possible de lister les
symboles d'une bibliothèque avec la commande nm
. Par
exemple,
$ nm libglloq.so
0000000000109df0 d glloq_message_func
000000000010a984 b glloq_msg
0000000000008a58 t glloq_nearest_pow
0000000000109dd8 d glloq_free_list
0000000000109cf8 d glloq_mem_chunk
Rajouter l'option -o
à nm
permet de plus d'afficher le
nom de la bibliothèque sur chaque ligne, ce qui simplifie les
recherches. Imaginons que nous cherchions le symbole
bulgroz_max
, une solution de barbare est d'effectuer une
recherche de ce genre:
$ nm /usr/lib/lib*.so | grep bulgroz_max
$ nm /usr/X11R6/lib/lib*.so | grep bulgroz_max
$ nm /usr/local/lib/lib*.so | grep bulgroz_max
/usr/local/lib/libzorglub.so:000000000004d848 T bulgroz_max
Formidable! Le symbole bulgroz_max
est défini dans
la bibliothèque zorglub
(la lettre majuscule T
se
trouve devant son nom). Il suffit de rajouter la chaîne
-lzorglub
dans la ligne de compilation en éditant le
fichier Makefile
: rajoutez-la à la fin de la ligne où
'LDFLAGS'
ou 'LFGLAGS'
(ou au pire
'CC'
) sont définis, ou alors sur la ligne responsable de la
création du fichier binaire final.
README
ou INSTALL
de la distribution pour
savoir quelle version de la bibliothèque doit être utilisée.
nm -o *.o
pour connaître son nom et
ajoutez le fichier .o
correspondant sur la ligne de
compilation s'il est manquant.
Segmentation fault (core dumped)
:
(« erreur de segmentation, fichier core
produit »)
Parfois, le compilateur échoue lamentablement, et produit ce message d'erreur. Je n'ai pas d'autre conseil que de vous demander d'installer une version plus récente de votre compilateur.
/tmp
La compilation, a besoin d'espace temporaire de travail lors de
ses différentes étapes; si elle ne l'a pas, elle échoue. Il
faut donc faire du ménage, mais attention car la suppression de
certains fichiers
risque de faire échouer des programmes en cours d'exécution
(serveur X, tubes...). Il faut donc
bien savoir ce que l'on fait! Si /tmp
fait partie d'une
partition qui ne contient pas que lui (par exemple, la racine),
recherchez et supprimez d'éventuels fichiers core
.
make
/configure
en boucle
Il s'agit généralement d'un problème d'heure sur votre système. make a en effet besoin de connaître la date et l'heure, ainsi que celles des fichiers qu'il vérifie. Il compare les dates des fichiers et utilise le résultat pour savoir si la cible est plus récente que la dépendance.
Il se peut que des problèmes de date amènent make à se
reconstruire sans fin (ou de construire et reconstruire un
arborescence en boucle). Dans ce cas-là, l'utilisation de la
commande touch
(qui a pour conséquence de mettre à l'heure
courante les fichiers passés en argument) permet de résoudre le
problème dans la plupart des cas.
Par exemple:
$ touch *
Ou encore plus barbare (mais efficace):
$ find . | xargs touch
Maintenant que tout est compilé, il vous reste a copier les fichiers
produits dans un endroit adéquat (généralement, dans un des
sous-répertoires de /usr/local
).
make permet généralement d'assurer ce travail. Une cible
spéciale est la cible install
. Très logiquement, utiliser
make install
permet d'installer les fichiers nécessaires.
Généralement, la procédure est décrite dans les fichiers INSTALL
ou README
. Mais parfois, l'auteur a oublié d'en prévoir une.
Dans ce cas, il va falloir tout installer à la main.
Copiez alors:
/usr/local/bin
lib*.so
) dans le répertoire
portant le nom
/usr/local/lib
*.h
) dans le répertoire
portant le nom
/usr/local/include
(attention à ne pas écraser les fichiers
originaux)
/usr/local/share
. Si vous ne connaissez pas la procédure
d'installation, vous pouvez essayer de démarrer le programme sans
copier les fichiers de données, et les mettre au bon endroit
lorsqu'il vous les demande (dans un message d'erreur du type
Cannot open /usr/local/share/glloq/data.db
).
man
se placent dans un des
sous-répertoires de /usr/local/man
. Généralement, ces
fichiers sont au format troff (ou groff), et ont
pour extension un chiffre. Leur nom est celui d'une commande (par
exemple, echo.1
). Si le chiffre est n
,
copiez ce fichier dans le sous-répertoire /usr/local/man/man<n>
.
info
se placent dans le répertoire
/usr/info
ou /usr/local/info
Et voilà, c'est fini! Félicitations! Vous êtes maintenant fin prêt à recompiler votre système d'exploitation tout entier.
Si vous venez d'installer un programme libre, par exemple GNU tar
et si, quand vous l'exécutez, ce n'est pas lui qui est appelé, ou s'il ne
fonctionne pas comme quand vous le testiez directement à partir du
répertoire src
, c'est un problème de PATH
, qui trouve le
programme dans un répertoire situé avant celui où vous avez installé le
nouveau logiciel. Vérifiez en exécutant type -a <programme>
.
La solution est de mettre le répertoire d'installation plus haut dans
le 'PATH'
, et/ou de supprimer/renommer les fichiers qui s'exécutent
sans qu'on le désire, et/ou de renommer votre nouveau programme (en
gtar
dans cet exemple), de sorte qu'il n'y ait pas confusion.
Vous pouvez aussi mettre en place un alias, si le shell le
permet (par exemple dire que tar
, c'est
/usr/local/bin/gtar
).
Plusieurs sources de documentation:
/usr/doc/HOWTO
(pas toujours, parfois ils sont mis ailleurs, c'est la commande
locate HOWTO
qui vous donnera la réponse en cas de doute),
ou alors, pour une version française des HOWTO,
sur l'URL http://www.freenix.fr/
.
man <commande>
pour obtenir de la documentation sur la commande <commande>
,
Si vous avez acheté une distribution « officielle » de
Linux-Mandrake, vous pouvez demander à l'assistance technique des
informations sur votre système. J'imagine que le support technique a
autre chose à faire que d'aider tous les utilisateurs à installer des
logiciels supplémentaires, mais certains proposent une aide à
l'installation de 'x'
jours. Peut-être peuvent-ils passer
quelque temps sur des problèmes de compilation?
Vous pouvez sinon compter sur l'aide de la communauté du logiciel libre:
fr.comp.os.linux.*
permettent de répondre à toutes les questions
concernant GNU/Linux. Le forum intitulé fr.comp.os.bsd
a pour sujet les systèmes BSD. Il doit exister d'autres forums
dédiés à d'autres Unix. N'oubliez pas de les lire pendant un
moment avant de commencer à y écrire.
#linux
sur la plupart des
réseaux d'IRC, ou #linuxhelp
sur IRCNET.
Pour trouver des logiciels libres, de nombreux pointeurs peuvent vous être utiles:
sunsite.unc.edu
ou l'un de ses miroirs
http://www.freshmeat.net/
est sans doute le site
le plus complet,
http://www.linux-france.org
contient de
nombreux pointeurs vers des logiciels fonctionnant sous
GNU/Linux.
La plupart fonctionnent bien sûr sur les autres plates-formes
Unix libres,
http://www.gnu.org/software/
pour une liste
exhaustive de tous les logiciels GNU. Bien sûr, tous sont
libres et la plupart ont pour licence la GPL.http://www.altavista.com/
et effectuer une requête
de type: +<logiciel> +download
ou "download
<logiciel>"
.Copyright (c) 1999 Benjamin Drieu,
association APRIL (dont le site web est
http://www.april.org/
[32]).
This document is free documentation; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. (« Ce document est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous). »).
This work is distributed in the hope that it will be useful, but without any warranty; without even the implied warranty of merchantability or fitness for a particular purpose. See the GNU General Public License for more details (« Ce programme est distribué car potentiellement utile, mais sans aucune garantie, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails. »).
You will find the GNU General Public License at address
http://www.gnu.org/copyleft/gpl.html
; you can also get a copy of
it by writing to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA. (« Vous trouverez la Licence
Publique Générale GNU dans votre distribution ou sur le Web à
l'adresse http://www.gnu.org/copyleft/gpl.html
; vous
pouvez aussi l'obtenir en écrivant à la Free Software Foundation, Inc.,
59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis. »).