vim: runtime/doc/eval.txt comparison

comparison runtime/doc/eval.txt @ 9422:f93704b11e43 v7.4.1992

commit https://github.com/vim/vim/commit/e381d3d5e098546854b008e01ca1d28ba1a4a057 Author: Bram Moolenaar <Bram@vim.org> Date: Thu Jul 7 14:50:41 2016 +0200 patch 7.4.1992 Problem: Values for true and false can be confusing. Solution: Update the documentation. Add a test. Make v:true evaluate to TRUE for a non-zero-arg.

author	Christian Brabandt <cb@256bit.org>
date	Thu, 07 Jul 2016 15:00:07 +0200
parents	cbf052ccb120
children	e70fd2eb3ae1

comparison

equal deleted inserted replaced

-:ce8891614a89
+:f93704b11e43
-*eval.txt*	For Vim version 7.4.  Last change: 2016 Jul 04
+*eval.txt*	For Vim version 7.4.  Last change: 2016 Jul 06
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
 <	64 ~
 To avoid a leading zero to cause octal conversion, or for using a different
 base, use |str2nr()|.
+							*TRUE* *FALSE*
 For boolean operators Numbers are used.  Zero is FALSE, non-zero is TRUE.
+You can also use |v:false| and |v:true|.  When TRUE is returned from a
-Note that in the command >
+function it is the Number one, FALSE is the number zero.
+Note that in the command: >
 	:if "foo"
-"foo" is converted to 0, which means FALSE.  To test for a non-empty string,
+	:" NOT executed
-use empty(): >
+"foo" is converted to 0, which means FALSE.  If the string starts with a
+non-zero number it means TRUE: >
+	:if "8foo"
+	:" executed
+To test for a non-empty string, use empty(): >
 	:if !empty("foo")
 <
+							*non-zero-arg*
+Function arguments often behave slightly different from |TRUE|: If the
+argument is present and it evaluates to a non-zero Number, |v:true| or a
+non-empty String, then the value is considere to be TRUE.
+Note that " " and "0" are also non-empty strings, thus cause the mode to be
+cleared.  A List, Dictionary or Float is not a Number or String, thus
+evaluates to FALSE.
 		*E745* *E728* *E703* *E729* *E730* *E731* *E908* *E910* *E913*
 List, Dictionary, Funcref and Job types are not automatically converted.
 							*E805* *E806* *E808*
 When mixing Number and Float the Number is converted to Float.	Otherwise
 -----
 expr2 ? expr1 : expr1
 The expression before the '?' is evaluated to a number.  If it evaluates to
-non-zero, the result is the value of the expression between the '?' and ':',
+|TRUE|, the result is the value of the expression between the '?' and ':',
 otherwise the result is the value of the expression after the ':'.
 Example: >
 	:echo lnum == 1 ? "top" : lnum
 Since the first expression is an "expr2", it cannot contain another ?:.  The
 					*expr-barbar* *expr-&&*
 The "||" and "&&" operators take one argument on each side.  The arguments
 are (converted to) Numbers.  The result is:
-	 input				 output ~
+input			 output ~
-n1		n2		n1 || n2	n1 && n2 ~
+n1	n2		n1 || n2	n1 && n2 ~
-zero		zero		zero		zero
+|FALSE|	|FALSE|		|FALSE|		|FALSE|
-zero		non-zero	non-zero	zero
+|FALSE|	|TRUE|		|TRUE|		|FALSE|
-non-zero	zero		non-zero	zero
+|TRUE|	|FALSE|		|TRUE|		|FALSE|
-non-zero	non-zero	non-zero	non-zero
+|TRUE|	|TRUE|		|TRUE|		|TRUE|
 The operators can be concatenated, for example: >
 	&nu || &list && &shell == "csh"
 arguments are not evaluated.  This is like what happens in C.  For example: >
 	let a = 1
 	echo a || b
-This is valid even if there is no variable called "b" because "a" is non-zero,
+This is valid even if there is no variable called "b" because "a" is |TRUE|,
-so the result must be non-zero.  Similarly below: >
+so the result must be |TRUE|.  Similarly below: >
 	echo exists("b") && b == "yes"
 This is valid whether "b" has been defined or not.  The second clause will
 only be evaluated if "b" has been defined.
 -----
 ! expr7			logical NOT		*expr-!*
 - expr7			unary minus		*expr-unary--*
 + expr7			unary plus		*expr-unary-+*
-For '!' non-zero becomes zero, zero becomes one.
+For '!' |TRUE| becomes |FALSE|, |FALSE| becomes |TRUE| (one).
 For '-' the sign of the number is changed.
 For '+' the number is unchanged.
 A String will be converted to a Number first.
 atan({expr})			Float	arc tangent of {expr}
 atan2({expr}, {expr})		Float   arc tangent of {expr1} / {expr2}
 browse({save}, {title}, {initdir}, {default})
 				String	put up a file requester
 browsedir({title}, {initdir})	String	put up a directory requester
-bufexists({expr})		Number	TRUE if buffer {expr} exists
+bufexists({expr})		Number	|TRUE| if buffer {expr} exists
-buflisted({expr})		Number	TRUE if buffer {expr} is listed
+buflisted({expr})		Number	|TRUE| if buffer {expr} is listed
-bufloaded({expr})		Number	TRUE if buffer {expr} is loaded
+bufloaded({expr})		Number	|TRUE| if buffer {expr} is loaded
 bufname({expr})			String	Name of the buffer {expr}
 bufnr({expr} [, {create}])	Number	Number of the buffer {expr}
 bufwinid({expr})		Number	window ID of buffer {expr}
 bufwinnr({expr})		Number	window number of buffer {expr}
 byte2line({byte})		Number	line number at byte count {byte}
 cursor({lnum}, {col} [, {off}])
 				Number	move cursor to {lnum}, {col}, {off}
 cursor({list})			Number	move cursor to position in {list}
 deepcopy({expr} [, {noref}])	any	make a full copy of {expr}
 delete({fname} [, {flags}])	Number	delete the file or directory {fname}
-did_filetype()			Number	TRUE if FileType autocommand event used
+did_filetype()			Number	|TRUE| if FileType autocmd event used
 diff_filler({lnum})		Number	diff filler lines about {lnum}
 diff_hlID({lnum}, {col})	Number	diff highlighting at {lnum}/{col}
-empty({expr})			Number	TRUE if {expr} is empty
+empty({expr})			Number	|TRUE| if {expr} is empty
 escape({string}, {chars})	String	escape {chars} in {string} with '\'
 eval({string})			any	evaluate {string} into its value
-eventhandler()			Number	TRUE if inside an event handler
+eventhandler()			Number	|TRUE| if inside an event handler
 executable({expr})		Number	1 if executable {expr} exists
 exepath({expr})			String  full path of the command {expr}
-exists({expr})			Number	TRUE if {expr} exists
+exists({expr})			Number	|TRUE| if {expr} exists
 extend({expr1}, {expr2} [, {expr3}])
 				List/Dict insert items of {expr2} into {expr1}
 exp({expr})			Float	exponential of {expr}
 expand({expr} [, {nosuf} [, {list}]])
 				any	expand special keywords in {expr}
 feedkeys({string} [, {mode}])	Number	add key sequence to typeahead buffer
-filereadable({file})		Number	TRUE if {file} is a readable file
+filereadable({file})		Number	|TRUE| if {file} is a readable file
-filewritable({file})		Number	TRUE if {file} is a writable file
+filewritable({file})		Number	|TRUE| if {file} is a writable file
 filter({expr}, {string})	List/Dict  remove items from {expr} where
 					{string} is 0
 finddir({name}[, {path}[, {count}]])
 				String	find directory {name} in {path}
 findfile({name}[, {path}[, {count}]])
 glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])
 				any	expand file wildcards in {expr}
 glob2regpat({expr})		String  convert a glob pat into a search pat
 globpath({path}, {expr} [, {nosuf} [, {list} [, {alllinks}]]])
 				String	do glob({expr}) for all dirs in {path}
