Ah bon, Vim peut remplacer mon vieux baril d'IDE ?!

Oui! Vim peut remplacer avantageusement votre vieil IDE pénible et pas standard.

Cet article aborde l'utilisation de makefiles avec GCC, mais bien entendu, le langage choisi reste à votre discrétion.

Dans le manuel de Vim, la compilation et la gestion des messages générés se nomme quickfix.

quickfix doit être spécifié à la compilation. C'est généralement le cas.


Pssst le Windozien, regarde par ici !

Si vous êtes sous MS-Windows, et que vous développez, vous utilisez probablement un shell tel que MSys ou Cygwin.

Si ce n'est pas le cas, vous devriez en installer un, et ajouter le path de Vim. Vous récupérerez ainsi un environnement utilisable pour la chaine de développement GNU (make, gcc, g++ etc..).

Vim sera bien sûr invoqué depuis le shell, afin qu'il hérite des variables d'environnement lorsque sera venu le moment de compiler.

Les gens qui s'obstinent à utiliser Visual Studio auront tout interet à changer le make par défaut:

:set makeprg=nmake

Ainsi que le format des erreurs du compilateur:

:compiler=msvc


quickfix : commandes de base

  • :compiler format des erreurs
    • permets d'indiquer à Vim le format des erreurs générées par le compilateur.
    • Ex: :compiler intel
    • sans argument, cette commande liste les formats disponibles.
  • :make arguments
    • lance la compilation.
    • si vous avez modifié des sources sans les sauver, vous serez prévenu par un message.
    • si "make" ne trouve pas le makefile, assurez vous que Vim cherche dans le bon répertoire
  • :pwd
    • affiche le répertoire courant de Vim (celui où il va chercher le makefile).
  • :cd
    • change le répertoire courant de Vim.
  • :cl
    • pour lister uniquement les erreurs.
  • :cl!
    • pour lister tous les messages générés par la compilation.
  • :cold et :cnew
    • quickfix fonctionne comme une pile.
    • par défaut, on est positionné à l'étage correspondant à la dernière compilation, mais on peut naviguer dans la pile avec cold et cnew
    • attention, il s'agit bien de :cnew et non pas cnext
    • la pile est utile pour revoir d'anciens warnings qui n'apparaissent plus dans la dernière compilation. C'est le cas pour un fichier qui n'a généré que des warnings, et qui ne sera donc pas recompilé.
    • 10 niveaux de pile sont disponibles.
  • :cn et :cp
    • pour la pile actuelle, affiche le warning/erreur suivant(e) ou précédent(e).
  • :cc[!] nr
    • pour voir/revoir un message, ou afficher complètement un message affiché précédemment sous forme abrégée.
    • si nr (numéro d'erreur) n'est pas spécifié, on reste indéfiniment sur l'erreur actuelle.
    • si :cc est suivi de !, on autorise un changement de buffer même si le buffer actuel comporte des modifications non sauvegardées.


Regarder par la fenêtre

Tout ça, c'est bien joli, mais les éditions lignes à ligne, ce n'est pas ce qu'il y a de plus pratique.

Voici quelques commandes supplémentaires pour afficher le buffer de compilation dans une fenêtre à part.

Vous pourrez continuer à utiliser les commandes du paragraphe précédent, ou naviguer directement dans cette fenêtre en pointant les lignes qui vous intéressent.

  • :cope hauteur
    • ouvre la fenêtre des erreurs.
    • si hauteur n'est pas spécifié, la fenêtre aura une hauteur de dix lignes.
    • cette fenêtre est mise à jour automatiquement à chaque nouvelle compilation.
  • :ccl
    • ferme la fenêtre des erreurs.

Normalement, la fenêtre quickfix apparait en bas de l'écran. Si il y a une séparation verticale entre plusieurs fenêtres, la fenêtre quickfix apparaitra en bas de la fenêtre la plus à droite. Pour lui faire occuper en permanence toute la largeur de l'écran, utilisez:

:botright cwindow


Compiler un source sans makefile

Il est également possible de compiler un source isolé sans avoir besoin d'un makefile pour l'occasion.

Il suffit pour cela de modifier la variable makeprg qui contient par défaut make.

Pour compiler le source fizzbuzz.cpp à l'aide de la commande :make, vous ferez:

set makeprg=g++\ fizzbuzz.cpp

suivi de:

:make

N'oubliez pas de rétablir la valeur de makeprg à sa valeur initiale si vous voulez utiliser un makefile dans la même session.


make & run

Allez, c'est vrai qu'il est plus agréable d'avoir un make'n'run sur une touche.

Pour cet exemple, on utilisera la touche F12.

Pour simplifier, on considère que le programme a le nom GNU par défaut (a.out).

Methode #1 : sous-shell depuis Vim

Cette méthode est inspirée d'une discussion avec Mark Weber (#vim) , merci Mark.

This method is based on a chat with Mark Weber (#vim) , thank you Mark.

  • Tous les messages partent dans quickfix (donc dans la fenêtre cope si elle est ouverte, ce qui peut être pratique).
  • .vimrc
    • set makeprg=sh
    • map <F12>:wa<CR> :make -c "make cible && ./a.out"<CR>


Methode #2 : sorties dans une nouvelle fenêtre
  • Méthode indiquée pour info, car semble poser problèmes dans MS-Windows. J'utilise la méthode #1, qui me convient parfaitement.
  • Les messages de compilation restent dans quickfix, les sorties du programme vont dans une nouvelle fenêtre créée pour l'occasion
  • il peut être nécessaire de tester la réussite de la compilation avec un check sur le v:system_result de Vim.
  • .vimrc
    • map <F12> :wa<CR> :make && ~/.vim/makerun ./a.out <CR>
  • contenu de makerun pour Bash :
#trop facile avec Bash
xterm -e less -f <($1 2>&1)


  • contenu de makerun pour les shells posix
#plus compliqué, mais posix :
(xterm -e "tail -f /tmp/$$.log | less"; rm -f /tmp/$$.log)&
$1 2>>/tmp/$$.log 1>&2


Vous en voulez encore ?

Cette courte présentation n'a pas la prétention d'être exaustive. Pour avoir la syntaxe complète des commandes précédemment évoquées, et bien plus encore:

:help quickfix

Bonne lecture :-)