** 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'. */

** 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

** Remove the last instruction created, correcting line information ** accordingly. */

** Close the scope for all variables up to level 'tolevel'. ** (debug info.) */

** mark root set and reset all gray lists, to start a new collection */

** Parse and compile a multiple assignment. The first "variable" ** (a 'suffixedexp') was already read by the caller. ** ** assignment -> suffixedexp

** Find a "name" for a 'C' value in an RK instruction. */

for offsets larger than 32, rotate right by 64 - offset */

TODO: honor abort signals

** Call a few finalizers */

** Processes options 'e' and 'l', which involve running Lua code, and ** 'W', which also affects the state. ** Returns 0 if some code raises an error.

** Search the upvalues of the function 'fs' for one ** with the given 'name'. */

** Look for an active local variable with the name 'n' in the ** function 'fs'. If found, initialize 'var' with it and return ** its expression kind;

** Replace in the path (on the top of the stack) any occurrence ** of LUA_EXEC_DIR with the executable's path. */

** Register the random functions and initialize their state. */

** Set 'trap' for all active Lua frames. ** This function can be called during a signal, under "reasonable" ** assumptions. A new 'ci' is completely l

** Solves the goto at index 'g' to given 'label' and removes it ** from the list of pending goto's. ** If it jumps into the scope of some variable, ra

** Solves forward jumps. Check whether new label 'lb' matches any ** pending gotos in current block and solves them. Return true ** if any of the goto

** Does a major collection after last collection was a "bad collection". ** ** When the program is building a big structure, it allocates lots of ** m

** subexpr -> (simpleexp | unop subexpr) { binop subexpr } ** where 'binop' is any binary operator with a priority higher than 'limit' */

return i * 5 */

return i * 9 */

** Traverse a Lua closure, marking its prototype and its upvalues. ** (Both can be NULL while closure is being created.) */

** Traverse a prototype. (While a prototype is being build, its ** arrays can be larger than needed; the extra slots are filled with ** NULL, so the u

** Traverse a thread, marking the elements in the stack up to its top ** and cleaning the rest of the stack in the final traversal. That ** ensures th

** Traverse a table with weak values and link it to proper list. During ** propagate phase, keep it in 'grayagain' list, to be revisited in the ** ato

** Get the next udata to be finalized from the 'tobefnz' list, and ** link it back into the 'allgc' list. */

** generates an error for an undefined 'goto'. */

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

** Executes "full continuation" (everything in the stack) of a ** previously interrupted coroutine until the stack is empty (or another ** interruptio

** Return false if folding can raise an error. ** Bitwise operations need operands convertible to integers; division ** operations cannot have 0 as di

** Writes the message and handle 'tocont', finishing the message ** if needed and setting the next warn function. */

** Does a young collection. First, mark 'OLD1' objects. Then does the ** atomic step. Then, sweep all lists and advance pointers. Finally, ** finish t