Serialise Lua data into JSON string. */

Handle the "value" context */

** Prints an error message, adding the program name in front of it ** (if present) */

** Look for a C function named 'sym' in a dynamically loaded library ** 'path'. ** First, check whether the library is already loaded; if not, try

** Performs a full GC cycle; if 'isemergency', set a flag to avoid ** some operations which could change the interpreter state in some ** unexpected

** main search function */

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

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

** Ensures final expression result is either in a register or it is ** a constant. */

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

** Create expression 't[k]'. 't' must have its final result already in a ** register or upvalue. */

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

** Path all jumps in 'list' to jump to 'target'. ** (The assert means that we cannot fix a jump to a forward address ** because we only know address

** Code a 'return' instruction */

** Emit a SETLIST instruction. ** 'base' is register that keeps table; ** 'nelems' is #table plus those to be stored now; ** 'tostore' is number of

** Generate code to store result of expression 'ex' into variable 'var'. */

** ensure that stack[idx][fname] has a table and push that table ** into the stack */

** resizes the string table */

** Return the name of the type of an object. For tables and userdata ** with metatable, use their '__name' metafield, if present. */

** Finish the table access 'val = t[key]'. ** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to ** t[k] entry (which must be nil).

** try to convert a value to an integer, rounding according to 'mode': ** mode == 0: accepts only integral values ** mode == 1: takes the floor of t

** This function can be called asynchronously (e.g. during a signal). ** Fields 'oldpc', 'basehookcount', and 'hookcount' (set by ** 'resethookcount

** When creating file handles, always creates a 'closed' file handle ** before opening the actual file; so, if there is a memory error, the ** handl

** Pack integer 'n' with 'size' bytes and 'islittle' endianness. ** The final 'if' handles the case when 'size' is larger than ** the size of a Lua

! Removes the task which should be executed next. */

** Read a sequence of (hex)digits */

** mark an object. Userdata, strings, and closed upvalues are visited ** and turned black here. Other objects are marked gray and added ** to approp

** Signal an error in the call to 'lua_resume', not in the execution ** of the coroutine itself. (Such errors should not be handled by any ** corout

semantic error */

! Gets the number of threads in the pool. * \return The number of threads. */

! Gets the number of threads in the pool. * \return The number of threads. */

** skip a sequence '[=*[' or ']=*]'; if sequence is well formed, return ** its number of '='s; otherwise, return a negative number (-1 iff there **