{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.Thread
(
Thread(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveThreadMethod ,
#endif
threadErrorQuark ,
threadExit ,
#if defined(ENABLE_OVERLOADING)
ThreadJoinMethodInfo ,
#endif
threadJoin ,
threadNew ,
#if defined(ENABLE_OVERLOADING)
ThreadRefMethodInfo ,
#endif
threadRef ,
threadSelf ,
threadTryNew ,
#if defined(ENABLE_OVERLOADING)
ThreadUnrefMethodInfo ,
#endif
threadUnref ,
threadYield ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GLib.Callbacks as GLib.Callbacks
newtype Thread = Thread (SP.ManagedPtr Thread)
deriving (Thread -> Thread -> Bool
(Thread -> Thread -> Bool)
-> (Thread -> Thread -> Bool) -> Eq Thread
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Thread -> Thread -> Bool
== :: Thread -> Thread -> Bool
$c/= :: Thread -> Thread -> Bool
/= :: Thread -> Thread -> Bool
Eq)
instance SP.ManagedPtrNewtype Thread where
toManagedPtr :: Thread -> ManagedPtr Thread
toManagedPtr (Thread ManagedPtr Thread
p) = ManagedPtr Thread
p
foreign import ccall "g_thread_get_type" c_g_thread_get_type ::
IO GType
type instance O.ParentTypes Thread = '[]
instance O.HasParentTypes Thread
instance B.Types.TypedObject Thread where
glibType :: IO GType
glibType = IO GType
c_g_thread_get_type
instance B.Types.GBoxed Thread
instance B.GValue.IsGValue (Maybe Thread) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_thread_get_type
gvalueSet_ :: Ptr GValue -> Maybe Thread -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Thread
P.Nothing = Ptr GValue -> Ptr Thread -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Thread
forall a. Ptr a
FP.nullPtr :: FP.Ptr Thread)
gvalueSet_ Ptr GValue
gv (P.Just Thread
obj) = Thread -> (Ptr Thread -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Thread
obj (Ptr GValue -> Ptr Thread -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Thread)
gvalueGet_ Ptr GValue
gv = do
Ptr Thread
ptr <- Ptr GValue -> IO (Ptr Thread)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Thread)
if Ptr Thread
ptr Ptr Thread -> Ptr Thread -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Thread
forall a. Ptr a
FP.nullPtr
then Thread -> Maybe Thread
forall a. a -> Maybe a
P.Just (Thread -> Maybe Thread) -> IO Thread -> IO (Maybe Thread)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Thread -> Thread) -> Ptr Thread -> IO Thread
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Thread -> Thread
Thread Ptr Thread
ptr
else Maybe Thread -> IO (Maybe Thread)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Thread
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Thread
type instance O.AttributeList Thread = ThreadAttributeList
type ThreadAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_thread_new" g_thread_new ::
CString ->
FunPtr GLib.Callbacks.C_ThreadFunc ->
Ptr () ->
IO (Ptr Thread)
threadNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> GLib.Callbacks.ThreadFunc
-> m Thread
threadNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> ThreadFunc -> m Thread
threadNew Maybe Text
name ThreadFunc
func = IO Thread -> m Thread
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Thread -> m Thread) -> IO Thread -> m Thread
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jName -> do
Ptr CChar
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jName'
Ptr (FunPtr ThreadFunc)
ptrfunc <- IO (Ptr (FunPtr ThreadFunc))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_ThreadFunc))
FunPtr ThreadFunc
func' <- ThreadFunc -> IO (FunPtr ThreadFunc)
GLib.Callbacks.mk_ThreadFunc (Maybe (Ptr (FunPtr ThreadFunc)) -> ThreadFunc -> ThreadFunc
GLib.Callbacks.wrap_ThreadFunc (Ptr (FunPtr ThreadFunc) -> Maybe (Ptr (FunPtr ThreadFunc))
forall a. a -> Maybe a
Just Ptr (FunPtr ThreadFunc)
ptrfunc) ThreadFunc
func)
Ptr (FunPtr ThreadFunc) -> FunPtr ThreadFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr ThreadFunc)
ptrfunc FunPtr ThreadFunc
func'
let data_ :: Ptr a
data_ = Ptr a
forall a. Ptr a
nullPtr
Ptr Thread
result <- Ptr CChar -> FunPtr ThreadFunc -> Ptr () -> IO (Ptr Thread)
g_thread_new Ptr CChar
maybeName FunPtr ThreadFunc
func' Ptr ()
forall a. Ptr a
data_
Text -> Ptr Thread -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"threadNew" Ptr Thread
result
Thread
result' <- ((ManagedPtr Thread -> Thread) -> Ptr Thread -> IO Thread
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Thread -> Thread
Thread) Ptr Thread
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
Thread -> IO Thread
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Thread
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_thread_try_new" g_thread_try_new ::
CString ->
FunPtr GLib.Callbacks.C_ThreadFunc ->
Ptr () ->
Ptr (Ptr GError) ->
IO (Ptr Thread)
threadTryNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> GLib.Callbacks.ThreadFunc
-> m Thread
threadTryNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> ThreadFunc -> m Thread
threadTryNew Maybe Text
name ThreadFunc
func = IO Thread -> m Thread
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Thread -> m Thread) -> IO Thread -> m Thread
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jName -> do
Ptr CChar
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jName'
Ptr (FunPtr ThreadFunc)
ptrfunc <- IO (Ptr (FunPtr ThreadFunc))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_ThreadFunc))
FunPtr ThreadFunc
func' <- ThreadFunc -> IO (FunPtr ThreadFunc)
GLib.Callbacks.mk_ThreadFunc (Maybe (Ptr (FunPtr ThreadFunc)) -> ThreadFunc -> ThreadFunc
GLib.Callbacks.wrap_ThreadFunc (Ptr (FunPtr ThreadFunc) -> Maybe (Ptr (FunPtr ThreadFunc))
forall a. a -> Maybe a
Just Ptr (FunPtr ThreadFunc)
ptrfunc) ThreadFunc
func)
Ptr (FunPtr ThreadFunc) -> FunPtr ThreadFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr ThreadFunc)
ptrfunc FunPtr ThreadFunc
func'
let data_ :: Ptr a
data_ = Ptr a
forall a. Ptr a
nullPtr
IO Thread -> IO () -> IO Thread
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Thread
result <- (Ptr (Ptr GError) -> IO (Ptr Thread)) -> IO (Ptr Thread)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Thread)) -> IO (Ptr Thread))
-> (Ptr (Ptr GError) -> IO (Ptr Thread)) -> IO (Ptr Thread)
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> FunPtr ThreadFunc
-> Ptr ()
-> Ptr (Ptr GError)
-> IO (Ptr Thread)
g_thread_try_new Ptr CChar
maybeName FunPtr ThreadFunc
func' Ptr ()
forall a. Ptr a
data_
Text -> Ptr Thread -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"threadTryNew" Ptr Thread
result
Thread
result' <- ((ManagedPtr Thread -> Thread) -> Ptr Thread -> IO Thread
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Thread -> Thread
Thread) Ptr Thread
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
Thread -> IO Thread
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Thread
result'
) (do
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_thread_join" g_thread_join ::
Ptr Thread ->
IO (Ptr ())
threadJoin ::
(B.CallStack.HasCallStack, MonadIO m) =>
Thread
-> m (Ptr ())
threadJoin :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Thread -> m (Ptr ())
threadJoin Thread
thread = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr Thread
thread' <- Thread -> IO (Ptr Thread)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Thread
thread
Ptr ()
result <- Ptr Thread -> IO (Ptr ())
g_thread_join Ptr Thread
thread'
Thread -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Thread
thread
ThreadFunc
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data ThreadJoinMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod ThreadJoinMethodInfo Thread signature where
overloadedMethod = threadJoin
instance O.OverloadedMethodInfo ThreadJoinMethodInfo Thread where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Thread.threadJoin",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.29/docs/GI-GLib-Structs-Thread.html#v:threadJoin"
})
#endif
foreign import ccall "g_thread_ref" g_thread_ref ::
Ptr Thread ->
IO (Ptr Thread)
threadRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
Thread
-> m Thread
threadRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Thread -> m Thread
threadRef Thread
thread = IO Thread -> m Thread
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Thread -> m Thread) -> IO Thread -> m Thread
forall a b. (a -> b) -> a -> b
$ do
Ptr Thread
thread' <- Thread -> IO (Ptr Thread)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Thread
thread
Ptr Thread
result <- Ptr Thread -> IO (Ptr Thread)
g_thread_ref Ptr Thread
thread'
Text -> Ptr Thread -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"threadRef" Ptr Thread
result
Thread
result' <- ((ManagedPtr Thread -> Thread) -> Ptr Thread -> IO Thread
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Thread -> Thread
Thread) Ptr Thread
result
Thread -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Thread
thread
Thread -> IO Thread
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Thread
result'
#if defined(ENABLE_OVERLOADING)
data ThreadRefMethodInfo
instance (signature ~ (m Thread), MonadIO m) => O.OverloadedMethod ThreadRefMethodInfo Thread signature where
overloadedMethod = threadRef
instance O.OverloadedMethodInfo ThreadRefMethodInfo Thread where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Thread.threadRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.29/docs/GI-GLib-Structs-Thread.html#v:threadRef"
})
#endif
foreign import ccall "g_thread_unref" g_thread_unref ::
Ptr Thread ->
IO ()
threadUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
Thread
-> m ()
threadUnref :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Thread -> m ()
threadUnref Thread
thread = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Thread
thread' <- Thread -> IO (Ptr Thread)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Thread
thread
Ptr Thread -> IO ()
g_thread_unref Ptr Thread
thread'
Thread -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Thread
thread
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ThreadUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ThreadUnrefMethodInfo Thread signature where
overloadedMethod = threadUnref
instance O.OverloadedMethodInfo ThreadUnrefMethodInfo Thread where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GLib.Structs.Thread.threadUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-glib-2.0.29/docs/GI-GLib-Structs-Thread.html#v:threadUnref"
})
#endif
foreign import ccall "g_thread_error_quark" g_thread_error_quark ::
IO Word32
threadErrorQuark ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
threadErrorQuark :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
threadErrorQuark = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
g_thread_error_quark
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_thread_exit" g_thread_exit ::
Ptr () ->
IO ()
threadExit ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> m ()
threadExit :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Ptr () -> m ()
threadExit Ptr ()
retval = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr () -> IO ()
g_thread_exit Ptr ()
retval
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_thread_self" g_thread_self ::
IO (Ptr Thread)
threadSelf ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Thread
threadSelf :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Thread
threadSelf = IO Thread -> m Thread
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Thread -> m Thread) -> IO Thread -> m Thread
forall a b. (a -> b) -> a -> b
$ do
Ptr Thread
result <- IO (Ptr Thread)
g_thread_self
Text -> Ptr Thread -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"threadSelf" Ptr Thread
result
Thread
result' <- ((ManagedPtr Thread -> Thread) -> Ptr Thread -> IO Thread
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Thread -> Thread
Thread) Ptr Thread
result
Thread -> IO Thread
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Thread
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_thread_yield" g_thread_yield ::
IO ()
threadYield ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ()
threadYield :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ()
threadYield = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
IO ()
g_thread_yield
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveThreadMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveThreadMethod "join" o = ThreadJoinMethodInfo
ResolveThreadMethod "ref" o = ThreadRefMethodInfo
ResolveThreadMethod "unref" o = ThreadUnrefMethodInfo
ResolveThreadMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveThreadMethod t Thread, O.OverloadedMethod info Thread p) => OL.IsLabel t (Thread -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveThreadMethod t Thread, O.OverloadedMethod info Thread p, R.HasField t Thread p) => R.HasField t Thread p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveThreadMethod t Thread, O.OverloadedMethodInfo info Thread) => OL.IsLabel t (O.MethodProxy info Thread) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif