*autocmd.txt*   Pour Vim version 6.2.


		 MANUEL de RÉFÉRENCE VIM - par Bram Moolenaar


Commandes automatiques					*autocommand*

Ce sujet est abordé dans la section |40.3| du Manuel de l'utilisateur.

1. Introduction			    |autocmd-intro|
2. Définir des autocommandes	    |autocmd-define|
3. Supprimer des autocommandes	    |autocmd-remove|
4. Lister des autocommandes	    |autocmd-list|
5. Événements			    |autocmd-events|
6. Motifs			    |autocmd-patterns|
7. Groupes			    |autocmd-groups|
8. Exécuter des autocommandes	    |autocmd-execute|
9. Utiliser des autocommandes	    |autocmd-use|

{absent de Vi}

==============================================================================
1. Introduction						*autocmd-intro*

Vous pouvez spécifier des commandes qui s'exécuteront automatiquement lors de
la lecture ou de l'écriture d'un fichier, à l'entrée ou à la sortie d'un
tampon ou d'une fenêtre, et lorsque vous quitterez Vim. Par exemple, vous
pouvez créer une autocommande pour activer l'option 'cindent' pour tous les
fichiers correspondant à "*.c". Vous pouvez aussi utiliser les autocommandes
pour mettre en oeuvre des fonctionnalités avancées, comme l'édition de
fichiers compactés (voir |gzip-example|). Le meilleur endroit pour mettre vos
autocommandes est votre fichier vimrc ou exrc.

							*E203* *E204* *E143*
ATTENTION ! L'utilisation des autocommandes se révèle particulièrement
puissante et peut engendrer des effets de bord indésirables. Veillez à ce
qu'elles n'endommagent pas votre texte.
- Il est plus prudent de faire quelques essais avec la copie d'un fichier en
  premier lieu. Par exemple : si vous utilisez des autocommandes pour
  décompacter un fichier quand vous commencez à l'éditer, assurez-vous que les
  autocommandes chargées de le compacter quand vous l'enregistrez fonctionnent
  correctement.
- Vous aurez peut-être à faire face à des erreurs survenant en cours
  d'exécution (p. ex., disque plein). Vim devrait être capable d'annuler les
  changements opérés sur le tampon dans la plupart des cas, mais vous devrez
  nettoyer les autres fichiers à la main (p. ex., compacter un fichier qui a
  été décompacté).
- Si les événements BufRead* vous autorisent à éditer un fichier compacté, il
  devrait en être de même pour les événements FileRead* (cela peut autoriser
  le recouvrement dans certains cas). Essayez d'utiliser les mêmes
  autocommandes pour les événements File* et Buf* quand c'est possible.

La fonctionnalité |+autocmd| n'est incluse que si elle n'a pas été désactivée
lors de la compilation.

==============================================================================
2. Définir des autocommandes				*autocmd-define*

NOTE : La commande ":autocmd" ne peut pas être suivie par une autre commande,
car le '|' est considéré comme une partie de la commande.

							*:au* *:autocmd*
:au[tocmd] [groupe] {even} {motif} [nested] {cmd}
			Ajoute {cmd} à la liste des commandes que Vim
			exécutera automatiquement à l'{even}ement pour un
			fichier correspondant à {motif}. Vim ajoute toujours
			la commande {cmd} après les autocommandes existantes,
			les autocommandes sont ainsi exécutées dans l'ordre où
			elles sont données.
			Voir |autocmd-nested| pour [nested].

NOTE : Les caractères spéciaux (p. ex., "%" ou "<cword>") dans les arguments
de ":autocmd" ne sont pas étendus lorsque l'autocommande est définie. Ils le
seront quand l'{even}ement sera reconnu, et la {cmd} exécutée. La seule
exception à cette règle est "<sfile>", qui est étendu lorsque l'autocommande
est définie. Exemple : >

	:au BufNewFile,BufRead *.html so <sfile>:h/html.vim

Ici, Vim étend <sfile> au nom du fichier contenant cette ligne.

Si votre fichier vimrc est sourcé deux fois, les autocommandes qu'il contient
apparaîtront deux fois. Pour éviter ceci, placez cette commande dans votre
fichier vimrc, avant de définir les autocommandes : >

	:autocmd!	" Supprime TOUTES les autocmd pour le groupe courant.

Si vous ne souhaitez pas supprimer toutes les autocommandes, vous pouvez à la
place utiliser une variable pour tester si Vim a déjà défini les autocommandes
ou pas : >

	:if !exists("autocommandes_incluses")
	:  let autocommandes_incluses = 1
	:  au ...
	:endif

Si l'argument [groupe] n'est pas donné, Vim utilise le groupe courant (comme
défini avec ":augroup") ; sinon, Vim utilise le groupe donné par [groupe].
   NOTE : [groupe] doit avoir été défini auparavant. Vous ne pouvez pas
définir un nouveau groupe avec ":au groupe ..." ; utilisez ":augroup" pour
cela.

Lors de tests d'autocommandes, l'option 'verbose' vous sera probablement
utile : >
	:set verbose=9
Ceci indique à Vim d'afficher les autocommandes au fur et à mesure qu'il les
exécute.

Si vous définissez une autocommande dans un script, elle sera capable
d'appeler des fonctions locales au script et d'utiliser des mappages locaux au
script. Quand l'événement est déclenché et la commande exécutée, elle sera
lancée dans le contexte du script dans lequel elle a été définie. Cela pose
problème lorsque |<SID>| est utilisé dans une commande.

Lors de l'exécution des commandes, les messages émis par une commande
effaceront les messages précédents. Cela diffère de l'exécution manuelle des
commandes. La plupart du temps, l'écran ne sera pas décalé vers le haut, il
n'y aura donc pas d'invite Appuyez-sur-entrée. Néanmoins, cela peut se
produire si une commande renvoie deux messages.

==============================================================================
3. Supprimer des autocommandes				*autocmd-remove*

