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

does the line segment l1->l2 intersect the rectangle r1->r2

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

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

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

** inserts a new key into a hash table; first, check whether key's main ** position is free. If not, check whether colliding node is in its main ** po

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

** 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. Floats ** with integral values need a different key, to avoid collision ** with actual integ

** 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 a pointer to the internal representation of an object. ** Note that ANSI C does not allow the conversion of a pointer to ** function to a '

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

** mark metamethods for basic types */

** Mark that current block has a to-be-closed variable. */

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

** Adds a new label/goto in the corresponding list. */

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