** Emit instruction to jump if 'e' is 'cond' (that is, if 'cond' ** is true, code will jump if 'e' is true.) Return jump position. ** Optimize when 'e

** find a "name" for the RK value 'c' */

** Compare two strings 'ls' x 'rs', returning an integer smaller-equal- ** -larger than zero if 'ls' is smaller-equal-larger than 'rs'. ** The code is

** Try to find a load function for module 'modname' at file 'filename'. ** First, change '.' to '_' in 'modname'; then, if 'modname' has ** the form X

** if object 'o' has a finalizer, remove it from 'allgc' list (must ** search the list to find it) and link it in 'finobj' list. */

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

add src:line information to 'msg' */

** Try to find a boundary in table 't'. A 'boundary' is an integer index ** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil). */

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

** Ensures final expression result is either in a register or in an ** upvalue. */

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

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

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

** Find or create a module table with a given name. The function ** first looks at the LOADED table and, if that fails, try a ** global variable with

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

converts back */

** converts an integer to a "floating point byte", represented as ** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if ** eeeee != 0 and (

** Convert a number object to a string */

** dump Lua function as precompiled chunk */

** load precompiled chunk */

** 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 for equality of Lua values; return 't1 == t2'. ** L == NULL means raw equality (no metamethods) */

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

** Main operation less than or equal to; return 'l <= r'. If it needs ** a metamethod and there is no '__le', try '__lt', based on ** l <= r iff !(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_div.) */

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

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

** mark metamethods for basic types */

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

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

=========================================================================*\ * Auxiliar functions \*===================================================

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