:au[tocmd]! [groupe] {even} {motif} [nested] {cmd}
			Supprime toutes les autocommandes associées à {even}
			et {motif}, et ajoute la commande {cmd}. Voir
			|autocmd-nested| pour [nested].

:au[tocmd]! [groupe] {even} {motif}
			Supprime toutes les autocommandes associées à {even}
			et {motif}.

:au[tocmd]! [groupe] * {motif}
			Supprime toutes les autocommandes associées à {motif}
			pour tous les événements.

:au[tocmd]! [groupe] {even}
			Supprime TOUTES les autocommandes pour {even}.

:au[tocmd]! [groupe]	Supprime TOUTES les autocommandes.

Si l'argument [groupe] n'est pas donné, Vim utilise le groupe courant (comme
défini avec ":augroup") ; sinon, Vim utilise le groupe donné par [groupe].

==============================================================================
4. Lister des autocommandes		    		*autocmd-list*

:au[tocmd] [groupe] {even} {motif}
			Affiche toutes les autocommandes associées à {even}
			et {motif}.

:au[tocmd] [groupe] * {motif}
			Affiche toutes les autocommandes associées à {motif}
			pour tous les événements.

:au[tocmd] [groupe] {even}
			Affiche toutes les autocommandes pour {even}.

:au[tocmd] [groupe]	Affiche toutes les autocommandes.

Si l'argument [groupe] est donné, Vim ne listera que les autocommandes pour
[groupe] ; sinon, Vim listera les autocommandes pour TOUS les groupes.
   NOTE : Le comportement de cet argument est différent quand vous définissez
ou supprimez des autocommandes.

==============================================================================
5. Événements					*autocmd-events* *E215* *E216*

				    *autocommand-events* *{event}* *{even}*
Vim reconnaît les événements suivants. Vim ignore la casse du nom des
événements (p. ex., vous pouvez écrire « BUFread » ou « bufread » au lieu de
« BufRead »).

							*BufNewFile*
BufNewFile		Quand un fichier qui n'existe pas commence à être
			édité. Peut servir à lire dans un squelette de
			fichier.
						*BufReadPre* *E200* *E201*
BufReadPre		Quand un nouveau fichier commence à être édité, avant
			la lecture du fichier dans le tampon. Non utilisé si
			le fichier n'existe pas.
BufReadPost	ou				*BufRead* *BufReadPost*
BufRead			Quand un nouveau fichier commence à être édité, après
			la lecture du fichier dans le tampon, avant
			l'exécution des lignes de mode. Voir |BufWinEnter| si
			vous avez besoin d'effectuer quelque chose après
			l'exécution des lignes de mode.
			Ceci ne fonctionne PAS pour ":r fichier". Non utilisé
			si le fichier n'existe pas. Également utilisé après le
			recouvrement réussi d'un fichier.
							*BufReadCmd*
BufReadCmd		Avant de commencer l'édition d'un nouveau tampon.
			Devrait lire le tampon dans le fichier. |Cmd-event|
							*BufFilePre*
BufFilePre		Avant de changer le nom du tampon courant avec les
			commandes ":file" ou ":saveas".
							*BufFilePost*
BufFilePost		Après avoir changé le nom du tampon courant avec les
			commandes ":file" ou ":saveas".
							*FileReadPre*
FileReadPre		Avant la lecture d'un fichier avec un ":read".
							*FileReadPost*
FileReadPost		Après la lecture d'un fichier avec une commande
			":read".
			NOTE : Vim fixe les marques '[ et '] aux premières et
			dernières lignes de la lecture. Ceci peut être utilisé
			pour opérer sur les lignes qui viennent juste d'être
			lues.
							*FileReadCmd*
FileReadCmd		Avant la lecture d'un fichier avec une commande
			":read". Devrait effectuer la lecture du fichier.
			|Cmd-event|
							*FilterReadPre* *E135*
FilterReadPre		Avant la lecture d'un fichier depuis une commande de
			filtre. Vim cherche une correspondance du motif de
			fichier avec le nom du tampon courant, et non avec le
			nom du fichier temporaire en sortie de la commande de
			filtre.
							*FilterReadPost*
FilterReadPost		Après la lecture d'un fichier depuis une commande de
			filtre. Vim cherche une correspondance du motif de
			fichier avec le nom du tampon courant, comme avec
			FilterReadPre.
							*FileType*
FileType		Quand l'option 'filetype' a été fixée.
			<afile> peut être utilisé pour donner le nom du
			fichier où cette option a été fixée, et <amatch> pour
			la nouvelle valeur de 'filetype'. Voir |filetypes|.
							*Syntax*
Syntax			Quand l'option 'syntax' a été fixée.
			<afile> peut être utilisé pour donner le nom du
			fichier où cette option a été fixée, et <amatch> pour
			la nouvelle valeur de 'syntax'. Voir |:syn-on|.
							*StdinReadPre*
StdinReadPre		Avant la lecture de stdin dans le tampon. Utilisé
			uniquement si l'argument '-' a été donné à Vim au
			démarrage |--|.
							*StdinReadPost*
StdinReadPost		Après la lecture de stdin dans le tampon, avant
			l'exécution des lignes de mode. Utilisé uniquement si
			l'argument '-' a été donné à Vim au démarrage |--|.
BufWritePre	ou				*BufWrite* *BufWritePre*
BufWrite		Avant l'écriture du tampon entier dans un fichier.
							*BufWritePost*
BufWritePost		Après l'écriture du tampon entier dans un fichier
			(devrait annuler les commandes pour BufWritePre).
							*BufWriteCmd*
BufWriteCmd		Avant l'écriture du tampon entier dans un fichier.
			Devrait enregistrer le fichier et désactiver
			'modified' si cela a réussi. Ne devrait pas modifier le
			tampon. |Cmd-event|
							*FileWritePre*
FileWritePre		Avant l'écriture dans un fichier, si ce n'est pas le
			tampon entier qui est écrit.
							*FileWritePost*
FileWritePost		Après l'écriture dans un fichier, si ce n'est pas le
			tampon entier qui est écrit.
							*FileWriteCmd*