-has({feature})			Number	TRUE if feature {feature} supported
+has({feature})			Number	|TRUE| if feature {feature} supported
-has_key({dict}, {key})		Number	TRUE if {dict} has entry {key}
+has_key({dict}, {key})		Number	|TRUE| if {dict} has entry {key}
 haslocaldir([{winnr} [, {tabnr}]])
-				Number	TRUE if the window executed |:lcd|
+				Number	|TRUE| if the window executed |:lcd|
 hasmapto({what} [, {mode} [, {abbr}]])
-				Number	TRUE if mapping to {what} exists
+				Number	|TRUE| if mapping to {what} exists
 histadd({history}, {item})	String	add an item to a history
 histdel({history} [, {item}])	String	remove an item from a history
 histget({history} [, {index}])	String	get the item {index} from a history
 histnr({history})		Number	highest index of a history
-hlexists({name})		Number	TRUE if highlight group {name} exists
+hlexists({name})		Number	|TRUE| if highlight group {name} exists
 hlID({name})			Number	syntax ID of highlight group {name}
 hostname()			String	name of the machine Vim is running on
 iconv({expr}, {from}, {to})	String	convert encoding of {expr}
 indent({lnum})			Number	indent of line {lnum}
 index({list}, {expr} [, {start} [, {ic}]])
 inputrestore()			Number	restore typeahead
 inputsave()			Number	save and clear typeahead
 inputsecret({prompt} [, {text}]) String  like input() but hiding the text
 insert({list}, {item} [, {idx}]) List	insert {item} in {list} [before {idx}]
 invert({expr})			Number  bitwise invert
-isdirectory({directory})	Number	TRUE if {directory} is a directory
+isdirectory({directory})	Number	|TRUE| if {directory} is a directory
-islocked({expr})		Number	TRUE if {expr} is locked
+islocked({expr})		Number	|TRUE| if {expr} is locked
-isnan({expr})			Number  TRUE if {expr} is NaN
+isnan({expr})			Number  |TRUE| if {expr} is NaN
 items({dict})			List	key-value pairs in {dict}
 job_getchannel({job})		Channel	get the channel handle for {job}
 job_info({job})			Dict	get information about {job}
 job_setoptions({job}, {options}) none	set options for {job}
 job_start({command} [, {options}])
 		|v:errors| when {pattern} matches {actual}.
 assert_true({actual} [, {msg}])					*assert_true()*
 		When {actual} is not true an error message is added to
 		|v:errors|, like with |assert_equal()|.
-		A value is true when it is a non-zero number.  When {actual}
+		A value is TRUE when it is a non-zero number.  When {actual}
 		is not a number the assert fails.
 		When {msg} is omitted an error in the form "Expected True but
 		got {actual}" is produced.
 asin({expr})						*asin()*
 							*browse()*
 browse({save}, {title}, {initdir}, {default})
 		Put up a file requester.  This only works when "has("browse")"
-		returns non-zero (only in some GUI versions).
+		returns |TRUE| (only in some GUI versions).
 		The input fields are:
-		    {save}	when non-zero, select file to write
+		    {save}	when |TRUE|, select file to write
 		    {title}	title for the requester
 		    {initdir}	directory to start browsing in
 		    {default}	default file name
 		When the "Cancel" button is hit, something went wrong, or
 		browsing is not possible, an empty string is returned.
 							*browsedir()*
 browsedir({title}, {initdir})
 		Put up a directory requester.  This only works when
-		"has("browse")" returns non-zero (only in some GUI versions).
+		"has("browse")" returns |TRUE| (only in some GUI versions).
 		On systems where a directory browser is not supported a file
 		browser is used.  In that case: select a file in the directory
 		to be used.
 		The input fields are:
 		    {title}	title for the requester
 		    {initdir}	directory to start browsing in
 		When the "Cancel" button is hit, something went wrong, or
 		browsing is not possible, an empty string is returned.
 bufexists({expr})					*bufexists()*
-		The result is a Number, which is non-zero if a buffer called
+		The result is a Number, which is |TRUE| if a buffer called
 		{expr} exists.
 		If the {expr} argument is a number, buffer numbers are used.
 		If the {expr} argument is a string it must match a buffer name
 		exactly.  The name can be:
 		- Relative to the current directory.
 		file name.
 							*buffer_exists()*
 		Obsolete name: buffer_exists().
 buflisted({expr})					*buflisted()*
-		The result is a Number, which is non-zero if a buffer called
+		The result is a Number, which is |TRUE| if a buffer called
 		{expr} exists and is listed (has the 'buflisted' option set).
 		The {expr} argument is used like with |bufexists()|.
 bufloaded({expr})					*bufloaded()*
-		The result is a Number, which is non-zero if a buffer called
+		The result is a Number, which is |TRUE| if a buffer called
 		{expr} exists and is loaded (shown in a window or hidden).
 		The {expr} argument is used like with |bufexists()|.
 bufname({expr})						*bufname()*
 		The result is the name of a buffer, as it is displayed by the
 		the same as one item in the list that 'omnifunc' would return.
 complete_check()				*complete_check()*
 		Check for a key typed while looking for completion matches.
 		This is to be used when looking for matches takes some time.
-		Returns non-zero when searching for matches is to be aborted,
+		Returns |TRUE| when searching for matches is to be aborted,
 		zero otherwise.
 		Only to be used by the function specified with the
 		'completefunc' option.
 						*confirm()*
 count({comp}, {expr} [, {ic} [, {start}]])			*count()*
 		Return the number of times an item with value {expr} appears
 		in |List| or |Dictionary| {comp}.
 		If {start} is given then start with the item with this index.
 		{start} can only be used with a |List|.
-		When {ic} is given and it's non-zero then case is ignored.
+		When {ic} is given and it's |TRUE| then case is ignored.
 							*cscope_connection()*
 cscope_connection([{num} , {dbpath} [, {prepend}]])
 		Checks for the existence of a |cscope| connection.  If no
 		Use |remove()| to delete an item from a |List|.
 		To delete a line from the buffer use |:delete|.  Use |:exe|
 		when the line number is in a variable.
 							*did_filetype()*
-did_filetype()	Returns non-zero when autocommands are being executed and the
+did_filetype()	Returns |TRUE| when autocommands are being executed and the
 		FileType event has been triggered at least once.  Can be used
 		to avoid triggering the FileType event again in the scripts
 		that detect the file type. |FileType|
 		When editing another file, the counter is reset, thus this
 		really checks if the FileType event has been triggered for the
 			echo exepath(v:progpath)
 <		If {expr} cannot be found in $PATH or is not executable then
 		an empty string is returned.
 							*exists()*
-exists({expr})	The result is a Number, which is non-zero if {expr} is
+exists({expr})	The result is a Number, which is |TRUE| if {expr} is
 		defined, zero otherwise.  The {expr} argument is a string,
 		which contains one of these:
 			&option-name	Vim option (only checks if it exists,
 					not if it really works)
 			+option-name	Vim option that works.
 expand({expr} [, {nosuf} [, {list}]])				*expand()*
 		Expand wildcards and the following special keywords in {expr}.
 		'wildignorecase' applies.
-		If {list} is given and it is non-zero, a List will be returned.
+		If {list} is given and it is |TRUE|, a List will be returned.
 		Otherwise the result is a String and when there are several
 		matches, they are separated by <NL> characters.  [Note: in
 		version 5.0 a space was used, which caused problems when a
 		file name contains a space]
 		'/' added.
 		When {expr} does not start with '%', '#' or '<', it is
 		expanded like a file name is expanded on the command line.
 		'suffixes' and 'wildignore' are used, unless the optional
-		{nosuf} argument is given and it is non-zero.
+		{nosuf} argument is given and it is |TRUE|.
 		Names for non-existing files are included.  The "**" item can
 		be used to search in a directory tree.  For example, to find
 		all "README" files in the current directory and below: >
 			:echo expand("**/README")
 <
 			a little later.  Useful for testing CursorHoldI.
 		Return value is always 0.
 filereadable({file})					*filereadable()*
-		The result is a Number, which is TRUE when a file with the
+		The result is a Number, which is |TRUE| when a file with the
 		name {file} exists, and can be read.  If {file} doesn't exist,
-		or is a directory, the result is FALSE.  {file} is any
+		or is a directory, the result is |FALSE|.  {file} is any
 		expression, which is used as a String.
 		If you don't care about the file being readable you can use
 		|glob()|.
 							*file_readable()*
 		Obsolete name: file_readable().
 		|literal-string| to avoid having to double backslashes.
 		If {expr2} is a |Funcref| it must take two arguments:
 			1. the key or the index of the current item.
 			2. the value of the current item.
-		The function must return TRUE if the item should be kept.
+		The function must return |TRUE| if the item should be kept.
 		Example that keeps the odd items of a list: >
 			func Odd(idx, val)
 			  return a:idx % 2 == 1
 			endfunc
 			call filter(mylist, function('Odd'))
 		list item is a dictionary with these entries:
 			bufnr	number of buffer that has the file name, use
 				bufname() to get the name
 			lnum	line number in the buffer (first line is 1)
 			col	column number (first column is 1)
-			vcol	non-zero: "col" is visual column
+			vcol	|TRUE|: "col" is visual column
-				zero: "col" is byte index
+				|FALSE|: "col" is byte index
 			nr	error number
 			pattern	search pattern used to locate the error
 			text	description of the error
 			type	type of the error, 'E', '1', etc.
-			valid	non-zero: recognized error message
+			valid	|TRUE|: recognized error message
 		When there is no error list or it's empty an empty list is
 		returned. Quickfix list entries with non-existing buffer
 		number are returned with "bufnr" set to zero.
 		register.  (For use in maps.)
 		getreg('=', 1) returns the expression itself, so that it can
 		be restored with |setreg()|.  For other registers the extra
 		argument is ignored, thus you can always give it.
-		If {list} is present and non-zero, the result type is changed
+		If {list} is present and |TRUE|, the result type is changed
 		to |List|. Each list item is one text line. Use it if you care
 		about zero bytes possibly present inside register: without
 		third argument both NLs and zero bytes are represented as NLs
 		(see |NL-used-for-Nul|).
 		When the register was not set an empty list is returned.
 <
 glob({expr} [, {nosuf} [, {list} [, {alllinks}]]])		*glob()*
 		Expand the file wildcards in {expr}.  See |wildcards| for the
 		use of special characters.
-		Unless the optional {nosuf} argument is given and is non-zero,
+		Unless the optional {nosuf} argument is given and is |TRUE|,
 		the 'suffixes' and 'wildignore' options apply: Names matching
 		one of the patterns in 'wildignore' will be skipped and
 		'suffixes' affect the ordering of matches.
 		'wildignorecase' always applies.
-		When {list} is present and it is non-zero the result is a List
+		When {list} is present and it is |TRUE| the result is a List
 		with all matching files. The advantage of using a List is,
 		you also get filenames containing newlines correctly.
 		Otherwise the result is a String and when there are several
 		matches, they are separated by <NL> characters.
 		If the expansion fails, the result is an empty String or List.
 		A name for a non-existing file is not included.  A symbolic
 		link is only included if it points to an existing file.
 		However, when the {alllinks} argument is present and it is
-		non-zero then all symbolic links are included.
+		|TRUE| then all symbolic links are included.
 		For most systems backticks can be used to get files names from
 		any external command.  Example: >
 			:let tagfiles = glob("`find . -name tags -print`")
 			:let &tags = substitute(tagfiles, "\n", ",", "g")
 		backslash.  Note that on MS-Windows a directory may have a
 		trailing backslash, remove it if you put a comma after it.
 		If the expansion fails for one of the directories, there is no
 		error message.
-		Unless the optional {nosuf} argument is given and is non-zero,
+		Unless the optional {nosuf} argument is given and is |TRUE|,
 		the 'suffixes' and 'wildignore' options apply: Names matching
 		one of the patterns in 'wildignore' will be skipped and
 		'suffixes' affect the ordering of matches.
-		When {list} is present and it is non-zero the result is a List
+		When {list} is present and it is |TRUE| the result is a List
 		with all matching files. The advantage of using a List is, you
 		also get filenames containing newlines correctly. Otherwise
 		the result is a String and when there are several matches,
 		they are separated by <NL> characters.  Example: >
 			:echo globpath(&rtp, "syntax/c.vim", 0, 1)
 hasmapto({what} [, {mode} [, {abbr}]])			*hasmapto()*
 		The result is a Number, which is 1 if there is a mapping that
 		contains {what} in somewhere in the rhs (what it is mapped to)
 		and this mapping exists in one of the modes indicated by
 		{mode}.
-		When {abbr} is there and it is non-zero use abbreviations
+		When {abbr} is there and it is |TRUE| use abbreviations
 		instead of mappings.  Don't forget to specify Insert and/or
 		Command-line mode.
 		Both the global mappings and the mappings local to the current
 		buffer are checked for a match.
 		If no matching mapping is found 0 is returned.
 		the String "4" is different from the Number 4.  And the number
 		4 is different from the Float 4.0.  The value of 'ignorecase'
 		is not used here, case always matters.
 		If {start} is given then start looking at the item with index
 		{start} (may be negative for an item relative to the end).
-		When {ic} is given and it is non-zero, ignore case.  Otherwise
+		When {ic} is given and it is |TRUE|, ignore case.  Otherwise
 		case must match.
 		-1 is returned when {expr} is not found in {list}.
 		Example: >
 			:let idx = index(words, "the")
 			:if index(numbers, 123) >= 0
 		Bitwise invert.  The argument is converted to a number.  A
 		List, Dict or Float argument causes an error.  Example: >
 			:let bits = invert(bits)
 isdirectory({directory})				*isdirectory()*
-		The result is a Number, which is non-zero when a directory
+		The result is a Number, which is |TRUE| when a directory
 		with the name {directory} exists.  If {directory} doesn't
-		exist, or isn't a directory, the result is FALSE.  {directory}
+		exist, or isn't a directory, the result is |FALSE|.  {directory}
 		is any expression, which is used as a String.
 islocked({expr})					*islocked()* *E786*
-		The result is a Number, which is non-zero when {expr} is the
+		The result is a Number, which is |TRUE| when {expr} is the
 		name of a locked variable.
 		{expr} must be the name of a variable, |List| item or
 		|Dictionary| entry, not the variable itself!  Example: >
 			:let alist = [0, ['a', 'b'], 2, 3]
 			:lockvar 1 alist
 <		When {expr} is a variable that does not exist you get an error
 		message.  Use |exists()| to check for existence.
 isnan({expr})						*isnan()*
-		Return non-zero if {expr} is a float with value NaN. >
+		Return |TRUE| if {expr} is a float with value NaN. >
 			echo isnan(0.0 / 0.0)
 <			1 ~
 		{only available when compiled with the |+float| feature}
 			"x"	Visual
 			"l"	langmap |language-mapping|
 			""	Normal, Visual and Operator-pending
 		When {mode} is omitted, the modes for "" are used.
