** empty the buffer space into the stack */

** Code binary operators with immediate operands. */

** Enter incremental mode. Turn all objects white, make all ** intermediate lists point to NULL (to avoid invalid pointers), ** and go to the pause st

** Enter first sweep phase. ** The call to 'sweeptolive' makes the pointer point to an object ** inside the list (instead of to the header), so that t

** Exchange the hash part of 't1' and 't2'. */

** Read an expression and generate code to put its results in next ** stack slot. ** */

** Ensures final expression result (which includes results from its ** jump lists) is in register 'reg'. ** If expression has jumps, need to patch the

** Free registers used by expressions 'e1' and 'e2' (if any) in proper ** order. */

** Check whether object 'o' should be kept in the 'grayagain' list for ** post-processing by 'correctgraylist'. (It could put all old objects ** in th

get a random 64-bit integer

** Get a space of size 'sz' in the buffer. If buffer has not enough ** space, empty it. 'sz' must fit in an empty buffer. */

** Read, classify, and fill other details about the next option. ** 'psize' is filled with option's size, 'notoalign' with its ** alignment requiremen

** "Generic" get version. (Not that generic: not valid for integers, ** which may be in array part, nor for floats with integral values.) ** See expla

** Returns the position of the instruction "controlling" a given ** jump (that is, its condition), or the jump itself if it is ** unconditional. */

** Check whether table being indexed by instruction 'i' is the ** environment '_ENV' */

** Initialize Header */

** Check whether expression 'e' is a literal integer in ** proper range to fit in register sC */

** Find a "name" for the constant 'c'. */

** Prints an error message, adding the program name in front of it ** (if present) */

** Look for a C function named 'sym' in a dynamically loaded library ** 'path'. ** First, check whether the library is already loaded; if not, try **

** Change collector mode to 'newmode'. */

** Performs a full GC cycle; if 'isemergency', set a flag to avoid ** some operations which could change the interpreter state in some ** unexpected w

** Calls 'luaF_close' in protected mode. Return the original status ** or, in case of errors, the new status. */

** Call the C function 'func' in protected mode, restoring basic ** thread information ('allowhook', etc.) and in particular ** its stack level in cas

** If stack size is more than 3 times the current use, reduce that size ** to twice the current use. (So, the final stack size is at most 2/3 the ** p

** Close all upvalues up to the given stack level. */

** Look for n-th local variable at line 'line' in function 'func'. ** Returns NULL if not found. */

** Insert a variable in the list of to-be-closed variables. */

** beware: when using this function you probably need to check a GC ** barrier and invalidate the TM cache. */

** Emit a "load constant" instruction, using either 'OP_LOADK' ** (if constant index 'k' fits in 18 bits) or an 'OP_LOADKX' ** instruction with "extra

** Emit code to go through if 'e' is true, jump otherwise. */

** Check whether expression 'e' is a literal integer. */

** Emit a SETLIST instruction. ** 'base' is register that keeps table; ** 'nelems' is #table plus those to be stored now; ** 'tostore' is number of va

** The use of 'lua_pushfstring' ensures this function does not ** need reserved stack space when called. */

** Computes ceil(log2(x)) */

** Calls an order tag method. ** For lessequal, LUA_COMPAT_LT_LE keeps compatibility with old ** behavior: if there is no '__le', try '__lt', based on

** Creates a new string and anchors it in scanner's table so that it ** will not be collected until the end of the compilation; by that time ** it sho

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

** Mark black 'OLD1' objects when starting a new young collection. ** Gray objects are already in some gray list, and so will be visited ** in the ato

** When creating file handles, always creates a 'closed' file handle ** before opening the actual file; so, if there is a memory error, the ** handle

** Pack integer 'n' with 'size' bytes and 'islittle' endianness. ** The final 'if' handles the case when 'size' is larger than ** the size of a Lua in

** Traverse a list of tests, patching their destination address and ** registers: tests producing values jump to 'vtarget' (and put their ** values in

** Read a sequence of (hex)digits */

** Reverse the stack segment from 'from' to 'to' ** (auxiliary to 'lua_rotate') ** Note that we move(copy) only the value inside the stack. ** (We do

rotate left 'x' by 'n' bits */

** Set debt for the next minor collection, which will happen when ** memory grows 'genminormul'%. */