Ours & Hippy — le blog

xmlgrep by examples: playing with Atom

2009-06-17T14:23:11+02:00

Edited 22.06. Incompatible syntax changes and more examples.

Since Matthew Sporleder on tech-userlevel has (implicitly) suggested that xmlgrep could be used to dissect Atom feeds, but was a bit lost at how to do it exactly, I thought I’d post a little demo of a console session playing with an Atom file and xmlgrep (as well as some other command-line tools).

First, let’s fetch the feed:

$ ftp http://mspo.com/blog/atom.xml
[...]

As a side effect of xmlgrep, we might want to indent the XML file to make it human-readable:

$ xmlgrep '*' atom.xml | more

List all posts in the NetBSD category with their IDs:

$ xmlgrep -x 'entry[category/@term=NetBSD]/(title|id)/.' atom.xml
tag:blogger.com,1999:blog-6347225410141611306.post-1131641169617411392
NetBSD quotas - quickstart
tag:blogger.com,1999:blog-6347225410141611306.post-1939815769827620970
NetBSD device drivers - easier than you might think
[...]

Those of you yet unfamiliar with the syntax might have some trouble understanding. The previous pattern could be read "select a text child of an id or title element, itself a child of an entry element, which contains a category element which has an attribute child term equal to NetBSD." Step by step, you should notice that a[b] is read "a such that b", | stands for "or", / for "child of", @ for "attribute", . for "text", and the braces are used for grouping purposes.

Now, let’s select a post by ID:

$ xmlgrep -x 'entry[id/.~"post-1939"]#' atom.xml

Or, select a post by title and view its contents using w3m:

$ xmlgrep -x 'entry[title/.~"device drivers"]/content/.' atom.xml |
> sed -e 's/&lt;/</g' -e 's/&gt;/>/g' -e 's/&amp;/\&/g' |
> w3m -T text/html

As a side note, I should mention that up to now we have used subpatterns quite a lot. This is because the Atom feed specification does not force an order (or does it?) on the children of entry elements. With more precise knowledge of the order of elements relative to each other, we could have optimized the pattern to use % and %% where possible. Subpatterns are costly, but for data sets this size, we probably don’t care much.

Let’s print all entry titles which date from March 2009 using the fact that we know the updated element comes before the title one:

$ xmlgrep -x 'entry/updated[.~"^2009-03"]%%title/.' atom.xml

A friend of mine told me it would be useful to have arithmetic predicates. I think they will feature in xmltools sooner or later, but even without them, it is still possible to do some simple statistics, by combining the results with awk(1), for example. The following one-liner counts the number of posts that have no older than March:

$ xmlgrep -x 'entry/updated/.' atom.xml | awk -F - '$2>=3' | wc -l

That’s it; I hope this will help people who want to get started with xmlgrep. If you have other good examples you’d want me to elaborate, do not hesitate to send me a mail!

Écrire du code C avec Emacs

2008-05-27T00:00:00+02:00

Et de deux ! —rz0

Cet article d’introduction s’intéresse aux aspects basiques liés à l’écriture et à la gestion du code C basique avec Emacs, et, bien sûr, aux fonctionnalités qui vous y aideront.

Édition du code avec le `c-mode`

Le mode d’édition du code C dans Emacs se nomme très simplement le c-mode et est inclus par défaut avec l’éditeur ; vous pouvez aussi obtenir la dernière version du mode (qui est développé en dehors d’Emacs lui-même) sur le site du cc-mode. Le c-mode offre plusieurs fonctionnalités et commandes intéressantes.

Indentation automatique

Tout d’abord, comme tous les modes de programmation dans Emacs, le c-mode possède l’indentation automatique. Cela signifie que la touche TAB (ou, de manière équivalente, C-i) n’est pas utilisée pour insérer un caractère « tabulation » mais pour indenter la ligne actuelle, c’est-à-dire aligner le début de celle-ci sur la colonne adéquate, comme vous le feriez vous-même si Emacs n’était pas là. Il est important de remarquer que cette opération ne tient absolument pas compte de l’indentation actuelle de la ligne : qu’elle soit trop décalée à gauche ou à droite, Emacs la replacera au bon endroit.

Emacs indentera la ligne selon deux informations : le contexte syntaxique (si vous êtes au début d’une instruction, au milieu d’un appel de fonction, etc.) et le style sélectionné (par exemple, K&R ou BSD ; voyez mon introduction à la configuration d’Emacs pour plus d’informations).

Comme il peut devenir lassant de devoir appuyer (quoique ce ne soit qu’une seule fois) sur la touche TAB à chaque début de ligne, sachez que vous pouvez aller à la ligne et indenter en une seule commande : C-j (newline-and-indent).

Mais l’indentation d’Emacs ne se limite pas à la ligne actuelle ! Vous pouvez également lui demander d’indenter tout un bloc ou une fonction pour vous. Il s’agit respectivement des commandes C-M-\ (indent-region) et C-c C-q (c-indent-defun), qui indentent la région actuelle (la zone de texte située entre la marque, usuellement apposée par C-SPC, et le curseur) et la fonction dans laquelle se trouve le curseur. En théorie, vous pourriez indenter tout le fichier ainsi, mais je vous le déconseille ; lalgorithme est lent et perd en précision si les constructions sont trop vilaines ou complexes. En revanche, si vous effectuez une modification au milieu d'un bloc, et que, par exemple, vous supprimez un niveau d'indentation, ces commandes peuvent s'avérer très utiles. Parfois, en revanche, vous voulez aligner des éléments (comme le ferait la toucheTABen temps normal) sans qu'Emacs n'essaie d'indenter la ligne. Pour cela, vous pouvez utiliser la commandeM-i(tab-to-tab-stop). C'est le cas, par exemple, si vous alignez vos déclarations ou vos instructions dans unswitch. Pour résumer, voici un tableau des commandes d'indentation et d'alignement : |TAB| indente la ligne actuelle | |C-j| retour à la ligne et indentation simultanés | |C-M-‘ | indente la région actuelle

`C-c C-q`	indente la fonction actuelle
`M-i`	aligne le curseur sur la prochaine colonne de tabulation

Gestion des commentaires

De même qu’Emacs sait indenter le code automatiquement, il sait insérer des commentaires au bon endroit ; pour se faire, il vous suffit d’actionner la commande M-; (comment-dwim). Que vous soyez sur une ligne vide ou non, Emacs déterminera la syntaxe à adopter. C’est la commande idéale pour ceux qui trouvent les commentaires de type C (/* ... */) trop longs à taper.

