** get field and width arguments for field-manipulation functions, ** checking whether they are valid. ** ('luaL_error' called without 'return' to avo

** check whether new label 'lb' matches any pending gotos in current ** block; solves forward jumps */

** try to close a goto with existing labels; this solves backward jumps */

** Completes the execution of an interrupted C function, calling its ** continuation function. */

** Continuation function for 'pcall' and 'xpcall'. Both functions ** already pushed a 'true' before doing the call, so in case of success ** 'finishpc

** Free registers used by expressions 'e1' and 'e2' (if any) in proper ** order. */

** "Generic" get version. (Not that generic: not valid for integers, ** which may be in array part, nor for floats with integral values.) */

** Read and classify next option. 'size' is filled with option's size. */

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

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