À la découverte de GNU Emacs

Transcription

À la découverte de GNU Emacs
Florent Rougon <f.rougon(**AT**)free[point]fr>
Version 1.36 (3 mai 2016)
Résumé
Ce document est une introduction à GNU Emacs, un des éditeurs de texte les plus puissants à ce jour. Un éditeur de texte est
un programme permettant de créer et modifier des fichiers au « format texte », c’est à dire sans format particulier (ces fichiers
sont des suites d’octets directement interprétés selon le codage adéquat – ASCII, UTF-8, ISO-8859-15, etc. – pour former du
texte). GNU Emacs est un logiciel libre sous licence GPL (cf. http://www.gnu.org/licenses/licenses.html#GPL). Ceci
implique notamment qu’il est gratuit, que son code source est librement accessible à tous, que l’on peut le modifier sans
aucune restriction et le redistribuer dans les conditions prévues par la licence GPL.
i
Table des matières
1 Où trouver ce document dans d’autres formats ?
1
2 Notions de base
3
2.1
Comment Emacs est construit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
2.2
Les raccourcis claviers (key sequences) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
2.3
Fonctions et commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2.4
Buffers et fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2.5
Modes majeurs et mineurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2.6
Windows et frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.7
La ligne de mode (modeline) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.8
Le minibuffer et l’echo area . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.9
Point, cursor : quelle différence ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
2.10 Mark, region, quesako ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
3 Quelques commandes
3.1
7
La base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
3.1.1
L’aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
3.1.2
Fichiers et buffers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
3.1.3
Diverses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
3.2
Les buffers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
3.3
Les windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
3.3.1
Commandes générales relatives aux windows
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
3.3.2
Commandes relatives à la other-window . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
Les frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
3.4.1
Commandes générales relatives aux frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
3.4.2
Commandes relatives à la other-frame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
Déplacements et édition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
3.5.1
Déplacements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
3.5.2
Édition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
3.6
Les bookmarks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
3.7
Les macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
3.4
3.5
TABLE DES MATIÈRES
4 Quelques modes
4.1
4.2
ii
15
Mineurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
4.1.1
Le mode auto-fill . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
4.1.2
Le mode font-lock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
Majeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
4.2.1
Le mode Fundamental . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
4.2.2
Le mode Text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
4.2.3
Le mode Info . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
4.2.4
Le mode Lisp Interaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
4.2.5
Le mode Hexl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
5 Introduction à ELisp, le dialecte Lisp d’Emacs
19
5.1
Courte présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
5.2
Approche de la syntaxe, évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
5.3
Les symboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
5.4
Manipulation des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
5.5
Écrire une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
5.5.1
Fonctions nommées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
5.5.2
Fonctions anonymes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
Compléments sur les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
5.6.1
Les cons cells . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
5.6.2
La Vraie Nature des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
Quelques mots sur les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
5.7.1
Les caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
5.7.2
La read syntax des chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
5.8
Quelques constructions pratiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
5.9
Gestion des fichiers ELisp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
5.6
5.7
6 Quelques idées pour votre fichier d’initialisation
29
6.1
Avec une version récente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
30
6.2
Avec d’anciennes versions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
7 Comment installer une extension à Emacs ?
39
8 Où trouver de la documentation ?
41
9 Mail et news avec Emacs
43
10 Quelques liens
45
11 GNU Emacs ou XEmacs ?
47
11.1 La petite histoire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
11.2 Qu’en est-il aujourd’hui ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
48
12 À propos de ce document
49
13 Qu’est-ce qui a changé dans ce document depuis la version x.yz ?
51
1
Chapitre 1
Où trouver ce document dans d’autres
formats ?
Ce document est écrit en SGML, ce qui rend possible la création automatique de nombreuses versions de celui-ci dans divers
formats tels que HTML, DVI, PDF, PostScript, Info, ou texte brut. La version que vous lisez actuellement a été obtenue
selon ce principe.
Vous trouverez en ‘À propos de ce document’ page 49 un lien vers des versions de ce document dans divers formats.
Chapitre 1. Où trouver ce document dans d’autres formats ?
2
3
Chapitre 2
Notions de base
2.1
Comment Emacs est construit
Le coeur d’Emacs est écrit en C et tout le reste en ELisp (Emacs Lisp). ELisp est un langage interprété 1 , ce qui permet une
très grande interactivité dans Emacs (on peut faire n’importe quoi en exécutant directement une simple ligne d’ELisp, il n’y
a rien à compiler préalablement).
2.2
Les raccourcis claviers (key sequences)
Les raccourcis clavier, appelés key sequences dans Emacs et donc par la suite séquences de touches dans ce document sont
constitués d’un éventuel préfixe et d’une combinaison de touches finale. Par exemple, la séquence de touches C-x 5 C-f
(signifiant qu’il faut taper : Control-x, relâcher ces touches, taper 5 2 , relâcher puis taper Control-f) est constituée du préfixe
C-x 5 et de C-f (en fait, C-x est également un préfixe au sens d’Emacs ; pour plus d’informations sur le sujet, se reporter au
GNU Emacs Lisp Reference Manual).
Les combinaisons de touches standard d’Emacs paraissent souvent incroyablement compliquées aux non-initiés ; la plupart
sont en fait assez faciles à mémoriser grâce aux conventions pour l’utilisation des préfixes et aux choix des combinaisons de
touches finales (comme h pour help) :
— le préfixe C-c est réservé aux commandes définies par les modes et par l’utilisateur ;
— Beaucoup d’autres préfixes sont remarquables dans les affectations standard des séquences de touches et seront signalés
dans la suite de ce document : C-x 4 pour les fonctions liées à la other window (autre fenêtre, attention à la signification
de fenêtre dans Emacs !), C-x 5 pour celles liées à la other frame, C-x r pour celles liées aux bookmarks, etc.
Certaines séquences de touches comportent ESC ou M- en leur sein. Sur la plupart des systèmes 3 , on peut dans ce cas
interpréter cette portion comme :
— taper la touche Echap puis la suite de la séquence ;
— ou bien 4 taper la touche Meta et en la gardant appuyée, taper la touche qui suit le M- ou le ESC puis relâcher les
deux et taper la suite de la séquence, s’il y a une telle suite.
La touche Meta existe telle quelle sur les claviers de certaines stations de travail (Sun par exemple). Sous Linux, elle dépend
de la configuration du serveur X (souvent, la touche Windows fait l’affaire). Sous Windows, il s’agit de la touche Alt 5 . Sous
MacOS, je ne sais pas.
Les autres petits noms qu’Emacs donne aux touches sont en général transparents : TAB pour la touche tabulation, RET pour
la touche Return (Enter), SPC pour la barre d’espacement, f1 et consorts pour les touches de fonction, left, right, up et
down pour les flèches, etc.
Certains raccourcis clavier paraissent très pénibles à exécuter et sont à l’origine de critiques injustifiées de la part de certaines
personnes qui ne connaissent pas Emacs (« combinaisons de touches impossibles, gna-gna-gna. . .»). Par exemple, quand on ne
connaît pas, on pense que C-x C-s (séquence de touches permettant de sauvegarder le contenu du buffer courant – cf. ‘Buffers
et fichiers’ page suivante) ne peut pas être effectuée rapidement. C’est totalement faux car :
1. On peut byte-compiler un fichier ELisp pour accélérer son chargement
2. Attention au pavé numérique dans certains cas
3. Le mot exact serait ici terminaux. . .
4. Pour un ESC qui n’est pas à la fin de la séquence de touches
5. Ceci empêche au passage l’utilisation de la touche qu’Emacs appelle A comme dans A-s que l’on peut réaliser avec Alt-s avec une configuration
de serveur X courante sous Linux avec un clavier PC. Mais je ne lui connais aucune utilisation standard dans Emacs, donc cela devrait être assez
peu gênant.
Chapitre 2. Notions de base
4
— Quand une séquence de touches comporte plusieurs C-<quelque chose> de suite (ou plusieurs M-<quelque chose> de
suite, etc.), on peut la taper en gardant la touche Control appuyée pour tous les C-<quelque chose> (ou M-<quelque
chose>. . .) qui se suivent directement. Donc ici, il suffit d’appuyer sur Control, appuyer sur x, relâcher x, et appuyer
sur s pour lancer save-buffer.
— En général, dans une telle séquence de touches, les emplacements des touches sont bien choisis : sur la plupart des
claviers, x et s sont très proches.
Si vous avez des problèmes avec C-s et C-q, sachez que la fonction enable-flow-control permet de basculer entre les
fonctionnements suivants :
— C-s et C-q sont interprétés par le terminal (et sont en principe utilisés pour le contrôle de flux) ;
— C-s et C-q sont interprétés par Emacs (traditionnellement, C-s pour la recherche de texte dans un buffer – cf. ‘Buffers
et fichiers’ de la présente page – et C-q pour la commande quoted-insert).
La FAQ d’Emacs (visualisable avec C-h F) traite de cette question plus en détail.
2.3
Fonctions et commandes
Le fonctionnement d’Emacs se fait au travers de fonctions écrites en ELisp ou en C. Celles que l’utilisateur appelle le plus
souvent sont des commandes 6 . Elles peuvent être exécutées par M-x nom-de-la-commande.
Après avoir tapé M-x, on est invité dans le minibuffer (voir ‘Le minibuffer et l’echo area’ page suivante) à taper le nom de la
commande. La complétion est bien sûr disponible (avec TAB) ; on peut taper la barre d’espace pour insérer un tiret (c’est plus
pratique) ; enfin, si on sait qu’il n’y a qu’une commande avec le nom commençant par ce qu’on a indiqué dans le minibuffer,
il suffit de taper RET pour compléter son nom et la lancer.
Il est important de noter que bon nombre de commandes, notamment parmi les commandes d’insertion de texte, interprètent
le universal argument (argument spécifié après C-u) comme le nombre de fois à répéter la fonction « de base » de la commande.
Par exemple, pour insérer 78 fois le caractère *, il suffit de taper C-u 7 8 * (si vous avez des problèmes, utilisez les chiffres
de la partie principale de votre clavier – pas ceux du pavé numérique).
Cette remarque prendra toute son importance au chapitre ‘Les macros’ page 12, C-u x y z t C-x e permettant d’exécuter
xyzt (nombre entier écrit en décimal) fois la dernière macro enregistrée. . .
2.4
Buffers et fichiers
Un buffer est une zone (en général en mémoire) dans laquelle on stocke quelque chose. Dans Emacs, le quelque chose est du
texte 7 , éventuellement colorisé. Chaque buffer dans Emacs a un nom unique qui permet entre autres de naviguer de l’un à
l’autre.
Un buffer peut « visiter un fichier » (traduction littérale ; comprendre : être lié à un fichier) mais ce n’est pas obligatoire.
Par exemple, les buffers *scratch* et *Messages* que l’on trouve par défaut dans Emacs après l’avoir lancé ne sont liés à
aucun fichier.
Intérêt de chaque type de buffer :
— un buffer lié à un fichier est pratique en ce que les fonctions de sauvegarde savent directement quoi faire (écrire le
contenu du buffer dans le fichier auquel il est lié) ;
— un buffer lié à aucun fichier est utile pour toute utilisation de type brouillon ; sauf demande expresse de la part de
l’utilisateur, le contenu du buffer ne sera jamais sauvegardé (en particulier, aucune question n’est posée pour ces buffers
lorsqu’on quitte Emacs).
2.5
Modes majeurs et mineurs
Chaque buffer doit obligatoirement être dans un mode dit mode majeur (major mode) qui définit la manière dont Emacs doit
interagir avec l’utilisateur pour ce buffer (colorisation, séquences de touches, etc.). Souvent, les modes majeurs sont écrits
pour éditer des buffers dont le contenu est dans un langage de programmation donné (exemples : c-mode, python-mode,
shell-script-mode, sql-mode, etc.).
6. Je ne définirai pas ici précisément ce qu’Emacs entend par commande, cela sortant largement du cadre d’un tutoriel dont le but est de
permettre une prise en main rapide d’Emacs en s’appuyant sur des bases tout de même assez solides. Le lecteur souhaitant voir les définitions
précises de tous les termes techniques employés ici trouvera certainement son bonheur dans le GNU Emacs Lisp Reference Manual (à chercher sur
le site Web du projet GNU (http://www.gnu.org/)).
7. ou des images, depuis la sortie d’Emacs 21
5
Parallèlement, un buffer peut être dans zéro, un ou plusieurs mode(s) mineur(s) (minor mode(s)) qui définissent une fonction
particulière, a priori valable pour tout mode majeur. Par exemple, le mode mineur font-lock-mode assure (si le mode
majeur lui fournit les indications suffisantes) la colorisation d’un buffer ; l’auto-fill-mode permet quant à lui (entre autres)
de taper « au kilomètre » en ayant un texte qui ne dépasse pas un nombre de colonnes choisi par l’utilisateur.
Tout mode, majeur ou mineur, peut être activé (et désactivé, s’il s’agit d’un mode mineur) par M-x nom-du-mode. Bien sûr,
activer un nouveau mode majeur pour le buffer courant désactive son mode majeur précédent.
Le mode Fundamental est le mode majeur le plus primitif, le plus simple d’Emacs. C’est le mode par défaut dans une
configuration standard. Dans ma configuration, le mode par défaut pour un nouveau buffer est le mode Text, sauf si les
mécanismes 8 pour déterminer le mode adéquat à l’ouverture d’un fichier en indiquent un autre.
2.6
Windows et frames
Un processus (programme) Emacs peut afficher plusieurs fenêtres en même temps sans consommer autant de ressources que
si l’on avait lancé autant de fois Emacs. De plus, ces fenêtres partagent tout ce qui constitue la session Emacs (variables
globales, buffers ouverts, etc.). Dans la terminologie d’Emacs, ces fenêtres sont appelées frames (littéralement : cadres).
Emacs sait aussi diviser verticalement et horizontalement le contenu d’une frame en plusieurs parties appelées windows dans
la terminologie Emacs. Ce terme étant particulièrement trompeur (ces parties ne sont pas des fenêtres comme on les conçoit
habituellement sur une interface graphique), il sera utilisé en italique dans tout ce document pour éveiller la vigilance du
lecteur. Chaque window peut contenir un buffer. Plusieurs windows peuvent contenir le même buffer, ce qui permet d’examiner
différents endroits d’un buffer sans se déplacer sans cesse.
2.7
La ligne de mode (modeline)
La ligne de mode est la ligne, souvent affichée en vidéo inverse, que l’on retrouve au bas de chaque window. Elle affiche
beaucoup d’informations utiles relatives au buffer qu’elles contiennent, entre autres, en standard :
— si le buffer visite un fichier, les caractères numéro 2 et 3 de cette ligne (en commençant à 0) permettent de savoir si
son contenu a été modifié depuis sa dernière sauvegarde, selon que ce sont des tirets ou des astérisques ;
— le nom du buffer ;
— le mode majeur et les éventuels modes mineurs (dans l’ordre, vers le milieu de la ligne et entre parenthèses) ;
— la position du point (curseur du clavier) – ligne, colonne 9 , pourcentage relatif à la taille du fichier – dans le buffer ;
— si le buffer visite un fichier, la ligne de mode indique si les fins de lignes de ce fichier sont codées à la manière de
MS-DOS d’Unix ou de MacOS.
2.8
Le minibuffer et l’echo area
Il s’agit simplement du tout petit buffer (en général réduit à une seule ligne 10 situé en bas de chaque frame. Il est utilisé
pour effectuer des saisies lors de l’exécution de nombreuses commandes.
La window où l’on voit le minibuffer est également utilisée pour faire parvenir de nombreux messages à l’utilisateur. Il ne s’agit
pas de saisie, cette fois-ci, mais seulement d’affichage. On dit que ces messages sont affichés dans l’echo area (littéralement :
zone d’écho, i.e., selon une vieille tradition de nomenclature informatique, zone où sont affichés de courts messages). Les
plus récents de ces messages peuvent généralement être consultés dans le buffer *Messages*, ce qui est bien pratique puisque
l’echo area ne peut afficher que le dernier message (et celui-ci disparaît dès que l’on presse une touche).
Notez que l’on peut, sauf dans des cas très particuliers comme avec la recherche incrémentale 11 , utiliser dans le minibuffer
les mêmes touches de déplacement ou d’édition (copier/coller par exemple) que dans un autre buffer. Ainsi, on se rendra vite
compte qu’il est très pratique pour corriger une saisie dans le minibuffer d’utiliser :
— M-DEL pour effacer (ou plutôt killer : voir ‘Édition’ page 11) le mot précédent le point (voir ‘Point, cursor : quelle
différence ?’ page suivante) ;
— C-a (et/ou home – la touche « Début » – selon la configuration) et C-e (et/ou end) pour se déplacer respectivement en
début et en fin de ligne ;
8. Ces mécanismes utilisent l’extension du fichier, sa première ligne, les File variables (voir le manuel d’Emacs avec Info), etc.
9. L’affichage de la colonne n’est pas en standard, au moins dans GNU Emacs 20.3. Pour en disposer dans tous les buffers, il suffit de mettre la
ligne (column-number-mode t) dans son fichier d’initialisation pour Emacs (.emacs ou, éventuellement, à partir de GNU Emacs 20.4, .emacs.el).
10. Depuis Emacs 21, la window affectée au minibuffer est redimensionnée automatiquement en fonction des besoins.
11. Le cas de la recherche incrémentale n’a rien de magique ; elle se déroule simplement dans un mode où l’affectation des touches est un peu
inhabituelle (cf. isearch-mode-map).
6
— C-k pour effacer la ligne courante à partir du point (donc C-a C-k permet dans tous les cas d’effacer entièrement la
ligne courante).
2.9
Point, cursor : quelle différence ?
Le mot point revient très souvent dans Emacs. Il représente une position particulière dans un buffer : celle où seront insérés
les prochains caractères (sauf utilisation de fonctions d’insertion particulières, bien sûr). Sa signification est donc très proche
de celle de curseur. Les principales différences sont :
— Le point est situé entre deux caractères alors que le curseur est généralement affiché sur un caractère. Par exemple, si
le curseur est sur le b de frob, Emacs dira que le point se situe entre le o et le b.
— Si l’on édite plusieurs buffers en même temps, chacun d’entre eux contient un point indépendant de celui des autres
buffers mais un seul curseur est affiché dans une frame donnée.
Cette distinction, que le débutant peut ignorer sans prendre beaucoup de risques, est détaillée dans le GNU Emacs Manual
à la section Point.
2.10
Mark, region, quesako ?
La marque est simplement un objet qui repère un endroit dans chaque buffer (il y a donc une marque par buffer). Elle permet
de faire beaucoup de choses, notamment le copier/coller. L’utilisateur peut la déposer où bon lui semble avec C-SPC (nous y
reviendrons plus tard – voir ‘Déplacements’ page 10).
Ceci permet non seulement de revenir par la suite à cet endroit avec un simple C-x C-x mais sert aussi à délimiter implicitement une zone de texte appelée region et définie comme étant l’ensemble des caractères compris entre le point et la marque
(le point peut être avant ou après la marque dans le buffer, cela n’a aucune importance).
Certaines fonctions, notamment des fonctions qui risquent de déplacer le point loin dans le buffer, posent une marque au
début de leur exécution pour permettre un retour rapide à l’endroit d’où elles ont été appelées. Elles l’indiquent en général
dans le minibuffer par « Mark set » ou un message analogue.
7
Chapitre 3
Quelques commandes
Les commandes listées ci-dessous ne constituent bien entendu pas une liste exhaustive (se reporter aux GNU Emacs Manual
et GNU Emacs Lisp Reference Manual pour une telle liste) et leurs descriptions sommaires ne sont là que pour guider le
lecteur, l’orienter rapidement vers la commande qu’il recherche. Souvent, les commandes admettent des arguments optionnels
qui offrent plus de possibilités que ce qui est décrit ici. Dans tous les cas, les références absolues sont l’aide en ligne d’Emacs
(parfois un peu succincte mais le plus souvent très pratique) et les manuels sus-cités.
Dans les sections qui suivent, on trouvera des listes de la forme :
C-x C-f (find-file) Ouvrir un fichier (. . .)
C-x C-s (save-buffer) Enregistrer le buffer courant (. . .)
Cela se lit : « C-x C-f (Control-x puis Control-f, en gardant éventuellement la touche Control appuyée durant toute la
séquence) est un raccourci clavier qui lance la commande find-file dont le rôle est (. . .). »
3.1
3.1.1
La base
L’aide
Toutes les séquences de touches standard liées à ces commandes commencent par le préfixe C-h (pour help).
C-h ? (help-for-help) Lister les commandes d’aide
C-h a (command-apropos) Donner une liste de commandes dont le nom contient la regexp 1 donnée par l’utilisateur.
C-h b (describe-bindings) Afficher tous les bindings (liens entre les séquences de touches et les commandes qu’elles exécutent) disponibles dans le buffer courant (ils dépendent de son mode majeur et de ses éventuels modes mineurs –
voir ‘Modes majeurs et mineurs’ page 4).
C-h f (describe-function) Décrire une fonction. Indispensable.
C-h i (info) Active le buffer *info* dans lequel on dispose de documentation 2 au format hypertexte Info (voir ‘Le mode
Info’ page 16).
C-h k (describe-key) Répondre à la question : « que fait cette séquence de touches ? ». Cela permet notamment de trouver
le nom de la fonction lancée par une séquence bien connue (pour l’utiliser dans un programme ELisp par exemple).
C-h l (view-lossage) Afficher les 100 derniers caractères tapés. Très utile quand on pense s’être emmêlé les pinceaux sans
vraiment savoir ce qu’on a fait.
C-h m (describe-mode) Afficher la documentation du mode majeur et des modes mineurs courants. Penser aussi à regarder
dans le système Info (voir ‘Le mode Info’ page 16).
C-h p (finder-by-keyword) Trouver un package Emacs lié à un sujet donné.
C-h t (help-with-tutorial) Pour ceux qui ne disposent pas de ce document. :-)
C-h v (describe-variable) Donner la valeur courante et la documentation d’une variable. Cette commande précise également si la variable est locale au buffer courant. Indispensable.
C-h w (where-is) Afficher les séquences de touches qui invoquent une commande dont on donne le nom. Plutôt utile.
1. regular expression : chaîne de caractères respectant une syntaxe particulière (pour connaître celle d’Emacs, faire C-h i, choisir le noeud
(node) Emacs puis Regexps) permettant de décrire tout un ensemble de chaînes de caractères. Une chaîne de caractères « ordinaires » est une
regexp décrivant la chaîne elle-même, ce qui permet de s’en sortir dans les cas simples même si on ne connaît rien à la syntaxe des regexps.
2. Sur un système complet (Debian GNU/Linux par exemple :-)), cette fonction donne accès à une documentation qui dépasse très largement
le cadre d’Emacs, le format Info étant indépendant d’Emacs. Sur un tel système, on peut d’ailleurs utiliser le programme info à la place d’Emacs
pour la consulter.
Chapitre 3. Quelques commandes
3.1.2
8
Fichiers et buffers
C-x C-f (find-file) Ouvrir un fichier dans un buffer du même nom (avec éventuellement un suffixe comme <2>, <3>, etc.
s’il existe déjà un buffer portant ce nom).
C-x C-s (save-buffer) Enregistrer le buffer courant dans un fichier. Si le buffer visitait déjà un fichier avant exécution de
la commande (par exemple s’il avait été créé par C-x C-f), ce fichier est choisi d’office pour sauver le contenu du buffer,
sinon la commande demande un nom de fichier.
C-x C-w (write-file) Enregistrer le buffer courant dans un fichier (la commande demande le nom du fichier).
C-x C-v (find-alternate-file) Ouvrir un fichier (demandé par la commande) et killer (tuer, fermer) le buffer courant.
Très utile quand on se trompe de nom de fichier avec C-x C-f. Astuce : je m’en sers également pour mettre le nom
(éventuellement avec le chemin d’accès) du fichier visité par le buffer courant dans le kill ring (« copier » le nom de
ce fichier). Bien sûr, find-alternate-file ne fait rien elle-même quant au kill ring. Elle permet simplement d’avoir
rapidement le nom du fichier dans un buffer.
Nous verrons également des variantes de C-x C-f : cf. ‘Les buffers’ page suivante, ‘Les windows’ page ci-contre et ‘Les frames’
page 10.
Rhhhaaa ! Emacs pollue les répertoires où il enregistre des fichiers !
Du calme. D’abord, retenez bien ces trois choses :
— dans Emacs, tout est configurable, jusqu’à la couleur de ses chaussettes ;
— si un comportement par défaut d’Emacs vous agace, il y a sûrement une bonne raison pour qu’il ait été
choisi comme tel ;
— si vous ne trouvez pas la fonction que vous désirez pour accomplir une certaine tâche, il est presque 3
toujours possible de l’écrire et il y a de bonnes chances pour que quelqu’un l’ait déjà fait (cherchez sur
Internet).
Emacs fait par défaut deux types de sauvegarde des fichiers.
— La première, appelée auto-save, est effectuée régulièrement (par exemple, au bout de n secondes ou au bout de p frappes
de touches) et produit des fichiers avec des noms du type #monfichier#. Cette sauvegarde permet de récupérer votre
travail quand Emacs n’est pas quitté correctement, par exemple si vous débranchez subitement la prise de l’ordinateur 4 .
— La seconde, appelée backup, est effectuée quand vous sauvegardez un fichier après l’avoir modifié dans Emacs. Elle
produit des fichiers avec des noms du type monfichier~.
Pour désactiver cette dernière, les possibilités sont multiples :
— si vous n’en voulez jamais, vous pouvez mettre la ligne :
(setq make-backup-files nil)
dans votre fichier d’initialisation (.emacs ou éventuellement .emacs.el à partir de GNU Emacs 20.4) ;
— si vous voulez juste sauver un fichier sans faire de copie de sauvegarde, utilisez M-0 C-x C-s (ceci est un appel à
save-buffer – C-x C-s – avec un argument numérique : 0) ;
— si pour un fichier donné, vous ne voulez jamais de ce genre de sauvegardes, regardez du côté des File variables
dans l’aide au format Info (C-h i) ;
— si vous souhaitez que les backup files se retrouvent tous dans un même répertoire (ma préférence va pour cette
solution, pour la plupart des fichiers), voici comment procéder :
— si vous êtes sous Emacs 21, vous pouvez mettre ceci dans votre .emacs.el :
(setq backup-directory-alist
’(("." . "/répertoire/choisi/")))
Le “.” est une regexp et signifie ici qu’on veut que tous les fichiers de sauvegarde aillent dans
/répertoire/choisi/.
— si vous êtes encore sous Emacs 20, vous pouvez utiliser le code suivant dans votre .emacs.el sachant que
certaines personnes connaissant très bien Emacs disent que cela pourrait parfois poser des problèmes. Je l’ai
utilisé pendant plusieurs mois sans problème et ne suis pas le seul à avoir mis en oeuvre cette méthode, mais
je préfère vous prévenir. Ah, dernier avertissement, je crois que le code suivant ne fonctionne pas sous GNU
Emacs 20.3 car subst-char-in-string n’y est pas encore définie. Cela dit, on peut remplacer cette fonction
facilement (ou mettre à jour son Emacs !).
(defvar flo-backup-files-directory "~/.flo-emacs-backup-files-directory/"
"Directory for Emacs’ backup files.
This directory is used by make-backup-file-name.")
(defun flo-make-backup-file-name (file)
"Create the non-numeric backup file name for FILE.
3. Ce presque est à prendre au sens mathématique – comme dans « la fonction f est nulle presque partout. »
4. C’est en général une mauvaise idée.
9
Return an absolute filename based on flo-backup-files-directory after
changing all : or / characters into underscores (_)."
(expand-file-name
(subst-char-in-string ?: ?_ (subst-char-in-string ?/ ?_ file))
flo-backup-files-directory))
(defalias ’make-backup-file-name ’flo-make-backup-file-name))
— si. . .
3.1.3
Diverses
C-g (keyboard-quit) Sortir de toute fonction qui s’exécute pour retourner au top-level (la boucle d’Emacs qui attend les
événements – frappes de touches, déplacements de la souris, etc. – et agit en conséquence). Indispensable. C’est elle
que vous utiliserez dès que vous vous serez trompé de fonction et que vous voudrez sortir du minibuffer (attendant une
saisie dont vous n’avez que faire).
C-x C-c (save-buffers-kill-emacs) Quitter Emacs après avoir demandé pour chaque buffer lié à un fichier qui a été
modifié depuis sa dernière sauvegarde si on veut sauvegarder son contenu. Cette commande assez rarement utilisée. :)5
C-x ESC ESC (repeat-complex-command) Éditer et réexécuter la dernière commande complexe : en gros, la dernière commande ayant impliqué une saisie dans le minibuffer. Cela peut servir par exemple de raccourci pour le dernier
M-x nom-à-rallonge-long-à-compléter exécuté.
3.2
Les buffers
Voir ‘Buffers et fichiers’ page 4 pour la définition d’un buffer dans Emacs.
C-x b (switch-to-buffer) Ouvrir un buffer existant ou créer un nouveau buffer lié (jusqu’à nouvel ordre) à aucun fichier
(la commande demande le nom du buffer et permet la complétion pour les buffers existants).
C-x k (kill-buffer) Killer (tuer, effacer) un buffer dont le nom est demandé par la commande.
M-x bury-buffer (bury-buffer) mettre le buffer courant à la fin de la liste des buffers, de sorte qu’il devienne celui qui
a le moins de chances d’être proposé par défaut si l’on exécute C-x b. Pratique lorsqu’on ne veut plus voir le buffer
courant mais qu’on sait qu’on va en avoir à nouveau besoin un peu plus tard.
C-x C-b (list-buffers) Lister tous les buffers existant dans la session Emacs courante.
Nous verrons également par la suite C-x 4 b (‘Commandes relatives à la other-window’ page suivante) et C-x 5 b (‘Commandes relatives à la other-frame’ page suivante).
3.3
Les windows
Voir ‘Windows et frames’ page 5 pour la définition d’une window dans Emacs.
3.3.1
Commandes générales relatives aux windows
C-x 2 (split-window-vertically) Diviser la window courante en deux parties l’une au-dessus de l’autre.
C-x 1 (delete-other-windows) Faire disparaître toutes les windows de la frame courante sauf la window courante : elle
occupe donc ensuite toute la frame.
C-x 0 (delete-window) Efface la window courante (selected window) de la frame courante.
C-x o (other-window) Se déplacer d’une window à l’autre au sein de la frame courante.
Comme la plupart des raccourcis clavier sous Emacs, ceux-ci sont assez faciles à mémoriser : 2 pour « 2 parties », 1 pour
« 1 window » (restant dans la frame après exécution de la commande), 0 pour « disparition de la selected window », o pour
« other ».
5. En utilisant Emacs, vous vous rendrez vite compte qu’on peut faire beaucoup de choses avec (par exemple lire son mail et les news). Du
coup, beaucoup d’utilisateurs d’Emacs le laissent tourner du matin au soir sur leur machine, ou même plusieurs semaines dans certains cas. . .
3.3.2
10
Commandes relatives à la other-window
Comme on (enfin, je !) utilise le plus souvent une ou deux windows par frame, la other-window est définie en général sans
problème. Dans le cas au moins 3 windows divisent la frame courante, la other-window est définie me semble-t-il comme
quelque chose du genre « la première obtenue en tournant dans le sens anti-horaire depuis la window courante ». Si cela vous
traumatise de ne pas connaître la définition authentique de la other-window, plongez-vous dans le GNU Emacs Manual ou
le GNU Emacs Lisp Reference Manual.
Les commandes relatives à la other-window sont accessibles en standard via le préfixe C-x 4.
C-x 4 b (switch-to-buffer-other-window) Choisir un buffer (dont le nom est demandé par la commande) à afficher dans
l’other-window.
C-x 4 C-f (find-file-other-window) Ouvrir un fichier (dont le nom est demandé par la commande) dans un buffer affiché
dans l’other-window.
3.4
Les frames
Voir ‘Windows et frames’ page 5 pour la définition d’une frame dans Emacs.
Les commandes relatives aux frames sont accessibles en standard via le préfixe C-x 5.
3.4.1
Commandes générales relatives aux frames
C-x 5 2 (make-frame-command) Créer une nouvelle frame.
C-x 5 0 (delete-frame) Efface la frame courante.
C-x 5 o (other-frame) Se déplacer d’une frame à l’autre au sein de la session Emacs courante.
3.4.2
Commandes relatives à la other-frame
Comme pour la other-window, le lecteur intéressé par une définition précise de la other-frame se reportera aux références que
constituent le GNU Emacs Manual et le GNU Emacs Lisp Reference Manual.
C-x 5 b (switch-to-buffer-other-frame) Choisir un buffer (dont le nom est demandé par la commande) à afficher dans
une window de l’other-frame. Une nouvelle frame est créée s’il n’y en avait qu’une auparavant.
C-x 5 C-f (find-file-other-frame) Ouvrir un fichier (dont le nom est demandé par la commande) dans un buffer affiché
dans une window de l’other-frame. Une nouvelle frame est créée s’il n’y en avait qu’une auparavant.
3.5
3.5.1
Déplacements et édition
Déplacements
Si Emacs est configuré correctement 6 , se déplacer au sein d’un buffer est très simple : les flèches et les touches habituelles
(sur PC) Début (Home) et Fin (End) devraient fonctionner sans problème. Dans le cas contraire, si le problème vient de la
configuration d’Emacs, jetez un oeil à ‘Quelques idées pour votre fichier d’initialisation’ page 29.
Il existe bien sûr quelques fonctions un peu plus évoluées et très pratiques pour se déplacer au sein d’un buffer :
C-left et/ou M-b (backword-word) Déplacer le point vers le début du buffer de mot 7 en mot.
C-right et/ou M-f (forward-word) Même chose mais vers le la fin du buffer.
C-a et éventuellement home (beginning-of-line) Déplacer le point au début de la ligne courante.
Quand on commence à prendre l’habitude, on se rend compte que C-a est bien plus rapide à taper que home. Mnémotechniquement, a correspond début de l’alphabet de même que C-a permet de se rendre au début de la ligne courante.
6. Ceci peut dépendre de plusieurs choses en cascade, notamment le fichier .emacs (ou .emacs.el), le terminal et le système X-Window si vous
l’utilisez.
7. Un mot (word) au sens d’Emacs a bien sûr une définition précise et modifiable par l’utilisateur. Pour plus d’informations sur ce sujet, se
reporter au GNU Emacs Manual.
11
C-e et éventuellement end (end-of-line) Déplacer le point à la fin de la ligne courante.
Quand on commence à prendre l’habitude, on se rend compte que C-e est bien plus rapide à taper que end. Mnémotechniquement, e évoque end (fin).
M-< et/ou C-home (beginning-of-buffer) Poser la marque (voir ‘Mark, region, quesako ?’ page 6) puis déplacer le point
au début du buffer. Le fait que beginning-of-buffer pose la marque avant de déplacer le point au début du buffer
est très pratique : il suffit de taper C-x C-x pour retourner à l’endroit où l’on a appelé beginning-of-buffer.
M-> et/ou C-end (end-of-buffer) Poser la marque (voir ‘Mark, region, quesako ?’ page 6) puis déplacer le point à la fin
du buffer. Même remarque que pour beginning-of-buffer.
C-SPC et C-@ (set-mark-command) Poser la marque à l’endroit où se trouve le point. Voir ‘Mark, region, quesako ?’ page 6
pour le concept de marque.
C-x C-x (exchange-point-and-mark) Échanger les positions du point et de la marque. Très pratique quand on s’est pas
mal déplacé dans un buffer et que l’on souhaite revenir là où se trouve la marque.
Mnémotechniquement, x évoque eXchange.
M-x goto-line (goto-line) Demander le numéro d’une ligne (via le minibuffer) et y déplacer le point. Surtout utile pour
les programmeurs.
C-s (isearch-forward) Démarre une recherche incrémentale dans le buffer courant. Cela signifie que vous êtes invité à
taper du texte dans le minibuffer et que au fur et à mesure, Emacs déplace le point, si possible, au premier endroit du
buffer où ce texte apparaît à partir de celui où la commande a été appelée.
Si la recherche a été fructueuse, vous pouvez passer à l’occurrence suivante du texte tapé en tapant à nouveau C-s.
Pour chercher vers le début du buffer au lieu de chercher vers la fin, il suffit de taper C-r. Enfin, pour terminer la
recherche, il suffit de taper :
— C-g pour retourner à l’endroit où elle a été commencée ;
— RET pour rester où on est. La marque est placée à l’endroit où la recherche a été commencée.
Cette commande est bien sûr indispensable. Mnémotechniquement, s évoque search et r reverse.
C-r (isearch-backward) Même chose que pour isearch-forward mais vers le début du buffer, le sens de la recherche
pouvant être inversé avec C-s.
M-C-f (forward-sexp ou autre suivant le mode majeur courant) Déplacer le point à la fin de la sexp où il se trouve.
Une sexp au sens d’Emacs est une expression d’un langage de programmation (voir le GNU Emacs Manual). Cette
fonction est indispensable avec les expressions parenthésées ou assimilées (comportant un délimiteur ouvrant et un
délimiteur fermant). Elle permet par exemple en mode Emacs-Lisp de se déplacer automatiquement après la parenthèse
fermante correspondant à (matching en anglais) la parenthèse ouvrante qui se trouve sous le point. De même, elle permet
en mode C de se déplacer d’une accolade ouvrante à l’accolade fermante correspondante.
M-C-b (backward-sexp ou autre suivant le mode majeur courant) Cette fonction est le pendant de la fonction précédente. Elle permet notamment de se déplacer en mode Emacs-Lisp d’une parenthèse fermante à la parenthèse ouvrante
correspondante et en mode C d’une accolade fermante à l’accolade ouvrante correspondante.
Notez que par défaut, les séquences de touches C-b (comme backward), C-f (comme forward), C-n (comme next) et C-p
(comme previous) jouent le rôle des flèches gauche, droite, bas et haut (respectivement). Certains disent qu’avec l’habitude,
elles permettent d’être plus efficace que les flèches. Elles peuvent dépanner dans le cas d’une mauvaise configuration le temps
de remettre les choses en place.
3.5.2
Édition
Avant de présenter les commandes d’édition fondamentales, à savoir annuler des actions précédentes, copier/couper/coller et
remplacer du texte, il est nécessaire d’expliquer deux concepts simples : ce qu’Emacs appelle delete et kill.
— To delete signifie effacer en anglais. Une fonction telle que delete-region efface donc purement et simplement le
contenu de la région.
— To kill signifie tuer. Dans Emacs, cela veut dire effacer après avoir gardé l’information dans une structure appelée le
kill ring. Le kill ring, comme son nom l’indique (ring signifiant anneau), a une structure circulaire : quand on réalise
plusieurs kills, le texte effacé à chaque fois est disposé comme autant d’éléments 8 le long de l’anneau constitué par le
kill ring ; lorsqu’on veut insérer un élément du kill ring, on peut faire défiler tous ceux qu’il contient les uns après les
autres. Après avoir fait défiler tous les éléments du kill ring, le processus recommence de manière circulaire (on repasse
au premier élément, puis au deuxième, etc.).
Ceci étant dit, voici les fonctions d’édition de base d’Emacs :
8. Enfin presque. Des kills de textes consécutifs peuvent être placés dans un même élément du kill ring.
12
C-_ et C-x u (undo) Annuler la dernière action. Ceci fonctionne sur plusieurs niveaux (en d’autres termes, plusieurs appels
successifs à cette fonction annulent plusieurs modifications successives dans le buffer courant). Indispensable.
Astuce énorme : pour faire du redo (annuler des annulations), il suffit, après avoir appelé au moins une fois successivement undo, d’insérer un caractère quelconque, par exemple un espace, puis d’appeler à nouveau undo. L’insertion
du caractère brise en quelque sorte la chaîne des undo et permet de la remonter (les actions annulées sont d’abord
l’insertion du caractère puis les undo qui l’on précédée.
M-w (kill-ring-save) Copier la région (voir ‘Mark, region, quesako ?’ page 6) dans le kill ring mais ne pas l’effacer du
buffer. Indispensable.
C-w (kill-region) Ceci kille la région (donc l’efface du buffer après l’avoir placée dans le kill ring). Indispensable.
C-y (yank) Insérer le bloc de texte le plus récemment killé ou yanké. Ceci correspond donc à peu de choses près à la fonction
traditionnellement appelée coller. Indispensable.
M-y (yank-pop) Remplacer le bloc de texte précédemment yanké par celui qui le précède dans le kill ring. Cette fonction
permet donc de se « balader » dans le kill ring.
M-% (query-replace) Effectuer un rechercher/remplacer interactif. Très utile, bien sûr.
M-x comment-region (comment-region) Cette fonction n’est a priori utile qu’aux programmeurs et n’a de sens que dans
un mode définissant la syntaxe d’un commentaire (ce qui est probablement le cas de tous les modes consacrés à un
langage de programmation). Elle sert à mettre la région en commentaire, au sens défini pour ce concept par le mode
courant (par exemple, la région sera entourée de /* et */ en mode C ).
3.6
Les bookmarks
Les bookmarks sont très pratiques si vous devez ouvrir de nombreuses fois un fichier situé à un endroit figé dans votre
arborescence. Ce cas se produit typiquement assez souvent, par exemple avec le fichier .emacs (ou .emacs.el), un document
quelconque rédigé sur plusieurs jours, etc.
Une utilisation basique des bookmarks est très simple :
C-x r m (bookmark-set) Mettre un bookmark sur le fichier visité dans le buffer courant.
Cela signifie : ajouter la liste des bookmarks (bookmark list) la correspondance entre un nom choisi par l’utilisateur
(par l’intermédiaire du minibuffer) et le fichier en question.
C-x r b (bookmark-jump) Ouvrir un fichier en donnant juste (et avec complétion bien sûr) le nom d’un bookmark qui y
fait référence.
M-x edit-bookmarks (edit-bookmarks) Ouvre un buffer appelé *Bookmark List* en mode Bookmark Menu dans lequel
on peut modifier la liste des bookmarks.
Ce buffer est à utiliser un peu comme celui invoqué par M-x dired (pour manipuler des fichiers et répertoires) : on
déplace le point sur la ligne qui nous intéresse et on tape une touche pour effectuer une action sur le bookmark indiqué
à cette ligne.
Par exemple, avec r (comme rename), on peut renommer un bookmark. Pour effacer des bookmarks, il suffit de les
marquer pour effacement (deletion) avec d puis de taper x (pour eXecute). Si on a marqué des bookmarks pour
effacement et qu’on désire annuler ce marquage, il suffit de taper u (pour unmark) avec le point sur la ligne en question.
Avec C-h m dans un buffer en mode Bookmark Menu, vous pouvez vous faire une petite idée de ce qu’on peut faire
dans ce mode.
Conclusion : si vous avez un fichier /chemin/très/long/et/pénible/à/taper et que vous allez l’ouvrir plusieurs fois d’ici
peu, ouvrez-le, faites un petit C-x r m et nommez le bookmark « machin ». La prochaine fois que vous voudrez ouvrir ce
fichier, il suffira de faire C-x r b puis de taper « machin » (voire moins en utilisant la complétion) et RET pour valider.
3.7
Les macros
Les macros constituent probablement l’outil d’Emacs offrant le meilleur rapport complexité de l’action effectuée / temps
consacré à la spécifier. Elles permettent d’enregistrer à peu près n’importe quelle séquence d’événements clavier 9 pour
ensuite la répéter avec un simple f4 (C-x e avant la version 22). Voici quelques commandes de base pour utiliser les macros :
f3 (kmacro-start-macro-or-insert-counter) Démarrer l’enregistrement d’une macro. Cette fonction, utilisée pendant
l’enregistrement, permet également d’insérer un entier qui est incrémenté à chaque nouvelle exécution de la macro.
9. Et souris, mais c’est un peu particulier et moins utile en général. . .
13
f4 (kmacro-end-or-call-macro) Terminer l’enregistrement d’une macro commencé avec f3. Utilisée hors enregistrement
d’une macro, cette fonction permet également d’exécuter la dernière macro enregistrée.
C-x C-k C-e (kmacro-edit-macro) Éditer la dernière macro enregistrée.
C-x C-k b (kmacro-bind-to-key) Affecter un raccourci clavier à la dernière macro enregistrée. Les sequences de touches
allant de C-x C-k 0 à C-x C-k 9 et de C-x C-k A à C-x C-k Z sont réservées pour les macros clavier définies par
l’utilisateur (et elles bénéficient d’un petit raccourci : il suffit de taper par exemple 4 après C-x C-k b pour affecter la
séquence C-x C-k 4 à l’exécution de la dernière macro définie).
C-x C-k n (kmacro-name-last-macro) Donner un nom à la dernière macro enregistrée.
M-x insert-kbd-macro (insert-kbd-macro) Insérer la définition d’une macro nommée (typiquement avec
kmacro-name-last-macro) dans le buffer courant (typiquement le .emacs.el pour pouvoir retrouver sa macro
au prochain démarrage d’Emacs). Par exemple, pour une macro essai sans intérêt simulant un appui sur la flèche
droite du clavier, on obtient :
(fset ’essai
(lambda (&optional arg) "Keyboard macro."
(interactive "p")
(kmacro-exec-ring-item (quote ([right] 0 "%d")) arg)))
Les raccourcis claviers indiqués ci-dessus sont valables depuis Emacs 22 ; les anciens raccourcis (« C-x ( » pour définir une
macro, « C-x ) » pour terminer la définition et « C-x e » pour l’exécuter) sont encore actifs par défaut sous Emacs 23. De
plus, après le premier C-x e, il suffit d’appuyer sur e pour exécuter à nouveau la macro.
Comme vous le voyez, les macros sont extrêmement simples à définir et utiliser. Et pourtant, elles n’en sont pas moins
puissantes, notamment en ayant les points suivants à l’esprit :
— Pour effectuer une action complexe dans une macro, on a souvent intérêt à utiliser des fonctions de déplacement évoluées
comme celles permettant de se déplacer au début ou à la fin d’un mot ou d’une ligne.
— Dans le même ordre d’idées, il est parfaitement possible – et souvent très efficace – d’utiliser les fonctions de recherche
(à commencer par isearch-forward, avec C-s) pour déplacer le point. Il est utile à ce propos de se rappeler que la
recherche peut-être terminée en tapant RET et que dans ce cas, la marque est déposée là où la recherche a été commencée.
— On peut bien sûr faire du copier/coller au sein d’une macro et exploiter le cas échéant ce que nous venons de dire sur
la position de la marque après une recherche. S’il y a plusieurs choses à mémoriser, le plus simple consiste à les stocker
dans des registres (se reporter au GNU Emacs Manual, section Registers).
— On peut répéter automatiquement xyzt (nombre entier écrit en décimal) fois 10 la dernière macro enregistrée avec
C-u x y z t f4 (voir ‘Fonctions et commandes’ page 4), par exemple pour traiter chaque ligne d’un buffer, en supposant que la macro passe d’une ligne à la suivante à chaque fois qu’elle est exécutée. Très puissant.
— La commande C-x C-k r (apply-macro-to-region-lines) exécute automatiquement la dernière macro enregistrée
pour chaque ligne de la région en plaçant le point en début de ligne avant chaque exécution, ce qui est très pratique.
Il y a pas mal d’autres possibilités relatives aux macros clavier, par exemple :
— pour contrôler plus finement l’insertion automatique d’un entier par une macro ;
— pour rajouter quelques touches à la dernière macro définie ;
— pour récupérer les dernières touches tapées et en faire une macro ;
— pour poser une question au cours de l’exécution de la macro un peu comme avec le rechercher/remplacer interactif
(M-%) ;
— pour faire tourner le macro ring et ainsi accéder aux différentes macros clavier définies au cours de la session.
Le lecteur intéressé trouvera tout cela dans le GNU Emacs Manual.
10. Ou même jusqu’à ce que la macro provoque une erreur, avec C-u 0.
14
15
Chapitre 4
Quelques modes
4.1
4.1.1
Mineurs
Le mode auto-fill
Le mode auto-fill est un mode mineur très pratique lorsqu’on souhaite avoir des lignes ne dépassant pas n caractères, n étant
bien sûr choisi par l’utilisateur. On peut l’activer ou le désactiver avec M-x auto-fill-mode.
Quand l’auto-fill-mode est actif, Emacs insère automatiquement un saut de ligne à la fin d’une ligne entre deux mots pour
que celle-ci comporte le maximum de caractères sans dépasser la valeur de la variable fill-column. Les espaces insécables
sont pris en compte donc ne peuvent donner lieu à une coupure par le mode auto-fill.
Donc si vous voulez taper un texte ne dépassant pas 78 colonnes par exemple, vous enclenchez si besoin est l’auto-fill-mode
puis mettez 78 dans la variable fill-column et il ne vous reste plus qu’à taper au kilomètre.
Pour changer la valeur de la variable fill-column, il y a au moins deux possibilités offertes par les fonctions suivantes :
C-x f (set-fill-column) Stocker la valeur de l’argument dans la variable fill-column. Par exemple, pour mettre 78 dans
cette variable, on peut taper C-u 7 8 C-x f 1 .
Cette fonction permet également d’utiliser la colonne courante pour affecter fill-column ; pour cela, il suffit de taper
C-u C-x f.
M-x set-variable (set-variable) Affecter une valeur à une variable, les deux étant demandées dans le minibuffer (sauf
si on lui fournit ses deux arguments en l’appelant en ELisp par exemple. . .).
Il est important de noter que set-variable ne propose pas dans le choix des variables à affecter (quand on l’appelle
interactivement) toutes les variables définies dans la session Emacs courante, mais seulement celles pour lesquelles les
programmeurs ont estimé qu’elles devaient être facilement modifiables par l’utilisateur. Leur chaîne de documentation
doit commencer par une astérisque « * ». Si vous avez besoin de contourner cette limitation, jetez un oeil à ‘Le mode
Lisp Interaction’ page 17.
Pour modifier n’importe quelle variable, on utilisera la fonction (ou plutôt special form) ELisp setq, par exemple en
tapant M-: puis (setq variable valeur).
On dispose ensuite (entre autres, comme toujours dans ce tutoriel) des fonctions suivantes dans le mode auto-fill :
M-q (fill-paragraph) Reformater le paragraphe où se trouve le point afin que ses lignes ne dépassent pas fill-column
caractères. Si l’on veut préserver certains sauts de lignes à l’intérieur des paragraphes, on regardera dans l’aide en ligne
d’Emacs (C-h i par exemple) du côté de la variable use-hard-newlines.
Dans la configuration par défaut, on peut aussi reformatter tous les paragraphes contenus dans la region à condition
de la sélectionner avec la souris avant de taper M-q, ce qui équivaut à la fonction fill-region décrite ci-dessous, au
mode de définition près de la zone à traiter.
M-x fill-region (fill-region) Reformater tous les paragraphes de la region comme avec M-q.
On peut également noter qu’Emacs permet de justifier les paragraphes, c’est à dire d’insérer des espaces le plus régulièrement
possible au sein de chaque ligne pour qu’elle fasse exactement fill-column caractères. On peut faire cela ponctuellement
avec par exemple M–- M-q ou de imposer ce mode de fonctionnement de manière globale en mettant à full la variable
default-justification – avec set-variable ou avec ce que nous allons voir en ‘Introduction à ELisp, le dialecte Lisp
d’Emacs’ page 19.
1. On dit dans ce cas que l’on passe 78 comme universal argument à la fonction set-fill-column. Voir ‘Fonctions et commandes’ page 4 pour
une autre utilisation du universal argument.
Chapitre 4. Quelques modes
4.1.2
16
Le mode font-lock
Le mode font-lock est le mode mineur le plus utilisé pour réaliser la couleur syntaxique dans un mode majeur donné.
Autrement dit, il est très utile !
À moins de vouloir réaliser un mode majeur avec colorisation vous-même (auquel cas le GNU Emacs Lisp Reference Manual
répondra à vos attentes), vous n’avez pas grand-chose à savoir de ce mode si ce n’est que :
— vous pouvez l’activer de manière globale (pour tous 2 les modes majeurs supportant le font-lock-mode en mettant la
ligne suivante dans votre .emacs :
(global-font-lock-mode 1)
— même s’il est actif, son nom n’apparaît pas dans la ligne de mode comme dans le cas des autres modes mineurs ;
— il peut être activé et désactivé (toggled) comme pour tout autre mode avec M-x font-lock-mode ;
— pour refaire la colorisation (to fontify en anglais) autour du point (s’il y a un problème local), on peut taper M-g M-g
(font-lock-fontify-block) ;
— pour refaire la colorisation de tout le buffer courant, on peut invoquer la commande font-lock-fontify-buffer ;
— si vous avez une machine lente, vous pouvez régler le niveau de fontification avec la variable
font-lock-maximum-decoration ;
4.2
4.2.1
Majeurs
Le mode Fundamental
Le mode Fundamental est le mode le plus simple d’Emacs (le moins spécialisé). Autant dire qu’il ne présente pas un grand
intérêt en pratique sinon qu’il forme la base pour définir les autres modes. Personnellement, je ne m’en sers jamais ; pour les
fichiers sans particularité (langage de programmation. . .), j’utilise le mode Text.
4.2.2
Le mode Text
Le mode Text est le mode le plus adapté en général quand il s’agit d’éditer un texte dans un langage naturel (par opposition
à un langage de programmation).
Dans ce mode, les paragraphes sont par défaut définis comme étant séparés par une ou plusieurs lignes blanches,
touche TAB invoque la commande indent-relative qui permet d’indenter une ligne comme la précédente, M-TAB lance
ispell-complete-word. . . bref, ce mode est pratique pour éditer du texte (ou un fichier de configuration sans mode prévu
spécialement pour lui, etc.).
Si vous séparez vos paragraphes avec un alinea plutôt qu’avec des lignes blanches, vous serez peut-être intéressé par le
paragraph-indent-text-mode.
4.2.3
Le mode Info
Le mode Info est utilisé pour naviguer au sein du système de documentation hypertexte Info (préféré aujourd’hui aux
manpages par le projet GNU). On y trouve la version Info du GNU Emacs Manual) et plus généralement la documentation
de tous les programmes disposant d’une aide au format Info et ayant été installés correctement (ce qui est fréquent sur les
systèmes de type Unix).
On peut ouvrir un buffer *info* en mode Info avec C-h i (info). La documentation dans ce format est organisée sous
forme d’arbre. On parle de noeud (node en anglais) pour désigner chaque « page » (à comprendre comme une page HTML).
Compte-tenu de la structure d’arbre, il y a un noeud particulier, (pour chaque document au format Info) qui n’a aucun
parent : c’est le noeud Top. Dans chaque noeud se trouvent des références à d’autres noeuds afin de pouvoir explorer l’arbre
(ce sont les références hypertexte). Une telle référence est indiquée par une ligne comme :
* Commands::
Named functions run by key sequences to do editing.
quand on visite un noeud. Il suffit de déplacer le point sur le * Commands:: (en général affiché en gras) et d’appuyer sur RET
pour explorer le noeud indiqué par la référence. On peut également cliquer dessus avec le bouton du milieu pour parvenir à
ce résultat.
En fait, quand on invoque la commande info, on se retrouve dans un noeud dit Top où les références sont aussi des noeuds
Top : c’est simplement que info nous amène dans le fichier dir, qui contient des références à toutes les docs au format Info
2. Cela peut être réglé de manière plus fine si le besoin s’en fait ressentir : voir la variable font-lock-global-modes.
17
correctement installées sur le système et que ces documentations sont chacune un fichier Info indépendant donc commençant
par un noeud Top.
Ceci était pour ceux qui se posent des questions. :-) Il est très simple de se naviguer dans la documentation avec le mode
Info : nous avons vu une manière de visiter un un noeud référencé par le noeud courant. Une autre manière souvent plus
efficace quand on connaît à l’avance le nom du noeud où l’on veut se rendre consiste à appuyer sur m (Info-menu) puis à
utiliser la complétion pour entrer le nom du noeud. Il est également très pratique, comme dans (presque) tout buffer Emacs,
d’utiliser la recherche incrémentale (voir ‘Déplacements’ page 10) pour chercher une information dans un noeud.
Les commandes suivantes sont également très utiles en mode Info :
u (Info-up) remonter d’un niveau dans l’arbre vers le noeud Top
l (Info-last) retourner au noeud précédemment visité
i (Info-index) chercher un noeud relatif à un sujet dans l’index ; on peut ensuite se déplacer parmi les résultats avec
(Info-index-next).
Pour plus d’informations, on consultera la documentation du programme Info (qui existe également indépendamment
d’Emacs). . . au format Info !
4.2.4
Le mode Lisp Interaction
Le mode Lisp Interaction est celui par défaut du buffer *scratch* (qui en principe est ouvert dans toute nouvelle session
Emacs). Il permet d’exécuter/tester facilement des petits bouts de code Lisp.
On y a (via le font-lock-mode) une colorisation adaptée au Lisp, on peut évaluer une expression (comme dans beaucoup
d’autres modes d’ailleurs) avec C-x C-e (eval-last-sexp) en ayant le point juste après la parenthèse qui la termine ; son
résultat (on dit la value de la Lisp form) est affiché dans la echo area (affichée au même endroit que le minibuffer, là ou
vous voyez la plupart des messages comme Auto-saving... ou Fontifying...done, retrouvés par la suite si besoin dans le
buffer *Messages*).
Plus spécifiquement au mode Lisp Interaction, on peut évaluer une Lisp form avec C-j (eval-print-last-sexp) (toujours
avec le point juste après la parenthèse qui la termine). Cette fois-ci, la form value est insérée dans le buffer courant, juste
avant le point, ce qui est très pratique si c’est volumineux, si on veut réutiliser cette valeur pour une autre Lisp form, etc.
Petit exemple pratique : mettez-vous dans le buffer *scratch*, insérez :
(+ 12 42)
Placez le point après la parenthèse fermante. Tapez C-x C-e : 54 (la somme de 12 et 42) s’affiche dans l’echo area. Tapez
C-j : cette fois-ci, 54 est inséré dans le buffer à la ligne suivant (+ 12 42).
Même si vous ne faites jamais de vraie programmation en ELisp, ce mode peut vous être utile par exemple pour affecter des
valeurs à certaines variables :
— si ces variables ne sont pas déclarées comme user customizable (susceptibles d’être modifiées par l’utilisateur dans un
but de configuration), elles ne sont pas accessibles par la commande set-variable mais on peut leur affecter une valeur
avec l’expression Lisp suivante :
(setq variable valeur)
— si la valeur de la variable est pénible à saisir, on ne s’en sort pas avec set-variable (surtout s’il faut faire plusieurs
essais. . .) alors qu’un petit copier/coller dans le buffer *scratch* résout très simplement le problème.
4.2.5
Le mode Hexl
Le mode Hexl permet de voir/éditer un fichier en visualisant l’écriture hexadécimale de chacun de ses octets (ce qui est
pratique dans le cas de fichiers binaires). On peut l’invoquer bien entendu avec M-x hexl-mode.
On trouvera une documentation basique du mode en tapant C-h m (describe-mode) par exemple (dans un buffer en
hexl-mode). On notera que les caractères « normaux » (de code compris entre 0x20 – l’espace – et 0x7E – le tilde –
sont insérés tels quels et que l’on peut insérer un caractère à l’aide de son code écrit en hexadécimal avec M-C-x, décimal
avec M-C-d et octal avec M-C-o.
Pour trouver les autres fonctions (par exemple celles permettant de se déplacer à un offset donné dans le buffer), on pourra
taper C-h b (describe-bindings) dans un buffer en mode Hexl et faire une recherche incrémentale sur hexl- (ceci est une
méthode générale pour trouver rapidement de l’aide sur un mode qu’on ne connaît pas).
18
19
Chapitre 5
Introduction à ELisp, le dialecte Lisp
d’Emacs
Ce chapitre a pour but de vous apprendre les bases juste nécessaires afin de pouvoir utiliser le GNU Emacs Lisp Reference
Manual pour découvrir le reste. Le GNU Emacs Lisp Reference Manual est extrêmement bien fait mais ce n’est pas un
tutoriel : en lecture linéaire, il faut attendre très longtemps avant de savoir écrire sa première fonction, ce qui n’est pas très
pratique quand on débute. . .
Ce chapitre doit donc vous permettre de comprendre de quoi on parle en ELisp afin que vous puissiez par la suite parcourir
sans peine le GNU Emacs Lisp Reference Manual à la recherche d’informations plus précises. Il pourra également être utile
à ceux qui aimeraient comprendre ce qu’ils mettent dans leur .emacs.el.
5.1
Courte présentation
Lisp signifie LISt Processor : l’essentiel des opérations se fait en manipulant des listes comme (34 12 (+ a b)) qui est une
liste composé des entiers 34, 12 et d’une liste elle-même composée des symboles +, a et b. On peut arriver, surtout si on n’aère
ou n’indente pas son code source, à quelque chose de peu lisible, si bien que certains disent de Lisp que ce terme signifie
« Lots of Insipid and Stupid Parentheses. »
Lisp n’est pas un langage. C’est une famille de langages et ELisp (Emacs Lisp) est un dialecte Lisp qui donne accès aux
fonctionnalités offertes par Emacs. C’est un langage interprété (donc très dynamique). On peut toutefois byte-compiler un
fichier ELisp afin d’accélérer son chargement (voir ‘Gestion des fichiers ELisp’ page 27).
5.2
Approche de la syntaxe, évaluation
Quand l’interpréteur Lisp évalue une liste, il évalue récursivement chaque élément de cette liste sauf contre-indication.
L’évaluation d’une liste dont le premier élément est un nom de fonction cause un appel de cette fonction avec pour arguments
les autres éléments de la liste et produit comme résultat la valeur de retour de cette fonction. Par exemple, lors de l’évaluation
de :
(- (* 3 (1+ 4) 2) (/ 4 2))
l’interpréteur Lisp trouve dans la première liste le symbole -, qui est le nom d’une fonction de base d’Emacs (fonction
soustraction) et l’appelle donc avec deux arguments : (* 3 (1+ 4) 5) et (/ 4 2). Le premier est aussi un appel de fonction :
multiplication de 3 par (1+ 4) et par 2, c’est-à-dire de 3 par 5 et par 2 (car 1+ est le nom d’une fonction qui ajoute 1 à son
argument). Ce premier argument vaut donc 30. De même, le deuxième argument de - est le résultat de la division de 4 par 2
donc l’expression entière donne par évaluation 3*5*2-4/2 c’est-à-dire l’entier 28. Mettez-vous dans le buffer *scratch*, tapez
l’expression ci-dessus, placez le point après la parenthèse fermante, tapez C-j ou C-x C-e : vous voyez s’afficher 28 (dans le
buffer si vous avez choisi C-j, dans l’echo area si vous avez choisi C-x C-e).
On peut également, en principe dans n’importe quel mode, évaluer une expression ELisp avec M-: (eval-expression).
L’expression doit être saisie dans le minibuffer et le résultat de son évaluation est affiché (dans la mesure du possible) dans
l’echo area. C’est assez pratique dans certains cas.
Les fonctions sont identifiées par des symboles qui sont leurs noms. Certains noms désignent des fonctions un peu particulières
appelées special forms (tout objet Lisp prévu pour être évalué est appelé une expression ou encore une form – en anglais) :
Chapitre 5. Introduction à ELisp, le dialecte Lisp d’Emacs
20
lors de l’évaluation d’une special form, certains de ses arguments ne sont pas évalués (contrairement à ce qui se passe dans
le cas d’une fonction). Ainsi, quand l’interpréteur Lisp évalue :
(setq ma-variable (+ 3 4))
il n’évalue pas le symbole ma-variable car setq est une special form qui n’évalue pas son premier argument (ceci peut
bien sûr être trouvé en plus complet dans le GNU Emacs Lisp Reference Manual). Par contre, setq évalue son deuxième
argument, qui vaut ici 3+4, c’est-à-dire 7. Finalement, cette expression affecte la valeur 7 à la variable ma-variable. La
valeur de l’expression est 7 (par définition de setq – voir le GNU Emacs Lisp Reference Manual) et peut donc être utilisée
dans un autre appel à setq. Par exemple :
(setq machin (setq truc 5))
affecte 5 aux variables truc et machin (dans cet ordre).
Il est très important que setq n’évalue pas son premier argument. En effet, dans l’exemple :
(setq machin "bla")
si setq évaluait tous ses arguments comme une fonction ordinaire, il y aurait probablement une erreur : soit parce que machin
n’aurait pas de valeur (variable non initialisée), soit parce que machin serait d’un type inadéquat pour désigner le nom d’une
variable (par exemple, machin pourrait être un entier ou une chaîne de caractères, donc on dirait d’affecter la valeur “bla” à
l’entier 3 par exemple).
En fait, c’est précisément à cause de ce comportement que setq a un nom si bizarre : la fonction set est une fonction
d’affectation, une vraie fonction, pas une special form : elle provoque l’évaluation de chacun de ses arguments, ce qui est peu
pratique en général pour affecter une valeur à une variable. Le q de setq signifie quoted, c’est-à-dire « mis entre guillemets. »
En effet, traditionnellement, dans le shell Unix ou certains langages de programmation, on met une expression entre guillemets
quand on veut la protéger de l’évaluation : qu’elle reste intacte lors d’une évaluation.
Pour quoter en ELisp, on dispose de plusieurs méthodes. La première, pas très souple, consiste à utiliser une special form
mais vu qu’on ne fait pas ce qu’on veut de l’argument quoté, ce n’est pas une méthode générale. Deux autres méthodes sont
d’utiliser la fonction quote (à un seul argument) ou son abréviation ’ (une apostrophe).
Mettez-vous dans le buffer *scratch*, tapez
(quote (+ 3 4))
et évaluez cette expression : vous obtenez (+ 3 4) et non 7 : la Lisp form (+ 3 4) a été protégée de l’évaluation par la
fonction quote. Vous obtenez le même résultat en évaluant ’(+ 3 4).
Évaluez ”’12 (ou (quote (quote (quote 12))), ce qui est équivalent) : vous obtenez (quote (quote 12)). Évaluez cette
expression à son tour : vous obtenez (quote 12). Évaluez (quote 12) : vous obtenez 12. Évaluez 12 : vous obtenez 12. Les
entiers sont invariants par évaluation. On dit qu’ils sont self-evaluating. En fait, toute Lisp form qui n’est ni une liste, ni un
symbole (voir ‘Les symboles’ page ci-contre) est self-evaluating. Donc les nombres, les chaînes de caractères comme "Emacs
est génial" ou les arrays comme [12 3 42] sont invariants par évaluation.
Finalement, pour affecter la valeur 3 à machin, vous avez de nombreuses possibilités :
(setq machin
(set ’machin
(setq machin
(set ’machin
3)
3)
’3) ; car ’3, identique à (quote 3), est évalué pour donner 3
’3)
ou encore beaucoup plus tordu :
(setq nom ’machin)
(set nom 3)
set attend comme premier argument un symbole qui est le nom de la variable à affecter. Ici, le résultat de l”évaluation de
nom dans (set nom 3) est le symbole machin donc on affecte bien 3 à la variable machin.
5.3
21
Les symboles
Un symbole (symbol en anglais) est un type de données Lisp fondamental permettant de nommer les fonctions et les variables,
aussi bien que d’être utilisé tel quel. Le nom en question est une suite de caractères choisis parmi un ensemble précisé dans
le GNU Emacs Lisp Reference Manual.
On dit qu’un symbole a plusieurs composantes (appelées components ou cells en anglais), entre autres les trois suivantes :
— la print name cell qui contient la chaîne de caractères utilisée pour représenter le symbole (par exemple quand on l’écrit
dans son programme) ;
— la function cell qui contient éventuellement une définition de fonction : la fonction dont le nom est celui du symbole ;
— la value cell qui contient la valeur de la variable dont le nom est celui du symbole, si elle a été affectée ;
Quand Emacs évalue une liste, il cherche la function cell du symbole qui est le premier élément de la liste (si c’est un symbole,
sinon il y a une erreur) pour accéder à la fonction en question. Si cette function cell est vide, on obtient le message d’erreur
bien connu : Symbol’s function definition is void: <nom-du-symbole>. Pour les autres éléments de la liste, il cherche
dans la value cell afin de déterminer la valeur des arguments correspondants, d’où le message d’erreur encore plus célèbre
quand on tente d’évaluer une variable à laquelle aucune valeur n’a été affectée : Symbol’s value as variable is void:
<le-nom-du-symbole>.
Finalement, dans une première approche, les symboles n’ont rien de compliqué : ce sont des noms comme toto, machin,
global-font-lock-mode, etc. permettant d’accéder soit à une variable, soit à une fonction, selon le contexte dans lequel ils
sont utilisés.
Il existe en ELisp deux symboles particuliers : t et nil. Ces symboles n’ont pas de function cell ni de value cell. On ne
peut pas les utiliser comme noms de fonctions. Par contre, il sont fréquemment utilisés comme arguments à des fonctions ou
comme résultat de l’évaluation d’une fonction (t signifiant souvent true, c’est-à-dire « vrai » et nil « faux »).
On utilise parfois les symboles directement pour leur nom et non pour leur function cell ou leur value cell. Par exemple, j’ai
dans mon .emacs.el pour préciser la taille du papier pour certaines fonctions de génération de fichiers prêts à être imprimés
(PostScript) la ligne suivante :
(setq ps-paper-type ’a4)
Le cas le plus fréquent d’utilisation d’un symbole tel quel est cependant celui de t ou nil, comme dans le cas de
(setq next-line-add-newlines nil)
qui permet de signaler à Emacs qu’on ne veut pas (nil) qu’il ajoute des lignes à un buffer quand on demande d’aller à la
ligne suivante alors qu’on est déjà à la fin de ce buffer.
5.4
Manipulation des variables
Nous avons déjà vu l’essentiel sur ce sujet en ‘Approche de la syntaxe, évaluation’ page 19. Nous avons en particulier déjà
parlé de setq pour affecter une valeur à une variable. On peut appeler cette special form avec plus de deux arguments pour
affecter plusieurs valeurs à plusieurs variables :
(setq variable1
variable2
.........
variablen
valeur1
valeur2
.......
valeurn)
Nous n’avons cependant pas encore évoqué l’existence de variables locales à un buffer (en anglais : buffer-local variables). Il
s’agit de variables (comme fill-column) qui peuvent avoir plusieurs valeurs différentes dans plusieurs buffers à un moment
donné d’une session Emacs. Quand on évalue (setq variable valeur) dans un buffer et que variable est buffer-local, on
n’affecte pas la valeur de cette variable dans les autres buffers.
Mais que se passe-t-il quand on crée un buffer ? Quelle valeur prend une variable buffer-local dans ce nouveau buffer ?
Réponse : sa valeur par défaut (en anglais, default value). Pour changer cette dernière, on utilisera setq-default au lieu de
setq.
Il y a quelques petits détails supplémentaires à ce sujet que vous trouverez si besoin dans le GNU Emacs Lisp Reference
Manual (notamment comment faire en sorte qu’une variable soit locale à un buffer).
5.5
22
Écrire une fonction
On distingue essentiellement deux types de fonctions en ELisp : les fonctions qui sont dans la function cell d’un symbole,
autrement dit celles qui ont un nom (celui du symbole) et les fonctions anonymes, qui sont utilisées soit temporairement,
soit stockées dans une liste, etc.
5.5.1
Fonctions nommées
Pour définir une fonction nommée, on dispose de la special form defun dont voici une syntaxe simplifiée :
(defun nom-de-la-fonction (argument1 argument2 ... argumentn)
"Chaîne de caractère pour documenter la fonction"
(Lisp form1)
(Lisp form2)
............
(Lisp formn)
)
Par exemple, voici une fonction qui prend deux arguments supposés être des chaînes de caractères et qui retourne la concaténation de ces deux chaînes de caractères :
(defun fonction-inutile (ch1 ch2)
"Fonction inutile pour concaténer deux chaînes de caractères.
Cette fonction est inutile car la fonction concat fait bien mieux
ce travail. C’est juste un exemple. D’ailleurs, cette fonction fait
appel à concat..."
(concat ch1 ch2))
Ici, il n’y a qu’une Lisp form dans le corps de la fonction : (concat ch1 ch2). Évaluez l’expression entière de définition
de fonction-inutile dans le buffer *scratch* puis évaluez par exemple (fonction-inutile "abc" "def") : vous obtenez le
résultat attendu, à savoir "abcdef".
La chaîne de caractères de documentation est optionnelle mais si vous avez l’intention de distribuer votre programme, il est
fortement conseillé de la mettre. On peut spécifier des arguments optionnels de la manière suivante :
(defun fonction-inutile (ch1 ch2 &optional ch3 ch4)
"Fonction inutile pour concaténer deux chaînes de caractères.
Cette fonction est inutile car la fonction concat fait bien mieux
ce travail. C’est juste un exemple. D’ailleurs, cette fonction fait
appel à concat..."
(if (and (not (null ch3))
(not (null ch4)))
(message (concat "Plonk ! " ch3 ch4))
(goto-char (point-min))
)
(concat ch1 ch2))
Ici, ch3 et ch4 sont optionnels. La fonction commence par tester si ces arguments ont été fournis lors de l’appel (sinon, Emacs
leur attribue la valeur nil) 1 . Si oui, elle affiche dans l’echo area un message composé à l’aide de ces arguments, sinon elle
déplace le point au début du buffer courant (oui, c’est vraiment une fonction inutile). Puis elle retourne comme la précédente
la concaténation de ses deux premiers arguments.
Les fonctions définies en ELisp peuvent même être déclarées comme admettant un nombre quelconque d’arguments optionnels : voir le GNU Emacs Lisp Reference Manual.
Les fonctions que nous venons de définir sont bien jolies, mais elles ne peuvent être appelées que par du code ELisp :
ce ne sont pas des commandes. Pour transformer une fonction en commande, afin qu’elle puisse être appelée par
M-x nom-de-la-fonction, il suffit d’ajouter une interactive declaration au début de la fonction comme dans l’exemple
suivant :
(defun ma-fonction ()
"Fonction d’exemple.
Fonction qui amène le point juste après le prochain nombre entier (écrit en
décimal) du buffer courant."
(interactive)
(save-match-data
(re-search-forward "[0-9]+")))
1. Ce test pourrait être écrit de manière plus courte mais cette syntaxe est proche de ce qu’on expliquerait oralement (si les arguments ne valent
pas nil, alors faire. . .).
23
On a simplement rajouté le (interactive) comme toute première Lisp form de la définition de ma-fonction.
L’appel à save-match-data sert juste à être propre car la fonction re-search-forward met à jour la match data, qui
mémorise des informations sur la dernière recherche faite avec des regular expressions (chercher « Regexps » dans le GNU
Emacs Manual), par exemple pour savoir qu’est-ce qui a été trouvé (où ça commence, où ça se termine, etc.). Si ma-fonction
est appelée entre deux Lisp forms qui travaillent sur la match data, on est sûr grâce au save-match-data qu’elle ne perturbera
pas la deuxième fonction. Ceci n’est pas très important à votre stade supposé de la connaissance d’ELisp. C’est juste pour
ne pas donner de mauvais exemple ni laisser de point obscur. :-)
Dans le cas précédent, transformer la fonction en commande était donc extrêmement simple : rajout de (interactive). Cela
se complique dans le cas d’une fonction qui prend au moins un argument obligatoire car il faut préciser comment elle les
obtient lorsqu’on invoque M-x nom-de-la-fonction. Cela peut se faire dans la plupart des cas en appelant interactive
avec une chaîne de caractères en argument mais on peut procéder différemment. Voir le GNU Emacs Lisp Reference Manual
à la section Using interactive pour plus d’informations. Voici un exemple de fonction qui prend deux arguments : des numéros
de caractères dans le buffer courant (ils servent donc à préciser deux « endroits » du buffer) et qui efface tout le texte compris
entre ces deux positions. Quand la fonction est invoquée par M-x efface, les deux positions sont les extrémités de la region
(tiens, r comme region, c’est marrant. . .).
(defun efface (pos1 pos2)
"Chaîne de documentation..."
(interactive "r")
(delete-region pos1 pos2))
Pour finir, quelques règles de bonne conduite quand vous définissez des fonctions :
— donnez-leur un nom dont vous êtes sûr qu’il est unique (typiquement préfixé par quelque chose identifiant le tout auquel
elles participent : par exemple, tous les noms des fonctions du mode Hexl commencent par hexl-) ;
— écrivez le plus possible en anglais (au moins le nom et la documentation de la fonction) pour que tout le monde puisse
en profiter !
— composez votre chaîne de documentation comme il se doit, c’est-à-dire commençant par une description très brève en
une ligne si possible, un retour à la ligne puis une description détaillée.
Il y a un certain nombre d’autres règles de bonnes conduite visant à assurer la cohérence au sein d’Emacs, vous les trouverez
dans le GNU Emacs Lisp Reference Manual, à la section Tips and Conventions.
5.5.2
Fonctions anonymes
Comme leur nom l’indique, les fonctions anonymes n’ont pas de nom. On les appelle aussi des lambda expressions. Voici
comment définir une telle fonction :
(lambda (arg1 arg2 argn)
(Lisp form1)
(Lisp form2)
.............
(Lisp formn))
Par exemple, si vous évaluez :
(
(lambda (arg1 arg2 arg3)
(* (+ arg1 arg2) arg3))
2 4 3)
vous obtenez le résultat de l’appel d’une fonction anonyme qui ajoute ses deux premiers arguments et multiplie le résultat
par le troisième, appelée avec les arguments 2, 4 et 3. On obtient donc (2+4)*3, soit 18.
Jusqu’ici, les fonctions anonymes n’ont pas l’air très utiles. Elles le deviennent quand on programme et qu’on a besoin d’une
fonction qui ne sert qu’une fois au milieu d’une autre. Elles sont également très pratiques quand on souhaite ajouter des
fonctions à un hook, par exemple pour configurer le processus d’entrée dans un mode donné.
En effet, tout mode machin digne de ce nom définit un hook appelé machin-mode-hook 2 qui permet « d’accrocher » (hook
signifie crochet) à un événement des fonctions définies par l’utilisateur. L’événement en question peut être l’ouverture d’un
buffer dans le mode machin, par exemple.
Ainsi, avec la ligne suivante dans mon .emacs.el :
(add-hook ’text-mode-hook ’turn-on-auto-fill)
2. Le nom peut être légèrement différent si les fonctions du hook sont censées accepter des arguments. Voir le GNU Emacs Lisp Reference
Manual.
24
j’active le mode mineur auto-fill-mode dans tout buffer qui passe dans le mode majeur Text (text-mode).
L’utilisation de lambda expressions permet d’ajouter des fonctions plus complexes à un hook sans avoir à les déclarer comme
fonction nommées. Par exemple :
(add-hook ’sgml-mode-hook
#’(lambda ()
(when (featurep ’psgml-init)
(require ’flo-psgml)
(define-key sgml-mode-map "\C-cf"
’flo-fill-debiandoc-sgml-item))))
fait des petites choses à l’initialisation du sgml-mode. Le # est optionnel, il sert à préciser que ce qui suit (et qui est quoté)
est une fonction et peut donc être byte-compilé sans crainte si le fichier l’est. C’est un peu mieux que de mettre un simple
quote (’).
5.6
Compléments sur les listes
Comme vous l’avez compris, la liste est un type de données fondamental pour l’interpréteur ELisp. Si vous faites un peu
d’ELisp, vous aurez vite besoin de manipuler une liste ou de comprendre certaines fonctions aux noms peu évocateurs comme
car ou cdr.
Je vais donc vous expliquer ici ce qu’il est important de connaître sur les listes sans être évident (pour les choses simples
du genre récupérer le n-ième élément d’une liste, je vous laisse vous reporter à la section adéquate du GNU Emacs Lisp
Reference Manual).
5.6.1
Les cons cells
La liste au sens d’ELisp est construite de manière récursive, comme nous allons bientôt le voir, à partir de cons cells. Une cons
cell est une structure manipulée par ELisp contenant deux références (deux pointeurs) vers deux objets ELisp quelconques.
Ces deux objets sont appelés le CAR et le CDR de la cons cell (pour des raisons qui tiennent à l’histoire du Lisp).
Pour créer une cons cell ayant pour CAR l’entier 2 et pour CDR la chaîne de caractères "abcd", il suffit d’écrire en ELisp :
(2 . "abcd") (ceci est appelé la dotted pair notation).
On peut également utiliser la fonction cons de la manière suivante :
(cons 2 "abcd")
La différence importante entre ces deux méthodes est que cons étant une fonction, arg1 arg2 sont évalués lorsqu’on appelle
(cons arg1 arg2), contrairement à ce qui se passe lorsqu’on utilise la dotted pair notation.
Les cons cells peuvent être imbriquées (puisque le CAR et le CDR contiennent des références vers n’importe quel objet
ELisp). Lorsque vous évaluez une expression du type ’(2 . (3 . 4)), vous obtenez (2 3 . 4) et non (2 . (3 . 4)).
Ces deux objets sont les mêmes. Ce sont simplement deux façons différentes de les représenter. De même, on pourra écrire
avantageusement (2 3 4 5 . 6) plutôt que ’(2 . (3 . (4 . (5 . 6)))) qui représente le même objet ELisp.
On peut accéder au car d’une cons cell avec la fonction (ô surprise !) car. Par exemple, le résultat de l’évaluation de (car
’(2 3 4 5 . 6)) qui, rappelons-le, est une expression équivalente à (car ’(2 . (3 . (4 . (5 . 6))))), est l’entier 2.
De même, la fonction cdr permet d’accéder au CDR d’une cons cell. Par exemple, (cdr ’(2 3 4 5 . 6)) donne comme
attendu (3 4 5 . 6).
5.6.2
La Vraie Nature des listes
Une liste en ELisp est définie de manière récursive :
— une liste vide est égale à nil. Si vous ne me croyez pas, évaluez l’expression ELisp (). Vous obtenez nil.
— une liste non vide est une cons cell (voir ‘Les cons cells’ de la présente page) dont le CAR est un objet ELisp quelconque
et le CDR est une liste.
La liste (12 42 "WAP" consultant) est en fait une cons cell dont le CAR est l’entier 12 et le CDR une cons cell dont le
CAR est 42 et le CDR une cons cell dont le CAR est la chaîne de caractères "WAP" et le CDR une cons cell dont le CAR est
le symbole consultant et le CDR nil.
C’est immonde, vous ne me croyez pas. Évaluez donc :
25
’(12 . (42 . ("WAP" . (consultant . nil))))
ou encore :
’(12 42 "WAP" consultant . nil)
qui, comme nous l’avons vu en ‘Les cons cells’ page précédente, lui est équivalent. Vous obtenez la liste (12 42 "WAP"
consultant).
Cette représentation est tout à fait générale et permet donc sans problème d’inclure des listes comme éléments d’autres listes.
Par exemple, la structure de la liste (12 42 ("WAP" consultant)) est représentée par l’expression :
’(12 . (42 . (("WAP" . (consultant . nil)) . nil)))
dont l’évaluation conduit bien à (12 42 ("WAP" consultant)).
Si cela vous semble obscur, sachez qu’il y a des petits dessins pour illustrer la structure des listes dans le GNU Emacs Lisp
Reference Manual. . .
5.7
Quelques mots sur les chaînes de caractères
Je serai assez bref dans cette section. Je vais seulement parler un peu des caractères en ELisp et de la read syntax des chaînes
de caractères ELisp, c’est-à-dire la syntaxe que vous pouvez utiliser dans un programme ELisp pour les représenter.
5.7.1
Les caractères
Un caractère en ELisp est un simple entier. Une read syntax pratique pour un caractère est, plutôt que d’utiliser son code,
celle mettant en jeu un point d’interrogation : ainsi, ?a est une read syntax pour le caractère a et est équivalente à 97, le
code ASCII (en décimal) de ce caractère.
On peut construire une chaîne de caractères à partir de caractères avec la fonction string :
(string ?A ?a ?b 97 ?c ?d)
donne après évaluation la chaîne de caractères "Aabacd".
Vous trouverez beaucoup plus d’informations sur la read syntax des caractères au début du GNU Emacs Lisp Reference
Manual si besoin.
5.7.2
La read syntax des chaînes de caractères
Cette read syntax traite le caractère antislash (\) de manière particulière. Entre autres :
— \n est remplacé par le caractère de code 10 (c’est-à-dire newline dans le code ASCII) ;
— \t est remplacé par le caractère de code 9 (caractère de tabulation dans le code ASCII) ;
— \" est remplacé par un " ;
— \\ est remplacé par un simple antislash (\) ;
— \ immédiatement suivi d’un saut de ligne est ignoré (c’est la séquence des deux, donc saut de ligne compris, qui est
ignorée).
Par exemple :
"a3\\nt\
b\"c\nd"
est une read syntax pour la chaîne de caractères composée des caractères a, 3, \, n, t, b, ", c, newline et d.
Les backslash escape-sequences utilisables dans les chaînes de caractères sont les mêmes que celles utilisables pour les caractères
eux-mêmes et leur liste complète se trouve donc à la section Character Type du GNU Emacs Lisp Reference Manual.
5.8
26
Quelques constructions pratiques
Je vais juste mentionner ici l’existence de quelques constructions très pratiques en ELisp qu’il est indispensable de connaître
dès qu’on programme un peu. Je vous fais par contre confiance pour trouver vous-même dans le GNU Emacs Lisp Reference
Manual les special forms « évidentes » comme while, if ou cond qui fournissent les structures de contrôle habituelles d’un
langage de programmation.
La première est introduite par la special form let (le terme special form est expliqué dans ‘Approche de la syntaxe, évaluation’
page 19). Par exemple :
(let (a bla c d)
(Lisp form 1)
(Lisp form 2)
..............
(Lisp form n)
)
est une Lisp form dont l’évaluation provoque l’évaluation successive de (Lisp form 1). . . (Lisp form n) avec a, bla, c, et
d comme variables locales (locales au let). La liste suivant le let permet quelques variations sur la syntaxe. Par exemple,
avec :
(let (a (bla "kjk") (c 3) d)
(Lisp form 1)
(Lisp form 2)
..............
(Lisp form n)
)
bla et c sont initialisées (localement au let) avec les valeurs "kjk" et 3, respectivement.
Il existe une variante de let, à savoir let*, qui permet d’initialiser une variable en fonction d’une variable précédemment
initialisée par ce même let* (dans l’exemple précédent, cela permettrait d’utiliser la valeur affectée à bla, c’est-à-dire "kjk",
pour initialiser c).
La deuxième construction dont je tiens à vous signaler l’existence est introduite par la special form progn. Elle permet de
construire un bloc d’instructions ELisp, tout comme let, mais est plus simple car ne permet pas directement la création de
variables locales à ce bloc (elle le permet indirectement bien sûr, en mettant un appel à let dans le progn). Par exemple, la
Lisp form suivante :
(progn
(setq machin "e-")
(setq machin (concat machin "commerce"))
(message machin))
provoque après évaluation l’affectation de la valeur "e-commerce" à la variable machin puis l’affichage du message
"e-commerce" dans l’echo area (l’affectation n’est a priori pas locale, donc c’est plutôt sale ; ce n’est qu’un exemple).
Ceci est très pratique, notamment quand on sait que la syntaxe de la special form if est :
(if condition then-form else-forms...)
En effet, il n’y a qu’une seule then-form, donc un progn s’avère bien pratique pour faire plusieurs choses dans la clause then.
La troisième construction dont je souhaite vous signaler l’existence avant que vous ne partiez seul(e) dans l’exploration du
GNU Emacs Lisp Reference Manual est introduite par la special form save-excursion. En fait, il existe pas mal de special
forms très utiles dont le nom commence par save.
save-excursion est à utiliser dans pratiquement toute fonction qui déplace le point et/ou la marque et/ou change de buffer.
L’évaluation de :
(save-excursion
(Lisp form 1)
(Lisp form 2)
..............
(Lisp form n)
)
provoque l’évaluation de (Lisp form 1). . . (Lisp form n) et fait en sorte que le buffer courant, la position du point et celle
de la marque soient inchangés avant et après l’évaluation cette Lisp form. Pour être précis, c’est l’identité et non le contenu
du buffer courant qui reste inchangée.
Cette fonction est indispensable si on veut programmer proprement. Pour citer le GNU Emacs Lisp Reference Manual : « It
is used more than 4000 times in the Lisp sources of Emacs. »
Il existe d’autres fonctions très utiles dans le même ordre d’idées. Parmi elles, unwind-protect, with-temp-buffer,
with-temp-file, with-current-buffer, save-match-data, . . .
5.9
27
Gestion des fichiers ELisp
Si vous avez lu les sections précédentes, vous savez écrire un peu d’ELisp et vous vous demandez certainement comment
stocker vos définitions de fonctions dans des fichiers afin de pouvoir les charger lors d’une session Emacs ultérieure (et d’en
faire profiter toute la communauté Emacs, merci d’avance).
Il suffit pour cela de placer le code ELisp dans un fichier d’extension .el. Pour le charger, on utilisera load ou require
en conjonction avec provide. Notez que la fonction locate-library permet de savoir si un fichier peut être trouvé dans le
load-path.
Si vous écrivez un fichier ELisp, vous avez intérêt une fois que vous l’estimez stable à le byte-compiler, par exemple avec
l’entrée « Byte-compile This File » du menu Emacs-Lisp présent en mode Emacs-Lisp. La byte-compilation d’un fichier
toto.el produit un fichier toto.elc (ELisp Compiled) qui est chargé plus rapidement que toto.el (avec load, require,
etc. qui détectent automatiquement la présence d’un fichier .elc lorsqu’on ne précise pas l’extension).
28
29
Chapitre 6
Quelques idées pour votre fichier
d’initialisation
Je vais dans ce chapitre indiquer quelques variables, packages ou fonctions rencontrés dans mon .emacs.el afin que vous
puissiez avoir rapidement un Emacs agréable à utiliser.
Mais qu’est-ce donc que ce .emacs.el (ou .emacs) dont on parle partout ? C’est le fichier que vous devez utiliser pour personnaliser Emacs. La notation .emacs.el (comprise par Emacs depuis la version 20.4) est plus cohérente que la traditionnelle
appellation .emacs car ce fichier est un fichier ELisp, comme tous les fichiers se terminant en .el livrés avec Emacs 1 .
Si vous venez d’installer Emacs, vous n’avez probablement pas déjà de .emacs ni de .emacs.el et utilisez donc la configuration
par défaut d’Emacs (sauf si vous avez un site-start.el (ou site-start.elc) dont le but est d’effectuer une configuration
globale d’Emacs pour tout un site, alors que le .emacs.el est censé être propre à chaque utilisateur). Dans ce cas, il faut le
créer dans un répertoire indiqué par la variable d’environnement HOME pour qu’Emacs le trouve. Sur les systèmes Unix, cette
variable d’environnement est toujours définie. Sous Windows, vous devrez certainement la déclarer dans votre autoexec.bat
(le fichier C:\autoexec.bat) avec une ligne du type :
Set HOME=C:\PROGRA~1\emacs
ou
Set HOME=C:\Marcel
ou que sais-je pourvu que dans se répertoire se trouve un fichier nommé .emacs ou .emacs.el ou encore paraît-il, puisque
l’explorateur Windows ne permettrait pas, dit-on, de créer facilement un fichier de ce nom, _emacs ou _emacs.el (je n’ai pas
vérifié). N.B. : sous Windows 95/98, il faut redémarrer l’ordinateur pour que la modification de HOME dans l’autoexec.bat
soit prise en compte. . .
Si vous êtes masochiste ou avez vraiment une raison valable de byte-compiler votre .emacs.el, libre à vous de le faire ; dans
les autres cas, cela vous apporterait certainement plus de tracas que d’avantages.
Le fichier .emacs.el, si Emacs parvient à le trouver, i.e. s’il est dans votre répertoire HOME, est lu et exécuté (c’est du
ELisp) par Emacs à la fin de son lancement. Pour vous en convaincre, vous pouvez par exemple ne mettre que la ligne
suivante dans votre .emacs.el :
(insert "Ce texte a été inséré ici par mon .emacs.el !")
et (re)lancer Emacs.
Voici donc quelques idées pour personnaliser Emacs à l’aide de ce fameux .emacs.el.
1. Si vous avez téléchargé une version d’Emacs sans les sources, vous n’avez peut-être que des fichiers se terminant en .elc à la place des .el.
Chaque fichier toto.elc est le résultat de la byte-compilation de toto.el. Il peut remplacer le fichier .el si vous n’avez besoin ni de le voir, ni
de le modifier. Il est chargé un peu plus rapidement que le .el, c’est pourquoi on byte-compile en général la plupart des fichiers d’Emacs et des
packages qu’on installe pour Emacs (ce qui n’empêche pas de garder les .el !).
Chapitre 6. Quelques idées pour votre fichier d’initialisation
6.1
30
Avec une version récente
Les suggestions suivantes s’appliquent en priorité à Emacs 23. Pour une version plus récente, penser à lire les changements
importants avec C-h N.
— En premier lieu, pour qu’Emacs sache dans quel environnement linguistique il est utilisé (on peut par exemple taper
du chinois ou du japonais avec Emacs), il est utile de lui préciser le language environment. Dans la mesure du possible,
je conseille d’utiliser UTF-8. Il s’agit du codage Unicode le plus répandu. Il permet de représenter les caractères d’à
peu près toutes les langues connues à ce jour et présente l’avantage, contrairement à d’autres codages Unicode, d’être
entièrement compatible avec le bon vieil ASCII. À cet effet, on pourra utiliser :
(set-language-environment "UTF-8")
;; UTF-8 en priorité, puis latin1, puis priorités définies par Emacs
(prefer-coding-system ’latin-1)
(prefer-coding-system ’utf-8)
L’alternative la plus courante à UTF-8 en France est ISO 8859-1, couramment appelé « Latin-1 ». UTF-8 est nettement
préférable car Latin-1 ne permet de représenter que les caractères les plus utilisés en Europe occidentale (concernant le
français, il manque le symbole euro, le « e dans l’o » et. . . le y tréma majuscule). Pour travailler en Latin-1 par défaut :
(set-language-environment "Latin-1")
Remarque : il est de bon ton de préciser le codage de chaque fichier texte dans ses deux premières lignes avec une
indication du type :
-*- coding: utf-8 -*-
Cette indication suit une syntaxe qui est comprise par Emacs et Python (entre autres). Elle peut être précédée ou
suivie de caractères quelconques afin de ne pas perturber les programmes qui auraient à lire le fichier (par exemple, on
la précèdera de « ;; » dans un fichier Emacs Lisp pour en faire un commentaire). Il est également possible de déclarer
le codage d’un fichier en plaçant une déclaration à la fin de celui-ci, mais elle ne sera a priori exploitable que par Emacs
(voir la section File Variables du GNU Emacs Manual).
N.B. : le codage de caractères utilisé par Emacs pour lire et écrire dans un fichier donné est indiqué à gauche de la
mode line, avec par exemple un U en UTF-8, un 1 en Latin-1, un 0 en ISO 8859-15, etc.
En cas de problème lors de l’interprétation des caractères entrés au clavier, on pourra tenter des variations sur les deux
commandes suivantes :
(set-keyboard-coding-system default-keyboard-coding-system)
(set-terminal-coding-system default-terminal-coding-system)
Notez qu’il existe un mécanisme permettant de changer la manière, appelée input method, dont sont interprétées
certaines séquences de touches. Ainsi, on peut faire en sorte par ce moyen de saisir les caractères accentués comme
« é » en tapant ’ puis e (latin-1-prefix) ou bien en tapant e puis ’ (latin-1-postfix). On peut changer d’input
method en choisissant Mule (Multilingual Environment) dans le menu Options. C’est grâce à ce mécanisme qu’on peut
taper en chinois ou en japonais sous Emacs avec un clavier US, azerty. . .
— Toujours en ce qui concerne la saisie, la ligne suivante est très pratique (déjà activée par défaut sous Emacs 23) :
;; Très pratique (C-x 8 machin, Alt-machin...) pour insérer des car. spéciaux
(require ’iso-transl)
Elle permet par exemple de taper un espace insécable avec C-x 8 SPC, un guillemet ouvrant avec C-x 8 <, un guillemet
fermant avec C-x 8 > et beaucoup d’autres choses que j’utilise moins souvent (que l’on peut trouver avec C-h b –
describe-bindings – en cherchant « iso-transl- »).
— Si vous utilisez Emacs sur plusieurs systèmes d’exploitation et/ou plusieurs machines, ils n’auront probablement pas
tous la même configuration. Pour faire la différence entre les uns et les autres dans votre .emacs.el, vous pouvez
utiliser les variables :
system-type Peut prendre des valeurs comme "gnu/linux" ou "windows-nt". Exemple :
(if ((string-equal system-type "windows-nt"))
(message "On est sous Windows.")
(message "On n’est pas sous Windows."))
system-name Sur un système GNU/Linux, cette variable donne le nom DNS complet de la machine (Fully Qualified
Domain Name – voir hostname –-fqdn), ou à défaut le nom de l’ordinateur sans suffixe de domaine (par exemple,
zita). Sur un Windows NT où j’ai effectué le test, elle vaut le nom NetBIOS de la machine (nom de la machine
sur le « voisinage réseau »). string-equal, comme nous venons de le voir avec system-type, pourra faire l’affaire
dans la plupart des cas ;
emacs-major-version et emacs-minor-version Ces variables permettent de choisir du code ELisp à exécuter en
fonction de la version d’Emacs. Par exemple :
31
(unless (>= (+ emacs-major-version (/ emacs-minor-version 10.0)) 20.4)
(autoload ’sql-mode "sql"))
charge le mode SQL à partir d’un fichier sql.el ou sql.elc supposé installé par vous dans le load-path (voir
un peu plus loin pour les explications sur cette variable) si la version d’Emacs est antérieure à 20.4 (à partir de
laquelle le mode SQL est reconnu dans la configuration par défaut).
exec-directory Cette variable m’est surtout utile sous Windows où elle indique le nom complet du répertoire bin d’Emacs (et permet donc d’accéder à <répertoire d’Emacs>/site-lisp par exemple en y rajoutant
"../site-lisp". . .) ;
— Les variables suivantes permettent de changer certains comportements par défaut qui sont parfois agaçants :
inhibit-startup-message En mettant cette variable à t avec une ligne comme :
(setq inhibit-startup-message t)
vous aurez un buffer *scratch* vide au lancement d’Emacs au lieu d’avoir le traditionnel message de présentation
et les explications bien connues dans le buffer *scratch*.
visible-bell En mettant cette variable à t avec une ligne comme :
(setq visible-bell t)
Emacs ne provoquera pas l’émission d’un son lors d’un appui par exemple sur C-g (keyboard-quit), mais fera en
quelque sorte clignoter la fenêtre pour faire passer le message.
— Vous pouvez redéfinir des séquences de touches de manière globale (i.e. valable quels que soient les modes majeur et
mineurs actifs) avec global-set-key comme suit :
(global-set-key [delete] ’delete-char)
;; Pour que ESC [ 4 ~ (ie. la touche Fin) lance end-of-line quand Emacs
;; tourne dans un terminal
(unless window-system
(global-set-key [select] ’end-of-line))
N.B. : je ne prétends pas à l’universalité du (global-set-key [select] ’end-of-line) indépendamment du type
de terminal. . . cela fonctionne dans mon cas et sert juste à vous donner une idée de ce qu’on peut faire.
Si vous ne connaissez pas le nom d’une touche pour Emacs comme delete ou select ci-dessus, utilisez C-h k !
— Si vous voulez un .emacs.el unique pour plusieurs configurations, vous apprécierez probablement la fonction
locate-library :
;; Chargement de AUCTeX s’il est dans le load-path
(if (locate-library "tex-site")
(require ’tex-site))
On peut également utiliser la fonction featurep pour tester si une fonctionnalité particulière a été chargée avec provide.
— À partir d’Emacs 21, il y a par défaut une barre de boutons (« barre d’outils ») et un curseur clignotant. Voici comment
remédier à ces problèmes depuis le .emacs.el :
;; Suppression de la barre d’outils
(tool-bar-mode 0)
;; Pour que le curseur ne clignote plus
(blink-cursor-mode 0)
— Quelques bindings pratiques :
(global-set-key
(global-set-key
(global-set-key
(global-set-key
[C-up] ’flo-scroll-one-line-down)
[C-down] ’flo-scroll-one-line-up)
"\C-z" ’undo)
"ce-que-vous-voulez-je-ne-veux-pas-le-savoir" ’goto-line)
où flo-scroll-one-line-down et flo-scroll-one-line-up sont définies en ce qui me concerne dans un fichier séparé
par :
(defun flo-scroll-one-line-up ()
"Scroll text of current window upward one line."
(interactive)
(scroll-up 1))
(defun flo-scroll-one-line-down ()
"Scroll text of current window downward one line."
(interactive)
(scroll-down 1))
— Pour faciliter l’insertion des guillemets à la française et des espaces insécables :
32
(defun flo-insert-left-guillemets ()
(interactive)
(insert (make-char ’latin-iso8859-15 171)))
(defun flo-insert-right-guillemets ()
(interactive)
(defun flo-insert-no-break-space ()
(interactive)
(global-set-key [?\s-<] ’flo-insert-left-guillemets)
(global-set-key [?\s->] ’flo-insert-right-guillemets)
(global-set-key (kbd "s-SPC") ’flo-insert-no-break-space)
où, dans ma configuration sous GNU/Linux, le modificateur s (Super) correspond à la touche Windows de gauche (au
moins une chose positive que nous aura laissée ce cher Bill).
— Si vous vous faites un .emacs.el « dynamique » (qui « réagit » en fonction de la machine ou du système sur laquelle
(lequel) il est lancé), vous trouverez certainement la fonction concat très utile pour concaténer plusieurs chaînes de
caractères :
(setq flo-site-lisp-dir
(cond (flo-on-windows-at-home-p
(concat exec-directory "../site-lisp/"))
(flo-at-work-p "~/Lisp/")
(t "/usr/share/emacs/site-lisp/")))
cond est quant à elle très pratique pour gérer plusieurs alternatives. Voir le GNU Emacs Lisp Reference Manual pour
les détails de son utilisation.
— La fonction add-to-list permet de d’ajouter un élément à une liste si, et seulement s’il n’y est pas déjà :
(if flo-on-windows-p
(add-to-list ’load-path flo-site-lisp-dir))
ou, très simplement, si vous débarquez et ne comprenez pas ce qui précède :
(add-to-list ’load-path "c:/marcel/lisp")
— La variable load-path joue un rôle très important : elle contient la liste des répertoires qu’Emacs parcourt lorsqu’on
lui demande de charger un fichier ELisp (avec load ou require par exemple). L’installation d’un nouveau mode,
programme, etc. pour Emacs passe donc presque toujours par l’ajout d’un élément au load-path.
— Les lignes suivantes sont un peu plus adaptées au français que la configuration par défaut d’Emacs :
(setq colon-double-space nil)
(setq sentence-end-double-space nil)
(setq sentence-end "[.?!][]\"»’)}]*\$$\\| \\|\t\$[ \t\n]*")
— Le numéro de colonne :
;; Pour avoir l’affichage du numéro de colonne :
(column-number-mode t)
Il existe aussi la fonction line-number-mode pour le numéro de ligne si besoin. . .
— Les délimiteurs qui vont par paires :
;; Pour que les parenthèses (ou accolades...) correspondantes soient
;; affichées sur fond coloré plutôt que de voir le curseur s’y
;; reporter
(require ’paren)
(show-paren-mode 1)
— Le calendrier (très pratique à l’occasion, par exemple pour trouver la date du 12142e jour après le 22 octobre 2001) :
;; Pour que les semaines (pour M-x calendar) commencent le lundi...
(setq calendar-week-start-day 1)
;; Pour que l’affichage des dates soit au format MM/JJ/AA
(calendar-set-date-style ’european)
;; << If t, show all the holidays that would appear in a complete Christian
;; calendar. >>
(setq calendar-christian-all-holidays-flag t)
— Le dictionnaire avec Ispell (au passage, il paraît que aspell est très bien. . .) :
;; Dictionnaire pour ispell
(setq ispell-dictionary "francais")
33
— Le mode majeur par défaut :
;; Pour que les nouveaux buffers soient par défaut en mode majeur Text
(setq default-major-mode ’text-mode)
;; auto-fill-mode associé au text-mode
(add-hook ’text-mode-hook ’turn-on-auto-fill)
Notez bien le (add-hook ’machin-mode-hook ’fonction). C’est une composante importante de la personnalisation
d’Emacs car tout mode sous Emacs se doit de fournir un hook, i.e. une liste de fonctions, permettant d’exécuter
une série d’actions à la fin du chargement du mode. Ici, à chaque fois que le text-mode sera chargé, la fonction
turn-on-auto-fill sera exécutée à la fin de ce chargement.
— Un mode Text sans auto-fill parce que ce que je viens de faire ci-dessus est parfois indésirable :
;; Mode Text *sans* auto-fill pour les fichiers batch
(defun flo-text-mode-without-auto-fill ()
"Run text-mode and turn off auto-fill-mode."
(text-mode) (setq auto-fill-function nil))
(add-to-list ’auto-mode-alist
’("\\.bat\\’" . flo-text-mode-without-auto-fill))
— La variable auto-mode-alist fait partie des incontournables de la configuration d’Emacs : elle permet de dire à Emacs
quel mode utiliser par défaut lors de l’ouverture d’un fichier en fondant sa décision sur le nom du fichier. Ici, je dis à
Emacs que tous les fichiers se terminant par .py devront être ouverts en mode python-mode :
(add-to-list ’auto-mode-alist ’("\\.py\\’" . python-mode))))
On peut réaliser plusieurs ajouts de ce type sous forme factorisée :
(dolist (mapping
’(("/\\.mailcap\\’" . flo-text-mode-without-auto-fill)
("/known_hosts\\’" . flo-text-mode-without-auto-fill)
("/authorized_keys\\’" . flo-text-mode-without-auto-fill)
("/id_rsa.*\\.pub\\’" . flo-text-mode-without-auto-fill)
("\\.bash\\’" . shell-script-mode)
("\\.py3\\’" . python-mode)
("\\.bat\\’" . flo-text-mode-without-auto-fill)
("\\.cddb\\’" . flo-text-mode-without-auto-fill)))
(add-to-list ’auto-mode-alist mapping))
— Pour les cas où l’extension ne permet pas de déterminer un mode majeur approprié :
; Choix d’un mode majeur à partir de la « shebang line »
(dolist (mapping ’(("python2" . python-mode)
("python3" . python-mode)))
(add-to-list ’interpreter-mode-alist mapping))
— La taille par défaut des frames : elle peut être réglée à l’aide de la ligne de commande (option –-geometry), des ressources
X (sous X11 ; cf. le GNU Emacs Manual pour les détails) et de la variable window-system-default-frame-alist (ou
à défaut, sur de vieilles versions, default-frame-alist). Il y a aussi initial-frame-alist mais je préfère utiliser les
ressources X lorsque cela est possible.
Le gros avantage de ces dernières pour régler la taille des frames et des polices de caractères découle du fait qu’elles sont
attachées au serveur X, autrement dit là où s’effectue l’affichage. Si vous travaillez sur un ordinateur A avec un grand
écran et un ordinateur B avec un petit écran, les ressources X permettent d’avoir toujours des paramètres adaptés à
l’écran dans chacune de ces situations :
— travail sur A en local ;
— travail sur A depuis B (par exemple avec ssh) ;
— travail sur B en local ;
— travail sur B depuis A.
Ce genre de problème, quel que soit le nombre d’ordinateurs impliqués, n’est gérable que si la configuration (géométrie
des frames et taille des polices de caractères) est attachée à la machine sur laquelle s’effectue l’affichage. C’est ce que
permettent naturellement les ressources X, contrairement à la configuration via la ligne de commande ou le .emacs.el.
— Les lignes suivantes permettent d’effacer (et copier) plus rapidement du texte avec C-k (kill-line) qu’avec le comportement par défaut :
;; Pour que kill-line kille la ligne _et_ son newline quand elle est
;; invoquée en début de ligne :
(setq kill-whole-line t)
— Je trouve pratique de pouvoir utiliser la complétion sous Emacs en ignorant la casse (ça évite de passer à côté d’une
alternative parce qu’on ne se souvenait pas qu’il y avait un caractère en majuscules. . .) :
(setq completion-ignore-case t)
34
— La gestion, l’harmonisation des tabulations ; un plaisir réservé aux programmeurs travaillant sur un même projet avec
différents éditeurs de texte (et mauvaises habitudes) !
;; N’insère jamais de tabulations, mais des espaces qui produisent le
;; même espacement. Voir aussi les fonctions M-x tabify et
;; M-x untabify trouvées par : Help -> Manuals -> Browse Manuals with
;; Info puis entrées "Emacs", "Indentation" et enfin "Just spaces".
(setq-default indent-tabs-mode nil)
N.B. : si vous recevez un fichier contenant des tabulations, vous pouvez changer la longueur qu’Emacs leur attribue
avec la variable tab-width. Vous obtenez un fichier présenté comme la personne qui l’a édité en dernier le voyait, vous
utilisez untabify et vous avez un beau fichier avec des espaces à la place des tabulations afin que tout le monde le voie
de la même manière.
De manière alternative, si vous souhaitez préserver les tabulations dans le fichier (et donc la possibilité de changer leur
largeur à l’affichage à tout moment), la variable tab-width est particulièrement utile comme file variable (voir ci-dessus
ou le GNU Emacs Manual).
— J’utilise ce qui suit pour l’impression avec les fonctions ps-print-buffer et ps-print-buffer-with-faces :
(setq ps-paper-type ’a4
ps-font-family ’Courier
ps-font-size 10
ps-print-header t
ps-landscape-mode nil
;; Marge inférieure en points PostScript : (* 72 (/ 1.8 2.54)) -> 1.8 cm
ps-bottom-margin 51.02362204724409)
;; Pour n’avoir que le nom du buffer et <page>/<total>.
(setq-default ps-header-lines 1)
— Si vous voulez modifier (globalement) la variable fill-column, il faudra utiliser setq-default et non setq car cette
variable est automatiquement « buffer-local » (si vous la modifiez avec setq, vous ne changez que sa valeur dans le
buffer où vous avez exécuté le setq) :
(setq-default fill-column 78) ; Cette variable est automatiquement buffer-local
— Si ce qui suit vous donne des idées pour la configuration du mode C, j’en serai ravi. . .
(defconst flo-c-style
’(;; C’est déjà en « default » dans *mon* .emacs, pas celui des autres...
(indent-tabs-mode . nil)
(c-hanging-braces-alist . ((brace-list-open)
(block-close . c-snug-do-while)
(extern-lang-open (after))
(block-open . (before after))))
)
"Florent’s C-style"
)
(add-hook ’c-mode-common-hook
#’(lambda ()
;; Le t sert à faire en sorte que flo-c-style soit le style
;; courant :
(c-add-style "Florent’s style" flo-c-style t)
;; Le c-mode-base-map est tiré de la FAQ du CC-mode (C-h i ->...)
(define-key c-mode-base-map "\C-m" ’newline-and-indent)
(define-key c-mode-base-map [f9] ’compile)
(setq compile-command "make")
;; Active les features auto-newline et hungry-delete-key.
(c-toggle-auto-hungry-state 1)
))
(add-hook ’c-mode-hook ’turn-on-auto-fill)
— Si vous utilisez AUCTeX pour le mode LaTeX, ce qui suit peut vous intéresser (assez ancien, mais ma configuration
actuelle est nettement plus complexe ; à adapter à votre cas) :
(defun do-LaTeX ()
"LaTeX the curent file."
(interactive)
(TeX-command "LaTeX" ’TeX-master-file))
(defun do-DVIview ()
"View the curent file with the default DVI viewer."
(interactive)
(TeX-command "View" ’TeX-master-file))
(defun do-DVIview ()
"View the curent file with xdvi."
(interactive)
(TeX-command "View with xdvi without prompt" ’TeX-master-file)))
(defun do-DVIPS ()
"DVIPS the curent file."
(interactive)
(TeX-command "dviPS" ’TeX-master-file))
35
(defun do-DVIPS ()
"DVIPS the curent file."
(interactive)
(TeX-command "DVIPS without prompt" ’TeX-master-file)))
(defun do-PSview ()
"PSView the curent file."
(interactive)
(TeX-command "Ghostview" ’TeX-master-file))
(defun do-PSview ()
"PSView the curent file."
(interactive)
(TeX-command "View with gv" ’TeX-master-file)))
(defun do-PDFview ()
"PDFView the curent file."
(interactive)
(error "Function not implemented")) ; mettre le bon exécutable...
(defun do-PDFview ()
"PDFView the curent file."
(interactive)
(TeX-command "View with okular" ’TeX-master-file)))
(if flo-on-my-debian-p
(add-hook
’LaTeX-mode-hook
#’(lambda ()
(add-to-list ’TeX-command-list
’("View with xdvi without prompt" "%v"
TeX-run-silent nil nil))
’("DVIPS without prompt" "dvips %d -o %f"
TeX-run-command nil nil))
’("View with gv" "gv %f" TeX-run-discard nil nil))
’("View with xpdf" "xpdf %s.pdf"
’("View with okular" "okular %s.pdf"
)))
(add-hook ’LaTeX-mode-hook
#’(lambda ()
;; Pour que les paragraphes soient justifiés en mode Fill, on
;; peut mettre :
;; (setq default-justification ’full)
;; Colorisation avec font-latex.el (fourni avec AUCTeX):
(require ’font-latex)
(define-key LaTeX-mode-map [C-f5] ’do-LaTeX)
(define-key LaTeX-mode-map [C-f6] ’do-DVIview)
(define-key LaTeX-mode-map [C-f7] ’do-DVIPS)
(define-key LaTeX-mode-map [C-f8] ’do-PSview)
(define-key LaTeX-mode-map [C-f9] ’do-PDFview)
;; Une « ruse » pour pouvoir se déplacer d’une sectional unit à
;; la suivante :
(setq page-delimiter
(setq page-delimiter
"^\$\\\\part\\|\\\\chapter\\|\\\\section\\|\
\\\\subsection\\|\\\\subsubsection\\|\\\\paragraph\\|\\\\subparagraph\$")
)))
;; Hook partagé par tous les modes *TeX
; (add-hook ’TeX-mode-hook ’flo-TeX-mode-hook)
(add-hook ’TeX-mode-hook ’turn-on-auto-fill)
— Emacs offre une fonctionnalité de type client/serveur très pratique. Avec la ligne suivante dans votre .emacs.el :
(server-start)
à partir du moment où Emacs est lancé, il vous suffit de taper emacsclient mon_fichier pour ouvrir mon_fichier
avec l’Emacs qui déjà lancé (au lieu de créer un nouveau processus Emacs inutilement, qui ne verrait pas les buffers de
l’autre processus Emacs, etc.). Une fois le fichier édité, il suffit de faire C-x # (server-edit) pour qu’Emacs signale à
emacsclient qu’il a terminé son travail. On peut aussi invoquer emacsclient avec l’option -n pour que celui-ci rende
la main immédiatement à l’interpréteur de commandes (i.e. le shell Unix ou l’invite de commandes MS-DOS ou. . .).
Pour les vieilles versions d’Emacs, voir « gnuserv/gnuclient » dans ‘Avec d’anciennes versions’ page suivante.
Voilà, je vous ai présenté des extraits de mes fichiers d’initialisation qui me semblent pouvoir intéresser la plupart des
utilisateurs débutants ainsi que les idées principales de la configuration de ce fichier (load-path, auto-mode-alist, les
hooks. . .).
Si votre configuration est assez longue, pensez à la répartir dans plusieurs fichiers chargés depuis le .emacs.el avec une ligne
du type :
36
(load "flo-init-main")
On peut aussi utiliser :
(require ’feature)
à condition que le fichier à charger effectue, de préférence comme dernière opération (pour éviter que la feature ne soit
prétendument présente dans le cas où il y aurait eu une erreur) :
(provide ’feature)
6.2
Avec d’anciennes versions
Ce qui précède fonctionne bien sous Emacs 23. Si vous êtes confronté à de vieilles versions, les recettes suivantes pourront
peut-être vous rendre service :
— Pour les caractères non-ASCII :
;; Pour l’antique Emacs 20 (à proscrire avec les versions plus récentes !)
(standard-display-european 1)
(set-input-mode nil nil 1)
Avec Emacs 21 et une police ISO-8859-15 (= latin9), on utilisera plutôt quelque chose du genre :
(set-terminal-coding-system ’latin-9)
(set-keyboard-coding-system ’latin-9)
(set-language-environment ’latin-9)
à quoi on pourra ajouter la ligne suivante pour que les copier/coller d’un programme X vers Emacs fonctionnent bien
avec les caractères accentués :
;; Pour le vieil Emacs 21
(setq selection-coding-system ’compound-text-with-extensions)
— La ligne suivante, inutile avec une version suffisamment récente d’Emacs, fait en sorte que dès lors qu’un mode sait
tirer partie du font-lock-mode 2 , tout buffer dans ce mode est colorisé par ce biais.
;; Activé par défaut sous Emacs 23, mais utile avec d’anciennes versions
(global-font-lock-mode 1)
— Avec les versions d’Emacs antérieures à 21.1, les bindings suivants amélioraient pas mal le quotidien :
(global-set-key
(global-set-key
(global-set-key
(global-set-key
;;
;;
;;
;;
;;
[home] ’beginning-of-line)
[end] ’end-of-line)
[C-home] ’beginning-of-buffer)
[C-end] ’end-of-buffer)
Gestion de la roulette de la souris avec plusieurs vitesses
(inspiration venant de http://www.emacsfr.org/phpwiki/index.php?.emacs)
Shift + roulette : petite vitesse
Roulette seule : vitesse moyenne
Control + roulette : grande vitesse
(defalias ’flo-scroll-down-small-amount ’flo-scroll-one-line-down)
(defalias ’flo-scroll-up-small-amount ’flo-scroll-one-line-up)
(defun flo-scroll-down-medium-amount ()
(interactive)
(scroll-down 5))
(defun flo-scroll-up-medium-amount ()
(interactive)
(scroll-up 5))
(defun flo-scroll-down-large-amount ()
(interactive)
(scroll-down))
(defun flo-scroll-up-large-amount ()
(interactive)
(scroll-up))
(global-set-key
(global-set-key
(global-set-key
(global-set-key
(global-set-key
(global-set-key
[S-mouse-4] ’flo-scroll-down-small-amount)
[S-mouse-5] ’flo-scroll-up-small-amount)
[mouse-4] ’flo-scroll-down-medium-amount)
[mouse-5] ’flo-scroll-up-medium-amount)
[C-mouse-4] ’flo-scroll-down-large-amount)
[C-mouse-5] ’flo-scroll-up-large-amount)
où les fonctions flo-scroll-one-line-down et flo-scroll-one-line-up sont définies dans ‘Avec une version récente’
page 30.
2. Le mode mineur font-lock-mode est la manière standard employée aujourd’hui pour gérer la colorisation sous Emacs, au moins en ce qui
concerne les modes liés à un langage de programmation.
37
— Avant la version 21.1, Emacs ajoutait automatiquement des lignes au buffer quand on déplaçait le point à la fin de
celui-ci et qu’on utilisait la fonction next-line (flèche du bas en général). Voici un moyen d’éviter ce comportement :
(setq next-line-add-newlines nil)
— Si vous utilisez un shell dans Emacs sous Windows et que vous avez des ^M (Control-M) à la fin des lignes, peut-être
trouverez-vous la ligne suivante utile :
(add-hook ’comint-output-filter-functions ’shell-strip-ctrl-m))
— Il existe (existait) un package non fourni avec Emacs offrant des fonctionnalités similaires à emacsclient, généralement
référencé sous le nom « gnuserv » ou « gnuserv/gnuclient ». L’utilité de ce package semble avoir nettement diminué
depuis une dizaine d’années, au fil des améliorations apportées à emacsclient. Il n’est a priori plus utile depuis
Emacs 22.1, qui contient déjà un emacsclient offrant toutes les fonctionnalités qui justifiaient auparavant l’installation
de « gnuserv/gnuclient ». Je m’en réfère aux anciens liens qui ne fonctionnent plus et à http://www.emacswiki.org/
emacs/GnuClient.
38
39
Chapitre 7
Comment installer une extension à Emacs ?
En principe, si vous avez lu ‘Introduction à ELisp, le dialecte Lisp d’Emacs’ page 19 et que vous lisez la documentation
accompagnant une extension pour Emacs 1 , en général soit dans un fichier nommé README ou INSTALL, soit au début du
fichier .el principal du programme, vous ne devriez pas avoir de problème pour l’installer. Pas de problème théorique, en
tout cas. Pour les aspects pratiques, je vous invite à visiter cette page de Matthieu Moy, qui offre une assez bonne vue
d’ensemble des procédures d’installation courantes : http://www-verimag.imag.fr/~moy/emacs/.
Il est à noter qu’Emacs dispose d’un système de gestion de packages qui est installé par défaut dans Emacs 24 et que l’on
peut installer à la main pour Emacs 23. J’invite le lecteur à consulter le chapitre Packages du GNU Emacs Manual (http://
www.gnu.org/software/emacs/manual/html_node/emacs/Packages.html) et http://www.emacswiki.org/emacs/ELPA.
1. Un mode ou quelques fonctions, sous forme de fichiers ELisp a priori.
Chapitre 7. Comment installer une extension à Emacs ?
40
41
Chapitre 8
Où trouver de la documentation ?
Les sources principales de documentation sur Emacs sont à mon sens (par ordre décroissant de préférence) :
— Le GNU Emacs Manual, disponible à http://www.gnu.org/software/emacs/#Manuals. Il existe un projet de traduction en français de ce manuel à l’adresse http://www.linux-france.org/article/appli/emacs/manuel/.
— Le GNU Emacs Lisp Reference Manual, disponible à http://www.gnu.org/software/emacs/#Manuals ;
— la FAQ (Frequently Asked Questions d’Emacs accessible via C-h F (view-emacs-FAQ) ;
— l’aide (souvent trop concise quand on ne connaît pas déjà) accessible via C-h f, C-h v, M-x apropos,
M-x apropos-documentation, M-x finder-by-keyword. . .
— les newsgroups (« forums de discussion ») fr.comp.applications.emacs, comp.emacs, gnu.emacs.help. . .
Le GNU Emacs Manual et le GNU Emacs Lisp Reference Manual sont d’excellente qualité. Ne vous en privez pas !
N.B. : ils sont tous les deux écrits en Texinfo, donc disponibles au moins dans les formats Info, PostScript et HTML.
Chapitre 8. Où trouver de la documentation ?
42
43
Chapitre 9
Mail et news avec Emacs
Fascinés par la puissance d’Emacs, certaines personnes ont écrit en ELisp des programmes qu’on n’imaginerait pas faire
partie d’un éditeur de texte à première vue. Il existe en effet plusieurs lecteurs de mail et news (forums de discussion de
l’espace Usenet : cf. http://www.usenet-fr.net/) pour Emacs.
Parmi les lecteurs de mail, on compte principalement Rmail (assez ancien, intégré à Emacs depuis longtemps), VM (plus récent,
encore assez populaire ; son site de référence est http://www.wonderworks.com/vm/), Mew (cf. http://www.mew.org/) et
Gnus (cf. http://www.gnus.org/).
Gnus est à mon avis le plus complet. C’est le seul que je connaisse assez bien donc je ne parlerai que de lui ici. Il est intégré
à Emacs depuis plusieurs versions.
À l’origine, il y avait GNUS, écrit par Masanobu Umeda (cf. http://www.gnus.org/history.html). Lars Magne Ingebrigtsen
a réécrit GNUS en 1994 et on parle désormais de Gnus. La fonction première de Gnus est de permettre de lire et écrire sur
Usenet (on parle de « lecteur de news ») mais il est tellement flexible qu’il permet également une excellente gestion du
courrier électronique (on parle de « lecteur de mail » ou encore de « Mail User Agent », soit MUA dans le jargon du mail).
Ceci est une bonne chose ; les utilisateurs avancés du mail se rendent vite compte que mail et news ont de nombreux points
en commun.
En effet, une fois qu’on a dit à Gnus qu’on souhaite que les messages de telle mailing-list arrivent dans tel groupe (au sens de
Gnus), lire et écrire sur la mailing-list ou sur un groupe de Usenet se fait de la même façon (sauf que par exemple un message
sur Usenet peut-être annulé alors que c’est impossible sur une mailing-list puisqu’on ne peut annuler un mail par définition
des protocoles sous-jacents). Pourquoi différencier ces fonctions alors que dans ces deux media, on trouve des messages postés
par différentes personnes, axés sur un thème bien défini, disposés en enfilades (threads) qui décrivent qui répond à qui et
ayant en gros la même structure (RFC 822 et consorts) ?
De plus, si vous lisez une mailing-list et un newsgroup sur le jardinage, naturellement vous voudrez archiver les messages
qui vous auront le plus intéressé. Voulez-vous vraiment les stocker dans deux zones à part selon qu’ils proviennent de la
mailing-list ou du forum Usenet ? Dans le cas général, non. Et comme le format des messages sur l’un et l’autre de ces media
est très proche, la seule raison justifiant le choix de la séparation dans le cas général est à mon avis la mauvaise foi.
Conclusion : un programme qui fait à la fois lecteur de mail et news est un choix censé, bien que certaines implémentations
de ce concept soient très critiquables (au hasard Microsoft Outlook Express) pour des raisons tout autres.
L’installation de Gnus ne doit pas poser de problème puisqu’il est intégré à Emacs depuis un certain temps. Son utilisation est
hors du cadre de ce tutoriel. Si vous voulez vous mettre à Gnus, il faudra lire les tutoriels existants et son manuel. Ce manuel
à des qualités certaines (style très plaisant, humour) mais je le trouve difficile d’accès (clarté de la terminologie, par exemple).
Vous êtes prévenu. Aidez-vous des tutoriels et exemples de fichiers .gnus (ou .gnus.el), commencez pas à pas (pour le mail,
car il n’y a quasiment rien à mettre en place si vous souhaitez juste lire les news avec Gnus), et demandez de l’aide aux
endroits appropriés si vous butez sur un problème (par exemple les forums fr.comp.applications.emacs, gnu.emacs.gnus et la
mailing-list « ding » indiquée à http://www.gnus.org/resources.html). Gnus est délicat à aborder pour le mail mais c’est
un vrai plaisir une fois le premier cap franchi. Courage ! ;-)
Chapitre 9. Mail et news avec Emacs
44
45
Chapitre 10
Quelques liens
Voici quelques liens à propos d’Emacs :
— un wiki consacré à Emacs : http://www.emacswiki.org/ ;
— l’« Emacs Lisp List », une (longue) liste de programmes écrits pour Emacs : http://www.damtp.cam.ac.uk/user/
sje30/emacs/ell.html ;
— l’« Emacs Timeline », arbre généalogique d’Emacs (et XEmacs et plein d’autres) : http://www.jwz.org/doc/
emacs-timeline.html. Impressionnant.
— la FAQ spécifique au portage d’Emacs sous les différentes versions (récentes) de Windows : http://www.gnu.org/
software/emacs/windows/ntemacs.html ;
— http://www.emacsfr.org/, un site utilisant daCode (cf. http://www.dacode.org/), donc adapté à la diffusion de
« news », les nouvelles en question étant ici des astuces relatives à Emacs. Notons qu’il y a également sur ce site une
section regroupant des liens relatifs à Emacs, un forum, quelques extraits de .emacs.el. . .
— Un site consacré au fichier d’initialisation d’Emacs (.emacs ou .emacs.el) : http://www.dotemacs.de/index.html.
— le site Web du projet GNU : http://www.gnu.org/.
Chapitre 10. Quelques liens
46
47
Chapitre 11
GNU Emacs ou XEmacs ?
En deux mots : GNU Emacs. :)
Non, vraiment, c’est une excellente question. D’autres questions ?
OK, je vois que je ne m’en tirerai pas comme ça. . . Z’êtes pas gentils avec moi ! Tous les Emacsiens, quelle que soit leur
religion euh, je veux dire leur choix entre Emacs et XEmacs, ont opté pour la Bonne Voie. Les différences qui restent sont
des broutilles, non ?
Des broutilles qui ont conduit à un schisme qui dure depuis près de dix ans et à des querelles interminables à vous arracher
le coeur entre des hackers 1 mythiques d’un côté comme de l’autre. . . Rien de bien méchant, en somme. . .
11.1
La petite histoire. . .
Pour comprendre la scission entre GNU Emacs, également appelé (à tort) 2 FSF Emacs car c’est soit-disant l’Emacs de la
FSF 3 , et XEmacs, il faut remonter à 1989-1992. Jamie Zawinski, alias JWZ, un hacker Unix renommé, travaillait à cette
époque au sein de la société Lucid Inc. qui avait comme projet de réaliser un environnement de développement intégré pour
le C et le C++ sous Unix.
Emacs apparaissait naturellement comme une très bonne base pour ce projet. Cependant, un tel produit nécessite une
interface utilisateur soignée, ce qui n’était pas à la portée de la dernière version d’Emacs en 1992 (la version 18). GNU Emacs
était la seule version « officielle » d’Emacs à cette époque mais depuis au moins 1990, probablement avant, existait une
version patchée (modifiée) d’Emacs 18, appelée Epoch, et qui offrait précisément de meilleures fonctionnalités qu’Emacs au
niveau interface utilisateur.
Cela dit, tout le monde, y compris les mainteneurs d’Epoch, envisageait d’intégrer certaines fonctionnalités d’Epoch dans
Emacs 18 pour donner Emacs 19 et d’abandonner Epoch immédiatement après.
On a donc décidé chez Lucid Inc. d’attendre Emacs 19 pour réaliser l’environnement de développement (appelé Energize)
sur des bases saines. Puis d’aider les développeurs d’Emacs 19 4 pour accélérer sa sortie, qui se faisait un peu trop attendre
(longtemps annoncée comme devant se produire really soon now (TM)).
Malheureusement, la collaboration entre Lucid Inc. et la FSF n’a pas du tout fonctionné et devant les impératifs de délais
vis à vis de ses clients, Lucid Inc. a fini par décider de finaliser son travail sur ce qui aurait dû être le futur Emacs 19 afin de
pouvoir l’intégrer à Energize. Lucid Emacs venait de naître.
En 1994, Lucid Inc. disparut et Jamie Zawinski passa Lucid Emacs à un nouveau mainteneur, Chuck Thompson (de la NCSA,
où a été développé Epoch), qui le renomma XEmacs.
XEmacs devint assez populaire car notamment :
— il était supérieur à GNU Emacs en plusieurs points ;
— son développement était plus ouvert que celui de GNU Emacs (ouvert signifiant ici qu’il était plus facile de frayer son
chemin si on voulait contribuer au développement d’XEmacs que pour GNU Emacs) ;
— les points qui le différenciaient principalement de GNU Emacs (interface utilisateur) sont de nature à plaire vite au
plus grand nombre. . .
1. Dans le sens noble – son seul vrai sens, d’ailleurs – du terme.
2. Les désignations correctes de ce logiciel sont Emacs et GNU Emacs. On parle parfois (plutôt en anglais) d’Emacsen pour désigner l’ensemble
des logiciels similaires à Emacs, y compris Emacs lui-même. Cette appellation recouvre notamment Emacs, XEmacs et MicroEMACS.
3. Free Software Fundation, créée par Richard Stallman, alias RMS, à qui l’on doit les premières versions d’Emacs (et bien plus).
4. Energize était un produit commercial et propriétaire mais le travail réalisé par Lucid Inc. sur Emacs, gcc et gdb allait être sous licence GPL.
Chapitre 11. GNU Emacs ou XEmacs ?
48
Et voilà comment on se retrouve en 2001 avec deux Emacs concurrents et une montagne de travail, de temps et de talents
mal utilisés. Les personnes impliquées se sont parfaitement rendu compte de l’ampleur du problème qu’allait poser la scission
en 1992 ; de nombreux efforts ont été faits pour l’éviter, mais ce fut en vain. Les deux camps n’ont pu se réconcilier. Je vous
conseille à ce sujet le document suivant : http://www.jwz.org/doc/lemacs.html, écrit par Jamie Zawinski, à partir duquel
j’ai écrit ce bref historique, et qui contient une archive conséquente de mails échangés entre les principaux protagonistes à
l’époque de la scission.
11.2
Qu’en est-il aujourd’hui ?
Voici les principales différences entre GNU Emacs et XEmacs à l’heure actuelle (2 février 2002) selon mon point de vue :
— XEmacs gère (de manière très simple) des packages, qui peuvent éventuellement faciliter l’installation d’un programme
pour XEmacs par un débutant ; cela dit, l’installation d’un tel programme pour GNU Emacs est en général très aisée
dès qu’on a quelques notions de base.
La situation a changé récemment (2013) : il y a désormais un système de gestion de packages installé par défaut dans
Emacs 24 et que l’on peut installer à la main pour Emacs 23.
— les choix relatifs à l’interface graphique ont été quelque peu différents entre GNU Emacs et XEmacs. Pour XEmacs,
on dispose depuis longtemps d’une « belle » interface, avec d’énormes boutons pour ouvrir un fichier ou faire un
copier/coller. Dans le cas de GNU Emacs, cette interface est restée, jusqu’à la version 20 incluse, nettement plus sobre,
voire franchement moins esthétique mais plus fonctionnelle à mon sens.
Depuis Emacs 21 (sorti le 22 octobre 2001), l’interface de GNU Emacs est à la fois belle et fonctionnelle (une fois qu’on
a supprimé la barre de boutons ! ;-).
— dans le même ordre d’idées, les menus par défaut d’XEmacs sont extrêmement fournis. Beaucoup trop pour un débutant,
à mon avis. À l’inverse, les menus par défaut de GNU Emacs sont beaucoup plus raisonnables et laissent à l’utilisateur
éclairé la possibilité de les étendre comme cela lui plaît.
Note : les menus d’Emacs 21 ont été complétés et réorganisés pour ne pas dépayser les utilisateurs d’un système
d’exploitation encore majoritaire chez les particuliers. De plus, Emacs 21 permet d’ajouter des tooltips (bulles contenant
une aide typiquement d’une ligne) permettant de se faire une idée plus claire de ce que fait un élément de menu en
laissant traîner le pointeur souris dessus quelques instants.
— il est plus facile de participer au développement du coeur d’XEmacs qu’à celui de GNU Emacs ;
— les développeurs d’XEmacs ont été moins stricts vis à vis des licences des diverses portions de code constituant XEmacs
que la Free Software Fundation ne l’a été vis à vis d’Emacs de sorte que la FSF ne peut accepter XEmacs comme
composante du projet GNU (il lui manque certains papiers légaux, les auteurs de certains fragments de code, etc.) et
ne peut, toujours pour les mêmes raisons légales, prendre du « bon code » d’XEmacs pour le mettre dans GNU Emacs,
alors que l’inverse est fait (ne serait-ce que parce qu’XEmacs dérive de GNU Emacs 18).
— Le noyau d’XEmacs est encore pour une bonne partie directement issu d’Emacs 18 (ou de la version de travail qui
aurait dû devenir GNU Emacs 19, appelez ça comme vous le souhaitez) ; il en découle que de nombreuses fonctions
d’Emacs 20 en sont absentes, ce qui complique la réalisation des programmes pour XEmacs et prive l’utilisateur
d’XEmacs des fonctionnalités qu’elles apportent. Je pense que le code de GNU Emacs est en moyenne plus propre que
celui d’XEmacs.
— XEmacs porte un nom qui fait croire aux débutants qu’il est « la version X d’Emacs » et donc qu’Emacs se cantonne
à la console. Ça m’énerve. :)
En dehors de ces différences et hors du domaine de la programmation, l’utilisation d’Emacs ou de XEmacs diffère assez peu
car la plupart des programmes conséquents développés pour l’un ou pour l’autre ont été modifiés afin de fonctionner sur les
deux.
Pour terminer, maintenant que vous connaissez mon point de vue sur la question, une petite mise en garde : vous trouverez sur
Internet quelques comparatifs entre Emacs et XEmacs comme http://www.xemacs.org/About/XEmacsVsGNUemacs.html.
Soyez méfiant ! Ce comparatif est biaisé et dépassé (par exemple, Emacs 21 n’est pas « soon available » au 2 février 2002 : il
est sorti le 22 octobre 2001). La même méfiance est de rigueur vis à vis du document que vous êtes en train de lire !
On y est, vous savez tout ; à vous de choisir !
49
Chapitre 12
À propos de ce document
Ce document a été réalisé avec GNU Emacs (http://www.gnu.org/software/emacs/emacs.html) sous le système d’exploitation Debian GNU/Linux (http://www.debian.org/) en SGML 1 avec la DTD (Document Type Definition) DebianDoc.
Ce dernier système signifie qu’il suffit d’écrire un seul document source pour produire automatiquement des documents dans
divers formats, destinés à la consultation sur écran (HTML, Info, texte brut, PDF) ou à l’impression 2 (PostScript, PDF).
On pourra trouver d’autres versions de ce document, en principe les versions SGML, HTML, DVI, PDF, PostScript, Info et
texte brut à l’adresse http://frougon.net/writings/emacs-tut/tous_formats/.
1. Pour être exact, le fichier SGML est obtenu après un traitement par le macro processor GNU m4 (http://www.gnu.org/software/m4/) afin
de gérer de manière centralisée la mise en forme de divers éléments (comme les raccourcis clavier, les mots en anglais, les termes comme Emacs,
etc.).
2. Cela dit, une conversion automatique parfaite n’est pas possible dans tous les cas de figure. En particulier, les versions PostScript et PDF
présentent quelques lignes trop longues, ce qui serait inacceptable dans le cas d’une publication.
Chapitre 12. À propos de ce document
50
51
Chapitre 13
Qu’est-ce qui a changé dans ce document
depuis la version x.yz ?
Version 1.36
— Le tutoriel se trouve désormais sur à l’adresse http://frougon.net/writings/emacs-tut/tous_formats/.
Version 1.35
— Mise à jour de l’URL de l’« Emacs Lisp Package Archive ».
Version 1.34
— Changements cosmétiques.
Version 1.33
— « gnuserv/gnuclient » est désormais à la retraite dans ‘Avec d’anciennes versions’ page 36 ;
— Mise à jour du lien vers l’« Emacs Lisp List ».
Version 1.32
— Complément sur fill-paragraph.
Version 1.31
— Prise en compte des « nouveautés » (depuis Emacs 22) concernant les macros clavier ; complément ;
— remaniement du chapitre ‘Quelques idées pour votre fichier d’initialisation’ page 29 ; les suggestions inutiles à partir
d’Emacs 23 et pour certaines clairement à éviter sur les versions récentes sont désormais regroupées dans une section
à part : ‘Avec d’anciennes versions’ page 36 ;
— ajout de quelques références au système de packaging désormais disponible sous GNU Emacs ;
— formats texte codés en ISO 8859-1 et UTF-8 ;
— amélioration du Makefile.
Version 1.30
— Correction de quelques liens devenus invalides.
Version 1.29
— Relecture de ‘Introduction à ELisp, le dialecte Lisp d’Emacs’ page 19 ; correction de fautes d’orthographe, et occasionnellement du style.
Version 1.28
— un peu de ménage dans ‘À propos de ce document’ page 49 ;
— ne plus insérer de test sur le format de sortie (PDF ou autre) dans la sortie LaTeX car DebianDoc le fait désormais
lui-même ;
— petit correctif dans le Makefile.
Version 1.27
— quelques précisions supplémentaires dans ‘Le minibuffer et l’echo area’ page 5 ; en particulier, elle présente brièvement
l’echo area en plus du minibuffer ;
— utilisation des fontes Latin Modern dans les sorties obtenues via TeX.
Version 1.26
— ajout du fameux
(setq selection-coding-system ’compound-text-with-extensions)
à ‘Quelques idées pour votre fichier d’initialisation’ page 29 ;
— ajout de ‘Mail et news avec Emacs’ page 43.
Version 1.25
Chapitre 13. Qu’est-ce qui a changé dans ce document depuis la version x.yz ?
52
— ajout d’une référence à http://www-verimag.imag.fr/~moy/emacs/ au sujet de l’installation d’extensions pour Emacs
Version 1.23
— correction de la sortie PDF
Version 1.22
— mises à jour ça et là relatives à Emacs 21 ;
— ajout d’une méthode permettant de mettre tous les backup files dans un même répertoire (voir ‘Rhhhaaa ! Emacs pollue
les répertoires où il enregistre des fichiers !’ page 8) ;
— ajout de bury-buffer dans ‘Les buffers’ page 9 ;
— ajout de quelques fonctions dans ‘Les macros’ page 12 ;
— ajout de comment-region dans ‘Édition’ page 11 ;
— correction dans ‘Le mode Info’ page 16 : les versions Info des GNU Emacs Manual et GNU Emacs Lisp Reference
Manual sont identiques du point de vue technique aux versions dans les autres formats comme HTML et PostScript.
Les seules différences concernent la présentation de la structure, la page de garde de la version PostScript, ce qui est
rendu différemment dans un format ou dans un autre. . . des détails) ;
— correction de la docstring (chaîne de caractères de documentation) de ma-fonction dans ‘Fonctions nommées’ page 22
(oui, vous avez raison, une vraie correction la mettrait en anglais, mais n’aurait pas vraiment sa place ici) ;
— gestion de la roulette de la souris dans ‘Quelques idées pour votre fichier d’initialisation’ page 29 ;
— correction de quelques fautes de frappe ou assimilées.
Version 1.11
— correction de quelques « typos »
Version 1.10
— remplacement des deux (global-font-lock-mode t) qui traînaient dans ce document par (global-font-lock-mode
1), qui est conforme à la documentation « en ligne » de la fonction global-font-lock-mode. Pour ma défense, on
trouve quand même (global-font-lock-mode t) dans le GNU Emacs Manual d’Emacs 20, donc il s’agit d’un bug
de la documentation, et comme les deux possibilités semblent donner le même résultat avec au moins Emacs 20.3, 20.4
et 20.7, je n’ai jamais remarqué ce « problème » avant.
Version 1.09
— explications sur ce qu’est le .emacs et où il faut le placer pour qu’Emacs le trouve (‘Quelques idées pour votre fichier
d’initialisation’ page 29) ;
— ajout mineur à l’explication sur le load-path (même section).
Version 1.08
— correction d’une faute de frappe dans ‘Quelques idées pour votre fichier d’initialisation’ page 29 (une parenthèse fermante
en trop après le deuxième (server-start)).
Version 1.07
— correction et complément sur gnuserv (section ‘Quelques idées pour votre fichier d’initialisation’ page 29) ; essentiellement, il y a :
— server.el et emacsclient fournis en standard avec Emacs ;
— gnuserv.{el,c,h}, gnuclient et gnudoit dans un package appelé gnuserv.
— ajout de quelques précisions sur les noms corrects et incorrects pour désigner Emacs, XEmacs, ou tous les Emacs-like
en un seul mot (‘GNU Emacs ou XEmacs ?’ page 47) ;
— ajout d’un lien vers un site consacré au .emacs.el (‘Quelques liens’ page 45) ;
— changement du titre du tutoriel car tout le monde ne connaît pas le document auquel faisait référence l’ancien titre
(The Not So Short Introduction to LaTeX2e, http://tex.loria.fr/general/lshort2e.pdf, traduit en français par
Une courte ( ?) introduction a LaTeX2e), ce qui peut prêter à confusion. . .
— changement du titre de la section consacrée à ELisp. . .
Version 1.06
— ajout de quelques lignes dans ‘Quelques idées pour votre fichier d’initialisation’ page 29 pour visualiser les fichiers PDF
avec AUCTeX ;
— ajout du chargement de font-latex.el dans cette même section (font-latex.el est fourni avec AUCTeX mais non
utilisé par défaut) pour la colorisation des fichiers LaTeX.

À la découverte de GNU Emacs

Transcription

Documents pareils

Un ´editeur de texte, pas un word processor L`essence du Logiciel

APACHE

CV ingénieur études et développement en informatique scientifique

Nous allons travailler en Unix sur des PC sous Linux (Redhat 6)

Installation d`emacs et Java (jdk)

Remplacement automatisé de caract`eres en Emacs

Image disque d`initiation à l`épreuve pratique de TP

Télécharger

Premiers pas en Emacs