* Resize the array to new size * * @param NewSize - new size of the array */

* Shuffle the elements */

Get the number of elements in array.

Compute an approximation and see if it is within 1/2 ULP

* @see FLuaArray::Get(...). Create a copy for the element */

* @see FLuaArray::Set(...) */

* Convert the values to an array * * @param OutArray - the memory the result array resides * @return - the result array */

** Add the replacement value to the string buffer 'b'. ** Return true if the original string was changed. (Function calls and ** table indexing result

** adds a new prototype into list of prototypes */

** Try to compile line on the stack as 'return <line>;'; on return, stack ** has either compiled chunk or original line (if compilation failed). */

** registry.CLIBS[path] = plib -- for queries ** registry.CLIBS[#CLIBS + 1] = plib -- also keep a list of all libraries */

-------------------------------------------------------------------------*\ * Make sure argument is a boolean \*--------------------------------------

-------------------------------------------------------------------------*\ * Get a userdata pointer if object belongs to a given class. Return NULL *

-------------------------------------------------------------------------*\ * Get a userdata pointer if object belongs to a given group. Return NULL *

** Quicksort algorithm (recursive function) */

-------------------------------------------------------------------------*\ * Encodes the Base64 last 1 or 2 bytes and adds padding '=' * Result, if a

-------------------------------------------------------------------------*\ * Setup basic stuff. \*---------------------------------------------------

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

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

** return registry.CLIBS[path] */

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

** Check objects in gray lists. */

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

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