De plus, Emacs dispose des commandes de traitement de régions suivantes : comment-region et uncomment-region. Elles sont accessibles par M-x et qui peuvent être associées à une combinaison de votre choix si vous en sentez le besoin. Je vous laisse deviner ce qu’elles font. Elles peuvent être utiles à ceux qui aiment isoler des morceaux de code avec des commentaires (personnellement, je préfère utiliser #if 0).

M-; insère un commentaire

Déplacements contextuels

Enfin, le c-mode dispose de mécanismes de navigation contextuelle. La plupart des commandes utilisées sont communes à tous les modes d’édition mais leur fonctionnement a été adapté à la structure du code C.

Vous pouvez, comme toujours, vous déplacer de mot en mot avec les habituels M-b (backward-word) et M-f (forward-word).

Juste au niveau supérieur, les commandes C-M-b (backward-sexp) et C-M-f (forward-sexp) vous permettent de sauter d’un bout à l’autre d’expressions équilibrées (un groupe entre parenthèses, crochets ou accolades). En complément, C-M-u (backward-up-list) et C-M-d (down-list) naviguent à travers les niveaux de parenthésage : C-M-u vous amène au début du groupe dans lequel se situe le curseur et C-M-d vous transporte au début du prochain groupe à l’intérieur de l’expression actuelle. Le plus simple est encore de les essayer pour en voir les effets !

Vous pouvez également vous déplacer au début et à la fin des instructions avec M-a (c-beginning-of-statement) et M-e (c-end-of-statement), respectivement.

Enfin, les commandes beginning-of-defun et end-of-defun font, sans surprise, le voyage au début et à la fin d’une définition de fonction.

Récapitulons les commandes directement accessibles :

`C-b,` `C-f`	déplacement au mot
`C-M-b,` `C-M-f`	déplacement à l’expression (équilibrée)
`C-M-u,` `C-M-d`	déplacement à l’expression (équilibrée)
`M-a,` `M-e`	déplacement à l’instruction

Plusieurs fichiers sources

Avec ce que nous venons juste de voir, nous sommes maintenant capables d’éditer un fichier source C. Toutefois, la plupart des projets ne sont pas constitués d’un seul fichier, aussi, nous allons nous pencher sur la gestion de plusieurs fichiers dans Emacs. Cette section n’est pas directement liée à la programmation en C, mais la question revient fréquemment chez les novices, et c’est pourquoi j’ai décidé de la traiter ici.

Hiérarchies de fichiers

Typiquement, le scénario est le suivant : vous possédez plusieurs fichiers sources regroupés dans un dossier. Quelque chose que beaucoup de gens aiment faire est pouvoir regarder la hiérarchie des fichiers et naviguer de fichier en fichier. Pour cela, Emacs offre deux mécanismes : dired, un explorateur de fichiers, et la speedbar, une barre latérale.

Selon vos goûts, vous préférerez sans doute l’un ou l’autre. Les différences sont multiples : dired possède plus de facilités pour la gestion des hiérarchies de fichiers et de dossiers, avec toutes les fonctions classiques que l’on pourrait attendre d’un explorateur de fichiers, et se présente comme une application Emacs à part entière, utilisant ses propres buffers. À l’opposé, la speedbar s’affiche dans un cadre (frame) à part, et son contenu est constamment recalculé de sorte que le dossier affiché dans la barre soit toujours celui du fichier actuel.

Si vous n’êtes pas habitué à la terminologie emacsienne, sachez qu’une fenêtre correspond à une division de l’affichage d’Emacs (ce que vous obtenez avec C-x 2 par exemple) tandis qu’un cadre est un ensemble de fenêtres indépendant, ce qui, en mode graphique, correspond, pour la plupart des gestionnaires de fenêtres, à ce qu’ils appellent une fenêtre. Sauf mention contraire, nous utiliserons ici le vocabulaire d’Emacs.

À l’usage, l’un ou l’autre est assez naturel. Pour lancer dired, utilisez la commande C-x d (dired) ou C-x C-f (find-file) avec le chemin d’un dossier. Pour lancer la speedbar, tapez M-x speedbar ; un cadre devrait apparaître à côté de votre cadre principal.

Une fois à l’intérieur de l’un ou l’autre, placez-vous sur un fichier et tapez RET (dired-advertised-find-file ou speedbar-edit-line) pour le visiter. Sous dired, vous avez l’option de visiter le fichier dans une autre fenêtre avec o (dired-find-file-other-window).

Si vous voulez parcourir des sous-dossiers, sachez que dired prône une disposition plane tandis que la speedbar affiche les dossiers et les fichiers sous forme arborescente. Lorsque votre curseur est sur une ligne correspondant à un sous-dossier, tapez i sous dired ou + dans la speedbar (respectivement, dired-maybe-insert-subdir et speedbar-expand-line) pour insérer son listage dans le buffer actuel. Pour supprimer l’affichage d’un sous-dossier, placez-vous sur son en-tête (son chemin, juste au-dessus du listage, pour dired, ou son nom dans l’arborescence, pour la speedbar) et exécutez la commande M-x dired-kill-subdir ou - (speedbar-contract-line), pour dired et la speedbar respectivement. Au lieu de l’effacer complètement, dired vous propose aussi d’utiliser la commande $ (dired-hide-subdir), qui, malgré son nom, permet de cacher et de découvrir le contenu du dossier.

Si votre gestionnaire de fenêtres ne vous permet pas de déplacer facilement le focus au clavier, sachez qu’Emacs vous permet d’aller de cadre en cadre avec C-x 5 o (other-frame).

Et comme précédemment, un petit récapitulatif :

	`dired`	`speedbar`
parcourir un dossier	`C-x d`	automatique
visiter un fichier	`RET`	`RET`
insérer un sous-dossier	`i`	`+`
cacher un sous-dossier	`$`	`-`

Plusieurs fichiers dans Emacs

Maintenant que vous savez accéder facilement à plusieurs fichiers de votre projet, vous risquez fort d’être vite submergé par le grand nombre de buffers ouverts. Emacs ne dispose pas de tabs (ce n’est pas comme si vous alliez vous servir de votre souris pour y accéder, de toute manière). En revanche, plusieurs modes sont disponibles pour gérer vos buffers. Je ne vais pas tous les passer en revue ici, je ne donnerai qu’une seule solution.

La première commande à connaître pour bien gérer vos multiples buffers est sans doute C-x C-b (list-buffers). Elle démarre le gestionnaire de buffers. Ce dernier se présente comme une simple liste des buffers ouverts. Vous pouvez y effectuer les opérations de navigation habituelles, dont la recherche (avec C-s (isearch-forward) pour les étourdis). RET (Buffer-menu-this-window) vous permet de visiter le buffer à la ligne actuelle. Une autre utilisation très pratique est de supprimer plusieurs buffers à la fois. Pour cela, marquez chaque buffer à détruire avec la commande d (Buffer-menu-delete). La lettre D apparaît alors à gauche du nom. La commande x (Buffer-menu-execute) effectue l’opération de nettoyage en elle-même. Ainsi, si vous vous êtes trompé dans votre marquage, vous pouvez revenir en arrière en utilisant la commande u (Buffer-menu-unmark) sur la même ligne.

Tout cela est bien utile pour faire le ménage mais ne vous aide guère pour votre besoin le plus simple : naviguer de buffer en buffer. Pour cela, il y a bien sûr la commande C-x b (switch-to-buffer) par défaut d’Emacs pour changer de buffer. Mais elle n’est pas très pratique ; en effet, elle demande d’entrer le début du nom pour accéder au buffer. Fort heureusement, il existe (au moins) un mode qui vous permet de changer de buffer en tapant quelques lettres n’importe où dans le nom. Je vous présente là l’iswitchb-mode. Pour l’essayer, il vous suffit d’effectuer la commande M-x iswitchb-mode ; de même pour le désactiver. Pour l’adopter définitivement, ajoutez à votre .emacs la ligne :

(iswitchb-mode t)

La combinaison C-x b invoquera à présent iswitchb-buffer. Si vous l’essayez, vous remarquerez que la liste des buffers qui sont encore candidats à la sélection est maintenant affichée à côté de votre saisie. Dans ce mode, les commandes C-r (iswitchb-prev-match) et C-s (iswitchb-next-match) vous permettent de faire défiler les éléments de la liste de manière cyclique, et RET sélectionne le premier buffer de la liste. Ainsi, vous n’aurez plus à taper le début exact du nom que vous voulez, il vous suffira simplement d’entrer quelques lettres remarquables et, moyennant quelques rotations de la liste, vous arriverez rapidement à destination.

Vous pouvez aussi demander à utiliser des expressions régulières. La commande C-t (iswitchb-toggle-regexp), dans l’iswitchb-mode, vous permet cela. Par exemple, pour obtenir une liste des fichiers C ouverts, vous pourriez utiliser le motif \.c$. Veuillez cependant prendre note du fait que les expressions régulières d’Emacs diffèrent d’autres syntaxes, soyez donc averti et pensez à lire le manuel (avec C-h i (info), par exemple) si vous désirez en faire bon usage.

Avec l’habitude, ce système très flexible remplace avantageusement les tabs. Vous n’êtes plus lié à une liste prédéfinie ; vous avez la possibilité de fabriquer rapidement la vôtre, adaptée à votre requête. Du reste, il vous permettra de même d’aller de buffer en buffer. Et tout cela pour un encombrement nul dans vos autres actions !

Et pour les petits étourdis :

`C-x C-b`	gestionnaire de buffers
`C-x b`	change de buffer
`C-r` et `C-s`	défilement de la liste (dans `iswitchb`)
`C-t`	activation des regexps (dans `iswitchb`)

Édition simultanée de plusieurs fichiers

Bien sûr, vous n’êtes pas encore capable de vous dédoubler pour éditer plusieurs fichiers à la fois, mais parfois, vous pourriez vouloir afficher deux fichiers (voire plus) côte à côte.

Pour se faire, rien de plus simple. Il vous suffit de partager votre affichage en deux : verticalement avec C-x 2 (split-window-vertically) ou horizontalement avec C-x 3 (split-window-horizontally). Pour passer d’une fenêtre à l’autre, utilisez C-x o (other-window). Enfin, C-x 0 (delete-window) et C-x 1 (delete-other-windows) vous permettent respectivement de supprimer la fenêtre sur laquelle se trouve le focus et de ne laisser qu’elle.

Ainsi, vous pourrez plus facilement comparer ou transférer du code d’un fichier à un autre.

Sachez également qu’il existe des commandes qui marient une action donnée à un changement de fenêtre, telles queC-x 4 f (find-file-other-window) et C-x 4 b (switch-to-buffer-other-window). La première ouvre un fichier, à l’instar de C-x C-f (find-file) mais l’affiche dans une fenêtre séparée. La seconde agit comme C-x b (switch-to-buffer) mais, de même, place le contenu dans une autre fenêtre. Si le cadre n’est constitué que d’une fenêtre, celui-ci est automatiquement scindé en deux.

`C-x 2,` `C-x 3`	création de fenêtres
`C-x o`	déplacement de fenêtre à fenêtre
`C-x 0,` `C-x 1`	suppression de fenêtres
`C-x 4 f`	visite un fichier dans une autre fenêtre
`C-x 4 b`	affiche un buffer dans une autre fenêtre

Gestion de l’historique des modifications avec VC

Le dernier outil essentiel à tout projet sérieux est un gestionnaire de versions. Si vous n’êtes pas familier avec ce concept, voici une brève introduction. Vos fichiers seront amenés à grandement évoluer avec les phases d’essai, de correction, d’essais publics, d’amélioration, etc. Il est donc primordial de contrôler ces changements sous forme de versions. Des logiciels spécialisés appelés « systèmes de contrôle de versions » (VCS, Version Control Systems en anglais) permettent de faire cela. Nous n’entrerons pas ici dans le détail du fonctionnement de ceux-ci, mais le principe général est le suivant : chaque fichier est associé à une copie persistante, qui représente tous ses états depuis le début, toutes ses versions, sous forme de différences. Cela signifie qu’une version n’est pas stockée en entier mais uniquement sous une forme relative à une version voisine. Dans sa réalisation la plus classique, par exemple, si vous ajoutez une ligne à un fichier, le fichier de contrôle, contenant la copie persistante, enregistrera une différence d’une ligne par rapport à la version précédente.

Emacs intègre un support de certains de ces systèmes, dont RCS, CVS, SVN et Git. Pour illustrer cette intégration, qui porte le petit nom de VC pour, vous l’aurez deviné, Version Control, nous allons nous intéresser au plus simple d’entre eux : RCS. Mais les commandes demeurent approximativement les mêmes quel que soit le programme de gestion de versions.

Traditionnellement, les fichiers de contrôle de RCS sont stockés localement dans un sous-dossier de celui où se situent vos fichiers sources, ce sous-dossier portant le nom RCS. Si vous ne le créez pas par vous-même, Emacs vous le proposera en temps voulu.

L’utilisation de VC repose sur la commande C-x v v (vc-next-action). Comme son nom l’indique, elle fait… des choses, selon l’état actuel du fichier. Avec RCS, un fichier peut avoir plusieurs états. Dans son utilisation classique, ce sont les suivants.

Au départ, le fichier est inconnu de RCS. Lorsque vous l’enregistrez auprès de ce dernier (avec C-x v v), celui-ci s’approprie le contenu. Le fichier et la version la plus récente connue de RCS sont alors les mêmes.
À ce stade, vous ne pouvez pas modifier le fichier à nouveau. Il vous faut prévenir RCS de votre intention, ceci afin d’empêcher que plusieurs personnes ne modifient le même fichier en même temps. Cette action s’appelle le verrouillage et s’effectue aussi par C-x v v. Une fois le fichier verrouillé, vous êtes sûr qu’il est la seule copie de travail existante.
Une fois vos modifications effectuées, C-x v v synchronise votre brouillon avec la copie de contrôle. VC vous demande alors de fournir un commentaire décrivant les changements, commentaire qui sera inscrit dans une espèce de journal de bord du fichier. La fenêtre d’édition du message est tout à fait banale et la validation est obtenue par le traditionnel C-c C-c, valable pour la plupart des formulaires sous Emacs. Après cette étape, le fichier et la version la plus récente connue de RCS sont à nouveau les mêmes.

Tout ceci est bien joli, mais à quoi serviraient un historique et un journal que l’on ne peut consulter ?

La commande C-x v ~ (vc-version-other-window) vous permet d’accéder au contenu d’une version antérieure de votre fichier. Le numéro de la version vous sera demandé. Mais que faire si vous ne vous rappelez plus de la bonne version ? C’est à cela que servent les commentaires que vous avez pris soin d’entrer tout au long de votre travail ! Pour voir la liste des versions ainsi que les messages associés, tapez C-x v l (vc-print-log).

Une fois la version voulue récupérée dans un buffer secondaire, vous pouvez afficher les deux buffers en parallèle comme nous avons vu précédemment. Mais VC propose une commande intéressante pour vous aider à voir les différences entre vos versions : C-x v = (vc-diff). Elle vous propose une comparaison rapide de deux versions, avec la différence placée dans un buffer à part.

Cela peut sembler beaucoup de choses à enregistrer si vous n’avez jamais utilisé de VCS auparavant, mais j’ai moi-même débuté dans ce domaine avec VC qui est, à mon avis, un moyen simple de se familiariser avec le concept tout en restant bien au chaud dans son éditeur préféré. Et pour vous y aider, voici un… récapitulatif ! Avouez que vous ne vous y attendiez pas.

`C-x v v`	change d’état
`C-x v ~`	ressuscite une version
`C-x v l`	invoque la liste des versions
`C-x v =`	compare deux versions

Cette présentation de VC et de RCS achève ce premier article. Dans le prochain chapitre (peut-être…^α), nous parlerons de la compilation de fichiers et de projets écrits en C, à l’aide de makefiles, le tout depuis Emacs. Contrairement à ce premier tutoriel, il sera bien moins porté sur Emacs lui-même que sur les outils à mettre en œuvre pour compiler depuis Emacs, c’est-à-dire GCC et make.

α : L’histoire nous a montré que ce « peut-être » a su se transformer en « non ». :)

