Decode literal, length, and distance codes and write out the resulting literal and match bytes until either not enough input or output is availa

=========================================================================== * Initialize a new block. */

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

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

For 80x86 and 680x0, an optimized version will be provided in match.asm or * match.S. The code will be functionally equivalent. */

** if object 'o' has a finalizer, remove it from 'allgc' list (must ** search the list to find it) and link it in 'finobj' 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.

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

** Generate a warning from an error message */

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 present and t[i+1] is absent, or 0 if t[1] is absent **

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

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

** Try to make 'e' a K expression with an index in the range of R/K ** indices. Return true iff succeeded. */

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

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

** Add an integer to list of constants and return its index. ** Integers use userdata as keys to avoid collision with floats with ** same value; conve

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

** equality for long strings */

** Resize the string table. If allocation fails, keep the current size. ** (This can degrade performance, but any non-zero size should work ** correct

** dump Lua function as precompiled chunk */

** Main operation for equality of Lua values; return 't1 == t2'. ** L == NULL means raw equality (no metamethods) */

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

** returns the 'main' position of an element in a table (that is, ** the index of its hash value). The key comes broken (tag in 'ktt' ** and value in

MAKECRCH */ Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+

Performs equivalent check of std::fabs(lhs - rhs) <= margin But without the subtraction to allow for INFINITY in comparison

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