*eval.txt*      Pour Vim version 6.2.


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


Évaluation d'expressions		    *expression* *expr* *E15* *eval*

L'utilisation des expressions est abordée dans le chapitre 41 du Manuel de
l'utilisateur |usr_41.txt|.

 1. Variables			    |variables|
 2. Syntaxe des expressions	    |expression-syntax|
 3. Variables internes		    |internal-variables|
 4. Fonctions internes		    |functions|
 5. Définir des fonctions	    |user-functions|
 6. Noms entre accolades	    |curly-braces-names|
 7. Commandes			    |expression-commands|
 8. Gestion des exceptions	    |exception-handling|
 9. Exemples			    |eval-examples|
10. Fonctionnalité +eval absente    |no-eval-feature|
11. Le bac à sable		    |eval-sandbox|

{absent de Vi}
{uniquement si compilé avec la fonctionnalité |+eval| ; voir aussi la section
|no-eval-feature| plus bas}

==============================================================================
1. Variables						*variables*

Il existe deux types de variables :

Nombre		un nombre sur 32 bits signé.
Chaîne		chaîne de caractères sur 8 bits non signés terminée par NUL.

La conversion entre ces deux types est automatique, en fonction de leur
contexte d'utilisation.

La conversion d'un Nombre en Chaîne se fait en donnant une représentation
ASCII du Nombre. Exemples :
	Nombre 123	    -->	    Chaîne "123"
	Nombre 0	    -->	    Chaîne "0"
	Nombre -1	    -->	    Chaîne "-1"

La conversion d'une Chaîne en Nombre se fait en convertissant les premiers
chiffres en nombre. Les nombres hexadécimaux ("0xf9") et octaux ("017") sont
reconnus. Si la Chaîne ne débute pas par des chiffres, le résultat vaut zéro.
Exemples :
	Chaîne "456"	    -->	    Nombre 456
	Chaîne "6navets"    -->	    Nombre 6
	Chaîne "toto"	    -->	    Nombre 0
	Chaîne "0xf1"	    -->	    Nombre 241
	Chaîne "0100"	    -->	    Nombre 64

Pour forcer la conversion d'une Chaîne en Nombre, ajoutez-lui zéro :
	:echo "0100" + 0

Les opérateurs booléens sont représentés par des Nombres. Un zéro est FAUX, un
non-nul est VRAI.

NOTE : Dans la commande
	:if "toto"
"toto" est converti en 0, ce qui signifie FAUX. Pour tester si une chaîne est
non-vide, utilisez strlen() :
	:if strlen("toto")

Pour connaître le type d'une variable ou d'une expression, utilisez la
fonction |type()|.

Lorsque le drapeau '!' est inclus dans l'option 'viminfo', les variables
globales qui débutent par une lettre majuscule et ne contiennent pas de
lettres minuscules sont enregistrées dans le fichier viminfo |viminfo-file|.

Lorsque l'option 'sessionoptions' contient "global", les variables globales
qui débutent par une lettre majuscule et contiennent au moins une lettre
minuscule sont enregistrées dans le fichier de session |session-file|.

	NOM DE VARIABLE	  PEUT ÊTRE ENREGISTRÉE...  ~
	    ma_var_6	  nulle part
	    Ma_Var_6	  dans le fichier de session
	    MA_VAR_6	  dans le fichier viminfo


Il est possible de former un nom de variable avec des accolades, voir
|curly-braces-names|.

==============================================================================
2. Syntaxe des expressions				*expression-syntax*

Sommaire des syntaxes d'expressions, par ordre croissant de priorité :

|expr1| expr2 ? expr1 : expr1	structure "if/then/else"

|expr2|	expr3 || expr3 ..	OU logique

|expr3|	expr4 && expr4 ..	ET logique

|expr4|	expr5 == expr5		égal
expr5 != expr5		non égal
expr5 >	 expr5		supérieur à
expr5 >= expr5		supérieur ou égal
expr5 <	 expr5		inférieur à
expr5 <= expr5		inférieur ou égal
expr5 =~ expr5		correspondance de motif
expr5 !~ expr5		non correspondance de motif
expr5 ==? expr5		égal, sans correspondance de casse
expr5 ==# expr5		égal, avec correspondance de casse
etc. (comme ci-dessus, préfixez '?' pour ignorer la casse, '#' pour la
respecter)

|expr5|	expr6 +	expr6 ..	somme arithmétique
expr6 - expr6 ..	différence arithmétique
expr6 . expr6 ..	concaténation de chaînes

|expr6|	expr7 *	expr7 ..	produit arithmétique
expr7 /	expr7 ..	quotient arithmétique
expr7 %	expr7 ..	modulo arithmétique

|expr7|	! expr7			NON logique
- expr7			moins unaire
+ expr7			plus unaire
expr8

|expr8|	expr9[expr1]		index dans une Chaîne

|expr9|	nombre			constante numérique
"chaîne"		constante de type chaîne
'chaîne'		constante de type chaîne littérale
&option			valeur d'option
(expr1)			expression imbriquée
variable		variable interne
va{ria}ble		variable interne avec des accolades
$VAR			variable d'environnement
@r			contenu du registre 'r'
fonction(expr1, ...)	appel de fonction
fonc{ti}on(expr1, ...)	appel de fonction avec des accolades


".." indique que les opérations de ce niveau peuvent être concaténées.
Exemple :
	&nu || &list && &shell == "csh"

Toutes les expressions au sein d'un même niveau sont analysées de gauche à
droite.


EXPR1							*expr1* *E109*

expr2 ? expr1 : expr1

L'expression avant le '?' est évaluée en tant que nombre. Si elle vaut un
non-nul, le résultat est la valeur de l'expression entre '?' et ':', sinon, le
résultat est la valeur de l'expression après ':'. Exemple :
	:echo lnum == 1 ? "haut" : lnum

Comme la première expression est une "expr2", elle ne peut pas contenir
une autre structure "?:". Les deux autres expressions le peuvent, ce qui
autorise une utilisation récursive de "?:". Exemple :
	:echo lnum == 1 ? "haut" : lnum == 1000 ? "bas" : lnum

Pour que cela reste lisible, il est conseillé d'utiliser des continuations de
lignes |line-continuation| :
	:echo lnum == 1
	:\	? "haut"
	:\	: lnum == 1000
	:\		? "bas"
	:\		: lnum


EXPR2 ET EXPR3						*expr2* *expr3*

	    					*expr-barbar* *expr-&&*
Les opérateurs "||" et "&&" admettent un argument de chaque côté. Les
arguments sont des Nombres (ou ils sont convertis). Le résultat est :

	ENTRÉE			SORTIE		     ~
	n1	  n2		n1 || n2   n1 && n2  ~
	zéro	  zéro		zéro	   zéro
	zéro	  non-nul	non-nul    zéro
	non-nul   zéro		non-nul    zéro
	non-nul   non-nul	non-nul    non-nul

Les opérateurs peuvent être concaténés, par exemple :

	&nu || &list && &shell == "csh"

NOTE : "&&" est prioritaire sur "||", l'exemple précédent revient donc à :

	&nu || (&list && &shell == "csh")

Dès que le résultat est connu, l'expression est « court-circuitée »,
c'est-à-dire que ses arguments suivants ne seront pas évalués. Ce comportement
est le même qu'en C. Par exemple

	:let a = 1
	:echo a || b

est valide même s'il n'existe pas de variable nommée "b", car "a" est non-nul
et le résultat sera donc non-nul. De la même façon

	:echo exists("b") && b == "oui"

est valide que "b" ait été défini ou non. La deuxième clause ne sera évaluée
que si "b" a été défini.


EXPR4							*expr4*

expr5 {cmp} expr5

Compare deux expressions expr5, et retourne 0 si FAUX ou 1 si VRAI.

				*expr-==*  *expr-!=*  *expr->*   *expr->=*
				*expr-<*   *expr-<=*  *expr-=~*  *expr-!~*
				*expr-==#* *expr-!=#* *expr->#*  *expr->=#*
				*expr-<#*  *expr-<=#* *expr-=~#* *expr-!~#*
				*expr-==?* *expr-!=?* *expr->?*  *expr->=?*
				*expr-<?*  *expr-<=?* *expr-=~?* *expr-!~?*
		     UTILISE 'ignorecase'   CASSE RESPECTÉE   CASSE IGNORÉE  ~
égal			      ==		  ==#		   ==?
non égal		      !=		  !=#		   !=?
supérieur à		      >			  ># 		   >?
supérieur ou égal	      >=		  >=#		   >=?
inférieur à		      <			  <# 		   <?
inférieur ou égal	      <=		  <=#		   <=?
correspondance d'exprat	      =~		  =~#		   =~?
non-correspondance d'exprat   !~		  !~#		   !~?

Exemples :
"abc" ==# "Abc"		est évalué à 0
"abc" ==? "Abc"		est évalué à 1
"abc" == "Abc"		est évalué à 1 si 'ignorecase' est activé, 0 sinon

Lorsqu'une Chaîne est comparée à un Nombre, la Chaîne est convertie en Nombre
et la comparaison est effectuée sur les Nombres. Ainsi, "0 == 'x'"  est VRAI,
car 'x' converti en Nombre vaut zéro.

Lorsque deux Chaînes sont comparées, strcmp() ou stricmp() sont utilisées.
Cela a pour effet d'opérer sur la différence mathématique (en comparant la
valeur des octets), qui n'est pas forcément identique à la différence
alphabétique pour une langue donnée.

Quand les opérateurs avec un '#' final sont utilisés, ou sans terminaison avec
'ignorecase' désactivé, la comparaison est effectuée avec strcmp().

Quand les opérateurs avec un '?' final sont utilisés, ou sans terminaison avec
'ignorecase' activé, la comparaison est effectuée avec stricmp().

Les opérateurs "=~" et "!~" essaient de faire correspondre l'argument du côté
gauche avec celui du côté droit, qui est utilisé en tant que motif. Voir
|pattern| pour la définition d'un motif. Cette correspondance est toujours
effectuée comme si 'magic' était activé et 'cpoptions' vide, indépendamment
des valeurs courantes de 'magic' et 'cpoptions'. Cela permet d'écrire des
scripts portables. Pour éviter d'avoir à doubler les contre-obliques dans le
motif d'exprat, utilisez une chaîne entre apostrophes simples, voir
|literal-string|.
   Comme une chaîne est censée être une ligne simple, un motif multi-lignes
(contenant "\n", « contre-oblique + n ») ne correspondra pas. Cependant, un
caractère <NL> littéral peut correspondre en tant que caractère ordinaire.
Exemples :
"toto\ntiti" =~ "\n"	est évalué à 1
"toto\ntiti" =~ "\\n"	est évalué à 0


EXPR5 ET EXPR6						*expr5* *expr6*

expr6 +	expr6 ..	somme arithmétique		*expr-+*
expr6 -	expr6 ..	différence arithmétique		*expr--*
expr6 .	expr6 ..	concaténation de chaînes	*expr-.*

expr7 *	expr7 ..	produit arithmétique		*expr-star*
expr7 /	expr7 ..	quotient arithmétique		*expr-/*
expr7 %	expr7 ..	modulo arithmétique		*expr-%*

Pour tous ces opérateurs, "." excepté, les Chaînes sont converties en Nombres.

Notez bien la différence entre "+" et "." :
"123" + "456" = 579
"123" . "456" = "123456"

Quand le côté droit de "/" vaut zéro, le résultat vaut 0x7fffffff.
Quand le côté droit de "%" vaut zéro, le résultat vaut 0.


EXPR7							*expr7*

! expr7			NON logique			*expr-!*
- expr7			moins unaire			*expr-unary--*
+ expr7			plus unaire			*expr-unary-+*

Avec "!", un non-nul devient zéro, zéro devient un.
Avec "-", le signe du nombre est inversé.
Avec "+", le nombre n'est pas modifié.

Une Chaîne sera d'abord convertie en Nombre.

Ces trois opérateurs peuvent être répétés et mélangés. Exemples :
!-1	    == 0
!!8	    == 1
--9	    == 9


EXPR8							*expr8*

expr9[expr1]		index dans une Chaîne		*expr-[]* *E111*

Cette expression donne une chaîne qui contient le expr1-ième caractère simple
de expr9. expr9 est utilisé en tant que Chaîne, expr1 en tant que Nombre.

NOTE : L'index zéro correspond au premier caractère. Cela fonctionne comme en
C. Attention cependant : les numéros des colonnes de texte commencent à un !
Par exemple, pour obtenir le caractère sous le curseur :
	:let c = getline(line("."))[col(".") - 1]

Si la longueur de la Chaîne est inférieure à l'index, une Chaîne vide est
renvoyée.


							*expr9*
NOMBRE

nombre			constante numérique		*expr-number*

Elle peut être décimale, hexadécimale (si elle débute par "0x" ou "0X"), ou
octale (si elle débute par "0").


CHAÎNE							*expr-string* *E114*

"chaîne"		constante de type chaîne	*expr-quote*

NOTE : Remarquez bien l'utilisation des doubles-apostrophes.

Une constante de type chaîne accepte ces caractères spéciaux :
\...	un nombre octal de trois chiffres (p. ex., "\316")
\..	un nombre octal de deux chiffres (doit être suivi par un non-chiffre)
\.	un nombre octal d'un chiffre (doit être suivi par un non-chiffre)
\x..	octet décrit par deux nombres hexa (p. ex., "\x1f")
\x.	octet décrit par un nombre hexa (doit être suivi par un caractère
	   non-hexa)
\X..	identique à \x..
\X.	identique à \x.
\u....	caractère décrit par un nombre hexa d'au plus 4 caractères, codé en
	   fonction de la valeur courante de 'encoding' (p. ex., "\u02a4")
\U....	identique à \u....
\b	retour arrière <RetArr>
\e	échappement <Echap>
\f	saut-de-page <FF>
\n	saut-de-ligne <NL>
\r	retour chariot <CR>
\t	tabulation <Tab>
\\	contre-oblique
\"	double-apostrophe
\<xxx>	séquence spéciale nommée "xxx" (p. ex., "\<C-W>" pour CTRL-W)

NOTE : "\000" et "\x00" forcent la fin de la chaîne.


CHAÎNE LITTÉRALE				*literal-string* *E115*

'chaîne'		constante de type chaîne littérale	*expr-'*

NOTE : Remarquez bien l'utilisation des apostrophes simples.

Cette chaîne est interprétée littéralement. Aucune contre-oblique n'est
supprimée ni ne possède de signification spéciale. Une chaîne littérale ne
peut pas contenir d'apostrophes simples. Utilisez une chaîne normale pour
cela.


OPTION						*expr-option* *E112* *E113*

&option			valeur d'option, valeur locale si possible
&g:option		valeur globale d'option
&l:option		valeur locale d'option

Exemples :
	:echo "tabstop vaut " . &tabstop
	:if &insertmode

N'importe quel nom d'option peut être utilisé. Voir |options|. Quand vous
demandez une valeur locale et qu'il n'y a pas de valeur locale de tampon ni de
fenêtre, la valeur globale est utilisée à la place.


REGISTRE						*expr-register*

@r			contenu du registre 'r'

Cette expression donne le contenu du registre nommé correspondant, en tant que
chaîne simple. Des sauts-de-lignes sont insérés aux endroits où c'est
nécessaire. Pour obtenir le contenu du registre sans nom, utilisez "@@". Le
registre '=' ne peut pas être utilisé ici. Voir |registers| pour le détail des
registres disponibles.


IMBRICATION						*expr-nesting* *E110*

(expr1)			expression imbriquée


VARIABLE D'ENVIRONNEMENT				*expr-env*

$VAR			variable d'environnement

La valeur de n'importe quelle variable d'environnement en tant que Chaîne.
Quand elle n'est pas définie, cette expression renvoie une chaîne vide.
							*expr-env-expand*
NOTE : Il y a une différence entre l'utilisation directe de $VAR et celle de
expand("$VAR"). L'utilisation directe étendra uniquement les variables
d'environnement qui sont connues à l'intérieur de la session Vim courante.
L'utilisation de expand() procédera de même en premier lieu. Mais si cela
échoue, un shell sera utilisé pour étendre la variable. Ceci peut être lent,
mais étendra toutes les variables connues par le shell. Exemple :
	:echo $version
	:echo expand("$version")
La première commande ne renverra probablement rien, tandis que la seconde
renverra la valeur de la variable $version (si votre shell la supporte).


VARIABLE INTERNE					*expr-variable*

variable		variable interne

Voir |internal-variables| ci-dessous.


APPEL DE FONCTION	    *expr-function* *E116* *E117* *E118* *E119* *E120*

fonction(expr1, ...)	appel de fonction

Voir |functions| plus bas.

==============================================================================
3. Variables internes			    *internal-variables* *E121* *E461*

Un nom de variable interne peut être composé de lettres, de chiffres et de
'_'. Mais il ne peut pas débuter par un chiffre. Il est en outre possible
d'utiliser des accolades, voir |curly-braces-names|.

Une variable interne est créée par la commande ":let" |:let|. Elle est
supprimée par la commande ":unlet" |:unlet|.
   L'utilisation d'un nom ne correspondant pas à une variable interne -- ou
correspondant à une variable supprimée -- produit une erreur.

Il existe plusieurs espaces de nommage pour les variables. Celui utilisé
dépend du préfixe employé :

		  (aucun) Dans une fonction : locale à la fonction ; sinon :
			     globale
|buffer-variable|    b:	  Locale au tampon courant		     ["Buffer"]
|window-variable|    w:	  Locale à la fenêtre courante		     ["Window"]
|global-variable|    g:	  Globale
|local-variable|     l:	  Locale à une fonction
|script-variable|    s:	  Locale à un script Vim sourcé |:source|
|function-argument|  a:	  Argument de fonction (uniquement dans une fonction)
|vim-variable|       v:	  Globale, prédéfinie par Vim

						*buffer-variable* *b:var*
Un nom de variable précédé par "b:" est local au tampon courant. Ainsi, vous
pouvez avoir plusieurs variables "b:toto", une pour chaque tampon.
   Ce type de variable est supprimé lorsque le tampon est déchargé. Si vous
voulez la conserver, faites en sorte que le tampon ne soit pas déchargé
(p. ex., en activant l'option 'hidden').

Il existe une variable locale de tampon prédéfinie :
					*b:changedtick-variable* *changetick*
b:changedtick	Le nombre total de modifications faites dans le tampon
		courant. Ce nombre est incrémenté à chaque modification. Une
		commande d'annulation comptera aussi pour une modification
		dans ce contexte. Cette variable peut être utilisée pour
		effectuer une action uniquement si le tampon a été modifié.
		Exemple :
			:if mon_changedtick != b:changedtick
			:  let mon_changedtick = b:changedtick
			:  call Ma_MiseAJour()
			:endif

						*window-variable* *w:var*
Une variable dont le nom est précédé par "w:" est locale à la fenêtre
courante. Elle est supprimée lorsque la fenêtre est fermée.

						*global-variable* *g:var*
Dans une fonction, utilisez "g:" pour accéder aux variables globales. Sans
cela, vous accéderez aux variables locales à la fonction. Mais vous pouvez
aussi utiliser "g:" à n'importe quel autre endroit si vous voulez.

						*local-variable* *l:var*
Dans une fonction, vous pouvez accéder aux variables locales sans aucun
préfixe. Mais vous pouvez aussi préfixer "l:" si vous voulez.

						*script-variable* *s:var*
Dans un script Vim, des variables débutant par "s:" peuvent être utilisées.
Vous ne pourrez pas y accéder en dehors du script, car elles sont locales au
script.

Elles peuvent être utilisées dans :
- les commandes exécutées lors du sourcement du script ;
- les fonctions définies dans le script ;
- les autocommandes définies dans le script ;
- les fonctions et les autocommandes définies dans les fonctions et les
  autocommandes qui ont été définies dans le script (récursivement) ;
- les commandes utilisateur définies dans le script.
Mais pas dans :
- les autres scripts sourcés depuis le script courant ;
- les mappages ;
- etc.

Les variables de script peuvent être utilisées pour éviter des conflits avec
des noms de variables globales. Par exemple, ceci fonctionne :

	let s:compteur = 0
	function MonCompteur()
	  let s:compteur = s:compteur + 1
	  echo s:compteur
	endfunction
	command Plus call MonCompteur()

Mais ceci ne fonctionne PAS :

	let s:compteur = 0
	command Plus let s:compteur = s:compteur + 1 | echo s:compteur

Quand la commande ":Plus" est exécutée en dehors du script, la variable
"s:compteur" ne sera pas disponible. Dans l'exemple précédent, l'appel de la
fonction MonCompteur() fixait le contexte pour les variables de script où la
fonction avait été définie, ainsi "s:compteur" pouvait être utilisé.
   Les variables de script sont également disponibles quand une fonction est
définie dans une fonction qui est définie dans un script. Exemple :

	let s:compteur = 0
	function DebutCompteur(incr)
	  if a:incr
	    function MonCompteur()
	      let s:compteur = s:compteur + 1
	    endfunction
	  else
	    function MonCompteur()
	      let s:compteur = s:compteur - 1
	    endfunction
	  endif
	endfunction

Ceci définit la fonction MonCompteur() pour soit incrémenter soit décrémenter
"s:compteur" à l'appel de DebutCompteur(). Cela reste indépendant de l'endroit
où DebutCompteur() est appelé, la variable "s:compteur" étant accessible dans
MonCompteur().

Quand un script est sourcé une nouvelle fois, il utilisera les mêmes variables
de script. Elles resteront valides tant que Vim ne sera pas quitté. Cela peut
servir à tenir un compteur :

	if !exists("s:compteur")
	  let s:compteur = 1
	  echo "script exécuté pour la première fois"
	else
	  let s:compteur = s:compteur + 1
	  echo "script exécuté " . s:compteur . " fois maintenant"
	endif

NOTE : Ceci implique que les greffons de types de fichiers n'utilisent pas
différents jeux de variables de script pour chaque tampon. Utilisez des
variables locales de tampon à la place |b:var|.


VARIABLES VIM PRÉDÉFINIES			*vim-variable* *v:var*

			    *v:charconvert_from* *charconvert_from-variable*
v:charconvert_from
		Le nom de l'encodage de caractères d'un fichier à convertir.
		Uniquement valide lors de l'évaluation de l'option
		'charconvert'.

			    *v:charconvert_to* *charconvert_to-variable*
v:charconvert_to
		Le nom de l'encodage de caractères d'un fichier après la
		conversion. Uniquement valide lors de l'évaluation de l'option
		'charconvert'.

					*v:cmdarg* *cmdarg-variable*
v:cmdarg	Cette variable est utilisée de deux façons :
		1. Elle contient les arguments supplémentaires donnés à une
		   commande de lecture/écriture de fichier. Actuellement, ce
		   sont "++enc=" et "++ff=". Cette variable est fixée avant
		   qu'un événement d'autocommande pour la lecture/écriture de
		   fichier n'ait été déclenché. Il y a un espace blanc
		   initial, afin de permettre l'ajout de cette variable
		   directement après la commande de lecture/écriture. NOTE :
		   L'argument "+cmd" n'est pas inclus ici, car il sera de
		   toute façon exécuté.
		2. Quand un fichier PostScript est imprimé avec ":hardcopy",
		   elle correspond à l'argument de la commande ":hardcopy".
		   Cela peut servir pour 'printexpr'.

					*v:count* *count-variable*
v:count		Le quantificateur donné pour la dernière commande en mode
		Normal. Peut servir à utiliser le quantificateur dans un
		mappage. En lecture seule. Exemple :
			:map _x :<C-U>echo "le quantificateur vaut" v:count<CR>
		NOTE : Le <C-U> est nécessaire pour effacer la plage de lignes
		que vous obtenez quand vous tapez ':' après un quantificateur.
		"count" marche aussi, pour compatibilité ascendante.

					*v:count1* *count1-variable*
v:count1	Comme "v:count", mais vaut un par défaut quand aucun
		quantificateur n'a été utilisé.

					*v:ctype* *ctype-variable*
v:ctype		La valeur de la région linguistique courante pour les
		caractères de l'environnement de support. Cela permet aux
		scripts Vim d'être renseignés sur l'encodage de la région
		linguistique courante. Détail technique : elle correspond à
		la valeur de LC_CTYPE.
		Cette variable ne peut pas être fixée directement, utilisez la
		commande |:language|.
		Normalement, elle est équivalente 'encoding', mais pas
		toujours...
		Voir |multi-lang|.

					*v:dying* *dying-variable*
v:dying		Normalement zéro. Lorsqu'un signal d'interruption est reçu,
		cette variable est fixée à un. Ce nombre augmente si plusieurs
		signaux sont reçus.
		Peut être utilisé dans une autocommande pour vérifier si Vim
		s'est terminé normalement. {uniquement sur Unix}
		Exemple :
			:au VimLeave * if v:dying |
			 \ echo "\nAAAAAAAaaaaahhhhh !!\n" | endif

					*v:errmsg* *errmsg-variable*
v:errmsg	Dernier message d'erreur émis. Il est possible de fixer cette
		variable. Exemple :
			:let v:errmsg = ""
			:silent! next
			:if v:errmsg != ""
			:  ... traitement de l'erreur
		"errmsg" marche aussi, pour compatibilité ascendante.

					*v:exception* *exception-variable*
v:exception	La valeur de l'exception la plus récemment interceptée et non
		terminée. Voir aussi |v:throwpoint| et |throw-variables|.
		Exemple :
			:try
			:  throw "oups"
			:catch /.*/
			:  echo v:exception "intercepté"
			:endtry
		Résultat : "oups intercepté".

					*v:fname_in* *fname_in-variable*