Je remercie Metzgermeister et nicofrand pour la relecture de cet article.

Votre premier .emacs

2008-05-04T00:00:00+02:00

Cela faisait un moment que je voulais migrer tous mes modestes écrits sur la même plateforme ; voilà un pas de plus dans cette direction avec la réédition de ce petit classique du fond de mon tiroir ! —rz0

Ceci n’est pas une introduction à Emacs en soi mais à sa configuration. Si vous connaissez les bases, avez lu le tutorial intégré ou quelque chose d’équivalent, que vous arrivez à vous déplacer, écrire du texte, et éditer des fichiers dans Emacs, mais souhaitez changer certains paramètres de son comportement, cet article est peut-être pour vous.

Cette introduction à la configuration vous apprendra au passage les bases de la syntaxe utilisée pour écrire le fichier .emacs ; si vous voulez juste copier et coller des bouts de code, cet article n’est pas pour vous.

Je ne documente ici ni XEmacs, ni NTEmacs, seulement GNU Emacs, soyez averti. Ce n’est pas que j’aie quoi que ce soit contre ceux-ci, mais je ne connais pas bien les autres emacs.

Comment configurer Emacs ?

Il existe trois moyens de configurer Emacs : par le menu, par une application intégrée appelée customize ou en éditant le fichier .emacs, situé dans votre dossier personnel ($HOME pour les étourdis).

