Vim permet de faire ceci grâce au greffon taglist.

Après avoir décompressé le plugin dans votre répertoire ~/.vim/plugin/, vous pourrez ajouter aussi la documentation (doc/taglist.txt) au répertoire ~/.vim/doc. Comme déjà expliqué dans un article précédent, il faudra ensuite faire sous vim

.

Ouvrez votre fichier source, puis tapez maintenant :TlistToggle.
Cela fera apparaître une fenêtre de la liste de vos variables, fonctions, classes, tout ceci de manière hiérarchique.

Pour naviguer sur une fonction, il suffit de positionner son curseur sur la fonction et de faire Entrer.
Pour passer d’une fenêtre à l’autre, faire la combinaison Ctrl-W W.

Pour obtenir une petite aide rapide des raccourcis claviers, taper F1 dans la « Taglist ».
Vous pourrez voir comment ouvrir ou fermer une arborescence.

Par défaut la liste des tags est affichée dans l’ordre d’apparition du fichier source.
Lorsque vous chercherez une fonction dont vous connaissez le début du nom, vous souhaiterez plutôt un affichage par ordre alphabétique.
Rien de plus simple, il suffit de taper la touche s (sort) dans la taglist.
Si vous tapez de nouveau sur cette touche, on bascule de nouveau sur l’affichage classique.

Pour ouvrir un nouveau fichier, placez vous d’abord dans la fenêtre du fichier source existant puis taper :e nouveau_fichier.c.
Vous pouvez aussi taper la commande :TlistAddFiles nouveau_fichier.c. Cette commande permet aussi d’ouvrir plusieurs fichiers en même temps, en précisant *.c par exemple.

Pour fermer un fichier, il suffira de faire un :bdelete (buffer delete).
cf. article sur l’édition de plusieurs fichiers et la manipulation des buffers
Plus simplement, vous pouvez positionner le curseur sur le fichier dans la Taglist et appuer sur la touche d.

Petite astuce: pour ouvrir facilement la Taglist ajouter ce code dans .vimrc :

map <F8> :TlistToggle

Comme vous l’aurez compris, cela permet d’ouvrir la Taglist par la touche F8 : très pratique !

Pour passer d’une fenêtre à l’autre, il suffit de taper Ctrl-W W.

La fermeture de la fenêtre courante s’effectue simplement par la commande :close.
Elle semble équivalente à la commande :q, à la seule différence que lors de la fermeture de la dernière fenêtre :close ne fermera pas vim.

Si vous souhaitez ne conserver que la fenêtre courante, et donc fermer toutes les autres, la commande :only répondra à vos besoins. Bien évidemment si une des fenêtres contient des modifications non enregistrées, vous obtiendrez un message d’erreur.

Dimensionner les fenêtres :
Lorsque vous ouvrez un fichier dans une nouvelle fenêtre via la commande :5split nouveau_fichier.txt, ceci signifie que la fenêtre aura une hauteur de 5 lignes.

Pour modifier par la suite la taille, il suffit de taper Ctrl-W + ou Ctrl-W - pour augmenter ou diminuer la hauteur. De la même manière que pour la plupart des commandes vim, il est possible de quantifier l’augmentation par 5 Ctrl-W +

Pour spécifier une taille fixe, 30 Ctrl-W _
Si vous ne précisez pas la taille (30 en l’occurrence), la fenêtre sera maximisée.

Il est certain que le redimensionnement des fenêtres au clavier n’est pas des plus aisé. Il est donc possible d’activer la souris (:set mouse=a) et de déplacer les barres de séparation via le pointeur.

Pour le partage vertical d’écran, la commande :vsplit s’utilise de la même manière que :split.

Pour passer d’une fenêtre à l’autre, il est possible d’utiliser la commande Ctrl-W h|j|k|l (la barre verticale signifiant ‘ou’) qui permettra de déplacer le curseur dans la direction souhaitée.

Pour modifier la largeur de la fenêtre courante, il suffira de taper Ctrl-W.
La largeur sera fixée par la commande : 20 Ctrl-W |

Lorsque vous ouvrez plusieurs fichiers au lancement de vim, il est possible d’ouvrir chaque fichier dans une fenêtre séparée via la commande :
vim -o fichier1.txt fichier2.txt fichier3.txt
Pour ouvrir les fenêtres dans le sens vertical utiliser l’option -O.

Si vos fichiers sont déjà ouverts dans vim (commande args), taper :all pour utiliser le multifenêtrage sur les fichiers de ligne de commande. Pour faire la séparation verticalement, taper :vertical all.

Il est aussi possible de préciser de quel côté vous souhaitez ouvrir une nouvelle fenêtre :

:leftabove {cmd} à gauche ou au-dessus de la fenêtre courante
:aboveleft {cmd} idem
:rightbelow {cmd} à droite ou en dessous de la fenêtre courante
:belowright {cmd} idem
:topleft {cmd} tout en haut ou à gauche de la fenêtre Vim
:botright {cmd} tout en bas ou à droite de la fenêtre Vim

Pour cela nous devrons charger un ‘greffon’, sorte de plugin typique à Vim.
:source $VIMRUNTIME/ftplugin/man.vim

Il suffit ensuite d’appeler la commande :
:Man printf
afin d’accéder aux pages man dans une nouvelle fenêtre en split horizontal.
Très pratique ! Il suffira ensuite d’user de la commande Ctrl-W W pour basculer d’une fenêtre à l’autre.

Autre fonction intéressante :
Via la commande \K, la page man s’ouvrira en fonction du mot sous le curseur.
Ceci rend la tâche on ne peut plus simple !

Nombreux sont ceux qui utilisent un gestionnaire de versions sur des projets de grands envergure, sur lesquels de nombreuses personnes développent.
Ceci permet de conserver une certaine cohérence sur le projet, de faire un retour arrière plus facilement, ou encore de fusionner le travail de plusieurs personnes sur une même source.

Etant donné le nombre de plus en plus croissant de gestionnaires de versions, nous installerons un greffon plutôt générique : VCSCommand.

VCSCommand permet de dialoguer avec les outils suivants: CVS (historique !), SVN (CVS amélioré), SVK (SVN en mode décentralisé), git (Made in Torvalds), bzr (décentralisé aussi), Mercurial (décentralisé, écrit en Python).

Une fois l’archive décompressée, 3 répertoires disponibles :
doc/
plugin/
syntax/

Dans le dossier doc/ se trouve l’aide vcscommand.txt qui vous indique de recopier les fichier .vim du répertoire plugin dans votre dossier plugin vim perso. Généralement il s’agit de $HOME/.vim/plugin.

Vous pouvez ajouter vcscommand.txt dans l’aide Vim en l’ajoutant votre répertoire d’aide perso ($HOME/.vim/doc). Raffraichissez ensuite l’aide Vim par la commande :helptags $HOME/.vim/doc/

Ceci permet d’accéder à l’aide sur les commandes, par exemple :help VCSAdd

Les commandes générales (commit, update, log, etc.) commencent par VCS…
Certaines commandes sont spécifiques au gestionnaire de versions, par exemple VCSCommandSVNDiffExt.

Ces commandes s’appliquent sur le buffer (ie. fichier) en cours d’édition.
Le résultat est affiché dans une fenêtre buffer temporaire.

Il est à noter que VCS n’affichera pas de prompt pour vous demander votre login/motdepasse pour vous connecter au serveur. Une erreur d’authentification s’affichera. De ce fait, il vous faudra appeler le gestionnaire de version en mode console une première fois et demander l’enregistrement du login/motdepasse.

Commande global
La commande :global permet de rechercher un motif particulier et d’exécuter une commande particulière sur la correspondance trouvée.
Par exemple, si l’on souhaire remplacer le mot ‘variable’ par ‘constante’ au sein d’un commentaire de type C++, il est possible d’employer la commande suivante :

:g+//+s/variable/constante/g

On recherche ici les caractères // (début de commentaire C++). Sur les lignes trouvées, on applique une substitution comme spécifié plus haut.
Vous aurez remarqué qu’on utilise le caractère + comme délimiteur (au lieu de / utilisé le plus souvent) pour des raisons de lisibilité.

Changement de casse

Pour passer du texte en minuscule ou en majuscule, il faut utiliser la commande gU (majuscule) ou gu (minuscule). Vous pouvez faire succéder la commande par w qui changera la casse du mot sous le curseur (gUw par exemple). Les objets textuels fonctionnent évidemment tout aussi bien.

Pour inverser la casse, il faut employer le caractère ~ en lieu et place de u.

Si vous doublez votre commande, ceci s’appliquera à la ligne entière (gUgU ou encore gUU).

Commandes externes

Le caractère ! permet d’appeler une commande externe de type unix de manière à effectuer tâche particulière que Vim ne sait pas faire.
Si l’on souhaite par exemple ajouter la date du jour dans le fichier, la commande unix ‘date’ permet de nous faciliter la tâche.
!!date +%d/%m/%y

Le point d’exclamation en double permet de préciser à Vim que nous travaillons sur la ligne courante.
Ensuite on retrouve notre commande date accompagnée de ses paramètres pour un affichage de la forme jour/mois/année.

Vous pouvez aussi lire le contenu de la sortie standard d’une commande.
:5read !ls -l

permet de lister les fichiers du répertoire courant et de les insérer à la ligne 5.

A l’inverse, il est possible d’envoyer sur l’entrée standard d’un programme externe une partie de texte.
:write !wc -w
Ceci affichera le nombre de mots du buffer en cours.

Le mot-clé substitute n’est presque jamais tapé complétement. Généralement on utilise le diminutif s.
Voici un exemple d’utilisation :

:%s/developper/developpez/

Ceci remplacera la première occurence de ‘developper’ par ‘developpez’ sur toutes les lignes (%).
Sur le texte suivant :

Sur le site developper.com, il est possible de parler de langages sur lesquels vous developper.
Alors n’hésitez pas ! developper !

L’application de la commande précédente donnera :

Sur le site developpez.com, il est possible de parler de langages sur lesquels vous developper.
Alors n’hésitez pas ! developpez !

Si vous ne précisez pas de plage, le remplacement se fera sur la ligne courante uniquement.
Pour remplacer toutes les occurrences de la ligne, il suffit d’utiliser le flag ‘g’ en fin de commange.
:%s/developper/developpez/g

Un autre flag plus usité est le flag ‘c’ qui permet de valider (ou non) le remplacement de chaque occurrence.
A chaque occurrence trouvé, il sera demandé à l’utilisateur une réponse dont voici la liste :

Motif source
Dans le motif source, vous pouvez utilisez des expressions régulières telles que ^Developpez qui ne recherchera le mot Developpez qu’en début de ligne.
Si dans votre motif source, vous devez y placer le caractère /, vous devrez l’annihiler par un antislash \.

:s/\//./g

Ceci permet de remplacer tous les / par . sur la ligne courante.

Autre solution, il est d’utiliser un autre caractère de séparation. Par exemple le caractère *.

:s*/*.*g

Motif plage
Détaillons maintenant le motif de plage. Nous connaissons % qui permet de parcourir l’ensemble du fichier.
Il existe une autre écriture dont l’effet est strictement identique : :1,$s/...
1 signifie la première ligne du fichier
$ signifie la dernière ligne du fichier

Nous avons donc simplement spécifier un interval de lignes.
. signifie la ligne courante
Ainsi, :.,$s/... permet d’indiquer un interval compris entre la ligne courante et la fin du fichier.
On peut aussi utiliser :

En tapant n, la prochaine occurrence sera recherchée. Sa version majuscule permettra de chercher dans le sens contraire (ie. vers le début du fichier).
Il est possible d’utiliser les quantifieurs. La commande 4n permettra de rechercher la 4ème occurrence.

Si vous souhaitez rechercher vers le haut, il est possible d’utiliser la commande ? en lieu et place de n.

Une option revient souvient dans la fonction de recherche des éditeurs de texte : Ignorer la casse, c’est-à-dire ne pas faire la distinction minuscule/majuscule.
Voici la commande associée à cette option :

:set ignorecase

Pour repasser en mode « prise en compte de la casse » :

:set noignorecase

A noter qu’il existe un historique des recherches récentes. Pour y avoir accès, il suffit simplement de taper / puis la flèche directionnelle vers le haut.
Les touchées fléchées Haut et Bas permettront de naviguer dans l’historique.

Une astuce qui vous fera gagner bien du temps.
Si vous recherchez un mot déjà visible à l’écran, placez le curseur dessus et tapez la commande *. Ceci permettra de rechercher sa prochaine occurrence directement sans avoir à taper le mot. Pour la recherche dans le sens opposé, la commande # fera l’équivalent. La recherche ne sera effectuée que pour les mots entiers uniquement.
Il y aura donc forcément un caractère d’espacement qui précède et succède le mot.

Pour appliquer une recherche sur un mot entier, il faut utiliser les éléments \< et \> qui, vous l’aurez deviné permettent d’indiquer un espacement en début et fin de mot.

Exemple:
/\<vim\>
Recherche le mot vim dans le fichier. S’il existe le mot ‘vime’ dans le fichier, celui-ci ne sera pas trouvé.

Mise en surbrillance des éléments trouvés

De plus en plus, les éditeurs affichent en couleur les éléments trouvés.
Vim fait de même via la commande :set hlsearch.
Les éléments restent en couleur jusqu’à la prochaine recherche.
Pour supprimer cette surbrillance, :nohlsearch vous rendra bien des services.

Recherche incrémentale

La recherche incrémentale permet de rechercher le texte au fur et à mesure de sa saisie. A chaque caractère saisi, vim positionnera le curseur sur la prochaine correspondante, ou restera à sa place si le texte sous le curseur est identique au texte recherché.
:set incsearch

Par défaut Vim fait boucler la recherche. Arrivé en fin de fichier, la recherche recommence automatiquement en début de fichier.
Pour désactiver ce mode, tapez :set nowrapscan.

Vous tapez ensuite toutes les commandes et saisies de texte que vous souhaitez appliquer.
Terminez enfin votre enregistrement en tapant simplement q en mode commande.

Supposons que vous souhaitiez faire précéder les noms des personnes par « M.  » et passer en majuscule toutes les lettres du nom.
Positionnez le curseur sur le nom de la première personne (Pierre), puis tapez les commandes suivantes :

Maintenant nous pouvons appliquer la commande aux noms suivants.
Pour rappeler la commande du registre a, tapez @a.
Vous devrez ensuite taper @a pour chacun des noms à modifier.

A noter que la commande de répétition « . » ne fonctionne pas sur la commande @a.
En revanche, il est possible de taper @@ pour rappeler le registre utilisé dernièrement.
Vous pourrez faire précéder le rappel de commande par un quantifieur.
Dans notre exemple, nous pouvons donc faire 2@a pour les 2 noms restants.

Petit point d’information qui vous permettra de connaître les fins fonds de Vim.
Le registre dans lequel nous avons enregistré notre commande peut être collé, de la même manière qu’un copier-coller.
Si vous tapez maintenant « ap, vous verrez apparaître la commande suivante : gUawiM.^[j

Vous pouvez tout à fait enregistrer une commande dans un registre en tapant la liste des actions puis en se plaçant en début de commande et en tapant "ay$. Ceci copiera la sélection depuis le curseur jusqu’à la fin de la ligne ($) pour le stocker dans le registre a.

Si vous souhaitez compléter une commande dans un registre, tapez qA par exemple. Ceci permettra dans notre exemple d’ajouter des commandes à notre commande existante.

$ vimdiff test.txt test2.txt

Voici le résultat observé :

Par défaut, la coloration syntaxique est active, ce qui rend la lecture très intuitive.
On constate par exemple que la couleur violette indique une modification d’une partie de la ligne, le rouge indiquant le texte ajouté ( » pour les non initiés » dans notre exemple).
Les lignes avec des tirets ——- signifie que la ligne est supprimée.

Par ailleurs, on constate la dernière ligne commence par « + » au niveau de la marge gauche. Celle-ci indique un repli de 27 lignes strictement identiques sur les 2 fichiers.
Cela facilite grandement la lecture sur des fichiers importants.
Pour ouvrir le repli, vous pouvez appuyer sur zo. Le bloc dissimulé est alors affiché mais il est toujours possible de fermer ce repli via la commande zc n’importe où dans le bloc.
A noter que cette fonction n’existe pas sur plugin Compare de np++ (ie. Notepad++).

Si vous souhaitez lancer une différence de fichier lorsque vous êtes déjà dans vim, ouvrez le premier fichier :
:edit test.txt
Puis utilisez la commande suivante:
:vertical diffsplit test2.txt
La commande :vertical permet de faire une séparation verticale. Par défaut la séparation est horizontale.

Si vous souhaitez appliquer un fichier de patch à un fichier existant et observer les différences, il suffit d’utiliser la commande :vertical diffpatch fichier_patch.diff

Autre commande indispensable, pouvoir naviguer rapidement d’une différence à une autre.
]c Différence suivante
[c Différence précédente

Vous aurez évidemment remarqué que lorsque vous faites défilé le curseur sur l’un des deux fichiers, le défilement s’effectue sur les deux fichiers en même temps.
Il est possible de désactiver cette fonction par l’option :set noscrollbind

Si vous modifiez les fichiers lors d’une comparaison, il est fort possible que la surbrillance ne soit pas à jour.
Pour rafraîchir cette surbrillance, tapez :diffupdate

Pour appliquer la différence sur l’autre fichier, utilisez la commande dp (diff put).
Inversement la commande do applique la modification de l’autre fichier sur le fichier courant.
Ces modifications s’appliquent sur les buffers et non les fichiers sur disque.

Nous utiliserons comme exemple le fichier test1.c qui est un programme en openGL.
Lorsque nous ouvrons le fichier dans vim, il n’y a par défaut aucune coloration syntaxique.
Fort heureusement, la commande :syntax enable nous facilite bien les choses car elle détecte le language utilisé. Pour activer cette option systématiquement, il suffit d’ajouter la commande dans le fichier .vimrc de votre répertoire $HOME.

Nous obtenons ainsi l’aperçu suivant :

On peut observer les fichiers d’entêtes (fichiers .h) OpenGL inclus au début du fichier.

Passons maintenant à la compilation.
Pour cela, tapez la commande :
gcc test1.c  -lGL -lglut -lGLU  -lX11 -lm

Les options -l spécifient les librairies statiques à charger pour la compilation.

Sur certains systèmes Linux, il vous faudra peut-être préciser les 2 options suivantes :
-I/usr/X11R6/include
-L/usr/X11R6/lib

-I indique le répertoire des fichiers d’entête (*.h)
-L indique le répertoire des librairies (lib*.a)

A noter que sous Debian ces 2 options sont inutiles car les librairies X sont dans /usr/lib et les entêtes dans /usr/include.

Ceci nous produit donc le fichier a.out que nous pouvons exécuter :

Vous aurez remarqué de suite que l’exécution est trop rapide. Nous pouvons par conséquent ajouter un sleep qui permettra de temporiser à chaque cycle d’affichage.

En tapant man 3 sleep, vous tombez sur la doc de développement de la glibc.

En regardant la signature de la fonction, on s’aperçoit que le temps est exprimé en secondes entières (unsigned int).
Fort heureusement, il existe une autre fonction usleep qui elle permet de faire en sleep mais en microsecondes.
Il faudra donc comme indiqué dans la manpage ajouter l’entête unistd.h.

Après avoir ajouté l’entête unistd.h en début du fichier test1.c, vous devrez ajouter l’appel à usleep au sein de la fonction myIdle().