\typeout{+==============================================+}
\typeout{|============== CONFIGURER ====================|}
\typeout{+==============================================+}
\chapter{Se mettre à l'aise !}
\label{chap-configurer}
\begin{epigraphe}{man bash}
   On login (subject to the \verb+-noprofile+ option):\\
           if \verb+/etc/profile+ exists, source it.\\
           if \verb+~/.bash_profile+ exists, source it,\\
   On exit:
           if \verb+~/.bash_logout+ exists, source it.
\end{epigraphe}

\begin{introchap}{Développer}
  un projet c'est aussi être dans un environnement agréable et
  correspondant à ses propres besoins. Ce chapitre a pour but de
  présenter la configuration de l'environnement de travail pour que le
  programmeur puisse se focaliser sur son travail.  Ce chapitre n'est
  pas un inventaire de ce que l'on peut configurer sous \unix{}, mais
  consiste en une présentation des mécanismes de configuration
  proprement dits.  Nous présentons donc ici, la configuration du
  shell, l'utilisation d'\com{emacs} et \com{vi}, le principe de la
  configuration d'un environnement graphique, ainsi que l'installation
  de logiciels pour un utilisateur sans privilège. Cette dernière
  section est terminée par une présentation de la gestion des paquets
  Debian.
\end{introchap}

\section{Avec le shell} 
\label{sec-conf-shell}
\index{shell!configuration|(}

Le shell est l'environnement de travail de base sous \unix{}. Grâce au
shell on peut dialoguer avec le système par le biais de commandes, de
scripts, en lançant des logiciels, etc. Il est donc important que cet
environnement soit configuré le mieux possible par rapport au besoin
de l'utilisateur.  La plupart des configurations effectuées au niveau
du shell se font :
\begin{itemize}
\item soit à l'aide de variables dites \voir{sec-unix-env}{\emph{variables
    d'environnement}} ;
\item soit en positionnement des variables propres au shell utilisé.
\end{itemize}
\begin{attention}
  Les possibilités de configuration présentées dans cette section ne
  prennent leur intérêt que couplées avec les
  \voir{sec-shell-demarrage}{fichiers de démarrage} : la configuration
  d'un environnement utilisateur passe par le positionnement de
  variables dans ces fichiers de démarrage de manière à rendre actif
  l'environnement personnalisé à chaque connexion.
\end{attention}

Les variables d'environnement sont des variables qui sont « exportées
» ---~c'est-à-dire transmises~--- aux \voir{sec-processus}{processus}
fils du shell, par l'une des syntaxes suivantes :
\begin{itemize}
\item \verb+export +\comarg{variable}\verb+=+\comarg{valeur} pour la
  famille \com{sh}, ou :
\item \verb+setenv +\comarg{variable}\verb+ +\comarg{valeur}, pour la
  famille \com{csh}.
\end{itemize}
Voyons sur un exemple comment sont exportées ces variables en
considérant le script suivant :
\begin{fichier}[label=testexport.sh]
  #!/bin/bash
  echo X=$X
  echo Y=$Y
\end{fichier}
\begin{shellcom}
  ¢usercom«X=4»
  ¢usercom«export Y=5»
  ¢usercom«./testexport.sh»
  X=
  Y=5
\end{shellcom}
on constate ici que le script \texttt{testexport.sh} « connaît » la valeur
de la variable \texttt{Y} mais \texttt{X}, elle, est inconnue car
uniquement définie pour le shell.

\subsection{Le prompt}
\label{sec-conf-shell-prompt}
\index{shell!prompt}
\index{prompt}

On peut changer l'allure du prompt  en modifiant le
contenu de la variable \envvar{PS1}. Par exemple :
\framaallongepage{1}
\begin{shellcom}[noendprompt]
  ¢usercom«PS1="vasyfaitpter# "»
  vasyfaitpter# ¢usercomwop«date»
  Wed Jun  7 11:55:21 CEST 2000
  vasyfaitpter#
\end{shellcom}
On peut avoir un prompt un peu plus évolué dans lequel il est possible
d'ajouter entre autres (ce qui suit est spécifique à \soft{bash}) :
\begin{itemize}
\item le nom de l'utilisateur : \verb+\u+ (\emph{user}) ;
\item le nom de la machine : \verb+\h+  (\emph{host name}) ;
\item le répertoire de travail : \verb+\w+ ou \verb+\W+ pour une forme
  abrégée (\emph{working directory}) ;
\item la date et l'heure : \verb+\d+ et \verb+\t+ (\emph{date} et
  \emph{time}).
\end{itemize}
Nous avons un petit faible pour le prompt suivant :
\begin{shellcom}[noendprompt]
  ¢usercom«PS1="\u@\h:\w>"»
  lozano@coltrane:~/tcqvatvs/guide>
\end{shellcom}
ou plus succinctement :
\begin{shellcom}[noendprompt]
  ¢usercom«PS1="\h\w>"»
  coltrane~/tcqvatvs/guide>
\end{shellcom}
Les shells utilisent également un prompt particulier pour indiquer
qu'une commande n'est pas complète bien que l'utilisateur ait pressé
la touche \touche{Entrée}. Ce prompt s'affiche sous \soft{bash} en
fonction de la valeur de la variable \envvar{PS2}. Par défaut cette
variable contient la chaîne~«\verb+>+», on peut y mettre par exemple :
\begin{shellcom}
  ¢usercom«PS2="et?> "»
\end{shellcom}
pour attirer l'attention. Ainsi :
\begin{shellcom}
  ¢usercom«for x in 1 2 3 ; do»
  ¢usercomwmp«echo $[x+1]»
  ¢usercomwmp«done»
  2
  3
  4
\end{shellcom}
%$
\begin{note}
  Les autres shells disposent  également de variables permettant de
  spécifier l'allure du prompt ; la syntaxe est légèrement différente
  mais l'idée générale est la même.
\end{note}

\subsection{Historique des commandes}
\label{sec-conf-shell-historique}
\index{shell!historique}
\index{commande!historique}
\index{historique}

Comme nous avons pu le noter, les shells d'\unix{} proposent
généralement un mécanisme d'historique permettant aux vaillants
utilisateurs de rappeler les commandes déjà saisies, pour
éventuellement les corriger ou simplement les ré-exécuter.
L'utilisateur peut compulser cet historique avec la commande
\com{history} :
\begin{shellcom}
  ¢usercom«history»
  ...  ...
  510  xdvi guide-unix.dvi &
  511  pdflatex guide-unix
  512  acroread guide-unix.pdf &
  513  xfig figs/lien_symbolique.fig&
  514  history 
\end{shellcom}
Par défaut le shell~\soft{bash} stocke cet historique, à chaque fois
qu'on quitte un shell, dans un fichier dont le nom est stocké dans la
variable \envvar{HISTFILE}. Par exemple sur la machine de votre
serviteur :
\begin{shellcom}
  ¢usercom«echo $HISTFILE»
  /home0/vincent/.bash_history
\end{shellcom}
%$
Deux autres variables sont bonnes à connaître :
\begin{itemize}
\item \envvar{HISTFILESIZE} le nombre de lignes à mémoriser pour
  l'historique ;
\item \envvar{HISTCONTROL} qu'on peut positionner à la valeur :
  \begin{itemize}
  \item \texttt{ignoredups} pour ne pas stocker dans l'historique
    deux commandes identiques ;
  \item \texttt{ignorespace} pour ne pas stocker les lignes commençant
    par un espace ;
  \item \texttt{ignoreboth} pour cumuler les deux effets précédents.
  \end{itemize}
\end{itemize}
Pour info, sur mon système :
\begin{shellcom}
  ¢usercom«echo $HISTFILESIZE $HISTCONTROL»
  500 ignoreboth
\end{shellcom}

\subsection{Alias et fonctions}
\label{sec-conf-alias}
\index{shell!alias}
\index{alias de commande}


Il est souvent intéressant d'utiliser les \emph{alias} pour créer ce
qu'on pourrait appeler des « raccourcis » de commandes. Par exemple,
au lieu d'écrire :
\begin{shellcom}
  ¢usercom«telnet -l lozano coltrane.freejazz.org»
  Trying xx.xx.xx.xx...
  Connected to coltrane.freejazz.org
  Escape character is '^]'.
  ...
\end{shellcom}
On peut définir un alias :
\begin{shellcom}
  ¢usercom«alias trane='telnet -l lozano coltrane.freejazz.org'»
  ¢usercom«trane»
  Trying xx.xx.xx.xx...
  Connected to coltrane.freejazz.org.
  Escape character is '^]'.
\end{shellcom}
\begin{attention}
  Contrairement aux alias de \com{tcsh}, ceux de \com{bash} « se
  contentent » d'effectuer le remplacement de l'alias par sa
  définition. Mais cette définition ne peut contenir de référence aux
  arguments de la ligne de commande. Il faut pour cela utiliser des 
  \voir{sec-shell-fonction}{\emph{fonctions}} de \com{bash}.
\end{attention}

Voici un exemple simple de fonction : supposons que l'on se connecte
régulièrement sur la machine \texttt{ayler.freejazz.org} mais sous des
utilisateurs différents. On pourrait avoir l'idée de génie d'écrire :
\begin{fichier}
  function sshayler()
  {
    ${1?:="donnez moi un login plize..."}
    ssh -X -l $1 ayler.freejazz.org
  }
\end{fichier}
Une fois cette fonction stockée dans un
\voir{sec-shell-demarrage}{fichier de démarrage}, on pourra simplement
taper :
\begin{shellcom}
  sshayler vincent
\end{shellcom}
pour se connecter en tant qu'utilisateur \texttt{vincent} sur
\texttt{ayler.freejazz.org}, quelle joie...  Notons enfin qu'il y a un
ordre de priorité dans l'exécution des commandes, alias et autres
fonctions ; cet ordre est le suivant :
\begin{enumerate}
\item les alias ;
\item les fonctions ;
\item les commandes internes ;
\item les commandes externes.
\end{enumerate}
Ainsi, si par exemple on définit un alias :
\begin{shellcom}
  ¢usercom«alias xdvi='xdvi -keep'»
\end{shellcom}
Alors la commande :
\begin{shellcom}  
  ¢usercom«xdvi bidule.dvi &»
\end{shellcom}
fera d'abord appel à l'alias qui lui, fera appel à la commande
externe. L'option~\texttt{-a} de la commande \com{type} peut donner
des informations à ce sujet :
\begin{shellcom}
  ¢usercom«type -a xdvi»
  xdvi is aliased to `xdvi -keep' ¢comcomment«alias»
  xdvi is /usr/bin/xdvi ¢comcomment«commande externe»
\end{shellcom}


\subsection{Environnement de développement}
\label{sec-conf-env}
\index{environnement!de développement}

Lorsqu'on développe des applications il arrive qu'on veuille les
stocker dans un sous-répertoire du répertoire privé tel que, par
exemple, \verb+~/bin+. Sans modification particulière de
l'environnement les programmes stockés dans ce répertoire ne pourront
être exécutés sans spécifier le nom complet du répertoire de stockage
:
\begin{flushleft}
  \texttt{\~{}/bin/}\comarg{mon-exécutable}
\end{flushleft}
\index{exécutable!localisation}

Pour remédier à cet inconvénient on peut modifier la variable
d'environnement \envvar{PATH}. Cette variable contient une liste de
répertoires séparés par des~«:» dans lesquels le shell va chercher les
exécutables appelés en ligne de commande. Par exemple, sur notre
système :
\begin{shellcom}
  ¢usercom«echo $PATH»
  /usr/local/Acrobat5/bin:/usr/local/bin:
  /bin:/usr/bin:/usr/X11R6/bin
\end{shellcom}
%$
Par conséquent, pour rajouter \verb+~/bin+ dans cette liste, on
peut écrire :
\begin{shellcom}
  ¢usercom«export PATH=~/bin:$PATH»
\end{shellcom}
%$
Ceci permet d'ajouter en début de liste notre répertoire de
stockage des exécutables « maison ». Lorsque ces exécutables sont liés
dynamiquement avec des bibliothèques « maison », on pourra stocker
ces bibliothèques dans un répertoire, par exemple \verb+~/lib+ ; et
pour faire en sorte que leur chargement se déroule correctement il
faudra mettre à jour la variable d'environnement
\envvar{LD\_LIBRARY\_PATH} :
\begin{shellcom}
  ¢usercom«export LD_LIBRARY_PATH=~/lib:$LD_LIBRARY_PATH»
\end{shellcom}
%$
On pourra aussi se reporter au paragraphe~\vref{sec-ou-sont-les-libs}
pour plus d'informations au sujet des bibliothèques dynamiques.


\subsection{Interaction avec les logiciels}
\index{environnement!des logiciels}

Certains logiciels font appel à des variables d'environnement pour
fonctionner. On ne peut évidemment pas dresser une liste exhaustive de
ces variables. Voici cependant quelques exemples qui permettront de
comprendre le mécanisme global : beaucoup de logiciels sont conçus
pour avoir un comportement par défaut que l'on peut surcharger en
positionnant une variable d'environnement.
\begin{itemize}
\item certains programmes utilisent la variable \envvar{EDITOR} au
  moment de lancer l'édition d'un texte ; ils supposent généralement
  que l'éditeur par défaut est \com{vi} ; si pour une raison ou une
  autre vous désirez utiliser un autre éditeur :
  \begin{shellcom}
    ¢usercom«export EDITOR=¢comarg«mon_éditeur»»
  \end{shellcom}
  fera l'affaire ;
\item la variable \envvar{TERM} indique au système le type de terminal
  utilisé. La valeur « passe-partout » est le \texttt{vt100}
  compatible avec la plupart des terminaux et qui suffit à la plupart
  des applications. On pourra donc écrire :
  \begin{shellcom}
    ¢usercom«export TERM=vt100»
    ¢usercom«reset»
    ...
  \end{shellcom}
  en cas de liaison difficile avec une machine distante possédant un
  système n'identifiant pas votre type de terminal.
\item la variable \envvar{PAGER} définit le programme chargé
  d'afficher les pages de \voir{sec-man}{manuel} avec la commande
  \com{man} ;
\item ...
\end{itemize}
En règle générale, les pages de manuel contiennent une rubrique
baptisée « En\-viron\-ne\-ment » qui décrit les variables d'environnement
ayant une influence sur le programme en question.

\subsection[Fichiers de démarrage]{%
  Sauvegarder ses configurations grâce aux fichiers de démarrage} 
\label{sec-shell-demarrage}
\index{shell!démarrage}
\index{démarrage (fichiers de)}

Lorsque le système lance un processus de shell, ce dernier va
lire ---~suivant sa famille \com{sh} ou \com{csh}~--- dans un ordre
défini, un certain nombre de fichiers pouvant contenir des commandes
ou des initialisations de variables d'environnement. Ces fichiers
sont appelés \emph{fichiers de démarrage} et portent
généralement le doux nom, de \texttt{login}, \texttt{profile}, et
autre \texttt{monshellrc}... Pour comprendre le fonctionnement des
fichiers de démarrage, il faut d'abord distinguer  les trois types
de lancement d'un shell :
\begin{description}
\item[login shell :] ou \emph{shell de connexion}, il est lancé lors
  de la connexion (ou \emph{login}) sur le système ;
\item[non login interactive shell :] il s'agit d'un shell lancé
  autrement que par une procédure de connexion, par exemple par
  l'intermédiaire d'une fenêtre \com{xterm} ;
\item[non interactive :] shell lancé pour interpréter un fichier de
  commande ;
\end{description}
Dans le cas du shell \com{bash}, les fichiers lus sont les suivants :
\begin{description}
\item[login shell :] \verb+~/.bash_profile+ ;
\item[non login shell :] \verb+~/.bashrc+ ;
\item[non interactif :] le fichier dont le nom est dans la variable
  \envvar{ENV}.
\end{description}

Voici un exemple de configuration classique des fichiers de démarrage.
De manière à tenir compte à la fois de la phase de connexion (login
shell) et des shells interactifs (non login interactive shell), une
solution est d'articuler la lecture des fichiers \verb+~/.bash_profile+
et \verb+~/.bashrc+ comme suit :
\begin{fichier}[label=\~{}/.bash\_profile]
  if [ -f ~/.bashrc ]; then
     . ~/.bashrc
  fi
  # exportation de variables :
  ...
\end{fichier}
et :
\begin{fichier}[label=\~{}/.bashrc]
  # définition d'alias et fonctions
  ...
\end{fichier}
Ainsi, les variables utiles à la configuration de l'environnement sont
initialisées une fois pour toute à la connexion. Ce qui suit est un
extrait des fichiers de configuration de l'auteur :
\begin{fichier}[label=\~{}/.bash\_profile]
  if [ -f ~/.bashrc ]; then
     . ~/.bashrc
  fi
  export PATH=~/bin:$PATH
  export MANPATH=~/man:$MANPATH
  export POVINI=~/povray3.6/povray.ini
  export TEXINPUTS=~/LaTeX/myinputs:
  export LD_LIBRARY_PATH=~/lib:~/src/lib:~/lib/GL
  PS2="et?> "
  HISTCONTROL=ignoreboth
  umask 027
\end{fichier}
et :
\begin{fichier}[label=\~{}/.bashrc]
  alias rm='rm -i'
  alias mv='mv -i'
  alias cp='cp -i'
  alias up='cd ..'
  alias uup='cd ../..'
  alias ou='find . -name '
  alias ltr='ls -ltr'

  function cleantex()
  {
    /bin/rm -f $1.aux $1.log $1.bbl $1.blg $1.mtc* $1.?dx\ 
    $1.?lg $1.?nd $1.toc
  }
\end{fichier}
%$
\index{shell!configuration|)}


\begin{gnuposix}
  Pour ajouter un répertoire personnel à la liste des répertoires de
  recherche, le shell \soft{bash} pris comme support dans ce manuel
  permet d'écrire :
\begin{verbatim}
  export PATH=~/bin:$PATH
\end{verbatim}
  \continuenota Cependant certains shells ne procèdent pas à l'expansion
  du \verb+~+, il faudra alors écrire :
\begin{verbatim}
  PATH=~/bin:$PATH export PATH
\end{verbatim}
\end{gnuposix}


\subsection{Étude(s) de cas}
\label{sec-conf-shell-cas}


\subsubsection{Un autre \LaTeX{}}

Lorsqu'on utilise ce merveilleux et monstrueux logiciel qu'est
\LaTeX{} pour produire des documents, on fait appel à deux programmes
distincts :
\begin{itemize}
\item on lance le visualiseur de document \com{xdvi}  avec la commande :
  \begin{verbatim}
    xdvi madoc.dvi &
  \end{verbatim}
\item puis, à intervalles réguliers, on lance la compilation du
  source :
  \begin{verbatim}
    latex madoc.tex
  \end{verbatim}
\end{itemize}
Une fois la compilation terminée, il faut rendre active la fenêtre de
logiciel \soft{xdvi} pour visualiser les changements dans le
document. Or, en lisant la documentation de \com{xdvi} on peut tomber
sur :
\begin{verbatim}
SIGNALS
   When xdvi receives a USR1 signal, it rereads the dvi file.
\end{verbatim}
L'idée qui germe donc dans l'esprit du lecteur d'esprit vif est la
suivante : il serait intéressant de pouvoir envoyer automatiquement ce
signal au programme \soft{xdvi} à chaque compilation avec \LaTeX{}, et
ce pour éviter d'avoir à cliquer sur la fenêtre du visualiseur pour la
rendre active... Voici l'algorithme proposé :
\begin{algo}
  \BEGIN
  \STATE{lancer la compilation du document $D$.tex}
  \STATE{trouver le pid $p$ du \soft{xdvi} qui visualise $D$.dvi}
  \IF{$p$ existe }
  \STATE{envoyer le signal \texttt{USR1} au programme de pid $p$}
  \ENDIF
  \END
\end{algo}
Et voici comment on peut implémenter cet algorithme en shell :
\begin{fichier}
  function latex()
  {
    # on enlève l'éventuelle extension
    j=${1%.*}
    # appel du « vrai » LaTeX
    command latex $j
    # récupération du pid de(s) xdvi(s)
    pids=$(ps -ef | grep xdvi.bin | grep $j.dvi \
                  | awk '{print $2}')
    # envoi du signal USR1 pour chacun d'eux
    for p in $pids ; do
      kill -USR1 $p
    done
  }
\end{fichier}
%$
On notera que dans la fonction, on fait appel à \texttt{command latex}
pour éviter un appel récursif à la fonction. Le reste de la fonction
fait appel à des outils (\com{ps}, \com{grep}, \com{awk}, boucle
\texttt{for} du shell) présentés dans les chapitres précédents (en
particulier les chapitres~\ref{chap-guide-survie} et~\ref{chap-toolbox}).

Il est intéressant de noter que la commande \com{fuser} permettant
d'obtenir la liste des processus utilisant un fichier particulier,
nous offre une autre solution au problème.  En effet si on tape :
\begin{shellcom}
  ¢usercom«fuser guide-unix.dvi»
  guide-unix.dvi:       2587
\end{shellcom}
alors le système nous indique que le processus de pid~2587 a ouvert le
fichier en question. La version de \com{fuser} de votre serviteur
permet en outre à l'aide de l'option \texttt{-k} d'envoyer un signal
particulier au(x) processus détecté(s). Ainsi :
\begin{shellcom}
  ¢usercom«fuser -k -USR1 guide-unix.dvi»
\end{shellcom}
permet d'envoyer le signal \texttt{USR1} aux processus utilisant  \verb+guide-unix.dvi+...

\subsubsection{Une poubelle}

Sous \unix{}, l'utilisateur n'a généralement pas la possibilité de
récupérer un fichier qu'il a effacé. La solution adoptée par les
systèmes d'exploitation consiste à proposer à l'utilisateur une «
corbeille » dans laquelle on déplace les fichiers plutôt que de les
effacer réellement\footnote{Ceci sans parler des sauvegardes
  journalières des données que tout bon administrateur système doit
  assurer...}. Lorsque la corbeille est vidée, les fichiers sont
effectivement effacés. Il est tout à fait possible d'envisager de
configurer l'environnement de travail pour mettre en place un tel
mécanisme. Voici quelques ébauches que le lecteur pourra lui-même
faire évoluer selon ses besoins :
\begin{fichier}[label=corbeille]
  CORBEILLE=~/.corbeille
  #
  # nouvelle commande rm
  #
  function rm()
  {
    # si la corbeille n'existe pas, on la crée
    if [ ! -d $CORBEILLE ]; then
       mkdir $CORBEILLE
    fi
    # on déplace tous les fichiers de la ligne de commande
    # dans la corbeille
    mv -f "$@" $CORBEILLE
  }
\end{fichier}
Cette nouvelle commande~\texttt{rm} peut être utilisée aussi bien pour
un ensemble de fichiers que pour un ensemble de répertoires. On peut
également créer une commande de vidange de la corbeille :
\begin{fichier}[label=corbeille]
  function vidange()
  {
    rm -rf $CORBEILLE
  }
\end{fichier}
%$
Cette nouvelle version de la commande \texttt{rm} est limitée par le
fait que tous les fichiers et répertoires effacés sont déplacés dans
le même répertoire (celui faisant office de corbeille). Par
conséquent :
\begin{itemize}
\item il n'y aucune trace dans la corbeille du répertoire dans lequel
  était initialement stocké le fichier ou répertoire effacé ;
\item si on efface deux fichiers portant le même nom, seul le dernier
  sera sauvegardé dans la poubelle ;
\item si on efface un répertoire portant le nom d'un fichier déjà
  effacé le shell nous enverra sur les roses avec le message :
\begin{flushleft}
  \ttfamily mv: cannot overwrite non-directory
  `~/.corbeille/\comarg{dir}'  with directory `\comarg{dir}/'
\end{flushleft}
\end{itemize}
Enfin, cette fonction ne traite pas le cas des options éventuellement
passées en ligne de commande. Pour éviter d'écraser un fichier déjà
dans la corbeille, on peut utiliser l'option \texttt{backup} de la
commande~\com{mv} du projet \gnu{} :
\begin{verbatim}
   mv -f --backup=numbered $* $CORBEILLE
\end{verbatim}
Cette option permettera de numéroter les fichiers dupliqués en faisant
appel à la syntaxe :
\begin{flushleft}
  \comarg{nom du fichier}\verb+.~+\comarg{numéro}\verb+~+
\end{flushleft}
Par exemple, toutes les sauvegardes du fichier \texttt{bidule.txt},
seront nommées :
\begin{verbatim}
  bidule.txt bidule.txt.~1~ bidule.txt.~2~ bidule.txt.~3~ ...
\end{verbatim}

%----------------------------------------------------------------------
%
% VI
%
%----------------------------------------------------------------------

\section{Avec vi} 
\label{sec-conf-vi}

\com{vi} ---~prononcer vi aïe~--- est l'éditeur de référence des systèmes
\unix{}; c'est en quelque sorte le « dénominateur commun » des
éditeurs de texte dans la mesure où la majorité des systèmes \unix{}
possède au moins cet éditeur. C'est une des raisons pour lesquelles il
est bon de connaître le principe de son fonctionnement. Le concept le
plus important de \com{vi} est qu'il fonctionne selon deux modes :
\begin{description}
\item[Mode commande :] dans ce mode on peut passer des ordres
  d'édition à \com{vi} (effacement d'une ligne, déplacement du
  curseur, etc.).