Cet article porte sur l’édition du fichier .emacs, mais je vais tout de même passer en revue les autres possibilités pour vous expliquer pourquoi nous n’allons pas y avoir recours.

Par le menu

La première méthode n’a pas besoin d’explications ; si vous lisez ceci, vous savez probablement vous servir d’une souris, ou d’un clavier, ce qui est encore mieux, et quoi qu’il en soit, c’est suffisant pour configurer Emacs par le menu. Cette approche est toutefois très limitée, les options du menu étant ce qu’elles sont, et rien de plus.

Par customize

La deuxième offre un choix beaucoup plus important d’options ; quasiment tout ce qui est utile en terme de configuration directe peut être réalisé par cette interface. Pour l’invoquer, il suffit d’utiliser la commande customize (invoquée par M-x customize comme vous vous en doutez si vous avez eu une introduction décente à Emacs ; sinon, sachez que M-x signifie « la touche X en maintenant la touche Meta, Alt sur les claviers de PC, enfoncée »).

À partir de là, l’interface est assez simple : il y a des options, avec leur description, et leur valeur actuelle, modifiable, ainsi que des dossiers avec plus d’options et des sous-dossiers. Pour tout sauvegarder, il y a un bouton en haut du buffer. Cela écrira dans le fichier .emacs, par défaut.

Cette méthode a cependant un défaut : les modifications que vous apportez à votre configuration sont ensuite difficilement rectifiables directement en éditant le fichier produit par l’outil. De même, les changements effectués en dehors du mode customize, tels que ceux opérés sur le fichier .emacs, se marient assez mal avec celui-ci.

De plus, d’une version à l’autre d’Emacs, customize ne semble pas demeurer totalement rétro-compatible dans le sens où le fichier généré par customize dans une version récente risque de ne pas fonctionner correctement avec une version précédente.

Pour illustrer mon propos, je vais prendre mon exemple. J’ai un thème de couleurs grandement personnalisé. Je l’avais débuté étant sous Emacs 21, puis suis passé à Emacs 22 dès sa sortie. Je n’ai rencontré aucun problème de transfert vers la nouvelle version. Cependant, lorsque j’ai voulu prêter le fichier à quelqu’un qui était encore sous Emacs 21, celui-ci n’a pas pu le lire correctement !

