022.html from Gulus at Krugle

Show 022.html syntax highlighted

<HTML><HEAD><TITLE>Linux-Mandrake: Guide de l'utilisateur et Manuel de référence</TITLE>
<LINK REV=MADE HREF="mailto:info@mandrakesoft.com"></HEAD>
<BODY BGCOLOR="#ffffff"><center><font size="+5"><STRONG><table border="0"><tr><td><STRONG>Linux-Mandrake</STRONG>:</td></tr><tr><td>Guide de l'utilisateur</td></tr><tr><td>et Manuel de référence</td></tr></table></STRONG></font>

<p><font size="+2"><STRONG><table border="0"><tr><td><STRONG>MandrakeSoft</STRONG></td></tr></table></STRONG></font>

<p><STRONG><table border="0"><tr><td>&nbsp;</td></tr><tr><td>&nbsp;</td></tr><tr><td>Janvier 2000</td></tr><tr><td><CODE>http://www.linux-mandrake.com</CODE></td></tr><tr><td></td></tr></table></STRONG></center>
<hr><a href="023.html">Suivant&nbsp;: Les utilitaires en ligne de commande</a><br><a href="021.html">Précédent&nbsp;: Compilation et
installation de nouveaux noyaux</a><br><a href="../">Retour</a><br><hr><a href="000.html#toc"><font size="-1">(Retour à la table des matières)</font></a>


<H1><font size="+1"><a name="239">Chapitre 1&nbsp;: Installation d'un logiciel libre</a></font></H1><hr><p><font size="-2"><blockquote><p>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.

<p>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 <STRONG>Unix</STRONG> (de type
<CODE>ls</CODE> ou <CODE>mkdir</CODE>).

<p>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.</blockquote></font>


<H1><a name="240">Introduction</a></H1>

<p>Ce qui différencie un logiciel libre d'un logiciel propriétaire, c'est
l'accès au code source du logiciel<a name="bodynote27" href="026.html#note27">[27]</a>.  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.

<p>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.


<H2><a name="241">Pré-requis</a></H2>

<p>Pour installer un logiciel libre, vous aurez besoin:


<ul><li>d'un ordinateur allumé pourvu d'un système d'exploitation,
<li>d'un peu d'espace disque,
<li>d'un compilateur (généralement pour le langage <EM>C</EM>), d'un
programme d'archivage (<CODE>tar</CODE>),
<li>d'une connaissance généraliste du système d'exploitation que
vous utilisez,
<li>de quoi manger (dans les mauvais cas, cela peut durer longtemps).
Un vrai <EM>hacker</EM> mange des pizzas, pas des quiches.
<li>de quoi boire (pour les mêmes raisons).  Un vrai
informaticien boit du soda au cola (pour la caféine).
<li>du numéro de téléphone de votre copain bidouilleur qui
recompile son noyau toutes les semaines,
<li>mais surtout de patience (beaucoup).</ul>

<p>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.


<H2><a name="242">Compilation</a></H2>


<H3><a name="243">Principe</a></H3>

<p>Pour passer d'une forme source à une forme binaire, il est nécessaire
d'effectuer une <STRONG>compilation</STRONG>.  Cette compilation est généralement
effectuée sur des programmes écrits en langage <EM>C</EM> ou <EM>C++</EM>
(qui sont les plus répandus dans la communauté du logiciel libre,
notamment dans le monde <STRONG>Unix</STRONG>).  Certains logiciels libres sont
écrits dans des langages ne nécessitant pas de compilation (par exemple
<STRONG>Perl</STRONG> ou le <EM>shell</EM>), mais ils ont quand même besoin
d'être configurés.

<p>La compilation <EM>C</EM> est assurée, très logiquement, par un
compilateur qui est généralement <STRONG>GCC</STRONG>, le compilateur libre écrit
par le projet <EM>GNU</EM> (<CODE>http://www.gnu.org/</CODE>).  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
<STRONG>make</STRONG>.


<H3><a name="244">Les quatre phases de la compilation</a></H3>

<p>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 <EM>C</EM> par exemple) vers un langage
compréhensible par une machine (ou un humain <EM>très</EM> entraîné, et
encore, dans de rares cas).  <STRONG>GCC</STRONG> exécutera l'un après l'autre
quatre programmes qui se chargeront chacun d'une étape:


<ul><li><STRONG><STRONG>cpp</STRONG></STRONG>:  la première étape consiste à remplacer des
directives (<STRONG>préprocesseurs</STRONG>) par des instructions <EM>C</EM>.
Typiquement, il s'agit d'insérer un fichier d'en-têtes
(<CODE>#include</CODE>) ou de définir une macro fonction (<CODE>#define</CODE>).  À
la fin de cette phase, un code purement <EM>C</EM> est engendré.
<li><STRONG><STRONG>cc1</STRONG></STRONG>:  cette étape consiste à convertir du <EM>C</EM> en
<STRONG>langage d'assemblage</STRONG>.  Le code généré est dépendant de
l'architecture cible.
<li><STRONG><STRONG>as</STRONG></STRONG>:  cette étape consiste à générer du code <STRONG>objet</STRONG>
(ou <STRONG>binaire</STRONG>) à partir du langage d'assemblage. À la fin de
cette phase, un fichier se terminant par <CODE>.o</CODE> est généré.
<li><STRONG><STRONG>ld</STRONG></STRONG>:  cette dernière étape (l'<STRONG>édition de liens</STRONG>, en
anglais <STRONG>"linkage"</STRONG>) assemble
(ou <STRONG>lie</STRONG>) tous les fichiers objets (<CODE>.o</CODE>) et les bibliothèques
associées, et génère un exécutable.</ul>


<H2><a name="245">Structure d'une distribution</a></H2>

<p>Une distribution de logiciel libre correctement structurée est
généralement organisée d'une manière bien précise:


<ul><li>un fichier <CODE>INSTALL</CODE>, qui décrit la procédure d'installation
du logiciel,
<li>un fichier <CODE>README</CODE> 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 <CODE>INSTALL</CODE> est absent, le fichier <CODE>README</CODE> contient
généralement une procédure succincte d'installation,
<li>un fichier <CODE>COPYING</CODE> qui contient la licence ou décrit les
conditions de distribution du logiciel.  Parfois, c'est un fichier
appelé <CODE>LICENCE</CODE> qui le remplace.
<li>un fichier <CODE>CONTRIB</CODE> ou <CODE>CREDITS</CODE> qui contient une liste
de personnes ayant un rapport avec le logiciel (participation active,
remarques pertinentes, logiciel tiers, etc.).
<li>un fichier <CODE>CHANGES</CODE> (ou, plus rarement, <CODE>NEWS</CODE>), qui
contient les nouveautés de la version actuelle par rapport à la version
précédente et les corrections de bogues,
<li>un fichier <CODE>Makefile</CODE> (voir la section&nbsp;126.0), qui
permet de compiler le logiciel (c'est un fichier nécessaire à
<STRONG>make</STRONG>).  Souvent, ce fichier n'existe pas encore et sera généré
lors du processus de configuration,
<li>assez souvent, un fichier <CODE>configure</CODE> ou <CODE>Imakefile</CODE>, qui
permettra de générer un nouveau fichier <CODE>Makefile</CODE>,
<li>un répertoire contenant les sources, qui sera généralement
celui où le binaire sera stocké une fois la compilation terminée.  Son
nom est généralement <CODE>src</CODE>,
<li>un répertoire contenant la documentation relative au programme
(généralement au format <STRONG>man</STRONG> ou <EM>Texinfo</EM>), dont le nom est
généralement <CODE>doc</CODE>,
<li>éventuellement, un répertoire contenant des données propres au
logiciel (typiquement, des fichiers de configuration, des exemples de
données produites, ou des fichiers de ressources).</ul>


<H1><a name="246">Décompactage</a></H1>


<H2><a name="247">Archive <CODE>tar.gz</CODE></a></H2>

<p>La norme<a name="bodynote28" href="026.html#note28">[28]</a> pour la compression sous
<STRONG>Unix</STRONG> est le format <STRONG>gzip</STRONG>, développé par le projet <EM>GNU</EM>,
et considéré comme un des meilleurs outils de compression généralistes.

<p><STRONG>gzip</STRONG> est souvent associé à un utilitaire nommé <STRONG>tar</STRONG>.
<STRONG>tar</STRONG> est un rescapé des temps préhistoriques où les
informaticiens stockaient leurs informations sur des bandes magnétiques.
Aujourd'hui, les disquettes et les <EM>CD-ROM</EM> ont remplacé les bandes
magnétiques, mais <STRONG>tar</STRONG> 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 à <STRONG>tar</STRONG>.  Ce fichier peut ensuite être facilement
compressé à l'aide de <STRONG>gzip</STRONG>.

<p>C'est pourquoi de nombreux logiciels libres sont disponibles sous la
forme d'archives <CODE>tar</CODE>, compressées avec <STRONG>gzip</STRONG>.  Leur
extension est donc <CODE>.tar.gz</CODE> (ou encore, sous forme abrégée,
<CODE>.tgz</CODE>).


<H2><a name="248">Utilisation de <STRONG>GNU Tar</STRONG></a></H2>

<p>Pour décompresser cette archive, on peut utiliser <STRONG>gzip</STRONG>, puis
<STRONG>tar</STRONG> ensuite.  Mais la version <EM>GNU</EM> de <STRONG>tar</STRONG>
(<STRONG>tar</STRONG>) permet d'utiliser <STRONG>gzip «&nbsp;à la
volée&nbsp;»</STRONG>, et ainsi de décompresser une archive de manière transparente,
sans nécessiter l'espace disque supplémentaire.

<p>L'utilisation de <STRONG>tar</STRONG> est incantatoire:

<p><font size="-2"><PRE>
tar &lt;options de fichier&gt; &lt;fichier en .tar.gz&gt; [&lt;fichiers&gt;]
</PRE></font>

<p>L'option <CODE>&lt;fichiers&gt;</CODE> 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 <CODE>.tar.gz</CODE>, alors vous n'avez
certainement pas besoin de spécifier cet argument.

<p>Par exemple:

<p><font size="-4"><PRE>
$ 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
...
</PRE></font>

<p>Parmi les options à passer à <STRONG>tar</STRONG>:


<ul><li><CODE>v</CODE> permet de rendre <STRONG>tar</STRONG> «&nbsp;verbeux&nbsp;».
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.
<li><CODE>f</CODE> est une option obligatoire.  Sans elle, <STRONG>tar</STRONG>
essaiera d'utiliser une bande magnétique à la place d'un fichier
d'archive (c'est-à-dire le périphérique <CODE>/dev/rmt0</CODE>).
<li><CODE>z</CODE> permet de manipuler une archive compressée par
<STRONG>gzip</STRONG> (avec suffixe de nom de fichier en <CODE>.gz</CODE>).  Si vous
oubliez cette option lors du décompactage d'une archive compressée,
alors <STRONG>tar</STRONG> produira une erreur.  Inversement, si vous êtes en
face d'une archive non compressée, n'utilisez pas cette option.
<li><STRONG>tar</STRONG> permet d'effectuer plusieurs manipulations différentes
sur une archive (extraction, lecture, création, ajout...).  Une option
permet de spécifier l'usage qui en est fait:


<ul><li><CODE>x</CODE>: cette option permet d'extraire des fichiers de
l'archive,
<li><CODE>t</CODE>: cette option liste le contenu de l'archive.
<li><CODE>c</CODE>: 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),
<li><CODE>r</CODE>: cette option permet d'ajouter des fichiers à la
fin de l'archive.  Elle ne fonctionne pas dans le cas d'une
archive compressée.</ul></ul>


<H2><a name="249"><STRONG>bzip2</STRONG></a></H2>

<p>Un format de compression nommé <STRONG>bzip2</STRONG> tend en ce moment à
remplacer <STRONG>gzip</STRONG>.  <STRONG>bzip2</STRONG> produit des archives de taille
plus petite que <STRONG>gzip</STRONG>, mais n'est pas encore une norme de fait.
On trouve donc depuis peu des archives à l'extension <CODE>.tar.bz2</CODE>.

<p><STRONG>bzip2</STRONG> s'utilise de la même manière que <STRONG>gzip</STRONG> par le biais
de la commande <STRONG>tar</STRONG>.  Il suffit de remplacer la lettre <CODE>z</CODE> par
la lettre <CODE>y</CODE>.  Par exemple:

<p><font size="+2"><PRE>
$ tar xvfy toto.tar.bz2
</PRE></font>

<p>Certaines distributions utilisent (ou ont utilisé) à la place l'option
<CODE>I</CODE>:

<p><font size="+2"><PRE>
$ tar xvfI toto.tar.bz2
</PRE></font>

<p>Une autre possibilité (qui semble être plus portable, mais plus longue à
taper!):

<p><font size="-1"><PRE>
$ tar --use-compress-program=bzip2 -xvf toto.tar.bz2
</PRE></font>

<p>Précisions qu'il est nécessaire que <STRONG>bzip2</STRONG> soit installé et
inclus dans la variable <CODE>'PATH'</CODE> avant que vous n'exécutiez
<STRONG>tar</STRONG>.


<H2><a name="250">C'est tout simple!</a></H2>


<H3><a name="251">Le plus simple</a></H3>

<p>Maintenant que vous êtes prêt à décompacter l'archive, n'oubliez pas
de le faire en tant qu'administrateur (<CODE>root</CODE>).  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 <CODE>root</CODE>
pendant toute la durée de l'opération.

<p>Commencez par vous rendre dans le répertoire <CODE>/usr/local/src</CODE>, 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.

<p>Normalement, le décompactage d'une archive <STRONG>tar</STRONG> devrait créer un
nouveau répertoire (détail dont vous pouvez vous être assuré grâce à
l'option <CODE>t</CODE>).  Rendez-vous maintenant dans ce répertoire, vous
êtes prêt à continuer.


<H3><a name="252">Le plus sûr</a></H3>

<p>Le système <STRONG>Unix</STRONG> (dont font partie <STRONG>GNU/Linux</STRONG> et
<STRONG>FreeBSD</STRONG>) 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.

<p>En revanche, l'utilisateur <CODE>root</CODE> 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<a name="bodynote29" href="026.html#note29">[29]</a>.

<p>L'idée consiste à créer un utilisateur dédié à l'administration
(<CODE>free</CODE> ou <CODE>admin</CODE> par exemple) par le biais de la commande
<CODE>adduser</CODE>.  Ce compte devra avoir le droit d'écrire dans le
répertoire <CODE>/usr/local/src</CODE> ainsi que dans les répertoires
<CODE>/usr/local/bin</CODE>, <CODE>/usr/local/lib</CODE> et toute l'arborescence de
<CODE>/usr/man</CODE> (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.

<p>Une fois que ces précautions sont prises, vous pouvez effectuer les
manipulations décrites dans la section&nbsp;72.0.


<H1><a name="253">Configuration</a></H1>

<p>Un intérêt purement technique du fait de disposer des sources est le
<STRONG>portage</STRONG> du logiciel.  Un logiciel libre développé pour un
<STRONG>Unix</STRONG>  est utilisable sur tous les <STRONG>Unix</STRONG>
existants (libres ou propriétaires), avec cependant quelques
modifications.  Ceci implique une configuration du logiciel juste avant
la compilation.

<p>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:


<ul><li>utiliser <STRONG>Autoconf</STRONG> (voir la section&nbsp;90.0) au
cas où un fichier nommé <CODE>configure</CODE> existe dans le répertoire
parent de la distribution.
<li>utiliser <STRONG>Imake</STRONG> (voir la section&nbsp;108.0)
dans le cas où un fichier nommé <CODE>Imakefile</CODE> existe dans
le répertoire parent de la distribution.
<li>exécuter un <STRONG>script</STRONG> <EM>shell</EM> (par exemple
<CODE>install.sh</CODE>) selon ce que dit le fichier <CODE>INSTALL</CODE> (ou le
fichier <CODE>README</CODE>)</ul>


<H2><a name="254"><STRONG>Autoconf</STRONG></a></H2>


<H3><a name="255">Principe</a></H3>

<p><STRONG>Autoconf</STRONG> permet de configurer correctement un logiciel.  Il crée
les fichiers nécessaires à la compilation (par exemple,
<CODE>Makefile</CODE>), et modifie parfois directement les sources (comme par
le biais d'un fichier <CODE>config.h.in</CODE>).

<p>Le principe d'<STRONG>Autoconf</STRONG> est simple:


<ul><li>l'auteur du logiciel sait quels tests sont nécessaires pour
configurer son logiciel (ex: «&nbsp;quelle version de cette
<STRONG>bibliothèque</STRONG>
est utilisée?&nbsp;»). Il les écrit dans un fichier nommé <CODE>configure.in</CODE>,
en suivant une syntaxe précise.
<li>il exécute <STRONG>Autoconf</STRONG>.  Ce dernier génère, à partir du
fichier <CODE>configure.in</CODE>, un script de configuration appelé
<CODE>configure</CODE>.  Ce script est celui qui effectuera les tests
nécessaires à la configuration du programme.
<li>l'utilisateur final exécute ce script, et <STRONG>Autoconf</STRONG> se
charge de configurer tout ce qui est nécessaire à la compilation.</ul>


<H3><a name="256">Exemple</a></H3>

<p>Un exemple d'utilisation d'<STRONG>Autoconf</STRONG>:

<p><font size="-4"><PRE>
$ ./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
</PRE></font>

<p>Si on veut avoir un peu plus de contrôle sur ce qu'engendre la commande
<CODE>configure</CODE>, on peut lui passer des options via la ligne de
commande ou des variables d'environnement.  Exemple:

<p><font size="+1"><PRE>
$ ./configure --with-gcc --prefix=/opt/GNU
</PRE></font>

<p>ou encore (sous <STRONG>Bash</STRONG>):

<p><font size="+2"><PRE>
$ export CC=`which gcc`
$ export CFLAGS=-O2
$ ./configure --with-gcc
</PRE></font>

<p>ou:

<p><font size="+2"><PRE>
$ CC=gcc CFLAGS=-O2 ./configure
</PRE></font>


<H3><a name="257">Et si... cela ne fonctionne pas?</a></H3>

<p>Typiquement, il s'agit d'une erreur de type <CODE>configure: error:
Cannot find library guile</CODE> («&nbsp;configure: erreur: je
n'arrive pas à trouver la bibliothèque <CODE>guile</CODE>&nbsp;») (cela couvre la
plupart des erreurs du script <CODE>configure</CODE>).

<p>Clairement, le script <CODE>configure</CODE> n'a pas réussi à trouver une
bibliothèque (dans notre exemple, la bibliothèque <CODE>guile</CODE>).  Le
principe est que le script <CODE>configure</CODE> 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.


<ul><li>Regardez d'où vient l'erreur rencontrée en examinant la fin
du fichier <CODE>config.log</CODE>, qui contient une trace de toutes les
étapes de la configuration.  Le compilateur de langage <EM>C</EM>
est généralement
assez explicite dans ses messages d'erreur.  Cela vous aidera pour
résoudre le problème.
<li>Vérifiez que la bibliothèque en question est bien installée.
Si ce n'est pas le cas, installez-la (à partir des sources ou d'un
binaire précompilé) et exécutez à nouveau le script <CODE>configure</CODE>.
Une méthode efficace pour vérifier l'installation
est de rechercher le fichier
matérialisant la bibliothèque, qui porte invariablement le nom
<CODE>lib&lt;nom&gt;.so</CODE>. Par exemple,

<p><font size="+2"><PRE>
$ find / -name 'libguile*'
</PRE></font>

<p>ou encore:

<p><font size="+2"><PRE>
$ locate libguile
</PRE></font>
<li>Vérifiez qu'elle est accessible au compilateur, c'est-à-dire que
la bibliothèque est bien située dans un répertoire parmi:
<CODE>/usr/lib</CODE>, <CODE>/lib</CODE>, <CODE>/usr/X11R6/lib</CODE> (ou parmi ceux
spécifiés par la variable d'environnement <CODE>'LD_LIBRARY_PATH'</CODE>,
expliquée page&nbsp;162.0.  Vérifiez que ce fichier est
bien une bibliothèque en tapant <CODE>file libguile.so</CODE>.
<li>Vérifiez que les fichiers d'en-têtes correspondant à la
bibliothèque sont bien installés à la bonne place (généralement,
<font size="-1"><CODE>/usr/include</CODE></font>, <font size="-1"><CODE>/usr/local/include</CODE></font>, ou
<font size="-1"><CODE>/usr/X11R6/include</CODE></font>.  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, <CODE>gtk+-devel</CODE> au lieu de <CODE>libgtk</CODE>). La version
de développement de la bibliothèque est livrée avec les fichiers de
type <CODE>include</CODE> («&nbsp;à inclure&nbsp;»)
nécessaires à la compilation d'un logiciel utilisant cette bibliothèque.
<li>Vérifiez que vous avez assez de place disque (en effet le script
<CODE>configure</CODE> a besoin d'un peu de place pour des fichiers
temporaires).  Utilisez la commande <CODE>df -k</CODE> pour visualiser
les partitions de votre système, et ne vous préoccupez que des
partitions pleines ou presque.</ul>

<p>Si vous ne comprenez pas le message d'erreur stocké dans le fichier
<CODE>config.log</CODE>, n'hésitez pas à demander aide et assistance à la
communauté du logiciel libre (voir la section&nbsp;198.0).

<p>De plus, méfiez-vous si <CODE>configure</CODE> répond 100% de
<CODE>No</CODE> ou s'il répond <CODE>No</CODE> 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
<CODE>curses</CODE>).  Dans de tels cas, on est probablement en présence
d'une variable <CODE>'LD_LIBRARY_PATH'</CODE> mal positionnée!


<H2><a name="258"><STRONG>Imake</STRONG></a></H2>

<p><STRONG>Imake</STRONG> permet de configurer un logiciel libre en créant un
fichier <CODE>Makefile</CODE> à partir de règles simples.  Ces règles
déterminent quels fichiers ont besoin d'être compilés pour construire le
binaire, et <STRONG>Imake</STRONG> engendre le <CODE>Makefile</CODE> correspondant.  Ces
règles sont spécifiées dans un fichier appelé <CODE>Imakefile</CODE>.

<p>Là où <STRONG>Imake</STRONG> prend tout son intérêt, c'est qu'il utilise des
informations dépendantes du <STRONG><EM>site</EM></STRONG> (de l'architecture de
la machine).  C'est assez pratique dans le cas d'applications utilisant
<STRONG>X Window System</STRONG>.  Mais <STRONG>Imake</STRONG> est utilisé dans le cas de
nombreuses autres applications.

<p>L'utilisation la plus simple de <STRONG>Imake</STRONG> est de se rendre dans le
répertoire principal de l'archive décompactée, et ensuite d'exécuter
le script <CODE>xmkmf</CODE>, qui fera appel au programme <CODE>imake</CODE>:

<p><font size="0"><PRE>
$ xmkmf -a
imake -DUseInstalled -I/usr/X11R6/lib/X11/config
make Makefiles
</PRE></font>

<p>Si le site est mal installé, recompiler et installer <STRONG>X11R6</STRONG>!


<H2><a name="259">Scripts <EM>shell</EM> divers</a></H2>

<p>Lisez le fichier <CODE>INSTALL</CODE> ou <CODE>README</CODE> pour de plus amples
informations.  Généralement, il va vous falloir exécuter un fichier de
type <CODE>install.sh</CODE> ou <CODE>configure.sh</CODE>.  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).

<p>Si vous n'arrivez pas à déterminer le fichier que vous devez exécuter,
vous pouvez (sous <STRONG>Bash</STRONG>) taper <CODE>./</CODE>, et ensuite taper deux
fois la touche <CODE>TAB</CODE> (touche de tabulation).  <STRONG>Bash</STRONG> 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.

<p>Un cas particulier est l'installation de modules <STRONG>Perl</STRONG> (mais pas
seulement).  L'installation de tels modules se fait par l'exécution d'un
script de configuration lui-même écrit en <STRONG>Perl</STRONG>.  La commande à
effectuer est généralement:

<p><font size="+2"><PRE>
$ perl Makefile.PL
</PRE></font>


<H2><a name="260">Autres possibilités</a></H2>

<p>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 «&nbsp;à la main&nbsp;»
les fichiers de configuration.  Généralement, ces fichiers sont un
fichier <CODE>Makefile</CODE> (voir la section&nbsp;126.0) et un fichier
<CODE>config.h</CODE> (mais ce nom n'est qu'une convention).

<p>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.


<H1><a name="261">Compilation</a></H1>

<p>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.


<H2><a name="262"><STRONG>make</STRONG></a></H2>

<p>L'outil préféré de la communauté du logiciel libre pour compiler des
sources est <CODE>make</CODE>.  L'intérêt de <CODE>make</CODE> est double:


<ul><li>il permet au développeur de gagner du temps, car il présente
des avantages permettant de gérer la compilation de son projet de
manière efficace,
<li>il permet à l'utilisateur final de compiler et d'installer le
logiciel en quelques lignes de commande, et ceci sans connaissance
préalable du développement.</ul>

<p>Les actions à exécuter pour arriver à une version compilée des sources
sont stockées dans un fichier nommé habituellement <CODE>Makefile</CODE>, ou
<CODE>GNUMakefile</CODE>.  En fait, lorsque <CODE>make</CODE> 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
<CODE>-f</CODE> à <CODE>make</CODE>.


<H2><a name="263">Règles</a></H2>

<p><STRONG>make</STRONG> fonctionne selon un système de <STRONG>dépendances</STRONG>.
C'est-à-dire que pour qu'un binaire soit compilé
(«&nbsp;<STRONG>cible</STRONG>&nbsp;»), un certain nombre d'étapes doivent être
accomplies («&nbsp;dépendances&nbsp;»).  Par exemple, pour créer le binaire
(imaginaire) <CODE>glloq</CODE>, on a besoin de compiler les fichiers objets
(fichiers intermédiaires de la compilation) <CODE>main.o</CODE> et
<CODE>init.o</CODE>, puis de les lier.  Ces fichiers objets sont eux aussi des
cibles, dont les dépendances sont les fichiers sources.

