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

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

* Executes after a Lua mod is started. * Executes for every Lua mod that is starting. * @param mod_name This is the name of the Lua

* Executes before a Lua mod is about to be stopped. * Executes for every Lua mod that is stopping. * @param mod_name This is the nam

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

** preinitialize a thread with consistent values without allocating ** any memory (to avoid errors) */

** Return the previous instruction of the current code. If there ** may be a jump target between the current instruction and the ** previous one, retu

** traverse one gray object, turning it to black. */

** Push the i-th capture on the stack. */

** Search for a name for a function in all loaded modules */

** Prompt the user, read a line, and push it into the Lua stack. */

** Push given string to the stack, as part of the buffer, and ** join the partial strings in the stack into one. */

** Set a "random" seed. To get some randomness, use the current time ** and the address of 'L' (in case the machine does address space layout ** rando