Il y a peut-être une façon ninja de faire cette manipulation mais je ne suis pas au courant.

Par le fichier `.emacs`

Le fichier .emacs est un simple fichier contenant du texte. Simple ? pas vraiment en vérité. Le format du fichier est loin de ressembler à ce que vous avez sans doute l’habitude de voir avec d’autres configurations. La configuration d’Emacs est écrite en Lisp, plus précisément en Emacs Lisp. Si vous ne le savez pas, le Lisp est un langage de programmation à part entière !

En effet, la spécificité d’Emacs est d’être entièrement (ou presque) programmable, grâce à son langage intégré. Tout (ou presque) dans Emacs est Lisp. Les divers modes et applications dans Emacs sont codés en Emacs Lisp, et de même la configuration est écrite en Lisp.

Même lorsque vous éditez votre configuration à l’aide des menus ou de customize, Emacs retranscrit vos modifications en Lisp et les sauvegarde dans un fichier.

En réalité, le fichier .emacs est aussi appelé fichier d’initialisation car c’est simplement un programme écrit en Emacs Lisp qui est exécuté au démarrage d’Emacs.

L’intérêt de cette dernière méthode réside dans sa flexibilité ; vous pouvez presque tout faire rien qu’en écrivant du code Lisp dans votre .emacs, et même si toutes ces possibilités ne vous seront pas tout de suite utiles, c’est également l’approche qui s’adapte le mieux à une évolution vers une utilisation confirmée d’Emacs, qui implique l’apprentissage de l’Emacs Lisp.

Une approche conseillée

Vous l’aurez compris, je vous recommande chaudement de configurer votre Emacs en éditant le fichier .emacs par vous-même. Cependant, le mode customize a un usage très important : parcourir l’ensemble des paramètres disponibles pour une catégorie donnée. Pour cela, vous pouvez utiliser la commande customize-group qui vous permet d’aller directement à la configuration d’un groupe d’options particulier, dont vous devez donner le nom. Généralement, c’est le nom correspondant à l’application ou au mode que vous voulez configurer.

Par exemple, pour voir les possibilités de personnalisation offertes par ERC, le client IRC, vous exécuteriez la commande customize-group erc. Nous verrons plus loin comment mieux exploiter ces informations ; pour l’heure, vous ne pouvez sans doute que lire les descriptions d’options.

Une autre utilisation de customize que j’admets sans vraiment conseiller est la mise en place d’un thème de couleurs. Le faire sans customize est vraiment très pénible ; je l’ai fait, une fois, pour mon thème de couleurs basique, pour la console, mais je ne le referai pas, je crois. Nous verrons plus loin comment changer les polices et les décorations du texte, pour créer un environnement un peu plus agréable que le look par défaut.

Premiers pas

Aperçu de la syntaxe Lisp

Configurer Emacs ne requiert pas de connaître parfaitement l’Emacs Lisp, mais quelques rapides notions sont toutefois recommandées pour comprendre la syntaxe des lignes d’exemples à venir.

Le Lisp est un langage possédant une syntaxe extrêmement régulière. Toutes les constructions (ou presque) prennent la forme suivante :

(OPÉRATEUR OPÉRANDE ...)

Si vous avez déjà un peu programmé, sachez qu’OPERATEUR peut être aussi bien une fonction qu’une instruction spéciale (un if, un while, etc.). Sinon, retenez simplement que le premier mot dans la liste indique l’action à effectuer.

Et sans le vouloir, nous venons d’introduire la notion de liste. Une liste, c’est exactement ce que je viens de vous montrer, une suite d’éléments entre parenthèses, séparés par des blancs. Tout le code écrit en Emacs Lisp est essentiellement constitué de listes donc !

Commentaires

Tous les langages de programmation civilisés possèdent leur syntaxe pour inclure des commentaires dans le code, des lignes qui ne seront pas interprétées par Emacs. Il suffit de pour cela de précéder le texte à commenter par un point-virgule (ou plusieurs).

;; Ceci est un commentaire.

Environnement

La première chose à savoir est qu’il existe plusieurs fichiers similaires au .emacs qui contiennent divers morceaux de configuration. Principalement, on peut prendre note des fichiers suivants :

$HOME/.emacs.el ou $HOME/.emacs

Votre fichier d’initialisation principal. Les fichiers de code Emacs Lisp sont habituellement nommés avec un suffixe .el mais le .emacs peut faire exception. Il existe quelque différences, mais elles ne nous gêneront pas ici et je me référerai toujours à ce fichier comme le .emacs bien que je l’ai moi-même appelé .emacs.el.

$PREFIX/share/emacs/site-lisp/site-start.el

Le fichier global d’initialisation. Il joue le même rôle que le .emacs dans votre dossier personnel mais est lu avant votre .emacs. Il est souvent rempli à l’avance par votre installation dans le cas des gestionnaire de paquets, qui s’en servent pour charger des informations utiles sur les applications tierces qu’ils installent pour Emacs.

$PREFIX est la racine où vous avez installé Emacs. Généralement $PREFIX vaut /usr ou /usr/local ; sur certains systèmes, cela peut être /usr/pkg ou, si vous l’avez installé dans votre dossier personnel, $HOME/local.

fichiers de configuration des applications

Emacs est un environnement de travail qui peut accueillir des applications (spécifiquement développées pour Emacs). Chaque application possède souvent son propre fichier qui est lu au chargement de celle-ci. Par exemple, Mew utilise $HOME/mew.el.

fichiers de configuration auxiliaires

Vous pouvez également scinder votre .emacs en plusieurs fichiers, lorsque celui-ci deviendra relativement volumineux. Ce ne sera pas le cas aujourd’hui, aussi, nous n’aborderons pas ce sujet dans cet article.

Premier réglage : le système de codage de caractères

Emacs étant avant tout un éditeur de texte, son interface ainsi que la plupart des informations qu’il lit, stocke et échange demeurent sous forme textuelle. Un réglage très global et très important est donc le système de codage par défaut.

Pour ceux d’entre vous qui ne savent pas ce qu’est un système de codage de caractères, c’est simplement la représentation numérique (« binaire ») des caractères (lettres, chiffres, symboles) qui forment le texte. Pour plus d’informations, vous pouvez consulter la page Wikipédia sur le codage de caractères.

Il existe plusieurs options pour configurer en finesse les différents codages ; le réglage principal est obtenu par la commande set-language-environment. La syntaxe est la suivante :