FileWriteCmd		Avant l'écriture dans un fichier, si ce n'est pas le
			tampon entier qui est écrit. Devrait effectuer
			l'écriture dans le fichier. Ne devrait pas modifier le
			tampon. |Cmd-event|
							*FileAppendPre*
FileAppendPre		Avant l'ajout dans un fichier.
							*FileAppendPost*
FileAppendPost		Après l'ajout dans un fichier.
							*FileAppendCmd*
FileAppendCmd		Avant l'ajout dans un fichier. Devrait effectuer
			l'ajout dans le fichier. |Cmd-event|
							*FilterWritePre*
FilterWritePre		Avant l'écriture dans un fichier par une commande de
			filtre, ou une comparaison (mode diff).
			Vim cherche une correspondance du motif de fichier
			avec le nom du tampon courant, et non avec le nom du
			fichier temporaire en sortie de la commande de filtre.
	    						*FilterWritePost*
FilterWritePost		Après l'écriture dans un fichier par une commande de
			filtre, ou une comparaison (mode diff).
			Vim cherche une correspondance du motif de fichier
			avec le nom du tampon courant, comme avec
			FilterWritePre.
							*FileChangedShell*
FileChangedShell	Quand Vim s'aperçoit que la date de modification d'un
			fichier a changé depuis que son édition est commencée.
			|timestamp|
			Déclenché le plus souvent après l'exécution d'une
			commande shell, mais également avec une commande
			|:checktime| ou lorsque Vim regagne le focus de la
			souris.
			Cette autocommande est déclenchée pour chaque fichier
			modifié. Elle n'est pas utilisée quand 'autoread' est
			activé et que le tampon n'a pas été modifié. Si une
			autocommande FileChangedShell est présente, le message
			d'avertissement et l'invite correspondants ne sont pas
			donnés. C'est utile pour recharger des fichiers
			concernés qui sont affectés par une seule commande.
			NOTE : Lorsque cette autocommande est exécutée, le
			tampon courant "%" peut être différent du tampon qui a
			été modifié "<afile>".
			NOTE : *E246* : Les commandes ne doivent pas modifier
			le tampon courant, basculer vers un autre tampon ou
			supprimer un tampon.
			NOTE : Cet événement ne peut pas être imbriqué, pour
			éviter une boucle sans fin. Cela signifie que lors de
			l'exécution de commandes pour l'événement
			FileChangedShell, aucun autre événement
			FileChangedShell ne sera déclenché.
							*FileChangedRO*
FileChangedRO		Avant d'effectuer un premier changement dans un
			fichier en lecture seule. Peut être utilisé pour
			automatiser un "checkout" sur un système de gestion de
			versions. Non déclenché si le changement est provoqué
			par une autocommande.
			ATTENTION ! Cet événement est déclenché lorsque le
			changement est effectué, juste avant qu'il ne soit
			appliqué au texte. Si l'autocommande déplace le
			curseur, l'effet du changement est indéfini.
							*FocusGained*
FocusGained		Quand Vim obtient le focus de la souris. Seule la
			version IHM graphique et certaines versions console
			peuvent détecter cet événement.
							*FocusLost*
FocusLost		Quand Vim perd le focus de la souris. Seule la version
			IHM graphique et certaines versions console peuvent
			détecter cet événement.
							*FuncUndefined*
FuncUndefined		Quand une fonction utilisateur est utilisée mais n'est
			pas définie. Utile pour définir une fonction
			uniquement si elle est utilisée. <amatch> et <afile>
			sont tous deux fixés au nom de la fonction.
							*CursorHold*
CursorHold		Quand l'utilisateur n'a pressé aucune touche au bout
			du temps déterminé par 'updatetime'. Non redéclenché
			jusqu'à ce que l'utilisateur presse à nouveau une
			touche (c.-à-d. que cet événement ne se déclenche pas
			toutes les 'updatetime' ms si vous quittez Vim pour
			vous faire du café :). Voir |CursorHold-example| pour
			obtenir un aperçu des marqueurs.
			Cet événement est déclenché uniquement en mode Normal.
			NOTE : Les commandes interactives ne peuvent pas être
			utilisées pour cet événement. Il n'aura pas d'invite
			Appuyez-sur-entrée, l'écran sera mis à jour
			directement (si nécessaire).
			NOTE : Dans une version ultérieure, il y aura
			probablement une autre option pour fixer le temps.
			Conseil : Pour forcer la mise à jour des lignes
			d'état, utilisez : >
				:let &ro = &ro
<			{uniquement sur Amiga, Unix, Win32, MS-DOS et toutes
			les versions IHM graphiques}
							*BufEnter*
BufEnter		Après l'entrée dans un tampon. Utile pour fixer des
			options pour un type de fichier. Également exécuté
			quand un tampon commence à être édité, après les
			autocommande BufReadPost.
							*BufLeave*
BufLeave		Avant de quitter le tampon pour un autre. Également
			quand la fenêtre courante est quittée ou fermée et que
			la nouvelle fenêtre courante ne contient pas le même
			tampon. Non utilisé pour ":qa" ou ":q" quand Vim est
			quitté.
							*BufWinEnter*
BufWinEnter		Après l'affichage d'un tampon dans une fenêtre. Cela
			peut être lors du chargement du tampon (après
			traitement des lignes de mode), lorsqu'un tampon caché
			est affiché dans une fenêtre (il n'est alors plus
			caché) ou lorsqu'un tampon déjà visible est à nouveau
			affiché dans une autre fenêtre.
							*BufWinLeave*
BufWinLeave		Avant qu'un tampon ne soit supprimé d'une fenêtre,
			mais pas s'il est encore visible dans une autre
			fenêtre. Également déclenché quand Vim est quitté.
			Déclenché avant BufUnload ou BufHidden.
			NOTE : Lorsque cette autocommande est exécutée, le
			tampon courant "%" peut être différent du tampon qui a
			été déchargé "<afile>".
							*BufUnload*
