** Return true iff value at stack index 'a' is less than the value at ** index 'b' (according to the order of the sort). */

** Sweep for generational mode. Delete dead objects. (Because the ** collection is not incremental, there are no "new white" objects ** during the swe

from strlib */ translate a relative string position: negative means back from end */

convert a 'lua_Unsigned' to a 'Rand64' */

** check whether current token is in the follow set of a block. ** 'until' closes syntactical blocks, but do not close scope, ** so it is handled in s

** If pointer 'p' points to 'o', move it to the next element. */

** clear entries with unmarked values from all weaktables in list 'l' up ** to element 'f' */

** Emit code for binary expressions that "produce values" over ** two registers. */

** Code a "conditional jump", that is, a test or comparison opcode ** followed by a jump. Return jump position. */

** Correct a list of gray objects. Return pointer to where rest of the ** list should be linked. ** Because this correction is done after sweeping, yo

** Interface to 'lua_pcall', which sets appropriate message function ** and C-signal handler. Used to run all chunks. */

** Check whether 'i' can be stored in an 'sC' operand. Equivalent to ** (0 <= int2sC(i) && int2sC(i) <= MAXARG_C) but without risk of ** overflows in

** Fix jump instruction at position 'pc' to jump to 'dest'. ** (Jump addresses are relative in Lua) */

** Gets the destination address of a jump instruction. Used to traverse ** a list of jumps. */

** Read an integer numeral and raises an error if it is larger ** than the maximum size for integers. */

** Check whether expression 'e' is a literal integer or float in ** proper range to fit in a register (sB or sC). */

** Load a nullable string into prototype 'p'. */

** Reallocate the stack to a new size, correcting all pointers into ** it. (There are pointers to a stack from its upvalues, from its list ** of call

** Finish a raw "set table" operation, where 'slot' is where the value ** should have been (the result of a previous "get table"). ** Beware: when usi

** main search function */

** Create expression 't[k]'. 't' must have its final result already in a ** register or upvalue. Upvalues can only be indexed by literal strings. ** K

** Path all jumps in 'list' to jump to 'target'. ** (The assert means that we cannot fix a jump to a forward address ** because we only know addresses

** Generate code to store result of expression 'ex' into variable 'var'. */

** this function handles only '%d', '%c', '%f', '%p', '%s', and '%%' conventional formats, plus Lua-specific '%I' and '%U' */

** Return the name of the type of an object. For tables and userdata ** with metatable, use their '__name' metafield, if present. */

** Main operation for concatenation: concat 'total' values in the stack, ** from 'L->top - total' up to 'L->top - 1'. */

** returns the 'main' position of an element in a table (that is, ** the index of its hash value). */

** precall for C functions */

** Returns a pointer to a free area with at least 'sz' bytes in buffer ** 'B'. 'boxidx' is the relative position in the stack where is the ** buffer's

returns for a >90% quadmonument the number of blocks, by area, in spawn range

** Mark an object. Userdata with no user values, strings, and closed ** upvalues are visited and turned black here. Open upvalues are ** already ind

** Signal an error in the call to 'lua_resume', not in the execution ** of the coroutine itself. (Such errors should not be handled by any ** coroutin

** Set the "time" to wait before starting a new GC cycle; cycle will ** start when memory use hits the threshold of ('estimate' * pause / ** PAUSEADJ)

** Variations of 'lua_settable', used by 'db_getinfo' to put results ** from 'lua_getinfo' into result table. Key is always a string; ** value can be

convert a 'Rand64' to a 'lua_Unsigned' */

return i << n */

** add length modifier into formats */

** Add a number to the buffer. */

** Adjust the number of results from an expression list 'e' with 'nexps' ** expressions to 'nvars' values. */

** Calls the 'close' function from a file handle. The 'volatile' avoids ** a bug in some versions of the Clang compiler (e.g., clang 3.0 for ** 32 bit

** Call a function (C or Lua) through C. 'inc' can be 1 (increment ** number of recursive invocations in the C stack) or nyci (the same ** plus increm

** Check whether current char is in set 'set' (with two chars) and ** saves it */

** Check whether a given upvalue from a given closure exists and ** returns its index */