** 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 empty).

** Garbage-collection function */

** About the overflow check: an overflow cannot occur when time ** is represented by a lua_Integer, because either lua_Integer is ** large enough to r

** Add constant 'v' to prototype's list of constants (field 'k'). ** Use scanner's table to cache position of constants in constant list ** and try to

** Free register 'reg', if it is neither a constant index nor ** a local variable. ) */

** advances the garbage collector until it reaches a state allowed ** by 'statemask' */

** Similar to 'luaD_call', but does not allow yields during the call. */

** Finishes a function call: calls hook if necessary, moves current ** number of results to proper place, and returns to previous call ** info. If fun

** set GCdebt to a new value keeping the value (totalbytes + GCdebt) ** invariant (and avoiding underflows in 'totalbytes') */

** Close all upvalues and to-be-closed variables up to the given stack ** level. Return restored 'level'. */

** returns current 'pc' and marks it as a jump target (to avoid wrong ** optimizations with consecutive instructions not in the same basic block). */

** set functions from list 'l' into table at top - 'nup'; each ** function gets the 'nup' elements at the top as upvalues. ** Returns with only the ta

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

** Finish a table assignment 't[key] = val'. ** If 'slot' is NULL, 't' is not a table. Otherwise, 'slot' points ** to the entry 't[key]', or to a val

** Convert 'nvar', a compiler index level, to its corresponding ** register. For that, search for the highest variable below that level ** that is in

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

** Add 'str' to the buffer. If string is larger than the buffer space, ** push the string directly to the stack. */

** Check whether a conversion specification is valid. When called, ** first character in 'form' must be '%' and last character must ** be a valid conv

** Copy 'size' bytes from 'src' to 'dest', correcting endianness if ** given 'islittle' is different from native endianness. */

** Auxiliary function used by several library functions: check for ** an optional thread as function's first argument and set 'arg' with ** 1 if this

** External interface for 'ccall' */

** Get the line corresponding to instruction 'pc' in function 'f'; ** first gets a base line and from there does the increments until ** the desired i

** Emit instruction 'i', checking for array sizes and saving also its ** line information. Return 'i' position. */

** Concatenate jump-list 'l2' into jump-list 'l1' */

semantic error */

** try to convert a value to an integer, rounding according to 'mode', ** without string coercion. ** ("Fast track" handled by macro 'tointegerns'.) *

** Let x = AB, where A is a prefix of length 'n'. Then, ** rotate x n == BA. But BA == (A^r . B^r)^r. */

** Create a new local variable with the given 'name'. Return its index ** in the function. */

** Accept current char if it is in 'set' (of size 2) */

i1 ^= i2 */

** Convert a BinOpr to an OpCode (ORDER OPR - ORDER OP) */

** If L1 != L, L1 can be in any state, and therefore there are no ** guarantees about its stack space; any push in L1 must be ** checked. */

** Clear keys for empty entries in tables. If entry is empty, mark its ** entry as dead. This allows the collection of the key, but keeps its ** entry

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

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

** increment line number and skips newline sequence (any of ** \n, \r, \n\r, or \r\n) */

** tells whether a key or value can be cleared from a weak ** table. Non-collectable objects are never removed from weak ** tables. Strings behave as

** Call a hook for the given event. Make sure there is a hook to be ** called. (Both 'L->hook' and 'L->hookmask', which trigger this ** function, can

** Raise a type error with "standard" information about the faulty ** object 'o' (using 'varinfo'). */

** search function for short strings */

** Resize table 't' for the new given sizes. Both allocations (for ** the hash part and for the array part) can fail, which creates some ** subtleties

** Format and emit an 'iABC' instruction. (Assertions check consistency ** of parameters versus opcode.) */

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

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

build a new Rand64 value */

** translate a relative initial string position ** (negative means back from end): clip result to [1, inf). ** The length of any string in Lua must fi

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

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

** Emit code for binary expressions that "produce values" ** (everything but logical operators 'and'/'or' and comparison ** operators). ** Expression

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