Lines Matching full:in
51 Lua is implemented as a library, written in <em>clean C</em>,
57 it only works <em>embedded</em> in a host client,
73 as stated in its license.
74 The implementation described in this manual is available
80 this document is dry in places.
83 For a detailed introduction to programming in Lua,
84 see Roberto's book, <em>Programming in Lua</em>.
101 There are no type definitions in the language.
106 All values in Lua are <em>first-class values</em>.
107 This means that all values can be stored in variables,
112 There are eight basic types in Lua:
125 which, in turn, usually follows the IEEE 754 standard.
138 Lua can call (and manipulate) functions written in Lua and
139 functions written in C
145 be stored in Lua variables.
150 Userdata has no predefined operations in Lua,
155 Userdata values cannot be created or modified in Lua,
182 Tables are the sole data structuring mechanism in Lua;
188 There are several convenient ways to create tables in Lua
202 In particular,
210 the definition of raw equality in the language.
237 As will be discussed in <a href="#3.2">§3.2</a> and <a href="#3.3.3">§3.3.3</a>,
240 Moreover, every chunk is compiled in the scope of
242 so <code>_ENV</code> itself is never a global name in a chunk.
249 In particular,
252 visible at that point in the program,
262 This value is kept at a special index in the C registry (see <a href="#4.5">§4.5</a>).
263 In Lua, the variable <a href="#pdf-_G"><code>_G</code></a> is initialized with this same value.
271 global variables in Lua code refer to entries in the global environment.
272 Moreover, all standard libraries are loaded in the global environment
276 (In C, you have to load the chunk and then change the value
281 If you change the global environment in the registry
285 as each has its own reference to the environment in its <code>_ENV</code> variable.
287 (which is stored in the original global environment)
298 all Lua actions start from C code in the host program
310 If you need to catch errors in Lua,
312 to call a given function in <em>protected mode</em>.
327 to be called in case of errors.
345 Every value in Lua can have a <em>metatable</em>.
350 of operations over a value by setting specific fields in its metatable.
352 Lua checks for a function in the field "<code>__add</code>" of the value's metatable.
358 The keys in a metatable are derived from the <em>event</em> names;
360 In the previous example, the event is <code>"add"</code>
388 A metatable controls how an object behaves in arithmetic operations,
410 The code shown here in Lua is only illustrative;
411 the real behavior is hard coded in the interpreter
413 All functions used in these descriptions
415 are described in <a href="#6.1">§6.1</a>.
416 In particular, to retrieve the metamethod of a given object,
429 (it simply results in <b>nil</b>).
436 it may be removed in future versions and therefore it is not present
437 in the following code.
671 Note that, in the absence of a "le" metamethod,
684 when <code>key</code> is not present in <code>table</code>.
716 when <code>key</code> is not present in <code>table</code>.
796 A value of 200 means that the collector waits for the total memory in use
807 can result in the collector never finishing a cycle.
819 the collector behaves as in old Lua versions,
825 You can change these numbers by calling <a href="#lua_gc"><code>lua_gc</code></a> in C
826 or <a href="#pdf-collectgarbage"><code>collectgarbage</code></a> in Lua.
832 As an experimental feature in Lua 5.2,
867 and later create that field in the metatable,
876 Instead, Lua puts it in a list.
879 for each object in that list:
892 the finalizers for objects are called in
894 among those collected in that cycle;
896 with the object marked last in the program.
906 and the object memory is freed in the next garbage-collection cycle.
907 However, if the finalizer stores the object in some global place
910 In any case,
932 In other words,
943 In any case, if either the key or the value is collected,
948 the keys in the table are weak.
950 the values in the table are weak.
956 In an ephemeron table,
958 In particular,
964 Any change in the weakness of a table may take effect only
966 In particular, if you change the weakness to a stronger mode,
987 have a special behavior in weak tables.
989 but are removed from weak keys only in the next collection
996 If a weak table is among the resurrected objects in a collection cycle,
1010 A coroutine in Lua represents an independent thread of execution.
1011 Unlike threads in multithread systems, however,
1039 A coroutine can terminate its execution in two ways:
1043 In the first case, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>tru…
1045 In case of errors, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> returns <b>fal…
1054 (that is, not in the main function,
1055 but in a function directly or indirectly called by the main function).
1056 In the case of a yield, <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> also retu…
1128 In other words,
1137 in which
1143 The complete syntax of Lua can be found in <a href="#9">§9</a>
1160 in Lua can be any string of letters,
1173 false for function goto if in
1212 results in a newline in the string.
1222 A byte in a literal string can also be specified by its numerical value.
1229 Strings in Lua can contain any 8-bit value, including embedded zeros,
1247 Literals in this bracketed form can run for several lines,
1257 Any byte in a literal string not
1259 However, Lua opens files for parsing in text mode,
1270 the newline is not included in the string.
1271 As an example, in a system using ASCII
1272 (in which '<code>a</code>' is coded as 97,
1321 There are three kinds of variables in Lua:
1333 Name denotes identifiers, as defined in <a href="#3.1">§3.1</a>.
1359 This function is not defined or callable in Lua.
1385 similar to those in Pascal or C.
1404 or write two semicolons in sequence:
1413 This possibility leads to an ambiguity in Lua's grammar.
1420 The grammar could see it in two ways:
1428 in the first way,
1448 add a <b>return</b> statement in the middle
1472 Moreover, such anonymous function is compiled as in the
1479 A chunk can be stored in a file or in a string inside the host program.
1489 Programs in source and compiled forms are interchangeable;
1504 The elements in both lists are separated by commas:
1511 Expressions are discussed in <a href="#3.4">§3.4</a>.
1525 (except when the call is enclosed in parentheses; see <a href="#3.4">§3.4</a>).
1538 because the <code>i</code> in <code>a[i]</code> is evaluated (to 3)
1561 This function is not defined or callable in Lua.
1587 Lua also has a <b>for</b> statement, in two flavors (see <a href="#3.3.5">§3.3.5</a>).
1595 (in particular, the number 0 and the empty string are also true).
1599 In the <b>repeat</b>–<b>until</b> loop,
1609 labels in Lua are considered statements too:
1620 A label is visible in the entire block where it is defined,
1647 from a function or a chunk (which is a function in disguise).
1659 If it is really necessary to <b>return</b> in the middle of a block,
1661 as in the idiom <code>do return end</code>,
1662 because now <b>return</b> is the last statement in its (inner) block.
1712 They must all result in numbers.
1746 stat ::= <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b>
1752 …for <em>var_1</em>, ···, <em>var_n</em> in <em>explist</em> do <em>block</em>…
1806 In this case, all returned values are thrown away.
1807 Function calls are explained in <a href="#3.4.9">§3.4.9</a>.
1827 and so local variables can be declared in a chunk outside any explicit block.
1831 The visibility rules for local variables are explained in <a href="#3.5">§3.5</a>.
1842 The basic expressions in Lua are the following:
1858 Numbers and literal strings are explained in <a href="#3.1">§3.1</a>;
1859 variables are explained in <a href="#3.2">§3.2</a>;
1860 function definitions are explained in <a href="#3.4.10">§3.4.10</a>;
1861 function calls are explained in <a href="#3.4.9">§3.4.9</a>;
1862 table constructors are explained in <a href="#3.4.8">§3.4.8</a>.
1866 they are explained in <a href="#3.4.10">§3.4.10</a>.
1879 Both function calls and vararg expressions can result in multiple values.
1886 (unless the expression is enclosed in parentheses).
1887 In all other contexts,
1916 Any expression enclosed in parentheses always results in only one value.
1957 the number is converted to a string, in a reasonable format.
1967 The relational operators in Lua are
1972 These operators always result in <b>false</b> or <b>true</b>.
1979 Numbers and strings are compared in the usual way.
2001 entries in a table.
2023 The logical operators in Lua are
2053 (In this manual,
2061 The string concatenation operator in Lua is
2064 strings according to the rules mentioned in <a href="#3.4.2">§3.4.2</a>.
2092 In that case, <em>n</em> is its length.
2110 Operator precedence in Lua follows the table below,
2155 Fields in the other formats do not affect this counting.
2178 If the last field in the list has the form <code>exp</code>
2193 A function call in Lua has the following syntax:
2198 In a function call,
2244 in a tail call,
2355 or in the middle of a list of expressions,
2359 (unless that last expression is enclosed in parentheses).
2448 Notice that, in a declaration like <code>local x = x</code>,
2449 the new <code>x</code> being declared is not in scope yet,
2492 are declared in the header file <a name="pdf-lua.h"><code>lua.h</code></a>.
2497 any facility in the API may be provided as a macro instead.
2505 As in most C libraries,
2516 Each element in this stack represents a Lua value
2531 most query operations in the API do not follow a strict stack discipline.
2532 Instead, they can refer to any element in the stack
2555 In particular,
2574 So, before pushing anything in the stack after such a call
2584 Any function in the API that receives stack indices
2602 but which are not in the stack.
2609 but only a value in the stack (e.g., query functions),
2618 functions in the API work with acceptable indices.
2680 or a light userdata with the address of a C object in your code,
2688 The integer keys in the registry are used by the reference mechanism,
2698 defined as constants in <code>lua.h</code>.
2715 <h2>4.6 – <a name="4.6">Error Handling in C</a></h2>
2720 search for <code>LUAI_THROW</code> in the source code.)
2743 in particular, the error message is at the top of the stack.
2750 Most functions in the API can throw an error,
2763 <h2>4.7 – <a name="4.7">Handling Yields in C</a></h2>
2787 This original function then calls one of those three functions in the C API,
2801 because its frame in the C stack was destroyed by the yield.
2813 in the same state it would be if the callee function had returned.
2823 The only difference in the Lua state between the original function
2833 Here we list all functions and types from the C API in
2845 A field in the form <code>x|y</code> means the function can push (or pop)
2929 It is used in the auxiliary library by <a href="#luaL_newstate"><code>luaL_newstate</code></a>.
2960 (or one, in the case of negation)
3009 in direct order;
3018 In this case, all results from the function are pushed.
3020 The function results are pushed onto the stack in direct order
3037 Here it is in C:
3078 In order to communicate properly with Lua,
3081 a C function receives its arguments from Lua in its stack
3082 in direct order (the first argument is pushed first).
3088 in direct order (the first result is pushed first),
3090 Any other value in the stack below the results will be properly
3126 Ensures that there are at least <code>extra</code> free stack slots in the stack.
3144 Destroys all objects in the given Lua state
3227 This pre-allocation is useful for performance when you know in advance
3244 results in a function equivalent to the one dumped.
3307 returns the current amount of memory (in Kbytes) in use by Lua.
3312 memory in use by Lua by 1024.
3318 (larger values mean more steps) in a non-specified way.
3368 If <code>ud</code> is not <code>NULL</code>, Lua stores in <code>*ud</code> the
3385 When called in the original function,
3399 That is, upon an error in the function called by <a href="#lua_pcallk"><code>lua_pcallk</code></a>,
3402 In that case, a call to <a href="#lua_getctx"><code>lua_getctx</code></a> will return the error code
3405 as in the case of a yield.
3418 As in Lua, this function may trigger a metamethod
3461 (putting the resulting value in its place).
3462 As in Lua, this function may trigger a metamethod
3474 Returns the index of the top element in the stack.
3476 this result is equal to the number of elements in the stack
3679 it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.6">§3.4.6</a>).
3731 which is used for error messages and in debug information (see <a href="#4.9">§4.9</a>).
3737 The string <code>mode</code> works as in function <a href="#pdf-load"><code>load</code></a>,
3751 stored at index <code>LUA_RIDX_GLOBALS</code> in the registry (see <a href="#4.5">§4.5</a>).
3764 Creates a new thread running in a new, independent state.
3770 passes to the allocator in every call.
3831 If there are no more elements in the table,
3839 /* table is in the stack at index 't' */
3872 The type of numbers in Lua.
3873 By default, it is double, but that can be changed in <code>luaconf.h</code>.
3886 Calls a function in protected mode.
3891 in <a href="#lua_call"><code>lua_call</code></a>.
3909 (In the current implementation, this index cannot be a pseudo-index.)
3910 In case of runtime errors,
3925 (defined in <code>lua.h</code>):
4026 In that case, it never throws a memory error.
4044 Any function to be registered in Lua must
4083 '<code>%%</code>' (inserts a '<code>%</code>' in the string),
4127 Userdata represent C values in Lua.
4272 Returns 1 if the two values in indices <code>index1</code> and
4462 Starts and resumes a coroutine in a given thread.
4477 or an error code in case of errors (see <a href="#lua_pcall"><code>lua_pcall</code></a>).
4481 In case of errors,
4528 As in Lua, this function may trigger a metamethod
4572 As in Lua, this function may trigger a metamethod
4619 every function in the library, except to <a href="#lua_newstate"><code>lua_newstate</code></a>,
4642 You can only call functions in threads with status <a href="#pdf-LUA_OK"><code>LUA_OK</code></a>.
4658 Like all tests in Lua,
4707 it is truncated in some non-specified way.
4731 <em>changes the actual value in the stack to a string</em>.
4740 after its last character (as in C),
4741 but can contain other zeros in its body.
4852 it is truncated in some non-specified way.
4887 Returns the type of the value in the given valid index,
4890 defined in <code>lua.h</code>:
4951 Returns the address of the version number stored in the Lua core.
5032 When a C function calls <a href="#lua_yieldk"><code>lua_yieldk</code></a> in that way,
5060 Lua has no built-in debugging facilities.
5105 it means that the function was defined in a file where
5108 the remainder of its contents describe the source in a user-dependent manner.
5110 the function was defined in a string where
5115 a "printable" version of <code>source</code>, to be used in error messages.
5140 Because functions in Lua are first-class values,
5143 while others can be stored only in a table field.
5161 In this case, the caller of this level is not in the stack.
5234 (In that case,
5236 For instance, to know in which line a function <code>f</code> was defined,
5247 Each character in the string <code>what</code>
5253 <li><b>'<code>n</code>': </b> fills in the field <code>name</code> and <code>namewhat</code>;
5257 fills in the fields <code>source</code>, <code>short_src</code>,
5261 <li><b>'<code>l</code>': </b> fills in the field <code>currentline</code>;
5264 <li><b>'<code>t</code>': </b> fills in the field <code>istailcall</code>;
5267 <li><b>'<code>u</code>': </b> fills in the fields
5288 (for instance, an invalid option in <code>what</code>).
5304 In the first case,
5319 In the second case, <code>ar</code> should be <code>NULL</code> and the function
5321 In this case, only parameters of Lua functions are visible
5366 and that are consequently included in its closure.)
5370 <code>funcindex</code> points to the closure in the stack.
5373 So, they are numbered in an arbitrary order.)
5401 To get the value of any other field in <code>ar</code>,
5408 in this case, there will be no corresponding return event.
5469 or when it jumps back in the code (even to the same line).
5493 Parameters <code>ar</code> and <code>n</code> are as in <a href="#lua_getlocal"><code>lua_getlocal<…
5518 Parameters <code>funcindex</code> and <code>n</code> are as in the <a href="#lua_getupvalue"><code>…
5537 Parameters <code>funcindex</code> and <code>n</code> are as in the <a href="#lua_getupvalue"><code>…
5582 are defined in header file <code>lauxlib.h</code> and
5587 All functions in the auxiliary library are built on
5595 Several functions in the auxiliary library use internally some
5597 When a function in the auxiliary library uses less than five slots,
5603 Several functions in the auxiliary library are used to
5620 in alphabetical order.
5723 but it is an idiom to use it in C functions
5838 In this case this function returns true and pushes onto the
5935 searches for this string in the array <code>lst</code>
5937 Returns the index in the array where the string was found.
5950 (The usual convention in Lua libraries is
6053 or true in case of errors.
6071 or true in case of errors.
6093 but it is an idiom to use it in C functions
6106 process-related functions in the standard library
6119 file-related functions in the standard library
6147 in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
6193 it is equivalent to the '<code>#</code>' operator in Lua (see <a href="#3.4.6">§3.4.6</a>).
6225 This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the
6233 The string <code>mode</code> works as in function <a href="#lua_load"><code>lua_load</code></a>.
6257 This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in the file
6261 The first line in the file is ignored if it starts with a <code>#</code>.
6265 The string <code>mode</code> works as in function <a href="#lua_load"><code>lua_load</code></a>.
6288 This function uses <a href="#lua_load"><code>lua_load</code></a> to load the chunk in
6310 the functions in list <code>l</code>.
6326 to store all entries in the array <code>l</code>
6328 It is intended to be used in conjunction with <a href="#luaL_setfuncs"><code>luaL_setfuncs</code></…
6355 In both cases pushes onto the stack the final value associated
6356 with <code>tname</code> in the registry.
6371 an error message to the standard error output in case of fatal
6570 in the table at index <code>t</code>,
6605 in which both <code>name</code> and <code>func</code> are <code>NULL</code>.
6618 and sets the call result in <code>package.loaded[modname]</code>,
6639 Registers all functions in the array <code>l</code>
6662 in the registry (see <a href="#luaL_newmetatable"><code>luaL_newmetatable</code></a>).
6687 in a reasonable format.
6757 of the control at level <code>lvl</code> in the call stack.
6785 and others could be implemented in Lua itself,
6787 deserve an implementation in C (e.g., <a href="#pdf-table.sort"><code>table.sort</code></a>).
6840 These functions are declared in <a name="pdf-lualib.h"><code>lualib.h</code></a>.
6848 If you do not include this library in your application,
6890 returns the total memory in use by Lua (in Kbytes) and
6891 a second value with the total memory in bytes modulo 1024.
6906 (larger values mean more steps) in a non-specified way.
6949 In case of errors, <code>dofile</code> propagates the error
6950 to its caller (that is, <code>dofile</code> does not run in protected mode).
7017 for i,v in ipairs(t) do <em>body</em> end
7099 is an index in this table.
7106 or with <b>nil</b> in an empty table,
7109 In particular,
7114 The order in which the indices are enumerated is not specified,
7116 (To traverse a table in numeric order,
7123 you assign any value to a non-existent field in the table.
7125 In particular, you may clear existing fields.
7146 for k,v in pairs(t) do <em>body</em> end
7164 the given arguments in <em>protected mode</em>.
7170 In such case, <code>pcall</code> also returns all results from the call,
7172 In case of any error, <code>pcall</code> returns <b>false</b> plus the error message.
7284 an integer numeral in that base.
7286 In bases above 10, the letter '<code>A</code>' (in either upper or lower case)
7289 If the string <code>e</code> is not a valid numeral in the given base,
7298 converts it to a string in a reasonable format.
7418 <code>"suspended"</code>, if the coroutine is suspended in a call to <code>yield</code>,
7440 In case of error, propagates the error.
7463 facilities for loading modules in Lua.
7464 It exports one function directly in the global environment:
7466 Everything else is exported in a table <a name="pdf-package"><code>package</code></a>.
7496 path stored in <a href="#pdf-package.path"><code>package.path</code></a>.
7498 path stored in <a href="#pdf-package.cpath"><code>package.cpath</code></a>.
7500 it tries an <em>all-in-one</em> loader (see <a href="#pdf-package.searchers"><code>package.searcher…
7514 In any case, <code>require</code> returns the
7539 <li>The second line is the character that separates templates in a path.
7543 substitution points in a template.
7546 <li>The fourth line is a string that, in a path in Windows,
7567 Lua initializes the C path <a href="#pdf-package.cpath"><code>package.cpath</code></a> in the …
7571 or a default path defined in <code>luaconf.h</code>.
7649 with a default path defined in <code>luaconf.h</code>,
7651 Any "<code>;;</code>" in the value of the environment variable
7683 Each entry in this table is a <em>searcher function</em>.
7685 <a href="#pdf-require"><code>require</code></a> calls each of these searchers in ascending order,
7699 The first searcher simply looks for a loader in the
7706 The search is done as described in function <a href="#pdf-package.searchpath"><code>package.searchp…
7713 the search is done as described in function <a href="#pdf-package.searchpath"><code>package.searchp…
7722 and <code>/usr/local/foo/init.so</code>, in that order.
7738 The fourth searcher tries an <em>all-in-one loader</em>.
7745 in our example, that would be <code>luaopen_a_b_c</code>.
7765 Searches for the given <code>name</code> in the given <code>path</code>.
7773 in the template with a copy of <code>name</code>
7790 <code>/usr/local/foo/a/init.lua</code>, in that order.
7795 open in read mode (after closing the file),
7810 When indexing a string in Lua, the first character is at position 1
7811 (not at 0, as in C).
7822 Therefore, you can use the string functions in object-oriented style.
7851 in which each character has the internal numerical code equal
7879 <code>pattern</code> in the string <code>s</code>.
7889 with no characters in <code>pattern</code> being considered magic.
7895 then in a successful match
7908 following the description given in its first argument (which must be a string).
7955 then the whole match is produced in each call.
7965 for w in string.gmatch(s, "%a+") do
7975 for k, v in string.gmatch(s, "(%w+)=(%w+)") do
7990 in which all (or the first <code>n</code>, if given)
8002 any sequence in <code>repl</code> of the form <code>%<em>d</em></code>,
8017 in order.
8021 In any case,
8032 (that is, the original match is kept in the string).
8086 <code>pattern</code> in the string <code>s</code>.
8123 In particular,
8157 The following combinations are allowed in describing a character class:
8194 when used to represent itself in a pattern.
8199 characters in <em>set</em>.
8202 in ascending order, with a '<code>-</code>',
8204 components in <em>set</em>.
8205 All other characters in <em>set</em> represent themselves.
8233 In particular, the class <code>[a-z]</code> may not be equivalent to <code>%l</code>.
8246 which matches any single character in the class;
8251 which matches 0 or more repetitions of characters in the class.
8257 which matches 1 or more repetitions of characters in the class.
8263 which also matches 0 or more repetitions of characters in the class.
8270 which matches 0 or 1 occurrence of a character in the class;
8319 A pattern can contain sub-patterns enclosed in parentheses;
8324 For instance, in the pattern <code>"(a*(.)%w(%s*))"</code>,
8359 in tables given as arguments.
8387 Inserts element <code>value</code> at position <code>pos</code> in <code>list</code>,
8422 in those cases, the function erases the element <code>list[pos]</code>.
8438 Sorts list elements in a given order, <em>in-place</em>,
8443 before the second in the final order
8498 Returns the arc cosine of <code>x</code> (in radians).
8508 Returns the arc sine of <code>x</code> (in radians).
8518 Returns the arc tangent of <code>x</code> (in radians).
8528 Returns the arc tangent of <code>y/x</code> (in radians),
8551 Returns the cosine of <code>x</code> (assumed to be in radians).
8571 Returns the angle <code>x</code> (given in radians) in degrees.
8614 in the range <em>[0.5, 1)</em>
8646 Returns the logarithm of <code>x</code> in the given base.
8710 Returns the angle <code>x</code> (given in degrees) in radians.
8728 in the range <em>[0,1)</em>.
8731 a uniform pseudo-random integer in the range <em>[1, m]</em>.
8734 integer in the range <em>[m, n]</em>.
8756 Returns the sine of <code>x</code> (assumed to be in radians).
8787 Returns the tangent of <code>x</code> (assumed to be in radians).
8814 all functions accept numeric arguments in the range
8818 and truncated to an integer (in some unspecified way),
8819 so that its final value falls in the range <em>[0,2<sup>32</sup> - 1]</em>.
8820 Similarly, all results are in the range <em>[0,2<sup>32</sup> - 1]</em>.
8840 In particular,
8842 result in zero or <code>0xFFFFFFFF</code> (all original bits are shifted out).
8911 All accessed bits must be in the range <em>[0, 31]</em>.
8949 In particular,
8963 In any direction, vacant bits are filled with zeros.
8964 In particular,
8966 result in zero (all bits are shifted out).
8995 In particular,
9009 In any direction, vacant bits are filled with zeros.
9010 In particular,
9012 result in zero (all bits are shifted out).
9066 in case of errors
9097 When called with a file name, it opens the named file (in text mode),
9106 In case of errors this function raises the error,
9117 Opens the given file name in read mode
9128 In this case it does not close the file when the loop ends.
9132 In case of errors this function raises the error,
9144 in the mode specified in the string <code>mode</code>.
9146 or, in case of errors, <b>nil</b> plus an error message.
9162 which is needed in some systems to open the file in binary mode.
9187 Starts program <code>prog</code> in a separated process and returns
9212 This file is opened in update mode
9283 for c in file:lines(1) do <em>body</em> end
9292 In case of errors this function raises the error,
9366 In case of success, <code>seek</code> returns the final file position,
9367 measured in bytes from the beginning of the file.
9413 specifies the size of the buffer, in bytes.
9429 In case of success, this function returns <code>file</code>.
9449 Returns an approximation of the amount in seconds of CPU time
9473 then the date is formatted in Coordinated Universal Time.
9513 In POSIX, Windows, and some other systems,
9665 In POSIX, Windows, and some other systems,
9668 In other systems, the meaning is not specified,
9691 in the time between getting the name and creating the file.)
9720 Moreover, some functions in this library may be slow.
9724 All functions in this library are provided
9786 with the string <code>what</code> describing which fields to fill in.
9838 In that case, <code>getlocal</code> returns only the name of function parameters.
10051 to be embedded in a host C program,
10099 with the default paths defined in <code>luaconf.h</code>.
10103 All options are handled in order, except <code>-i</code> and <code>-E</code>.
10116 <code>lua</code> collects all arguments in the command line
10117 in a global table called <code>arg</code>.
10124 For instance, in the call
10144 In interactive mode,
10151 In case of unprotected errors in the script,
10171 script interpreter in Unix systems,
10176 as in
10182 the location of the Lua interpreter may be different in your machine.
10183 If <code>lua</code> is in your <code>PATH</code>,
10201 all these compatibility options will be removed in the next version of Lua.
10203 all features marked as deprecated in Lua 5.1
10204 have been removed in Lua 5.2.
10208 <h2>8.1 – <a name="8.1">Changes in the Language</a></h2>
10238 Doing a step or a full collection in the garbage collector
10247 The event <em>tail return</em> in debug hooks was removed.
10265 <h2>8.2 – <a name="8.2">Changes in the Libraries</a></h2>
10276 because of the changes in environments.
10292 Write it in Lua if you really need it.
10307 Character class <code>%z</code> in patterns is deprecated,
10321 of flaws in the verification algorithm.)
10322 When in doubt,
10328 The standard paths in the official distribution may
10337 <h2>8.3 – <a name="8.3">Changes in the API</a></h2>
10369 Finalizers (<code>__gc</code> metamethods) for userdata are called in the
10417 Here is the complete syntax of Lua in extended BNF.
10440 <b>for</b> namelist <b>in</b> explist <b>do</b> block <b>end</b> |