<p>Ceci n'est qu'une introduction minimale pour survivre dans le monde
impitoyable de <STRONG>make</STRONG>.  Si vous voulez en savoir plus, je vous
conseille de vous rendre sur le site d'<STRONG>APRIL</STRONG> à l'adresse
<CODE>http://www.april.org/groupes/doc/</CODE> pour une documentation un peu
plus détaillée sur <STRONG>make</STRONG>.  Pour une documentation exhaustive,
voir <EM>Managing Projects with Make</EM> («&nbsp;La
gestion de projets avec <STRONG>make</STRONG>&nbsp;», seconde édition, chez <STRONG>O'Reilly</STRONG>,
d'Andrew <STRONG>Oram</STRONG> et Steve
<STRONG>Talbott</STRONG>.


<H2><a name="264">C'est parti!</a></H2>

<p>Généralement, l'utilisation de <STRONG>make</STRONG> obéit à plusieurs
conventions.  Par exemple:


<ul><li><STRONG>make</STRONG> sans argument exécute la compilation seule du
programme, sans l'installer.
<li><CODE>make install</CODE> 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 (<CODE>man</CODE>, <CODE>info</CODE>), il faut alors les copier à la
main.  Dans certains cas, il faut effectuer une nouvelle fois un
<CODE>make install</CODE> dans des sous-répertoires.  Généralement, il
s'agit de modules développés par des tiers.
<li><CODE>make clean</CODE> efface tous les fichiers temporaires créés par
la compilation, y compris le fichier exécutable dans la majorité des
cas.</ul>

<p>La première étape est de compiler le programme, et donc de taper
(exemple fictif):

<p><font size="-4"><PRE>
$ 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
</PRE></font>

<p>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&nbsp;180.0.


<H2><a name="265">Explications</a></H2>

<p>Si vous avez la curiosité de regarder ce qu'il y a dans le fichier
<CODE>Makefile</CODE>, vous y trouverez des commandes connues (<CODE>rm</CODE>,
<CODE>mv</CODE>, <CODE>cp</CODE>, ...), mais aussi des chaînes de caractères
étranges, de la forme <CODE>'$(CFLAGS)'</CODE>.

<p>Il s'agit de <EM><STRONG>variables</STRONG></EM>, c'est-à-dire de chaînes qui
sont fixées généralement au début du fichier <CODE>Makefile</CODE>, 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.

<p>Par exemple, pour afficher la chaîne «&nbsp;<CODE>toto</CODE>&nbsp;» à l'écran
en tapant un <CODE>make all</CODE>:

<p><font size="+2"><PRE>
TEST = toto
all:
        echo $(TEST)
</PRE></font>

<p>La plupart du temps, les variables suivantes sont définies:


<ul><li><STRONG><CODE>'CC'</CODE></STRONG>:  il s'agit du compilateur que l'on va utiliser.
Généralement il s'agit de <CODE>gcc</CODE>, mais sur la plupart des
systèmes libres, le compilateur par défaut utilisé par <STRONG>make</STRONG>
(soit <CODE>cc</CODE>) est un synonyme de <CODE>gcc</CODE>.  Dans le doute,
n'hésitez pas à mettre ici <CODE>gcc</CODE>.
<li><STRONG><CODE>'LD'</CODE></STRONG>:  il s'agit du programme utilisé parfois pour
assurer la phase finale de la compilation (voir la
section&nbsp;36.0).  Par défaut, la valeur est <CODE>ld</CODE>.
<li><STRONG><CODE>'CFLAGS'</CODE></STRONG>:  ce sont les arguments supplémentaires qu'on
passera au compilateur lors des premières phases de la compilation.
Parmi ceux-ci:


<ul><li><CODE>-I&lt;chemin&gt;</CODE>: spécifie au compilateur où chercher
des fichiers d'en-têtes supplémentaires

<p>(ex:
<CODE>-I/usr/X11R6/include</CODE> permet d'inclure les fichiers
d'en-têtes se situant dans <CODE>/usr/X11R6/include</CODE>)
<li><CODE>-D&lt;symbole&gt;</CODE>: définit un symbole supplémentaire,
utile dans certains programmes qui se compilent différemment selon
les symboles définis (ex: utilise le fichier <CODE>string.h</CODE> si
<CODE>'HAVE_STRING_H'</CODE> est défini)</ul>

<p>On trouve souvent des lignes de compilation de la forme:

<p><font size="+2"><PRE>
$(CC) $(CFLAGS) -c toto.c -o toto.o
</PRE></font>
<li><CODE>'LDFLAGS'</CODE> (ou <CODE>'LFLAGS'</CODE>): ce sont les arguments passés
lors de la dernière phase de la compilation.  Parmi ceux-ci:


<ul><li><CODE>-L&lt;chemin&gt;</CODE>: spécifie un chemin supplémentaire où
chercher des bibliothèques (ex: <CODE>-L/usr/X11R6/lib</CODE>).
<li><CODE>-l&lt;bibliothèque&gt;</CODE>: spécifie une bibliothèque
supplémentaire à utiliser lors de la dernière phase de compilation.</ul></ul>


<H2><a name="266">Et si ça ne fonctionne pas?</a></H2>

<p>Pas de panique, cela arrive à tout le monde.  Parmi les causes les plus
communes:


<ul><li><STRONG><CODE>glloq.c:16: decl.h: No such file or directory</CODE></STRONG>:

<p>(«&nbsp;<CODE>glloq.c:16</CODE>: <CODE>decl.h</CODE>: aucun fichier
ou répertoire ne porte ce nom&nbsp;»)

<p>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:


<ul><li>vérifiez que l'en-tête existe vraiment sur le disque dans
un des répertoires suivants: <font size="-1"><CODE>/usr/include</CODE></font>,
<font size="-1"><CODE>/usr/local/include</CODE></font>,
<font size="-1"><CODE>/usr/X11R6/include</CODE></font> ou un
de leurs sous-répertoires.  Si ce n'est pas le cas, recherchez-le sur tout
le disque (avec <CODE>find</CODE> ou <CODE>locate</CODE>),
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 <CODE>find</CODE> et <CODE>locate</CODE> dans leurs pages
de manuel respectives.
<li>vérifiez que l'en-tête est bien accessible en lecture
(tapez <CODE>less &lt;chemin&gt;/&lt;fichier&gt;.h</CODE> pour tester cela)
<li>s'il se trouve dans un répertoire comme
<font size="-1"><CODE>/usr/local/include</CODE></font> ou
<font size="-1"><CODE>/usr/X11R6/include</CODE></font>, il est
parfois nécessaire de passer un argument supplémentaire au
compilateur.  Ouvrez le fichier <CODE>Makefile</CODE> correspondant
(prenez garde à ouvrir le bon, celui qui se trouve dans le répertoire
où la compilation échoue<a name="bodynote30" href="026.html#note30">[30]</a>) avec votre éditeur de textes favori
(<STRONG>Emacs</STRONG>, <STRONG>VI</STRONG>, ...). Recherchez la ligne fautive, et
ajoutez la chaîne de caractères <CODE>-I&lt;path&gt;</CODE> (où
<CODE>&lt;chemin&gt;</CODE> est le chemin où se trouve l'en-tête en question juste
après l'appel du compilateur (<CODE>gcc</CODE>, ou parfois
<CODE>$(CC)</CODE>).  Si vous ne savez pas où rajouter cette
option, rajoutez-la au début du fichier, à la fin de la ligne
<CODE>CFLAGS=&lt;quelquechose&gt;</CODE> ou de la ligne
<CODE>CC=&lt;quelquechose&gt;</CODE>.
<li>exécutez <STRONG>make</STRONG> de nouveau, et si cela ne fonctionne toujours pas,
vérifiez que cette option (cf point précédent) est bien ajoutée à
la compilation sur la ligne fautive.
<li>si cela ne fonctionne toujours pas, demandez à votre gourou local
ou faites appel à la communauté du logiciel libre pour
résoudre votre problème (voir la section&nbsp;198.0).</ul>
<li><STRONG><CODE>glloq.c:28: `struct toto' undeclared (first use
this function)</CODE></STRONG>:
(«&nbsp;<CODE>glloq.c:28</CODE>: «&nbsp;<CODE>struct toto</CODE>&nbsp;»
n'est pas déclarée (ceci est la première utilisation de cette
fonction)&nbsp;»)

<p>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:


<ul><li>de tenter de vérifier si la structure en question est
une structure définie dans le programme ou par le système.  Une
solution est d'utiliser la commande <CODE>grep</CODE> afin de vérifier
si la structure est définie dans un des fichiers d'en-têtes.

<p>Par exemple, après vous être rendu dans la racine de la distribution:

<p><font size="-1"><PRE>
$ find . -name '*.h'| xargs grep 'struct toto' | less
</PRE></font>

<p>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 <CODE>grep</CODE>.

<p>La définition d'une structure est:

<p><font size="+2"><PRE>
struct toto {
        &lt;contenu de la structure&gt;
};
</PRE></font>

<p>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 <CODE>.c</CODE> fautif.  Deux solutions s'offrent à vous:


<ul><li>ajoutez la ligne
<CODE>#include "&lt;nom_du_fichier&gt;.h"</CODE> au début du
fichier <CODE>.c</CODE> fautif.
<li>ou copiez-collez la définition de la structure au
début de ce fichier (ce qui n'est pas très propre, mais ça
a le mérite de fonctionner, en général).</ul>
<li>si ce n'est pas le cas, faites la même chose sur les
fichiers d'en-têtes du système (qui se trouvent sur
<CODE>/usr/include</CODE>, <CODE>/usr/X11R6/include</CODE>, ou
<CODE>/usr/local/include</CODE> en général).  Mais cette fois-ci,
utilisez la ligne

<p><CODE>#include &lt;&lt;nom_du_fichier&gt;.h&gt;</CODE>.
<li>si cette structure n'existe toujours pas, essayez de
trouver dans quelle bibliothèque (au sens ensemble de
fonctions regroupées dans un seul paquetage) elle devrait être
définie (regardez dans le fichier <CODE>INSTALL</CODE> ou <CODE>README</CODE>
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.
<li>si cela ne fonctionne toujours pas, vérifiez que le programme
fonctionne bien correctement sur votre architecture (certains
programmes n'ont pas encore été portés sur tous les
<STRONG>Unix</STRONG>).  Vérifiez aussi que vous avez bien configuré le
programme (au moment du <CODE>configure</CODE>, par exemple) pour votre
architecture.</ul>
<li><STRONG><CODE>parse error</CODE></STRONG>:  («&nbsp;erreur d'analyse
syntaxique&nbsp;»)

<p>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:

<p><font size="-3"><PRE>
main.c:1: parse error before `glloq_t
main.c:1: warning: data definition has no type or storage class
</PRE></font>

<p>alors, le problème est que le type <CODE>glloq_t</CODE> 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.
<blockquote>Note:
il peut y avoir une erreur de type <CODE>parse error</CODE> dans les
vieilles bibliothèques <CODE>curses</CODE> si ma mémoire est bonne.</blockquote>
<li><STRONG><CODE>no space left on device</CODE></STRONG>:  («&nbsp;plus de place
disponible sur le périphérique&nbsp;»)

<p>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
<CODE>/tmp</CODE>, faites-le plutôt dans <CODE>/usr/local/src</CODE> ce
qui évite de saturer inutilement la partition <CODE>/tmp</CODE>.
Vérifiez de plus que vous n'avez pas de <STRONG>fichiers
<CODE>core</CODE></STRONG><a name="bodynote31" href="026.html#note31">[31]</a>
sur le disque.  Si oui, effacez-les ou faites-les effacer s'ils
appartiennent à un autre utilisateur.
<li><STRONG><CODE>/usr/bin/ld: cannot open -lglloq: No such file or
directory</CODE></STRONG>:  («&nbsp;<CODE>/usr/bin/ld</CODE>: je ne peux pas
ouvrir <CODE>-lglloq</CODE>: aucun fichier ou répertoire ne porte ce nom&nbsp;»)

<p>Clairement, le programme <CODE>ld</CODE> (utilisé par <CODE>gcc</CODE> 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,
<CODE>ld</CODE> va chercher un fichier dont le nom est passé par l'argument
<CODE>-l&lt;bibliothèque&gt;</CODE>.  Ce fichier porte le nom de
<CODE>lib&lt;bibliothèque&gt;.so</CODE>.  Si <CODE>ld</CODE> n'arrive pas à le
trouver, alors il produit ce message d'erreur.  Pour résoudre ce
problème, procédons par étapes:


<ul><li>Vérifions que ce fichier existe bien sur le disque dur,
en utilisant la commande <CODE>locate</CODE>.  Généralement, les
bibliothèques graphiques se trouvent dans
<CODE>/usr/X11R6/lib</CODE>.  Par exemple:

<p><font size="+2"><PRE>
$ locate libglloq
</PRE></font>

<p>Si cela ne produit rien, vous pouvez faire une recherche avec la
commande <CODE>find</CODE>

<p>(ex: <CODE>find /usr -name libglloq.so*</CODE>).  Si vous ne trouvez
toujours pas la bibliothèque, alors il vous reste plus qu'à l'installer.
<li>Une fois la bibliothèque localisée, vérifiez que cette
bibliothèque est bien accessible pour la commande <CODE>ld</CODE>: le fichier
<CODE>/etc/ld.conf</CODE> 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
<CODE>'LD_LIBRARY_PATH'</CODE>.  Par exemple, en imaginant que le
répertoire à ajouter est <CODE>/usr/X11R6/lib</CODE>, tapez:
<CODE>export</CODE>

<p><font size="-1"><CODE>LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/X11R6/lib</CODE></font>

<p>(si votre <EM>shell</EM> est <STRONG>Bash</STRONG>).
<li>Si cela ne fontionne toujours pas, vérifiez que la
bibliothèque incriminée est bien au format <EM>ELF</EM> (avec la commande
<CODE>file</CODE>).  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 <CODE>nm libglloq.so</CODE>).  Les permissions peuvent
de plus être incorrectes (si vous utilisez un compte autre que
<CODE>root</CODE> et que la bibliothèque est protégée en lecture par
exemple).</ul>
<li><STRONG><CODE>glloq.c(.text+0x34): undefined reference to
`glloq_init'</CODE></STRONG>:

<p>(«&nbsp;<CODE>glloq.c(.text+0x34)</CODE>: référence inconnue au
symbole «&nbsp;<CODE>glloq_init</CODE>&nbsp;»&nbsp;»)

<p>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:


<ul><li>la première chose à faire est de savoir si le symbole est
<EM>censé</EM> être présent dans une bibliothèque.  Par exemple,
s'il s'agit d'un symbole commençant par <CODE>gtk</CODE>, il appartient
très certainement à la bibliothèque <CODE>gtk</CODE>.  Si le nom de la
bibliothèque est difficilement identifiable
(comme par exemple
<CODE>zorglub_gloubiboulga</CODE>), il est possible de lister les
symboles d'une bibliothèque avec la commande <CODE>nm</CODE>.  Par
exemple,

<p><font size="+2"><PRE>
$ 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
</PRE></font>

<p>Rajouter l'option <CODE>-o</CODE> à <CODE>nm</CODE> 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
<CODE>bulgroz_max</CODE>, une solution de barbare est d'effectuer une
recherche de ce genre:

<p><font size="-2"><PRE>
$ 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
</PRE></font>

<p>Formidable!  Le symbole <CODE>bulgroz_max</CODE> est défini dans
la bibliothèque <CODE>zorglub</CODE> (la lettre majuscule <CODE>T</CODE> se
trouve devant son nom).  Il suffit de rajouter la chaîne
<CODE>-lzorglub</CODE> dans la ligne de compilation en éditant le
fichier <CODE>Makefile</CODE>: rajoutez-la à la fin de la ligne où
<CODE>'LDFLAGS'</CODE> ou <CODE>'LFGLAGS'</CODE> (ou au pire
<CODE>'CC'</CODE>) sont définis, ou alors sur la ligne responsable de la
création du fichier binaire final.
<li>la compilation se fait avec une version de la bibliothèque
qui n'est pas la même que celle prévue pour le logiciel.  Lisez
le fichier <CODE>README</CODE> ou <CODE>INSTALL</CODE> de la distribution pour
savoir quelle version de la bibliothèque doit être utilisée.
<li>tous les fichiers objets de la distribution ne sont pas
correctement liés.  Il manque le fichier dans lequel cette
fonction est définie. Tapez <CODE>nm -o *.o</CODE> pour connaître son nom et
ajoutez le fichier <CODE>.o</CODE> correspondant sur la ligne de
compilation s'il est manquant.
<li>la fonction ou variable incriminée est peut-être
fantaisiste.  Essayez de la supprimer: éditez le fichier source
incriminé (son nom est spécifié au début du message d'erreur).
C'est une solution désespérée, qui va avoir pour conséquence un
fonctionnement très probablement anarchique du programme
(<STRONG>erreur de segmentation</STRONG> au démarrage, etc.)</ul>
<li><STRONG><CODE>Segmentation fault (core dumped)</CODE></STRONG>:
(«&nbsp;erreur de segmentation, fichier <CODE>core</CODE> produit&nbsp;»)

<p>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.
<li>plus de place sur <CODE>/tmp</CODE>

<p>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 <STRONG>X</STRONG>, tubes...). Il faut donc
bien savoir ce que l'on fait!  Si <CODE>/tmp</CODE> fait partie d'une
partition qui ne contient pas que lui (par exemple, la racine),
recherchez et supprimez d'éventuels fichiers <CODE>core</CODE>.
<li><CODE>make</CODE>/<CODE>configure</CODE> en boucle

<p>Il s'agit généralement d'un problème d'heure sur votre système.
<STRONG>make</STRONG> 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.

<p>Il se peut que des problèmes de date amènent <STRONG>make</STRONG> à se
reconstruire sans fin (ou de construire et reconstruire un
arborescence en boucle).  Dans ce cas-là, l'utilisation de la
commande <CODE>touch</CODE> (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.

<p>Par exemple:

<p><font size="+2"><PRE>
$ touch *
</PRE></font>

<p>Ou encore plus barbare (mais efficace):

<p><font size="+2"><PRE>
$ find . | xargs touch
</PRE></font></ul>


<H1><a name="267">Installation</a></H1>


<H2><a name="268">Avec <STRONG>make</STRONG></a></H2>

<p>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 <CODE>/usr/local</CODE>).

<p><STRONG>make</STRONG> permet généralement d'assurer ce travail.  Une cible
spéciale est la cible <CODE>install</CODE>.  Très logiquement, utiliser
<CODE>make install</CODE> permet d'installer les fichiers nécessaires.

<p>Généralement, la procédure est décrite dans les fichiers <CODE>INSTALL</CODE>
ou <CODE>README</CODE>.  Mais parfois, l'auteur a oublié d'en prévoir une.
Dans ce cas, il va falloir tout installer à la main.

<p>Copiez alors:


<ul><li>les exécutables (programmes) dans le répertoire
portant le nom
<CODE>/usr/local/bin</CODE>
<li>les bibliothèques (fichiers <CODE>lib*.so</CODE>) dans le répertoire
portant le nom
<CODE>/usr/local/lib</CODE>
<li>les fichiers d'en-têtes (fichiers <CODE>*.h</CODE>) dans le répertoire
portant le nom
<CODE>/usr/local/include</CODE> (attention à ne pas écraser les fichiers
originaux)
<li>les fichiers de données vont généralement dans le répertoire
<CODE>/usr/local/share</CODE>.  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

<p><CODE>Cannot open /usr/local/share/glloq/data.db</CODE>).
<li>la documentation est un peu à part:


<ul><li>les fichiers <CODE>man</CODE> se placent dans un des
sous-répertoires de <CODE>/usr/local/man</CODE>.  Généralement, ces
fichiers sont au format <STRONG>troff</STRONG> (ou <STRONG>groff</STRONG>), et ont
pour extension un chiffre.  Leur nom est celui d'une commande (par
exemple, <CODE>echo.1</CODE>).  Si le chiffre est <CODE>n</CODE>,
copiez ce fichier dans le sous-répertoire <CODE>/usr/local/man/man&lt;n&gt;</CODE>.
<li>les fichiers <CODE>info</CODE> se placent dans le répertoire
<CODE>/usr/info</CODE> ou <CODE>/usr/local/info</CODE></ul></ul>

<p>Et voilà, c'est fini!  Félicitations!  Vous êtes maintenant fin prêt
à recompiler votre système d'exploitation tout entier.


<H2><a name="269">Problèmes</a></H2>

<p>Si vous venez d'installer un programme libre, par exemple <STRONG>GNU tar</STRONG>
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 <CODE>src</CODE>, c'est un problème de <CODE>PATH</CODE>, qui trouve le
programme dans un répertoire situé avant celui où vous avez installé le
nouveau logiciel.  Vérifiez en exécutant <CODE>type -a &lt;programme&gt;</CODE>.

<p>La solution est de mettre le répertoire d'installation plus haut dans
le <CODE>'PATH'</CODE>, 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
<CODE>gtar</CODE> dans cet exemple), de sorte qu'il n'y ait pas confusion.

<p>Vous pouvez aussi mettre en place un alias, si le <EM>shell</EM> le
permet (par exemple dire que <CODE>tar</CODE>, c'est
<CODE>/usr/local/bin/gtar</CODE>).


<H1><a name="270">Assistance</a></H1>


<H2><a name="271">Documentation</a></H2>

<p>Plusieurs sources de documentation:


<ul><li>les <EM>HOWTO</EM>, petites documentations sur un sujet précis
(généralement, pas trop proche de ce qui nous intéresse ici, mais
parfois utiles).  Voir sur votre disque dans le répertoire
<CODE>/usr/doc/HOWTO</CODE>
(pas toujours, parfois ils sont mis ailleurs, c'est la commande
<CODE>locate HOWTO</CODE> qui vous donnera la réponse en cas de doute),
ou alors, pour une version française des <EM>HOWTO</EM>,
sur l'<EM>URL</EM> <CODE>http://www.freenix.fr/</CODE>.
<li>les pages de manuel.  Tapez <CODE>man &lt;commande&gt;</CODE>
pour obtenir de la documentation sur la commande <CODE>&lt;commande&gt;</CODE>,
<li>la littérature spécialisée.  Plusieurs grands éditeurs
commencent à publier des livres sur les systèmes libres (plus
spécialement sur <STRONG>GNU/Linux</STRONG>).  C'est souvent utile si vous débutez et
si vous ne comprenez pas tous les termes de la présente documentation.</ul>


<H2><a name="272">Assistance technique</a></H2>

<p>Si vous avez acheté une distribution «&nbsp;officielle&nbsp;» de
<STRONG>Linux-Mandrake</STRONG>, 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 <CODE>'x'</CODE> jours.  Peut-être peuvent-ils passer
quelque temps sur des problèmes de compilation?

<p>Vous pouvez sinon compter sur l'aide de la communauté du logiciel
libre:


<ul><li>les <STRONG><EM>newsgroups</EM></STRONG> (forums de discussions sur
l'<EM>Usenet</EM>) dont le nom vérifie
<CODE>fr.comp.os.linux.*</CODE> permettent de répondre à toutes les questions
concernant <STRONG>GNU/Linux</STRONG>.  Le forum intitulé <CODE>fr.comp.os.bsd</CODE>
a pour sujet les systèmes <EM>BSD</EM>.  Il doit exister d'autres forums
dédiés à d'autres <STRONG>Unix</STRONG>. N'oubliez pas de les lire pendant un
moment avant de commencer à y écrire.
<li>plusieurs associations ou groupes d'enthousiastes du logiciel
libre proposent une assistance bénévole. Pour trouver ceux dont les
membres habitent près de chez vous, la meilleure chose à faire est
de consulter les sites <EM>web</EM> spécialisés ou de lire les forums
de discussions concernés pendant un moment.
<li>plusieurs <STRONG><EM>channels</EM></STRONG> <EM>IRC</EM> permettent une
assistance en temps réel (mais en aveugle) par des <STRONG>gourous</STRONG>.  Voir par
exemple le <EM>channel</EM> <CODE>#linux</CODE> sur la plupart des
réseaux d'<EM>IRC</EM>, ou <CODE>#linuxhelp</CODE> sur <EM>IRCNET</EM>.
<li>en dernier recours, demander à l'auteur du logiciel (s'il a
mentionné son nom et son <STRONG>adresse électronique</STRONG> dans un fichier de la
distribution) si vous êtes sûr d'avoir identifié un bogue (qui peut
n'être dû qu'à votre architecture, mais après tout, un logiciel
libre est censé être portable).</ul>


<H2><a name="273">Comment trouver des logiciels libres</a></H2>

<p>Pour trouver des logiciels libres, de nombreux pointeurs peuvent vous
être utiles:


<ul><li>l'énorme site <EM>FTP</EM> <CODE>sunsite.unc.edu</CODE> ou l'un de ses miroirs
<li>les sites webs suivants effectuent un catalogue de nombreux
logiciels libres utilisables sur plates-formes <STRONG>Unix</STRONG> (mais
on y trouve aussi des logiciels propriétaires):


<ul><li><CODE>http://www.freshmeat.net/</CODE> est sans doute le site
le plus complet,
<li><CODE>http://www.linux-france.org</CODE> contient de
nombreux pointeurs vers des logiciels fonctionnant sous
<STRONG>GNU/Linux</STRONG>.
La plupart fonctionnent bien sûr sur les autres plates-formes
<STRONG>Unix</STRONG> libres,
<li><CODE>http://www.gnu.org/software/</CODE> pour une liste
exhaustive de tous les logiciels <EM>GNU</EM>.  Bien sûr, tous sont
libres et la plupart ont pour licence la <EM>GPL</EM>.</ul>
<li>vous pouvez de plus effectuer une recherche sur des moteurs
comme <CODE>http://www.altavista.com/</CODE> et effectuer une requête
de type: <CODE>+&lt;logiciel&gt; +download</CODE> ou <CODE>"download
&lt;logiciel&gt;"</CODE>.</ul>


<H1><a name="274">Remerciements</a></H1>


<ul><li>Relectures et commentaires désobligeants (et par ordre
alphabétique):
Sébastien <STRONG>Blondeel</STRONG>,
Mathieu <STRONG>Bois</STRONG>,
Xavier <STRONG>Renaut</STRONG>,
Kamel <STRONG>Sehil</STRONG>,
<li><STRONG><EM>Bêta-testing</EM></STRONG>:
Laurent <STRONG>Bassaler</STRONG>
<li>Traduction en anglais:
Fanny <STRONG>Drieu</STRONG></ul>


<H1><a name="275">Copyright</a></H1>

<p>Copyright (c) 1999 Benjamin <STRONG>Drieu</STRONG>,
association <STRONG>APRIL</STRONG> (dont le site <EM>web</EM> est
<CODE>http://www.april.org/</CODE><a name="bodynote32" href="026.html#note32">[32]</a>).

<p>This document is free documentation; you can redistribute it and/or
modify it under the terms of the <EM>GNU</EM> General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.  («&nbsp;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).&nbsp;»).

<p>This work is distributed in the hope that it will be useful, but
<STRONG>without any warranty</STRONG>; without even the implied warranty of
<STRONG>merchantability</STRONG> or <STRONG>fitness for a particular purpose</STRONG>.
See the GNU General Public License for more details («&nbsp;Ce
programme est distribué car potentiellement utile, mais <STRONG>sans
aucune garantie</STRONG>, ni explicite ni implicite, y compris les garanties de
<STRONG>commercialisation</STRONG> ou d'<STRONG>adaptation dans un but
spécifique</STRONG>. Reportez-vous à la Licence Publique Générale <EM>GNU</EM> pour
plus de détails.&nbsp;»).

<p>You will find the GNU General Public License at address
<CODE>http://www.gnu.org/copyleft/gpl.html</CODE>; you can also get a copy of
it by writing to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA.  («&nbsp;Vous trouverez la Licence
Publique Générale GNU dans votre distribution ou sur le <EM>Web</EM> à
l'adresse <font size="-1"><CODE>http://www.gnu.org/copyleft/gpl.html</CODE></font>; vous
pouvez aussi l'obtenir en écrivant à la Free Software Foundation, Inc.,
59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.&nbsp;»).
<hr><a href="023.html">Suivant&nbsp;: Les utilitaires en ligne de commande</a><br><a href="021.html">Précédent&nbsp;: Compilation et
installation de nouveaux noyaux</a><br><a href="../">Retour</a><br><hr>Copyright © 2000 <a href="http://www.mandrakesoft.com/">MandrakeSoft</a></BODY></HTML>
See more files for this project here