** Format and emit an 'iABx' instruction. */

** Ensures final expression result is either in a register or it is ** a constant. */

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

** Create expression 't[k]'. 't' must have its final result already in a ** register or upvalue. */

** Add an integer to list of constants and return its index. ** Integers use userdata as keys to avoid collision with floats with ** same value; conve

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

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

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

** ensure that stack[idx][fname] has a table and push that table ** into the stack */

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

** resizes the string table */

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

** Finish the table access 'val = t[key]'. ** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to ** t[k] entry (which must be nil). */

** try to convert a value to an integer, rounding according to 'mode': ** mode == 0: accepts only integral values ** mode == 1: takes the floor of the

** This function can be called asynchronously (e.g. during a signal). ** Fields 'oldpc', 'basehookcount', and 'hookcount' (set by ** 'resethookcount')

Same as new(). For backward compatibility reasons, this is an alternative name for the new() function.

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

* Process the contents of a single ordered or unordered list, splitting it * into individual list items. * @param {string} listStr * @param {

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

** mark an object. Userdata, strings, and closed upvalues are visited ** and turned black here. Other objects are marked gray and added ** to appropri

** Recovers from an error in a coroutine. Finds a recover point (if ** there is one) and completes the execution of the interrupted ** 'luaD_pcall'. I

** signal an error in the call to 'resume', not in the execution of the ** coroutine itself. (Such errors should not be handled by any coroutine ** er

** Reverse the stack segment from 'from' to 'to' ** (auxiliary to 'lua_rotate') */

semantic error */

** skip a sequence '[=*[' or ']=*]'; if sequence is well formed, return ** its number of '='s; otherwise, return a negative number (-1 iff there ** ar

** sweep at most 'count' elements from a list of GCObjects erasing dead ** objects, where a dead object is one marked with the old (non current) ** wh

** If expression is a numeric constant, fills 'v' with its value ** and returns 1. Otherwise, returns 0. */

** Decode one UTF-8 sequence, returning NULL if byte sequence is invalid. */