Indentation avec Emacs

haypo

- Titre : Indentation avec Emacs

- Auteur : haypo

- Parution : 23 février 2003

- Mise à jour : 8 mars 2013

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2013 haypo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- II. Modifier le style d'indentation C existant

- III. Créer son propre style

I - Introduction

Emacs possède une fonction très intéressant : « indent-region ». Celle-ci permet de réindenter une région d'un fichier selon le mode actuel. Le mode qu'on va étudier ici est le mode « c-mode » (« cc-mode »), c'est à dire l'indentation des fichiers C.

Mais chacun à son propre style de programmation. Vous pouvez changer de style avec la fonction « c-set-style ». Mais certain, moi par exemple, ne trouveront toujours pas leur bonheur. Ce n'est pas grave, Emacs a pensé à tout le monde :-)

II - Modifier le style d'indentation C existant

Il existe deux raccourcis très utiles sous Emacs spécifiques à l'indentation :

- C-c C-s : informe sur l'indentation ;

- C-c C-o : Change interactivement l'indentation.

Pour vous entraîner, utilisez ce fichier C :

/* // comment-intro
* // c (multi-line comment)
* Explication de l'indentation Emacs.
*
* C-c C-s : Affiche les infos sur l'indentation.
* C-c C-o : Modifie l'option courante l'indentation.
*
* HaypoStyle =
* c-basic-offset = 2
* substatement-open = 0
*/

// cpp-macro
#define MACRO(a,b) (a)+(b)\
+(a) // cpp-macro-cont

int main(int argc,
char **argv) // arglist-cont-nonempty
{
int a; // defun-block-intro
const char *txt;

enum
{ // brace-list-open
NOMBRE, // brace-list-intro
CARACTERE // brace-list-entry
} TypeElement; // brace-list-close

a = 8
+1; // statement-cont

do
{
a--;
}
while (0); // do-while-closure

txt = "texte \
qui tient sur plusieurs lignes"; // string

switch (a)
{ // substatement-open
// Commentaire // comment-intro
case 0: // case-label
a++; // statement-case-intro
break;
default: a=1;
}

printf ("a = %i\n",
a); // arglist-cont-nonempty

if (a)
{ // substatement-open
a = 0; // statement-block-intro
} // block-close
else // else-clause
{ // substatement-open
a = 1; // statement-block-intro
} // block-close
} // defun-close

Je l'ai spécialement écrit pour configurer l'indentation, je ne sais pas s'il sert à quelque chose :-)

III - Créer son propre style

Pour créer son propre style, utilisez la fonction « c-add-style ». Le mieux est de se baser sur un style existant, puis de le retravailler.

Mon style est basé sur le style GNU en modifiant deux ou trois paramètres.

;; Le style d'indentation de Haypo
;; Yeah, groovy Baby !

(c-add-style
"haypo"
(quote
(
;; Indentation de base = 2 espaces
(c-basic-offset . 2)
(c-backslash-column . 48)
(c-cleanup-list scope-operator)
(c-comment-only-line-offset . 0)
(c-electric-pound-behavior)
(c-hanging-braces-alist
(brace-list-open)
(brace-entry-open)
(substatement-open after)
(block-close . c-snug-do-while)
(extern-lang-open after)
(inexpr-class-open after)
(inexpr-class-close before))
(c-hanging-colons-alist)
(c-hanging-comment-starter-p . t)
(c-hanging-comment-ender-p . t)
(c-offsets-alist
(string . c-lineup-dont-change)
(c . c-lineup-C-comments)
(defun-open . 0)
(defun-close . 0)
(defun-block-intro . +)
(class-open . 0)
(class-close . 0)
(inline-open . +)
(inline-close . 0)
(func-decl-cont . +)
(knr-argdecl-intro . +)
(knr-argdecl . 0)
(topmost-intro . 0)
(topmost-intro-cont . 0)
(member-init-intro . +)
(member-init-cont . 0)
(inher-intro . +)
(inher-cont . c-lineup-multi-inher)
(block-open . 0)
(block-close . 0)
(brace-list-open . 0)
(brace-list-close . 0)
(brace-list-intro . +)
(brace-list-entry . 0)
(brace-entry-open . 0)
(statement . 0)
(statement-cont . +)
(statement-block-intro . +)
(statement-case-intro . +)
(statement-case-open . 0)
(substatement . +)

;; Pas de décalage lors de l'ouverture d'un bloc
(substatement-open . 0)
(case-label . 0)
(access-label . -)
(label . 2)
(do-while-closure . 0)
(else-clause . 0)
(catch-clause . 0)
(comment-intro . c-lineup-comment)
(arglist-intro . +)
(arglist-cont . 0)
(arglist-cont-nonempty . c-lineup-arglist)
(arglist-close . +)
(stream-op . c-lineup-streamop)
(inclass . +)
(cpp-macro . -1000)
(cpp-macro-cont . c-lineup-dont-change)
(friend . 0)
(objc-method-intro . -1000)
(objc-method-args-cont . c-lineup-ObjC-method-args)
(objc-method-call-cont . c-lineup-ObjC-method-call)
(extern-lang-open . 0)
(extern-lang-close . 0)
(inextern-lang . +)
(namespace-open . 0)
(namespace-close . 0)
(innamespace . +)
(template-args-cont . +)
(inlambda . c-lineup-inexpr-block)
(lambda-intro-cont . +)
(inexpr-statement . 0)
(inexpr-class . +)
)
)
)
)

Vous pouvez le charger au démarrage en ajoutant la ligne >(load "~/haypo_style.el")< dans votre fichier de configuration ("~/.emacs").

Vous pouvez alors utiliser le style « haypo » en utilisant la fonction « c-set-style ». Cool !