** Generic allocation routine. */

** Convert a number object to a Lua string, replacing the value at 'obj' */

** Clear API string cache. (Entries cannot be empty, so fill them with ** a non-collectable string.) */

** Initialize the string table and the string cache */

** dump Lua function as precompiled chunk */

** Load precompiled chunk. */

** finish execution of an opcode interrupted by a yield */

** Integer division; return 'm // n', that is, floor(m/n). ** C division truncates its result (rounds towards zero). ** 'floor(q) == trunc(q)' when 'q

** Main operation less than or equal to; return 'l <= r'. */

** Main operation less than; return 'l < r'. */

** Integer modulus; return 'm % n'. (Assume that C '%' with ** negative operands follows C99 behavior. See previous comment ** about luaV_idiv.) */

** Float modulus */

** try to convert a value to an integer. */

--------------------------------------------------------------- read --- */

** This function can be called during a signal, under "reasonable" ** assumptions. ** Fields 'basehookcount' and 'hookcount' (set by 'resethookcount')

** convert a hexadecimal numeric string to a number, following ** C99 specification for 'strtod' */

** compiles the main function, which is a regular vararg function with an ** upvalue named LUA_ENV */

** Convert a string mask (for 'sethook') into a bit mask */

** Mark block where variable at given level was defined ** (to emit close instructions later). */

** Adjust pending gotos to outer level of a block. */

** Given 'nres' results at 'firstResult', move 'wanted' of them to 'res'. ** Handle most typical cases (zero results for commands, one result for ** e

** Compute new size for buffer 'B', enough to accommodate extra 'sz' ** bytes. (The test for "not big enough" also gets the case when the ** computati

** Create a new upvalue at the given level, and link it to the list of ** open upvalues of 'L' after entry 'prev'. **/

** Add nil to list of constants and return its index. */

** return registry.LUA_NOENV as a boolean */

check whether pattern has no special characters */

** Count keys in array part of table 't': Fill 'nums[i]' with ** number of keys that will go into corresponding slice and return ** total number of no

** Does the partition: Pivot P is at the top of the stack. ** precondition: a[lo] <= P == a[up-1] <= a[up], ** so it only needs to do the partition fr

** Remove first element from the tbclist plus its dummy nodes. */

** Unrolls a coroutine in protected mode while there are recoverable ** errors, that is, errors inside a protected call. (Any error ** interrupts 'unr

** Prepare and call a closing method. ** If status is CLOSEKTOP, the call to the closing method will be pushed ** at the top of the stack. Otherwise,

from http://www.lua.org/pil/24.2.3.html

** create a new Lua closure, push it in the stack, and initialize ** its upvalues. */

** Given a path such as ";blabla.so;blublu.so", pushes the string ** ** no file 'blabla.so' ** no file 'blublu.so' */

** Serialize a floating-point number in such a way that it can be ** scanned back by Lua. Use hexadecimal format for "common" numbers ** (to preserve

** Read a number: first reads a valid prefix of a numeral into a buffer. ** Then it calls 'lua_stringtonumber' to check whether the format is ** corre

** Register a new local variable in the active 'Proto' (for debug ** information). */

** nums[i] = number of keys 'k' where 2^(i - 1) < k <= 2^i */

** (Re)insert all elements from the hash part of 'ot' into table 't'. */

** Change all pointers to the stack into offsets. */

** For each non-marked thread, simulates a barrier between each open ** upvalue and its value. (If the thread is collected, the value will be ** assig