:: a typeCtrl KGHC 9.10.3 · lts/ghc-9.10.x · 248f8f0 · 2026-10-05
Modulelua-2.3.2Haskell2010
Extend Haskell programs with a Lua interpreter.
This package provides the basic building blocks to integrate Lua into a Haskell program. The library is kept very close to the C Lua API, and users familiar with the C API should have no problem using it.
However, there are important differences of which users must be aware:
The method for error signaling used in Lua, based on setjmp and
longjmp, is incompatible with the Haskell FFI. All errors must be
handled at language boundaries, as failure to do so will lead to
unrecoverable crashes. C API functions that can throw Lua errors are
still exported, but non-error throwing hslua_ versions are provided as
safer alternatives. . The hslua ersatz functions have worse
performance than the original versions, but should be fast enough for
most use cases.
The Haskell FFI requires all C function that can call back into Haskell
to be imported safely. Some of the Lua functions may, directly or
indirectly, call a Haskell function, so they are always imported with
the safe keyword.
Many API functions can trigger garbage collection. This will lead to
problems if Haskell functions are used as part of finalizers (i.e.,
__gc metamethods). Haskell in finalizers is not supported by default,
but can be enabled by unsetting the allow-unsafe-gc flag.
Runs operations on a new Lua State. 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.
Run a small Lua operation (prints the major version of Lua).
withNewState $ \l -> do
luaL_openlibs l
withCString "print" (lua_getglobal l)
withCString "_VERSION" (lua_getglobal l)
lua_pcall l (NumArgs 1) (NumResults 1) (StackIndex 0)An 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
lua_State.
Eq StateDefined in lua-2.3.2 · Lua.TypesGeneric StateDefined in lua-2.3.2 · Lua.Typestype Rep State = D1 ('MetaData "State"
"Lua.Types"
"lua-2.3.2-70lbxEsccETF14NSmxmYYI"
'True) (C1 ('MetaCons "State"
'PrefixI 'False) (S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Ptr ()))))Defined in lua-2.3.2 · Lua.TypesThe reader function used by Lua.loadNULL or set size to zero. The reader function may
return pieces of any size greater than zero.
See lua_Reader.
Type 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, Lua.Functions.lua_gettopLua.Functions.lua_gettop
See lua_CFunction.
Type of Haskell functions that can be turned into C functions.
This is the same as a dereferenced CFunction.
The type of integers in Lua.
By default this type is Int64, but that can be changed to
different values in Lua. (See LUA_INT_TYPE in luaconf.h.)
See lua_Integer.
Bounded IntegerDefined in lua-2.3.2 · Lua.TypesEnum IntegerDefined in lua-2.3.2 · Lua.TypesEq IntegerDefined in lua-2.3.2 · Lua.TypesIntegral IntegerDefined in lua-2.3.2 · Lua.TypesNum IntegerDefined in lua-2.3.2 · Lua.TypesOrd IntegerDefined in lua-2.3.2 · Lua.TypesRead IntegerDefined in lua-2.3.2 · Lua.TypesReal IntegerDefined in lua-2.3.2 · Lua.TypesShow IntegerDefined in lua-2.3.2 · Lua.TypesThe type of floats in Lua.
By default this type is Double, but that can be changed in Lua to
a single float or a long double. (See LUA_FLOAT_TYPE in
luaconf.h.)
See lua_Number.
Eq NumberDefined in lua-2.3.2 · Lua.TypesFloating NumberDefined in lua-2.3.2 · Lua.TypesFractional NumberDefined in lua-2.3.2 · Lua.TypesNum NumberDefined in lua-2.3.2 · Lua.TypesOrd NumberDefined in lua-2.3.2 · Lua.TypesRead NumberDefined in lua-2.3.2 · Lua.TypesReal NumberDefined in lua-2.3.2 · Lua.TypesRealFloat NumberDefined in lua-2.3.2 · Lua.TypesRealFrac NumberDefined in lua-2.3.2 · Lua.TypesShow NumberDefined in lua-2.3.2 · Lua.TypesValue which Lua usually uses as True.
Value which Lua usually uses as False.
A stack index
Enum StackIndexDefined in lua-2.3.2 · Lua.TypesEq StackIndexDefined in lua-2.3.2 · Lua.TypesNum StackIndexDefined in lua-2.3.2 · Lua.TypesOrd StackIndexDefined in lua-2.3.2 · Lua.TypesShow StackIndexDefined in lua-2.3.2 · Lua.TypesStack index of the Lua registry.
The number of arguments consumed curing a function call.
The number of results returned by a function call.
Eq NumResultsDefined in lua-2.3.2 · Lua.TypesNum NumResultsDefined in lua-2.3.2 · Lua.TypesOrd NumResultsDefined in lua-2.3.2 · Lua.TypesShow NumResultsDefined in lua-2.3.2 · Lua.TypesOption for multiple returns in Lua.lua_pcall
Integer code used to encode the type of a Lua value.
Non-valid stack index
Type of Lua's nil value
Type of Lua booleans
Type of light userdata
Type of Lua numbers. See Lua.Number
Type of Lua string values
Type of Lua tables
Type of functions, either normal or CFunction
Type of full user data
Type of Lua threads
Compares for equality (==)
Compares for less than (<)
Compares for less or equal (<=)
Performs addition (+).
Performs subtraction (-)
Performs multiplication (*)
Performs float division (/)
Performs floor division (//)
Performs modulo (%)
Performs exponentiation (^)
Performs mathematical negation (unary -)
Performs bitwise NOT (~)
Performs bitwise AND (&)
Performs bitwise OR (|)
Performs bitwise exclusive OR (~)
Performs left shift (<<)
Performs right shift (>>)
Integer code used to signal the status of a thread or computation.
Eq StatusCodeDefined in lua-2.3.2 · Lua.TypesShow StatusCodeDefined in lua-2.3.2 · Lua.TypesStorable StatusCodeDefined in lua-2.3.2 · Lua.TypesSuccess.
Yielding / suspended coroutine.
A runtime error.
A syntax error.
Memory allocation error. For such errors, Lua does not call the message handler.
Error while running the message handler.
File related error (e.g., the file cannot be opened or read).
Stack index of the nth element from the top of the stack.
Stack index of the nth element from the bottom of the stack.
Alias for nthTop.
Index of the topmost stack element.
Destroys 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.
Creates a new thread, pushes it on the stack, and returns a State 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.
Returns the address of the version number (a C static variable)
stored in the Lua core. When called with a valid State, returns
the address of the version used to create that state. When called
with NULL, returns the address of the version running the call.
Converts the acceptable index idx into an equivalent absolute
index (that is, one that does not depend on the stack top).
Returns 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).
Accepts any index, or 0, and sets the stack top to this index. If
the new top is larger than the old one, then the new elements are
filled with *nil*. If index is 0, then all stack elements are
removed.
Pushes a copy of the element at the given index onto the stack.
Pops n elements from the stack.
Copies the element at index fromidx into the valid index toidx,
replacing the value at that position. Values at other positions are
not affected.
Removes the element at the given valid index, shifting down the elements above this index to fill the gap. This function cannot be called with a pseudo-index, because a pseudo-index is not an actual stack position.
Moves 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.
Moves the top element into the given valid index without shifting any element (therefore replacing the value at that given index), and then pops the top element.
Rotates the stack elements between the valid index idx and the
top of the stack. The elements are rotated n positions in the
direction of the top, for a positive n, or -n positions in the
direction of the bottom, for a negative n. The absolute value of
n must not be greater than the size of the slice being rotated.
This function cannot be called with a pseudo-index, because a
pseudo-index is not an actual stack position.
Ensures that the stack has space for at least n 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.
Returns Lua.TRUELua.FALSE
Returns Lua.TRUELua.FALSE
Returns Lua.TRUELua.FALSE
Returns Lua.TRUELua.FALSE
Returns Lua.TRUELua.FALSE
Returns Lua.TRUELua.FALSE
Returns Lua.TRUELua.FALSE
Returns Lua.TRUELua.FALSE
Returns Lua.TRUELua.FALSE
Returns Lua.TRUELua.FALSE
https://www.lua.org/manual/5.4/manual.html#lua_islightuserdata
Returns Lua.TRUELua.FALSE
Returns Lua.TRUELua.FALSE
Returns Lua.TRUELua.FALSE
Returns the type of the value in the given valid index, or
Lua.LUA_TNONE
Returns the name of the type encoded by the value tp, which must
be one the values returned by lua_type.
Returns True if the two values in indices idx1 and idx2 are
primitively equal (that is, without calling the __eq metamethod).
Otherwise returns False. Also returns False if any of the indices
are not valid.
Converts the Lua value at the given index to a haskell boolean
value. Like all tests in Lua, toboolean returns True for any Lua
value different from *false* and *nil*; otherwise it returns False.
(If you want to accept only actual boolean values, use
lua_isboolean to test the value's type.)
Converts a value at the given index to a C function. That value
must be a C function; otherwise, returns Nothing.
Converts the Lua value at the given acceptable index to the signed
integral type Integer. The Lua value must be an integer, a
number, or a string convertible to an integer (see
§3.4.3 of the Lua
5.4 Reference Manual); otherwise, lua_tointegerx returns 0.
If the number is not an integer, it is truncated in some non-specified way.
If isnum is not NULL, its referent is assigned a boolean value
that indicates whether the operation succeeded.
Converts the Lua value at the given index to the C type lua_Number (see lua_Number). The Lua value must be a number or a string convertible to a number (see §3.4.3); otherwise, lua_tonumberx returns 0.
If isnum is not NULL, its referent is assigned a boolean value
that indicates whether the operation succeeded.
Converts the Lua value at the given index to a C string. If len
is not NULL, it sets the referent with the string length. The Lua
value must be a string or a number; otherwise, the function returns
NULL. If the value is a number, then lua_tolstring also changes
the actual value in the stack to a string. (This change confuses
lua_next when lua_tolstring is applied to keys during a table
traversal.)
lua_tolstring returns a pointer to a string inside the Lua state.
This string always has a zero ('0') after its last character (as in
C), but can contain other zeros in its body.
Because Lua has garbage collection, there is no guarantee that the
pointer returned by lua_tolstring will be valid after the
corresponding Lua value is removed from the stack.
Converts the value at the given index to a generic C pointer
(void*). The value can be a userdata, a table, a thread, or a
function; otherwise, lua_topointer returns nullPtr. Different
objects will give different pointers. There is no way to convert the
pointer back to its original value.
Typically this function is used only for hashing and debug information.
If the value at the given index is a full userdata, returns its
block address. If the value is a light userdata, returns its pointer.
Otherwise, returns nullPtr.
Returns the raw "length" of the value at the given index: for
strings, this is the string length; for tables, this is the result of
the length operator (#) with no metamethods; for userdata, this is
the size of the block of memory allocated for the userdata; for other
values, it is 0.
Pushes a nil value onto the stack.
Pushes a float with the given value onto the stack.
Pushes an integer with with the given value onto the stack.
Pushes the string pointed to by s with size len onto the stack.
Lua makes (or reuses) an internal copy of the given string, so the
memory at s can be freed or reused immediately after the function
returns. The string can contain any binary data, including embedded
zeros.
Returns a pointer to the internal copy of the string.
Pushes the zero-terminated string pointed to by s onto the stack.
Lua makes (or reuses) an internal copy of the given string, so the
memory at s can be freed or reused immediately after the function
returns.
Returns a pointer to the internal copy of the string.
If s is NULL, pushes nil and returns NULL.
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
§3.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.4/manual.html#lua_pushcclosure.
Pushes a C function onto the stack. This function receives a
pointer to a C function and pushes onto the stack a Lua value of type
function that, when called, invokes the corresponding C function.
Any function to be callable by Lua must follow the correct protocol to receive its parameters and return its results (see CFunction).
https://www.lua.org/manual/5.4/manual.html#lua_pushcfunction.
Pushes a boolean value with the given value onto the stack.
Pushes a light userdata onto the stack.
Userdata represent C values in Lua. A light userdata represents a
pointer, a Ptr () (i.e., void* in C lingo). It is a value (like a
number): you do not create it, it has no individual metatable, and it
is not collected (as it was never created). A light userdata is equal
to "any" light userdata with the same C address.
https://www.lua.org/manual/5.4/manual.html#lua_pushlightuserdata.
Pushes the current thread onto the stack. Returns 1 iff this
thread is the main thread of its state.
Similar to lua_gettable, but does a raw access (i.e., without
metamethods).
Pushes onto the stack the value t[n], where t is the table at
the given index. The access is raw, that is, it does not invoke the
__index metamethod.
Creates 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.
This function creates and pushes on the stack a new full userdata,
with nuvalue associated Lua values, called user values, plus an
associated block of raw memory with size bytes. (The user values
can be set and read with the functions lua_setiuservalue and
lua_getiuservalue.)
The function returns the address of the block of memory. Lua ensures that this address is valid as long as the corresponding userdata is alive (see §2.5). Moreover, if the userdata is marked for finalization (see §2.5.3), its address is valid at least until the call to its finalizer.
https://www.lua.org/manual/5.4/manual.html#lua_newuserdatauv.
If 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.4/manual.html#lua_getmetatable.
Pushes onto the stack the n-th user value associated with the
full userdata at the given index and returns the type of the pushed
value.
If the userdata does not have that value, pushes nil and returns
LUA_TNONE.
https://www.lua.org/manual/5.4/manual.html#lua_getiuservalue
This is an unsafe function, errors will lead to a program crash; consider using hslua_getglobal instead.
Pushes 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
Lua.hslua_getglobalallow-unsafe-gc.
This is an unsafe function, errors will lead to a program crash; consider using hslua_gettable instead.
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 §2.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
Lua.hslua_gettableallow-unsafe-gc.
Similar to lua_settable, but does a raw assignment (i.e.,
without metamethods).
Does the equivalent of t[i] = v, where t is the table at the
given index and v is the value at the top of the stack.
This function pops the value from the stack. The assignment is raw,
that is, it does not invoke the __newindex metamethod.
Pops a table from the stack and sets it as the new metatable for the value at the given index.
https://www.lua.org/manual/5.4/manual.html#lua_setmetatable.
Pops a value from the stack and sets it as the new n-th user
value associated to the full userdata at the given index. Returns 0
if the userdata does not have that value.
https://www.lua.org/manual/5.4/manual.html#lua_setiuservalue
This is an unsafe function, errors will lead to a program crash; consider using hslua_getglobal instead.
Pops a value from the stack and sets it as the new value of global
name.
WARNING: lua_setglobal 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
Lua.hslua_setglobalallow-unsafe-gc.
This is an unsafe function, errors will lead to a program crash; consider using hslua_settable instead.
Does the equivalent to t[k] = v, where t is the value at the
given index, v is the value at the top of the stack, and k is the
value just below the top.
This function pops both the key and the value from the stack. As in Lua, this function may trigger a metamethod for the "newindex" event (see §2.4).
WARNING: lua_settable 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
Lua.hslua_settableallow-unsafe-gc.
Converts the zero-terminated string s to a number, pushes that
number into the stack, and returns the total size of the string, that
is, its length plus one. The conversion can result in an integer or a
float, according to the lexical conventions of Lua (see
§3.1). The string
may have leading and trailing spaces and a sign. If the string is not
a valid numeral, returns 0 and pushes nothing. (Note that the result
can be used as a boolean, true if the conversion succeeds.)
https://www.lua.org/manual/5.4/manual.html#lua_stringtonumber.
This is an unsafe function, errors will lead to a program crash; consider using hslua_arith instead.
Performs an arithmetic or bitwise operation over the two values (or one, in the case of negations) at the top of the stack, with the value at the top being the second operand, pops these values, and pushes the result of the operation. The function follows the semantics of the corresponding Lua operator (that is, it may call metamethods).
The value of op must be one of the following constants:
LUA_OPADD: performs addition (+)
LUA_OPSUB: performs subtraction (-)
LUA_OPMUL: performs multiplication (*)
LUA_OPDIV: performs float division (/)
LUA_OPIDIV: performs floor division (//)
LUA_OPMOD: performs modulo (%)
LUA_OPPOW: performs exponentiation (^)
LUA_OPUNM: performs mathematical negation (unary -)
LUA_OPBNOT: performs bitwise NOT (~)
LUA_OPBAND: performs bitwise AND (&)
LUA_OPBOR: performs bitwise OR (|)
LUA_OPBXOR: performs bitwise exclusive OR (~)
LUA_OPSHL: performs left shift (<<)
LUA_OPSHR: performs right shift (>>)
WARNING: lua_arith 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
Lua.hslua_arithallow-unsafe-gc.
This is an unsafe function, it will cause a program crash if a metamethod throws an error. Consider using hslua_concat instead.
Concatenates the n values at the top of the stack, pops them, and
leaves the result at the top. If n is 1, 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
§3.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 Lua.hslua_concat
This is an unsafe function, it will cause a program crash if the given key is neither nil nor present in the table. Consider using hslua_next instead.
Pops 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
lua_next
returns Lua.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
loopWhile traversing a table, do not call lua_tolstring directly on a key, unless you know that the key is actually a string. Recall that lua_tolstring may change the value at the given index; this confuses the next call to lua_next.
See function next 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 Lua.hslua_next
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 Lua.LUA_MULTRET
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
lua_pcall.
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 lua_pcall, since by then
the stack has unwound.
lua_load Loads 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:
Lua.LUA_OK
Lua.LUA_ERRSYNTAX
Lua.LUA_ERRMEM
Lua.LUA_ERRGCMM__gc
metamethod. (This error has no relation with the chunk being
loaded. It is generated by the garbage collector.)
This 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 Reader). 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
§4.7).
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.
Returns the status of this Lua thread.
The status can be Lua.LUA_OKlua_resume
with an error, or Lua.LUA_YIELD
You can only call functions in threads with status
Lua.LUA_OKLua.LUA_OKLua.LUA_YIELD
Controls the garbage collector.
See the Lua docs at https://www.lua.org/manual/5.4/manual.html#lua_gc. Unused dataN values should be set to 0, but can be anything.
Stops the garbage collector.
Restarts the garbage collector.
Performs a full garbage-collection cycle.
Returns the current amount of memory (in Kbytes) in use by Lua.
Returns the remainder of dividing the current amount of bytes of memory in use by Lua by 1024.
Performs an incremental step of garbage collection.
Sets data as the new value for the pause of the collector (see §2.5) and returns the previous value of the pause.
Sets data as the new value for the step multiplier of the collector (see §2.5) and returns the previous value of the step multiplier.
Returns a boolean that tells whether the collector is running (i.e., not stopped).
Changes the collector to generational mode.
Changes the collector to incremental mode.
Emits a warning with the given message. A message in a call with
tocont true should be continued in another call to this function.
See warn for more details about warnings.
Sets the warning function to be used by Lua to emit warnings (see
WarnFunction). The ud parameter sets the value ud passed to the
warning function.
The type of warning functions, called by Lua to emit warnings. The
first parameter is an opaque pointer set by lua_setwarnf. The
second parameter is the warning message. The third parameter is a
boolean that indicates whether the message is to be continued by the
message in the next call.
See warn for more details about warnings.
Pushes the global environment onto the stack.
https://www.lua.org/manual/5.4/manual.html#lua_pushglobaltable
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
LUA_TNIL.
Pushes onto the stack the metatable associated with name tname in
the registry (see luaL_newmetatable) (nil if there is no
metatable associated with that name). Returns the type of the pushed
value.
Loads a buffer as a Lua chunk. This function uses lua_load 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.
Opens all standard Lua libraries into the given state.
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.
Creates 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 luaL_unref frees a
reference and its associated object.
If the object at the top of the stack is nil, luaL_ref returns the
constant LUA_REFNIL. The constant
LUA_NOREF is guaranteed to be different
from any reference returned by luaL_ref.
Checks whether the function argument arg is a userdata of the
type tname (see luaL_newmetatable) and returns the userdata
address (see Lua.lua_touserdataNULL if the
test fails.
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.
Releases reference ref from the table at index t (see
luaL_ref). 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.
Key, in the registry, for table of loaded modules.
Key, in the registry, for table of preloaded loaders.
Reference to a stored value.
Value signaling that no reference was created.
Value signaling that no reference was found.
Convert a reference to its C representation.
Create a reference from its C representation.
Gets information about the n-th upvalue of the closure at index
funcindex. It pushes the upvalue's value onto the stack and
returns its name. Returns NULL (and pushes nothing) when the index
n is greater than the number of upvalues.
See debug.getupvalue for more information about upvalues.
[0, +(0|1), -]Sets the value of a closure’s upvalue. It assigns the value on the top of the stack to the upvalue and returns its name. It also pops the value from the stack.
Returns NULL (and pops nothing) when the index n is greater than
the number of upvalues.
Parameters funcindex and n are as in the function
lua_getupvalue.
[-(0|1), +0, -]Creates a new Lua state and set extra registry values for error bookkeeping.
Converts object to string, respecting any metamethods; returns
NULL if an error occurs.
hsluaL_requiref If modname is not already present in package.loaded. calls
function openf with string modname as an argument and sets the
call result in package.loaded[modname], as if that function has
been called through
require.
If glb is true, also stores the module into global modname.
Leaves a copy of the module on the stack.
Behaves like lua_gettable, but prevents
unrecoverable program crashes by calling that function through
Lua.lua_pcalllua_pcall.
Behaves like lua_getglobal, but prevents
unrecoverable program crashes by calling that function through
Lua.lua_pcalllua_pcall.
Behaves like lua_settable, but prevents
unrecoverable program crashes by calling that function through
Lua.lua_pcalllua_pcall.
Behaves like lua_setglobal, but prevents
unrecoverable program crashes by calling that function through
Lua.lua_pcalllua_pcall.
Replacement for lua_error; it uses the HsLua error signaling convention instead of raw Lua errors.
Wrapper around lua_next which catches any Lua errors.
Wrapper around lua_concat which catches any Lua errors.
Performs an arithmetic or bitwise operation over the two values (or one, in the case of negations) at the top of the stack, with the value at the top being the second operand, pops these values, and pushes the result of the operation. The function follows the semantics of the corresponding Lua operator (that is, it may call metamethods).
The value of op must be one of the following constants:
LUA_OPADD: performs addition (+)
LUA_OPSUB: performs subtraction (-)
LUA_OPMUL: performs multiplication (*)
LUA_OPDIV: performs float division (/)
LUA_OPIDIV: performs floor division (//)
LUA_OPMOD: performs modulo (%)
LUA_OPPOW: performs exponentiation (^)
LUA_OPUNM: performs mathematical negation (unary -)
LUA_OPBNOT: performs bitwise NOT (~)
LUA_OPBAND: performs bitwise AND (&)
LUA_OPBOR: performs bitwise OR (|)
LUA_OPBXOR: performs bitwise exclusive OR (~)
LUA_OPSHL: performs left shift (<<)
LUA_OPSHR: performs right shift (>>)
This function wraps lua_arith and takes an additional parameter
status; if it is not NULL, then the return value is set to the
status after calling lua_arith.
hslua_compare :: State-> StackIndexindex 1
-> StackIndexindex 2
-> OPCodeoperator
-> Ptr StatusCodestatus
-> IO LuaBoolCompares two Lua values. Returns 1 if the value at index index1
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.
The value of op must be one of the following constants:
LUA_OPEQ: compares for equality (==)
LUA_OPLT: compares for less than (<)
LUA_OPLE: 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.
Sets a warning function. This is a simplified version of lua_setwarnf. The function at the top of the stack is set as the "warning hook", i.e., it is called with the concatenated warning components as the single argument.
The hook function is popped of the stack.
The control messages @on and @off are still supported; as with
the default warning function, these commands can switch error
reporting to stderr on and off. The given Haskell function will be
called in either case, even when the error is not written to stderr.
Pointer to function opening the base library.
Pointer to function opening the table library.
Pointer to function opening the io library.
Pointer to function opening the os library.
Pointer to function opening the string library.
Pointer to function opening the math library.
Pointer to function opening the debug library.
Pointer to function opening the package library.
Pushes 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 Lua.hslua_error
Export 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)Lua version information in the form "Lua MAJOR.MINOR".
Lua version information in the form "Lua MAJOR.MINOR.RELEASE".
Lua copyright information; includes the Lua release