(set-language-environment "NOM")

Il faut bien sûr remplacer NOM par le nom de l’environnement de votre choix. Les valeurs d’intérêt pour nous seront "UTF-8" si vous souhaitez avoir un environnement utilisant principalement l’UTF-8, ou "Latin-1" si vous voulez de l’ISO-8859-1. Les deux sont capables de représenter les caractères français ; l’UTF-8 permet en plus les caractères internationaux, provenant d’autres langues. Si vous ne savez pas pour lequel opter, je vous conseille l’UTF-8 ; la tendance actuelle va vers UTF-8 et les deux environnements de bureau dominants, à savoir GNOME et KDE, l’utilisent, par défaut.

Rajoutez la ligne qui convient à votre .emacs. S’il n’existe pas, créez le.

Organisation de vos fichiers

Votre .emacs ne contenant actuellement qu’une seule ligne, il semble superflu d’essayer de le diviser en plusieurs fichiers. Toutefois, en prévision des modifications que nous allons effectuer par le biais de customize, afin de mettre en place un thème de couleurs, un petit arrangement s’impose.

Par défaut, customize s’amuse à écrire dans votre .emacs, ce qui est très mal venu, surtout si vous utilisez un gestionnaire de versions comme RCS ou Git.

Il est très simple cependant de l’instruire de sorte à ce que le contenu soit placé dans un fichier réservé, de manière civilisée. Le nom de ce fichier est donné par la variable custom-file.

Variables dans Emacs

Dans Emacs, une variable est l’association d’une valeur (« quelque chose ») à un nom (un symbole dans le vocabulaire emacsien).

Ici, le symbole est custom-file et la valeur est le nom du fichier.

On change la valeur d’une variable avec la forme :

(setq SYMBOLE VALEUR)

Dans notre cas, la ligne devient :

(setq custom-file "NOM-DU-FICHIER")

Remarquez que le nom du fichier est entre guillemets droits ; c’est la manière d’écrire du texte (des chaînes de caractères pour ceux qui ont quelque expérience en programmation) en Emacs Lisp.

Par exemple, vous pourriez appeler ce fichier .emacs-custom.el et le placer dans votre dossier personnel, comme ceci :

(setq custom-file "~/.emacs-custom.el")

J’ai fait exprès d’utiliser le tilde, au cas où vous douteriez qu’Emacs le reconnaisse à l’instar du shell.

La syntaxe d’affectation (changement de valeur d’une variable) est très utile pour la configuration et n’est pas propre à la variable custom-file ; beaucoup d’options sont modifiables de cette manière. J’aurais pu vous donner directement l’instruction tout entière, mais, désormais, vous saurez reconnaître une affectation. C’est un premier pas sur la voie du programmeur Emacs Lisp ! :)

Toutefois, dans ce cas précis, simplement changer la valeur de la variable ne suffit pas. Cette manipulation va dire à customize d’inscrire ses modifications dans le fichier, mais celui-ci ne sera pas lu par Emacs lui-même comme l’est votre .emacs (et par voie de conséquence, comme l’étaient les ajouts faits par customize à celui-ci, avant que nous ne décidions de les détourner).

Pour charger ce fichier dans la mémoire d’Emacs et l’exécuter, nous allons employer la fonction load comme ceci :

(load custom-file)

Cette ligne est à placer après avoir donné à la variable custom-file sa valeur, bien entendue ; en effet, on demande ici à Emacs de lire le fichier dont le nom est donné par la variable custom-file. On aurait pu écrire :

(load "~/.emacs-custom.el")

Variables dans customize

Maintenant que nous avons eu un bref aperçu des variables, rappelez-vous customize et de son utilisation en tant qu’explorateur d’options.

Dans l’interface de customize, vous trouverez beaucoup d’options de configurations ; chacune porte un nom, qui, en règle générale, correspond à celui d’une variable, avec des espaces à la place des tirets et des majuscules au début des mots. L’option Ceci Est Une Option est en vérité la variable ceci-est-une-option.

La description ainsi que les menus vous donnerons une petite idée des valeurs acceptables et vous pourrez modifier la variable dans votre .emacs. Remarquez que le menu offert par le bouton State vous propose de voir l’expression Lisp telle que vous pourriez vouloir l’inscrire dans votre .emacs.

Récapitulatif

Nous avons vu, dans cette partie, quelques réglages fondamentaux, ainsi que la syntaxe pour affecter une valeur à une variable. Votre .emacs devrait maintenant ressembler à ceci :

(set-language-environment "UTF-8")

(setq custom-file "~/.emacs-custom.el")
(load custom-file)

Changer l’apparence d’Emacs

Ce n’est certainement pas le plus utile, mais c’est une question qui revient fréquemment : comment changer l’apparence d’Emacs. La méthode présentée ici n’est peut-être pas la plus propre, mais c’est celle que je trouve la plus pratique, et pour quelque chose de secondaire tel que l’affichage, elle conviendra bien.

Changer la police d’affichage

Cette section n’a d’intérêt que si vous utilisez Emacs en mode graphique. Autrement, il s’agit de configurer votre console et non Emacs.

L’interface d’Emacs est majoritairement constituée de texte, il est important de configurer une police qui vous est agréable. La police par défaut doit être monospacée, mais cela mis à part, vous pouvez utiliser n’importe quelle police supportée par les applications graphiques. Sous X, cependant, la version 22 ne supporte pas encore le lissage des caractères. Je vous conseille donc de prendre une police disponible en format bitmap. Personnellement, j’utilise terminus pour Emacs 22.

Comme je l’ai indiqué auparavant, nous allons utiliser customize pour modifier les paramètres d’affichage. La commande M-x customize-face réalise cela.

Dans Emacs, « face » est le nom donné à un jeu d’attributs d’affichage. Il y en a pour chaque type de caractère que vous pouvez rencontrer dans un buffer : les caractères normaux, les mots-clés ou encore les commentaires, dans du code.

Emacs vous demande alors quel type de caractères modifier. Entrez default pour personnaliser le type par défaut, dont les attributs sont hérités par tous les autres, si ceux-ci ne fournissent pas les leurs. Vous devriez alors obtenir une interface semblable à celle représentée ci-dessous :

Default face: (sample) Hide Face
   State: SAVED and set.
