** Try to find a boundary in table 't'. (A 'boundary' is an integer index ** such that t[i] is present and t[i+1] is absent, or 0 if t[1] is absent **

** inserts a new key into a hash table; first, check whether key's main ** position is free. If not, check whether colliding node is in its main ** po

** Check register-stack level, keeping track of its maximum size ** in field 'maxstacksize' */

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

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

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

** Create a OP_LOADNIL instruction, but try to optimize: if the previous ** instruction is also OP_LOADNIL and ranges are compatible, adjust ** range

** Add a float to list of constants and return its index. Floats ** with integral values need a different key, to avoid collision ** with actual integ

** Code a 'return' instruction */

** Fix an expression to return one result. ** If expression is not a multi-ret expression (function call or ** vararg), it already returns one result,

** equality for long strings */

** Resize the string table. If allocation fails, keep the current size. ** (This can degrade performance, but any non-zero size should work ** correct

** Main operation for equality of Lua values; return 't1 == t2'. ** L == NULL means raw equality (no metamethods) */

** Main operation 'ra = #rb'. */

** Returns a pointer to the internal representation of an object. ** Note that ANSI C does not allow the conversion of a pointer to ** function to a '

** mark all objects in list of being-finalized */

** mark metamethods for basic types */

** Mark that current block has a to-be-closed variable. */

** check whether list has any jump that do not produce a value ** or produce an inverted value */

** Negate condition 'e' (where 'e' is a comparison). */

------------------------------------------------------------------------------

** Adds a new label/goto in the corresponding list. */

** Add current char to buffer (if not out of space) and read next one */

** Patch destination register for a TESTSET instruction. ** If instruction in position 'node' is not a TESTSET, return 0 ("fails"). ** Otherwise, if '

** preinitialize a thread with consistent values without allocating ** any memory (to avoid errors) */

** Return the previous instruction of the current code. If there ** may be a jump target between the current instruction and the ** previous one, retu

** Project the random integer 'ran' into the interval [0, n]. ** Because 'ran' has 2^B possible values, the projection can only be ** uniform when the

** traverse one gray object, turning it to black. */

** Push the i-th capture on the stack. */

** Search for a name for a function in all loaded modules */

** Push given string to the stack, as part of the result, and ** join it to previous partial result if there is one. ** It may call 'luaV_concat' whil

** Set a "random" seed. To get some randomness, use the current time ** and the address of 'L' (in case the machine does address space layout ** rando

LUA_NUMBER */ ** This function is quite liberal in what it accepts, as 'luaO_str2num' ** will reject ill-formed numerals. Roughly, it accepts the foll

** Remove line information from the last instruction. ** If line information for that instruction is absolute, set 'iwthabs' ** above its max to force

** Traverse a list of tests ensuring no one produces a value */

** Executes a return hook for Lua and C functions and sets/corrects ** 'oldpc'. (Note that this correction is needed by the line hook, so it ** is don

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

** Save line info for a new instruction. If difference from last line ** does not fit in a byte, of after that many instructions, save a new ** absolu

** Move all unreachable objects (or 'all' objects) that need ** finalization from list 'finobj' to list 'tobefnz' (to be finalized). ** (Note that obj

------------------------------------------------------------------------------

** Set all fields from structure 'tm' in the table on top of the stack */

** Creates an array for the hash part of a table with the given ** size, or reuses the dummy node if size is zero. ** The computation for size overflo

** Set a path */

** Find a variable with the given name 'n', handling global variables ** too. */

** Find a variable with the given name 'n'. If it is an upvalue, add ** this upvalue into all intermediate functions. If it is a global, set ** 'var'

** reads the first character of file 'f' and skips an optional BOM mark ** in its beginning plus its first line if it starts with '#'. Returns ** true

** Convert a VKSTR to a VK */

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

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