\item[Mode insertion :] dans ce mode on peut saisir du texte.
\end{description}
Ce principe quelque peu archaïque\footnote{Ne pas taper svp. Je
  m'adresse aux djeuns qui ne connaissent que des éditeurs où il y a
  de jolis onglets/boutons/menus/icones/...\label{note-archaisme}} peut surprendre au
premier abord, c'est pourquoi nous avons dressé une liste des «
pourquoi » utiliser \com{vi} :
\begin{itemize}
\item parce que dans certaines situations, seul \com{vi} est
  disponible : par exemple lorsqu'on se connecte sur une machine
  distante pour modifier un fichier  ;
\item parce que c'est « puissant », en effet derrière un aspect
  simpliste\footnote{cf. note \ref{note-archaisme}.} et
  rudimentaire\footnote{cf. note \ref{note-archaisme}.} se cache une
  multitude de fonctionnalités surprenantes pour l'édition de texte ;
\item parce que c'est « léger », donc le lancement est très rapide, et
  peu de ressources mémoire ou calcul sont grevées ;
\item et enfin parce que ça fait snob \texttt{;-)}\footnote{Parmi les
    querelles de clochers du monde \unix, le débat \soft{Emacs} \textit{versus}
    \soft{vi} est très célèbre. Cette remarque douteuse n'arrange 
    d'ailleurs pas les choses.\label{note-provocation}}
\end{itemize}
Après cette introduction, voici quelques commandes de \com{vi} à
connaître, ces commandes suffisent à survivre dans la majorité des cas
:
\newenvironment{vicom}{%
  \begin{list}{}{%
      \setlength{\listparindent}{5pt}%
      \setlength{\labelwidth}{2.4cm}%
      \setlength{\itemindent}{0pt}%
      \setlength{\leftmargin}{\labelwidth+\labelsep}%
      \renewcommand{\makelabel}[1]{%
        \fbox{\texttt{##1}}\hfil}}}{\end{list}}
\begin{vicom}
  \item[i] passe en mode insertion (on peut alors « taper » du texte) ;
  \item[ESC] revient en mode commande (quitte le mode insertion) ;
  \item[:w] sauve le fichier ;
  \item[:q] quitte vi. Cette commande et la précédente peuvent être
    utilisées en même temps (\texttt{:wq}) et dans le cas où l'on doit
    forcer la sauvegarde ou la sortie il est nécessaire d'ajouter
    un~\texttt{!},  par exemple (\texttt{:q!}), pour quitter \soft{vi}
    sans sauver même si le fichier a été modifié ;
  \item[dd \textrm{ou} \comarg{n} dd] efface une ou \comarg{n} lignes ;
  \item[a] passe en mode insertion après le curseur ;
  \item[\^{} \textrm{ou} \$] va en début ou fin de ligne (ces deux
    commandes rappellent la syntaxe des expressions régulières) ;
  \item[/ \comarg{motif}] cherche la chaîne \comarg{motif} dans le texte ;
  \item[n] cherche l'occurrence suivante ;
  \item[.] répète la dernière action ;
  \item[cw \comarg{texte} ESC] remplace par \comarg{texte} la portion
    comprise entre le curseur et la fin du mot courant (\emph{change word}) ;
  \item[w \textrm{ou} b] avance ou recule d'un mot ;
  \item[o \textrm{ou} O] insère une ligne vierge et commence l'insertion en
    dessous ou au dessus du curseur ;
  \item[Y \textrm{ou} \comarg{n} Y] copie une ou \comarg{n} lignes (\emph{yank})
  \item[p \textrm{ou} P] colle le texte copié (ou coupé) par n'importe
    quelle commande qui copie (par exemple \texttt{Y}) ou qui coupe
    (par exemple \texttt{d}) en dessous ou au dessus de curseur ;
\end{vicom}
Voici un exemple de « rechercher/remplacer » dans
\com{vi}\footnote{Accrochez-vous...} :
\begin{shellcom}
  ¢usercom«vi bidule»
  ...
\end{shellcom}
Puis une fois dans l'éditeur taper les commandes suivantes pour
remplacer la chaîne « \texttt{machin} » par la chaîne « \texttt{chose} » :
\begin{enumerate}\ttfamily
\newcommand{\commentaire}[1]{\quad\leftarrowfill\quad\textrm{#1}}
\item /machin \toucheEntree{}  \commentaire{cherche la première occurrence}
\item cw chose \toucheEscape{} \commentaire{la remplace}
\item n                  \commentaire{cherche la suivante}
\item . \commentaire{la remplace à nouveau}
\item \textrm{répéter à partir de 3 tant que c'est nécessaire.}
\end{enumerate}
Le même remplacment peut se faire en mode commande en tapant :
\begin{verbatim}
  :%s/machin/chose/g
\end{verbatim}
\begin{note}
  Sur certains systèmes, le \soft{vi} disponible est \soft{vim} pour
  \soft{vi} \anglais{improved} (soit \soft{vi} « amélioré », ce qui en
  dit long sur l'état du premier\footnote{cf. note
    \ref{note-provocation}.}). Cette version est moins légère que la
  version originale mais apporte beaucoup de fonctionnalités et des
  facilités pour sa configuration.
\end{note}


%----------------------------------------------------------------------
%
% EMACS
%
%----------------------------------------------------------------------
\section[Avec Emacs]{Avec Emacs\footnotemark}
\footnotetext{Cette section est beaucoup plus longue que celle
  consacrée à l'éditeur \soft{vi}. Je suis un utilisateur quotidien et
  enthousiaste d'\soft{Emacs}, c'est pourquoi de manière totalement
  subjective et partiale, je m'étendrais quelque peu sur le sujet...}

\label{sec-conf-emacs}

Présenter \emacs{} en quelques pages est une tâche difficile.
Donner envie au lecteur d'utiliser ce logiciel extraordinaire en est
une autre. La première chose que l'on peut dire au sujet de cet «
éditeur de texte à tout faire » est que son nom est une contraction de
\emph{Editing MACroS} et que son origine remonte à 1976 date à laquelle
Richard M. \textsc{Stallman}, fondateur du projet GNU, commença le
développement d'\emacs{}.

\emacs{} fait partie des « stars » des logiciels libres, dans le sens
où c'est sans doute un modèle de logiciel \emph{ouvert}. À l'instar de
\LaTeX{}, les utilisateurs enthousiastes ont montré que grâce à cette
ouverture on pouvait ajouter de nombreuses fonctionnalités à ce
logiciel fascinant. \emacs{} est essentiellement utilisé pour les
facilités qu'il apporte à l'édition de fichier source au sens large du
terme ; l'auteur ---~qui en a une expérience somme toute assez
maigre~--- a pu éditer les fichiers suivants : scripts shell, langage C,
C++, Lisp, Pascal, Perl, PostScript, script Matlab, fichiers \LaTeX{}
et HTML, des Makefiles, script de Persistence of Vision, et tout ceci
en bénéficiant de l'insertion de commentaires, de l'indentation
automatique et de la mise en évidence des mots clefs en couleur,
entre autres choses. Mais bien que son rôle premier soit l'édition de
fichiers texte, il est aussi capable de jouer aux tours de hanoï
(\texttt{M-x hanoi}), au morpion (\texttt{M-x gomoku}), à Tétris
(\texttt{M-x tetris}), de vous psychanalyser (\texttt{M-x doctor}), de
lire les mails et les news, de transférer des fichiers par ftp, de
compulser un calendrier (\texttt{M-x calendar}) permettant notamment
de savoir que la date du jour (4 juillet 2000) correspondant au
septidi de Messidor de l'année~209 de la Révolution française, éditer
des fichiers en hexadécimal (\texttt{M-x hexl-mode}), j'en passe et
des pires...


Cette section est une introduction aux concepts fondamentaux d'\emacs{}
ainsi qu'aux commandes à connaître pour y prendre goût. Nous donnons
en fin de ce paragraphe quelques idées pour chercher de l'aide pour
les explorations futures.

\subsection{Concepts de base}

\begin{note}
  Pour commencer, il est important de noter qu'\emacs{} a la
  particularité de pouvoir s'exécuter aussi bien en mode texte dans un
  terminal qu'en mode graphique (ou fenêtre) en s'appuyant sur un
  serveur~\soft{X}. Dans l'un ou l'autre des modes, on pourra utiliser
  les commandes présentées dans cette section.
\end{note}
\label{sec-emacs-base}
\begin{figure}[htbp]
  \ifframabookversion
  \includegraphics[angle=90, height=18cm]{emacs-X}
  \else
  \begin{changemargin}{-1.7cm}{-2.5cm}
    \begin{center}
      \includegraphics[width=\linewidth]{emacs-X}
    \end{center}
  \end{changemargin}
  \fi
\caption{Emacs dans un environnement graphique}
  \label{fig-emacs-X}  
\end{figure}

Les objets graphiques qui composent l'éditeur \emacs{} sont les
suivants :
\begin{description}
\item[Frame :] \emacs{} est multi-fenêtre, et nomme chacune d'elles
  \jargon{frame}\footnote{Nous conserverons ici à dessein le jargon
    anglais d'\emacs{} en utilisant une fonte
    \jargon{particulière}.}.  La figure~\ref{fig-emacs-X} montre une
  session avec deux \jargon{frames} ;
\item[Window :] les \jargon{frames} contiennent une ou plusieurs
  \jargon{windows}. La figure~\ref{fig-emacs-X} montre trois
  \jargon{windows} : une dans la frame de gauche et deux dans la frame
  de droite ;
\item[Buffer :] les données qui sont affichées dans les \jargon{windows}
  sont des zones mémoires appelées \jargon{buffers}. Ces zones contiennent
  du texte à éditer. Un \jargon{buffer} peut être sauvegardé sur disque,
  créé à partir d'un fichier, etc. En fait sous \emacs{}, « tout
  est buffer » ;
\item[Minibuffer :] buffer particulier composé d'une ligne tout en bas
  de chaque \jargon{frame}. C'est dans cette zone qu'a lieu la majeure
  partie des interactions avec l'utilisateur ;
\item[Status bar :] ou barre d'état, située en bas de chaque
  \jargon{window}, elle indique différentes informations ; ici : le nom
  du fichier, l'heure, la position du curseur, le mode
  d'édition (cf. plus bas), etc. :
  \begin{center}
    \includegraphics[width=.8\textwidth]{emacs-etat}
  \end{center}
\item[Menu :] chaque \jargon{frame} dispose d'un menu permettant de
  lancer diverses fonctions.
\end{description}

Les deux autres concepts fondamentaux sont les suivants :
\begin{description}
\index{commande!emacs}
\index{emacs!commande}
\item[Commandes :] toute action exécutée dans l'éditeur, quelle
  qu'elle soit, est le résultat de l'interprétation d'une fonction
  Lisp\footnote{Le Lisp --- dont le nom vient de l'anglais
    \anglais{list processing} --- est le langage utilisé pour
    concevoir les différentes extensions d'\soft{Emacs}. La
    configuration de celui-ci demande d'ailleurs de connaître les
    rudiments de ce langage.}. Cette fonction peut être appelée par
  son nom, par une combinaison de touches, ou par le biais du menu. Il
  faut noter que toutes les fonctions n'ont pas nécessairement de
  combinaison de touches ou d'entrée dans le menu ;
\item[Mode :] chaque buffer est « piloté » par \emacs{} dans un
\index{mode!emacs}%
\index{emacs!mode}%
  \emph{mode} particulier. Le mode en question correspond à la manière
  dont les commandes vont être interprétées. À titre d'exemple, les
  fonctions d'indentation, de mise en couleur, de mise en commentaire,
  sont interprétées différemment selon qu'\emacs{} est en mode
  \LaTeX, ou en mode C pour ne citer que ceux-là.
\end{description}


\subsection{Notations utilisées}
\label{sec-emacs-notation}

Dans les diverses documentations que l'on trouve traitant d'\emacs{},
et dans \soft{emacs} lui-même, on retrouve les notations suivantes au
sujet des combinaisons de touches :
\begin{itemize}
\item \texttt{C-}\comarg{t} : pour une pression sur \toucheCtrl{} et la
  touche \comarg{t} ;
\item \texttt{M-}\comarg{t} : désigne l'utilisation de la touche «
  Meta » : 
  \begin{itemize}
  \item une pression sur \toucheAlt{} et la touche \comarg{t}, ou à
    défaut :
  \item une pression sur \toucheEscape{} \textbf{puis} la touche
    \comarg{t}.
  \end{itemize}
\item \texttt{ESC} : la touche \toucheEscape{} ;
\item \texttt{RET} : la touche \toucheEntree{} ;
\item \texttt{SPC} : la barre d'espacement ;
\end{itemize}
Ainsi : 
\begin{itemize}
\item \texttt{M-x} signifie \toucheAlt{} et \touche{x} ou
  \toucheEscape{} puis \touche{x} ;
\item \texttt{C-x C-c} signifie \toucheCtrl{} et \touche{x} et
  \toucheCtrl{} et \touche{c}, que l'on peut obtenir en maintenant
  \toucheCtrl{} enfoncée tout en tapant dans l'ordre \touche{x} puis
  \touche{c}.
\end{itemize}


\subsection{Appeler une commande}
\label{sec-emacs-cmd}

À partir de l'exemple de la commande d'ouverture d'un fichier, nous
allons passer en revue quelques-unes des notions importantes
d'\emacs{} concernant l'appel des commandes.
On peut appeler la commande d'ouverture de fichier
(\texttt{find-file}) de quatre manières :
\begin{itemize}
\item par son nom à l'aide de la combinaison : \texttt{M-x find-file}
  ;
\item à l'aide de la combinaison  : \texttt{C-x C-f} ;
\item à l'aide d'un éventuel raccourci clavier défini sur votre
  installation ;
\item à l'aide de l'entrée \texttt{File/Open File} dans la barre de menu.
\end{itemize}

\subsubsection{Le minibuffer}
\index{minibuffer!emacs}
\index{emacs!minibuffer}

Dans les trois cas le lancement de cette commande donne le focus au
\jargon{minibuffer}, et l'utilisateur doit entrer le nom du fichier
qu'il veut ouvrir ou un nom quelconque pour créer un nouveau buffer.
\begin{flushleft}
  \quad\texttt{M-x find-file} \toucheEntree{} \texttt{monfichier.txt} \toucheEntree{}  
\end{flushleft}

Dans le minibuffer la touche « Espace » (\toucheEspace{}) ou « Tab »
(\toucheTab{}) permet de compléter automatiquement un nom de commande
ou un nom de fichier. En cas d'équivoque une pression sur ces touches
crée une nouvelle \jargon{window} avec un \jargon{buffer} contenant
les différentes alternatives possibles à la complétion.  Par exemple
si on tape :
\begin{flushleft}
  \texttt{M-x find} \toucheEspace{}
\end{flushleft}
on fait apparaître une fenêtre contenant le buffer suivant :
\begin{footnotesize}
\begin{verbatim}
  Click mouse-2 on a completion to select it.
  In this buffer, type RET to select the completion near point.

  Possible completions are:
  find-alternate-file                find-alternate-file-other-window
  find-dired                         find-file
  find-file-at-point                 find-file-literally
  find-file-other-frame              find-file-other-window
  find-file-read-only                find-file-read-only-other-frame
  find-file-read-only-other-window   find-function
  find-function-at-point             find-function-on-key
  find-function-other-frame          find-function-other-window
  find-grep-dired                    find-name-dired
  find-tag                           find-tag-noselect
  find-tag-other-frame               find-tag-other-window
  find-tag-regexp                    find-variable
  find-variable-at-point             find-variable-other-frame
  find-variable-other-window
\end{verbatim}
\end{footnotesize}
qui montre donc toutes les commandes dont le nom commence par
« \texttt{find} ». Donc en tapant les deux premiers caractères :
\begin{flushleft}
  \texttt{M-x find} \toucheEspace{}\texttt{fi}\toucheEspace{}\toucheEntree{}
\end{flushleft}
\index{complétion!emacs} \index{emacs!complétion} on complète jusqu'à
\texttt{find-file} et il est alors possible de saisir le nom du
fichier que l'on veut charger. On notera que la complétion automatique
fonctionne aussi sur les noms de fichiers. Enfin, la fenêtre
d'information vous indique également que vous pouvez utiliser le
bouton du milieu de votre souris\footnote{Si votre souris n'a qu'un
  bouton, c'est que vous avez un Machinetoque, changer alors
  d'ordinateur ; si votre souris n'a que deux boutons, vous vous êtes
  fait avoir par le protocole « micro logiciel », changez de souris.}
pour choisir le fichier parmi la sélection.


\subsubsection{Stop !}

Pour interrompre une action entreprise dans le \jargon{minibuffer}, il
faut utiliser la combinaison \texttt{C-g} qui appelle la fonction
\texttt{keyboard-quit}.  Cette fonction est également utile pour
interrompre l'exécution d'une commande.
\begin{attention}
  Lorsqu'on débute sous \emacs{}, on a tendance à « laisser traîner » son
  curseur dans le \jargon{minibuffer} ; ce qui peut entraîner un comportement
  étrange de l'éditeur qui vous narguera par des :
  \begin{center}\ttfamily
    Command attempted to use minibuffer while in minibuffer
  \end{center}
  \continuenota dans ce cas une ou deux pressions sur \texttt{C-g}
  remet \emacs{} dans le droit chemin.
\end{attention}


\subsubsection{Historique}
\index{historique!emacs}
\index{emacs!historique}

La combinaison \texttt{C-x ESC ESC} rappelle la dernière commande
exécutée. Les touches \toucheUp{} et
\toucheDown{} dans le \jargon{minibuffer} permettent alors de
choisir et éventuellement modifier l'une des dernières commandes
exécutées :
\begin{center}\ttfamily
  Redo: (find-file "\~{}/tcqvatvs/guide/chap-configurer.tex" 1)
\end{center}
cet historique permet en outre d'avoir une première idée de la syntaxe
d'appel des commandes Lisp.



\subsubsection{Arguments et répétition}
\index{emacs!arguments}
\index{arguments!dans emacs}
Certaines commandes d'\emacs{} attendent un argument numérique. On
peut passer cet argument en préfixant l'appel de la commande par
\texttt{C-u} \marg{n}, pour passer la valeur \marg{n}. Si la commande
en question n'attend pas d'argument elle sera simplement exécutée
\marg{n} fois. Par exemple la séquence : \texttt{C-u 24 a}, insère :
\begin{flushleft}\ttfamily
  aaaaaaaaaaaaaaaaaaaaaaaa
\end{flushleft}
dans le \jargon{buffer} courant. 

\subsection{Manipuler les objets d'Emacs}
\label{sec-emacs-obj}

Les objets d'\emacs ---~\jargon{frame}, \jargon{window},
\jargon{buffer}, etc.~--- peuvent être manipulés via un certain
nombre de fonctions qu'il est souhaitable de connaître.


\paragraph{Frame} les tâches courantes autour des \jargon{frames} sont la
création et la destruction. On crée une nouvelle \jargon{frame} avec :
\index{emacs!frame}
\index{frame d'emacs}
\begin{itemize}
\item \texttt{C-x 5 2} ou :
\item \texttt{M-x make-frame-command}
\item par le menu \texttt{File/Make New Frame} 
\end{itemize}
on détruit celle sur laquelle on se trouve avec :
\begin{itemize}
\item \texttt{C-x 5 0} ou :
\item \texttt{M-x delete-frame}
\item en cliquant sauvagement sur le bouton « delete window » de son
  gestionnaire de fenêtres préféré.
\end{itemize}
\begin{attention}
  Il est bien évident que les \jargon{frames} d'\emacs{} ne sont
  disponibles que dans un environnement permettant le «
  multi-fenêtrage » comme X window...
\end{attention}


\paragraph{Window} on peut créer de nouvelles fenêtres dans une
  \jargon{frame} à partir de la première :
\index{emacs!window}
\index{window d'emacs}
  \begin{itemize}
  \item \texttt{C-x 3} « divise horizontalement » la \jargon{window}
    actuelle ;
  \item \texttt{C-x 2} « divise verticalement » la \jargon{window}
    actuelle ;
  \item \texttt{C-x 1} ne conserve que la \jargon{window} contenant le
    curseur
  \end{itemize}
  ces combinaisons de touches correspondent respectivement aux
  fonctions :
  \begin{itemize}
  \item \texttt{M-x split-window-horizontaly} ;
  \item  \texttt{M-x split-window-verticaly} ;
  \item  \texttt{M-x delete-other-windows}.
\end{itemize}
Il est particulièrement intéressant de noter qu'après une série de
\texttt{C-x 2} et \texttt{C-x 3} ---~dans cet ordre~--- on obtient un
\emph{quad tree} à la mode \emacs{} (voir
figure~\ref{fig-emacs-quad-tree}).
\begin{figure}[tb]
  \begin{center}
    \includegraphics[width=\ifframabookversion.7\textwidth\else.5\textwidth\fi]{%
      emacs-quadtree}
    \caption{The \emacs{} quad tree}
    \label{fig-emacs-quad-tree}
  \end{center}
\end{figure}
Mais ne nous égarons pas dans des considérations douteuses, puisqu'on
peut aussi redimensionner une fenêtre coupée en deux horizontalement
(après un \texttt{C-x 2}) à l'aide de :
\begin{itemize}
\item \texttt{C-x \^} ou \texttt{M-x enlarge-window} ;
\item en déplaçant la \emph{status bar} à l'aide du bouton du milieu
  de votre souris.
\end{itemize}


\paragraph{Buffer} on peut « tuer » un buffer, lorsqu'on a fini
d'éditer un fichier, ou simplement parce que le buffer en question
n'est plus utile lors de la session, avec :
\index{emacs!buffer}
\index{buffer d'emacs}
\begin{itemize}
\item \texttt{C-x C-k} ou \item \texttt{M-x kill-buffer}, ou :
\item le menu \texttt{File/Kill Current Buffer}
\end{itemize}
Notez bien que si le buffer a été modifié depuis la dernière
\voir{sec-emacs-fichiers}{sauvegarde}, vous devrez répondre à
quelques questions qui vous seront gentiment posées par le truchement
du \jargon{minibuffer}. Il est également possible d'avoir la liste de
tous les buffers ouverts depuis le début de la session avec :
\begin{itemize}
\item \texttt{C-x C-b} ou \texttt{M-x list-buffers}, ou :
\item par le menu \texttt{Buffers/List All Buffers}
\end{itemize}
Une partie de cette liste est visible dans les premières entrées du
menu \texttt{Buffers}.

\subsection{Les tâches basiques}


\subsubsection{Se déplacer / effacer}
\index{emacs!effacer}
\index{effacer dans emacs}
\index{emacs!se déplacer}
\index{deplacer@{se déplacer} dans emacs}

Malgré ce que dit le tutorial d'\emacs{}, qui préconise l'usage des
combinaisons (\texttt{C-f}, \texttt{C-b}, \texttt{C-n} et
\texttt{C-b}) pour déplacer le curseur, il semble raisonnable de
penser qu'en ce début de siècle, on peut utiliser les flèches du
clavier. Il est cependant intéressant de noter que ces raccourcis
existent ---~ils sont facilement mémorisables : \texttt{f}orward,
\texttt{b}ackward, \texttt{n}ext, \texttt{p}revious~--- pour les
utiliser en cas d'urgence.  Les autres combinaisons utiles pour se
déplacer sont :
\begin{itemize}
\item \texttt{C-e}/\texttt{C-a} va en fin/début de ligne ;
\item \texttt{C-}\toucheLeft{} et
  \texttt{C-}\toucheRight{} va un mot vers la
  gauche et vers la droite respectivement (on pourra également
  utiliser \texttt{M-f} (\anglais{forward}) et \texttt{M-b}
  (\anglais{backward}) ;
\item \texttt{C-}\toucheUp{} et
  \texttt{C-}\toucheDown{} va un paragraphe
  vers le haut et vers le bas respectivement ;
\item \texttt{C-l} centre verticalement le curseur au milieu de la
  \jargon{window} courante en déplaçant le texte le cas échéant ;
\item \texttt{M-<} et \texttt{M->} permettent d'aller ou début et à la
  fin du buffer, ces fonctions sont également disponibles avec les
  touches \toucheHome{} et \toucheEnd{} si votre clavier en
  dispose ;
\end{itemize}
%% \begin{nota}
%%   Le gestionnaire de fenêtres que vous utilisez peut lui aussi définir
%%   ces raccourcis, dans ces cas celles d'\emacs{} ne sont pas
%%   prioritaires. C'est le cas du gestionnaire de fenêtre \soft{fvwm}
%%   qui utilise les touches \texttt{C-} « flèches » pour passer d'un
%%   bureau virtuel à un autre.
%% \end{nota}

Pour effacer du texte, les touches « delete » et « backspace » ont
l'effet escompté. On peut en outre effacer à partir du curseur jusqu'à
la fin de la ligne avec \texttt{C-k}. Cette opération s'apparente à un
« couper » puisque le texte effacé est stocké pour éventuellement être
collé. Notez également que \texttt{M-}\toucheBackspace{} efface le
mot avant le curseur.


\subsubsection{Sélectionner}
\index{emacs!sélectionner}
\index{sélectionner dans emacs}

Pour sélectionner une zone, il suffit de se placer au début de la zone
que l'on veut traiter et appuyer sur \texttt{C-SPC}. En fonction de la
configuration d'\emacs{}, lorsqu'on déplace le curseur, on voit
apparaître la zone sélectionnée en « inverse vidéo ». La souris permet
également de sélectionner une zone, bien entendu.

\subsubsection{Copier, Couper,  Coller...}
\label{sec-emacs-cut-and-paste}
\index{emacs!copier/coller}
\index{copier/coller dans emacs}

Une fois la zone sélectionnée, on peut procéder aux trois opérations
classiques :
\begin{itemize}
\item \texttt{C-w} : couper ;
\item \texttt{C-y} : coller ;
\item \texttt{M-w} : copier.
\end{itemize}
Le « coller » d'\emacs{} apporte beaucoup de souplesse, puisqu'une
fois la séquence \texttt{C-y} entrée, on peut éventuellement choisir
le texte à coller grâce à la combinaison \texttt{M-y} qui permet de
choisir une selection parmi les zones copiées ou coupées jusqu'à
présent.


\subsubsection{Défaire, refaire}
\index{emacs!undo/redo}
\index{undo/redo dans emacs}
\index{annuler dans emacs}

\emacs{} dispose d'un « undo » permettant de « remonter » jusqu'aux
premières modifications apportées lors du démarrage de la session. Le
« undo » s'obtient grâce à la combinaison \texttt{C-\_} ou \texttt{C-x
  u}\footnote{le premier est plus simple sur un clavier français.}.

Une propriété intéressante du « undo » d'\emacs{} est qu'il peut
aisément se transformer en « redo ». Pour cela il suffit de taper le
fameux \texttt{C-g}. Si on peut voir le « undo » comme une « remontée
vers le passé », un \texttt{C-g} permet de faire en sorte que
l'utilisation du \texttt{C-\_} suivant « revienne vers le futur » :
\begin{center}
  \begin{tabular}{|l|l|l|}
    \hline
                   & \texttt{abcdef}   &\\
    \texttt{C-\_}  & \texttt{abcde}    & undo \\
    \texttt{C-\_}  & \texttt{abcd}     & undo \\
    \texttt{C-g}   & \texttt{abcd}     & glurps !\\
    \texttt{C-\_}  & \texttt{abcde}    & redo \\ \hline
  \end{tabular}
\end{center}

\subsubsection{Manipulation de fichiers}
\label{sec-emacs-fichiers}

Les trois opérations qui sont indubitablement utiles sont :
\begin{description}
\item[La sauvegarde :] qui sauve le contenu du \jargon{buffer} dans un
  fichier est obtenue grâce à :
\index{emacs!sauver}
\index{sauver dans emacs}
  \begin{itemize}
  \item \texttt{C-x C-s} ou \texttt{M-x save-buffer}, ou :
  \item menu \texttt{File/Save Buffer}.
  \end{itemize}
\item[Le chargement :] permet d'insérer le contenu d'un fichier dans un
  \jargon{buffer} tout neuf. Si le fichier n'existe pas, un
  \jargon{buffer} est créé portant le nom spécifié et la sauvegarde
  suivante créera le fichier sur le disque. Nous avons vu précédemment que
  le chargement pouvait être réalisé grâce à :
  \begin{itemize}
  \item la commande \texttt{M-x find-file}, ou
  \item le raccourci \texttt{C-x C-f}, ou
  \item le menu \texttt{File/Open File}.
  \end{itemize}
\index{emacs!charger}
\index{charger dans emacs}
\item[La mise à jour :] il arrive que le fichier dont on a un buffer
  dans \emacs{} soit modifié par une source extérieure (un autre
  programme).  Dans ce cas la « copie » dont on dispose dans le
  \jargon{buffer} n'est plus à jour par rapport au contenu du fichier,
  il faut donc utiliser la commande :
  \begin{itemize}
  \item \texttt{M-x revert-buffer} ou : 
  \item menu \texttt{File/Revert Buffer}
  \end{itemize}
  qui recharge le contenu du fichier dans le buffer courant. Dans
  cette situation, \emacs{} avertit l'utilisateur par plusieurs
  messages dans le \jargon{minibuffer}.
\end{description}
D'autres opérations peuvent être utiles à connaître comme le célèbre «
sauver sous » (\texttt{C-x C-w} ou \texttt{M-x write-file}) qui sauve
le buffer dans un fichier portant un autre nom. Est également
intéressante \texttt{M-x
  insert-file} (ou \texttt{C-x i}) qui insère à l'endroit où est le
curseur le contenu d'un fichier.


\subsubsection{Rechercher / Remplacer}
\label{sec-emacs-search}
\index{emacs!rechercher/remplacer}
\index{rechercher remplacer dans emacs}

Voici les deux fonctions à connaître pour rechercher des chaînes de
caractères dans un \jargon{buffer} et éventuellement les remplacer.

\paragraph{Juste chercher...}
La première est la fonction \texttt{M-x isearch-forward} dont
un raccourci pratique est \texttt{C-s}.  Dès que la combinaison
\texttt{C-s} est pressée, \emacs{} attend par l'intermédiaire du
\jargon{minibuffer} les lettres composant la chaîne de caractères à
rechercher. À chaque lettre entrée, le curseur se déplace sur la
première partie du texte correspondant à la chaîne formée jusque là.
On a alors plusieurs alternatives :
\begin{itemize}
\item la chaîne est introuvable (message \texttt{Failing I-search}) ;
\item la chaîne a été trouvée : en pressant à nouveau sur \texttt{C-s}
  le curseur se positionne sur l'occurrence suivante ;
\item si on presse \texttt{C-g} le curseur se repositionne là où il se
  trouvait au début de la recherche et celle-ci s'arrête ;
\item si on presse \toucheEntree{}, le curseur reste dans sa position
  actuelle et la recherche s'arrête.
\end{itemize}
Le pendant de \texttt{C-s} est \texttt{C-r} qui effectue le même
travail, mais en cherchant « vers le haut » (\texttt{M-x
  isearch-backward}). On peut d'ailleurs passer du « backward » au «
forward » sans problème lors d'une recherche.

\paragraph{Chercher et remplacer}

La fonction \texttt{M-x query-replace}, dont le raccourci est
\texttt{M-\%}, permet, comme son nom l'indique, de chercher une chaîne
et de la remplacer par une autre. Le \jargon{minibuffer} vous
demandera donc deux chaînes pour effectuer les remplacements. Si une
chaîne est trouvée, \emacs{} vous demandera ce que vous désirez faire,
vous pourrez alors répondre :
\begin{itemize}
\item \texttt{y} pour remplacer ;
\item \texttt{b} pour ne pas remplacer ;
\item \texttt{!} pour remplacer partout ;
\item \texttt{q} pour quitter ;
\item \texttt{h} pour voir les autres possibilités !
\end{itemize}
Une particularité de cette commande est qu'elle peut agir uniquement
sur une zone si elle est préalablement sélectionnée. Notez aussi
qu'\emacs{} est généralement configuré pour préserver les majuscules dans le
remplacement, c'est-à-dire que dans un texte où l'on demande de remplacer
«\texttt{a}« par~«\texttt{b}», «\texttt{A}» sera remplacé
par~«\texttt{B}».


Il existe une version améliorée de la commande \texttt{M-x
  search-replace} : la commande \texttt{query-replace-regexp} (dont le
raccourci est \texttt{M-C-\%}) qui permet de chercher et remplacer des
chaînes spécifiées à partir \voir{sec-regexp}{d'expressions
  régulières}. Par exemple :
\begin{flushleft}
\texttt{M-C-\%} \toucheEntree{} \verb+^b.*e$+ \toucheEntree{}
  \texttt{hoplà}   \toucheEntree{}  %$
\end{flushleft}
dans le texte de gauche, donne le texte de droite :
\begin{center}\ttfamily
  \begin{tabular}{l|l}
    bcde         & hoplà\\
    bbd          & bbd\\
    cde          & cde\\
    bqmlksdjfe   & hoplà
  \end{tabular}
\end{center}
Nous rappelons que \verb+^b.*e$+ %$
signifie : une ligne qui commence par~«\texttt{b}» suivi d'une série
de caractères et finissant par~«\texttt{e}».

\subsubsection{Indenter / Commenter}
\label{sec-emacs-comment}
\index{emacs!commenter}
\index{commenter dans emacs}

Un des plaisirs que l'on peut tirer de l'utilisation de ce gros
patapouf d'\emacs{}\footnote{Des mauvaises langues disent que
  \soft{Emacs} est l'acronyme de « Emacs makes a computer slow ».} est
l'indentation automatique des sources et l'insertion de
commentaires\footnote{Notez bien que d'autres éditeurs comme
  \soft{vim} pour ne pas le citer, sont également capables de ce genre
  de prouesses.}.  Il n'y a rien de difficile à apprendre dans ce
paragraphe puisque tout est fait automatiquement en fonction du
\emph{mode} utilisé. Prenons l'exemple d'un fichier C++. À chaque
pression sur la touche \toucheTab{} le curseur se mettra à la « bonne
place », c'est-à-dire en fonction de l'imbrication des diverses
boucles et autres blocs. Si le curseur ne se met pas à une position
correcte c'est que le source comporte une erreur de syntaxe.  Il y a
trois commandes à connaître :
\begin{itemize}
\item \texttt{M-x indent-region} qui indente la zone sélectionnée en
  fonction du mode utilisé ;
\item \texttt{M-x comment-region} qui commente la région sélectionnée
  en fonction de la syntaxe du langage correspondant au mode d'\emacs{}
  pour le buffer ;
\item \texttt{C-u M-x comment-region} qui retire les commentaires de
  la zone sélectionnée.
\end{itemize}
\begin{figure}[htbp]
  \begin{margefigure}{1cm}{2cm}
  \begin{center}
    \subfloat[]{%
      \includegraphics[width=.55\textwidth]{emacs-indent-before}
      \label{fig-emacs-indent-before}}
    \subfloat[]{%
      \includegraphics[width=.55\textwidth]{emacs-indent-after}
      \label{fig-emacs-indent-after}}
  \end{center}
\end{margefigure}
\caption[Commentaires et indentation automatique]{%
  Commentaires et indentation automatique : pour passer de la
  figure~(a) à la figure~(b), on a  appelé la
  fonction \texttt{M-x indent-region} après avoir sélectionné le
  buffer entier ; puis après avoir sélectionné le corps de la fonction
  \texttt{f()}, on a fait appel à la commande \texttt{M-x
    comment-region} pour commenter son code.}
  \label{fig-emacs-indent}
\end{figure}

\begin{note}
  Lorsqu'\emacs{} est en mode langage~C, on peut commenter une région
  préalablement sélectionnée avec le raccourci \texttt{C-c C-c}. Pour
  décommenter on pourra utiliser le raccourci \texttt{C-u C-c C-c}.
\end{note}

\subsection{Emacs et les Makefiles}
\label{sec-emacs-make}
\index{emacs!et les Makefiles}
\index{make@\texttt{make}!dans emacs}

La commande \texttt{M-x compile} permet d'exécuter une commande dans
un shell fils d'\emacs{}. Ainsi lorsqu'on lance cette fonction, le
\jargon{minibuffer} attend une commande à exécuter :
\begin{comsyntax}
  Compile command: make
\end{comsyntax}
On peut alors remplacer \texttt{make} par la commande de son choix,
par exemple \texttt{echo salut les coins coins} et presser la touche
\toucheEntree{}. La commande est alors exécutée dans un shell et le
résultat est affiché dans un \jargon{buffer} nommé
\texttt{*compilation*} :
\begin{verbatim}
    cd /home/vincent/LaTeX/tcqvatvs/guide/
    echo salut les coinscoins
    salut les coinscoins

    Compilation finished at Wed Jul  5 23:17:32
\end{verbatim}
Ce qui n'est certes pas passionnant. Cependant si en lieu et place
d'un bonjour aux canards, on invoque \soft{make}, cela devient plus
intéressant. En effet, en éditant un fichier C (par exemple), on peut
lancer la compilation dans \emacs{}. L'éditeur devient alors un
environnement de développement qui se suffit à lui-même. Le buffer
\texttt{*compilation*} peut en effet être utilisé pour cerner les
erreurs de compilation.
\begin{figure}[bt]
  \begin{margefigure}{1cm}{2cm}
  \begin{center}
    \subfloat[]{\includegraphics[width=.55\textwidth]{emacs-make}}
    \subfloat[]{\includegraphics[width=.55\textwidth]{emacs-make-error}%
      \label{fig-emacs-make-error}}
  \end{center}
\end{margefigure}
\caption{Compilation dans \emacs{}}
  \label{fig-emacs-make}
\end{figure} 
La figure~\ref{fig-emacs-make-error} montre le contenu de ce
\jargon{buffer} lorsque le source contient une erreur. Un clic de
souris avec le bouton du milieu sur la ligne contenant l'erreur
positionne le curseur à la ligne du programme source correspondant.

\subsection{Personnaliser}
\label{sec-emacs-perso}
\index{emacs!personnaliser|(}
\index{personnaliser emacs|(}


\subsubsection{Macros}
\index{emacs!macros}
\index{macros d'emacs}

Si on reprend l'étymologie du mot \emacs{} on pense à « macro ». Les
macros sont des séquences de touches que l'utilisateur peut
enregistrer et réutiliser plus tard. Le principe d'enregistrement
d'une macro est le suivant :
\begin{enumerate}
\item commencer l'enregistrement ;
\item tapoter sur le clavier la séquence de touches qu'on veut
  mémoriser ;
\item finir l'enregistrement ;
\item donner un nom à la macro définie ;
\item stocker éventuellement le « code » de la macro.
\end{enumerate}
Le commencement et la fin de l'enregistrement sont stipulés par les
commandes \texttt{M-x start-kbd-macro} et \texttt{M-x end-kbd-macro}
dont les raccourcis élégants sont « \texttt{C-x (} » et « \texttt{C-x
  )} ».  Toute touche tapée entre le début et la fin de
l'enregistrement est stockée dans la macro courante. On peut ensuite
donner un nom à la macro définie avec \texttt{M-x
  name-last-kbd-macro}, et enfin insérer le code Lisp de cette macro
dans le fichier de démarrage à l'aide de la commande \texttt{M-x
  insert-named-kbd-macro}.  Voyons un exemple : c'est une pratique
courante en langage C, d'insérer dans les fichiers include la
directive de compilation suivante :
\begin{verbatim}
    #ifndef __BIDULE_H
    #define __BIDULE_H
\end{verbatim}
\begin{center}
  (...contenu du fichier include...)
\end{center}
\begin{verbatim}
    #endif
\end{verbatim}
Pour éviter d'insérer systématiquement ces directives, à chaque
création d'un fichier include, on peut envisager de créer une macro de
la manière suivante :
\begin{enumerate}
\item top départ : \texttt{C-x (} \comcomment{à partir d'ici tout ce qu'on tape
  est enregistré}
\item enregistrement de la macro :
  \begin{itemize}
  \item \texttt{M-x <} \comcomment{aller au début du buffer}
  \item \verb+#ifndef ___H+ \toucheEntree{}
  \item \verb+#define ___H+ \toucheEntree{}
  \item \texttt{M-x >} \comcomment{aller à la fin du buffer}
  \item \toucheEntree{} \verb'#endif'
\end{itemize}
\item \texttt{C-x )} : fin d'enregistrement.
\item donner un nom à la macro avec \texttt{M-x name-last-kbd-macro} :
  dans le \jargon{minibuffer} on répond par exemple
  \texttt{insert-ifndef} qui est ma foi un nom très seyant pour cette
  macro.
\end{enumerate}
On peut maintenant utiliser cette macro comme une autre commande. Il
man\-que à notre exemple l'association d'une combinaison de touche à
cette macro et la sauvegarde de cette macro pour les sessions
suivantes ; c'est l'objet des paragraphes suivants.

\subsubsection{Raccourcis clavier}
\index{emacs!raccourcis}
\index{raccourcis d'emacs}

On peut associer une combinaison de touches à une fonction en utilisant
la commande \texttt{M-x global-set-key}. Cette commande demande à
l'utilisateur la combinaison puis la fonction à y associer. On pourra
par exemple associer la combinaison de touches \texttt{F5} (ou
\texttt{F10}, ou \texttt{C-x C-...})\footnote{On peut utiliser la
  combinaison \texttt{C-h k} pour vérifier si la combinaison choisie
  n'est pas déjà utilisée par \emacs.} à la fonction qui commente une
région :
\begin{flushleft}
  \texttt{M-x global-set-key }\toucheEntree{} F5 \toucheEntree{}
  \texttt{comment-region} \toucheEntree{}
\end{flushleft}


\subsubsection{Le fichier {\fontseries{m}\selectfont\texttt{.emacs}}}
\index{emacs!emacs@\texttt{.emacs}}
\index{emacs@\texttt{.emacs}}

On peut stocker des configurations personnelles ---~telles que des
raccourcis clavier par exemple~--- dans un fichier qui est chargé à
chaque lancement d'\emacs{}. Ce fichier doit porter le nom
\texttt{.emacs} et doit résider dans le répertoire privé de
l'utilisateur. La « petite » difficulté réside dans le fait que le
contenu de ce fichier doit être en Lisp.  La composition d'un fichier
\texttt{.emacs} dépasse le cadre de ce manuel\footnote{Et surtout les
  compétences de l'auteur...} c'est pourquoi nous donnerons ici
quelques possibilités :
\begin{verbatim}
  ; pour preserver les liens lors d'une sauvegarde :
  (setq backup-by-copying-when-linked t)
  ; remplace une selection par ce que l'on tape
  (delete-selection-mode t)
  ; numero de colonne
  (setq column-number-mode t)
  ; bip visible et non sonore
  (setq visible-bell t)
\end{verbatim}
Notez tout de même, qu'un moyen possible pour construire son propre
fichier \texttt{.emacs} peut consister à :
\begin{enumerate}
\item exécuter la commande que l'on veut sauvegarder dans le
  \texttt{.emacs}, par exemple  \texttt{M-x standard-display-european}
  pour afficher les caractères accentués ;
\item faire apparaître le code Lisp d'appel dans le minibuffer avec
  l'historique \texttt{C-x ESC ESC} ;
\item copier ce code dans son \texttt{.emacs} :
  \texttt{(standard-display-european nil)} en utilisant le mécanisme
  de copier/coller d'\emacs{} ;
\item recharger le \texttt{.emacs} avec la commande \texttt{M-x load-file} 
\end{enumerate}
Cette méthode est bien entendu limitée à l'ajout de fonctionnalités
simples.

\subsubsection{Francisation}
\index{emacs!francisation}
\index{francisation d'emacs}

Pour forcer \emacs{} à afficher les caractères accentués, il peut être
nécessaire de lancer la commande \texttt{M-x standard-display-european}.
Ainsi la phrase qui par défaut s'affichait comme ceci :
\begin{verbatim}
  cet apr\350s midi d'\351t\351 \340 la campagne...
\end{verbatim}
s'affichera comme cela :
\begin{verbatim}
  cet après midi d'été à la campagne...
\end{verbatim}


\subsubsection{Modes}
\index{emacs!modes}
\index{mode!emacs}

Comme on l'a entr'aperçu un peu plus haut, chaque \jargon{buffer} est
piloté par un \emph{mode} particulier qui gère l'indentation, la mise
en couleur, etc. Ce mode est indiqué dans la barre d'état.

À chaque chargement de fichier, \emacs{} se place dans un mode
d'édition particulier en fonction de l'extension du fichier.  Cette
reconnaissance peut échouer dans certains cas. On peut alors basculer
manuellement dans le mode désiré avec les commandes \texttt{M-x
  c++-mode}, \texttt{sh-mode}, \texttt{latex-mode}, etc. 

On peut également charger le mode désiré de manière automatique. Un
exemple : lors du chargement d'un fichier dont l'extension est
\texttt{.h}, le mode C est lancé ; si l'on préfère le mode C++, il
faudra insérer dans son \texttt{.emacs} :
\begin{verbatim}
   (setq auto-mode-alist 
      (cons '("\\.h\\'" . c++-mode) auto-mode-alist))
\end{verbatim}

Certains modes sont dits \emph{mineurs} par opposition aux modes
\emph{majeurs} (\emph{minor and major modes}) dans la mesure où ils
sont chargés en plus du mode majeur. C'est le cas par exemple des
modes :
\begin{itemize}
\item \texttt{M-x outline-minor-mode} qui permet d'utiliser un mode «
  plan » dans les fichiers \LaTeX{} offrant la possibilité de
  masquer certaines sections (paragraphes, sous paragraphes, etc.) ;
\item \texttt{M-x auto-fill-mode} qui permet de passer à la ligne
  automatiquement dans les \jargon{buffers} en fonction d'un nombre de
  caractères défini pour chaque ligne.
\end{itemize}
On peut charger ces modes mineurs grâces aux commandes introduites
ci-dessus, ou automatiquement en utilisant la notion de \emph{hook}.
Un hook associé à un mode donné est, entre autres, un moyen d'exécuter
des commandes lorsque le mode en question est chargé.  Les deux
lignes suivantes dans votre \texttt{.emacs} :
\begin{verbatim}
   (add-hook 'LaTeX-mode-hook 
      (function ( lambda() (auto-fill-mode))))
   (add-hook 'LaTeX-mode-hook 
      (function ( lambda() (outline-minor-mode))))
\end{verbatim}
chargent automatiquement les modes \texttt{outline} et
\texttt{auto-fill} lorsque un fichier \LaTeX{} est chargé avec
le \texttt{LaTeX-mode}.


\subsubsection{Le « bureau »}
\index{emacs!bureau}
\index{bureau d'emacs}

Lors d'une session \emacs{}, on ouvre une quantité de \jargon{buffers}
plus ou moins importante. Il est agréable de pouvoir recharger ces
\jargon{buffers} lors de la session suivante. Pour ce faire il faut
procéder en deux temps :
\begin{enumerate}
\item ajouter la ligne :
\begin{verbatim}
   (desktop-read)         ; chargement du bureau
\end{verbatim}
  dans son \texttt{.emacs} (le caractère « \verb+;+ » est le
  commentaire du Lisp) ;
\item exécuter la commande \texttt{M-x desktop-save} (une seule fois
  suffit). Précisez que vous voulez sauver votre bureau dans votre
  répertoire racine, et le tour est joué.
\end{enumerate}
À chaque lancement d'\emacs{}, vos \jargon{buffers} seront chargés. Si
vous êtes curieux vous pouvez jeter un \oe il dans le fichier
\texttt{.emacs.desktop} qui contient une description des
fichiers à charger. Notez que la sauvegarde du bureau ne tient pas
compte des \jargon{frames}.

\subsection{À l'aide}
\label{sec-emacs-help}
\index{emacs!aide}
\index{aide!dans emacs}

La touche magique pour obtenir de l'aide à partir d'emacs est
\texttt{C-h}. Cette touche est un préfixe aisément mémorisable qui,
associé avec d'autres combinaisons fournit les informations suivantes
:
\begin{itemize}
\item \texttt{C-h C-k} donne la signification de la combinaison de
  touches que vous taperez (k pour \emph{key}) ; c'est aussi utile
  pour savoir si une combinaison de touche est active ;
\item \texttt{C-h C-f} décrit la fonction dont vous donnerez le nom ;
\item \texttt{C-h C-t} lance le très instructif \emph{tutorial}
  d'\emacs{} ;
\item \texttt{C-h C-i} lance l'ensemble des manuels au format
  \voir{sec-info}{info} installés sur votre ordinateur ; il y a bien
  sûr le manuel d'\emacs{}.
\end{itemize}

\index{emacs!personnaliser|)}
\index{personnaliser emacs|)}


\section{Avec  Xwindow} 
\label{sec-conf-X}

Mais qu'est-ce donc que cet étrange \soft{X}, ou \soft{X window} ou
\soft{Xlib} ? Derrière ce joli nom se cachent plusieurs concepts réunis
en un seul : une interface graphique, un protocole réseau et une
bibliothèque de développement !  On peut voir \soft{X} comme la couche
intermédiaire entre \emph{le matériel} et les applications
\emph{graphiques}. Pour l'instant on peut se contenter de dire que la
couche \soft{X} est la couche nécessaire pour pouvoir utiliser \unix{}
en mode graphique, c'est-à-dire dans un environnement multi-fenêtres, avec
des jolis menus, la souris et tout.


\subsection{Principe général}
\label{sec-conf-x}
\index{Xwindow!principe général}

\soft{X} est basé sur le principe de \emph{client-serveur}. Les rôles
de l'un et l'autre des acteurs sont les suivants :
\begin{description}
\item[Serveur :] c'est le logiciel qui a pour but de piloter la carte
  graphique et l'écran de la machine destinée à afficher, ainsi que
  répondre au mouvement de la souris et aux pressions des touches du
  clavier. Il faut qu'il y ait un serveur \soft{X} en attente sur une
  machine pour pouvoir accéder à la couche graphique.
\index{Xwindow!serveur}
\index{serveur X}
\item[Le client :] c'est l'\emph{application} qui après s'être 
  \emph{connectée} au serveur, l'utilise pour
  effectuer entre autres les affichages. Par exemple, si vous utilisez
  un navigateur \texttt{pdf} ou un visualiseur \texttt{ps} pour
  consulter ce document, les affichages sont gérés par le serveur
  \soft{X}, les évènements de la souris et du clavier sont interceptés
  par le serveur et gérés par le client par le truchement d'une file
  d'attente d'événements.
\index{Xwindow!client}
\index{client Xwindow}
\end{description}
\begin{figure}[htbp]
  \begin{center}
    \includegraphics[width=.95\textwidth]{xwindow}
    \caption[Principe de fonctionnement du protocole \soft{X}]{%
      Principe de fonctionnement du protocole \soft{X} : les requêtes
      sont issues du matériel (clavier/souris).  Elles sont
      interceptées par le serveur, et sont gérées par le client par
      l'intermédiaire d'une file d'attente d'évènements. Le traitement
      de ces requêtes correspond à un affichage particulier.}
    \label{fig-principe-X}
  \end{center}
\end{figure}
En s'appuyant sur la figure~\vref{fig-principe-X} voyons quel est le
principe du mode client-serveur de \soft{X} :
\begin{enumerate}
\item au lancement, le client (c'est-à-dire l'application) va se
  connecter au serveur ; le résultat de la connexion consiste en
  l'établissement d'un canal de communication entre l'application et
  les périphériques d'affichage et de saisie de la machine pilotée par
  le serveur ; ce canal en jargon \soft{X} est appelé un
  \emph{display} ;
\index{Xwindow!display}
\index{display Xwindow}
\item une fois connecté, le client va demander au serveur d'afficher un
  certain nombre de choses, qui correspondent à l'application
  elle-même ;
\item le client se met alors en attente d'évènements ;
\item lorsque l'utilisateur presse une touche de clavier ou manipule
  la souris, le serveur avertit le client de la position de la souris,
  du bouton qui a été pressé, etc. Le client réagit alors en fonction
  de ces informations et envoie un ordre au serveur (par exemple si la
  zone où survient un clic de souris est un bouton, le client va
  demander au serveur d'afficher un bouton enfoncé).
\end{enumerate}


\subsection{Les différentes couches}
\label{sec-conf-couches-X}

Lorsqu'on est face à un environnement graphique sous \unix{}, il faut
distinguer plusieurs couches différentes :
\begin{description}
\item[X :] c'est la couche de base, c'est \emph{in fine} toujours
  \soft{X} qui dessine à l'écran ; comme on peut le constater à la
  figure~\vref{subfig-X-xlogo}, une application est exécutée dans une
  fenêtre qui n'est qu'un rectangle à l'écran ;
\item[Le gestionnaire de fenêtres :] c'est le programme qui « habille
  » les fenêtres avec des barres de titres, ascenseurs et
  autres fonctionnalités qui permettent à l'utilisateur de les
  redimensionner, déplacer, iconifier, etc. Chacun de ces programmes
  (appelés en anglais \emph{window managers}) apporte un « look and
  feel » particulier à l'environnement : l'affichage (le look) et la
  manière de manipuler les fenêtres (le feel) dépendent du gestionnaire
  de fenêtres. Les plus connus sont \soft{fvwm}
  (figure~\ref{subfig-fvwm-xlogo}), \soft{windowmaker}
  (figure~\ref{subfig-wmaker-xlogo}), \soft{afterstep}
  (figure~\ref{subfig-afterstep-xlogo}), \soft{mwm} ;
\index{Xwindow!window manager}
\index{window manager}
\index{gestionnaire de fenêtres}
\item[Les widgets :] ce sont les différents objets qui composent une
  application (boutons, ascenseurs, menus, boîtes de dialogue, etc.).
  Ces objets sont construits par le biais de bibliothèques dont les
  plus connues sont \soft{Xt}, \soft{Xaw}, \soft{Gtk}, \soft{Qt},
  \soft{Motif}, lesquelles sont bâties à partir des bibliothèques
  \soft{X} de base ;
\item[Les environnements intégrés :] il y a quelques années, devant la
  multitude de choix possibles quant aux gestionnaires de fenêtres et
  la relative difficulté qu'il y a à configurer l'environnement
  graphique, plusieurs vendeurs d'\unix{} (Sun, HP, IBM) ont décidé de
  créer le \emph{Common Desktop Environnement} (dit CDE) destiné à
  homogénéiser l'interface graphique des systèmes \unix{}. Dans le
  monde des logiciels libres, l'idée a également séduit et deux
  environnements intégrés sont nés : \soft{Gnome} et \soft{Kde}. Ces
  environnements ne seront pas traités dans ce manuel, ceci dans un
  souci d'ouverture. Nous préférons en effet présenter les couches
  inférieures pour une meilleure compréhension globale\footnote{Aussi
    parce qu'à mon humble avis, bien que ces environnements permettent
    au novice de s'initier à \unix, ils tendent à reproduire ce qu'on
    reproche à Windows : à savoir la dissimulation des
    informations...}.
\end{description}
\begin{figure}[htbp]
  \begin{margefigure}{.5cm}{1cm}
    \begin{center}
      \subfloat[Xlogo tout nu]{%
        \includegraphics[scale=.9]{X-xlogo}\label{subfig-X-xlogo}}
      \subfloat[Avec \soft{fvwm}]{%
        \includegraphics[scale=.9]{fvwm-xlogo}\label{subfig-fvwm-xlogo}}\\
      \subfloat[Avec \soft{afterstep}]{%
        \includegraphics[scale=.9]{afterstep-xlogo}\label{subfig-afterstep-xlogo}}
      \subfloat[Avec \soft{windowmaker}]{%
        \includegraphics[scale=.9]{wmaker-xlogo}\label{subfig-wmaker-xlogo}}
      \caption{Différents gestionnaires de fenêtres}
      \label{fig-X-wm}
    \end{center}
  \end{margefigure}
\end{figure}


\subsection{Comprendre le démarrage}
\label{sec-conf-X-start}
\index{Xwindow!démarrage}
\index{démarrage de Xwindow}

Un système \unix{} peut passer en mode graphique par deux moyens :
\begin{enumerate}
\item directement au démarrage, dans ce cas la fenêtre de login est
  une fenêtre graphique et le fichier \texttt{\~{}/.xsession} de
  l'utilisateur  est exécuté ;
\index{Xwindow!xsession@\texttt{.xsession}}
\index{xsession@\texttt{.xsession}}
\item manuellement : l'utilisateur se connecte sur une console texte,
  et exécute un utilitaire généralement appelé \texttt{startx} ou
  quelque chose d'approchant, qui permet de lancer l'environnement
  graphique ; dans ce cas précis c'est le fichier
  \texttt{\~{}/.xinitrc} de l'utilisateur qui est exécuté.
  \index{Xwindow!xsession@\texttt{.xinitrc}}
  \index{xsession@\texttt{.xinitrc}}
\end{enumerate}
Il est souvent suffisant de faire en sorte que le fichier
\texttt{\~{}/.xsession} soit un lien symbolique sur le fichier
\texttt{\~{}/.xinitrc}. Attention, ce dernier doit être exécutable. Voici un
exemple de fichier de démarrage :
\begin{fichier}[label=\~{}/.xinitrc]
  #!/bin/sh 
  # .xinitrc
  # pas de beep
  xset b off
  # fond
  xsetroot -solid lightseagreen
  # un terminal pour commencer
  xterm +ls &
  # gestionnaire de fenêtres
  exec fvwm2
\end{fichier}
On comprend qu'au lancement de \soft{X}, on va successivement, imposer
un bip silencieux, donner une couleur à la fenêtre racine\footnote{La
  fenêtre appelée racine est la fenêtre constituant le « bureau » de
  l'environnement, elle ne peut être déplacée ou iconifiée, et
  contient toutes les autres.}, lancer un terminal~\soft{X}, et
finalement lancer le gestionnaire de fenêtre.
\begin{attention}
  Dans un tel fichier, le dernier programme ---~ici
  \soft{fvwm2}~--- ne doit pas être lancé en tâche de fond, et la
  terminaison de celui-ci implique la fin de la session~\soft{X}.
\end{attention}
\begin{note}
  Le démarrage de \soft{X} sur votre système n'est peut être pas tout
  à fait identique à ce qui est décrit plus haut. Pour savoir comment
  ça se passe chez vous, jouez les Hercule Poirot, et vous pourrez
  tomber, comme sur le système de l'auteur, sur un fichier
  \texttt{/etc/X11/xdm/Xsession} dont voici la fin :
  \begin{fichier}[label=/etc/X11/xdm/Xsession]
    if [ -x "$HOME/.xsession" ]; then 
      exec "$HOME/.xsession" 
   elif [ -x "$HOME/.Xclients" ]; then 
      exec "$HOME/.Xclients" 
   elif [ -x /etc/X11/xinit/Xclients ]; then 
      exec /etc/X11/xinit/Xclients 
   else
      exec xsm 
   fi
 \end{fichier}
 extrait que vous êtes à même de comprendre si vous avez lu
 attentivement le chapitre~\ref{chap-developper} !
\end{note}
Nous donnons ici à nouveau et à titre d'information, l'arborescence
des \voir{sec-lien-de-parente}{processus} correspondant à une session
\soft{X} :
\begin{verbatim}
  PID PPID CMD
  324    1 [xdm]
  334  324  \_ /etc/X11/X
  335  324  \_ [xdm]
  346  335      \_ [.xsession]
  360  346          \_ fvwm2 -s
  448  360              \_xterm -ls
  451  448              |  \_-bash
  636  451              |    \_ ps --forest -eo pid,ppid,cmd
  576  360              \_ /usr/X11R6/lib/X11/fvwm2/FvwmAuto
  577  360              \_ /usr/X11R6/lib/X11/fvwm2/FvwmPager
\end{verbatim}

\subsection{X et le réseau}
\label{sec-conf-X-net}

Un des aspects particulièrement souple de \soft{X} est sa capacité à
faire communiquer le client et le serveur à travers un réseau. En
d'autres termes, il est possible pour une machine distante exécutant
une application graphique (client \soft{X}), d'envoyer les affichages
sur la machine que vous avez devant les yeux ---~c'est-à-dire utiliser
le serveur \soft{X} local. Cette idée est illustrée à la
figure~\vref{fig-xwinres}.
\begin{figure}[htbp]
  \begin{center}
    \includegraphics[width=\textwidth]{xwinres}
    \caption{\soft{X} en tant que protocole réseau}
    \label{fig-xwinres}
  \end{center}
\end{figure}



\subsubsection{La variable d'environnement \envvar{DISPLAY}}
\index{Xwindow!display@\texttt{DISPLAY}}


Lorsqu'une  application \soft{X} démarre, elle cherche à se connecter au
serveur spécifié par la variable \envvar{DISPLAY} ---~sauf si
l'application a été programmée pour se connecter à un serveur
spécifique. La variable \envvar{DISPLAY} a la forme suivante :
\begin{flushleft}
  \quad\comarg{machine}:\comarg{numéro\_display}.\comarg{numéro\_écran}
\end{flushleft}
\comarg{machine} est le nom de la machine. Selon le contexte, cela
peut être :
\begin{itemize}
\item le nom de la machine seul : \texttt{mekanik} ;
\item le nom complet de la machine : \texttt{mekanik.zeuhl.org} ;
\item rien du tout, l'application cherchera à se connecter au serveur
  \soft{X} de la machine sur laquelle elle s'exécute.
\end{itemize}
Le nombre \comarg{numéro\_display} correspond au numéro du canal
initialisé par le serveur, le premier porte le numéro $0$. Dans la
plupart des cas les machines n'ont qu'un seul display, c'est-à-dire
qu'il n'y a qu'un seul ensemble clavier/souris qui communique avec le
serveur. Ce nombre ne doit pas être omis. \comarg{numéro\_écran},
quant à lui, est le numéro associé aux écrans attachés à un canal
donné. Ainsi si une machine possède deux écrans, le premier portera le
numéro~$0$, le suivant~$1$, etc.  La plupart des applications dispose
d'une option \texttt{-display}, \texttt{-d} ou \texttt{-{}-display}
pour passer outre l'effet de la variable \envvar{DISPLAY}, en écrivant
par exemple :
\begin{shellcom}
  ¢usercom«xclock -display machine.domain.org:0 & »
  [1] 3452
\end{shellcom}
qui lance une magnifique horloge sur la machine
\texttt{machine.domain.org} si elle l'a autorisé.

\subsubsection{Autoriser des machines à se connecter à un serveur} 
\index{Xwindow!autorisation|(}
\index{autorisation avec X|(}
De manière à éviter que toutes les machines connectées au même réseau
que vous (par exemple Internet !) ne puissent utiliser votre serveur~X,
il est nécessaire d'adopter une politique d'autorisation. La première
politique consiste à n'autoriser que certaines machines dont on
stockera les noms dans une liste. On verra que la gestion de cette
liste est effectuée par l'utilitaire \com{xhost}.

En supposant qu'un utilisateur assis devant la machine \texttt{mekanik}
veuille utiliser les ressources de calcul de la machine distante
\texttt{ayler}, tout en affichant sur l'écran de \texttt{mekanik},
voici les étapes à effectuer :
\begin{enumerate}
\item autoriser la machine distante \texttt{ayler} à utiliser le serveur
  \soft{X} de la machine locale \texttt{mekanik} ;
\item se connecter sur \texttt{ayler} ;
\item spécifier que le serveur \soft{X} à utiliser est sur la machine
  \texttt{mekanik} ; c'est-à-dire qu'on veut afficher sur l'écran de la
  machine locale et non sur celui de la machine distante
  \texttt{ayler} ;
\item lancer l'application !
\end{enumerate}
ce qui se traduit dans un shell par\footnote{Pour l'utilisation de
  \com{rlogin}, se référer à \S~\vref{sec-com-telnet-rlogin}} :
\begin{shellcom}
  ¢usercom«xhost +ayler.freejazz.org ¢comcomment«autorisation»»
  ayler.freejazz.org has been added to control list
  ¢usercom«rlogin ayler.freejazz.org» ¢comcomment«connexion sur la  machine distante»
  ¢usercom«export DISPLAY=mekanik.zeuhl.org:0.0» ¢comcomment«affichage sur mekanik»
  xappli &
  [1] 15678
\end{shellcom}


\subsubsection{Autoriser des utilisateurs à se connecter à un serveur}
\hyphenation{coo-kie}
Lorsque la politique basée sur les machines est trop laxiste
(autoriser une machine c'est autoriser tous les utilisateurs de cette
machine), il faut envisager d'autoriser uniquement certains
utilisateurs. Pour ce faire, on s'appuie sur l'utilitaire \com{xauth}
qui gère un ensemble de clefs ---~appelées \emph{cookies} dans le jargon
de \com{xauth}~--- associées à chaque display pour un utilisateur donné.
Le principe est le suivant : pour autoriser une machine \texttt{B} à
afficher sur une machine \texttt{A}, il faut :
\begin{itemize}
\item récupérer un cookie de la machine \texttt{A} ;
\item le faire connaître à la machine \texttt{B}
\end{itemize}
Pour récupérer un cookie sur la machine locale \texttt{A}, on fait :
\begin{shellcom}
  ¢usercom«xauth nlist A:0»
  0000 0004 a1031e2f 0001 30 0012 4d49542d4d414749432d434f4f4b4
  9452d310010 002e46651c4158584654595d61125506
\end{shellcom}
qui affiche le cookie correspondant au display
{\shorthandoff{:}\texttt{A:0}} sur la sortie standard. Dans une autre
fenêtre, on se connecte sur la machine distante, et on lance la
commande :
\begin{shellcom}[noendprompt]
  ¢usercom«xauth nmerge -»
\end{shellcom}
qui attend un cookie sur son entrée standard. Par un habile «
copier/coller » on peut fournir le cookie de la machine \texttt{A}.
Une solution élégante, si les deux machines le permettent, est de
lancer sur la machine locale \texttt{A} :
\begin{shellcom}
  ¢usercom«xauth nlist A:0 | rsh B /usr/X11R6/bin/xauth nmerge -»
\end{shellcom}
en utilisant la commande  \com{rsh} qui lance le \com{xauth} sur la
machine \texttt{A} depuis la machine \texttt{B}.


\subsubsection{Compter sur ssh pour l'autorisation}

Aujourd'hui sur certains systèmes, on peut utiliser l'option
\texttt{-X} de la commande \voir{sec-ssh}{\com{ssh}} permettant de
passer outre la configuration (fastidieuse) des cookies :
\begin{shellcom}[noendprompt]
  ¢usercom«ssh -X machine_distante»
  Password:
\end{shellcom}
Une fois connecté sur la machine distante, les clients \soft{X} utiliseront
automatiquement le serveur de la machine locale et feront transiter
les requêtes \soft{X} en utilisant le cryptage de \com{ssh}.

\index{Xwindow!autorisation|)}
\index{autorisation avec X|)}


\subsection{Étude de cas : fond d'écran}
\label{sec-X-cas}

Dans l'environnement \soft{X}, on peut imposer une couleur à la
fenêtre racine avec la commande \com{xsetroot}, par exemple :
\begin{shellcom}
  ¢usercom«xsetroot -solid black»
\end{shellcom}
met le fond d'écran à la couleur noire. Dans cette étude de cas, on se
propose de mettre en fond d'écran une image tirée au hasard parmi une
série. Pour ce faire, on utilisera le programme \soft{xloadimage}. Si
l'on dispose d'une image~\texttt{fond.jpg}, on pourra la mettre en
fond d'écran avec la commande :
\begin{shellcom}
  ¢usercom«xloadimage -border black -center -onroot fond.png»
  fond.jpg is a 1075x716 JPEG image, [...], Huffman coding.
  Merging...done
  Building XImage...done
\end{shellcom}
Supposons maintenant que l'on dispose de plusieurs images dans un
répertoire :
\begin{shellcom}
  ¢usercom«ls ~/photos/fonds»
  fond-00.png  fond-02.png  fond-04.png  fond-06.png
  fond-01.png  fond-03.png  fond-05.png  fond-07.png
\end{shellcom}
Pour choisir une image au hasard, on va d'abord compter le nombre
d'images du répertoire et le stocker dans une variable :
\begin{shellcom}
  ¢usercom«nbf=$(ls -l ~photos/fonds/fond-??.png | wc -l)»
  ¢usercom«echo $nbf»
  8
\end{shellcom}
%$
On peut ensuite choisir un nombre au hasard en exploitant la
variable~\envvar{RANDOM} et l'opérateur modulo du shell :
\begin{shellcom}
  ¢usercom«f=$[RANDOM%nbf]»
  ¢usercom«echo $f»
  3
\end{shellcom}
la variable~\envvar{RANDOM} contient une valeur tirée aléatoirement
entre~0 et~\nombre{32767}\footnote{Le valeur \nombre{32767}
  correspond au plus grand nombre entier positif que l'on peut
  générer à l'aide de 16 bits, soit $2^{16}-1$. Vous pouvez placer
  cela lors d'une soirée entre ami, cela fait toujours beaucoup
  d'effet.}. L'opérateur~\verb+%+ renvoie le reste
de la division entière. Par conséquent l'expression arithmétique
\verb+$[RANDOM%nbf]+
renvoie un nombre tiré aléatoirement entre~0 et~\texttt{nbf}-1. Il ne
reste plus qu'à construire le nom du fichier à partir de ce
nombre. Pour cela, on peut utiliser la commande \com{printf}
fonctionnant comme celle du langage~C :
\begin{shellcom}
  ¢usercom«printf "~/photos/fond/fond-%02d.png\n" $f»
  ~/photos/fond/fond-03.png
\end{shellcom}
%$
\begin{gnuposix}
  Outre le fait que \verb+$RANDOM+ n'est pas aussi aléatoire qu'on le
  souhaiterait en particulier dans les bits de poids faible, cette
  variable ne fait pas partie de la norme Posix mais est disponible dans
  les shells \soft{bash} et \soft{ksh}.
\end{gnuposix}
Voici enfin une possibilité de script rassemblant les commandes
précédentes :
\begin{fichier}[label=fond.sh]
  #!/bin/sh
  # répertoire stockant les images
  dirfonds="$HOME/photos/fonds"

  # nombre d'images dans ce répertoires
  nbfonds=$(ls -l $dirfonds/fond-??.png | wc -l)

  # numéro du fond tiré aléatoirement
  nfondchoisi=$(echo $[RANDOM%$nbfonds])
  # nom du fond tiré aléatoirement
  fondchoisi=$(printf "$dirfonds/fond-%02d.png" $nfondchoisi)

  # chargement en fond d'écran
  xloadimage -display :0 -border black -center \
             -onroot $fondchoisi > /dev/null
\end{fichier}
%$
Il ne reste plus qu'à lancer ce script dans le fichier de
\voir[][10pt]{sec-conf-X-start}{démarrage} de la session~\soft{X} (le fichier
\texttt{.xsession}), et dans la \voir{sec-cron}{crontab} de
l'utilisateur séduit par ce merveilleux fond d'écran dynamique. Ainsi
par exemple :
\begin{shellcom}
  ¢usercom«crontab -l»
  0-59/15 * * * * ~/bin/fond.sh
\end{shellcom}
changera de fond d'écran tous les quarts d'heure. Notez bien que ce
\soft{cron} n'aura de sens que si le système sur lequel vous vous connectez
vous propose un serveur~\soft{X}...
\begin{note}
  L'option \texttt{-display} de la commande \com{xloadimage} dans le
  script est nécessaire car au moment où le script est lancé par le
  daemon~\com{cron}, la variable~\envvar{DISPLAY} est vide. Vous aurez
  également noté qu'on redirige dans le fichier « trou noir », les
  bavardages du programme \soft{xloadimage}, ceci pour éviter que le
  daemon~\com{cron} ne nous les envoie par mail tous les quarts
  d'heure...
\end{note}
%----------------------------------------------------------------------
%
% INSTALLER DES LOGICIELS
%
%----------------------------------------------------------------------
\section{Installer  des logiciels}
\index{installer des logiciels|(}


Nous finirons ce chapitre par une présentation succincte de la manière
d'installer des logiciels sur son propre compte. Cette activité peut
en effet être vue comme la configuration de son environnement de
développement, puisqu'on a parfois besoin d'installer des utilitaires
pour son usage personnel sans exiger de l'administrateur qu'ils soient
installés pour tous les utilisateurs. Les instructions primordiales
sont les suivantes :
\begin{itemize}
\item \textbf{lire la doc !} celle-ci se trouve généralement dans des
  fichiers portant les noms \texttt{README}, \texttt{INSTALL},
  \texttt{LISEZMOI}, etc.
\item maîtriser l'utilisation des outils
  \voir{sec-unix-targzip}{d'archivage} et de compression (\com{gzip} et
  \texttt{tar}) ;
\item maîtriser l'utilisation de l'utilitaire \voir{sec-dev-make}{\com{make}}
   dans le cas d'installation sous forme
  de source.
\end{itemize}
On considérera donc que le « package » binaire ou source à installer
se présente sous forme d'une archive compressée et que l'utilisateur
est capable de la décompacter dans un répertoire particulier.

\subsection{Installer des binaires}
\label{sec-conf-install-bin}

Une fois l'archive décompressée, il faut suivre les instructions 
se trouvant dans le fichier décrivant l'installation. Certaines
archives contiennent des scripts permettant de copier les fichiers
dans des répertoires spécifiques de manière plus ou moins
automatique. On peut toujours éditer ces scripts pour les adapter à
ses besoins.  En tout état de cause, l'installation de programme
binaire consiste la plupart du temps à copier :
\begin{itemize}
\item un ou plusieurs fichiers exécutables dans un endroit spécifique ;
\item des bibliothèques.
\item des pages de manuels et autres fichiers \texttt{info}.
\end{itemize}
En supposant que le logiciel s'installe dans le répertoire
\verb+~/monsoft+, il faudra s'assurer que le système puisse accéder à
ces différents fichiers de la manière suivante :
\begin{itemize}
\item mettre à jour la variable \envvar{PATH} :
\begin{verbatim}
  export PATH=~/monsoft/bin:$PATH
\end{verbatim}
%$
\item mettre à jour la variable \envvar{MANPATH} :
\begin{verbatim}
  export MANPATH=~/monsoft/man:$MANPATH
\end{verbatim}
%$
\item mettre à jour la variable \envvar{LD\_LIBRARY\_PATH} :
\begin{verbatim}
  export LD_LIBRARY_PATH=~/monsoft/lib:$LD_LIBRARY_PATH
\end{verbatim}
\end{itemize}
%$
Dans le cas de « petits » utilitaires on peut se contenter d'installer
les fichiers avec d'autres utilitaires, par exemple dans les
répertoires :
\begin{itemize}
\item \verb+~/bin+ pour les exécutables ;
\item \verb+~/man+ pour les pages de manuels ;
\item \verb+~/lib+ pour les bibliothèques dynamiques.
\end{itemize}
%\clearpage

\subsection{Installer des sources}
\label{sec-conf-install-src}

L'installation de programmes sous forme de sources peut être plus
délicate à cause des problèmes de portabilité entres les différentes
versions d'\unix. Lorsque l'archive est proposée sous forme de sources,
elle fournit un \texttt{Makefile} contenant diverses informations
que l'on peut adapter à son installation :
\begin{itemize}
\item le compilateur utilisé, ainsi que les options associées ;
\item les répertoires d'installations (pour les binaires, le manuel,
  etc. )
\item ...
\end{itemize}
Ces informations sont proposées sous la forme de
\voir{sec-make-variables}{variables} \com{make}. Une fois le
\texttt{Makefile} adapté (le fichier \texttt{INSTALL} ou le
\texttt{Makefile} lui-même contient des instructions qui guident le
choix de ces options), il faut créer l'exécutable, généralement en
lançant simplement la commande :
\begin{shellcom}
  ¢usercom«make»
  ... 
\end{shellcom}
Puis il faudra lancer l'installation proprement dite des fichiers ; ce
qui est généralement effectué grâce à la commande :
\begin{shellcom}
  ¢usercom«make install»
  ...
\end{shellcom}
encore une fois les \texttt{Makefile} peuvent être préparés de manière
différentes selon le logiciel à installer, il est donc
impératif de lire les documentations fournies pour connaître les
cibles exactes. À ce propos, la commande :
\begin{shellcom}
  ¢usercom«make -n install»
  ...
\end{shellcom}
vous permettera de simuler l'installation et d'avoir un aperçu des
répertoires dans lesquels seront installés les fichiers.

Pour simplifier la vie des vaillants utilisateurs, le projet GNU a
créé un utilitaire permettant d'adapter automatiquement le
\texttt{Makefile} à votre système, ceci tout en gardant un certain
degré de souplesse. Cet utilitaire se présente dans l'archive des
sources sous la forme d'un script nommé \texttt{configure} :
\begin{shellcom}
  ¢usercom«./configure»
  ...
\end{shellcom}
permet après un temps de scrutation de votre système de créer un
\texttt{Makefile} reflétant les caractéristiques de l'\unix{} sur
lequel vous travaillez. Une fois le \texttt{Makefile} créé, les
commandes décrites plus haut (\texttt{make} et \texttt{make install})
ont le même rôle. 

Le script \texttt{configure} tient généralement compte du fait que le
logiciel s'installera dans le répertoire \texttt{/usr/local}, ce qui
est une pratique courante. Dans la mesure où vous n'avez généralement
pas les droits d'accès à ce répertoire, vous pouvez spécifier la
racine de l'installation, avec :
\begin{shellcom}
  ¢usercom«./configure --prefix=$HOME/monsoft»
  ...
\end{shellcom}
qui configurera le \texttt{Makefile} pour que l'utilitaire soit
installé  avec comme racine \texttt{\~{}/monsoft}. La commande
\texttt{./configure -{}-help} vous donnera les autres options
disponibles pour le package que vous installez.
\index{installer des logiciels|)}

%$
\subsection{Installer des paquet Debian}

\begin{gnuposix}
  Ce qui suit  vous sera utile uniquement si votre  \unix{}
  est un système \gnu/\linux{} et si celui-ci est installé via des paquets
  Debian. C'est la cas bien évidemment  de la célèbre Debian mais
  aussi de la star du moment : la distribution Ubuntu.
\end{gnuposix}

Les distributions de \gnu/\linux{} Debian et Ubuntu utilisent le même
système de « paquets » pour installer les logiciels. Ce système permet
de gérer les différentes versions à mettre à jour et d'inclure dans
chaque paquet des scripts de pré-installation et post-installation qui
sont lancés, comme leur nom l'indique, avant et après l'installation
des binaires\footnote{Les paquets Debian peuvent également contenir
  les sources des logiciels.} du paquet\footnote{De tels scripts
  existent également pour l'opération de suppression du paquet.}.

Dans son utilisation la plus courante, le principe de la gestion des
paquets repose sur l'utilisation de dépôts accessibles depuis le
réseau ou depuis des périphériques amovibles (cédérom, dvd, ...). Ces
dépôts contiennent les versions officielles des paquets constituant la
distribution. Il en existe des « miroirs » dans différents pays
accélérant ainsi l'accès aux ressources. Vous devriez trouver sur
votre système un fichier \texttt{/etc/apt/sources.list} dont voici ce
que pourrait être un extrait :
\begin{shellcom}
  ¢usercom«cat /etc/apt/sources.list»
  [...]
  deb http://ftp.fr.debian.org/debian/ lenny main
  deb http://security.debian.org/ lenny/updates main contrib non-free
  deb http://www.debian-multimedia.org lenny main
  [...]
\end{shellcom}
Dans la mesure où les fichiers stockés sur ces machines distantes
évoluent il est nécessaire de mettre à jour la liste des paquets sur
votre système. Cette liste est conservée dans le fichier :
\begin{flushleft}
  \ttfamily/var/cache/apt/pgkcache.bin
\end{flushleft}
Même s'il est fort probable que votre distribution mette à jour
automatiquement par \soft{cron} ce fichier, il n'est pas inutile de
savoir qu'on peut explicitement rafraîchir ce fichier grâce à la
commande :
\begin{flushleft}
  \ttfamily apt-get update
\end{flushleft}
Ensuite un certain nombre d'opérations classiques sont possibles en
utilisant entre autres, cette même commande \com{apt-get} :
\begin{itemize}
\item installation d'un paquet :
  \begin{comsyntax}
    apt-get install \argument{nom\_du\_paquet}
  \end{comsyntax}
\item effacement d'un paquet (y compris ses fichiers de configuration)
  \begin{comsyntax}
    apt-get --purge remove \argument{nom\_du\_paquet}
  \end{comsyntax}
\item mettre à jour toutes les paquets pour lesquels existe une
  nouvelle version :
  \begin{comsyntax}
    apt-get upgrade
  \end{comsyntax}
\item chercher parmi les paquets (installés ou non) ceux qui
  correspondent à un motif particulier :
  \begin{comsyntax}
    apt-cache --names-only search \argument{motif}
  \end{comsyntax}
  Le motif doit être saisi comme une \voir{sec-regexp}{expression
    régulière}.  Par exemple tous les paquets commençant par «
  \texttt{lib} » et finissant par « \texttt{pgsql} » peuvent être
  listés grâce à la commande :
  \begin{comsyntax}
    apt-cache --names-only search \verb+'^lib.*pgsql$'+
  \end{comsyntax}
  %$
  Pour chercher les paquets dont le nom \emph{ou la description}
  contiendrait le mot « \texttt{penguin} » suivi du mot «
  \texttt{race} » :
  \begin{comsyntax}
    apt-cache search \verb+'penguin.*race'+
  \end{comsyntax}
\end{itemize}
Pour finir cette présentation, sur les paquets Debian, il faut savoir
qu'il existe un utilitaire de plus bas niveau permettant d'agir
directement sur un paquet, c'est-à-dire sans passer un dépôt : la
commande \com{dpkg}. Cette commande est d'ailleurs finalement appelée
par la commande \com{apt-get} par exemple. Elle permet donc
d'installer ou d'enlever un paquet, mais aussi d'extraire toutes
les informations d'un fichier au format des paquets Debian.


\section*{Pour conclure}
\label{sec-conclusion}

Vous êtes donc armé pour naviguer dans un système \unix{} puisque vous
avez maintenant les connaissances de base pour manipuler un éditeur
de texte, configurer votre shell et votre environnement graphique. Ces
connaissances, couplées avec celle du chapitre~\ref{chap-developper}
sur le développement, et du chapitre~\ref{chap-communiquer} sur le
réseau, vous donnent les bases nécessaires à l'exploration de ce
système particulièrement vaste qu'est \unix{}. Le chapitre qui suit
vous donnera quelques pistes pour trouver les informations qui vous
manquent.

%%% Local Variables: 
%%% mode: latex
%%% TeX-master: "../framabook"
%%% End: 
