** Resumes a coroutine. Returns the number of results for non-error ** cases or -1 for errors. */

** t[k] = value at the top of the stack (where 'k' is a string) */

** get (if 'get' is true) or set an upvalue from a closure */

** Convert a BinOpr to a tag method (ORDER OPR - ORDER TM) */

** call all pending finalizers */

** If possible, shrink string table. */

** Raises an error if variable described by 'e' is read only */

** Check whether message is a control message. If so, execute the ** control or ignore it if unknown. */

** Check that 'arg' either is a table or can behave like one (that is, ** has a metatable with the required metamethods) */

** clear entries with unmarked keys from all weaktables in list 'l' */

** Code arithmetic operators ('+', '-', ...). If second operand is a ** constant in the proper range, use variant opcodes with K operands. */

** Code binary operators with K operand. */

** Code binary operators with no constant operand. */

** Emit an "extra argument" instruction (format 'iAx') */

** Get the constant value from a constant expression */

** Try to "constant-fold" an operation; return 1 iff successful. ** (In this case, 'e1' has the final result.) */

** Traverse all ephemeron tables propagating marks from keys to values. ** Repeat until it converges, that is, nothing new is marked. 'dir' ** inverts

copy strings in stack from top - n up to top - 1 to buffer */

** Change back all offsets into pointers. */

** Create a new label with the given 'name' at the given 'line'. ** 'last' tells whether label is the last non-op statement in its ** block. Solves al

** creates a new string object */

** Delete all objects in list 'p' until (but not including) object ** 'limit'. */

** Read an integer numeral from string 'fmt' or return 'df' if ** there is no numeral */

** Ensure expression value is in a register, making 'e' a ** non-relocatable expression. ** (Expression still may have jump lists.) */

** Ensure expression value is in register 'reg', making 'e' a ** non-relocatable expression. ** (Expression still may have jump lists.) */

** Enter generational mode. Must go until the end of an atomic cycle ** to ensure that all objects are correctly marked and weak tables ** are cleared

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

** Search for an active label with the given name. */

Try to code a binary operator negating its second operand. ** For the metamethod, 2nd operand must keep its original value. */

** Finish a young-generation collection. */

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

** First allocation will fail except when freeing a block (frees never ** fail) and when it cannot try again; this fail will trigger 'tryagain' ** and

** Check whether 'i' can be stored in an 'sBx' operand. */

** Fix for instruction at position 'pc' to jump to 'dest'. ** (Jump addresses are relative in Lua). 'back' true means ** a back jump. */

** Generate code for a 'for' loop. */

** Free two registers in proper order */

** Does a full collection in generational mode. */

** Try to find a name for a function based on how it was called. */

** get information about the i-th capture. If there are no captures ** and 'i==0', return information about the whole match, which ** is the range 's'

** Gets an optional ending string position from argument 'arg', ** with default value 'def'. ** Negative means back from end: clip result to [0, len]

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

** Hash for integers. To allow a good hash, use the remainder operator ** ('%'). If integer fits as a non-negative int, compute an int ** remainder, w

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

** Check whether expression 'e' is a small literal string */

** Check whether real size of the array is a power of 2. ** (If it is not, 'alimit' cannot be changed to any other value ** without changing the real

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

** Convert string 's' to a Lua number (put in 'result'). Return NULL on ** fail or the address of the ending '\0' on success. ('mode' == 'x') ** means

** Compare two strings 'ls' x 'rs', returning an integer less-equal- ** -greater than zero if 'ls' is less-equal-greater than 'rs'. ** The code is a l

** Try to convert a value from string to a number value. ** If the value is not a string or is a string not representing ** a valid numeral (or if coe

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

** Get the debug-information entry for current variable 'vidx'. */

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

** Call all finalizers of the objects in the given Lua state, and ** then free all objects, except for the main thread. */

** create a new collectable object (with given type, size, and offset) ** and link it to 'allgc' list. */

** Executes a call hook for Lua functions. This function is called ** whenever 'hookmask' is not zero, so it checks whether call hooks are ** active.

** Prepares the call to a function (C or Lua). For C functions, also do ** the call. The function to be called is at '*func'. The arguments ** are on

** Check whether 'func' has a '__call' metafield. If so, put it in the ** stack, below original 'func', so that 'luaD_precall' can call it. Raise ** a

** Called when 'getCcalls(L)' larger or equal to LUAI_MAXCCALLS. ** If equal, raises an overflow error. If value is larger than ** LUAI_MAXCCALLS (whi

add src:line information to 'msg' */