** Quicksort algorithm (recursive function) */

** Add a false to list of constants and return its index. */

** Add a true to list of constants and return its index. */

** Break statement. Semantically equivalent to "goto break". */

** Call closing method for object 'obj' with error message 'err'. The ** boolean 'yy' controls whether the call is yieldable. ** (This function assume

** Check whether new instruction 'newpc' is in a different line from ** previous instruction 'oldpc'. More often than not, 'newpc' is only ** one or a

** check whether, in an assignment to an upvalue/local variable, the ** upvalue/local variable is begin used in a previous assignment to a ** table. I

** return registry.CLIBS[path] */

** Check whether object at given level has a close metamethod and raise ** an error if not. */

** Check whether there is already a label with the given 'name'. */

** Choose an element in the middle (2nd-3th quarters) of [lo,up] ** "randomized" by 'rnd' */

returns +1 if newer, -1 if older and 0 if equal

** Code bitwise operations; they are all associative, so the function ** tries to put an integer constant as the 2nd operand (a K operand). */

** codes instruction to create new closure in parent function. ** The OP_CLOSURE instruction uses the last available register, ** so that, if it invok

** Code commutative operators ('+', '*'). If first operand is a ** numeric constant, change order of operands to try to use an ** immediate or K opera

** Create code for '(e1 .. e2)'. ** For '(e1 .. e2.1 .. e2.2)' (which is '(e1 .. (e2.1 .. e2.2))', ** because concatenation is right associative), mer

** Emit code for equality comparisons ('==', '~='). ** 'e1' was already put as RK by 'luaK_infix'. */

** Code 'not e', doing constant folding. */

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

** Emit code for unary expressions that "produce values" ** (everything but 'not'). ** Expression to produce final result will be encoded in 'e'. */

** Traverses all arguments from 'argv', returning a mask with those ** needed before running any Lua code (or an error code if it finds ** any invalid

** Compute the optimal size for the array part of table 't'. 'nums' is a ** "count array" where 'nums[i]' is the number of integers in the table ** be

** Convert a constant in 'v' into an expression description 'e' */

** Correct all gray lists, coalescing them into 'grayagain'. */

** Correct pointers to objects inside 'allgc' list when ** object 'o' is being removed from the list. */

** {================================================================== ** Stack reallocation ** ======================================================

** Create the 'arg' table, which stores all arguments from the ** command line ('argv'). It should be aligned so that, at index 0, ** it has 'argv[scr

** create table CLIBS to keep track of loaded C libraries, ** setting a finalizer to close all libraries when closing state. */

** Receives 'globname[=modname]' and runs 'globname = require(modname)'. */

** Check whether key 'k1' is equal to the key in node 'n2'. This ** equality is raw, so there are no metamethods. Floats with integer ** values have b

** return the final target of a jump (skipping jumps to jumps) */

** Search for 'objidx' in table at index -1. ('objidx' must be an ** absolute index.) Return 1 + string at top if it found a good name. */

** returns the index of a 'key' for table traversals. First goes all ** elements in the array part, then elements in the hash part. The ** beginning o

** find last 'next' field in list 'p' list (to add elements in its end) */

** Try to find a suspended protected call (a "recover point") for the ** given thread. */

** Try to find last instruction before 'lastpc' that modified register 'reg'. */

** Completes the execution of a C function interrupted by an yield. ** The interruption must have happened while the function was either ** closing it

** Finish the job of 'lua_pcallk' after it was interrupted by an yield. ** (The caller, 'finishCcall', does the final call to 'adjustresults'.) ** The

** Execute a step of a float numerical for loop, returning ** true iff the loop must continue. (The integer case is ** written online with opcode OP_F

** Try to convert a 'for' limit to an integer, preserving the semantics ** of the loop. Return true if the loop must not run; otherwise, '*p' ** gets

** Prepare a numerical for loop (opcode OP_FORPREP). ** Return true to skip the loop. Otherwise, ** after preparation, stack will be as follows: **

** Perform a full collection in incremental mode. ** Before running the collection, check 'keepinvariant'; if it is true, ** there may be some objects

** Try to find a name for a function based on the code that called it. ** (Only works when function was called by a Lua function.) ** Returns what the

** Does a generational "step". ** Usually, this means doing a minor collection and setting the debt to ** make another collection when memory grows 'g

** Return the string to be used as a prompt by the interpreter. Leave ** the string (or nil, if using the default value) on the stack, to keep ** it a

** Get a "base line" to find the line corresponding to an instruction. ** Base lines are regularly placed at MAXIWTHABS intervals, so usually ** an in

** Get a conversion specification and copy it to 'form'. ** Return the address of its last character. */