Basic default face.
Parent groups: Basic Faces
Choice: Value Menu
 Attributes: [X] Font Family: xos4-terminus
             [X] Width: Value Menu medium
             [X] Height: Value Menu Height in 1/10 pt: 151
             [X] Weight: Value Menu medium
             [X] Slant: Value Menu normal
             [X] Underline: Value Menu Off
             [X] Overline: Value Menu Off
             [X] Strike-through: Value Menu Off
             [X] Box around text: Value Menu Off
             [X] Inverse-video: Value Menu Off
             [X] Foreground: gray88     (sample)
             [X] Background: black      (sample)
             [X] Stipple: Value Menu None
             [ ] Inherit: *

La plupart des champs devraient parler d’eux-mêmes. En vérité, pour le type par défaut, nous ne voulons sans doute pas altérer d’autres champs que Font Family, Height, Foreground et Background. Vous pouvez obtenir une jolie liste des couleurs et leurs noms avec la commande M-x list-colors-display.

Expérimentez un peu pour obtenir ce qui vous convient. Pour appliquer vos changements, actionnez le bouton State ; les choix proposés ne posent aucune difficulté. Faites plusieurs fois Set for Current Session, puis, lorsque vous êtes content de vos paramètres, choisissez Save for Future Sessions.

Cette manipulation est réalisable pour n’importe quel type ; pour avoir accès à la liste complète, validez sans fournir de nom, lors de l’invite offerte par M-x customize-face. Veuillez prendre note du fait que seuls les types existants seront ainsi disponibles. En particulier, si vous souhaitez personnaliser un module particulier, il faudra le charger avant d’utiliser M-x customize-face. La plupart des modules se chargent automatiquement lorsque vous tentez d’accéder à un de leurs modes.

Si vous voulez changer la manière dont s’affichent les titres sous le mode LaTeX, tentez de visiter un fichier LaTeX avant d’utiliser M-x customize-face.

Un moyen pratique de savoir quel type personnaliser est de placer votre curseur sur un caractère présentant les propriétés que vous voulez changer et d’invoquer M-x customize-face ; l’invite vous proposera alors par défaut de changer le type dont est affecté ce caractère !

Composants de l’interface

Après ce petit intermède en compagnie de customize, revenons à l’édition de notre .emacs.

Par défaut, Emacs affiche beaucoup de composants sans grand intérêt dans son interface : un menu, une barre d’outils et même des barres de défilement, mais oublie certaines informations importantes telles que le numéro de la colonne à laquelle le curseur se situe. Nous allons au plus vite remédier à cela.

Le menu, les barres d’outils et de défilement peuvent être supprimés avec les instructions suivantes :

(menu-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)

L’affichage du numéro de la colonne est obtenu par l’instruction :

(column-number-mode 1)

Le tout est bien sûr à placer dans votre .emacs, à la suite des changements précédents. Voilà déjà quelques lignes de gagnées dans votre espace de travail !

Autres paramètres d’affichage

Terminons notre petit tour d’horizon des options de configuration de l’interface d’Emacs par quelques paramètres que vous pourriez vouloir et qui adressent chacune un aspect différent de l’affichage d’Emacs.

La première est truncate-partial-width-windows. Par défaut, Emacs replie automatiquement les lignes de texte dans les fenêtres en plein écran, mais, si vous décidez de partager horizontalement votre Emacs en deux fenêtres côte à côte, vous vous apercevrez qu’Emacs tronque à présent les lignes trop longues. Pour empêcher cela, il faut changer la valeur de la variable truncate-partial-width-windows de t (qui signifie « vrai » en termes booléens) à nil (qui signifie « faux »).
```
(setq truncate-partial-width-windows nil)
```
Emacs possède de même tout un tas de paramètres qui vous permettent de changer la manière dont il affiche les éléments. N’hésitez pas à fouiller pour en trouver d’autres !
Mentionnons, par exemple, un petit réglage de confort sous la forme de la variable ring-bell-function. Elle vous permet de spécifier une fonction à appeler au lieu de faire sonner la petite alarme (qui fait « bip ») interne de votre ordinateur. Il y a plusieurs valeurs possibles, mais un choix convenable est le suivant :
```
(setq ring-bell-function 'ignore)
```
La fonction ignore ne fait rien ; du coup, vous n’aurez plus droit à ces alarmes que personnellement je trouve perturbatrices.
En deuxième, regardons comment on peut avoir l’heure tout en restant dans Emacs. Cela fait partie des nombreux gadgets (mais qui peuvent s’avérer utiles ; en l’occurrence, j’aime avoir l’heure dans Emacs) disponibles sous Emacs.
Pour activer l’affichage de l’heure dans la barre de modes, inscrivez la ligne suivante dans votre .emacs.
```
(display-time-mode t)
```
Vous l’aurez peut-être remarqué, nous avons déjà vu plusieurs fonctions dont le nom se termine par -mode. Ici, ce sont des modes mineurs globaux. En d’autres termes, ce sont des fonctionnalités que vous pouvez activer ou désactiver. À la différence des variables, les modes fonctionnent dans une optique plus binaire : un mode est actif ou il ne l’est pas. Les variables, quant à elles, permettent de spécifier des valeurs particulières pour contrôler certains aspects du fonctionnement d’Emacs.

Changer les combinaisons au clavier

Maintenant que vous savez comment configurer l’apparence d’Emacs, nous allons nous intéresser aux combinaisons au clavier. Emacs étant un éditeur « orienté clavier », tout peut se faire au clavier. Mais cela signifie aussi qu’il est important d’avoir des raccourcis pratiques.

Cela ne signifie pas essayer de mettre Ctrl-C et Ctrl-V de partout. Cela ne marchera pas comme vous voudrez. Emacs a ses conventions et ses manières. Cette section vous apprend à ajouter des commandes facilement accessibles par une combinaison de touches ; elle n’est pas là pour vous inciter à faire de votre Emacs un Notepad++ ou je ne sais quoi encore.

Notations des combinaisons dans Emacs

Si vous avez un minimum d’expérience sous Emacs, vous le savez déjà, mais la notation des combinaisons de touches sous Emacs n’est pas la même que sous d’autres environnements. Chaque touche modificatrice (Ctrl, Alt, etc.) est représentée par une lettre et une combinaison est notée Mod-Reste où Mod est la lettre correspondant à la touche modificatrice et Reste est une combinaison.

Les correspondances sont les suivantes :

`Shift`	`S`
`Ctrl`	`C`
`Meta` (ou `Alt`)	`M`

Par exemple, C-a est obtenu en maintenant Ctrl et en appuyant sur a, et C-M-f est la combinaison de Ctrl, Alt et f sur un clavier français usuel.

Combinaisons réservées

Emacs possède des conventions quant aux combinaisons que vous pouvez utiliser et à celles qui sont réservées à différentes parties de l’éditeur.

Il vous faut simplement retenir que vous êtes autorisé à créer des raccourcis débutant par C-c suivi d’une lettre pour vos besoins personnels, en tant qu’utilisateur. Les autres combinaisons commençant par C-c sont réservées aux modes majeurs et mineurs (ce n’est pas important si vous ne savez pas bien ce que sont les uns et les autres) et les autres espaces sont pris par Emacs lui-même ou des composants spécialisés.

Fonctions, commandes et combinaisons

Pour pouvoir associer des commandes aux combinaisons de touches, il faut d’une part savoir comment noter la combinaison et d’autre part connaître la fonction à lui associer.

Pour Emacs, chaque combinaison de touches invoque une commande (encore appelée fonction interactive). Une commande est une fonction, c’est-à-dire, dit simplement, une suite d’actions à effectuer, soit écrite en Emacs Lisp, soit écrite en C et connue nativement d’Emacs. Mais toutes les fonctions ne sont pas des commandes. Il faut en effet qu’elles soient prévues pour être appelées de manière interactive, par l’utilisateur. Toute fonction qui peut être appelée via M-x NOM-DE-LA-FONCTION est une commande ; le but de cette section est de vous permettre d’éviter d’avoir à taper le nom de la commande à chaque fois, en lui associant un raccourci clavier.

La fonction `global-set-key`

C’est la fonction permettant d’attacher une combinaison de touches à une commande, au niveau global, c’est-à-dire disponible partout dans Emacs. La syntaxe est la suivante :

(global-set-key COMBINAISON COMMANDE)

COMBINAISON est une séquence de touches. La manière la plus simple de l’écrire est d’utiliser la fonction kbd comme ceci :

(kbd DESCRIPTION)

DESCRIPTION est alors la description de touches telle qu’elle a été présentée ci-dessus, entre guillemets droits. Par exemple :

(kbd "C-c g")

Le tout est à mettre à la place de COMBINAISON.

COMMANDE est, dans sa forme la plus simple, et la seule que nous verrons dans cet article, le nom d’une fonction précédé d’une apostrophe ; par exemple : 'replace-string.

Imaginons que vous vouliez attacher la commande replace-string à la combinaison C-c h. Vous pourriez écrire la ligne suivante dans le .emacs :

(global-set-key (kbd "C-c h") 'replace-string)

Dorénavant, lorsque vous rencontrerez une commande intéressante, sur un wiki, un blog, ou dans le .emacs de quelqu’un d’autre, vous saurez comment l’affecter aux touches de votre choix !

Quelques commandes utiles qui ne demandent qu’à être affectées

Commande	Description rapide
`replace-string`	remplace un texte par un autre dans le buffer
`replace-regexp`	pareil que `replace-string` avec une regexp
`bury-buffer`	cycle parmi vos buffers
`kill-this-buffer`	détruit le buffer et ferme le fichier
`compile`	invoque make pour compiler vos fichiers sources
`gdb`	invoque gdb pour déboguer vos programmes

Configurer Emacs pour programmer en C

Si vous avez lu et appliqué mes instructions jusqu’ici, votre Emacs devrait être suffisamment configuré pour l’édition de fichiers de texte. La plupart des utilisateurs d’Emacs le sont cependant pour leurs besoins en matière de programmation. Aussi, cette avant-dernière section adresse quelques points de configuration d’Emacs pour pouvoir écrire du C dans de bonnes conditions.

D’autres modes de langages de programmation ont des paramétrages semblables, mais il n’y a pas de règle vraiment générale. Il vous faudra lire les manuels correspondants.

Style d’indentation

L’une des fonctionnalités les plus appréciées d’Emacs est sa capacité à indenter intelligemment le code selon le contexte. Le mode d’édition du C, notamment, possède un indenteur relativement performant. Cependant, par défaut, celui-ci suit les règles de présentation du GNU. Si comme moi cela vous contrarie fortement, il est aisé de changer de style. La variable c-default-style contient le nom du style à utiliser, sous forme d’une chaîne de caractères (entre guillemets). Les valeurs habituelles sont les suivantes :

`"k&r"`	le style K&R, aussi appelé style kernel
`"bsd"`	le style Allman, aussi appelé style BSD
`"whitesmith"`	le style Whitesmiths
`"gnu"`	le style GNU, celui par défaut

Par exemple, si vous utilisez le style K&R, vous écrirez :

(setq c-default-style "k&r")

Pas d’indentation, espaces et tabulations

En plus du style, il y a également une histoire de pas (ou largeur) d’indentation. Par exemple, par défaut, Emacs indente vos blocs de 4, en style K&R. Personnellement, j’utilise un pas de 8. Cela est obtenu en changeant la valeur de la variable c-basic-offset. Pour moi :

(setq c-basic-offset 8)

De plus, la variable indent-tabs-mode contrôle l’usage des tabulations pour l’indentation. C’est une variable booléenne. Une valeur vraie (t) signifie que les tabulations seront utilisées dès que possible tandis qu’une valeur fausse (nil) obligera Emacs à n’utiliser que des espaces pour indenter. Par défaut, elle vaut t. Je vous laisse deviner l’instruction à placer dans votre .emacs si vous voulez des espaces !

Autres options

Le mode C étant l’un des plus populaires, il possède son lot de paramètres intéressants ou obscurs que je vous laisse découvrir en compagnie de la documentation. Vous pourriez vouloir personnaliser un peu plus le style d’indentation en modifiant la variable c-offsets-alist. Je ne détaillerai pas son fonctionnement ici, mais n’hésitez pas à consulter mon .emacs pour un petit exemple.

Avec tout cela, l’édition du code C devrait maintenant être tout à fait satisfaisante. Ainsi, votre Emacs devrait maintenant être relativement complet pour un début. Cet article s’achève ici et je vous laisse comparer le résultat de votre apprentissage avec un exemple de fichier .emacs écrit d’après ce tutoriel.

Exemple final d’un fichier `.emacs` basique

;; Environnement
(set-language-environment "UTF-8")

(setq custom-file "~/.emacs-custom.el")
(load custom-file)

;; Affichage
(menu-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)

(column-number-mode t)

(setq truncate-partial-width-windows nil)
(setq ring-bell-function 'ignore)

(display-time-mode t)

;; Raccourcis
(global-set-key (kbd "C-c h") 'replace-string)
(global-set-key (kbd "C-c j") 'replace-regexp)
(global-set-key (kbd "C-c o") 'bury-buffer)
(global-set-key (kbd "C-c k") 'kill-this-buffer)
(global-set-key (kbd "C-c c") 'compile)
(global-set-key (kbd "C-c g") 'gdb)