“ To represent records, Lua uses the field name as an index. The language supports this representation by providing a.name as syntactic sugar for a ["name"] . There are several convenient ways to create tables in Lua (see §3.4.8) .
We use the term sequence to denote a table where the set of all positive numeric keys is equal to {1..n} for some integer n, which is called the length of the sequence (see §3.4.6) .
Like indices, the values of table fields can be of any type. In particular, because functions are first-class values, table fields can contain functions. ”

“ A function definition is an executable expression, whose value has type function. When Lua precompiles a chunk, all its function bodies are precompiled too. Then, whenever Lua executes the function definition, the function is instantiated (or closed) . This function instance (or closure) is the final value of the expression. ”

“ When a C function is created, it is possible to associate some values with it, thus creating a C closure (see §4.4) ; these values are then accessible to the function whenever it is called. To associate values with a C function, first these values should be pushed onto the stack (when there are multiple values, the first value is pushed first) . Then lua_pushcclosure is called to create and push the C function onto the stack, with the argument n telling how many values should be associated with the function. lua_pushcclosure also pops these values from the stack. ”

“ In order to communicate properly with Lua, a C function must use the following protocol, which defines the way parameters and results are passed: a C function receives its arguments from Lua in its stack in direct order (the first argument is pushed first) . ”

“ Tables, userdata, and threads are compared by reference: two objects are considered equal only if they are the same object. Every time you create a new object (a table, userdata, or thread) , this new object is different from any previously existing object. Closures with the same reference are always equal. Closures with any detectable difference (different behavior, different definition) are always different.
You can change the way that Lua compares tables and userdata by using the "eq" metamethod (see §2.4) . ”

“ Allows a program to traverse all fields of a table. Its first argument is a table and its second argument is an index in this table. next returns the next index of the table and its associated value. When called with nil as its second argument, next returns an initial index and its associated value. When called with the last index, or with nil in an empty table, next returns nil. If the second argument is absent, then it is interpreted as nil. In particular, you can use next (t) to check whether a table is empty. ”

“ Lua performs automatic memory management. This means that you have to worry neither about allocating memory for new objects nor about freeing it when the objects are no longer needed. Lua manages memory automatically by running a garbage collector to collect all dead objects (that is, objects that are no longer accessible from Lua) . All memory used by Lua is subject to automatic management: strings, tables, userdata, functions, threads, internal structures, etc. ”

“ A protected environment uses setjmp to set a recovery point; any error jumps to the most recent active recovery point.
If an error happens outside any protected environment, Lua calls a panic function (see lua_atpanic) and then calls abort, thus exiting the host application. Your panic function can avoid this exit by never returning (e.g., doing a long jump to your own recovery point outside Lua) .
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. However, there is no guarantees about stack space. ”

“ In particular, if you change the weakness to a stronger mode, Lua may still collect some items from that table before the change takes effect.
Only objects that have an explicit construction are removed from weak tables. Values, such as numbers and light C functions, are not subject to garbage collection, and therefore are not removed from weak tables (unless its associated value is collected) . Although strings are subject to garbage collection, they do not have an explicit construction, and therefore are not removed from weak tables. ”

“ Returns a table with information about a function. You can give the function directly or you can give a number as the value of f, which means the function running at level f of the call stack of the given thread: level 0 is the current function (getinfo itself) ; level 1 is the function that called getinfo (except for tail calls, which do not count on the stack) ; and so on. If f is a number larger than the number of active functions, then getinfo returns nil.
The returned table can contain all the fields returned by lua_getinfo, with the string what describing which fields to fill in. ”

“ For an object (table or userdata) to be finalized when collected, you must mark it for finalization. You mark an object for finalization when you set its metatable 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 is marked, you can freely change the __gc field of its metatable.
When a marked object becomes garbage, it is not collected immediately by the garbage collector. Instead, Lua puts it in a list. ”

“ All functions in the auxiliary library are built on top of the basic API, and so they provide nothing that cannot be done with that API. Nevertheless, the use of the auxiliary library ensures more consistency to your code. ”

“ Several functions in the auxiliary library use internally some extra stack slots. When a function in the auxiliary library uses less than five slots, it does not check the stack size; it simply assumes that there are enough slots.
Several functions in the auxiliary library are used to check C function arguments. Because the error message is formatted for arguments (e.g., "bad argument #1") , you should not use these functions for other stack values.
Functions called luaL_check* always throw an error if the check is not satisfied. ”

“ The second field, p, is how many elements the function pushes onto the stack. (Any function always pushes its results after popping its arguments.) A field in the form x|y means the function can push (or pop) x or y elements, depending on the situation; an interrogation mark '?' means that we cannot know how many elements the function pops/pushes by looking only at its arguments (e.g., they may depend on what is on the stack) . The third field, x, tells whether the function may throw errors: '-' means the function never throws any error; 'e' means the function may throw errors ”