BufUnload		Avant le déchargement d'un tampon, c'est-à-dire quand
			le texte dans le tampon va être libéré. Cela peut être
			après un BufWritePost et avant un BufDelete. Également
			utilisé pour tous les tampons qui sont chargés quand
			Vim va être quitté.
			NOTE : Lorsque cette autocommande est exécutée, le
			tampon courant "%" peut être différent du tampon qui a
			été déchargé "<afile>".
							*BufHidden*
BufHidden		Juste après qu'un tampon a été caché, c'est-à-dire
			quand il n'y a plus de fenêtres qui affichent le
			tampon, mais qu'il n'est pas déchargé ou supprimé. Non
			utilisé pour ":qa" ou ":q" quand Vim est quitté.
			NOTE : Lorsque cette autocommande est exécutée, le
			tampon courant "%" peut être différent du tampon qui a
			été déchargé "<afile>".
							*BufNew*
BufNew			Juste après la création d'un nouveau tampon. Également
			utilisé juste après qu'un tampon a été renommé. Quand
			le tampon est ajouté à la liste des tampons, BufAdd ne
			sera pas déclenché.
			NOTE : Lorsque cette autocommande est exécutée, le
			tampon courant "%" peut être différent du tampon qui a
			été créé "<afile>".
BufCreate	ou					*BufCreate* *BufAdd*
BufAdd			Juste après la création d'un nouveau tampon qui sera
			ajouté à la liste des tampons, ou après l'ajout d'un
			tampon à cette liste.
			Également utilisé juste après qu'un tampon de la
			liste des tampons a été renommé.
			L'événement BufCreate assure la compatibilité avec les
			versions antérieures.
			NOTE : Lorsque cette autocommande est exécutée, le
			tampon courant "%" peut être différent du tampon qui a
			été créé "<afile>".
							*BufDelete*
BufDelete		Avant la suppression d'un tampon de la liste des
			tampons. BufUnload peut être appelé en premier (si le
			tampon était chargé).
			Également utilisé juste avant qu'un tampon de la liste
			des tampons soit renommé.
			NOTE : Lorsque cette autocommande est exécutée, le
			tampon courant "%" peut être différent du tampon qui a
			été supprimé "<afile>".
							*BufWipeout*
BufWipeout		Avant la suppression complète (la « liquidation »)
			d'un tampon. Les événements BufUnload et BufDelete
			peuvent être appelés en premier (si le tampon était
			chargé et présent dans la liste des tampons).
			Également utilisé juste avant qu'un tampon soit
			renommé (même quand il n'est pas présent dans la liste
			des tampons).
			NOTE : Lorsque cette autocommande est exécutée, le
			tampon courant "%" peut être différent du tampon qui a
			été supprimé "<afile>".
							*WinEnter*
WinEnter		Après l'entrée dans une autre fenêtre. Non déclenché
			pour la première fenêtre, quand Vim vient d'être
			lancé. Utile pour fixer la hauteur de la fenêtre.
			Si la fenêtre est pour un autre tampon, Vim exécute
			les autocommandes BufEnter après les autocommandes
			WinEnter.
			NOTE : Quand ":split nomfich" est utilisé, l'événement
			WinEnter est déclenché après le partage mais avant le
			chargement du fichier "nomfich".
							*WinLeave*
WinLeave		Avant de quitter une fenêtre. Si la fenêtre où Vim
			doit ensuite entrer contient un tampon différent, Vim
			exécutera les autocommandes BufLeave avant les
			autocommandes WinLeave (mais pas pour ":new"). Non
			utilisé pour ":qa" ou ":q" quand Vim est quitté.
							*CmdwinEnter*
CmdwinEnter		Après l'entrée dans la fenêtre command-line. Utile
			pour fixer des options spécifiques à ce type spécial
			de fenêtre. Cet événement est déclenché À LA PLACE de
			BufEnter et WinEnter.
			<afile> est fixé à un caractère simple, indiquant le
			type de la fenêtre command-line. |cmdwin-char|
							*CmdwinLeave*
CmdwinLeave		Avant de quitter la fenêtre command-line. Utile pour
			effacer des paramètres globaux fixés avec CmdwinEnter.
			Cet événement est déclenché À LA PLACE de BufLeave et
			WinLeave.
			<afile> est fixé à un caractère simple, indiquant le
			type de la fenêtre command-line. |cmdwin-char|
							*GUIEnter*
GUIEnter		Après que l'IHM graphique a été lancée avec succès, et
			après l'ouverture de la fenêtre. Déclenché avant
			VimEnter quand gvim est utilisé. Peut être utilisé
			pour placer la fenêtre dans un fichier gvimrc : >
				:autocmd GUIEnter * winpos 100 50
<							*VimEnter*
VimEnter		Après toutes les initialisations du démarrage, y
			compris le chargement des fichiers vimrc, l'exécution
			des arguments "-c cmd", la création de toutes les
			fenêtres et le chargement des tampons dedans.
							*VimLeavePre*
VimLeavePre		Avant de quitter Vim, juste avant l'écriture du
			fichier viminfo. N'est exécuté qu'une seule fois, s'il
			existe une correspondance avec le nom de ce qui est le
			tampon courant quand Vim est quitté.
			Essentiellement utile avec un motif "*" : >
				:autocmd VimLeavePre * call AvantDeSortir()
<			Pour détecter une sortie anormale, utilisez |v:dying|.
							*VimLeave*
VimLeave		Avant de quitter Vim, juste après l'écriture du
			fichier viminfo. N'est exécuté qu'une fois, comme
			VimLeavePre.
			Pour détecter une sortie anormale, utilisez |v:dying|.
							*EncodingChanged*
EncodingChanged		Déclenché quand l'option 'encoding' est modifiée.
			Utile pour changer de police, par exemple.
							*FileEncoding*
FileEncoding		Obsolète. Est toujours supporté et est équivalent à
			|EncodingChanged|.
							*RemoteReply*