v:fname_in	Le nom du fichier d'entrée. Uniquement valide lors de
		l'évaluation :
			OPTION		UTILISÉE POUR	~
			'charconvert'	le fichier à convertir
			'diffexpr'	le fichier original
			'patchexpr'	le fichier original
			'printexpr'	le fichier à imprimer

					*v:fname_out* *fname_out-variable*
v:fname_out	Le nom du fichier de sortie. Uniquement valide lors de
		l'évaluation :
			OPTION		UTILISÉE POUR	~
			'charconvert'	le fichier converti produit (*)
			'diffexpr'	la sortie de `diff`
			'patchexpr'	le fichier rustine produit
		(*) Lors de la conversion pour une commande d'écriture
		(p. ex., ":w fichier"), il sera identique à v:fname_in. Lors
		de la conversion pour une commande de lecture (p. ex., ":e
		fichier"), il s'agira d'un fichier temporaire différent de
		v:fname_in.

					*v:fname_new* *fname_new-variable*
v:fname_new	Le nom de la nouvelle version du fichier. Uniquement valide
		lors de l'évaluation de 'diffexpr'.

					*v:fname_diff* *fname_diff-variable*
v:fname_diff	Le nom du fichier diff (rustine). Uniquement valide lors de
		l'évaluation de 'patchexpr'.

					*v:folddashes* *folddashes-variable*
v:folddashes	Utilisé pour 'foldtext' : les tirets représentant le niveau de
		repli d'un repli fermé.
		En lecture seule. |fold-foldtext|

					*v:foldlevel* *foldlevel-variable*
v:foldlevel	Utilisé pour 'foldtext' : niveau de repli d'un repli fermé.
		En lecture seule. |fold-foldtext|

					*v:foldend* *foldend-variable*
v:foldend	Utilisé pour 'foldtext' : dernière ligne d'un repli fermé.
		En lecture seule. |fold-foldtext|

					*v:foldstart* *foldstart-variable*
v:foldstart	Utilisé pour 'foldtext' : première ligne d'un repli fermé.
		En lecture seule. |fold-foldtext|

					*v:lang* *lang-variable*
v:lang		La valeur de la région linguistique courante pour les
		messages de l'environnement de support. Cela permet aux
		scripts Vim d'être renseignés sur la langue courante. Détail
		technique : elle correspond à la valeur de LC_MESSSAGE.
		Cette variable ne peut pas être fixée directement, utilisez la
		commande |:language|.
		Elle peut être différente de |v:ctype| quand les messages sont
		demandés dans une langue différente de celle utilisée pour
		l'encodage de caractères. Voir |multi-lang|.

					*v:lc_time* *lc_time-variable*
v:lc_time	La valeur de la région linguistique courante pour les
		messages de date de l'environnement de support. Cela permet
		aux scripts Vim d'être renseignés sur la langue courante.
		Détail technique : elle correspond à la valeur de LC_TIME.
		Cette variable ne peut pas être fixée directement, utilisez la
		commande |:language|. Voir |multi-lang|.

					*v:lnum* *lnum-variable*
v:lnum		Le numéro de ligne pour les expressions 'foldexpr' et
		'indentexpr'. Uniquement valide lors de l'évaluation d'une de
		ces expressions.
		En lecture seule. |fold-expr| |'indentexpr'|

					*v:prevcount* *prevcount-variable*
v:prevcount	Le quantificateur donné pour l'avant-dernière commande en mode
		Normal. Il s'agit de la valeur v:count de la commande
		précédente. Utile si vous souhaitez quitter le mode Visuel
		puis utiliser le quantificateur.
			:vmap % <Esc>:call MonFiltre(v:prevcount)<CR>
		En lecture seule.

					*v:progname* *progname-variable*
v:progname	Contient le nom (le chemin d'accès est supprimé) par lequel
		Vim a été invoqué. Permet de réaliser des initialisations
		spéciales pour `view`, `evim`, etc., ou n'importe quel nom de
		lien symbolique que vous avez pu créer pour Vim.
		En lecture seule.

					*v:register* *register-variable*
v:register	Le nom du registre fourni à la dernière commande en mode
		Normal. Vide si aucun registre n'a été fourni. |getreg()|
		|setreg()|

					*v:servername* *servername-variable*
v:servername	Le nom enregistré par une IHM graphique Vim sur le serveur X
		s'il y en a un. |x11-clientserver|
		En lecture seule.

					*v:shell_error* *shell_error-variable*
v:shell_error	Résultat de la dernière commande shell. Si non-nul, la
		dernière commande shell s'est soldée par une erreur. Si nul,
		il n'y a pas eu de problème. Cela ne marche que quand le shell
		retourne son code d'erreur à Vim.
		La valeur -1 est souvent utilisée quand la commande n'a pas pu
		être exécutée. En lecture seule.
		Exemple :
			:!mv toto titi
			:if v:shell_error
			:  echo 'Impossible de renommer « toto » en « titi » !'
			:endif
		"shell_error" marche aussi, pour compatibilité ascendante.

					*v:statusmsg* *statusmsg-variable*
v:statusmsg	Dernier message d'état émis. Il est possible de fixer cette
		variable.

				*v:termresponse* *termresponse-variable*
v:termresponse	La séquence d'échappement retournée par le terminal pour
		l'entrée termcap |t_RV|. Cette variable est fixée quand Vim
		reçoit une séquence d'échappement qui débute par « Échap '[' »
		ou CSI, et se termine par un 'c', avec entre les deux
		uniquement des chiffres, ';' et '.'.
		Quand cette variable est fixée, l'événement d'autocommande
		TermResponse est déclenché, afin que vous puissiez réagir à la
		réponse du terminal.
		La réponse donnée par le nouveau xterm est : "<Echap>[ Pp ;
		Pv ; Pc c". Pp définit le type du terminal : 0 pour vt100 et 1
		pour vt220. Pv définit le niveau de rustine (comme ceci a été
		introduit dans la rustine 95, il vaut toujours 95 ou plus). Pc
		vaut toujours zéro.
		{uniquement si compilé avec la fonctionnalité |+termresponse|}

				*v:this_session* *this_session-variable*
v:this_session	Nom de fichier complet du dernier fichier de session chargé ou
		enregistré |:mksession|. Il est possible de fixer cette
		variable. Si aucun fichier de session n'a été enregistré,
		cette variable est vide.
		"this_session" marche aussi, pour compatibilité ascendante.

					*v:throwpoint* *throwpoint-variable*
v:throwpoint	L'endroit où l'exception la plus récemment interceptée et non
		terminée a été émise. Non fixé lorsque les commandes sont
		tapées directement. Voir aussi |v:exception| et
		|throw-variables|.
		Exemple :
			:try
			:  throw "oups"
			:catch /.*/
			:  echo "Exception dans" v:throwpoint
			:endtry
		Sortie : "Exception dans test.vim, ligne 2".

					*v:version* *version-variable*
v:version	Numéro de version de Vim : numéro de version majeur fois 100
		plus numéro de version mineur. Ainsi, la version 5.0
		correspond à 500 ; la version 5.1 (5.01) à 501. En lecture
		seule.
		"version" marche aussi, pour compatibilité ascendante.
		Utilisez |has()| pour vérifier si une certaine rustine a été
		incluse, p. ex. :
			if has("patch123")
		NOTE : Les numéros de rustines sont spécifiques à chaque
		version, ainsi, les versions 5.0 et 5.1 peuvent avoir toutes
		deux une rustine 123, mais qui sera totalement différente.

					*v:warningmsg* *warningmsg-variable*
v:warningmsg	Dernier message d'avertissement émis. Il est possible de fixer
		cette variable.

==============================================================================
4. Fonctions internes					*functions*

Voir |function-list| pour un index thématique de ces fonctions.

(Utilisez CTRL-] sur le nom d'une fonction pour sauter jusqu'à son explication
détaillée.)

USAGE			      RÉSULTAT	DESCRIPTION	    ~
------------------------------------------------------------
append( {nol}, {chaine})	Nombre	ajoute {chaine} sous la ligne {nol}
argc()				Nombre	nb. de fichiers dans la liste des arg.
argidx()			Nombre	index courant dans la liste des arg.
argv( {no})			Chaîne	entrée {no} de la liste des arg.
browse( {enreg}, {titre}, {repinit}, {defaut})
				Chaîne	ouvre un sélecteur de fichier
bufexists( {expr})		Nombre	VRAI si le tampon {expr} existe
buflisted( {expr})		Nombre	VRAI si le tampon {expr} est listé
bufloaded( {expr})		Nombre	VRAI si le tampon {expr} est chargé
bufname( {expr})		Chaîne	nom du tampon {expr}
bufnr( {expr})			Nombre	numéro du tampon {expr}
bufwinnr( {expr})		Nombre	numéro de la fenêtre du tampon {expr}
byte2line( {octet})		Nombre	n° de ligne correspondant à l'{octet}
char2nr( {expr})		Nombre	valeur ASCII du premier car. de {expr}
cindent( {nol})			Nombre	indentation C pour la ligne {nol}
col( {expr})			Nombre	n° de colonne à la position {expr}
confirm( {msg} [, {choix} [, {defaut} [, {type}]]])
				Nombre	offre plusieurs choix à l'utilisateur
cscope_connection( [{nb} , {cheminBD} [, {prefixe}]])
				Nombre	teste si une connexion cscope existe
cursor( {nol}, {col})		Nombre	place le curseur sur {nol} et {col}
delete( {nomfich})		Nombre	supprime le fichier {nomfich}
did_filetype()			Nombre	VRAI si événement FileType utilisé
escape( {chaine}, {cars})	Chaîne	protège {cars} dans {chaine} par '\'
eventhandler()			Nombre	VRAI ds 1 routine de traitement d'évén.
executable( {expr})		Nombre	1 si l'exécutable {expr} existe
exists( {var})			Nombre	VRAI si {var} existe XXX {expr}
expand( {expr})			Chaîne	étend les mots-clés spéciaux ds {expr}
filereadable( {fich})		Nombre	VRAI si {fich} peut être lu
filewritable( {fich})		Nombre	VRAI si {fich} peut être écrit
fnamemodify( {nomfich}, {mods})	Chaîne	modifie le nom du fichier
foldclosed( {nol})		Nombre	première l. du repli sur {nol} si fermé
foldclosedend( {nol})		Nombre	dernière l. du repli sur {nol} si fermé
foldlevel( {nol})		Nombre	niveau de repli sur {nol}
foldtext()			Chaîne	ligne affichée pour un repli fermé
foreground()			Nombre	met la fenêtre Vim au premier plan
getchar( [expr])		Nombre	attend un caractère de l'utilisateur
getcharmod()			Nombre	modificateurs pour le dernier car entré
getbufvar( {expr}, {nomvar})		variable {nomvar} du tampon {expr}
getcwd()			Chaîne	le répertoire courant
getfsize( {nomfich})		Nombre	taille en octets du fichier
getftime( {nomfich})		Nombre	date de dernière modification du fich.
getline( {nol})			Chaîne	ligne {nol} du tampon courant
getreg( [{nomreg}])		Chaîne	contenu du registre
getregtype( [{nomreg}])		Chaîne	type du registre
getwinposx()			Nombre	coord X (pixels) de la fenêtre IHMg Vim
getwinposy()			Nombre	coord Y (pixels) de la fenêtre IHMg Vim
getwinvar( {no}, {nomvar})		variable {nomvar} de la fenêtre {no}
glob( {expr})			Chaîne	étend les car. d'englobement de {expr}
globpath( {chemin}, {expr})	Chaîne	glob({expr}) pour les rép. de {chemin}
has( {fctalite})		Nombre	VRAI si la {fctalite} est supportée
hasmapto( {qqc} [, {mode}])	Nombre	VRAI si un mappage à {qqc} existe
histadd( {histo}, {elem})	Chaîne	ajoute un élément à un historique
histdel( {histo} [, {elem}])	Chaîne	supprime un élément d'un historique
histget( {histo} [, {index}])	Chaîne	donne l'élément {index} d'un historique
histnr( {histo})		Nombre	index le plus élevé d'un historique
hlexists( {nom})		Nombre	VRAI si le grp surbrillance existe
hlID( {nom})			Nombre	donne l'ID du grp de surbrillance {nom}
hostname()			Chaîne	nom de la machine où Vim s'exécute
iconv( {expr}, {de}, {a})	Chaîne	convertit l'encodage de {expr}
indent( {nol})			Nombre	indentation de la ligne {nol}
input( {invite} [, {texte}])	Chaîne	attend une entrée de l'utilisateur
inputdialog({invite} [, {texte} [, {retourannul}]])
				Chaîne	comme input() mais ds un dialogue IHMg
inputrestore()			Nombre	restaure une saisie sauvegardée
inputsave()			Nombre	sauvegarde la saisie et l'efface
inputsecret( {invite} [, {texte}])
				Chaîne	comme input() mais masque la saisie
isdirectory( {repertoire})	Nombre	VRAI si {repertoire} est un répertoire
libcall( {bib}, {fonc}, {arg})	Chaîne	appelle {fonc} dans {bib} avec {arg}
libcallnr( {bib}, {fonc}, {arg})
				Nombre	idem, mais retourne un Nombre
line( {expr})			Nombre	n° de ligne à la position {expr}
line2byte( {nol})		Nombre	numéro d'octet correspondant à {nol}
lispindent( {nol})		Nombre	indentation Lisp pour la ligne {nol}
localtime()			Nombre	date courante
maparg( {nom} [, {mode}])	Chaîne	ctg du mappage {nom} en mode {mode}
mapcheck( {nom} [, {mode}])	Chaîne	si des mappages correspondent à {nom}
match( {expr}, {mtf} [, {debut}])
				Nombre	position où {mtf} correspond ds {expr}
matchend( {expr}, {mtf} [, {debut})
				Nombre	position où {mtf} se termine ds {expr}
matchstr( {expr}, {mtf} [, {debut}])
				Chaîne	correspondance de {mtf} dans {expr}
mode()				Chaîne	mode d'édition courant
nextnonblank( {nol})		Nombre	n° de ligne de la ligne non-vide suiv.
nr2char( {expr})		Chaîne	caractère simple de valeur ASCII {expr}
prevnonblank( {nol})		Nombre	n° de ligne de la ligne non-vide préc.
remote_expr( {serveur}, {chaine} [, {varID}])
				Chaîne	envoie une expression
remote_foreground( {serveur})	Nombre	met le serveur Vim au premier plan
remote_peek( {IDserveur} [, {varretour}])
				Nombre	teste s'il y a des chaînes de réponses
remote_read( {IDserveur})	Chaîne	lit une chaîne de réponse
remote_send( {serveur}, {chaine} [, {varID}])
				Chaîne	envoie une séquence de touches
rename( {de}, {a})		Nombre	renomme (déplace) le fich. {de} en {a}
resolve( {nomfich})		Chaîne	fichier vers lequel pointe un raccourci
search( {mtf} [, {drapeaux}])	Nombre	recherche {mtf}
searchpair( {debut}, {milieu}, {fin} [, {drapeaux} [, {ignore}]])
				Nombre	trouve l'autre fin d'1 couple début/fin
server2client( {IDclient}, {chaine})
				Nombre	envoie une chaîne de réponse
serverlist()			Chaîne	donne la liste des serveurs disponibles
setbufvar( {expr}, {nomvar}, {val})	fixe {nomvar} ds le tamp {expr} à {val}
setline( {nol}, {ligne})	Nombre	remplace la ligne {nol} par {ligne}
setreg( {reg}, {val} [, {opt}])	Nombre	fixe la valeur et le type du registre
setwinvar( {no}, {nomvar}, {val})	fixe {nomvar} ds fenêtre {no} à {val}
strftime( {format} [, {date}])	Chaîne	date dans le format spécifié
stridx( {foin}, {aiguille})	Nombre	premier index de {aiguille} dans {foin}
strlen( {expr})			Nombre	longueur de la chaîne {expr}
strpart( {src}, {debut} [, {long}])
				Chaîne	{long} car. de {src} depuis {debut}
strridx( {foin}, {aiguille})	Nombre	dernier index de {aiguille} dans {foin}
strtrans( {expr})		Chaîne	{expr} traduite pour être imprimable
submatch( {no})			Chaîne	corres. spécifique dans ":substitute"
substitute( {expr}, {mtf}, {sub}, {drapeaux})
				Chaîne	les {mtf} de {expr} remplacés par {sub}
synID( {ligne}, {col}, {trans})	Nombre	ID de syntaxe à la {ligne} et {col}
synIDattr( {IDsyn}, {qqc} [, {mode}])
				Chaîne	attribut {qqc} de l'ID syntaxe {IDsyn}
synIDtrans( {IDsyn})		Nombre	ID de syntaxe traduit de {IDsyn}
system( {expr})			Chaîne	sortie d'une commande shell {expr}
tempname()			Chaîne	donne un nom pour un fichier temporaire
tolower( {expr})		Chaîne	la chaîne {expr} passée en minuscules
toupper( {expr})		Chaîne	la chaîne {expr} passée en majuscules
type( {nom})			Nombre	type de la variable {nom}
virtcol( {expr})		Nombre	colonne d'écran à la position {expr}
visualmode( [expr])		Chaîne	dernier mode Visuel utilisé
winbufnr( {no})			Nombre	numéro de tampon de la fenêtre {no}
wincol()			Nombre	colonne de fenêtre du curseur
winheight( {no})		Nombre	hauteur de la fenêtre {no}
winline()			Nombre	ligne de fenêtre du curseur
winnr()				Nombre	numéro de la fenêtre courante
winwidth( {no})			Nombre	largeur de la fenêtre {no}
------------------------------------------------------------

					    		*append()*
append({nol}, {chaine})
		Ajoute le texte {chaine} après la ligne {nol} dans le tampon
		courant. {nol} peut être nul, ce qui permet d'insérer un ligne
		avant la première. Retourne 1 en cas d'échec ({nol} est hors
		limites) ou 0 en cas de succès.

							*argc()*
argc()		Renvoie le nombre de fichiers dans la liste des arguments de
		la fenêtre courante. Voir |arglist|.

							*argidx()*
argidx()	Renvoie l'index courant dans la liste des arguments. 0 désigne
		le premier fichier ; "argc() - 1" désigne le dernier. Voir
		|arglist|.

							*argv()*
argv({no})	Renvoie le {no}-ième fichier dans la liste des arguments de la
		fenêtre courante. Voir |arglist|. "argv(0)" fait référence au
		premier fichier. Exemple :
			:let i = 0
			:while i < argc()
			:  let f = escape(argv(i), '. ')
			:  exe 'amenu Arg.' . f . ' :e ' . f . '<CR>'
			:  let i = i + 1
			:endwhile

							*browse()*
browse({enreg}, {titre}, {repinit}, {defaut})
		Ouvre un sélecteur de fichier. Cela ne fonctionne que lorsque
		"has("browse")" retourne un non-nul (uniquement pour certaines
		versions IHM graphiques). Les arguments sont :
		    {enreg}	si non-nul, spécifie un fichier à enregistrer
		    {titre}	titre pour le sélecteur
		    {repinit}   répertoire où commencer la navigation
		    {defaut}    nom de fichier par défaut
		Quand le bouton "Cancel" est pressé, que quelque chose tourne
		mal, ou que la navigation n'est pas possible, une chaîne vide
		est renvoyée.

							*bufexists()*
bufexists({expr})
		Renvoie un Nombre, qui est non-nul si un tampon nommé {expr}
		existe.
		Si l'argument {expr} est une chaîne, elle doit correspondre
		exactement au nom d'un tampon.
		Si l'argument {expr} est un nombre, les numéros de tampons
		sont utilisés.
		Les tampons non listés seront trouvés.
		NOTE : Les fichiers d'aide sont listés par leur nom court dans
		la sortie de |:buffers|, mais bufexists() a besoin d'utiliser
		leur nom long pour pouvoir les trouver.
		Utilisez "bufexists(0)" pour tester s'il existe un nom de
		fichier alternatif.
							*buffer_exists()*
		Nom obsolète : buffer_exists().

							*buflisted()*
buflisted({expr})
		Renvoie un Nombre, qui est non-nul si un tampon nommé {expr}
		existe et est listé (son option 'buflisted' est activée).
		L'argument {expr} est utilisé comme avec bufexists().

							*bufloaded()*
bufloaded({expr})
		Renvoie un Nombre, qui est non-nul si un tampon nommé {expr}
		existe et est chargé (il est visible dans une fenêtre ou
		caché).
		L'argument {expr} est utilisé comme avec bufexists().

							*bufname()*
bufname({expr})	Renvoie le nom d'un tampon, tel qu'il est donné par la
		commande ":ls".
		Si {expr} est un Nombre, le nom du tampon portant ce numéro
		est donné. Zéro correspond au tampon alternatif pour la
		fenêtre courante.
		Si {expr} est une Chaîne, elle est utilisée comme un motif
		d'exprat pour correspondre avec les noms des tampons. Cette
		correspondance est toujours établie comme si 'magic' était
		activée et 'cpoptions' vide. Quand il y a plus d'une
		correspondance, une chaîne vide est retournée.
		"" ou "%" peuvent être utilisés pour le tampon courant, "#"
		pour le tampon alternatif.
		Une correspondance entière sera privilégiée, sinon une
		correspondance au début, à la fin, ou au milieu du nom du
		tampon sera acceptée.
		Les tampons listés sont trouvés en premier. S'il existe une
		correspondance unique avec un tampon listé, celui-ci est
		retourné. Sinon, la recherche s'effectuera ensuite sur les
		tampons non listés.
		Si {expr} est une Chaîne, mais que vous souhaitez l'utiliser
		comme un numéro de tampon, forcez sa conversion en Nombre en
		lui ajoutant zéro :
			:echo bufname("3" + 0)
		Si le tampon n'existe pas, ou ne porte pas de nom, une chaîne
		vide est retournée.
			bufname("#")	    nom du tampon alternatif
			bufname(3)	    nom du tampon n° 3
			bufname("%")	    nom du tampon courant
			bufname("fich2")    nom du tampon où "fich2" correspond
							*buffer_name()*
		Nom obsolète : buffer_name().

							*bufnr()*
bufnr({expr})	Renvoie le numéro d'un tampon, tel qu'il est donné par la
		commande ":ls".
		Sur l'utilisation de {expr}, voir |bufname()| ci-dessus. Si le
		tampon n'existe pas, -1 est retourné. bufnr("$") désigne le
		dernier tampon :
			:let dernier_tampon = bufnr("$")
		Ceci renvoie un nombre, qui est le numéro de tampon le plus
		élevé des tampons existants. NOTE : Tous les tampons portant
		un numéro inférieur n'existent pas forcément, car ":bwipeout"
		peut en avoir liquidé certains. Utilisez bufexists() pour
		tester l'existence d'un tampon.
							*buffer_number()*
		Nom obsolète : buffer_number().
							*last_buffer_nr()*
		Nom obsolète pour bufnr("$") : last_buffer_nr().

							*bufwinnr()*
bufwinnr({expr})
		Renvoie un Nombre, qui est le numéro de la première fenêtre
		associée au tampon {expr}.
		Sur l'usage de {expr}, voir |bufname()| ci-dessus. Si le
		tampon n'existe pas ou n'a pas de fenêtre associée, -1 est
		retourné. Exemple :
			:echo "La fenêtre" (bufwinnr(1)) "contient le tampon 1"

							*byte2line()*
byte2line({octet})
		Renvoie le numéro de ligne qui contient le caractère
		correspondant au numéro d'octet {octet} dans le tampon
		courant. Cela inclut le caractère fin-de-ligne, selon la
		valeur de l'option 'fileformat' pour le tampon courant. Le
		premier caractère porte le numéro un.
		Voir aussi |line2byte()|, |go| et |:goto|.
		{uniquement si compilé avec la fonctionnalité |+byte_offset|}

							*char2nr()*
char2nr({expr})	Renvoie un Nombre, correspondant à la valeur ASCII du premier
		caractère dans {expr}. Exemples :
			char2nr(" ")		retourne 32
			char2nr("ABC")		retourne 65
		La valeur courante de 'encoding' est utilisée. Par exemple,
		pour "utf-8" :
			char2nr("á")		retourne 225
			char2nr("á"[0])		retourne 195

							*cindent()*
cindent({nol})	Renvoie un Nombre, correspondant à l'indentation de la ligne
		{nol} selon les règles d'indentation du C, comme avec
		'cindent'. L'indentation est comptée en espaces, la valeur de
		'tabstop' est prise en compte. {nol} est traitée comme dans
		|getline()|.
		Si {nol} est invalide ou que Vim n'a pas été compilé avec la
		fonctionnalité |+cindent|, renvoie -1.

							*col()*
col({expr})	Renvoie un Nombre, correspondant à la colonne dont la position
		dans le fichier est donnée par {expr}. Les positions acceptées
		sont :
		    .	    la position du curseur
		    $	    la fin de la ligne du curseur (retourne le nombre
			       de caractères dans la ligne du curseur plus un)
		    'x	    la position de la marque x (si la marque n'est pas
			       fixée, 0 est retourné)
		NOTE : Seules les marques dans le fichier courant peuvent être
		utilisées. Exemples :
			col(".")	       colonne du curseur
			col("$")	       longueur de la ligne du curseur
						  plus un
			col("'t")	       colonne de la marque 't'
			col("'" . nommarque)   colonne de la marque nommarque
		1 désigne la première colonne. En cas d'erreur, renvoie 0.
		Pour la position du curseur, quand 'virtualedit' est fixé, le
		numéro de colonne est supérieur de un si le curseur est à la
		fin de la ligne. Ceci peut être utilisé pour obtenir le numéro
		de colonne en mode Insertion :
			:imap <F2> <C-O>:let ve_sauv = &ve<CR>
				 \ <C-O>:set ve=all<CR>
				 \ <C-O>:echo col(".") . "\n" <Bar>
				 \ let &ve = ve_sauv<CR>

							*confirm()*
confirm({msg} [, {choix} [, {defaut} [, {type}]]])
		confirm() offre un dialogue à l'utilisateur, où un choix peut
		être fait. Le numéro du choix est renvoyé. 1 désigne le
		premier choix.
		NOTE : confirm() est supporté uniquement si Vim a été compilé
		avec le support des dialogues, voir |+dialog_con| et
		|+dialog_gui|.
		{msg} est affiché dans un |dialog|ue, avec {choix} comme
		alternatives. Si {choix} est absent ou vide, "&OK" est utilisé
		(et traduit).
		{msg} est une Chaîne, utilisez "\n" pour inclure un
		saut-de-ligne. La chaîne n'est enroulée quand elle dépasse du
		dialogue que sur certains systèmes.
		{choix} est une Chaîne, contenant l'ensemble des alternatives
		séparées par "\n", p. ex. :
			confirm("Écrire le tampon ?", "&Oui\n&Non\n&Annuler")
		La lettre après un '&' est le raccourci pour ce choix. Ainsi,
		vous pouvez tapez 'a' pour choisir « Annuler ». Le raccourci
		peut porter sur n'importe quelle lettre :
			confirm("Tampon modifié", "&Ecrire\nEcrire &Tous")
		Pour la console, la première lettre de chaque choix est
		utilisée comme raccourci par défaut.
		L'argument optionnel {defaut} donne le numéro du choix retenu
		si l'utilisateur frappe <CR>. Entrez 1 pour utiliser le
		premier choix par défaut. Entrez 0 pour ne pas utiliser de
		défaut. Si {defaut} est omis, 0 est utilisé.
		L'argument optionnel {type} donne le type du dialogue. Cela
		sert uniquement pour l'icône de l'IHM graphique Win32. Il peut
		prendre une des valeurs suivantes : "Error", "Question",
		"Info", "Warning" ou "Generic". Seul le premier caractère est
		pris en compte. Si {type} est omis, "Generic" est utilisé.
		Si l'utilisateur fait avorter le dialogue en pressant <Echap>,
		CTRL-C, ou une autre touche d'interruption valide, confirm()
		retourne 0.

		Un exemple :
			:let choix = confirm("Et pour le dessert ?",
				     \ "&Pommes\n&Bananes\n&Oranges", 2)
			:if choix == 0
			:  echo "Les fruits sont bons pour la santé !"
			:elseif choix == 3
			:  echo "Excellent choix."
			:else
			:  echo "Je préfère les oranges pour ma part."
			:endif
		Dans un dialogue IHM graphique, des boutons sont utilisés. La
		disposition des boutons dépend du drapeau 'v' de 'guioptions'.
		S'il est inclus, les boutons sont toujours placés
		verticalement. Sinon, confirm() essaie de placer les boutons
		alignés horizontalement. S'il dépassent, la disposition
		verticale est utilisée quand même. Sur certains systèmes, la
		disposition horizontale est toujours utilisée.

							*cscope_connection()*
cscope_connection([{nb} , {cheminBD} [, {prefixe}]])
		Teste l'existence d'une connexion |cscope|. Si aucun argument
		n'est donné, cette fonction renvoie :
		    0	si cscope n'est pas disponible (fonctionnalité absente)
			   ou s'il n'existe pas de connexions cscope ;
		    1	s'il existe au moins une connexion cscope.

		Si des arguments sont donnés, la valeur de {nb} détermine
		alors la façon dont une connexion cscope sera testée :

		    NB	 DESCRIPTION DU TEST D'EXISTENCE  ~
		    0	 Comme sans arguments (p. ex., "cscope_connection()").
		    1	 Ignore {prefixe} et utilise des correspondances de
			 chaînes partielles pour {cheminBD}.
		    2	 Ignore {prefixe} et utilise des correspondances de
			 chaînes exactes pour {cheminBD}.
		    3	 Utilise {prefixe} et utilise des correspondances de
			 chaînes partielles pour {cheminBD} et {prefixe}.
		    4	 Utilise {prefixe} et utilise des correspondances de
			 chaînes exactes pour {cheminBD} et {prefixe}.

		NOTE : Toutes les comparaisons de chaînes sont sensibles à la
		casse !

		Exemple : supposons que vous obteniez la sortie suivante (avec
		":cs show") :

		    # pid    database name			prepend path ~
		    0 27664  cscope.out				/usr/local ~

		    INVOCATION				   VAL. DE RETOUR  ~
		    cscope_connection()					1
		    cscope_connection(1, "out")				1
		    cscope_connection(2, "out")				0
		    cscope_connection(3, "out")				0
		    cscope_connection(3, "out", "local")		1
		    cscope_connection(4, "out")				0
		    cscope_connection(4, "out", "local")		0
		    cscope_connection(4, "cscope.out", "/usr/local")	1

							*cursor()*
cursor({nol}, {col})
		Place le curseur à la colonne {col} de la ligne {nol}. Ne
		modifie pas la liste des sauts.
		Si {nol} est supérieur au nombre de lignes du tampon, le
		curseur sera placé sur la dernière ligne du tampon. Si {nol}
		vaut zéro, le curseur restera dans la ligne courante.
		Si {col} est supérieur au nombre de caractères dans la ligne,
		le curseur sera placé sur le dernier caractère de la ligne. Si
		{col} vaut zéro, le curseur restera dans la colonne courante.

							*delete()*
delete({nomfich})
		Supprime le fichier de nom {nomfich}. Cette fonction renvoie
		un Nombre, qui vaut 0 si le fichier a été supprimé avec
		succès, un non-nul si la suppression a échoué.

							*did_filetype()*
did_filetype()	Renvoie un non-nul lorsque des autocommandes ont été exécutées
		et que l'événement FileType a été déclenché au moins une fois.
		Peut être utilisé afin d'éviter un nouveau déclenchement de
		l'événement FileType dans les scripts qui détectent le type de
		fichier. |FileType|
		Lorsque vous éditez un autre fichier, le compteur est
		désactivé, ainsi le test vérifie si l'événement FileType a été
		réellement déclenché pour le tampon courant. Ceci permet à une
		autocommande qui commence l'édition d'un autre tampon de fixer
		'filetype' et de charger un fichier de syntaxe.

							*escape()*
escape({chaine}, {cars})
		Protège les caractères simples {cars} qui apparaissent dans
		{chaine} par une contre-oblique. Exemple :
			:echo escape('c:\program files\vim', ' \')
		Ceci retourne :
			c:\\program\ files\\vim ~

							*eventhandler()*
eventhandler()	Retourne 1 si à l'intérieur d'une routine de traitement
		d'événement. Cela signifie que vous ne pourrez pas utiliser de
		commandes interactives. Sinon, 0 est retourné.

							*executable()*
executable({expr})
		Cette fonction teste si un exécutable nommé {expr} existe.
		{expr} doit correspondre au nom du programme sans aucun
		argument. executable() utilise la variable $PATH normale.
		Renvoie un Nombre :
		     1	    existe
		     0	    n'existe pas
		    -1	    non disponible sur ce système

							*exists()*
exists({expr})	Renvoie un nombre, qui est non-nul si {expr} existe, nul
		sinon. L'argument {expr} est une chaîne, qui peut contenir un
		de ces éléments :
		    &nomoption	  option Vim (teste seulement si elle existe,
				     pas si elle fonctionne)
		    +nomoption	  option Vim qui fonctionne
		    $NOMVARENV	  variable d'environnement (peut également
				     être comparée avec une chaîne vide)
		    *nomfonc	  fonction interne (voir |functions|) ou
				     fonction utilisateur (voir
				     |user-functions|)
		    nomvar	  variable interne |internal-variables| ; ne
				     fonctionne pas pour les noms entre
				     accolades |curly-braces-names|
		    :nomcmd	  commande Ex (les commandes internes comme
				     les commandes utilisateur |:command|) ;
				     retourne les valeurs suivantes :
				     1 - correspond avec le début d'une cmd
				     2 - correspond en entier avec une commande
				     3 - correspond à plusieurs cmd utilisateur
		    #évén	  autocommande définie pour cet événement
		    #évén#motif	  autocommande définie pour ces événement et
				     motif (le motif est pris littéralement et
				     comparé aux motifs des autocommandes
				     caractère par caractère)

		Exemples :
			exists("&shortname")
			exists("$HOSTNAME")
			exists("*strftime")
			exists("*s:MaFonc")
			exists("notamp")
			exists(":Make")
			exists("#CursorHold");
			exists("#BufReadPre#*.gz")
		Il ne doit pas y avoir d'espace entre le symbole ('&'/'$'/'*'/
		'#') et le nom.
		NOTE : L'argument doit être une chaîne, pas le nom de la
		variable elle-même ! Par exemple :
			exists(notamp)
		Ceci ne teste pas l'existence de la variable "notamp", mais
		recherche le contenu de "notamp", et teste si cela existe.

							*expand()*
