{-# LANGUAGE OverloadedStrings #-}
module HsLua.Core.Primary where
import Prelude hiding (EQ, LT, compare, concat, error)
import Control.Monad
import Data.ByteString (ByteString)
import Data.Maybe (fromMaybe)
import HsLua.Core.Error
import HsLua.Core.Types as Lua
import Lua
import Foreign.Marshal.Alloc (alloca)
import Foreign.Ptr
import qualified Data.ByteString as B
import qualified Data.ByteString.Unsafe as B
import qualified Foreign.Storable as F
ensureTable :: LuaError e => StackIndex -> (Lua.State -> IO a) -> LuaE e a
ensureTable :: forall e a. LuaError e => StackIndex -> (State -> IO a) -> LuaE e a
ensureTable StackIndex
idx State -> IO a
ioOp = do
Bool
isTbl <- forall e. StackIndex -> LuaE e Bool
istable StackIndex
idx
if Bool
isTbl
then forall a e. (State -> IO a) -> LuaE e a
liftLua State -> IO a
ioOp
else forall e a. LuaError e => ByteString -> StackIndex -> LuaE e a
throwTypeMismatchError ByteString
"table" StackIndex
idx
{-# INLINE ensureTable #-}
absindex :: StackIndex -> LuaE e StackIndex
absindex :: forall e. StackIndex -> LuaE e StackIndex
absindex = forall a b e. (State -> a -> IO b) -> a -> LuaE e b
liftLua1 State -> StackIndex -> IO StackIndex
lua_absindex
{-# INLINABLE absindex #-}
call :: LuaError e => NumArgs -> NumResults -> LuaE e ()
call :: forall e. LuaError e => NumArgs -> NumResults -> LuaE e ()
call NumArgs
nargs NumResults
nresults = do
Status
res <- forall e.
NumArgs -> NumResults -> Maybe StackIndex -> LuaE e Status
pcall NumArgs
nargs NumResults
nresults forall a. Maybe a
Nothing
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Status
res forall a. Eq a => a -> a -> Bool
/= Status
OK) forall e a. LuaError e => LuaE e a
throwErrorAsException
{-# INLINABLE call #-}
checkstack :: Int -> LuaE e Bool
checkstack :: forall e. Int -> LuaE e Bool
checkstack Int
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> CInt -> IO LuaBool
lua_checkstack State
l (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n)
{-# INLINABLE checkstack #-}
close :: Lua.State -> IO ()
close :: State -> IO ()
close = State -> IO ()
lua_close
{-# INLINABLE close #-}
compare :: LuaError e
=> StackIndex
-> StackIndex
-> RelationalOperator
-> LuaE e Bool
compare :: forall e.
LuaError e =>
StackIndex -> StackIndex -> RelationalOperator -> LuaE e Bool
compare StackIndex
idx1 StackIndex
idx2 RelationalOperator
relOp = LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> forall e a.
LuaError e =>
(State -> Ptr StatusCode -> IO a) -> LuaE e a
liftLuaThrow
(\State
l -> State
-> StackIndex
-> StackIndex
-> OPCode
-> Ptr StatusCode
-> IO LuaBool
hslua_compare State
l StackIndex
idx1 StackIndex
idx2 (RelationalOperator -> OPCode
fromRelationalOperator RelationalOperator
relOp))
{-# INLINABLE compare #-}
concat :: LuaError e => NumArgs -> LuaE e ()
concat :: forall e. LuaError e => NumArgs -> LuaE e ()
concat NumArgs
n = forall e a.
LuaError e =>
(State -> Ptr StatusCode -> IO a) -> LuaE e a
liftLuaThrow (State -> NumArgs -> Ptr StatusCode -> IO ()
`hslua_concat` NumArgs
n)
{-# INLINABLE concat #-}
copy :: StackIndex -> StackIndex -> LuaE e ()
copy :: forall e. StackIndex -> StackIndex -> LuaE e ()
copy StackIndex
fromidx StackIndex
toidx = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> StackIndex -> StackIndex -> IO ()
lua_copy State
l StackIndex
fromidx StackIndex
toidx
{-# INLINABLE copy #-}
createtable :: Int -> Int -> LuaE e ()
createtable :: forall e. Int -> Int -> LuaE e ()
createtable Int
narr Int
nrec = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
State -> CInt -> CInt -> IO ()
lua_createtable State
l (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
narr) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
nrec)
{-# INLINABLE createtable #-}
equal :: LuaError e
=> StackIndex
-> StackIndex
-> LuaE e Bool
equal :: forall e. LuaError e => StackIndex -> StackIndex -> LuaE e Bool
equal StackIndex
index1 StackIndex
index2 = forall e.
LuaError e =>
StackIndex -> StackIndex -> RelationalOperator -> LuaE e Bool
compare StackIndex
index1 StackIndex
index2 RelationalOperator
EQ
{-# INLINABLE equal #-}
error :: LuaE e NumResults
error :: forall e. LuaE e NumResults
error = forall a e. (State -> IO a) -> LuaE e a
liftLua State -> IO NumResults
hslua_error
{-# INLINABLE error #-}
gc :: GCControl -> LuaE e Int
gc :: forall e. GCControl -> LuaE e Int
gc GCControl
what = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> do
let (CInt
data1, CInt
data2, CInt
data3) = GCControl -> (CInt, CInt, CInt)
toGCdata GCControl
what
forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> GCCode -> CInt -> CInt -> CInt -> IO CInt
lua_gc State
l (GCControl -> GCCode
toGCcode GCControl
what) CInt
data1 CInt
data2 CInt
data3
{-# INLINABLE gc #-}
getfield :: LuaError e => StackIndex -> Name -> LuaE e Type
getfield :: forall e. LuaError e => StackIndex -> Name -> LuaE e Type
getfield StackIndex
i (Name ByteString
s) = do
StackIndex
absidx <- forall e. StackIndex -> LuaE e StackIndex
absindex StackIndex
i
forall e. ByteString -> LuaE e ()
pushstring ByteString
s
forall e. LuaError e => StackIndex -> LuaE e Type
gettable StackIndex
absidx
{-# INLINABLE getfield #-}
getglobal :: LuaError e => Name -> LuaE e Type
getglobal :: forall e. LuaError e => Name -> LuaE e Type
getglobal (Name ByteString
name) = forall e a.
LuaError e =>
(State -> Ptr StatusCode -> IO a) -> LuaE e a
liftLuaThrow forall a b. (a -> b) -> a -> b
$ \State
l Ptr StatusCode
status' ->
forall a. ByteString -> (CStringLen -> IO a) -> IO a
B.unsafeUseAsCStringLen ByteString
name forall a b. (a -> b) -> a -> b
$ \(Ptr CChar
namePtr, Int
len) ->
TypeCode -> Type
toType forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> Ptr CChar -> CSize -> Ptr StatusCode -> IO TypeCode
hslua_getglobal State
l Ptr CChar
namePtr (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
len) Ptr StatusCode
status'
{-# INLINABLE getglobal #-}
getmetatable :: StackIndex -> LuaE e Bool
getmetatable :: forall e. StackIndex -> LuaE e Bool
getmetatable StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_getmetatable State
l StackIndex
n
{-# INLINABLE getmetatable #-}
gettable :: LuaError e => StackIndex -> LuaE e Type
gettable :: forall e. LuaError e => StackIndex -> LuaE e Type
gettable StackIndex
n = forall e a.
LuaError e =>
(State -> Ptr StatusCode -> IO a) -> LuaE e a
liftLuaThrow (\State
l -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TypeCode -> Type
toType forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> StackIndex -> Ptr StatusCode -> IO TypeCode
hslua_gettable State
l StackIndex
n)
{-# INLINABLE gettable #-}
gettop :: LuaE e StackIndex
gettop :: forall e. LuaE e StackIndex
gettop = forall a e. (State -> IO a) -> LuaE e a
liftLua State -> IO StackIndex
lua_gettop
{-# INLINABLE gettop #-}
getiuservalue :: StackIndex
-> Int
-> LuaE e Type
getiuservalue :: forall e. StackIndex -> Int -> LuaE e Type
getiuservalue StackIndex
idx Int
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
TypeCode -> Type
toType forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> CInt -> IO TypeCode
lua_getiuservalue State
l StackIndex
idx (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n)
insert :: StackIndex -> LuaE e ()
insert :: forall e. StackIndex -> LuaE e ()
insert StackIndex
index = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> StackIndex -> IO ()
lua_insert State
l StackIndex
index
{-# INLINABLE insert #-}
isboolean :: StackIndex -> LuaE e Bool
isboolean :: forall e. StackIndex -> LuaE e Bool
isboolean StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_isboolean State
l StackIndex
n
{-# INLINABLE isboolean #-}
iscfunction :: StackIndex -> LuaE e Bool
iscfunction :: forall e. StackIndex -> LuaE e Bool
iscfunction StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_iscfunction State
l StackIndex
n
{-# INLINABLE iscfunction #-}
isfunction :: StackIndex -> LuaE e Bool
isfunction :: forall e. StackIndex -> LuaE e Bool
isfunction StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_isfunction State
l StackIndex
n
{-# INLINABLE isfunction #-}
isinteger :: StackIndex -> LuaE e Bool
isinteger :: forall e. StackIndex -> LuaE e Bool
isinteger StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_isinteger State
l StackIndex
n
{-# INLINABLE isinteger #-}
islightuserdata :: StackIndex -> LuaE e Bool
islightuserdata :: forall e. StackIndex -> LuaE e Bool
islightuserdata StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_islightuserdata State
l StackIndex
n
{-# INLINABLE islightuserdata #-}
isnil :: StackIndex -> LuaE e Bool
isnil :: forall e. StackIndex -> LuaE e Bool
isnil StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_isnil State
l StackIndex
n
{-# INLINABLE isnil #-}
isnone :: StackIndex -> LuaE e Bool
isnone :: forall e. StackIndex -> LuaE e Bool
isnone StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_isnone State
l StackIndex
n
{-# INLINABLE isnone #-}
isnoneornil :: StackIndex -> LuaE e Bool
isnoneornil :: forall e. StackIndex -> LuaE e Bool
isnoneornil StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_isnoneornil State
l StackIndex
n
{-# INLINABLE isnoneornil #-}
isnumber :: StackIndex -> LuaE e Bool
isnumber :: forall e. StackIndex -> LuaE e Bool
isnumber StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_isnumber State
l StackIndex
n
{-# INLINABLE isnumber #-}
isstring :: StackIndex -> LuaE e Bool
isstring :: forall e. StackIndex -> LuaE e Bool
isstring StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_isstring State
l StackIndex
n
{-# INLINABLE isstring #-}
istable :: StackIndex -> LuaE e Bool
istable :: forall e. StackIndex -> LuaE e Bool
istable StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_istable State
l StackIndex
n
{-# INLINABLE istable #-}
isthread :: StackIndex -> LuaE e Bool
isthread :: forall e. StackIndex -> LuaE e Bool
isthread StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_isthread State
l StackIndex
n
{-# INLINABLE isthread #-}
isuserdata :: StackIndex -> LuaE e Bool
isuserdata :: forall e. StackIndex -> LuaE e Bool
isuserdata StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_isuserdata State
l StackIndex
n
{-# INLINABLE isuserdata #-}
lessthan :: LuaError e => StackIndex -> StackIndex -> LuaE e Bool
lessthan :: forall e. LuaError e => StackIndex -> StackIndex -> LuaE e Bool
lessthan StackIndex
index1 StackIndex
index2 = forall e.
LuaError e =>
StackIndex -> StackIndex -> RelationalOperator -> LuaE e Bool
compare StackIndex
index1 StackIndex
index2 RelationalOperator
LT
{-# INLINABLE lessthan #-}
load :: Lua.Reader -> Ptr () -> Name -> LuaE e Status
load :: forall e. Reader -> Ptr () -> Name -> LuaE e Status
load Reader
reader Ptr ()
data' (Name ByteString
chunkname) = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
forall a. ByteString -> (Ptr CChar -> IO a) -> IO a
B.useAsCString ByteString
chunkname forall a b. (a -> b) -> a -> b
$ \Ptr CChar
namePtr ->
StatusCode -> Status
toStatus forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State
-> Reader -> Ptr () -> Ptr CChar -> Ptr CChar -> IO StatusCode
lua_load State
l Reader
reader Ptr ()
data' Ptr CChar
namePtr forall a. Ptr a
nullPtr
{-# INLINABLE load #-}
ltype :: StackIndex -> LuaE e Type
ltype :: forall e. StackIndex -> LuaE e Type
ltype StackIndex
idx = TypeCode -> Type
toType forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> forall a e. (State -> IO a) -> LuaE e a
liftLua (State -> StackIndex -> IO TypeCode
`lua_type` StackIndex
idx)
{-# INLINABLE ltype #-}
newtable :: LuaE e ()
newtable :: forall e. LuaE e ()
newtable = forall e. Int -> Int -> LuaE e ()
createtable Int
0 Int
0
{-# INLINABLE newtable #-}
newuserdatauv :: Int -> Int -> LuaE e (Ptr ())
newuserdatauv :: forall e. Int -> Int -> LuaE e (Ptr ())
newuserdatauv Int
size Int
nuvalue =
forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> CSize -> CInt -> IO (Ptr ())
lua_newuserdatauv State
l (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
size) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
nuvalue)
{-# INLINABLE newuserdatauv #-}
next :: LuaError e => StackIndex -> LuaE e Bool
next :: forall e. LuaError e => StackIndex -> LuaE e Bool
next StackIndex
idx = LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> forall e a.
LuaError e =>
(State -> Ptr StatusCode -> IO a) -> LuaE e a
liftLuaThrow (\State
l -> State -> StackIndex -> Ptr StatusCode -> IO LuaBool
hslua_next State
l StackIndex
idx)
{-# INLINABLE next #-}
openlibs :: LuaE e ()
openlibs :: forall e. LuaE e ()
openlibs = forall a e. (State -> IO a) -> LuaE e a
liftLua State -> IO ()
luaL_openlibs
{-# INLINABLE openlibs #-}
openbase :: LuaError e => LuaE e ()
openbase :: forall e. LuaError e => LuaE e ()
openbase = forall e. CFunction -> LuaE e ()
pushcfunction CFunction
luaopen_base forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e. LuaError e => NumArgs -> NumResults -> LuaE e ()
call NumArgs
0 NumResults
multret
{-# INLINABLE openbase #-}
opendebug :: LuaError e => LuaE e ()
opendebug :: forall e. LuaError e => LuaE e ()
opendebug = forall e. CFunction -> LuaE e ()
pushcfunction CFunction
luaopen_debug forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e. LuaError e => NumArgs -> NumResults -> LuaE e ()
call NumArgs
0 NumResults
multret
{-# INLINABLE opendebug #-}
openio :: LuaError e => LuaE e ()
openio :: forall e. LuaError e => LuaE e ()
openio = forall e. CFunction -> LuaE e ()
pushcfunction CFunction
luaopen_io forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e. LuaError e => NumArgs -> NumResults -> LuaE e ()
call NumArgs
0 NumResults
multret
{-# INLINABLE openio #-}
openmath :: LuaError e => LuaE e ()
openmath :: forall e. LuaError e => LuaE e ()
openmath = forall e. CFunction -> LuaE e ()
pushcfunction CFunction
luaopen_math forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e. LuaError e => NumArgs -> NumResults -> LuaE e ()
call NumArgs
0 NumResults
multret
{-# INLINABLE openmath #-}
openos :: LuaError e => LuaE e ()
openos :: forall e. LuaError e => LuaE e ()
openos = forall e. CFunction -> LuaE e ()
pushcfunction CFunction
luaopen_os forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e. LuaError e => NumArgs -> NumResults -> LuaE e ()
call NumArgs
0 NumResults
multret
{-# INLINABLE openos #-}
openpackage :: LuaError e => LuaE e ()
openpackage :: forall e. LuaError e => LuaE e ()
openpackage = forall e. CFunction -> LuaE e ()
pushcfunction CFunction
luaopen_package forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e. LuaError e => NumArgs -> NumResults -> LuaE e ()
call NumArgs
0 NumResults
multret
{-# INLINABLE openpackage #-}
openstring :: LuaError e => LuaE e ()
openstring :: forall e. LuaError e => LuaE e ()
openstring = forall e. CFunction -> LuaE e ()
pushcfunction CFunction
luaopen_string forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e. LuaError e => NumArgs -> NumResults -> LuaE e ()
call NumArgs
0 NumResults
multret
{-# INLINABLE openstring #-}
opentable :: LuaError e => LuaE e ()
opentable :: forall e. LuaError e => LuaE e ()
opentable = forall e. CFunction -> LuaE e ()
pushcfunction CFunction
luaopen_table forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e. LuaError e => NumArgs -> NumResults -> LuaE e ()
call NumArgs
0 NumResults
multret
{-# INLINABLE opentable #-}
pcall :: NumArgs -> NumResults -> Maybe StackIndex -> LuaE e Status
pcall :: forall e.
NumArgs -> NumResults -> Maybe StackIndex -> LuaE e Status
pcall NumArgs
nargs NumResults
nresults Maybe StackIndex
msgh = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
StatusCode -> Status
toStatus forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> NumArgs -> NumResults -> StackIndex -> IO StatusCode
lua_pcall State
l NumArgs
nargs NumResults
nresults (forall a. a -> Maybe a -> a
fromMaybe StackIndex
0 Maybe StackIndex
msgh)
{-# INLINABLE pcall #-}
pop :: Int -> LuaE e ()
pop :: forall e. Int -> LuaE e ()
pop Int
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> CInt -> IO ()
lua_pop State
l (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n)
{-# INLINABLE pop #-}
pushboolean :: Bool -> LuaE e ()
pushboolean :: forall e. Bool -> LuaE e ()
pushboolean Bool
b = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> LuaBool -> IO ()
lua_pushboolean State
l (Bool -> LuaBool
toLuaBool Bool
b)
{-# INLINABLE pushboolean #-}
pushcclosure :: CFunction -> NumArgs -> LuaE e ()
pushcclosure :: forall e. CFunction -> NumArgs -> LuaE e ()
pushcclosure CFunction
f NumArgs
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> CFunction -> NumArgs -> IO ()
lua_pushcclosure State
l CFunction
f NumArgs
n
{-# INLINABLE pushcclosure #-}
pushcfunction :: CFunction -> LuaE e ()
pushcfunction :: forall e. CFunction -> LuaE e ()
pushcfunction CFunction
f = forall e. CFunction -> NumArgs -> LuaE e ()
pushcclosure CFunction
f NumArgs
0
{-# INLINABLE pushcfunction #-}
pushglobaltable :: LuaE e ()
pushglobaltable :: forall e. LuaE e ()
pushglobaltable = forall a e. (State -> IO a) -> LuaE e a
liftLua State -> IO ()
lua_pushglobaltable
{-# INLINABLE pushglobaltable #-}
pushinteger :: Lua.Integer -> LuaE e ()
pushinteger :: forall e. Integer -> LuaE e ()
pushinteger = forall a b e. (State -> a -> IO b) -> a -> LuaE e b
liftLua1 State -> Integer -> IO ()
lua_pushinteger
{-# INLINABLE pushinteger #-}
pushlightuserdata :: Ptr a -> LuaE e ()
pushlightuserdata :: forall a e. Ptr a -> LuaE e ()
pushlightuserdata = forall a b e. (State -> a -> IO b) -> a -> LuaE e b
liftLua1 forall a. State -> Ptr a -> IO ()
lua_pushlightuserdata
{-# INLINABLE pushlightuserdata #-}
pushnil :: LuaE e ()
pushnil :: forall e. LuaE e ()
pushnil = forall a e. (State -> IO a) -> LuaE e a
liftLua State -> IO ()
lua_pushnil
{-# INLINABLE pushnil #-}
pushnumber :: Lua.Number -> LuaE e ()
pushnumber :: forall e. Number -> LuaE e ()
pushnumber = forall a b e. (State -> a -> IO b) -> a -> LuaE e b
liftLua1 State -> Number -> IO ()
lua_pushnumber
{-# INLINABLE pushnumber #-}
pushstring :: ByteString -> LuaE e ()
pushstring :: forall e. ByteString -> LuaE e ()
pushstring ByteString
s = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
forall a. ByteString -> (CStringLen -> IO a) -> IO a
B.unsafeUseAsCStringLen ByteString
s forall a b. (a -> b) -> a -> b
$ \(Ptr CChar
sPtr, Int
z) -> State -> Ptr CChar -> CSize -> IO ()
lua_pushlstring State
l Ptr CChar
sPtr (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
z)
{-# INLINABLE pushstring #-}
pushthread :: LuaE e Bool
pushthread :: forall e. LuaE e Bool
pushthread = (CInt
1 forall a. Eq a => a -> a -> Bool
==) forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> forall a e. (State -> IO a) -> LuaE e a
liftLua State -> IO CInt
lua_pushthread
{-# INLINABLE pushthread #-}
pushvalue :: StackIndex -> LuaE e ()
pushvalue :: forall e. StackIndex -> LuaE e ()
pushvalue StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> StackIndex -> IO ()
lua_pushvalue State
l StackIndex
n
{-# INLINABLE pushvalue #-}
rawequal :: StackIndex -> StackIndex -> LuaE e Bool
rawequal :: forall e. StackIndex -> StackIndex -> LuaE e Bool
rawequal StackIndex
idx1 StackIndex
idx2 = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> StackIndex -> IO LuaBool
lua_rawequal State
l StackIndex
idx1 StackIndex
idx2
{-# INLINABLE rawequal #-}
rawget :: LuaError e => StackIndex -> LuaE e Type
rawget :: forall e. LuaError e => StackIndex -> LuaE e Type
rawget StackIndex
n = forall e a. LuaError e => StackIndex -> (State -> IO a) -> LuaE e a
ensureTable StackIndex
n (\State
l -> TypeCode -> Type
toType forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO TypeCode
lua_rawget State
l StackIndex
n)
{-# INLINABLE rawget #-}
rawgeti :: LuaError e => StackIndex -> Lua.Integer -> LuaE e Type
rawgeti :: forall e. LuaError e => StackIndex -> Integer -> LuaE e Type
rawgeti StackIndex
k Integer
n = forall e a. LuaError e => StackIndex -> (State -> IO a) -> LuaE e a
ensureTable StackIndex
k (\State
l -> TypeCode -> Type
toType forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> Integer -> IO TypeCode
lua_rawgeti State
l StackIndex
k Integer
n)
{-# INLINABLE rawgeti #-}
rawlen :: StackIndex -> LuaE e Int
rawlen :: forall e. StackIndex -> LuaE e Int
rawlen StackIndex
idx = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO CSize
lua_rawlen State
l StackIndex
idx
{-# INLINABLE rawlen #-}
rawset :: LuaError e => StackIndex -> LuaE e ()
rawset :: forall e. LuaError e => StackIndex -> LuaE e ()
rawset StackIndex
n = forall e a. LuaError e => StackIndex -> (State -> IO a) -> LuaE e a
ensureTable StackIndex
n (\State
l -> State -> StackIndex -> IO ()
lua_rawset State
l StackIndex
n)
{-# INLINABLE rawset #-}
rawseti :: LuaError e => StackIndex -> Lua.Integer -> LuaE e ()
rawseti :: forall e. LuaError e => StackIndex -> Integer -> LuaE e ()
rawseti StackIndex
k Integer
m = forall e a. LuaError e => StackIndex -> (State -> IO a) -> LuaE e a
ensureTable StackIndex
k (\State
l -> State -> StackIndex -> Integer -> IO ()
lua_rawseti State
l StackIndex
k Integer
m)
{-# INLINABLE rawseti #-}
register :: LuaError e => Name -> CFunction -> LuaE e ()
register :: forall e. LuaError e => Name -> CFunction -> LuaE e ()
register Name
name CFunction
f = do
forall e. CFunction -> LuaE e ()
pushcfunction CFunction
f
forall e. LuaError e => Name -> LuaE e ()
setglobal Name
name
{-# INLINABLE register #-}
remove :: StackIndex -> LuaE e ()
remove :: forall e. StackIndex -> LuaE e ()
remove StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> StackIndex -> IO ()
lua_remove State
l StackIndex
n
{-# INLINABLE remove #-}
replace :: StackIndex -> LuaE e ()
replace :: forall e. StackIndex -> LuaE e ()
replace StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> StackIndex -> IO ()
lua_replace State
l StackIndex
n
{-# INLINABLE replace #-}
rotate :: StackIndex
-> Int
-> LuaE e ()
rotate :: forall e. StackIndex -> Int -> LuaE e ()
rotate StackIndex
idx Int
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> StackIndex -> CInt -> IO ()
lua_rotate State
l StackIndex
idx (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n)
{-# INLINABLE rotate #-}
setfield :: LuaError e => StackIndex -> Name -> LuaE e ()
setfield :: forall e. LuaError e => StackIndex -> Name -> LuaE e ()
setfield StackIndex
i (Name ByteString
s) = do
StackIndex
absidx <- forall e. StackIndex -> LuaE e StackIndex
absindex StackIndex
i
forall e. ByteString -> LuaE e ()
pushstring ByteString
s
forall e. StackIndex -> LuaE e ()
insert (CInt -> StackIndex
nthTop CInt
2)
forall e. LuaError e => StackIndex -> LuaE e ()
settable StackIndex
absidx
{-# INLINABLE setfield #-}
setglobal :: LuaError e => Name -> LuaE e ()
setglobal :: forall e. LuaError e => Name -> LuaE e ()
setglobal (Name ByteString
name) = forall e a.
LuaError e =>
(State -> Ptr StatusCode -> IO a) -> LuaE e a
liftLuaThrow forall a b. (a -> b) -> a -> b
$ \State
l Ptr StatusCode
status' ->
forall a. ByteString -> (CStringLen -> IO a) -> IO a
B.unsafeUseAsCStringLen ByteString
name forall a b. (a -> b) -> a -> b
$ \(Ptr CChar
namePtr, Int
nameLen) ->
State -> Ptr CChar -> CSize -> Ptr StatusCode -> IO ()
hslua_setglobal State
l Ptr CChar
namePtr (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
nameLen) Ptr StatusCode
status'
{-# INLINABLE setglobal #-}
setmetatable :: StackIndex -> LuaE e ()
setmetatable :: forall e. StackIndex -> LuaE e ()
setmetatable StackIndex
idx = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> StackIndex -> IO ()
lua_setmetatable State
l StackIndex
idx
{-# INLINABLE setmetatable #-}
settable :: LuaError e => StackIndex -> LuaE e ()
settable :: forall e. LuaError e => StackIndex -> LuaE e ()
settable StackIndex
index = forall e a.
LuaError e =>
(State -> Ptr StatusCode -> IO a) -> LuaE e a
liftLuaThrow forall a b. (a -> b) -> a -> b
$ \State
l -> State -> StackIndex -> Ptr StatusCode -> IO ()
hslua_settable State
l StackIndex
index
{-# INLINABLE settable #-}
settop :: StackIndex -> LuaE e ()
settop :: forall e. StackIndex -> LuaE e ()
settop = forall a b e. (State -> a -> IO b) -> a -> LuaE e b
liftLua1 State -> StackIndex -> IO ()
lua_settop
{-# INLINABLE settop #-}
setiuservalue :: StackIndex -> Int -> LuaE e Bool
setiuservalue :: forall e. StackIndex -> Int -> LuaE e Bool
setiuservalue StackIndex
idx Int
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> CInt -> IO LuaBool
lua_setiuservalue State
l StackIndex
idx (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n)
setwarnf :: WarnFunction
-> Ptr ()
-> LuaE e ()
setwarnf :: forall e. WarnFunction -> Ptr () -> LuaE e ()
setwarnf WarnFunction
f Ptr ()
ud = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
State -> WarnFunction -> Ptr () -> IO ()
lua_setwarnf State
l WarnFunction
f Ptr ()
ud
status :: LuaE e Status
status :: forall e. LuaE e Status
status = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap StatusCode -> Status
toStatus forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> IO StatusCode
lua_status
{-# INLINABLE status #-}
toboolean :: StackIndex -> LuaE e Bool
toboolean :: forall e. StackIndex -> LuaE e Bool
toboolean StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> State -> StackIndex -> IO LuaBool
lua_toboolean State
l StackIndex
n
{-# INLINABLE toboolean #-}
tocfunction :: StackIndex -> LuaE e (Maybe CFunction)
tocfunction :: forall e. StackIndex -> LuaE e (Maybe CFunction)
tocfunction StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> do
CFunction
fnPtr <- State -> StackIndex -> IO CFunction
lua_tocfunction State
l StackIndex
n
forall (m :: * -> *) a. Monad m => a -> m a
return (if CFunction
fnPtr forall a. Eq a => a -> a -> Bool
== forall a. FunPtr a
nullFunPtr then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just CFunction
fnPtr)
{-# INLINABLE tocfunction #-}
tointeger :: StackIndex -> LuaE e (Maybe Lua.Integer)
tointeger :: forall e. StackIndex -> LuaE e (Maybe Integer)
tointeger StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca forall a b. (a -> b) -> a -> b
$ \Ptr LuaBool
boolPtr -> do
Integer
res <- State -> StackIndex -> Ptr LuaBool -> IO Integer
lua_tointegerx State
l StackIndex
n Ptr LuaBool
boolPtr
Bool
isNum <- LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> forall a. Storable a => Ptr a -> IO a
F.peek Ptr LuaBool
boolPtr
forall (m :: * -> *) a. Monad m => a -> m a
return (if Bool
isNum then forall a. a -> Maybe a
Just Integer
res else forall a. Maybe a
Nothing)
{-# INLINABLE tointeger #-}
tonumber :: StackIndex -> LuaE e (Maybe Lua.Number)
tonumber :: forall e. StackIndex -> LuaE e (Maybe Number)
tonumber StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca forall a b. (a -> b) -> a -> b
$ \Ptr LuaBool
bptr -> do
Number
res <- State -> StackIndex -> Ptr LuaBool -> IO Number
lua_tonumberx State
l StackIndex
n Ptr LuaBool
bptr
Bool
isNum <- LuaBool -> Bool
fromLuaBool forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> forall a. Storable a => Ptr a -> IO a
F.peek Ptr LuaBool
bptr
forall (m :: * -> *) a. Monad m => a -> m a
return (if Bool
isNum then forall a. a -> Maybe a
Just Number
res else forall a. Maybe a
Nothing)
{-# INLINABLE tonumber #-}
topointer :: StackIndex -> LuaE e (Ptr ())
topointer :: forall e. StackIndex -> LuaE e (Ptr ())
topointer StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> State -> StackIndex -> IO (Ptr ())
lua_topointer State
l StackIndex
n
{-# INLINABLE topointer #-}
tostring :: StackIndex -> LuaE e (Maybe ByteString)
tostring :: forall e. StackIndex -> LuaE e (Maybe ByteString)
tostring StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca forall a b. (a -> b) -> a -> b
$ \Ptr CSize
lenPtr -> do
Ptr CChar
cstr <- State -> StackIndex -> Ptr CSize -> IO (Ptr CChar)
lua_tolstring State
l StackIndex
n Ptr CSize
lenPtr
if Ptr CChar
cstr forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr
then forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
else do
CSize
cstrLen <- forall a. Storable a => Ptr a -> IO a
F.peek Ptr CSize
lenPtr
forall a. a -> Maybe a
Just forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> CStringLen -> IO ByteString
B.packCStringLen (Ptr CChar
cstr, forall a b. (Integral a, Num b) => a -> b
fromIntegral CSize
cstrLen)
{-# INLINABLE tostring #-}
tothread :: StackIndex -> LuaE e (Maybe Lua.State)
tothread :: forall e. StackIndex -> LuaE e (Maybe State)
tothread StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> do
thread :: State
thread@(Lua.State Ptr ()
ptr) <- State -> StackIndex -> IO State
lua_tothread State
l StackIndex
n
if Ptr ()
ptr forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr
then forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
else forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just State
thread)
{-# INLINABLE tothread #-}
touserdata :: StackIndex -> LuaE e (Maybe (Ptr a))
touserdata :: forall e a. StackIndex -> LuaE e (Maybe (Ptr a))
touserdata StackIndex
n = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l -> do
Ptr a
ptr <- forall a. State -> StackIndex -> IO (Ptr a)
lua_touserdata State
l StackIndex
n
if Ptr a
ptr forall a. Eq a => a -> a -> Bool
== forall a. Ptr a
nullPtr
then forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
else forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just Ptr a
ptr)
{-# INLINABLE touserdata #-}
typename :: Type -> LuaE e ByteString
typename :: forall e. Type -> LuaE e ByteString
typename Type
tp = forall a e. (State -> IO a) -> LuaE e a
liftLua forall a b. (a -> b) -> a -> b
$ \State
l ->
State -> TypeCode -> IO (Ptr CChar)
lua_typename State
l (Type -> TypeCode
fromType Type
tp) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Ptr CChar -> IO ByteString
B.packCString
{-# INLINABLE typename #-}
upvalueindex :: StackIndex -> StackIndex
upvalueindex :: StackIndex -> StackIndex
upvalueindex StackIndex
i = StackIndex
registryindex forall a. Num a => a -> a -> a
- StackIndex
i
{-# INLINABLE upvalueindex #-}