** Check whether pointer 'o' points to some value in the stack ** frame of the current function. Because 'o' may not point to a ** value in this stack

** Generates an error that a goto jumps into the scope of some ** local variable. */

Check whether 'mode' matches '[rwa]%+?[L_MODEEXT]*' */

** Prints (calling the Lua 'print' function) any values on the stack */

** Use 'time' and 'clock' as sources of "randomness". Because we don't ** know the types 'clock_t' and 'time_t', we cannot cast them to ** anything wi

** Convert string 's' to a Lua number (put in 'result') handling the ** current locale. ** This function accepts both the current locale or a dot as t

** return 'l <= r' for non-numbers. */

** return 'l < r' for non-numbers. */

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

** Load the upvalues for a function. The names must be filled first, ** because the filling of the other fields can raise read errors and ** the creat

** Read a line and try to load (compile) it first as an expression (by ** adding "return " in front of it) and second as a statement. Return ** the fi

** performs a basic GC step if collector is running */

** Try to grow the stack by at least 'n' elements. when 'raiseerror' ** is true, raises any error; otherwise, return 0 in case of errors. */

** Prepare a function for a tail call, building its call info on top ** of the current call info. 'narg1' is the number of arguments plus 1 ** (so tha

** free all CallInfo structures not in use by a thread */

** free half of the CallInfo structures not in use by a thread, ** keeping the first one. */

** Generate a warning from an error message */

** Find and reuse, or create if it does not exist, an upvalue ** at the given level. */

** fill a closure with new closed upvalues */

** Raise an error for calling a non-callable object. Try to find a name ** for the object based on how it was called ('funcnamefromcall'); if it ** ca

** Error when both values are convertible to numbers, but not to integers */

** Traces the execution of a Lua function. Called before the execution ** of each opcode, when debug is on. 'L->oldpc' stores the last ** instruction

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

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

** Do a final pass over the code of a function, doing small peephole ** optimizations and adjustments. */

** Process 1st operand 'v' of binary operation 'op' before reading ** 2nd operand. */

** Finalize code for binary operation, after reading 2nd operand. */

** Apply prefix operation 'op' to expression 'e'. */

** Emit SELF instruction (convert expression 'e' into 'e:key(e,'). */

** Fix an expression to return the number of results 'nresults'. ** 'e' must be a multi-ret expression (function call or vararg). */

** Stripped-down 'require': After checking "loaded" table, calls 'openf' ** to open a module, registers the result in 'package.loaded' table and, ** i

** Generic allocation routine. */

** Convert a number object to a Lua string, replacing the value at 'obj' */

** Clear API string cache. (Entries cannot be empty, so fill them with ** a non-collectable string.) */

** Initialize the string table and the string cache */

** Load precompiled chunk. */

** finish execution of an opcode interrupted by a yield */

** Integer division; return 'm // n', that is, floor(m/n). ** C division truncates its result (rounds towards zero). ** 'floor(q) == trunc(q)' when 'q

** Main operation less than or equal to; return 'l <= r'. */

** Main operation less than; return 'l < r'. */

** Integer modulus; return 'm % n'. (Assume that C '%' with ** negative operands follows C99 behavior. See previous comment ** about luaV_idiv.) */

** Float modulus */

** try to convert a value to an integer. */