-		When {abbr} is there and it is non-zero use abbreviations
+		When {abbr} is there and it is |TRUE| use abbreviations
 		instead of mappings.
-		When {dict} is there and it is non-zero return a dictionary
+		When {dict} is there and it is |TRUE| return a dictionary
 		containing all the information of the mapping with the
 		following items:
 		  "lhs"	     The {lhs} of the mapping.
 		  "rhs"	     The {rhs} of the mapping as typed.
 		  "silent"   1 for a |:map-silent| mapping, else 0.
 mapcheck({name}[, {mode} [, {abbr}]])			*mapcheck()*
 		Check if there is a mapping that matches with {name} in mode
 		{mode}.  See |maparg()| for {mode} and special names in
 		{name}.
-		When {abbr} is there and it is non-zero use abbreviations
+		When {abbr} is there and it is |TRUE| use abbreviations
 		instead of mappings.
 		A match happens with a mapping that starts with {name} and
 		with a mapping which is equal to the start of {name}.
 			matches mapping "a"	"ab"	"abc" ~
 <
 							*mode()*
 mode([expr])	Return a string that indicates the current mode.
 		If [expr] is supplied and it evaluates to a non-zero Number or
 		a non-empty String (|non-zero-arg|), then the full mode is
-		returned, otherwise only the first letter is returned.  Note
+		returned, otherwise only the first letter is returned.
-		that " " and "0" are also non-empty strings.
 			n	Normal
 			no	Operator-pending
 			v	Visual by character
 			V	Visual by line
 shellescape({string} [, {special}])			*shellescape()*
 		Escape {string} for use as a shell command argument.
 		On MS-Windows and MS-DOS, when 'shellslash' is not set, it
 		will enclose {string} in double quotes and double all double
 		quotes within {string}.
-		For other systems, it will enclose {string} in single quotes
+		Otherwise it will enclose {string} in single quotes and
-		and replace all "'" with "'\''".
+		replace all "'" with "'\''".
 		When the {special} argument is present and it's a non-zero
 		Number or a non-empty String (|non-zero-arg|), then special
 		items such as "!", "%", "#" and "<cword>" will be preceded by
 		a backslash.  This backslash will be removed again by the |:!|
 		command.
 					*test_disable_char_avail()*
 test_disable_char_avail({expr})
 		When {expr} is 1 the internal char_avail() function will
-		return FALSE.  When {expr} is 0 the char_avail() function will
+		return |FALSE|.  When {expr} is 0 the char_avail() function will
 		function normally.
 		Only use this for a test where typeahead causes the test not
 		to work.  E.g., to trigger the CursorMovedI autocommand event.
 test_garbagecollect_now()			 *test_garbagecollect_now()*
 <		This enters the same Visual mode as before.  It is also useful
 		in scripts if you wish to act differently depending on the
 		Visual mode that was used.
 		If Visual mode is active, use |mode()| to get the Visual mode
 		(e.g., in a |:vmap|).
-							*non-zero-arg*
 		If [expr] is supplied and it evaluates to a non-zero Number or
 		a non-empty String, then the Visual mode will be cleared and
-		the old value is returned.  Note that " " and "0" are also
+		the old value is returned.  See |non-zero-arg|.
-		non-empty strings, thus cause the mode to be cleared.  A List,
-		Dictionary or Float is not a Number or String, thus does not
-		cause the mode to be cleared.
 wildmenumode()					*wildmenumode()*
-		Returns non-zero when the wildmenu is active and zero
+		Returns |TRUE| when the wildmenu is active and |FALSE|
 		otherwise.  See 'wildmenu' and 'wildmode'.
 		This can be used in mappings to handle the 'wildcharm' option
 		gracefully. (Makes only sense with |mapmode-c| mappings).
 		For example to make <c-j> work like <down> in wildmode, use: >

Mercurial > vim

comparison runtime/doc/eval.txt @ 9422:f93704b11e43 v7.4.1992