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 :

 
TéléchargerSélectionnez
/* // 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.

 
TéléchargerSélectionnez
;; 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 !