expand({expr} [, {drapeau}])
		Étend les jokers et autres mots-clés spéciaux dans {expr}.
		Renvoie une Chaîne.

		Lorsqu'il existe plusieurs correspondances, elles sont
		séparées par des caractères <NL>. [NOTE : Dans la version 5.0,
		un espace était utilisé, ce qui posait des problèmes quand un
		nom de fichier contenait un espace.]

		Si l'expansion échoue, la fonction renvoie une chaîne vide. Le
		nom d'un fichier inexistant n'est pas inclus.

		Quand {expr} débute par '%', '#' ou '<', l'expansion est
		effectuée comme pour les variables spéciales Ex
		|cmdline-special|, avec leurs modificateurs associés. En voici
		un survol :
			%	    nom du fichier courant
		    	#	    nom du fichier alternatif
		    	#n	    nom du fichier alternatif n
		    	<cfile>	    nom du fichier sous le curseur
		    	<afile>	    nom de fichier dans une autocommande
		    	<abuf>	    numéro de tampon dans une autocommande
				       (en tant que Chaîne !)
		    	<amatch>    nom de la correspondance d'une autocommande
		    	<sfile>	    nom de fichier du script sourcé
		    	<cword>	    mot sous le curseur
		    	<cWORD>	    MOT sous le curseur
		    	<client>    l'{IDclient} du dernier message reçu
				       |server2client()|
		Modificateurs :
			:p	    étend le chemin complet	       ["Path"]
		    	:h	    tête (dernier segment supprimé)    ["Head"]
		    	:t	    queue (dernier segment seul)       ["Tail"]
		    	:r	    racine (une extension supprimée)
		    	:e	    extension uniquement

		Exemple :
			:let &tags = expand("%:p:h") . "/tags"
		NOTE : Lors de l'expansion d'une chaîne qui débute par '%',
		'#' ou '<', tout texte supplémentaire est ignoré. Ceci ne
		fonctionne PAS :
			:let nefonctionnepas = expand("%:h.sauv")
		Utilisez ceci :
			:let fonctionne = expand("%:h") . ".sauv"

		NOTE : L'expansion de "<cfile>" et autres chaîne spéciales
		retourne simplement le nom du fichier référencé, sans autre
		expansion. Si "<cfile>" vaut "~/.cshrc", vous devrez effectuer
		un autre expand() pour que "~/" soit étendu en chemin du
		répertoire personnel :
			:echo expand(expand("<cfile>"))

		Il ne doit pas y avoir d'espaces blancs entre les variables et
		les modificateurs qui suivent. La fonction |fnamemodify()|
		peut être utilisée pour modifier les noms de fichiers normaux.

		Si '%' ou '#' sont spécifiés alors que les noms des fichiers
		courant ou alternatif ne sont pas définis, une chaîne vide est
		utilisée. L'utilisation de "%:p" dans un tampon sans nom
		renvoie le répertoire courant, avec un '/' ajouté.

		Quand {expr} ne débute pas par '%', '#' ou '<', il est étendu
		comme l'est un nom de fichier sur la ligne de commande.
		'suffixes' et 'wildignore' sont utilisés, à moins que
		l'argument optionnel {drapeau} soit donné et soit non-nul. Les
		noms de fichiers inexistants sont inclus.

		expand() peut aussi être utilisé pour étendre des variables et
		des variables d'environnement qui ne sont connues que du
		shell. Mais cela peut être lent, car un shell doit être lancé.
		Voir |expr-env-expand|.
		La variable étendue est encore traitée comme une liste de noms
		de fichiers.

		Voir |glob()| pour trouver des fichiers existants. Voir
		|system()| pour obtenir la sortie brute d'une commande
		externe.

							*filereadable()*
filereadable({fichier})
		Renvoie un Nombre, qui est VRAI si un fichier nommé {fichier}
		existe et peut être lu. Si {fichier} n'existe pas ou est un
		répertoire, renvoie un Nombre FAUX. {fichier} est une
		expression, qui est utilisée comme une Chaîne.
							*file_readable()*
		Nom obsolète : file_readable().

							*filewritable()*
filewritable({fichier})
		Renvoie un Nombre, qui vaut 1 si un fichier nommé {fichier}
		existe et peut être enregistré. Si {fichier} n'existe pas ou
		n'est pas accessible en écriture, renvoie 0. Si {fichier} est
		un répertoire accessible en écriture, renvoie 2.

							*fnamemodify()*
fnamemodify({nomfich}, {mods})
		Modifie le nom du fichier {nomfich} selon {mods}. {mods} est
		une chaîne de caractères comme celles utilisées pour les noms
		de fichiers sur la ligne de commande. |filename-modifiers|
		Par exemple
			:echo fnamemodify("main.c", ":p:h")
		retourne :
			/home/mool/vim/vim/src ~
		NOTE : Les variables d'environnement et "~" ne sont pas
		reconnus dans {nomfich}, utilisez d'abord |expand()|.

							*foldclosed()*
foldclosed({nol})
		Renvoie un Nombre. Si la ligne {nol} est dans un repli fermé,
		renvoie le numéro de la première ligne de ce repli. Si la
		ligne {nol} n'est pas dans un repli fermé, renvoie -1.

							*foldclosedend()*
foldclosedend({nol})
		Renvoie un Nombre. Si la ligne {nol} est dans un repli fermé,
		renvoie le numéro de la dernière ligne de ce repli. Si la
		ligne {nol} n'est pas dans un repli fermé, renvoie -1.

							*foldlevel()*
foldlevel({nol})
		Renvoie un Nombre, qui correspond au niveau de repli de la
		ligne {nol} dans le tampon courant. Pour des replis imbriqués,
		renvoie le niveau le plus profond. S'il n'y a pas de repli à
		la ligne {nol}, renvoie zéro. Les replis peuvent être
		indépendamment fermés ou ouverts.
		Quand elle est utilisée lors de la mise à jour des replis
		(depuis 'foldexpr'), cette fonction renvoie -1 pour les lignes
		où les replis doivent encore être mis à jour et où le niveau
		de repli est inconnu.

							*foldtext()*
foldtext()	Renvoie une Chaîne, utilisée pour représenter un repli fermé.
		Cette fonction est utilisée par défaut pour l'option
		'foldtext', elle ne devrait normalement être appelée que lors
		de l'évaluation de cette option. Elle utilise les variables
		|v:foldstart|, |v:foldend| et |v:folddashes|.
		La chaîne retournée ressemble à ceci :
			+-- 45 lignes: abcdef ~
		Le nombre de tirets dépend du niveau du repli. "45" est le
		nombre de lignes dans le repli. "abcdef" est le texte de la
		première ligne non blanche du repli (les espaces blancs
		initiaux, "//" ou "/*" et le texte des options 'foldmarker' et
		'commentstring' sont supprimés).
		{uniquement si compilé avec la fonctionnalité |+folding|}

							*foreground()*
foreground()	Met la fenêtre Vim au premier plan. Utile pour envoyer d'un
		client à un serveur Vim. |remote_send()|
		Cela peut ne pas marcher sur des systèmes Win32, le SE
		n'autorisant pas toujours une fenêtre à passer d'elle-même au
		premier plan. Utilisez |remote_foreground()| à la place.
		{uniquement dans les versions IHM graphiques Win32, Athena,
		Motif et GTK+, ainsi que dans la version console Win32}

							*getchar()*
getchar([expr])	Attend un caractère simple de l'utilisateur. Si c'est un
		caractère 8-bits, cette fonction renvoie un Nombre. Sinon,
		elle renvoie une Chaîne égale au caractère donné. Pour une
		touche spéciale, il s'agit d'une séquence d'octets débutant
		par 0x80 (128 en décimal).
		- Si [expr] est omis, attend jusqu'à ce qu'un caractère soit
		  disponible.
		- Si [expr] vaut 0, ne prend un caractère que s'il y en a un
		  de disponible.
		- Si [expr] vaut 1, teste uniquement si un caractère est
		  disponible, mais ne le consomme pas. Si un caractère normal
		  est disponible, il est renvoyé ; sinon, une valeur non-nulle
		  est renvoyée.
		Si un caractère est disponible, il est retourné en tant que
		Nombre. Utilisez nr2char() pour le convertir en Chaîne.
		Inversement, pour transformer une Chaîne multi-octets en
		Nombre, utilisez ceci :
			:let c = getchar()
			:if c == 0
			:  let c = char2nr(c)
			:endif
		La valeur retournée est négative pour les touches spéciales.
		La valeur retournée est nulle si aucun caractère n'est
		disponible.
		Il n'y a pas d'invite, vous devrez donc faire apparaître
		clairement à l'utilisateur qu'un caractère doit être entré.
		Aucun mappage ne sera effectué pour le caractère.
		Les codes clavier sont remplacés : quand l'utilisateur presse
		la touche <Suppr>, le code de la touche <Suppr> est renvoyé,
		et non la séquence clavier brute. Exemples :
			getchar() == "\<Del>"
			getchar() == "\<S-Left>"
		Cet exemple redéfinit "f" pour ignorer la casse :
			:nmap f :call ChercheCar()<CR>
			:function ChercheCar()
			:  let c = nr2char(getchar())
			:  while col('.') < col('$') - 1
			:    normal l
			:    if getline('.')[col('.') - 1] ==? c
			:      break
			:    endif
			:  endwhile
			:endfunction

							*getcharmod()*
getcharmod()	Renvoie un Nombre, qui donne l'état des modificateurs pour le
		dernier caractère obtenu avec getchar() ou d'une autre
		manière. Ces valeurs sont ajoutées :
			2	maj
			4	contrôle
			8	alt (méta)
			16	double clic de la souris
			32	triple clic de la souris
			64	quadruple clic de la souris
			128	Macintosh uniquement : commande
		Seuls les modificateurs qui n'ont pas été inclus dans le
		caractère lui-même peuvent être obtenus. Par exemple, Maj + a
		donne 'A', sans modificateur.

							*getbufvar()*
getbufvar({expr}, {nomvar})
		Renvoie la valeur de l'option ou de la variable locale de
		tampon {nomvar} dans le tampon {expr}. NOTE : Le nom sans "b:"
		doit être utilisé.
		Cela marche aussi pour une option globale ou locale de
		fenêtre, mais pas pour une variable globale ou locale de
		fenêtre.
		Sur l'utilisation de {expr}, voir |bufname()| plus haut.
		Si le tampon ou la variable n'existe pas, renvoie une chaîne
		vide, sans émettre de message d'erreur.
		Exemples :
			:let tamponmodif = getbufvar(1, "&mod")
			:echo "nomfich mavar =" getbufvar("nomfich", "mavar")

							*getcwd()*
getcwd()	Renvoie une Chaîne, qui correspond au nom du répertoire de
		travail courant.

							*getfsize()*
getfsize({nomfich})
		Renvoie un Nombre, qui correspond à la taille en octets du
		fichier {nomfich}.
		Si {nomfich} est un répertoire, renvoie 0.
		Si le fichier {nomfich} ne peut pas être trouvé, renvoie -1.

							*getftime()*
getftime({nomfich})
		Renvoie un Nombre, qui correspond à la date de dernière
		modification du fichier {nomfich}. La valeur est mesurée en
		secondes écoulées depuis le 1er janvier 1970, et peut être
		passée à strftime(). Voir aussi |localtime()| et |strftime()|.
		Si le fichier {nomfich} ne peut pas être trouvé, renvoie -1.

							*getline()*
getline({nol})  Renvoie une Chaîne, correspondant à la ligne {nol} du tampon
		courant. Exemple :
			getline(1)
		Si {nol} est une Chaîne qui ne débute pas par un chiffre,
		line() est appelée pour traduire la Chaîne en Nombre.
		Pour obtenir la ligne sous le curseur :
			getline(".")
		Si {nol} est inférieur à 1 ou supérieur au nombre de lignes du
		tampon, renvoie une chaîne vide.

							*getreg()*