“ Ensures that there are at least extra free stack slots in the stack. It returns false if it cannot fulfill the request, because it would cause the stack to be larger than a fixed maximum size (typically at least a few thousand elements) or because it cannot allocate memory for the new stack size. This function never shrinks the stack; if the stack is already larger than the new size, it is left unchanged. ”

“ The control structures if, while, and repeat have the usual meaning and familiar syntax:
stat ::= while exp do block end stat ::= repeat block until exp stat ::= if exp then block {elseif exp then block} [else block] end Lua also has a for statement, in two flavors (see §3.3.5) .
The condition expression of a control structure can return any value. Both false and nil are considered false. All values different from nil and false are considered true (in particular, the number 0 and the empty string are also true) . ”

“ A weak table is a table whose elements are weak references. A weak reference is ignored by the garbage collector. In other words, if the only references to an object are weak references, 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 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, the whole pair is removed from the table. ”

“ The package library provides basic facilities for loading modules in Lua. It exports one function directly in the global environment: require. Everything else is exported in a table name="pdf-package".
name="pdf-require" Loads the given module. The function starts by looking into the package.loaded table to determine whether modname is already loaded. If it is, then require returns the value stored at package.loaded [modname] . Otherwise, it tries to find a loader for the module. ”

“ This function returns table.
name="pdf-select" If index is a number, returns all arguments after argument number index; a negative number indexes from the end (-1 is the last argument) . Otherwise, index must be the string "#", and select returns the total number of extra arguments it received.
name="pdf-setmetatable" Sets the metatable for the given table. (You cannot change the metatable of other types from Lua, only from C.) If metatable is nil, removes the metatable of the given table. If the original metatable has a "__metatable" field, raises an error. ”

“ 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, 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.) ”

“ Receives any number of arguments and prints their values to stdout, using the tostring function to convert each argument to a string. print is not intended for formatted output, but only as a quick way to show a value, for instance for debugging. For complete control over the output, use string.format and io.write.
name="pdf-rawequal" Checks whether v1 is equal to v2, without invoking any metamethod. Returns a boolean.
name="pdf-rawget" Gets the real value of table [index] , without invoking any metamethod. table must be a table; index may be any value. ”

“ Numerical codes are not necessarily portable across platforms.
name="pdf-string.dump" Returns a string containing a binary representation of the given function, so that a later load on this string returns a copy of the function (but with new upvalues) .
name="pdf-string.find" Looks for the first match of pattern in the string s. 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 where to start the search; its default value is 1 and can be negative. ”

“ If there are more values than needed, the excess values are thrown away. If there are fewer values than needed, the list is extended with as many nil's as needed. If the list of expressions ends with a function call, then all values returned by that call enter the list of values, before the adjustment (except when the call is enclosed in parentheses; see §3.4) . ”

“ Several of its functions violate basic assumptions about Lua code (e.g., that variables local to a function cannot be accessed from outside; that userdata metatables cannot be changed by Lua code; that Lua programs do not crash) and therefore can compromise otherwise secure code. Moreover, some functions in this library may be slow.
All functions in this library are provided inside the name="pdf-debug" table. All functions that operate over a thread have an optional first argument which is the thread to operate over. The default is always the current thread. ”

“ It is easy to set up a module with regular Lua code. Modules are not expected to set global variables. Functions setfenv and getfenv were removed, because of the changes in environments. Function math.log10 is deprecated. Use math.log with 10 as its second argument, instead. Function loadstring is deprecated. Use load instead; it now accepts string arguments and are exactly equivalent to loadstring. Function table.maxn is deprecated. Write it in Lua if you really need it. Function os.execute now returns true when command terminates successfully and nil plus error information otherwise. ”

“ A pattern is a sequence of pattern items. A caret '^' at the beginning of a pattern anchors the match at the beginning of the subject string. A '$' at the end of a pattern anchors the match at the end of the subject string. ”

“ The reader must return a pointer to a block of memory with a new piece of the chunk and set size to the block size. The block must exist until the reader function is called again. To signal the end of the chunk, the reader must return NULL or set size to zero. The reader function may return pieces of any size greater than zero. ”

“ Lua implements an incremental mark-and-sweep collector. It uses two numbers to control its garbage-collection cycles: the garbage-collector pause and the garbage-collector step multiplier. Both use percentage points as units (e.g., a value of 100 means an internal value of 1) .
The garbage-collector pause controls how long the collector waits before starting a new cycle. Larger values make the collector less aggressive. Values smaller than 100 mean the collector will not wait to start a new cycle. ”