** 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 black 'OLD1' objects when starting a new young collection. ** Gray objects are already in some gray list, and so will be visited ** in the ato

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

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

** Traverse a list of tests, patching their destination address and ** registers: tests producing values jump to 'vtarget' (and put their ** values in

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

** Reverse the stack segment from 'from' to 'to' ** (auxiliary to 'lua_rotate') ** Note that we move(copy) only the value inside the stack. ** (We do

rotate left 'x' by 'n' bits */

** Set debt for the next minor collection, which will happen when ** memory grows 'genminormul'%. */

** Use 'sigaction' when available. */

** read a sequence '[=*[' or ']=*]', leaving the last bracket. If ** sequence is well formed, return its number of '='s + 2; otherwise, ** return 1 if

** Sweep a list of objects to enter generational mode. Deletes dead ** objects and turns the non dead to old. All non-dead threads---which ** are now

** Decode one UTF-8 sequence, returning NULL if byte sequence is ** invalid. The array 'limits' stores the minimum value for each ** sequence length,

** Build a string with a "description" for the value 'o', such as ** "variable 'x'" or "upvalue 'y'". */

** Traverse a list making all its elements white and clearing their ** age. In incremental mode, all objects are 'new' all the time, ** except for fix

return i1 + i2 */

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

** Add integer part of 'x' to buffer and return new 'x' */

** returns the index for 'k' if 'k' is an appropriate key to live in ** the array part of a table, 0 otherwise. */

** Clears all gray lists, sweeps objects, and prepare sublists to enter ** generational mode. The sweeps remove dead objects and turn all ** surviving

** Auxiliary function to create the iteration function for 'lines'. ** The iteration function is a closure over 'io_readline', with ** the following u

** Resumes a coroutine. Returns the number of results for non-error ** cases or -1 for errors. */

** t[k] = value at the top of the stack (where 'k' is a string) */

** get (if 'get' is true) or set an upvalue from a closure */

** call all pending finalizers */

** If possible, shrink string table. */

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

** Check whether message is a control message. If so, execute the ** control or ignore it if unknown. */

** Check that 'arg' either is a table or can behave like one (that is, ** has a metatable with the required metamethods) */

** clear entries with unmarked keys from all weaktables in list 'l' */

** Code arithmetic operators ('+', '-', ...). If second operand is a ** constant in the proper range, use variant opcodes with K operands. */

** Emit an "extra argument" instruction (format 'iAx') */

** Emit code for order comparisons. When using an immediate operand, ** 'isfloat' tells whether the original value was a float. */

** Get the constant value from a constant expression */