Eclats de vers : Ordina 05 : Édition

Vim dispose d'une aide intégrée. Cette aide est notamment disponible au moyen des commandes ex :

Dans la suite, nous adoptons une convention qui consiste à préfixer les commandes ex par un « : », afin de ne pas les confondre avec les commandes du mode normal.

Notons qu'on peut entrer plusieurs commandes sur une même ligne au moyen de la syntaxe :

:/commande-1/ | /commande-2/

Si on souhaite entre plusieurs lignes de commande ex d'affilée, on peut entrer dans le mode ex multiligne au moyen de la commande du mode normal (et donc non préfixée) :

Q

On entre alors les lignes de commandes ex que l'on souhaite sans devoir les préfixer par un « : ». On quitte ensuite le mode ex multiligne via la commande :

:vi

En résumé, nous avons donc :

Le mode ex multiligne est agréable pour entrer quelques commandes, mais si l'on souhaite entre de longs blocs de codes, le mieux est de créer un script, c'est-à-dire un fichier qui accueillera toutes vos commandes. Cerise sur le gâteau, les commandes ex d'un script ne doivent pas être obligatoirement préfixées par un « : ». Un script peut s'exécuter au moyen de la commande :

:source /script/

On peut également l'exécuter au démarrage de vim :

vim -S /script/

Il est possible d'exécuter une commande du mode normal à partir du mode ex, il suffit d'utiliser la syntaxe :

:normal /commande-du-mode-normal/

On rencontre ce genre de construction dans les scripts.

Il est possible d'exécuter le code contenu dans une chaîne de caractères :

:exe /chaine/

Voici quelques raccourcis disponibles dans le mode ex :

« Vim » reprend en partie la philosophie de « Ed » et certaines de ses commandes, en particulier les commandes d'ajout et d'insertion :

Les lignes assez longues pour dépasser la largeur de la fenêtre sont affichées sous la forme de plusieurs lignes virtuelles visibles écran si l'option :

set wrap

est activée. Les mouvement habituel considérent des lignes réelles, mais il existe aussi des commandes permettant de se déplacer dans les lignes virtuelles.

On peut définir :

• 26 signets locaux par fichier, chacun correspondant à une lettre minuscule (a…z)
• 26 signets globaux, chacun correspondant à une lettre majuscule (A…Z)

Les clefs suivantes indiquent le début et la fin du motif :

Tout ce qui intervient en dehors de ces limites constitue le contexte. Exemple :

/contexteAvant/\zs/motif/\ze/contexteArrière/

Le princip est le même avec les rétro-recherches, le « / » est simplement remplacé par un « ? ». Exemples :

On peut associer un motif à une couleur via un groupe. On commence par définir le groupe :

match /Groupe/ //motif//

Ensuite, on définit les couleurs d'avant-plan (ctermfg) et d'arrière-plan (ctermbg) :

highlight Groupe ctermfg=/couleur/ guifg=/couleur/ highlight Groupe ctermbg=/couleur/ guibg=/couleur/

Par défaut, la plage est souvent la ligne courante.

Une plage peut se définir par une adresse de début et une adresse de fin. La forme générale est :

: /adresseDébut/ , /adresseFin/ /commande/

ou :

: /adresseDébut/ ; /adresseFin/ /commande/

La forme en « ; » provoque le déplacement du curseur à chaque nouvelle adresse, tandis que la forme « , » laisse le curseur constant. Nous verrons la raison de cette nuance plus loin.

Voici quelques plages possibles :

Lorsqu'un nombre est entré avant une ligne de commande :

/N/ :

la plage part de la ligne courante et compte N lignes au total :

:.,.+/(N - 1)/

On peut alors entrer la commande :

:.,.+/(N - 1)/ /commande/

Les objets textuels permettent d'appliquer une commande du mode normal sur un mot, une phrase, un contenu entre (), [], {}, etc. La forme générale est :

/commande/i/objet/

La forme adjacente est similaire, mais permet de sélectionner également les caractères à la frontière. La forme générale est :

/commande/a/objet/

Exemples :

Les opérateurs de copie acceptent les mouvements en argument :

Exemples :

Les opérateurs de copie acceptent les signets en argument :

Les opérateurs de copie acceptent les objets textuels en argument. Exemple :

Pour afficher la liste des registres et leurs contenus, on dispose de la commande :

:registers

ou, sous forme abrégée :

:reg

Exemples :

Les registres servent également à enregistrer des macros.

On peut aussi copier une plage de texte dans un registre pour l'exécuter ensuite. La commande suivante exécute la ligne courante :

"/registre/ yy @/registre/

Les objets textuels peuvent être utilisés pour sélectionner un mot, une phrase, un paragraphe, un contenu entre (), [], {}, etc. Exemples :

On peut indiquer à l'opérateur de substitution une plage où opérer :

Le dernier motif de substitution définit l'adresse :

Exemples :

La touche de tabulation a différents effets suivant le contexte :

• Complétion non ambiguë si possible
• Liste de solutions possibles si il y en a plusieurs
• Choix suivant dans la liste si celle-ci est affichée

Pour revenir en arrière dans la liste, il suffit de presser shift et tab simultanément.

L'omni-complétion se sert du langage et du contexte pour déterminer les mots-clés. On l'active avec l'option omnifunc. Exemple :

omnifunc=htmlcomplete#CompleteTags

Ensuite, on utilise l'omni-complétion dans le sous-mode ctrl-X du mode insertion avec :

<ctrl o>

Après avoir inséré le préfixe de la ligne de commande « : » en mode normal, on a accès à l'historique avec les flèches :

Après avoir inséré le préfixe de la ligne de commande « : » et le début d'une ligne de commande, les flèches haut et bas donnent accès à l'historique des commandes correspondant à la partie déjà frappée.

Après avoir inséré un préfixe de recherche (/ ou ?) en mode normal, on a accès à l'historique des motifs de recherche avec les flèches :

Après avoir inséré le préfixe de recherche (/ ou ?) et le début d'un motif de recherche, les flèches donnent accès à l'historique des motifs qui correspondent à la partie déjà frappée.

On peut définir des blocs de textes au sein d'un fichier. Un nombre quelconque de blocs pouvant être imbriqué dans un autre, on donne ainsi une allure arborescente au texte. Chaque bloc peut être plié ou déplié à volonté.

L'affichage de N niveaux de l'arborescence à gauche du texte se fait au moyen de l'option :

:set foldcolumn=/N/

Les opérations de sélection en mode visuel, de copie, de déplacement et autres peuvent se faire aisément sur des blocs pliés. Par exemple, si on se place sur la ligne d'un bloc plié et qu'on fait :

dd

cela coupe tout le bloc. On peut le déplacer en se rendant à la destination voulue et en le collant avec p ou P. On peut aussi passer en mode visuel et copier, couper ou faire une substitution sur plusieurs blocs.

Les arguments sont les fichiers passés en ligne de commande à vim. La liste des arguments peut être modifié dans vim lui-même.

L'éclatement (ou split en anglais) consiste à scinder une fenêtre en plusieurs sous-fenêtres, ce qui permet de visualiser plusieurs fichiers simultanément. On peut aussi utiliser les splits pour disposer de plusieurs vues sur un même fichier.

On peut lancer vim avec des options pour éditer les fichiers en arguments dans des onglets séparés :

Vim conserve en mémoire une copie de chaque fichier ouvert depuis son lancement. Une telle copie s'appelle un tampon (ou buffer en anglais). Les tampons ne sont supprimés que sur demande explicite, ou si on quitte vim.

Pour rechercher dans plusieurs fichiers, on peut utiliser la commande :vimgrep :

:vimgrep //motifRecherché// /fichiers/

Cette commande établit une liste des endroits où les occurrences du motif sont rencontrées et se déplace au premier élément de la liste. On peut se déplacer dans la liste avec les commandes suivantes :

On peut également passer d'une liste à une liste plus ancienne ou plus récente :

La variante :

:vimgrepa //motifRecherché// /fichiers/

ajoute les occurrences à la liste au lieu d'en créer une nouvelle.

Le mode différentiel permet de comparer plusieurs fichiers (de 2 à 4), leurs différences étant mises en évidence.

Il faut parfois placer la commande dans une chaîne de caractère afin de la séparer de la suivante. Exemple :

Pour utiliser les labels, il faut d'avoir remplir un fichier les contenant. En voici le format :

/label1/ /fichier1/ /commande1/
/label2/ /fichier2/ /commande2/
/label3/ /fichier3/ /commande3/
/.../

Les colonnes sont séparées par des tabulations. Les fichiers sont ceux contenant les définitions des labels correspondant, et les commandes sont les commandes vim permettant d'y accéder. Le plus souvent, il s'agit de motifs de recherche :

/label1/ /fichier1/ //motif1//
/label2/ /fichier2/ //motif2//
/label3/ /fichier3/ //motif3//
/.../

Attention toutefois, à part ^ et $, vim considère tous les caractères d'un fichier de labels de façon littérale. Un motif de recherche vim :

/.*bidule.*/

deviendra :

/\.\*bidule\.\*/

dans le fichier de labels. Voir :

:h magic

pour plus de détails.

On ajoute le nom du fichier de labels dans le chemin d'accès :

set tags+=/fichierDesLabels/

ou, si le fichier est dans le répertoire courant des fichiers concernés :

set tags+=.//fichierDesLabels/

Dans le sous-mode ctrl-X du mode insertion, la commande :

<ctrl ]>

propose le choix de complétion suivant d'après les labels.

Si le dictionnaire de votre langue est déjà installé, il suffit d'activer l'option :

set spell

La langue se définit par :

set spelllang=en

pour l'anglais ou :

set spelllang=fr

pour le français. Si vous voulez utiliser les deux langues, il suffit de faire :

set spelllang=en,fr

Si vous recevez un message d'erreur, c'est que le dictionnaire n'est pas installé. Dans ce cas, il vous faut d'abord obtenir un dictionnaire sous forme d'un fichier contenant une liste de mot. On peut en créer un léger avec les erreurs les plus courantes soi-même, mais il en existe de disponibles sur internet, par exemple ici :

http://extensions.libreoffice.org/extension-center/dictionnaires-francais">http://extensions.libreoffice.org/extension-center/dictionnaires-francais

pour les dictionnaires français ou :

http://extensions.libreoffice.org/extension-center/american-british-canadian-spelling-hyphen-thesaurus-dictionaries">http://extensions.libreoffice.org/extension-center/american-british-canadian-spelling-hyphen-thesaurus-dictionaries

pour les dictionnaires anglais. On extrait si nécessaire les fichiers de l'archive contenant les dictionnaires, puis on lance vim et on construit le dictionnaire utilisable par vim avec la commande :

:mkspell /langage/ /dictionnaire(s)/

Par défaut, vim recherche les listes de mots dans :

/dictionnaire(s)/
/dictionnaire(s)/.dic
/dictionnaire(s)/.aff

La commande mkspell crée le fichier :

/langage/./encodage/.spl

que l'on déplace dans le répertoire :

~/.vim/spell

Il ne reste plus qu'à activer l'option de correction orthographique :

set spell
set spelllang=/langue(s)/

On peut définir une liste de fichiers contenant des mots servant à la complétion :

set dictionary=/fichier(s)Dicos(s)/

On peut aussi référencer des fichiers contenant des synonymes :

set thesaurus=/fichier(s)Synonymes(s)/

La complétion basée sur ces fichiers s'utilise comme suit :

Un map associe une chaîne de caractère à une autre chaîne de caractères, qui peut être ordinaire ou contenir une commande. Le map est immédiatement remplacé par la chaîne.

Une abréviation associe un mot à une chaîne de caractères ordinaire ou contenant une commande. L'abréviation est remplacée par la chaîne au premier espace, tabulation, fin de ligne ou :

<ctrl ]>

On peut définir une commande personnalisée par :

:com /Commande/ /Définition/

On peut ensuite utiliser :

:/Commande/

Le nom d'une commande personnalisée doit obligatoirement commencer par une majuscule, pour la différencier des commandes internes de vim.

Une autocommande permet d'associer une action à un événement intervenant sur les fichiers respectant un motif :

:au /événement/ /motif/ /action/

Quelques événements :

Exemples de motif :

On définit une liste par :

let /liste/ = [/element-1/, /element-2/, ...]

On accède à un élément d'une liste par :

let /var/ = /liste/[/indice/]
let /liste/[/indice/] = /valeur/

On définit un dictionnaire par :

let /dictionnaire/ = {'/cle-1/': '/valeur-1/', '/cle-2/': '/valeur-2/' ...}

On accède à un élément d'un dictionnaire par :

let var = dictionnaire[/cle/] let dictionnaire[/cle/] = valeur

ou :

let var = dictionnaire./cle/ let dictionnaire./cle/ = valeur

La commande echo affiche à la sortie standard.

On définit une fonction par :

function /Fonction/()
/.../
endfunction

On l'appelle ensuite par :

:call /Fonction/()

Le nom d'une fonction personnalisée doit obligatoirement commencer par une majuscule, pour la différencier des fonctions internes de vim.

Une commande se définit par :

:com /Commande/ /Expression/

On l'appelle ensuite par :

:/Commande/

et l'expression sera exécutée.

On peut définir une commande associée à une fonction par :

:com /Commande/ /:call Fonction/()

for elt in liste

endfor

while condition

endwhile

Un digraphe est une combinaison de deux caractères qui permet insérer un caractère spécial (symboles, lettres de certaines langues, etc).

On peut filtrer une plage de texte en l'envoyant à l'entrée d'une commande externe et en la remplaçant par la sortie :

Pour accéder à un shell dans un terminal, on entre :

:sh

Une fois le paquet vim-perl installé, vim permet d'exécuter des commandes et scripts perl :

Une fois le paquet vim-python installé, vim permet d'exécuter des commandes et scripts python :

De son coté, python dispose d'un module lui permettant d'exécuter des commandes vim :

import vim vim.command("commandeVim")

Il peut également demander des données :

/chaine/ = vim.eval("input('/Donnez une chaîne/ :')")

Le tuple vim.buffers permet de boucler sur les tampons ouverts :

for tampon in vim.buffers :

print /tampon/.name

Le tampon courant porte un nom particulier :

vim.current.buffer

Chaque tampon peut être vu comme une liste de lignes. On peut donc par exemple ajouter une ligne à la fin :

vim.current.buffer.append("/ligne/")

Le tuple vim.windows contient la liste des fenêtres. La fenêtre courante est désignée par vim.current.window. Un exemple qui modifie la position du curseur :

vim.current.window.cursor(/M/, /N/)

Une fois le paquet vim-ruby installé, vim permet d'exécuter des commandes et scripts python :

On peut ajouter un langage personnel en insérant :

--langdef=/langage/

dans le fichier ~/.ctags.

On associe des extensions à un langage en insérant une ligne de la forme :

--langmap=/langage/:./ext1/./ext2/./ext3/

dans le fichier ~/.ctags. Les fichiers de la forme :

*./ext1/
*./ext2/
*./ext3/

sont alors associés au langage.

On peut définir de nouveaux labels par la syntaxe :

--regex-/langage/=//motif///label///code/,/catégorie//

Le motif contient une expression régulière étendue qui permet de trouver les lignes des labels. Le label contient en général une rétro-référence permettant de donner un nom à chaque label trouvé. Le code est une lettre permettant de regrouper les labels du langage en catégories. La chaîne catégorie correspond au nom de la catégorie.

L'exemple suivant définit le langage css et considère comme labels les lignes de la forme :

/bidule/ {