h$_d      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2021 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None 8lua2The number of results returned by a function call.lua8The number of arguments consumed curing a function call.lua A stack index luaGarbage-collection options. luaInteger code used to signal the status of a thread or computation. luaRelational operator code.lua4Integer code used to encode the type of a Lua value.lua:Boolean value returned by a Lua C API function. This is a  and should be interpreted as  iff the value is 0,  otherwise.luaThe type of floats in Lua.By default this type is , but that can be changed in Lua to a single float or a long double. (See LUA_FLOAT_TYPE in  luaconf.h.)See  5https://www.lua.org/manual/5.3/manual.html#lua_Number lua_Number.luaThe type of integers in Lua.By default this type is <, but that can be changed to different values in lua. (See  LUA_INT_TYPE in  luaconf.h.)See  6https://www.lua.org/manual/5.3/manual.html#lua_Integer lua_Integer.luaThe reader function used by  . Every time it needs another piece of the chunk, lua_load calls the reader, passing along its data parameter. The reader must return a pointer to a block of memory with a new piece of the chunk and set size to the block size. The block must exist until the reader function is called again. To signal the end of the chunk, the reader must return NULL or set size to zero. The reader function may return pieces of any size greater than zero.See  5https://www.lua.org/manual/5.3/manual.html#lua_Reader lua_Reader.lua>Type of Haskell functions that can be turned into C functions.#This is the same as a dereferenced .luaType for C functions.In order to communicate properly with Lua, a C function must use the following protocol, which defines the way parameters and results are passed: a C function receives its arguments from Lua in its stack in direct order (the first argument is pushed first). So, when the function starts,   returns the number of arguments received by the function. The first argument (if any) is at index 1 and its last argument is at index  . To return values to Lua, a C function just pushes them onto the stack, in direct order (the first result is pushed first), and returns the number of results. Any other value in the stack below the results will be properly discarded by Lua. Like a Lua function, a C function called by Lua can also return many results.See  8https://www.lua.org/manual/5.3/manual.html#lua_CFunction lua_CFunction.luaAn opaque structure that points to a thread and indirectly (through the thread) to the whole state of a Lua interpreter. The Lua library is fully reentrant: it has no global variables. All information about a state is accessible through this structure. Synonym for  lua_State *. See  )https://www.lua.org/manual/5.3/#lua_State lua_State.    2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2021 Albert KrewinkelMIT,Albert Krewinkel betaForeignFunctionInterface, CPPNone Ilua0Pointer to function opening the package library.Jlua.Pointer to function opening the debug library.Klua-Pointer to function opening the math library.Llua/Pointer to function opening the string library.Mlua+Pointer to function opening the os library.Nlua+Pointer to function opening the io library.Olua.Pointer to function opening the table library.Plua-Pointer to function opening the base library.IJKLMNOPPONMLKJI 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2021 Albert KrewinkelMIT,Albert Krewinkel betaForeignFunctionInterface, CPPNone QluaWrapper around  1https://lua.org/manual/5.3/manual.html#lua_concat lua_concat which catches any Lua errors.RluaWrapper around  /https://lua.org/manual/5.3/manual.html#lua_nextlua_next which catches any Lua errors.SluaReplacement for  0https://lua.org/manual/5.3/manual.html#lua_error lua_error; it uses the HsLua error signaling convention instead of raw Lua errors.Tlua Behaves like  , but prevents unrecoverable program crashes by calling that function through  . Takes an additional status code pointer that is set to the status returned by  lua_pcall.Ulua Behaves like  , but prevents unrecoverable program crashes by calling that function through  . Takes an additional status code pointer that is set to the status returned by  lua_pcall.Vlua Behaves like  , but prevents unrecoverable program crashes by calling that function through  . Takes an additional status code pointer that is set to the status returned by  lua_pcall.Wlua Behaves like  , but prevents unrecoverable program crashes by calling that function through  . Takes an additional status code pointer that is set to the status returned by  lua_pcall.Xlua!Compares two Lua values. Returns 1 if the value at index index15 satisfies op when compared with the value at index index2, following the semantics of the corresponding Lua operator (that is, it may call metamethods). Otherwise returns 0. Also returns 0% if any of the indices is not valid.7The value of op must be one of the following constants:: compares for equality (==): compares for less than (<)!: compares for less or equal (<=)This function wraps  lua_compare$ and takes an additional parameter status; if it is not NULL<, then the return value is set to the status after calling  lua_compare.Xluaindex 1luaindex 2luaoperatorluastatusQRSTUVWXXWVUTSRQ 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2021 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None YluaConverts object to string, respecting any metamethods; returns NULL if an error occurs.ZluaCreates a new Lua state and set extra registry values for error bookkeeping.YZZY 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2021 Albert KrewinkelMIT,Albert Krewinkel betaForeignFunctionInterface, CPPNone [lua2Returns the name of the type encoded by the value tp,, which must be one the values returned by \. 7https://www.lua.org/manual/5.3/manual.html#lua_typename\luahttps://www.lua.org/manual/5.3/manual.html#lua_pushglobaltable|lua&Pushes a new C closure onto the stack.When a C function is created, it is possible to associate some values with it, thus creating a C closure (see  .https://www.lua.org/manual/5.1/manual.html#3.43.4); these values are then accessible to the function whenever it is called. To associate values with a C function, first these values should be pushed onto the stack (when there are multiple values, the first value is pushed first). Then lua_pushcclosure is called to create and push the C function onto the stack, with the argument n telling how many values should be associated with the function. lua_pushcclosure also pops these values from the stack.The maximum value for n is 255. ;https://www.lua.org/manual/5.3/manual.html#lua_pushcclosure.}lua;Pushes a boolean value with the given value onto the stack. :https://www.lua.org/manual/5.3/manual.html#lua_pushboolean.~luaPops n elements from the stack. 2https://www.lua.org/manual/5.3/manual.html#lua_poplua#Calls a function in protected mode.To call a function you must use the following protocol: first, the function to be called is pushed onto the stack; then, the arguments to the function are pushed in direct order; that is, the first argument is pushed first. Finally you call  lua_pcall; nargs is the number of arguments that you pushed onto the stack. All arguments and the function value are popped from the stack when the function is called. The function results are pushed onto the stack when the function returns. The number of results is adjusted to nresults , unless nresults is  . In this case, all results from the function are pushed. Lua takes care that the returned values fit into the stack space. The function results are pushed onto the stack in direct order (the first result is pushed first), so that after the call the last result is on the top of the stack.If there is any error,  lua_pcall catches it, pushes a single value on the stack (the error message), and returns the error code.  lua_pcall? always removes the function and its arguments from the stack.If msgh is 0, then the error object returned on the stack is exactly the original error object. Otherwise, msgh is the location of a message handler. (This index cannot be a pseudo-index.) In case of runtime errors, this function will be called with the error object and its return value will be the object returned on the stack by .Typically, the message handler is used to add more debug information to the error object, such as a stack traceback. Such information cannot be gathered after the return of ', since by then the stack has unwound. 4https://www.lua.org/manual/5.3/manual.html#lua_pcall.luaPops a key from the stack, and pushes a key@value pair from the table at the given index (the "next" pair after the given key). If there are no more elements in the table, then  3https://www.lua.org/manual/5.3/manual.html#lua_nextlua_next returns FALSE (and pushes nothing).$A typical traversal looks like this: -- table is in the stack at index 't' lua_pushnil l -- first key let loop = lua_next l t >>= \case FALSE -> return () _ -> do lua_type l (-2) >>= lua_typename l >>= peekCString >>= putStrLn lua_type l (-1) >>= lua_typename l >>= peekCString >>= putStrLn -- removes 'value'; keeps 'key' for next iteration lua_pop l 1 loop loop&While traversing a table, do not call a directly on a key, unless you know that the key is actually a string. Recall that a may change the value at the given index; this confuses the next call to  3https://www.lua.org/manual/5.3/manual.html#lua_nextlua_next.See function  3https://www.lua.org/manual/5.3/manual.html#pdf-nextnext> for the caveats of modifying the table during its traversal.WARNING: lua_next is unsafe in Haskell: This function will cause an unrecoverable crash an error if the given key is neither nil. nor present in the table. Consider using the   ersatz function instead.luaThis function allocates a new block of memory with the given size, pushes onto the stack a new full userdata with the block address, and returns this address. The host program can freely use this memory. :https://www.lua.org/manual/5.3/manual.html#lua_newuserdata.lua=Creates a new thread, pushes it on the stack, and returns a  that represents this new thread. The new thread returned by this function shares with the original thread its global environment, but has an independent execution stack.There is no explicit function to close or to destroy a thread. Threads are subject to garbage collection, like any Lua object. 8https://www.lua.org/manual/5.3/manual.html#lua_newthreadluaLoads a Lua chunk (without running it). If there are no errors, lua_load pushes the compiled chunk as a Lua function on top of the stack. Otherwise, it pushes an error message.The return values of lua_load are:  : no errors; &: syntax error during pre-compilation; : memory allocation error; : error while running a __gc metamethod. (This error has no relation with the chunk being loaded. It is generated by the garbage collector.)5This function only loads a chunk; it does not run it.lua_load automatically detects whether the chunk is text or binary, and loads it accordingly (see program luac).The lua_load function uses a user-supplied reader function to read the chunk (see ). The data argument is an opaque value passed to the reader function.The  chunkname argument gives a name to the chunk, which is used for error messages and in debug information (see  .https://www.lua.org/manual/5.3/manual.html#4.94.9).lua_load automatically detects whether the chunk is text or binary and loads it accordingly (see program luac)). The string mode works as in function load, with the addition that a NULL) value is equivalent to the string "bt".lua_load uses the stack internally, so the reader function must always leave the stack unmodified when returning. 3https://www.lua.org/manual/5.3/manual.html#lua_load.luaReturns    if the value at the given index is a userdata (either full or light), and  ! otherwise. 9https://www.lua.org/manual/5.3/manual.html#lua_isuserdataluaReturns   3 if the value at the given index is a thread, and  ! otherwise. 7https://www.lua.org/manual/5.3/manual.html#lua_isthreadluaReturns   2 if the value at the given index is a table, and  ! otherwise. 6https://www.lua.org/manual/5.3/manual.html#lua_istableluaReturns    if the value at the given index is a string or a number (which is always convertible to a string), and  ! otherwise. 7https://www.lua.org/manual/5.3/manual.html#lua_isstringluaReturns    if the value at the given index is a number or a string convertible to a number, and  ! otherwise. 7https://www.lua.org/manual/5.3/manual.html#lua_isnumberluaReturns    if the given index is not valid or if the value at the given index is nil, and  ! otherwise. :https://www.lua.org/manual/5.3/manual.html#lua_isnoneornilluaReturns   ' if the given index is not valid, and  ! otherwise. 5https://www.lua.org/manual/5.3/manual.html#lua_isnoneluaReturns   % if the value at the given index is nil, and  ! otherwise. 4https://www.lua.org/manual/5.3/manual.html#lua_isnilluaReturns   ; if the value at the given index is a light userdata, and  ! otherwise. >https://www.lua.org/manual/5.3/manual.html#lua_islightuserdataluaReturns    if the value at the given index is an integer (that is, the value is a number and is represented as an integer), and  ! otherwise. 8https://www.lua.org/manual/5.3/manual.html#lua_isintegerluaReturns    if the value at the given index is a function (either C or Lua), and  ! otherwise. 9https://www.lua.org/manual/5.3/manual.html#lua_isfunctionluaReturns   7 if the value at the given index is a C function, and  ! otherwise. :https://www.lua.org/manual/5.3/manual.html#lua_iscfunctionluaReturns   4 if the value at the given index is a boolean, and  ! otherwise. 8https://www.lua.org/manual/5.3/manual.html#lua_isbooleanluaMoves the top element into the given valid index, shifting up the elements above this index to open space. This function cannot be called with a pseudo-index, because a pseudo-index is not an actual stack position. 5https://www.lua.org/manual/5.3/manual.html#lua_insertluaPushes onto the stack the Lua value associated with the full userdata at the given index.%Returns the type of the pushed value. ;https://www.lua.org/manual/5.3/manual.html#lua_getuservalueluaReturns the index of the top element in the stack. Because indices start at 1, this result is equal to the number of elements in the stack (and so 0 means an empty stack). 5https://www.lua.org/manual/5.3/manual.html#lua_gettoplua Pushes onto the stack the value t[k], where t& is the value at the given index and k& is the value at the top of the stack.This function pops the key from the stack, pushing the resulting value in its place. As in Lua, this function may trigger a metamethod for the "index" event (see  .https://www.lua.org/manual/5.3/manual.html#2.42.4).%Returns the type of the pushed value.WARNING:  lua_gettable is unsafe in Haskell: if the call to a metamethod triggers an error, then that error cannot be handled and will lead to an unrecoverable program crash. Consider using the  " ersatz function instead. Likewise, the metamethod may not call a Haskell function unless the library was compiled without allow-unsafe-gc. 7https://www.lua.org/manual/5.3/manual.html#lua_gettable.luaIf the value at the given index has a metatable, the function pushes that metatable onto the stack and returns 1#. Otherwise, the function returns 0! and pushes nothing on the stack. ;https://www.lua.org/manual/5.3/manual.html#lua_getmetatable.luaPushes onto the stack the value of the global name. Returns the type of that value.WARNING:  lua_getglobal is unsafe in Haskell: if the call to a metamethod triggers an error, then that error cannot be handled and will lead to an unrecoverable program crash. Consider using the  # ersatz function instead. Likewise, the metamethod may not call a Haskell function unless the library was compiled without allow-unsafe-gc. 8https://www.lua.org/manual/5.3/manual.html#lua_getglobal.luaControls the garbage collector.See the Lua docs at  1https://www.lua.org/manual/5.3/manual.html#lua_gc.luaCreates a new empty table and pushes it onto the stack. Parameter narr is a hint for how many elements the table will have as a sequence; parameter nrec is a hint for how many other elements the table will have. Lua may use these hints to preallocate memory for the new table. This preallocation is useful for performance when you know in advance how many elements the table will have. Otherwise you can use the function  lua_newtable. :https://www.lua.org/manual/5.3/manual.html#lua_createtable.luaCopies the element at index fromidx into the valid index toidx, replacing the value at that position. Values at other positions are not affected. 3https://www.lua.org/manual/5.3/manual.html#lua_copyluaConcatenates the n values at the top of the stack, pops them, and leaves the result at the top. If nis1, the result is the single value on the stack (that is, the function does nothing); if n is 0, the result is the empty string. Concatenation is performed following the usual semantics of Lua (see  0https://www.lua.org/manual/5.3/manual.html#3.4.63.4.6 of the Lua manual).WARNING:  lua_concat is unsafe in Haskell: This function will cause an unrecoverable crash an error if any of the concatenated values causes an error when executing a metamethod. Consider using the  $ ersatz function instead.luaDestroys all objects in the given Lua state (calling the corresponding garbage-collection metamethods, if any) and frees all dynamic memory used by this state. In several platforms, you may not need to call this function, because all resources are naturally released when the host program ends. On the other hand, long-running programs that create multiple states, such as daemons or web servers, will probably need to close states as soon as they are not needed. 4https://www.lua.org/manual/5.3/manual.html#lua_closelua.Ensures that the stack has space for at least n7 extra slots (that is, that you can safely push up to n values into it). It returns false if it cannot fulfill the request, either because it would cause the stack to be larger than a fixed maximum size (typically at least several thousand elements) or because it cannot allocate memory for the extra space. This function never shrinks the stack; if the stack already has space for the extra slots, it is left unchanged. 9https://www.lua.org/manual/5.3/manual.html#lua_checkstackluaConverts the acceptable index idx into an equivalent absolute index (that is, one that does not depend on the stack top). 7https://www.lua.org/manual/5.3/manual.html#lua_absindex[luatp `luaindexluaisnumaluaindexlualenbluaindexluaisnumgluaindex hluaindex jluaname pluan rluaidx1luaidx2uluas xluaslualen|luafnluan~luan luanargsluanresultsluamsghluaindex luareaderluadatalua chunknameluamodeluaindex luaname luawhat luadata luanarrluanrecluafromidxluatoidxluan luan luaidxQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[% 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2021 Albert KrewinkelMIT,Albert Krewinkel betaNone O QRSTUVWXYZ WVUTSRQXZY 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2021 Albert KrewinkelMIT,Albert Krewinkel betaForeignFunctionInterfaceNone Z$lua Value which Lua usually uses as .lua Value which Lua usually uses as .lua,Value signaling that no reference was found.lua.Value signaling that no reference was created.luaReturns a boolean that tells whether the collector is running (i.e., not stopped).luaSets data as the new value for the step multiplier of the collector (see 2.5) and returns the previous value of the step multiplier.luaSets data as the new value for the pause of the collector (see 2.5) and returns the previous value of the pause.lua3Performs an incremental step of garbage collection.luaReturns the remainder of dividing the current amount of bytes of memory in use by Lua by 1024.lua?Returns the current amount of memory (in Kbytes) in use by Lua.lua)Performs a full garbage-collection cycle.luaRestarts the garbage collector.luaStops the garbage collector.luaCompares for less or equal (<=)luaCompares for less than (<)luaCompares for equality (==)lua=File related error (e.g., the file cannot be opened or read).lua(Error while running the message handler.luaError while running a __gc metamethod. For such errors, Lua does not call the message handler (as this kind of error typically has no relation with the function being called).luaMemory allocation error. For such errors, Lua does not call the message handler.luaA syntax error.luaA runtime error.luaYielding / suspended coroutine.luaSuccess.luaType of Lua threadsluaType of full user datalua$Type of functions, either normal or luaType of Lua tablesluaType of Lua string valuesluaType of Lua numbers. See  &luaType of light userdataluaType of Lua booleansluaType of Lua's nil valueluaNon-valid stack indexlua Stack index of the Lua registry.luaOption for multiple returns in  .$$ 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2021 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None luaPushes a Haskell operation as a Lua function. The Haskell operation is expected to follow the custom error protocol, i.e., it must signal errors with  '.Example4Export the function to calculate triangular numbers. let triangular :: PreCFunction triangular l' = do n <- lua_tointegerx l' (nthBottom 1) nullPtr lua_pushinteger l' (sum [1..n]) return (NumResults 1) hslua_newhsfunction l triangular withCString "triangular" (lua_setglobal l) 2007@2012 Gracjan Polak;  2012@2016 mer Sinan Aacan;  2017-2021 Albert KrewinkelMIT,Albert Krewinkel betanon-portable (depends on GHC)None luaReference to a stored value.luaReference to a stored valueluaReference to a nil valueluaPushes onto the stack a string identifying the current position of the control at level lvl in the call stack. Typically this string has the following format: chunkname:currentline:Level0 is the running function, level1 is the function that called the running function, etc.;This function is used to build a prefix for error messages.lua%Checks whether the function argument arg is a userdata of the type tname (see )) and returns the userdata address (see  ( ). Returns NULL if the test fails. 9https://www.lua.org/manual/5.3/manual.html#luaL_testudataluaReleases reference ref from the table at index t (see ). The entry is removed from the table, so that the referred object can be collected. The reference ref! is also freed to be used again.lua,Creates and pushes a traceback of the stack l1. If msg is not NULL it is appended at the beginning of the traceback. The level parameter tells at which level to start the traceback.lua7Creates and returns a reference, in the table at index t, for the object at the top of the stack (and pops the object).A reference is a unique integer key. As long as you do not manually add integer keys into table t, luaL_ref ensures the uniqueness of the key it returns. You can retrieve an object referred by reference r by calling lua_rawgeti l t r . Function . frees a reference and its associated object..If the object at the top of the stack is nil, luaL_ref returns the constant ). The constant *? is guaranteed to be different from any reference returned by luaL_ref.lua6Opens all standard Lua libraries into the given state. 8https://www.lua.org/manual/5.3/manual.html#luaL_openlibslua$If the registry already has the key tname , returns 0. Otherwise, creates a new table to be used as a metatable for userdata, adds to this new table the pair __name = tname!, adds to the registry the pair [tname] = new table, and returns 1. (The entry __name, is used by some error-reporting functions.)In both cases pushes onto the stack the final value associated with tname in the registry.lua0Loads a file as a Lua chunk. This function uses lua_load? to load the chunk in the file named filename. If filename is NULL, then it loads from the standard input. The first line in the file is ignored if it starts with a #.%The string mode works as in function lua_load.*This function returns the same results as lua_load, but it has an extra error code LUA_ERRFILE for file-related errors (e.g., it cannot open or read the file).As lua_load:, this function only loads the chunk; it does not run it.lua0Equivalent to luaL_loadfilex with mode equal to NULL.lua2Loads a buffer as a Lua chunk. This function uses lua_load0 to load the chunk in the buffer pointed to by buff with size sz.*This function returns the same results as lua_load. name is the chunk name, used for debug information and error messages.luaPushes onto the stack the metatable associated with name tname in the registry (see ) (nil if there is no metatable associated with that name). Returns the type of the pushed value.lua Pushes onto the stack the field e, from the metatable of the object at index obj and returns the type of the pushed value. If the object does not have a metatable, or if the metatable does not have this field, pushes nothing and returns +.lua2Key, in the registry, for table of loaded modules.lua5Key, in the registry, for table of preloaded loaders.lua,Convert a reference to its C representation.lua-Create a reference from its C representation. luallualvllualluaargluatnameluat luaref luallual1luamsglualevelluat luatname luafilenameluamodeluafilenameluabuffluaszluanameluaobjluae  2021 Albert KrewinkelMIT,Albert Krewinkel betaportableNone luaRuns operations on a new Lua . The state is created when the function is called and closed on return. The state, and all pointers to values within it, must not% be used after the function returns.Example do luaL_openlibs l withCString "print" (lua_getglobal l) withCString "_VERSION" (lua_getglobal l) lua_pcall l (NumArgs 1) (NumResults 1) (StackIndex 0)lua9Stack index of the nth element from the top of the stack.luabetaForeignFunctionInterfaceNone PluaCreates and registers a new metatable for a userdata-wrapped Haskell value; checks whether a metatable of that name has been registered yet and uses the registered table if possible.lua9Creates a new userdata wrapping the given Haskell object.luaRetrieves a Haskell object from userdata at the given index. The userdata must have the given name.lua?Replaces the Haskell value contained in the userdata value at index&. Checks that the userdata is of type name and returns  on success, or  otherwise.lua Lua stateluaUserdata name (__name)lua&True iff new metatable was created.luauserdata indexluanameluaindexluanameluanew Haskell value,,-../00122334455677&&889:;<<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop$'#"qrstu(vwxyz{|}~ ! *)+         "lua-2.0.0.1-KJc66JUzHKzKQcTm2W3zBg Lua.TypesLua.LibLua.Ersatz.FunctionsLua.Ersatz.Auxiliary Lua.Primary Lua.ConstantsLua.Call Lua.AuxiliaryLua Lua.Userdataload Lua.Functions lua_gettop lua_setglobal lua_pcall lua_settable lua_getglobal lua_gettableLUA_OPEQLUA_OPLTLUA_OPLE LUA_TNONELUA_OK LUA_YIELDhslua_settablehslua_setglobal LUA_MULTRET hslua_next LUA_ERRSYNTAX LUA_ERRMEM LUA_ERRGCMMTRUEFALSEhslua_gettablehslua_getglobal hslua_concat Lua.ErsatzNumber hslua_errorlua_touserdata LUA_REFNIL LUA_NOREFLUA_TNIL NumResultsfromNumResultsNumArgs fromNumArgs StackIndexfromStackIndexGCCode StatusCodeOPCodeTypeCode fromTypeCodeLuaBoolIntegerReader PreCFunction CFunctionState$fEqNumResults$fNumNumResults$fOrdNumResults$fShowNumResults $fEqNumArgs $fNumNumArgs $fOrdNumArgs $fShowNumArgs$fEnumStackIndex$fEqStackIndex$fNumStackIndex$fOrdStackIndex$fShowStackIndex $fEqGCCode$fStorableGCCode$fEqStatusCode$fStorableStatusCode $fEqOPCode$fStorableOPCode $fEqTypeCode $fOrdTypeCode$fShowTypeCode $fEqLuaBool$fStorableLuaBool $fShowLuaBool $fEqNumber$fFloatingNumber$fFractionalNumber $fNumNumber $fOrdNumber $fRealNumber$fRealFloatNumber$fRealFracNumber $fShowNumber$fBoundedInteger $fEnumInteger $fEqInteger$fIntegralInteger $fNumInteger $fOrdInteger $fRealInteger $fShowInteger $fEqState$fGenericStateluaopen_package luaopen_debug luaopen_mathluaopen_string luaopen_os luaopen_io luaopen_table luaopen_base hslua_comparehsluaL_tolstringhsluaL_newstate lua_typenamelua_type lua_tothread lua_topointer lua_tonumberx lua_tolstringlua_tointegerxlua_tocfunction lua_toboolean lua_statuslua_setuservalue lua_settoplua_setmetatable lua_replace lua_remove lua_rawseti lua_rawset lua_rawlen lua_rawgeti lua_rawget lua_rawequal lua_pushvaluelua_pushthreadlua_pushstringlua_pushnumber lua_pushnillua_pushlstringlua_pushlightuserdatalua_pushintegerlua_pushglobaltablelua_pushcclosurelua_pushbooleanlua_poplua_nextlua_newuserdata lua_newthreadlua_loadlua_isuserdata lua_isthread lua_istable lua_isstring lua_isnumberlua_isnoneornil lua_isnone lua_isnillua_islightuserdata lua_isintegerlua_isfunctionlua_iscfunction lua_isboolean lua_insertlua_getuservaluelua_getmetatablelua_gclua_createtablelua_copy lua_concat lua_closelua_checkstack lua_absindexLUA_GCISRUNNINGLUA_GCSETSTEPMULLUA_GCSETPAUSE LUA_GCSTEP LUA_GCCOUNTB LUA_GCCOUNT LUA_GCCOLLECT LUA_GCRESTART LUA_GCSTOP LUA_ERRFILE LUA_ERRERR LUA_ERRRUN LUA_TTHREAD LUA_TUSERDATA LUA_TFUNCTION LUA_TTABLE LUA_TSTRING LUA_TNUMBERLUA_TLIGHTUSERDATA LUA_TBOOLEANLUA_REGISTRYINDEXhslua_pushhsfunction ReferenceRefNil luaL_whereluaL_testudata luaL_unrefluaL_tracebackluaL_ref luaL_openlibsluaL_newmetatableluaL_loadfilex luaL_loadfileluaL_loadbufferluaL_getmetatableluaL_getmetafieldloadedTableRegistryFieldpreloadTableRegistryField fromReference toReference $fEqReference$fShowReference withNewStatenthTop nthBottomnthtophslua_newudmetatablehslua_newhsuserdatahslua_fromuserdatahslua_putuserdatabaseForeign.C.TypesCIntghc-prim GHC.TypesFalseTrueDoubleGHC.IntInt64GHC.PtrnullPtr