RemoteReply		Lors de la réception d'une réponse de la part d'un Vim
			qui fonctionne en tant que serveur. |server2client()|
			<amatch> est fixé à l'{IDserveur} depuis lequel la
			réponse a été envoyée, et <afile> à la chaîne de la
			réponse.
			NOTE : Même si une autocommande est définie, la
			réponse devrait être lue avec |remote_read()| pour
			être consommée.
							*TermChanged*
TermChanged		Après le changement de la valeur de 'term'. Utile pour
			recharger le fichier de syntaxe pour mettre à jour les
			couleurs, polices et autres paramètres dépendant du
			terminal. Exécuté pour tous les tampons chargés.
							*TermResponse*
TermResponse		Après que la réponse à |t_RV| a été reçue du terminal.
			La valeur de |v:termresponse| peut être utilisée pour
			effectuer certaines actions dépendamment de la version
			du terminal.
	    						*UserGettingBored*
UserGettingBored	Quand l'utilisateur frappe CTRL-C. Non, c'est pour
			rire ! :-)
							*User*
User			Jamais exécuté automatiquement. À utiliser pour les
			autocommandes qui sont uniquement exécutées avec
			":doautocmd".


Il existe trois couples d'événements possibles pour la LECTURE des fichiers.
Vim n'en utilise qu'un seul à la fois :
BufNewFile			au commencement de l'édition d'un fichier non
				   existant
BufReadPre	BufReadPost	au commencement de l'édition d'un fichier
				   existant
FilterReadPre	FilterReadPost	à la lecture du fichier temporaire en sortie
				   du filtre
FileReadPre	FileReadPost	pour toute autre lecture

