From 8cf571c5ea48be2d281d2c83ed0f2dba6f2c32f4 Mon Sep 17 00:00:00 2001 From: Alexander Lantsev Date: Mon, 13 Jun 2016 14:18:51 +0000 Subject: lublua: - updated to 5.3.3 - renamed to lua53.dll git-svn-id: http://svn.miranda-ng.org/main/trunk@16965 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c --- libs/liblua/doc/manual.html | 929 +++++++++++++++++++++++++------------------- 1 file changed, 525 insertions(+), 404 deletions(-) (limited to 'libs/liblua/doc/manual.html') diff --git a/libs/liblua/doc/manual.html b/libs/liblua/doc/manual.html index 5ed8f06922..5fb26b23c8 100644 --- a/libs/liblua/doc/manual.html +++ b/libs/liblua/doc/manual.html @@ -1,39 +1,41 @@ - - - -Lua 5.3 Reference Manual - - + + +Lua 5.3 Reference Manual + + - + - + -
-

- +

+Lua Lua 5.3 Reference Manual -

+ +

by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes -

- -Copyright © 2015 Lua.org, PUC-Rio. + +

+ +Copyright © 2015–2016 Lua.org, PUC-Rio. Freely available under the terms of the Lua license. - -

-

+ -contents +

+contents +· +index · -index +other versions +

- + @@ -41,30 +43,47 @@ Freely available under the terms of the

1 – Introduction

-Lua is an extension programming language designed to support -general procedural programming with data description -facilities. -Lua also offers good support for object-oriented programming, -functional programming, and data-driven programming. -Lua is intended to be used as a powerful, lightweight, -embeddable scripting language for any program that needs one. +Lua is a powerful, efficient, lightweight, embeddable scripting language. +It supports procedural programming, +object-oriented programming, functional programming, +data-driven programming, and data description. + + +

+Lua combines simple procedural syntax with powerful data description +constructs based on associative arrays and extensible semantics. +Lua is dynamically typed, +runs by interpreting bytecode with a register-based +virtual machine, +and has automatic memory management with +incremental garbage collection, +making it ideal for configuration, scripting, +and rapid prototyping. + + +

Lua is implemented as a library, written in clean C, the common subset of Standard C and C++. +The Lua distribution includes a host program called lua, +which uses the Lua library to offer a complete, +standalone Lua interpreter, +for interactive or batch use. +Lua is intended to be used both as a powerful, lightweight, +embeddable scripting language for any program that needs one, +and as a powerful but lightweight and efficient stand-alone language.

As an extension language, Lua has no notion of a "main" program: -it only works embedded in a host client, +it works embedded in a host client, called the embedding program or simply the host. +(Frequently, this host is the stand-alone lua program.) The host program can invoke functions to execute a piece of Lua code, can write and read Lua variables, and can register C functions to be called by Lua code. Through the use of C functions, Lua can be augmented to cope with a wide range of different domains, thus creating customized programming languages sharing a syntactical framework. -The Lua distribution includes a sample host program called lua, -which uses the Lua library to offer a complete, standalone Lua interpreter, -for interactive or batch use.

@@ -113,15 +132,15 @@ There are eight basic types in Lua: nil, boolean, number, string, function, userdata, thread, and table. -Nil is the type of the value nil, +The type nil has one single value, nil, whose main property is to be different from any other value; it usually represents the absence of a useful value. -Boolean is the type of the values false and true. +The type boolean has two values, false and true. Both nil and false make a condition false; any other value makes it true. -Number represents both +The type number represents both integer numbers and real (floating-point) numbers. -String represents immutable sequences of bytes. +The type string represents immutable sequences of bytes. Lua is 8-bit clean: strings can contain any 8-bit value, @@ -132,6 +151,7 @@ it makes no assumptions about the contents of a string.

The type number uses two internal representations, +or two subtypes, one called integer and the other called float. Lua has explicit rules about when each representation is used, but it also converts between them automatically as needed (see §3.4.3). @@ -142,7 +162,7 @@ or to assume complete control over the representation of each number. Standard Lua uses 64-bit integers and double-precision (64-bit) floats, but you can also compile Lua so that it uses 32-bit integers and/or single-precision (32-bit) floats. -The option with 32 bits for both integers and floats +The option with 32 bits for both integers and floats is particularly attractive for small machines and embedded systems. (See macro LUA_32BITS in file luaconf.h.) @@ -185,8 +205,8 @@ even those that do not support threads natively. The type table implements associative arrays, that is, arrays that can be indexed not only with numbers, but with any Lua value except nil and NaN. -(Not a Number is a special numeric value used to represent -undefined or unrepresentable results, such as 0/0.) +(Not a Number is a special value used to represent +undefined or unrepresentable numerical results, such as 0/0.) Tables can be heterogeneous; that is, they can contain values of all types (except nil). Any key with value nil is not considered part of the table. @@ -348,8 +368,8 @@ It is up to the Lua program or its host to handle such error objects. When you use xpcall or lua_pcall, you may give a message handler to be called in case of errors. -This function is called with the original error message -and returns a new error message. +This function is called with the original error object +and returns a new error object. It is called before the error unwinds the stack, so that it can gather more information about the error, for instance by inspecting the stack and creating a stack traceback. @@ -379,23 +399,30 @@ Lua calls this function to perform the addition.

-The keys in a metatable are derived from the event names; +The key for each event in a metatable is a string +with the event name prefixed by two underscores; the corresponding values are called metamethods. -In the previous example, the event is "add" +In the previous example, the key is "__add" and the metamethod is the function that performs the addition.

You can query the metatable of any value using the getmetatable function. +Lua queries metamethods in metatables using a raw access (see rawget). +So, to retrieve the metamethod for event ev in object o, +Lua does the equivalent to the following code: +

+     rawget(getmetatable(o) or {}, "__ev")
+

You can replace the metatable of tables using the setmetatable function. -You cannot change the metatable of other types from Lua +You cannot change the metatable of other types from Lua code (except by using the debug library (§6.10)); -you must use the C API for that. +you should use the C API for that.

@@ -417,23 +444,7 @@ when a userdata or a table is garbage collected (§2.5).

-A detailed list of events controlled by metatables is given next. -Each operation is identified by its corresponding event name. -The key for each event is a string with its name prefixed by -two underscores, '__'; -for instance, the key for operation "add" is the -string "__add". -Note that queries for metamethods are always raw; -the access to a metamethod does not invoke other metamethods. -You can emulate how Lua queries a metamethod for an object obj -with the following code: - -

-     rawget(getmetatable(obj) or {}, "__" .. event_name)
-
- -

-For the unary operators (negation, length, and bitwise not), +For the unary operators (negation, length, and bitwise NOT), the metamethod is computed and called with a dummy second operand, equal to the first one. This extra operand is only to simplify Lua's internals @@ -442,17 +453,21 @@ and may be removed in future versions. (For most uses this extra operand is irrelevant.) +

+A detailed list of events controlled by metatables is given next. +Each operation is identified by its corresponding key. + +

+

+It is a good practice to add all needed metamethods to a table +before setting it as a metatable of some object. +In particular, the __gc metamethod works only when this order +is followed (see §2.5.1). + + +

+Because metatables are regular tables, +they can contain arbitrary fields, +not only the event names defined above. +Some functions in the standard library +(e.g., tostring) +use other fields in metatables for their own purposes. + + @@ -752,8 +770,6 @@ and the metatable has a field indexed by the string "__gc". Note that if you set a metatable without a __gc field and later create that field in the metatable, the object will not be marked for finalization. -However, after an object has been marked, -you can freely change the __gc field of its metatable.

@@ -794,7 +810,7 @@ Moreover, if the finalizer marks a finalizing object for finalization again, its finalizer will be called again in the next cycle where the object is unreachable. In any case, -the object memory is freed only in the GC cycle where +the object memory is freed only in a GC cycle where the object is unreachable and not marked for finalization. @@ -822,8 +838,8 @@ then the garbage collector will collect that object.

A weak table can have weak keys, weak values, or both. -A table with weak keys allows the collection of its keys, -but prevents the collection of its values. +A table with weak values allows the collection of its values, +but prevents the collection of its keys. A table with both weak keys and weak values allows the collection of both keys and values. In any case, if either the key or the value is collected, @@ -913,10 +929,10 @@ You execute a coroutine by calling corouti When you first call coroutine.resume, passing as its first argument a thread returned by coroutine.create, -the coroutine starts its execution, -at the first line of its main function. +the coroutine starts its execution by +calling its main function. Extra arguments passed to coroutine.resume are passed -as arguments to the coroutine's main function. +as arguments to that function. After the coroutine starts running, it runs until it terminates or yields. @@ -930,7 +946,7 @@ In case of normal termination, coroutine.resume returns true, plus any values returned by the coroutine main function. In case of errors, coroutine.resume returns false -plus an error message. +plus an error object.

@@ -1046,7 +1062,8 @@ except as delimiters between names and keywords. (also called identifiers) in Lua can be any string of letters, digits, and underscores, -not beginning with a digit. +not beginning with a digit and +not being a reserved word. Identifiers are used to name variables, table fields, and labels. @@ -1111,7 +1128,7 @@ into the string contents. Strings in Lua can contain any 8-bit value, including embedded zeros, which can be specified as '\0'. More generally, -we can specify any byte in a literal string by its numerical value. +we can specify any byte in a literal string by its numeric value. This can be done with the escape sequence \xXX, where XX is a sequence of exactly two hexadecimal digits, @@ -1162,7 +1179,7 @@ and the system file functions may have problems with some control characters. So, it is safer to represent non-text data as a quoted literal with -explicit escape sequences for non-text characters. +explicit escape sequences for the non-text characters.

@@ -1186,7 +1203,7 @@ the five literal strings below denote the same string:

-A numerical constant (or numeral) +A numeric constant (or numeral) can be written with an optional fractional part and an optional decimal exponent, marked by a letter 'e' or 'E'. @@ -1195,9 +1212,11 @@ which start with 0x or 0X. Hexadecimal constants also accept an optional fractional part plus an optional binary exponent, marked by a letter 'p' or 'P'. -A numeric constant with a fractional dot or an exponent +A numeric constant with a radix point or an exponent denotes a float; -otherwise it denotes an integer. +otherwise, +if its value fits in an integer, +it denotes an integer. Examples of valid integer constants are 

@@ -1581,11 +1600,11 @@ because now return is the last statement in its (inner) block.
 

 
 The for statement has two forms:
-one numeric and one generic.
+one numerical and one generic.
 
 
 

-The numeric for loop repeats a block of code while a
+The numerical for loop repeats a block of code while a
 control variable runs through an arithmetic progression.
 It has the following syntax:
 
@@ -1788,7 +1807,7 @@ bitwise operators (see §3.4.2),
 relational operators (see §3.4.4), logical operators (see §3.4.5),
 and the concatenation operator (see §3.4.6).
 Unary operators comprise the unary minus (see §3.4.1),
-the unary bitwise not (see §3.4.2),
+the unary bitwise NOT (see §3.4.2),
 the unary logical not (see §3.4.5),
 and the unary length operator (see §3.4.7).
 
@@ -1879,13 +1898,13 @@ so that it works for non-integer exponents too.
 
 

 Floor division (//) is a division 
-that rounds the quotient towards minus infinite,
+that rounds the quotient towards minus infinity,
 that is, the floor of the division of its operands.
 
 
 

 Modulo is defined as the remainder of a division
-that rounds the quotient towards minus infinite (floor division).
+that rounds the quotient towards minus infinity (floor division).
 
 
 

@@ -1902,12 +1921,12 @@ that is equal modulo 264 to the mathematical result.)
 Lua supports the following bitwise operators:
 
 
    
-
  • &: bitwise and
    • 
-
  • |: bitwise or
    • 
-
  • ~: bitwise exclusive or
    • 
+
  • &: bitwise AND
    • 
+
  • |: bitwise OR
    • 
+
  • ~: bitwise exclusive OR
    • 
 
  • >>: right shift
    • 
 
  • <<: left shift
    • 
-
  • ~: unary bitwise not
    • 
+
  • ~: unary bitwise NOT
    • 
 

 
 

@@ -1972,8 +1991,16 @@ The conversion from strings to numbers goes as follows:
 First, the string is converted to an integer or a float,
 following its syntax and the rules of the Lua lexer.
 (The string may have also leading and trailing spaces and a sign.)
-Then, the resulting number is converted to the required type
-(float or integer) according to the previous rules.
+Then, the resulting number (float or integer)
+is converted to the type (float or integer) required by the context
+(e.g., the operation that forced the conversion).
+
+
+

+All conversions from strings to numbers 
+accept both a dot and the current locale mark
+as the radix character.
+(The Lua lexer, however, accepts only a dot.)
 
 
 

@@ -2006,11 +2033,7 @@ Equality (==) first compares the type of its operands.
 If the types are different, then the result is false.
 Otherwise, the values of the operands are compared.
 Strings are compared in the obvious way.
-Numbers follow the usual rule for binary operations:
-if both operands are integers,
-they are compared as integers;
-otherwise, they are converted to floats
-and compared as such.
+Numbers are equal if they denote the same mathematical value.
 
 
 

@@ -2045,8 +2068,8 @@ The operator ~= is exactly the negation of equality (==
 The order operators work as follows.
 If both arguments are numbers,
-then they are compared following
-the usual rule for binary operations.
+then they are compared according to their mathematical values
+(regardless of their subtypes).
 Otherwise, if both arguments are strings,
 then their values are compared according to the current locale.
 Otherwise, Lua tries to call the "lt" or the "le"
@@ -2055,6 +2078,12 @@ A comparison a > b is translated to b < a
 and a >= b is translated to b <= a.
 
 
+

+Following the IEEE 754 standard,
+NaN is considered neither smaller than,
+nor equal to, nor greater than any value (including itself).
+
+
 
 
 
@@ -2636,29 +2665,22 @@ works only with valid indices or acceptable indices.
 
 

 A valid index is an index that refers to a
-real position within the stack, that is,
-its position lies between 1 and the stack top
-(1 ≤ abs(index) ≤ top).
-
-Usually, functions that can modify the value at an index
-require valid indices.
-
-
-

-Unless otherwise noted,
-any function that accepts valid indices also accepts pseudo-indices,
-which represent some Lua values that are accessible to C code
-but which are not in the stack.
-Pseudo-indices are used to access the registry
+position that stores a modifiable Lua value.
+It comprises stack indices between 1 and the stack top
+(1 ≤ abs(index) ≤ top)
+
+plus pseudo-indices,
+which represent some positions that are accessible to C code
+but that are not in the stack.
+Pseudo-indices are used to access the registry (see §4.5)
 and the upvalues of a C function (see §4.4).
 
 
 

-Functions that do not need a specific stack position,
-but only a value in the stack (e.g., query functions),
+Functions that do not need a specific mutable position,
+but only a value (e.g., query functions),
 can be called with acceptable indices.
 An acceptable index can be any valid index,
-including the pseudo-indices,
 but it also can be any positive index after the stack top
 within the space allocated for the stack,
 that is, indices up to the stack size.
@@ -2701,11 +2723,13 @@ Whenever a C function is called,
 its upvalues are located at specific pseudo-indices.
 These pseudo-indices are produced by the macro
 lua_upvalueindex.
-The first value associated with a function is at position
+The first upvalue associated with a function is at index
 lua_upvalueindex(1), and so on.
 Any access to lua_upvalueindex(n),
 where n is greater than the number of upvalues of the
-current function (but not greater than 256),
+current function
+(but not greater than 256,
+which is one plus the maximum number of upvalues in a closure),
 produces an acceptable but invalid index.
 
 
@@ -2719,8 +2743,7 @@ Lua provides a registry,
 a predefined table that can be used by any C code to
 store whatever Lua values it needs to store.
 The registry table is always located at pseudo-index
-LUA_REGISTRYINDEX,
-which is a valid index.
+LUA_REGISTRYINDEX.
 Any C library can store data into this table,
 but it must take care to choose keys
 that are different from those used
@@ -2789,7 +2812,7 @@ never returning
 
 

 The panic function runs as if it were a message handler (see §2.3);
-in particular, the error message is at the top of the stack.
+in particular, the error object is at the top of the stack.
 However, there is no guarantee about stack space.
 To push anything on the stack,
 the panic function must first check the available space (see §4.2).
@@ -2971,7 +2994,11 @@ by looking only at its arguments
 The third field, x,
 tells whether the function may raise errors:
 '-' means the function never raises any error;
-'e' means the function may raise errors;
+'m' means the function may raise out-of-memory errors
+and errors running a __gc metamethod;
+'e' means the function may raise any errors
+(it can run arbitrary Lua code,
+either directly or through metamethods);
 'v' means the function may raise an error on purpose.
 
 
@@ -2981,7 +3008,8 @@ tells whether the function may raise errors:
 
int lua_absindex (lua_State *L, int idx);

 
 

-Converts the acceptable index idx into an absolute index
+Converts the acceptable index idx
+into an equivalent absolute index
 (that is, one that does not depend on the stack top).
 
 
@@ -3097,10 +3125,10 @@ The value of op must be one of the following constants:
 
  • LUA_OPMOD:  performs modulo (%)
    • 
 
  • LUA_OPPOW:  performs exponentiation (^)
    • 
 
  • LUA_OPUNM:  performs mathematical negation (unary -)
    • 
-
  • LUA_OPBNOT:  performs bitwise negation (~)
    • 
-
  • LUA_OPBAND:  performs bitwise and (&)
    • 
-
  • LUA_OPBOR:  performs bitwise or (|)
    • 
-
  • LUA_OPBXOR:  performs bitwise exclusive or (~)
    • 
+
  • LUA_OPBNOT:  performs bitwise NOT (~)
    • 
+
  • LUA_OPBAND:  performs bitwise AND (&)
    • 
+
  • LUA_OPBOR:  performs bitwise OR (|)
    • 
+
  • LUA_OPBXOR:  performs bitwise exclusive OR (~)
    • 
 
  • LUA_OPSHL:  performs left shift (<<)
    • 
 
  • LUA_OPSHR:  performs right shift (>>)
    • 
 
@@ -3142,7 +3170,8 @@ The function results are pushed onto the stack when the function returns.
 The number of results is adjusted to nresults,
 unless nresults is LUA_MULTRET.
 In this case, all results from the function are pushed.
-Lua takes care that the returned values fit into the stack space.
+Lua takes care that the returned values fit into the stack space,
+but it does not ensure any extra space in the stack.
 The function results are pushed onto the stack in direct order
 (the first result is pushed first),
 so that after the call the last result is on the top of the stack.
@@ -3224,7 +3253,7 @@ many results.
 
 
    
 As an example, the following function receives a variable number
-of numerical arguments and returns their average and their sum:
+of numeric arguments and returns their average and their sum:
 
 
          static int foo (lua_State *L) {
@@ -3252,14 +3281,15 @@ of numerical arguments and returns their average and their sum:
 
    int lua_checkstack (lua_State *L, int n);
    
 
 
    
-Ensures that the stack has space for at least n extra slots.
+Ensures that the stack has space for at least n extra slots
+(that is, that you can safely push up to n values into it).
 It returns false if it cannot fulfill the request,
 either because it would cause the stack
 to be larger than a fixed maximum size
 (typically at least several thousand elements) or
 because it cannot allocate memory for the extra space.
 This function never shrinks the stack;
-if the stack is already larger than the new size,
+if the stack already has space for the extra slots,
 it is left unchanged.
 
 
@@ -3344,7 +3374,7 @@ Values at other positions are not affected.
 
 
 
    lua_createtable
    
-[-0, +1, e]
+[-0, +1, m]
 
    void lua_createtable (lua_State *L, int narr, int nrec);
    
 
 
    
@@ -3354,7 +3384,7 @@ will have as a sequence;
 parameter nrec is a hint for how many other elements
 the table will have.
 Lua may use these hints to preallocate memory for the new table.
-This pre-allocation is useful for performance when you know in advance
+This preallocation is useful for performance when you know in advance
 how many elements the table will have.
 Otherwise you can use the function lua_newtable.
 
@@ -3363,7 +3393,7 @@ Otherwise you can use the function lua_newtable
    lua_dump
    
-[-0, +0, e]
+[-0, +0, –]
 
    int lua_dump (lua_State *L,
                         lua_Writer writer,
                         void *data,
@@ -3383,8 +3413,9 @@ to write them.
 
 
    
 If strip is true,
-the binary representation is created without debug information
-about the function.
+the binary representation may not include all debug information
+about the function,
+to save space.
 
 
 
    
@@ -3416,7 +3447,7 @@ and therefore never returns
 
 
 
    lua_gc
    
-[-0, +0, e]
+[-0, +0, m]
 
    int lua_gc (lua_State *L, int what, int data);
    
 
 
    
@@ -3661,7 +3692,7 @@ By default this type is long long,
 (usually a 64-bit two-complement integer),
 but that can be changed to long or int
 (usually a 32-bit two-complement integer).
-(See LUA_INT in luaconf.h.)
+(See LUA_INT_TYPE in luaconf.h.)
 
 
 
    
@@ -3850,7 +3881,7 @@ and 0 otherwise.
 
 
    
 The type for continuation-function contexts.
-It must be a numerical type.
+It must be a numeric type.
 This type is defined as intptr_t
 when intptr_t is available,
 so that it can store pointers too.
@@ -3911,7 +3942,7 @@ The return values of lua_load are:
 syntax error during precompilation;
 
 
  • LUA_ERRMEM: 
-memory allocation error;
    • 
+memory allocation (out-of-memory) error;
 
 
  • LUA_ERRGCMM: 
 error while running a __gc metamethod.
@@ -3976,7 +4007,7 @@ passes to the allocator in every call.
 
 
 
    lua_newtable
    
-[-0, +1, e]
+[-0, +1, m]
 
    void lua_newtable (lua_State *L);
    
 
 
    
@@ -3988,7 +4019,7 @@ It is equivalent to lua_createtable(L, 0, 0).
 
 
 
    lua_newthread
    
-[-0, +1, e]
+[-0, +1, m]
 
    lua_State *lua_newthread (lua_State *L);
    
 
 
    
@@ -4009,7 +4040,7 @@ like any Lua object.
 
 
 
    lua_newuserdata
    
-[-0, +1, e]
+[-0, +1, m]
 
    void *lua_newuserdata (lua_State *L, size_t size);
    
 
 
    
@@ -4068,7 +4099,7 @@ the table during its traversal.
 
 
 
    lua_Number
    
-
    typedef double lua_Number;
    
+
    typedef ... lua_Number;
    
 
 
    
 The type of floats in Lua.
@@ -4076,8 +4107,8 @@ The type of floats in Lua.
 
 
    
 By default this type is double,
-but that can be changed to a single float.
-(See LUA_REAL in luaconf.h.)
+but that can be changed to a single float or a long double.
+(See LUA_FLOAT_TYPE in luaconf.h.)
 
 
 
@@ -4120,7 +4151,7 @@ If there are no errors during the call,
 lua_pcall behaves exactly like lua_call.
 However, if there is any error,
 lua_pcall catches it,
-pushes a single value on the stack (the error message),
+pushes a single value on the stack (the error object),
 and returns an error code.
 Like lua_call,
 lua_pcall always removes the function
@@ -4129,20 +4160,20 @@ and its arguments from the stack.
 
 
    
 If msgh is 0,
-then the error message returned on the stack
-is exactly the original error message.
+then the error object returned on the stack
+is exactly the original error object.
 Otherwise, msgh is the stack index of a
 message handler.
-(In the current implementation, this index cannot be a pseudo-index.)
+(This index cannot be a pseudo-index.)
 In case of runtime errors,
-this function will be called with the error message
-and its return value will be the message
+this function will be called with the error object
+and its return value will be the object
 returned on the stack by lua_pcall.
 
 
 
    
 Typically, the message handler is used to add more debug
-information to the error message, such as a stack traceback.
+information to the error object, such as a stack traceback.
 Such information cannot be gathered after the return of lua_pcall,
 since by then the stack has unwound.
 
@@ -4219,7 +4250,7 @@ Pushes a boolean value with value b onto the stack.
 
 
 
    lua_pushcclosure
    
-[-n, +1, e]
+[-n, +1, m]
 
    void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
    
 
 
    
@@ -4267,20 +4298,11 @@ when called, invokes the corresponding C function.
 
 
 
    
-Any function to be registered in Lua must
+Any function to be callable by Lua must
 follow the correct protocol to receive its parameters
 and return its results (see lua_CFunction).
 
 
-
    
-lua_pushcfunction is defined as a macro:
-
-
    -     #define lua_pushcfunction(L,f)  lua_pushcclosure(L,f,0)
-
    
-Note that f is used twice.
-
-
 
 
 
@@ -4309,7 +4331,7 @@ The conversion specifiers can only be
 '%%' (inserts the character '%'),
 '%s' (inserts a zero-terminated string, with no size restrictions),
 '%f' (inserts a lua_Number),
-'%L' (inserts a lua_Integer),
+'%I' (inserts a lua_Integer),
 '%p' (inserts a pointer as a hexadecimal numeral),
 '%d' (inserts an int),
 '%c' (inserts an int as a one-byte character), and
@@ -4318,6 +4340,12 @@ The conversion specifiers can only be
 
 
 
+
    
+Unlike other push functions,
+this function checks for the stack space it needs,
+including the slot for its result.
+
+
 
 
 
@@ -4365,20 +4393,19 @@ light userdata with the same C address.
 
 
 
    lua_pushliteral
    
-[-0, +1, e]
+[-0, +1, m]
 
    const char *lua_pushliteral (lua_State *L, const char *s);
    
 
 
    
-This macro is equivalent to lua_pushlstring,
-but can be used only when s is a literal string.
-It automatically provides the string length.
+This macro is equivalent to lua_pushstring,
+but should be used only when s is a literal string.
 
 
 
 
 
 
    lua_pushlstring
    
-[-0, +1, e]
+[-0, +1, m]
 
    const char *lua_pushlstring (lua_State *L, const char *s, size_t len);
    
 
 
    
@@ -4421,7 +4448,7 @@ Pushes a float with value n onto the stack.
 
 
 
    lua_pushstring
    
-[-0, +1, e]
+[-0, +1, m]
 
    const char *lua_pushstring (lua_State *L, const char *s);
    
 
 
    
@@ -4468,7 +4495,7 @@ onto the stack.
 
 
 
    lua_pushvfstring
    
-[-0, +1, e]
+[-0, +1, m]
 
    const char *lua_pushvfstring (lua_State *L,
                               const char *fmt,
                               va_list argp);
    
@@ -4488,7 +4515,7 @@ instead of a variable number of arguments.
 
    
 Returns 1 if the two values in indices index1 and
 index2 are primitively equal
-(that is, without calling metamethods).
+(that is, without calling the __eq metamethod).
 Otherwise returns 0.
 Also returns 0 if any of the indices are not valid.
 
@@ -4515,8 +4542,8 @@ Similar to lua_gettable, but does a raw
 
    
 Pushes onto the stack the value t[n],
 where t is the table at the given index.
-The access is raw;
-that is, it does not invoke metamethods.
+The access is raw,
+that is, it does not invoke the __index metamethod.
 
 
 
    
@@ -4535,7 +4562,7 @@ Pushes onto the stack the value t[k],
 where t is the table at the given index and
 k is the pointer p represented as a light userdata.
 The access is raw;
-that is, it does not invoke metamethods.
+that is, it does not invoke the __index metamethod.
 
 
 
    
@@ -4563,7 +4590,7 @@ for other values, it is 0.
 
 
 
    lua_rawset
    
-[-2, +0, e]
+[-2, +0, m]
 
    void lua_rawset (lua_State *L, int index);
    
 
 
    
@@ -4575,7 +4602,7 @@ Similar to lua_settable, but does a raw
 
 
 
    lua_rawseti
    
-[-1, +0, e]
+[-1, +0, m]
 
    void lua_rawseti (lua_State *L, int index, lua_Integer i);
    
 
 
    
@@ -4586,28 +4613,28 @@ and v is the value at the top of the stack.
 
 
    
 This function pops the value from the stack.
-The assignment is raw;
-that is, it does not invoke metamethods.
+The assignment is raw,
+that is, it does not invoke the __newindex metamethod.
 
 
 
 
 
 
    lua_rawsetp
    
-[-1, +0, e]
+[-1, +0, m]
 
    void lua_rawsetp (lua_State *L, int index, const void *p);
    
 
 
    
-Does the equivalent of t[k] = v,
+Does the equivalent of t[p] = v,
 where t is the table at the given index,
-k is the pointer p represented as a light userdata,
+p is encoded as a light userdata,
 and v is the value at the top of the stack.
 
 
 
    
 This function pops the value from the stack.
-The assignment is raw;
-that is, it does not invoke metamethods.
+The assignment is raw,
+that is, it does not invoke __newindex metamethod.
 
 
 
@@ -4672,7 +4699,7 @@ because a pseudo-index is not an actual stack position.
 
    
 Moves the top element into the given valid index
 without shifting any element
-(therefore replacing the value at the given index),
+(therefore replacing the value at that given index),
 and then pops the top element.
 
 
@@ -4684,7 +4711,7 @@ and then pops the top element.
 
    int lua_resume (lua_State *L, lua_State *from, int nargs);
    
 
 
    
-Starts and resumes a coroutine in a given thread.
+Starts and resumes a coroutine in the given thread L.
 
 
 
    
@@ -4706,7 +4733,7 @@ or an error code in case of errors (see lua_pcall
@@ -4731,12 +4758,16 @@ this parameter can be NULL.
 
    void lua_rotate (lua_State *L, int idx, int n);
    
 
 
    
-Rotates the stack elements from idx to the top n positions
-in the direction of the top, for a positive n,
+Rotates the stack elements between the valid index idx
+and the top of the stack.
+The elements are rotated n positions in the direction of the top,
+for a positive n,
 or -n positions in the direction of the bottom,
 for a negative n.
 The absolute value of n must not be greater than the size
 of the slice being rotated.
+This function cannot be called with a pseudo-index,
+because a pseudo-index is not an actual stack position.
 
 
 
@@ -4993,13 +5024,13 @@ indicates whether the operation succeeded.
 
 
 
    lua_tolstring
    
-[-0, +0, e]
+[-0, +0, m]
 
    const char *lua_tolstring (lua_State *L, int index, size_t *len);
    
 
 
    
 Converts the Lua value at the given index to a C string.
 If len is not NULL,
-it also sets *len with the string length.
+it sets *len with the string length.
 The Lua value must be a string or a number;
 otherwise, the function returns NULL.
 If the value is a number,
@@ -5010,7 +5041,7 @@ when lua_tolstring is applied to keys during a table traversal.)
 
 
 
    
-lua_tolstring returns a fully aligned pointer
+lua_tolstring returns a pointer
 to a string inside the Lua state.
 This string always has a zero ('\0')
 after its last character (as in C),
@@ -5072,14 +5103,14 @@ There is no way to convert the pointer back to its original value.
 
 
 
    
-Typically this function is used only for debug information.
+Typically this function is used only for hashing and debug information.
 
 
 
 
 
 
    lua_tostring
    
-[-0, +0, e]
+[-0, +0, m]
 
    const char *lua_tostring (lua_State *L, int index);
    
 
 
    
@@ -5127,7 +5158,7 @@ Returns the type of the value in the given valid index,
 or LUA_TNONE for a non-valid (but acceptable) index.
 The types returned by lua_type are coded by the following constants
 defined in lua.h:
-LUA_TNIL,
+LUA_TNIL (0),
 LUA_TNUMBER,
 LUA_TBOOLEAN,
 LUA_TSTRING,
@@ -5177,11 +5208,13 @@ the running function (see §4.4).
 
 
 
    lua_version
    
-[-0, +0, v]
+[-0, +0, –]
 
    const lua_Number *lua_version (lua_State *L);
    
 
 
    
-Returns the address of the version number stored in the Lua core.
+Returns the address of the version number
+(a C static variable)
+stored in the Lua core.
 When called with a valid lua_State,
 returns the address of the version used to create that state.
 When called with NULL,
@@ -5285,9 +5318,9 @@ when the coroutine eventually resumes,
 it continues executing the continuation function.
 However, there is one special case,
 which is when this function is called
-from inside a line hook (see §4.9).
+from inside a line or a count hook (see §4.9).
 In that case, lua_yieldk should be called with no continuation
-(probably in the form of lua_yield),
+(probably in the form of lua_yield) and no results,
 and the hook should return immediately after the call.
 Lua will yield and,
 when the coroutine resumes again,
@@ -5618,24 +5651,26 @@ it returns 0.
 
    const char *lua_getupvalue (lua_State *L, int funcindex, int n);
    
 
 
    
-Gets information about a closure's upvalue.
-(For Lua functions,
-upvalues are the external local variables that the function uses,
-and that are consequently included in its closure.)
-lua_getupvalue gets the index n of an upvalue,
-pushes the upvalue's value onto the stack,
+Gets information about the n-th upvalue
+of the closure at index funcindex.
+It pushes the upvalue's value onto the stack
 and returns its name.
-funcindex points to the closure in the stack.
-(Upvalues have no particular order,
-as they are active through the whole function.
-So, they are numbered in an arbitrary order.)
+Returns NULL (and pushes nothing)
+when the index n is greater than the number of upvalues.
 
 
 
    
-Returns NULL (and pushes nothing)
-when the index is greater than the number of upvalues.
 For C functions, this function uses the empty string ""
 as a name for all upvalues.
+(For Lua functions,
+upvalues are the external local variables that the function uses,
+and that are consequently included in its closure.)
+
+
+
    
+Upvalues have no particular order,
+as they are active through the whole function.
+They are numbered in an arbitrary order.
 
 
 
@@ -5680,10 +5715,10 @@ that is, they cannot call lua_yieldk,
 
 
    
 Hook functions can yield under the following conditions:
-Only count and line events can yield
-and they cannot yield any value;
-to yield a hook function must finish its execution
-calling lua_yield with nresults equal to zero.
+Only count and line events can yield;
+to yield, a hook function must finish its execution
+calling lua_yield with nresults equal to zero
+(that is, with no values).
 
 
 
@@ -5700,7 +5735,7 @@ Sets the debugging hook function.
 
    
 Argument f is the hook function.
 mask specifies on which events the hook will be called:
-it is formed by a bitwise or of the constants
+it is formed by a bitwise OR of the constants
 LUA_MASKCALL,
 LUA_MASKRET,
 LUA_MASKLINE,
@@ -5748,9 +5783,7 @@ A hook is disabled by setting mask to zero.
 
 
    
 Sets the value of a local variable of a given activation record.
-Parameters ar and n are as in lua_getlocal
-(see lua_getlocal).
-lua_setlocal assigns the value at the top of the stack
+It assigns the value at the top of the stack
 to the variable and returns its name.
 It also pops the value from the stack.
 
@@ -5761,6 +5794,10 @@ when the index is greater than
 the number of active local variables.
 
 
+
    
+Parameters ar and n are as in function lua_getlocal.
+
+
 
 
 
@@ -5773,13 +5810,15 @@ Sets the value of a closure's upvalue.
 It assigns the value at the top of the stack
 to the upvalue and returns its name.
 It also pops the value from the stack.
-Parameters funcindex and n are as in the lua_getupvalue
-(see lua_getupvalue).
 
 
 
    
 Returns NULL (and pops nothing)
-when the index is greater than the number of upvalues.
+when the index n is greater than the number of upvalues.
+
+
+
    
+Parameters funcindex and n are as in function lua_getupvalue.
 
 
 
@@ -5792,9 +5831,6 @@ when the index is greater than the number of upvalues.
 
    
 Returns a unique identifier for the upvalue numbered n
 from the closure at index funcindex.
-Parameters funcindex and n are as in the lua_getupvalue
-(see lua_getupvalue)
-(but n cannot be greater than the number of upvalues).
 
 
 
    
@@ -5805,6 +5841,11 @@ Lua closures that share an upvalue
 will return identical ids for those upvalue indices.
 
 
+
    
+Parameters funcindex and n are as in function lua_getupvalue,
+but n cannot be greater than the number of upvalues.
+
+
 
 
 
@@ -5880,7 +5921,7 @@ in alphabetical order.
 
 
 
    luaL_addchar
    
-[-?, +?, e]
+[-?, +?, m]
 
    void luaL_addchar (luaL_Buffer *B, char c);
    
 
 
    
@@ -5892,7 +5933,7 @@ Adds the byte c to the buffer B
 
 
 
    luaL_addlstring
    
-[-?, +?, e]
+[-?, +?, m]
 
    void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);
    
 
 
    
@@ -5906,7 +5947,7 @@ The string can contain embedded zeros.
 
 
 
    luaL_addsize
    
-[-?, +?, e]
+[-?, +?, –]
 
    void luaL_addsize (luaL_Buffer *B, size_t n);
    
 
 
    
@@ -5919,7 +5960,7 @@ buffer area (see luaL_prepbuffer).
 
 
 
    luaL_addstring
    
-[-?, +?, e]
+[-?, +?, m]
 
    void luaL_addstring (luaL_Buffer *B, const char *s);
    
 
 
    
@@ -5932,7 +5973,7 @@ to the buffer B
 
 
 
    luaL_addvalue
    
-[-1, +?, e]
+[-1, +?, m]
 
    void luaL_addvalue (luaL_Buffer *B);
    
 
 
    
@@ -6070,7 +6111,7 @@ the buffer must be declared as a variable
 
 
 
    luaL_buffinitsize
    
-[-?, +?, e]
+[-?, +?, m]
 
    char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz);
    
 
 
    
@@ -6246,7 +6287,7 @@ returns the userdata address (see lua_touserdata
 
 
 
    luaL_checkversion
    
-[-0, +0, –]
+[-0, +0, v]
 
    void luaL_checkversion (lua_State *L);
    
 
 
    
@@ -6321,7 +6362,7 @@ as return luaL_error(args).
 
 
 
    luaL_execresult
    
-[-0, +3, e]
+[-0, +3, m]
 
    int luaL_execresult (lua_State *L, int stat);
    
 
 
    
@@ -6334,7 +6375,7 @@ process-related functions in the standard library
 
 
 
    luaL_fileresult
    
-[-0, +(1|3), e]
+[-0, +(1|3), m]
 
    int luaL_fileresult (lua_State *L, int stat, const char *fname);
    
 
 
    
@@ -6347,7 +6388,7 @@ file-related functions in the standard library
 
 
 
    luaL_getmetafield
    
-[-0, +(0|1), e]
+[-0, +(0|1), m]
 
    int luaL_getmetafield (lua_State *L, int obj, const char *e);
    
 
 
    
@@ -6362,14 +6403,14 @@ pushes nothing and returns LUA_TNIL.
 
 
 
    luaL_getmetatable
    
-[-0, +1, –]
+[-0, +1, m]
 
    int luaL_getmetatable (lua_State *L, const char *tname);
    
 
 
    
 Pushes onto the stack the metatable associated with name tname
-in the registry (see luaL_newmetatable).
-If there is no metatable associated with tname,
-returns false and pushes nil.
+in the registry (see luaL_newmetatable)
+(nil if there is no metatable associated with that name).
+Returns the type of the pushed value.
 
 
 
@@ -6392,7 +6433,7 @@ and false if it creates a new table.
 
 
 
    luaL_gsub
    
-[-0, +1, e]
+[-0, +1, m]
 
    const char *luaL_gsub (lua_State *L,
                        const char *s,
                        const char *p,
@@ -6462,7 +6503,7 @@ The string mode works as in function lua_
 
 
 
    luaL_loadfile
    
-[-0, +1, e]
+[-0, +1, m]
 
    int luaL_loadfile (lua_State *L, const char *filename);
    
 
 
    
@@ -6473,7 +6514,7 @@ Equivalent to luaL_loadfilex with 
    luaL_loadfilex
    
-[-0, +1, e]
+[-0, +1, m]
 
    int luaL_loadfilex (lua_State *L, const char *filename,
                                             const char *mode);
    
 
@@ -6527,7 +6568,7 @@ it does not run it.
 
 
 
    luaL_newlib
    
-[-0, +1, e]
+[-0, +1, m]
 
    void luaL_newlib (lua_State *L, const luaL_Reg l[]);
    
 
 
    
@@ -6549,7 +6590,7 @@ not a pointer to it.
 
 
 
    luaL_newlibtable
    
-[-0, +1, e]
+[-0, +1, m]
 
    void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);
    
 
 
    
@@ -6570,7 +6611,7 @@ not a pointer to it.
 
 
 
    luaL_newmetatable
    
-[-0, +1, e]
+[-0, +1, m]
 
    int luaL_newmetatable (lua_State *L, const char *tname);
    
 
 
    
@@ -6624,6 +6665,27 @@ Opens all standard Lua libraries into the given state.
 
 
 
+
    luaL_opt
    
+[-0, +0, e]
+
    T luaL_opt (L, func, arg, dflt);
    
+
+
    
+This macro is defined as follows:
+
+
    +     (lua_isnoneornil(L,(arg)) ? (dflt) : func(L,(arg)))
+
    
+In words, if the argument arg is nil or absent,
+the macro results in the default dflt.
+Otherwise, it results in the result of calling func
+with the state L and the argument index arg as
+parameters.
+Note that it evaluates the expression dflt only if needed.
+
+
+
+
+
 
    luaL_optinteger
    
 [-0, +0, v]
 
    lua_Integer luaL_optinteger (lua_State *L,
@@ -6660,6 +6722,9 @@ Otherwise, raises an error.
 
    
 If l is not NULL,
 fills the position *l with the result's length.
+If the result is NULL
+(only possible when returning d and d == NULL),
+its length is considered zero.
 
 
 
@@ -6698,7 +6763,7 @@ Otherwise, raises an error.
 
 
 
    luaL_prepbuffer
    
-[-?, +?, e]
+[-?, +?, m]
 
    char *luaL_prepbuffer (luaL_Buffer *B);
    
 
 
    
@@ -6710,7 +6775,7 @@ with the predefined size LUAL_BUFFERSIZE
    luaL_prepbuffsize
    
-[-?, +?, e]
+[-?, +?, m]
 
    char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz);
    
 
 
    
@@ -6726,7 +6791,7 @@ it to the buffer.
 
 
 
    luaL_pushresult
    
-[-?, +1, e]
+[-?, +1, m]
 
    void luaL_pushresult (luaL_Buffer *B);
    
 
 
    
@@ -6738,7 +6803,7 @@ the top of the stack.
 
 
 
    luaL_pushresultsize
    
-[-?, +1, e]
+[-?, +1, m]
 
    void luaL_pushresultsize (luaL_Buffer *B, size_t sz);
    
 
 
    
@@ -6749,7 +6814,7 @@ Equivalent to the sequence luaL_addsize
 
 
 
    luaL_ref
    
-[-1, +0, e]
+[-1, +0, m]
 
    int luaL_ref (lua_State *L, int t);
    
 
 
    
@@ -6820,7 +6885,7 @@ Leaves a copy of the module on the stack.
 
 
 
    luaL_setfuncs
    
-[-nup, +0, e]
+[-nup, +0, m]
 
    void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup);
    
 
 
    
@@ -6884,7 +6949,7 @@ this function receives the file handle as its sole argument and
 must return either true (in case of success)
 or nil plus an error message (in case of error).
 Once Lua calls this field,
-the field value is changed to NULL
+it changes the field value to NULL
 to signal that the handle is closed.
 
 
@@ -6892,7 +6957,7 @@ to signal that the handle is closed.
 
 
 
    luaL_testudata
    
-[-0, +0, e]
+[-0, +0, m]
 
    void *luaL_testudata (lua_State *L, int arg, const char *tname);
    
 
 
    
@@ -6918,7 +6983,7 @@ the function also sets *len with the string length.
 
 
 
    
-If the value has a metatable with a "__tostring" field,
+If the value has a metatable with a __tostring field,
 then luaL_tolstring calls the corresponding metamethod
 with the value as argument,
 and uses the result of the call as its result.
@@ -6928,7 +6993,7 @@ and uses the result of the call as its result.
 
 
 
    luaL_traceback
    
-[-0, +1, e]
+[-0, +1, m]
 
    void luaL_traceback (lua_State *L, lua_State *L1, const char *msg,
                      int level);
    
 
@@ -6975,7 +7040,7 @@ If ref is LUA_NOREF or 
    luaL_where
    
-[-0, +1, e]
+[-0, +1, m]
 
    void luaL_where (lua_State *L, int lvl);
    
 
 
    
@@ -7207,7 +7272,7 @@ nor vice versa.
 
    
 If object does not have a metatable, returns nil.
 Otherwise,
-if the object's metatable has a "__metatable" field,
+if the object's metatable has a __metatable field,
 returns the associated value.
 Otherwise, returns the metatable of the given object.
 
@@ -7333,7 +7398,7 @@ you can use next(t) to check whether a table is empty.
 
    
 The order in which the indices are enumerated is not specified,
 even for numeric indices.
-(To traverse a table in numeric order,
+(To traverse a table in numerical order,
 use a numerical for.)
 
 
@@ -7411,7 +7476,7 @@ use string.format and rawequal (v1, v2)
 Checks whether v1 is equal to v2,
-without invoking any metamethod.
+without invoking the __eq metamethod.
 Returns a boolean.
 
 
@@ -7420,7 +7485,7 @@ Returns a boolean.
 
    
 
    rawget (table, index)
    
 Gets the real value of table[index],
-without invoking any metamethod.
+without invoking the __index metamethod.
 table must be a table;
 index may be any value.
 
@@ -7431,7 +7496,7 @@ without invoking any metamethod.
 
    rawlen (v)
    
 Returns the length of the object v,
 which must be a table or a string,
-without invoking any metamethod.
+without invoking the __len metamethod.
 Returns an integer.
 
 
@@ -7440,7 +7505,7 @@ Returns an integer.
 
    
 
    rawset (table, index, value)
    
 Sets the real value of table[index] to value,
-without invoking any metamethod.
+without invoking the __newindex metamethod.
 table must be a table,
 index any value different from nil and NaN,
 and value any Lua value.
@@ -7472,10 +7537,11 @@ and select returns the total number of extra arguments it received.
 
 
    
 Sets the metatable for the given table.
-(You cannot change the metatable of other types from Lua, only from C.)
+(To change the metatable of other types from Lua code,
+you must use the debug library (§6.10).)
 If metatable is nil,
 removes the metatable of the given table.
-If the original metatable has a "__metatable" field,
+If the original metatable has a __metatable field,
 raises an error.
 
 
@@ -7522,14 +7588,12 @@ the function returns nil.
 
    tostring (v)
    
 Receives a value of any type and
 converts it to a string in a human-readable format.
-Floats always produce strings with some
-floating-point indication (either a decimal dot or an exponent).
 (For complete control of how numbers are converted,
 use string.format.)
 
 
 
    
-If the metatable of v has a "__tostring" field,
+If the metatable of v has a __tostring field,
 then tostring calls the corresponding value
 with v as argument,
 and uses the result of the call as its result.
@@ -7555,8 +7619,11 @@ and "userdata".
 
 
    
 
    _VERSION
    
+
+
+
    
 A global variable (not a function) that
-holds a string containing the current interpreter version.
+holds a string containing the running Lua version.
 The current value of this variable is "Lua 5.3".
 
 
@@ -7579,8 +7646,8 @@ except that it sets a new message handler msgh.
 
    6.2 – Coroutine Manipulation
    
 
 
    
-The operations related to coroutines comprise a sub-library of
-the basic library and come inside the table coroutine.
+This library comprises the operations to manipulate coroutines,
+which come inside the table coroutine.
 See §2.6 for a general description of coroutines.
 
 
@@ -7590,7 +7657,7 @@ See §2.6 for a general description of coroutines.
 
 
    
 Creates a new coroutine, with body f.
-f must be a Lua function.
+f must be a function.
 Returns this new coroutine,
 an object with type "thread".
 
@@ -7674,7 +7741,7 @@ or if it has stopped with an error.
 
 
    
 Creates a new coroutine, with body f.
-f must be a Lua function.
+f must be a function.
 Returns a function that resumes the coroutine each time it is called.
 Any arguments passed to the function behave as the
 extra arguments to resume.
@@ -8073,7 +8140,7 @@ The string library assumes one-byte character encodings.
 
 
    
 
    string.byte (s [, i [, j]])
    
-Returns the internal numerical codes of the characters s[i],
+Returns the internal numeric codes of the characters s[i],
 s[i+1], ..., s[j].
 The default value for i is 1;
 the default value for j is i.
@@ -8082,7 +8149,7 @@ following the same rules of function string.sub<
 
 
 
    
-Numerical codes are not necessarily portable across platforms.
+Numeric codes are not necessarily portable across platforms.
 
 
 
@@ -8091,12 +8158,12 @@ Numerical codes are not necessarily portable across platforms.
 
    string.char (···)
    
 Receives zero or more integers.
 Returns a string with length equal to the number of arguments,
-in which each character has the internal numerical code equal
+in which each character has the internal numeric code equal
 to its corresponding argument.
 
 
 
    
-Numerical codes are not necessarily portable across platforms.
+Numeric codes are not necessarily portable across platforms.
 
 
 
@@ -8112,9 +8179,9 @@ of the given function,
 so that a later load on this string returns
 a copy of the function (but with new upvalues).
 If strip is a true value,
-the binary representation is created without debug information
-about the function
-(local variable names, lines, etc.).
+the binary representation may not include all debug information
+about the function,
+to save space.
 
 
 
    
@@ -8138,7 +8205,7 @@ Looks for the first match of
 If it finds a match, then find returns the indices of s
 where this occurrence starts and ends;
 otherwise, it returns nil.
-A third, optional numerical argument init specifies
+A third, optional numeric argument init specifies
 where to start the search;
 its default value is 1 and can be negative.
 A value of true as a fourth, optional argument plain
@@ -8169,6 +8236,9 @@ The only differences are that the options/modifiers
 *, h, L, l, n,
 and p are not supported
 and that there is an extra option, q.
+
+
+
    
 The q option formats a string between double quotes,
 using escape sequences when necessary to ensure that
 it can safely be read back by the Lua interpreter.
@@ -8186,16 +8256,22 @@ may produce the string:
 
 
    
 Options
-A and a (when available),
-E, e, f,
+A, a, E, e, f,
 G, and g all expect a number as argument.
 Options c, d,
 i, o, u, X, and x
 expect an integer.
-Option q expects a string;
-option s expects a string without embedded zeros.
-If the argument to option s is not a string,
+When Lua is compiled with a C89 compiler,
+options A and a (hexadecimal floats)
+do not support any modifier (flags, width, length).
+
+
+
    
+Option s expects a string;
+if its argument is not a string,
 it is converted to one following the same rules of tostring.
+If the option has any modifier (flags, width, length),
+the string argument should not contain embedded zeros.
 
 
 
@@ -8344,7 +8420,7 @@ the captures from the pattern;
 otherwise it returns nil.
 If pattern specifies no captures,
 then the whole match is returned.
-A third, optional numerical argument init specifies
+A third, optional numeric argument init specifies
 where to start the search;
 its default value is 1 and can be negative.
 
@@ -8385,6 +8461,11 @@ The default value for sep is the empty string
 Returns the empty string if n is not positive.
 
 
+
    
+(Note that it is very easy to exhaust the memory of your machine
+with a single call to this function.)
+
+
 
 
 
    
@@ -8499,7 +8580,7 @@ represents the character x itself.
 represents the character x.
 This is the standard way to escape the magic characters.
 Any non-alphanumeric character
-(including all punctuations, even the non-magical)
+(including all punctuation characters, even the non-magical)
 can be preceded by a '%'
 when used to represent itself in a pattern.
 
    • 
@@ -8520,6 +8601,14 @@ and [0-7%l%-] represents the octal digits plus
 the lowercase letters plus the '-' character.
 
 
+
    
+You can put a closing square bracket in a set
+by positioning it as the first character in the set.
+You can put an hyphen in a set
+by positioning it as the first or the last character in the set.
+(You can also use an escape for both cases.)
+
+
 
    
 The interaction between ranges and classes is not defined.
 Therefore, patterns like [%a-z] or [a-%%]
@@ -8898,13 +8987,17 @@ of list t.
 
 
 
    
-Moves elements from table a1 to table a2.
-This function performs the equivalent to the following
+Moves elements from table a1 to table a2,
+performing the equivalent to the following
 multiple assignment:
 a2[t],··· = a1[f],···,a1[e].
 The default for a2 is a1.
 The destination range can overlap with the source range.
-Index f must be positive.
+The number of elements to be moved must fit in a Lua integer.
+
+
+
    
+Returns the destination table a2.
 
 
 
@@ -8956,14 +9049,23 @@ If comp is given,
 then it must be a function that receives two list elements
 and returns true when the first element must come
 before the second in the final order
-(so that not comp(list[i+1],list[i]) will be true after the sort).
+(so that, after the sort,
+i < j implies not comp(list[j],list[i])).
 If comp is not given,
 then the standard Lua operator < is used instead.
 
 
+
    
+Note that the comp function must define
+a strict partial order over the elements in the list;
+that is, it must be asymmetric and transitive.
+Otherwise, no valid sort may be possible.
+
+
 
    
 The sort algorithm is not stable;
-that is, elements considered equal by the given order
+that is, elements not comparable by the given order
+(e.g., equal elements)
 may have their relative positions changed by the sort.
 
 
@@ -9120,7 +9222,7 @@ that rounds the quotient towards zero. (integer/float)
 
 
    
 The float value HUGE_VAL,
-a value larger than any other numerical value.
+a value larger than any other numeric value.
 
 
 
@@ -9215,14 +9317,13 @@ in the range  [0,1).
 When called with two integers m and n,
 math.random returns a pseudo-random integer
 with uniform distribution in the range [m, n].
-(The value m-n cannot be negative and must fit in a Lua integer.)
+(The value n-m cannot be negative and must fit in a Lua integer.)
 The call math.random(n) is equivalent to math.random(1,n).
 
 
 
    
 This function is an interface to the underling
 pseudo-random generator function provided by C.
-No guarantees can be given for its statistical properties.
 
 
 
@@ -9390,7 +9491,7 @@ instead of returning an error code.
 
 
 
    
-
    io.lines ([filename ···])
    
+
    io.lines ([filename, ···])
    
 
 
 
    
@@ -9422,8 +9523,8 @@ instead of returning an error code.
 
    
 This function opens a file,
 in the mode specified in the string mode.
-It returns a new file handle,
-or, in case of errors, nil plus an error message.
+In case of success,
+it returns a new file handle.
 
 
 
    
@@ -9488,7 +9589,8 @@ Equivalent to io.input():read(···).
 
 
 
    
-Returns a handle for a temporary file.
+In case of success,
+returns a handle for a temporary file.
 This file is opened in update mode
 and it is automatically removed when the program ends.
 
@@ -9602,16 +9704,12 @@ reads a numeral and returns it as a float or an integer,
 following the lexical conventions of Lua.
 (The numeral may have leading spaces and a sign.)
 This format always reads the longest input sequence that
-is a valid prefix for a number;
-if that prefix does not form a valid number
+is a valid prefix for a numeral;
+if that prefix does not form a valid numeral
 (e.g., an empty string, "0x", or "3.4e-"),
 it is discarded and the function returns nil.
 
 
-
  • "i": 
-reads an integral number and returns it as an integer.
-
    • 
-
 
  • "a": 
 reads the whole file, starting at the current position.
 On end of file, it returns the empty string.
@@ -9768,10 +9866,10 @@ then the date is formatted in Coordinated Universal Time.
 After this optional character,
 if format is the string "*t",
 then date returns a table with the following fields:
-year (four digits), month (1–12), day (1–31),
+year, month (1–12), day (1–31),
 hour (0–23), min (0–59), sec (0–61),
-wday (weekday, Sunday is 1),
-yday (day of the year),
+wday (weekday, 1–7, Sunday is 1),
+yday (day of the year, 1–366),
 and isdst (daylight saving flag, a boolean).
 This last field may be absent
 if the information is not available.
@@ -9786,8 +9884,8 @@ formatted according to the same rules as the ISO C function strftime<
 
    
 When called without arguments,
 date returns a reasonable date and time representation that depends on
-the host system and on the current locale
-(that is, os.date() is equivalent to os.date("%c")).
+the host system and on the current locale.
+(More specifically, os.date() is equivalent to os.date("%c").)
 
 
 
    
@@ -9946,16 +10044,25 @@ because of its reliance on C function setlocale.
 
 
    
 Returns the current time when called without arguments,
-or a time representing the date and time specified by the given table.
+or a time representing the local date and time specified by the given table.
 This table must have fields year, month, and day,
 and may have fields
 hour (default is 12),
 min (default is 0),
 sec (default is 0),
 and isdst (default is nil).
+Other fields are ignored.
 For a description of these fields, see the os.date function.
 
 
+
    
+The values in these fields do not need to be inside their valid ranges.
+For instance, if sec is -10,
+it means -10 seconds from the time specified by the other fields;
+if hour is 1000,
+it means +1000 hours from the time specified by the other fields.
+
+
 
    
 The returned value is a number, whose meaning depends on your system.
 In POSIX, Windows, and some other systems,
@@ -10093,7 +10200,7 @@ valid lines.
 
 
    
 For instance, the expression debug.getinfo(1,"n").name returns
-a table with a name for the current function,
+a name for the current function,
 if a reasonable name can be found,
 and the expression debug.getinfo(print)
 returns a table with all available information
@@ -10464,6 +10571,14 @@ the interpreter waits for its completion
 by issuing a different prompt.
 
 
+
    
+If the global variable _PROMPT contains a string,
+then its value is used as the prompt.
+Similarly, if the global variable _PROMPT2 contains a string,
+its value is used as the secondary prompt
+(issued during incomplete statements).
+
+
 
    
 In case of unprotected errors in the script,
 the interpreter reports the error to the standard error stream.
@@ -10599,7 +10714,8 @@ The bit32 library has been deprecated.
 It is easy to require a compatible external library or,
 better yet, to replace its functions with appropriate bitwise operations.
 (Keep in mind that bit32 operates on 32-bit integers,
-while the bitwise operators in standard Lua operate on 64-bit integers.)
+while the bitwise operators in Lua 5.3 operate on Lua integers,
+which by default have 64 bits.)
 
    • 
 
 
  • 
@@ -10614,7 +10730,7 @@ its __ipairs metamethod has been deprecated.
 
 
  • 
 Option names in io.read do not have a starting '*' anymore.
-For compatibility, Lua will continue to ignore this character.
+For compatibility, Lua will continue to accept (and ignore) this character.
 
    • 
 
 
  • 
@@ -10641,6 +10757,12 @@ if it cannot find an open function according to the new style.
 but it did not document the change.)
 
    • 
 
+
  • 
+The call collectgarbage("count") now returns only one result.
+(You can compute that second result from the fractional part
+of the first result.)
+
    • 
+
 
 
 
@@ -10776,13 +10898,12 @@ and LiteralString, see §3.1.)
 
 
 
-
    
-
+
    
 Last update:
-Tue Jan  6 10:10:50 BRST 2015
-
+Mon May 30 13:11:08 BRT 2016
+
    
 
 
 
-- 
cgit v1.2.3