vim: runtime/doc/eval.txt comparison

comparison runtime/doc/eval.txt @ 27459:5825405e4e2c

Update runtime files Commit: https://github.com/vim/vim/commit/f10911e5db16f1fe6ab519c5d091ad0c1df0d063 Author: Bram Moolenaar <Bram@vim.org> Date: Sat Jan 29 22:20:48 2022 +0000 Update runtime files

author	Bram Moolenaar <Bram@vim.org>
date	Sat, 29 Jan 2022 23:30:04 +0100
parents	3649b5a6b1b6
children	063952f68595

comparison

equal deleted inserted replaced

-:2a7fc102cb91
+:5825405e4e2c
-*eval.txt*	For Vim version 8.2.  Last change: 2022 Jan 21
+*eval.txt*	For Vim version 8.2.  Last change: 2022 Jan 24
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
 ==============================================================================
 1. Variables						*variables*
 1.1 Variable types ~
-						*E712* *E896* *E897* *E899*
+					*E712* *E896* *E897* *E899* *E1098*
+					*E1107* *E1135* *E1138*
 There are ten types of variables:
 							*Number* *Integer*
 Number		A 32 or 64 bit signed number.  |expr-number|
 		The number of bits is available in |v:numbersize|.
 						*no-type-checking*
 You will not get an error if you try to change the type of a variable.
 1.2 Function references ~
-						*Funcref* *E695* *E718*
+					*Funcref* *E695* *E718* *E1086*
 A Funcref variable is obtained with the |function()| function, the |funcref()|
 function or created with the lambda expression |expr-lambda|.  It can be used
 in an expression in the place of a function name, before the parenthesis
 around the arguments, to invoke the function it refers to.  Example: >
 In legacy script it is possible to form a variable name with curly braces, see
 |curly-braces-names|.
 ==============================================================================
 2. Expression syntax					*expression-syntax*
+							*E1143*
 Expression syntax summary, from least to most significant:
 |expr1|	expr2
 	expr2 ? expr1 : expr1	if-then-else
 "..." indicates that the operations in this level can be concatenated.
 Example: >
 	&nu || &list && &shell == "csh"
 All expressions within one level are parsed from left to right.
+Expression nesting is limited to 1000 levels deep (300 when build with MSVC)
+to avoid running out of stack and crashing. *E1169*
 expr1				*expr1* *trinary* *falsy-operator* *??* *E109*
 -----
 Note that the dot is also used for String concatenation.  To avoid confusion
 always put spaces around the dot for String concatenation.
-expr9(expr1, ...)	|Funcref| function call
+expr9(expr1, ...)	|Funcref| function call  	*E1085*
 When expr9 is a |Funcref| type variable, invoke the function it refers to.
 expr9->name([args])	method call			*method* *->*
 	:echo expand("$shell")
 The first one probably doesn't echo anything, the second echoes the $shell
 variable (if your shell supports it).
-internal variable				*expr-variable* *E1015*
+internal variable			*expr-variable* *E1015* *E1089*
 -----------------
 variable		internal variable
 See below |internal-variables|.
 			To be able to define a function inside an `:execute`
 			command, use line breaks instead of |:bar|: >
 				:exe "func Foo()\necho 'foo'\nendfunc"
 <
-				*:delf* *:delfunction* *E131* *E933*
+				*:delf* *:delfunction* *E131* *E933* *E1084*
 :delf[unction][!] {name}
 			Delete function {name}.
 			{name} can also be a |Dictionary| entry that is a
 			|Funcref|: >
 				:delfunc dict.init
 :retu[rn] [expr]	Return from a function.  When "[expr]" is given, it is
 			evaluated and returned as the result of the function.
 			If "[expr]" is not given, the number 0 is returned.
 			When a function ends without an explicit ":return",
 			the number 0 is returned.
-			Note that there is no check for unreachable lines,
+			In a :def function *E1095* is given if unreachable
-			thus there is no warning if commands follow ":return".
+			code follows after the `:return`.
+			In legacy script there is no check for unreachable
+			lines, thus there is no warning if commands follow
+			`:return`.
 			If the ":return" is used after a |:try| but before the
 			matching |:finally| (if present), the commands
 			following the ":finally" up to the matching |:endtry|
 			are executed first.  This process applies to all
 arguments an argument "..." can be specified, which means that more arguments
 may optionally be following.  In the function the extra arguments can be used
 as "a:1", "a:2", etc.  "a:0" is set to the number of extra arguments (which
 can be 0).  "a:000" is set to a |List| that contains these arguments.  Note
 that "a:1" is the same as "a:000[0]".
-								*E742*
+							*E742* *E1090*
 The a: scope and the variables in it cannot be changed, they are fixed.
 However, if a composite type is used, such as |List| or |Dictionary| , you can
 change their contents.  Thus you can pass a |List| to a function and have the
 function add an item to it.  If you want to make sure the function cannot
 change a |List| or |Dictionary| use |:lockvar|.
 			Set internal variable {var-name} to the result of the
 			expression {expr1}.  The variable will get the type
 			from the {expr}.  If {var-name} didn't exist yet, it
 			is created.
-:let {var-name}[{idx}] = {expr1}			*E689*
+:let {var-name}[{idx}] = {expr1}			*E689* *E1141*
 			Set a list item to the result of the expression
 			{expr1}.  {var-name} must refer to a list and {idx}
 			must be a valid index in that list.  For nested list
 			the index can be repeated.
 			This cannot be used to add an item to a |List|.
 :let &g:{option-name} .= {expr1}
 :let &g:{option-name} += {expr1}
 :let &g:{option-name} -= {expr1}
 			Like above, but only set the global value of an option
 			(if there is one).  Works like |:setglobal|.
+								*E1093*
 :let [{name1}, {name2}, ...] = {expr1}		*:let-unpack* *E687* *E688*
 			{expr1} must evaluate to a |List|.  The first item in
 			the list is assigned to {name1}, the second item to
 			{name2}, etc.
 			The number of names must match the number of items in
 :let [{name}, ..., ; {lastname}] -= {expr1}
 			Like above, but append/add/subtract the value for each
 			|List| item.
 						*:let=<<* *:let-heredoc*
-						*E990* *E991* *E172* *E221*
+					*E990* *E991* *E172* *E221* *E1145*
 :let {var-name} =<< [trim] {endmarker}
 text...
 text...
 {endmarker}
 			Set internal variable {var-name} to a |List|
 			it can no longer be changed (until it is unlocked).
 			A locked variable can be deleted: >
 				:lockvar v
 				:let v = 'asdf'	  " fails!
 				:unlet v	  " works
-<							*E741* *E940*
+<			*E741* *E940* *E1118* *E1119* *E1120* *E1121* *E1122*
 			If you try to change a locked variable you get an
 			error message: "E741: Value is locked: {name}".
 			If you try to lock or unlock a built-in variable you
 			get an error message: "E940: Cannot lock or unlock
 			variable {name}".
 			When {object} is a |Blob|, Vim always makes a copy to
 			iterate over.  Unlike with |List|, modifying the
 			|Blob| does not affect the iteration.
 :for [{var1}, {var2}, ...] in {listlist}
-:endfo[r]
+:endfo[r]							*E1140*
 			Like ":for" above, but each item in {listlist} must be
 			a list, of which each item is assigned to {var1},
 			{var2}, etc.  Example: >
 				:for [lnum, col] in [[1, 3], [2, 5], [3, 8]]
 				   :echo getline(lnum)[col]
 			|:try| and the ":finally" is left:  either by falling
 			through to the ":finally" or by a |:continue|,
 			|:break|, |:finish|, or |:return|, or by an error or
 			interrupt or exception (see |:throw|).
-							*:th* *:throw* *E608*
+						*:th* *:throw* *E608* *E1129*
 :th[row] {expr1}	The {expr1} is evaluated and thrown as an exception.
 			If the ":throw" is used after a |:try| but before the
 			first corresponding |:catch|, commands are skipped
 			until the first ":catch" matching {expr1} is reached.
 			If there is no such ":catch" or if the ":throw" is

Mercurial > vim

comparison runtime/doc/eval.txt @ 27459:5825405e4e2c