getreg([{nomreg}]
		Renvoie une Chaîne, correspondant au contenu du registre
		{nomreg}. Exemple :
			:let textepp = getreg('*')
		getreg('=') renvoie la dernière valeur évaluée du registre
		d'expression (utile dans les mappages).
		Si {nomreg} n'est pas spécifié, |v:register| est utilisé.

							*getregtype()*
getregtype([{nomreg}])
		Renvoie une Chaîne, correspondant au type du registre
		{nomreg}. Les valeurs possibles sont :
		    "v"		pour du texte par caractères |characterwise|
		    "V"		pour du texte par lignes |linewise|
		    "<CTRL-V>{larg}"
				pour du texte par blocs |blockwise-visual|
		    0		pour un registre vide ou inconnu
		<CTRL-V> désigne un caractère unique, de valeur 0x16.
		Si {nomreg} n'est pas spécifié, |v:register| est utilisé.

							*getwinposx()*
getwinposx()	Renvoie un Nombre, correspondant à la coordonnée X en pixels
		du côté gauche de la fenêtre IHM graphique Vim.
		Si l'information n'est pas disponible, renvoie -1.

							*getwinposy()*
getwinposy()	Renvoie un Nombre, correspondant à la coordonnée Y en pixels
		du sommet de la fenêtre IHM graphique Vim.
		Si l'information n'est pas disponible, renvoie -1.

							*getwinvar()*
getwinvar({no}, {nomvar})
		Renvoie la valeur de l'option ou de la variable locale de
		fenêtre {nomvar} dans la fenêtre {no}.
		Cela marche aussi pour une option globale ou locale de tampon,
		mais pas pour une variable globale ou locale de tampon.
		NOTE : Le nom sans "w:" doit être utilisé.
		Exemples :
			:let list_est_actif = getwinvar(2, '&list')
			:echo "mavar = " . getwinvar(1, 'mavar')

							*glob()*
glob({expr})	Étend les caractères d'englobement dans {expr}. Renvoie une
		Chaîne.
		S'il y a des correspondances multiples, elles sont séparées
		par des caractères <NL>.
		Si l'expansion échoue, renvoie une chaîne vide.
		Un nom de fichier inexistant n'est pas inclus.

		Sur la plupart des systèmes, des contre-apostrophes peuvent
		être utilisées pour obtenir des noms de fichiers depuis une
		commande externe. Exemple :
			:let fichmarqueur = glob("`find . -name tags -print`")
			:let &tags = substitute(fichmarqueur, "\n", ",", "g")
		La sortie du programme entre contre-apostrophes doit contenir
		un seul élément par ligne. Les espaces sont autorisés dans un
		élément.

		Voir |expand()| pour étendre des variables spéciales de Vim.
		Voir |system()| pour récupérer la sortie brute d'une commande
		externe.

							*globpath()*
globpath({chemin}, {expr})
		Effectue glob() dans tous les répertoires de {chemin} et
		concatène le résultat. Exemple :
			:echo globpath(&rtp, "syntax/c.vim")
		{chemin} est une liste de noms de répertoires séparés par des
		virgules. Chaque nom de répertoire est préfixé à {expr} et
		étendu comme avec glob(). Un séparateur de chemin est ajouté
		si nécessaire.
		Si l'expansion échoue pour un des répertoires, il n'y a pas de
		message d'erreur.
		L'option 'wildignore' s'applique : les noms correspondant à un
		des motifs de 'wildignore' seront sautés.

							*has()*
has({fctalite})	Renvoie un Nombre, qui vaut 1 si la fonctionnalité {fctalite}
		est supportée, zéro sinon. L'argument {fctalite} est une
		chaîne. Voir |feature-list| ci-dessous.

							*hasmapto()*
hasmapto({qqc} [, {mode}])
		Renvoie un Nombre, qui vaut 1 s'il existe un mappage qui
		contient {qqc} quelque part dans son côté droit (ce à quoi une
		séquence est mappée) et que ce mappage existe dans un des
		modes donnés par {mode}.
		Cette fonction teste les mappages globaux comme les mappages
		locaux au tampon courant.
		Si aucun mappage correspondant n'est trouvé, renvoie 0.
		Les caractères suivants sont reconnus dans {mode} :
			n	mode Normal
			v	mode Visuel
			o	mode Opérateur-en-cours
			i	mode Insertion
			l	mode Arg-lang ("r", "f", "t", etc.)
			c	mode Ligne-de-commande
		Si {mode} est omis, "nvo" est utilisé.

		Cette fonction est utile pour tester si un mappage à une
		fonction existe déjà dans un script Vim. Exemple :
			:if !hasmapto('\Choseafaire')
			:  map <Leader>d \Choseafaire
			:endif
		Ceci installe un mappage à "\Choseafaire" uniquement s'il
		n'existe pas déjà de mappage à "\Choseafaire".

							*histadd()*
histadd({histo}, {elem})
		Ajoute la Chaîne {elem} à l'historique {histo} qui peut
		prendre une des valeurs suivantes :
							*hist-names*
		    "cmd"    ou ":"	historique de la ligne de commande
		    "search" ou "/"	historique de la chaîne de recherche
		    "expr"   ou "="	historique du registre d'expression
		    "input"  ou "@"	historique de la ligne d'entrée
		Si {elem} existe déjà dans l'historique, il sera repositionné
		pour devenir l'entrée la plus récente.
		Renvoie un Nombre : 1 si l'opération s'est déroulée avec
		succès, 0 sinon.

		Exemple :
			:call histadd("input", strftime("%d %b %Y"))
			:let date = input("Entrez la date : ")
		Cette fonction n'est pas disponible dans le bac à sable
		|sandbox|.

							*histdel()*
histdel({histo} [, {elem}])
		Efface {histo}, c.-à-d. supprime toutes ses entrées. Voir
		|hist-names| pour les valeurs possibles de {histo}.

		Si l'argument {elem} est donné comme une Chaîne, il est
		traité en tant qu'expression rationnelle. Toutes les entrées
		correspondant à cette expression (s'il y en a) seront
		supprimées de l'historique. La casse doit correspondre, à
		moins que "\c" ne soit utilisé |/\c|.
		Si {elem} est un Nombre, il sera interprété comme un index,
		voir |:history-indexing|. L'entrée correspondante sera
		supprimée si elle existe.

		Renvoie un Nombre : 1 si l'opération s'est déroulée avec
		succès, 0 sinon.

		Exemples :
			:call histdel("expr")
				Efface l'historique du registre d'expression.
			:call histdel("/", '^\*')
				Supprime toutes les entrées débutant par "*"
				de l'historique de recherche.
			:call histdel("search", histnr("search"))
			:call histdel("search", -1)
			:call histdel("search", '^'.histget("search", -1).'$')
				Ces trois commandes sont équivalentes.
			:call histdel("search", -1)
			:let @/ = histget("search", -1)
				Supprime le dernier motif de recherche et
				utilise l'avant-dernier pour la commande "n"
				et 'hlsearch'.

							*histget()*
histget({histo} [, {index}])
		Renvoie une Chaîne, correspondant à l'entrée de numéro {index}
		dans {histo}. Voir |hist-names| pour les valeurs possibles de
		{histo} et |:history-indexing| pour {index}. S'il n'existe
		pas d'entrée correspondante, renvoie une Chaîne vide. Quand
		{index} est omis, l'élément le plus récent de l'historique est
		utilisé.

		Exemples :
			:execute '/' . histget("search", -2)
				Restaure l'avant-dernière recherche effectuée
				selon l'historique.
			:command -nargs=1 H execute histget("cmd", 0+<args>)
				Définit une commande Ex ":H {no}" qui effectue
				la réexécution de la {no}-ième entrée de la
				sortie de |:history|.

							*histnr()*
histnr({histo}) Renvoie un Nombre, qui correspond à l'entrée courante dans
		{histo}. Voir |hist-names| pour les valeurs possibles de
		{histo}.
		Si une erreur se produit, renvoie -1.

		Exemple :
			:let index_entr = histnr("expr")

							*hlexists()*
hlexists({nom})	Renvoie un Nombre, qui est non-nul si un groupe de
		surbrillance nommé {nom} existe. Ce groupe doit avoir été
		défini d'une façon ou d'une autre (pas uniquement quand une
		surbrillance a été définie pour lui, mais aussi quand il a été
		utilisé pour un élément de syntaxe).
							*highlight_exists()*
		Nom obsolète : highlight_exists().

							*hlID()*
hlID({nom})	Renvoie un Nombre, correspondant à l'ID du groupe de
		surbrillance de nom {nom}. Lorsque le groupe de surbrillance
		n'existe pas, renvoie zéro.
		Cela peut être utilisé pour extraire une information sur le
		groupe de surbrillance. Par exemple, pour obtenir la couleur
		de fond du groupe "Comment" :
			:echo synIDattr(synIDtrans(hlID("Comment")), "bg")
							*highlightID()*
		Nom obsolète : highlightID().

							*hostname()*
hostname()	Renvoie une Chaîne, qui correspond au nom de la machine sur
		laquelle Vim s'exécute actuellement. Les noms de machines
		d'une longueur supérieure à 256 caractères sont tronqués.

							*iconv()*
iconv({expr}, {de}, {a})
		Renvoie une Chaîne, qui correspond au texte {expr} converti de
		l'encodage {de} à l'encodage {a}.
		Quand la conversion échoue, renvoie une chaîne vide.
		Les noms d'encodages peuvent prendre toutes les valeurs
		acceptées par la fonction de bibliothèque iconv(), voir ":!man
		3 iconv".
		La plupart des conversions requièrent que Vim ait été compilé
		avec la fonctionnalité |+iconv|. Sans cela, seule la
		conversion UTF-8 -> Latin-1 et son contraire peuvent être
		effectuées.
		Cela peut être utilisé pour afficher des messages avec des
		caractères spéciaux, indépendamment de la valeur de
		'encoding'. Écrivez le message en UTF-8 et utilisez :
			:echo iconv(chaine_utf8, "utf-8", &enc)
		NOTE : Vim utilise UTF-8 pour tous les encodages Unicode, la
		conversion de/en UCS-2 est automatiquement changée pour
		utiliser UTF-8. Vous ne pouvez pas utiliser UCS-2 dans une
		chaîne de toute façon, à cause des octets NUL.
		{uniquement si compilé avec la fonctionnalité |+multi_byte|}

							*indent()*
indent({nol})	Renvoie un Nombre, correspondant à l'indentation de la ligne
		{nol} dans le tampon courant. L'indentation est comptée en
		espaces, la valeur de 'tabstop' est prise en compte. {nol} est
		traitée comme dans |getline()|.
		Si {nol} est invalide, renvoie -1.

							*input()*
input({invite} [, {texte}])
		Renvoie une Chaîne, qui correspond à tout ce que l'utilisateur
		peut saisir sur la ligne de commande. {invite} peut être soit
		une chaîne d'invite, soit une chaîne blanche (pas d'invite).
		"\n" peut être utilisé dans l'invite pour débuter une nouvelle
		ligne. La surbrillance fixée par |:echohl| est utilisée pour
		l'invite. La saisie est entrée exactement comme une ligne de
		commande, avec les mêmes commandes d'édition et mappages. Il
		existe un historique séparé pour les lignes tapées pour
		input().
		Si le {texte} optionnel est présent, il est utilisé comme
		réponse par défaut, comme si l'utilisateur l'avait saisi.
		NOTE : Cela ne doit pas être utilisé dans un fichier de
		démarrage, pour les versions qui fonctionnent uniquement en
		mode IHM graphique (p. ex., l'IHM graphique Win32).
		NOTE : Quand input() est appelé depuis un mappage, il
		consommera tous les caractères jusqu'à la fin du mappage, car
		un mappage est traité comme si les caractères étaient saisis.
		Utilisez |inputsave()| avant input() et |inputrestore()| après
		input() pour éviter cela. Une autre solution consiste à éviter
		que des caractères additionnels ne suivent dans le mappage,
		p. ex., en utilisant |:execute| ou |:normal|.

		Exemple :
			:if input("Bière ou café ? ") == "bière"
			:  echo "À votre santé !"
			:endif
		Exemple avec un texte par défaut :
			:let couleur = input("Couleur ? ", "blanc")
		Exemple avec un mappage :
			:nmap \x :call DonneMTF()<CR>:exe "/" . MTF<CR>
			:function DonneMTF()
			:  call inputsave()
			:  let g:MTF = input("Entrez un motif de recherche : ")
			:  call inputrestore()
			:endfunction

							*inputdialog()*
inputdialog({invite} [, {texte} [, {retourannul}]])
		Comme input(), mais lorsque l'IHM graphique est lancée et que
		les dialogues de texte sont supportés, une boîte de dialogue
		apparaît pour la saisie du texte.
		Exemple :
			:let n = inputdialog("valeur de shiftwidth", &sw)
			:if n != ""
			:  let &sw = n
			:endif
		Retourne {retourannul} quant le dialogue est annulé. Retourne
		une chaîne vide quand il est ignoré.
		Taper <Entree> revient à presser le bouton "OK". Taper <Echap>
		revient à presser le bouton "Cancel".

							*inputrestore()*
inputrestore()	Restaure une saisie antérieure sauvegardée à l'aide de
		inputsave(). Devrait être appelé autant de fois que
		inputsave() l'a été. Si cependant vous l'appelez un plus grand
		nombre de fois, cela sera sans conséquence.
		Retourne 1 quand il n'y a rien à restaurer, 0 sinon.

							*inputsave()*
inputsave()	Sauvegarde la saisie courante (mappages inclus) et l'efface
		afin qu'une nouvelle invite attende une saisie ultérieure de
		l'utilisateur. Devrait être suivi par un inputrestore()
		correspondant après l'invite. Peut être utilisé plusieurs
		fois, auquel cas il faut utiliser un nombre équivalent
		d'appels à inputrestore().
		Retourne 1 si la mémoire est insuffisante, 0 sinon.

							*inputsecret()*
inputsecret({invite} [, {texte}])
		Cette fonction se comporte comme la fonction |input()|, à deux
		exceptions près :
		1° La réponse de l'utilisateur sera affichée comme une
		   séquence d'étoiles ('*') afin de garder la saisie secrète ;
		2° La réponse de l'utilisateur ne sera pas enregistrée dans
		   l'historique de la ligne d'entrée |history|.
		Renvoie une Chaîne, qui correspond à tout ce que l'utilisateur
		a saisi sur la ligne de commande à la suite de l'invite
		proposée.

							*isdirectory()*
isdirectory({repertoire})
		Renvoie un Nombre, qui est non-nul quand un répertoire de
		nom {repertoire} existe. Si {repertoire} n'existe pas, ou
		n'est pas un répertoire, renvoie FAUX. {repertoire} peut être
		une expression quelconque, qui est utilisée en tant que
		Chaîne.

						*libcall()* *E364* *E368*
libcall({nombib}, {nomfonc}, {argument})
		Appelle la fonction {nomfonc} dans la bibliothèque de support
		{nombib} avec l'argument simple {argument}.
		C'est utile pour appeler les fonctions d'une bibliothèque que
		vous avez créée spécialement pour utiliser avec Vim. Comme un
		seul argument est autorisé, l'appel de fonctions de la
		bibliothèque standard est plutôt limité.
		Renvoie la Chaîne retournée par la fonction. Si la fonction
		retourne NUL, cela apparaîtra comme une chaîne vide "" pour
		Vim.
		Si la fonction retourne un Nombre, utilisez libcallnr() !
		Si {argument} est un Nombre, il est passé à la fonction en
		tant qu'entier ; si {argument} est une Chaîne, il est passé à
		la fonction en tant que chaîne terminée par NUL.
		Cette fonction échouera en mode restreint |restricted-mode|.

		libcall() vous permet d'écrire vos propres extensions à
		« greffer » dans Vim sans avoir à recompiler le programme. Il
		n'est PAS conçu pour appeler des fonctions système ! Si vous
		essayez malgré tout, Vim plantera très probablement.

		Pour Win32, les fonctions que vous écrivez doivent être
		placées dans un DLL et utiliser les conventions d'appel
		normales du C (PAS de Pascal, qui est utilisé dans les DLL
		système de Windows). La fonction doit accepter exactement un
		un paramètre, soit un pointeur de caractère, soit un entier
		long, et doit retourner un pointeur de caractère ou NUL. Le
		pointeur de caractère retourné doit pointer sur une zone de la
		mémoire qui restera valide après le retour de la fonction
		(p. ex., des données statiques dans le DLL). S'il pointe sur
		une zone de mémoire déjà allouée, une fuite de mémoire en
		découlera. L'utilisation d'un tampon statique dans la fonction
		devrait fonctionner, celui-ci est ensuite libéré lorsque le
		DLL est déchargé.

		ATTENTION ! Si la fonction retourne un pointeur non valide,
		Vim peut planter ! De même si la fonction retourne un Nombre,
		car Vim croit qu'il s'agit d'un pointeur.
		Pour les systèmes Win32, {nombib} devrait être le nom du
		fichier DLL sans le suffixe ".DLL". Le chemin complet n'est
		nécessaire que si le DLL n'est pas trouvé aux endroits
		habituels.
		Pour Unix : lorsque vous compilez vos propres greffons,
		n'oubliez pas que le code objet doit être compilé comme
		indépendant de la position ("PIC").
		{uniquement dans Win32 et sur certaines versions Unix, lorsque
		la fonctionnalité |+libcall| est présente}
		Exemples :
			:echo libcall("libc.so", "getenv", "HOME")
			:echo libcallnr("/usr/lib/libc.so", "getpid", "")

							*libcallnr()*
libcallnr({nombib}, {nomfonc}, {argument})
		Exactement comme libcall(), mais utilisé pour une fonction qui
		retourne un entier au lieu d'une chaîne.
		{uniquement dans Win32 et sur certaines versions Unix, lorsque
		la fonctionnalité |+libcall| est présente}
		Exemples (pas très utiles...) :
			:call libcallnr("libc.so", "printf", "Bonjour monde\n")
			:call libcallnr("libc.so", "sleep", 10)

							*line()*
line({expr})	Renvoie un Nombre, correspondant au numéro de ligne de la
		position dans le fichier donnée par {expr}. Les positions
		acceptées sont :
		    .	    la position du curseur
		    $	    la dernière ligne du tampon courant
		    'x	    la position de la marque x (si la marque n'est pas
			       fixée, 0 est renvoyé)
		NOTE : Seules les marques dans le fichier courant peuvent être
		utilisées. Exemples :
			line(".")		ligne du curseur
			line("'t")		ligne de la marque t
			line("'" . nommarque)	ligne de la marque nommarque
							*last-position-jump*
		Cette autocommande saute à la dernière position connue dans un
		fichier juste après son ouverture, quand la marque '" est
		fixée :
			:au BufReadPost *
			 \ if line("'\"") > 0 && line("'\"") <= line("$") |
			 \   exe "normal g'\"" |
			 \ endif

							*line2byte()*
line2byte({nol})
		Renvoie le numéro d'octet depuis le début du tampon de la
		ligne {nol}. Cela inclut le caractère fin-de-ligne, selon la
		valeur de l'option 'fileformat' pour le tampon courant. La
		première ligne renvoie 1.
		Cela peut aussi servir à obtenir le numéro d'octet de la ligne
		située juste en dessous de la dernière :
			line2byte(line("$") + 1)
		Ceci correspond à la taille du fichier plus un.
		Si {nol} est invalide ou que Vim n'a pas été compilé avec la
		fonctionnalité |+byte_offset|, renvoie -1.
		Voir aussi |byte2line()|, |go| et |:goto|.

							*lispindent()*
lispindent({nol})
		Renvoie un Nombre, correspondant à