NOTE : Les autocommandes pour les événements *ReadPre et tous les événements
Filter ne sont pas autorisés à modifier le tampon courant (vous obtiendrez un
message d'erreur si cela se produit). Cela permet d'éviter que le fichier ne
soit lu dans le mauvais tampon.

NOTE : Le drapeau de modification est désactivé APRÈS l'exécution des
autocommandes BufReadPost et BufNewFile. Mais pas si l'option 'modified' a été
activée par les autocommandes.

Vous pouvez utiliser l'option 'eventignore' pour ignorer un certain nombre
d'événements, ou tous les événements.

==============================================================================
6. Motifs						*autocmd-patterns*

Le motif de fichier {motif} est traité pour établir une correspondance avec le
nom de fichier d'une de ces deux façons :
1. Quand il n'y a pas de '/' dans le motif, Vim ne recherche de
   correspondance qu'avec la « queue » du nom de fichier (sans le chemin
   d'accès initial).
2. Quand il y a un '/' dans le motif, Vim recherche une correspondance avec le
   nom de fichier court (tel que vous l'avez saisi) et le nom de fichier
   entier (après l'avoir étendu en un chemin complet et avoir résolu les liens
   symboliques).

Exemples : >
	:autocmd BufRead *.txt		set et
<		Active l'option 'et' pour tous les fichiers texte. >
	:autocmd BufRead /vim/src/*.c	set cindent
<		Active l'option 'cindent' pour les fichiers C dans le
		répertoire "/vim/src". >
	:autocmd BufRead /tmp/*.c	set ts=5
<		Si "/tmp/test.c" est lié à "/home/babar/vim/src/test.c" et que
		vous commencez à éditer le fichier "/tmp/test.c", cette
		autocommande correspondra.

NOTE : Pour correspondre à une partie d'un chemin, mais pas depuis le
répertoire racine, utilisez un '*' comme premier caractère. Exemple : >
	:autocmd BufRead */doc/*.txt	set tw=78
Cette autocommande sera par exemple exécutée pour "/tmp/doc/xx.txt" et
"/usr/home/bibi/doc/yy.txt". Le nombre de répertoires n'importe pas ici.


Le nom de fichier auquel le motif doit correspondre est celui obtenu après
l'expansion des jokers. Ainsi, si vous entrez cette commande >
	:e $ROOTDIR/main.$EXT
l'argument est d'abord étendu en
	/usr/root/main.py ~
avant de pouvoir correspondre avec le motif de l'autocommande. Faites
attention à cela quand vous utilisez des événements comme FileReadCmd, la
valeur de <amatch> peut ne pas correspondre à ce que vous espérez.


Les variables d'environnement peuvent être utilisées dans un motif : >
	:autocmd BufRead $VIMRUNTIME/doc/*.txt  set expandtab
Et '~' peut être utilisé pour le répertoire personnel (si $HOME est défini) : >
	:autocmd BufWritePost ~/.vimrc	so ~/.vimrc
	:autocmd BufRead ~archive/*     set readonly
La variable d'environnement est étendue quand l'autocommande est définie, pas
quand elle est exécutée. À l'inverse de la commande !

							*file-pattern*
Le motif est interprété selon les règles généralement utilisées pour les noms
de fichiers :
	*	correspond à n'importe quelle séquence de caractères
	?	correspond à n'importe quel caractère simple
	\?	correspond à un '?'
	.	correspond à un '.'
	~	correspond à un '~'
	,	sépare des motifs
	\,	correspond à un ','
	{ }	comme \( \) dans un motif |pattern|
	,	entre { } : comme \| dans un motif |pattern|
	\	signification spéciale comme dans un motif |pattern|
	[ch]	correspond à 'c' ou 'h'

NOTE : Le caractère '/' est utilisé comme séparateur de chemin pour tous les
systèmes (même MS-DOS et OS/2). Cela a été décidé car la contre-oblique est
difficile à utiliser dans un motif, et pour rendre les autocommandes portables
entre les différents systèmes.


La correspondance avec le motif est effectuée quand un événement est
déclenché. La modification du nom du tampon dans une des autocommandes -- ou
même la suppression du tampon -- n'infléchira pas l'exécution des
autocommandes. Exemple : >

	:au BufEnter *.blabla  bdel
	:au BufEnter *.blabla  set modified

Ceci supprimera le tampon courant puis activera 'modified' dans celui qui est
devenu le tampon courant. Vim ne tient pas compte de ce que "*.blabla" ne
corresponde plus au nom de ce tampon. Il correspondait au moment où
l'événement avait été défini.

==============================================================================
7. Groupes						*autocmd-groups*

Des autocommandes peuvent être réunies au sein d'un groupe. C'est pratique
pour exécuter ou supprimer un groupe d'autocommandes. Par exemple, toutes les
autocommandes relatives à la coloration syntaxique sont réunies dans le groupe
"highlight", ce qui permet d'exécuter ":doautoall highlight BufRead" quand
l'IHM graphique est lancée.

Si aucun groupe particulier n'est sélectionné, Vim utilise le groupe par
défaut. Le groupe par défaut n'a pas de nom. Vous ne pouvez pas exécuter les
autocommandes du groupe par défaut séparément ; vous ne pouvez le faire qu'en
exécutant les autocommandes pour tous les groupes.

Normalement, quand les autocommandes sont exécutées automatiquement, Vim les
utilise pour tous les groupes. La spécification d'un groupe n'est réalisable
qu'avec ":doautocmd" ou ":doautoall", ou lors de la définition ou de la
suppression d'autocommandes.

Un nom de groupe peut contenir n'importe quel caractère sauf l'espace blanc.
Le nom de groupe "end" est réservé (y compris en majuscules). Le nom de groupe
est sensible à la casse.

							*:aug* *:augroup*
:aug[roup] {nom}	Définit le nom du groupe d'autocommandes pour les
			commandes ":autocmd" suivantes. Le nom "end" ou
			"END" sélectionne le groupe par défaut.

						*:augroup-delete* *E367*
:aug[roup]! {nom}	Supprime le groupe d'autocommandes {nom}. N'utilisez
			pas ceci s'il reste une autocommande qui utilise ce
			groupe ! Cela n'est pas vérifié.

Pour entrer des autocommandes pour un groupe en particulier, utilisez cette
méthode :
1. Sélectionnez le groupe avec ":augroup {nom}".
2. Supprimez toutes les anciennes autocommandes avec ":au!".
3. Définissez les autocommandes.
4. Revenez au groupe par défaut avec "augroup END".

Exemple : >

	:augroup decompactage
	:  au!
	:  au BufEnter *.gz	%!gunzip
	:augroup END

Cela évite d'avoir des autocommandes définies deux fois (p. ex., après un
nouveau sourcement du fichier vimrc).

==============================================================================
8. Exécuter des autocommandes				*autocmd-execute*

Vim peut aussi exécuter des autocommandes non automatiquement. C'est utile si
vous avez modifié les autocommandes, ou quand Vim a exécuté de mauvaises
autocommandes (p. ex., quand la correspondance avec le nom de fichier était
mauvaise).

NOTE : L'option 'eventignore' s'applique ici aussi. Les commandes reliées aux
événements listés dans cette option ne pourront pas s'exécuter.

						*:do* *:doautocmd* *E217*
:do[autocmd] [groupe] {even} [nomfich]
			Applique les autocommandes correspondant à [nomfich]
			(défaut : nom du fichier courant) pour {even} au
			tampon courant.
			Vous pouvez utiliser ceci quand le nom de fichier
			courant ne correspond pas au bon motif, après avoir
			changé des paramètres, ou pour exécuter des
			autocommandes pour un certain événement.
			Il est également possible d'utiliser ceci à
			l'intérieur d'une autocommande, vous pouvez alors
			baser les autocommandes d'une extension sur une autre
			extension. Exemple : >
				:au Bufenter *.cpp so ~/.vimrc_cpp
				:au Bufenter *.cpp doau BufEnter x.c
<			Attention aux boucles sans fin !  Voir
			|autocmd-nested|.

			Quand l'argument [groupe] n'est pas donné, Vim exécute
			les autocommandes pour tous les groupes. Quand il est
			donné, Vim exécute uniquement les autocommandes
			correspondant à [groupe]. NOTE : Si vous utilisez un
			nom de groupe non défini, Vim émet un message
			d'erreur.

						*:doautoa* *:doautoall*
:doautoa[ll] [groupe] {even} [nomfich]
			Comme ":doautocmd", mais applique les autocommandes à
			chaque tampon chargé. Attention ! N'utilisez pas ceci
			pour les autocommandes qui suppriment un tampon,
			changent pour un autre tampon ou modifient le contenu
			d'un tampon ; le résultat serait imprévisible. Cette
			commande est destinée aux autocommandes qui fixent des
			options, modifient la coloration, et des choses comme
			ça.

==============================================================================
9. Utiliser des autocommandes				*autocmd-use*

Il existe quatre ensembles d'événements possibles pour l'ÉCRITURE dans des
fichiers. Vim n'en utilise qu'un seul à la fois :

    BufWriteCmd    BufWritePre     BufWritePost	     lors de l'écriture du
							tampon entier
		   FilterWritePre  FilterWritePost   lors de l'écriture dans un
							fichier temp de filtre
    FileAppendCmd  FileAppendPre   FileAppendPost    lors de l'ajout dans un
							fichier
    FileWriteCmd   FileWritePre    FileWritePost     pour tout autre écriture
							dans un fichier

Lorsqu'il existe une autocommande "*Cmd", Vim suppose qu'elle effectuera
l'enregistrement. Il n'y aura pas d'enregistrement ultérieur, et les autres
événements ne seront pas déclenchés. |Cmd-event|

NOTE : Les commandes *WritePost devraient annuler les changements apportés au
tampon par les commandes *WritePre ; sans cela, l'enregistrement du fichier
aura pour effet de bord de modifier le tampon.

Avant d'exécuter les autocommandes, le tampon duquel les lignes doivent être
écrites devient temporairement le tampon courant. À moins que les
autocommandes ne changent le tampon courant ou suppriment le tampon courant
précédent, ce dernier redeviendra à nouveau le tampon courant.

Les autocommandes *WritePre et *AppendPre ne doivent pas supprimer le tampon
duquel les lignes doivent être écrites.

Les marques '[ et '] ont une position spéciale :
- Avant l'événement *ReadPre, la marque '[ est fixée à la ligne juste
  au-dessus d'où les nouvelles lignes seront insérées.
- Avant l'événement *ReadPost, la marque '[ est fixée à la première ligne qui
  vient d'être lue, la marque '] à la dernière ligne.
- Avant l'exécution des autocommandes *WritePre et *AppendPre, la marque '[
  est fixée à la première ligne qui devra être écrite, la marque '] à la
  dernière ligne.
Attention ! '[ et '] changent quand des commandes qui modifient le tampon sont
utilisées.

Dans les commandes qui attendent un nom de fichier, vous pouvez utiliser
"<afile>" pour donner le nom du fichier qui doit être lu |:<afile>| (vous
pouvez aussi utiliser "%" pour le nom du fichier courant).
   "<abuf>" peut être utilisé pour donner le numéro du tampon courant
effectif. Cela marche aussi pour les tampons qui n'ont pas de nom ; mais pas
pour les fichiers sans tampon (p. ex., avec ":r fichier").

							*gzip-example*
Exemple (pour lire et enregistrer des fichiers compactés) : >

	:augroup gzip
	:  autocmd!
	:  autocmd BufReadPre,FileReadPre	*.gz set bin
	:  autocmd BufReadPost,FileReadPost	*.gz '[,']!gunzip
	:  autocmd BufReadPost,FileReadPost	*.gz set nobin
	:  autocmd BufReadPost,FileReadPost	*.gz execute ":doautocmd BufReadPost " . expand("%:r")
	:  autocmd BufWritePost,FileWritePost	*.gz !mv <afile> <afile>:r
	:  autocmd BufWritePost,FileWritePost	*.gz !gzip <afile>:r
	
	:  autocmd FileAppendPre		*.gz !gunzip <afile>
	:  autocmd FileAppendPre		*.gz !mv <afile>:r <afile>
	:  autocmd FileAppendPost		*.gz !mv <afile> <afile>:r
	:  autocmd FileAppendPost		*.gz !gzip <afile>:r
	:augroup END

Le groupe "gzip" est utilisé pour permettre de supprimer toutes les
autocommandes existantes avec ":autocmd!", pour le cas où le fichier serait
sourcé deux fois.

("<afile>:r" est le nom du fichier sans son extension, voir |:_%:|.)

Les commandes exécutées pour les événements BufNewFile, BufRead/BufReadPost,
BufWritePost, FileAppendPost et VimLeave ne modifient pas le drapeau de
modification du fichier. Quand vous décompactez le tampon avec les
autocommandes BufReadPost, vous pouvez toujours quitter avec ":q". Quand vous
utilisez ":undo" dans BufWritePost pour annuler les changements effectués par
les commandes BufWritePre, vous pouvez toujours faire ":q" ("ZZ" fonctionnera
aussi). Si vous souhaitez que le tampon soit marqué comme modifié, activez
l'option 'modified'.

Pour exécuter des commandes du mode Normal à partir d'une autocommande,
utilisez la commande ":normal". Mais soyez prudent ! si la commande du mode
Normal n'est pas terminée, l'utilisateur devra taper des caractères
supplémentaires (p. ex., après ":normal m", vous devrez entrer le nom d'une
marque).

Si vous ne souhaitez pas que le tampon soit considéré comme modifié après
l'avoir changé, désactivez l'option 'modified'. Cela permet de quitter le
tampon avec ":q" au lieu de ":q!".

						    *autocmd-nested* *E218*
Par défaut, les autocommandes ne s'imbriquent pas. Si vous utilisez ":e" ou
":w" dans une autocommande, Vim n'exécutera pas les autocommandes BufRead et
BufWrite pour ces commandes. Pour autoriser l'imbrication, utilisez le drapeau
"nested" avec les commandes pour lesquelles vous la souhaitez. Par exemple : >

	:autocmd FileChangedShell *.c nested e!

L'imbrication est limitée à 10 niveaux, pour sortir des boucles récursives.

Il est possible d'utiliser la commande ":au" dans une autocommande. Cela peut
donner une commande qui s'auto-modifie ! Cela peut être utile pour une
autocommande qui ne devrait s'exécuter qu'une seule fois.

Il n'existe actuellement aucun moyen pour désactiver les autocommandes. Si
vous souhaitez enregistrer un fichier sans exécuter les autocommandes
associées à son type, enregistrez-le sous un nom différent puis renommez-le
par l'intermédiaire d'une commande shell. Dans certains cas, vous pouvez
utiliser l'option 'eventignore'.

NOTE : Lors de la lecture d'un fichier (avec ":read fichier" ou une commande
de filtre), si la dernière ligne du fichier ne contient pas de <EOL>, Vim se
le rappellera. Lors du prochain enregistrement (avec ":write fichier" ou une
commande de filtre), si la même ligne est à nouveau écrite comme dernière
ligne dans un fichier ET que 'binary' est activé, Vim n'ajoutera pas de <EOL>.
Cela permet à une commande de filtre exécutée sur les lignes juste lues
d'écrire le fichier tel qu'il vient d'être lu, et à une commande d'écriture
sur les lignes juste filtrées d'écrire le fichier tel qu'il vient d'être lu
depuis le filtre. Par exemple, pour enregistrer un fichier compacté, on peut
aussi employer cette méthode : >

	:autocmd FileWritePre	*.gz	set bin|'[,']!gzip
	:autocmd FileWritePost	*.gz	undo|set nobin
<
						    *autocommand-pattern*
Vous pouvez spécifier des motifs multiples, séparés par des virgules. Voici
quelques exemples : >

  :autocmd BufRead   *	      set tw=79 nocin ic infercase fo=2croq
  :autocmd BufRead   .lettre  set tw=72 fo=2tcrq
  :autocmd BufEnter  .lettre  set dict=/usr/lib/dict/words
  :autocmd BufLeave  .lettre  set dict=
  :autocmd BufRead,BufNewFile *.c,*.h	set tw=0 cin noic
  :autocmd BufEnter  *.c,*.h  abbr FOR for (i = 0; i < 3; ++i)<CR>{<CR>}<Esc>O
  :autocmd BufLeave  *.c,*.h  unabbr FOR

Pour les fichiers de type Makefile ("makefile", "Makefile", "imakefile",
"makefile.unix", etc.) : >

	:autocmd BufEnter  ?akefile*	set include=^s\=include
	:autocmd BufLeave  ?akefile*	set include&

Pour toujours commencer l'édition des fichiers C à la première fonction : >

	:autocmd BufRead   *.c,*.h	1;/^{

Sans le "1;" ci-dessus, la recherche débuterait de l'endroit où le fichier a
été ouvert, plutôt que du début du fichier.

						    *skeleton* *template*
Pour lire un squelette (modèle) de fichier lors de l'ouverture d'un nouveau
fichier : >

	:autocmd BufNewFile  *.c	0r ~/vim/squelette.c
	:autocmd BufNewFile  *.h	0r ~/vim/squelette.h
	:autocmd BufNewFile  *.java	0r ~/vim/squelette.java

Pour insérer la date et l'heure courante dans un fichier ".html" lors de son
enregistrement : >

	:autocmd BufWritePre,FileWritePre *.html   ks|call DerModif()|'s
	:fun DerModif()
	:  if line("$") > 20
	:    let l = 20
	:  else
	:    let l = line("$")
	:  endif
	:  exe "1," . l . "g/Dernière modification : /s/Dernière modification : .*/Dernière modification : " .
	:  \ strftime("%d %b %Y %X %Z")
	:endfun

Vous devrez avoir une ligne "Dernière modification : <date heure>" dans les
20 première lignes du fichier pour que cela fonctionne. Vim remplace "<date
heure>" (et tout ce qui suit dans la même ligne) par la date et l'heure
courante.
   Dissection :
	ks		 marque la position courante avec 's'
	call DerModif()  appelle la fonction DerModif() pour effectuer le
			    travail
	's		 revient à l'ancienne position
La fonction DerModif() teste si le fichier fait moins de 20 lignes, puis
utilise la commande ":g" pour trouver les lignes qui contiennent "Dernière
modification : ". Pour ces lignes, la commande ":s" est exécutée pour
remplacer les date et heure existantes par les courantes. La commande
":execute" est utilisée pour pouvoir employer une expression avec les
commandes ":g" et ":s". La date et l'heure sont obtenues avec la fonction
strftime(). Vous pouvez en modifier les arguments pour obtenir une autre
chaîne d'horodatage.

Quand vous entrez ":autocmd" sur la ligne de commande, le complètement des
noms d'événements et de commandes peut être effectué (avec <Tab>, CTRL-D,
etc.) là où c'est approprié.

Vim exécute toutes les autocommandes correspondantes dans l'ordre où vous les
avez spécifiées. Il est recommandé de placer en premier les autocommandes
devant être exécutées pour tous les fichiers (celles qui utilisent le motif
"*" comme motif de fichier). Cela vous permet de définir les paramètres que
vous souhaitez par défaut pour tous vos fichiers ; s'il y a ensuite d'autres
autocommandes correspondantes, elles recouvriront ces valeurs. Ainsi, lorsque
vous ouvrez un fichier, il utilise au moins les paramètres par défaut, même si
le fichier précédent avait fixé ces paramètres différemment.
   NOTE : "*" correspondra aussi aux fichiers débutant par '.', contrairement
aux shells Unix.

						    *autocmd-searchpat*
Les autocommandes ne modifient pas les motifs de recherche courants. Vim
enregistre les motifs de recherche courants avant d'exécuter les
autocommandes, puis les restaure après qu'elles ont fini. Cela signifie que
les autocommandes n'affectent pas les chaînes mises en surbrillance avec
l'option 'hlsearch'. À l'intérieur des autocommandes, vous pouvez toujours
utiliser les motifs de recherche normalement, p. ex., avec la commande "n".
   Si vous souhaitez qu'une autocommande fixe le motif de recherche afin qu'il
reste utilisable après que l'autocommande a fini, utilisez la commande
":let @/ =".
   La surbrillance de recherche ne peut pas être désactivée avec ":nohlsearch"
dans une autocommande. Utilisez le drapeau 'h' de l'option 'viminfo' pour
désactiver la surbrillance de recherche au démarrage de Vim.

						    *Cmd-event*
Quand un des événements "*Cmd" est utilisé, les autocommandes correspondantes
sont censées effectuer la lecture ou l'enregistrement du fichier. Ceci peut
être utilisé lorsque vous travaillez avec des fichiers d'un type particulier,
par exemple sur un système distant.
   ATTENTION ! Si vous utilisez ces événements de mauvaise façon, cela peut
avoir comme effet de rendre impossible la lecture ou l'enregistrement des
fichiers correspondants. Assurez-vous d'abord de bien tester vos
autocommandes. Le mieux est d'utiliser un motif qui ne pourra jamais
correspondre à un nom de fichier normal, par exemple "ftp://*".

Quand vous définissez un événement BufReadCmd, il sera difficile pour Vim de
recouvrer une session d'édition plantée. Lors du recouvrement à partir du
fichier original, Vim lit uniquement les parties du fichier qu'il ne trouve
pas dans le fichier d'échange. Comme cela n'est pas possible avec BufReadCmd,
utilisez la commande |:preserve| pour vous assurer que le fichier original ne
sera plus nécessaire pour le recouvrement. Cela n'est utile qu'au cas où le
fichier a été modifié.

La variable |v:cmdarg| contient les arguments "++enc=" et "++ff=" effectifs.
Ils devraient être utilisés pour la commande qui lit/enregistre le fichier.

Voir $VIMRUNTIME/plugin/netrw.vim pour avoir des exemples.

 vim:tw=78:ts=8:ft=help:norl: