{-# LINE 1 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
----------------------------------------------------------------------------
-- |
-- Module      :  Data.Emacs.Module.Raw.Env
-- Copyright   :  (c) Sergey Vinokurov 2018
-- License     :  Apache-2.0 (see LICENSE)
-- Maintainer  :  serg.foo@gmail.com
--
-- Low-level and, hopefully, low-overhead wrappers around @struct emacs_env@.
----------------------------------------------------------------------------

{-# LANGUAGE FlexibleContexts         #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE ScopedTypeVariables      #-}
{-# LANGUAGE TemplateHaskell          #-}

{-# OPTIONS_HADDOCK not-home #-}

{-# OPTIONS_GHC -Wno-missing-signatures #-}

module Data.Emacs.Module.Raw.Env
  ( EnumFuncallExit(..)
  , UserPtrFinaliserType
  , UserPtrFinaliser
  , CBoolean
  , isTruthy
  , isValidEnv

  , makeGlobalRef
  , freeGlobalRef

  , nonLocalExitCheck
  , nonLocalExitGet
  , nonLocalExitSignal
  , nonLocalExitThrow
  , nonLocalExitClear

  , variadicFunctionArgs
  , makeFunction

  , funcall
  , funcallPrimitive
  , intern
  , typeOf
  , isNotNil
  , eq

  , extractInteger
  , makeInteger
  , extractFloat
  , makeFloat
  , copyStringContents
  , makeString
  , makeUserPtr
  , getUserPtr
  , setUserPtr
  , getUserFinaliser
  , setUserFinaliser
  , vecGet
  , vecSet
  , vecSize
  ) where

import Control.Monad.IO.Class

import Data.Coerce
import Foreign
import Foreign.C

import Data.Emacs.Module.NonNullPtr
import Data.Emacs.Module.Raw.Env.Internal as Env
import Data.Emacs.Module.Raw.Env.TH
import Data.Emacs.Module.Raw.Value

import Data.Emacs.Module.NonNullPtr.Internal



newtype EnumFuncallExit = EnumFuncallExit { EnumFuncallExit -> CInt
unEnumFuncallExit :: CInt }

type UserPtrFinaliserType a = Ptr a -> IO ()
type UserPtrFinaliser a = FunPtr (UserPtrFinaliserType a)

-- | A wrapper around C value that denotes true or false.
newtype CBoolean = CBoolean (Word8)
{-# LINE 85 "src/Data/Emacs/Module/Raw/Env.hsc" #-}

{-# INLINE isTruthy #-}
-- | Check whether a 'CBoolean' denotes true.
isTruthy :: CBoolean -> Bool
isTruthy :: CBoolean -> Bool
isTruthy (CBoolean Word8
a) = Word8
a Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
0


{-# INLINE isValidEnv #-}
-- | Check wheter passed @emacs_env@ structure has expected size so that
-- we will be able to access all of its fields.
isValidEnv :: MonadIO m => Env -> m Bool
isValidEnv :: Env -> m Bool
isValidEnv Env
env = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
  CPtrdiff
realSize <- ((\Ptr Env
hsc_ptr -> Ptr Env -> Int -> IO CPtrdiff
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr Env
hsc_ptr Int
0)) (Env -> Ptr Env
Env.toPtr Env
env)
{-# LINE 98 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
  pure $ expectedSize <= realSize
  where
    expectedSize :: CPtrdiff
    expectedSize :: CPtrdiff
expectedSize = ((CPtrdiff
232))
{-# LINE 102 "src/Data/Emacs/Module/Raw/Env.hsc" #-}

$(wrapEmacsFunc "makeGlobalRefTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 16)) |]
{-# LINE 105 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> IO RawValue |])

{-# INLINE makeGlobalRef #-}
makeGlobalRef
  :: forall m. MonadIO m
  => Env
  -> RawValue
  -> m GlobalRef
makeGlobalRef :: Env -> RawValue -> m GlobalRef
makeGlobalRef Env
env RawValue
x =
  IO GlobalRef -> m GlobalRef
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GlobalRef -> m GlobalRef) -> IO GlobalRef -> m GlobalRef
forall a b. (a -> b) -> a -> b
$
    (Env -> RawValue -> IO RawValue) -> Env -> RawValue -> IO GlobalRef
coerce
      (Env -> RawValue -> IO RawValue
forall (m :: * -> *). MonadIO m => Env -> RawValue -> m RawValue
makeGlobalRefTH
        :: Env
        -> RawValue
        -> IO RawValue)
      Env
env
      RawValue
x


$(wrapEmacsFunc "freeGlobalRefTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 24)) |]
{-# LINE 126 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> IO () |])

{-# INLINE freeGlobalRef #-}
freeGlobalRef
  :: forall m. MonadIO m
  => Env
  -> GlobalRef
  -> m ()
freeGlobalRef :: Env -> GlobalRef -> m ()
freeGlobalRef Env
env GlobalRef
x =
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
  (Env -> RawValue -> IO ()) -> Env -> GlobalRef -> IO ()
coerce
    (Env -> RawValue -> IO ()
forall (m :: * -> *). MonadIO m => Env -> RawValue -> m ()
freeGlobalRefTH :: Env -> RawValue -> IO ())
    Env
env
    GlobalRef
x


$(wrapEmacsFunc "nonLocalExitCheckTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 32)) |]
{-# LINE 144 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> IO EnumFuncallExit |])

{-# INLINE nonLocalExitCheck #-}
nonLocalExitCheck
  :: MonadIO m
  => Env
  -> m EnumFuncallExit
nonLocalExitCheck :: Env -> m EnumFuncallExit
nonLocalExitCheck = Env -> m EnumFuncallExit
forall (m :: * -> *). MonadIO m => Env -> m EnumFuncallExit
nonLocalExitCheckTH


$(wrapEmacsFunc "nonLocalExitGetTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 48)) |]
{-# LINE 156 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> NonNullPtr RawValue -> NonNullPtr RawValue -> IO EnumFuncallExit |])

{-# INLINE nonLocalExitGet #-}
nonLocalExitGet
  :: MonadIO m
  => Env
  -> NonNullPtr RawValue -- ^ Symbol output
  -> NonNullPtr RawValue -- ^ Data output
  -> m EnumFuncallExit
nonLocalExitGet :: Env
-> NonNullPtr RawValue -> NonNullPtr RawValue -> m EnumFuncallExit
nonLocalExitGet = Env
-> NonNullPtr RawValue -> NonNullPtr RawValue -> m EnumFuncallExit
forall (m :: * -> *).
MonadIO m =>
Env
-> NonNullPtr RawValue -> NonNullPtr RawValue -> m EnumFuncallExit
nonLocalExitGetTH


$(wrapEmacsFunc "nonLocalExitSignalTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 56)) |]
{-# LINE 170 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> RawValue -> IO () |])

{-# INLINE nonLocalExitSignal #-}
nonLocalExitSignal
  :: MonadIO m
  => Env
  -> RawValue -- ^ Error symbol
  -> RawValue -- ^ Error data
  -> m ()
nonLocalExitSignal :: Env -> RawValue -> RawValue -> m ()
nonLocalExitSignal = Env -> RawValue -> RawValue -> m ()
forall (m :: * -> *).
MonadIO m =>
Env -> RawValue -> RawValue -> m ()
nonLocalExitSignalTH


$(wrapEmacsFunc "nonLocalExitThrowTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 64)) |]
{-# LINE 184 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> RawValue -> IO () |])

{-# INLINE nonLocalExitThrow #-}
nonLocalExitThrow
  :: MonadIO m
  => Env
  -> RawValue -- ^ Tag, a symbol
  -> RawValue -- ^ Value
  -> m ()
nonLocalExitThrow :: Env -> RawValue -> RawValue -> m ()
nonLocalExitThrow = Env -> RawValue -> RawValue -> m ()
forall (m :: * -> *).
MonadIO m =>
Env -> RawValue -> RawValue -> m ()
nonLocalExitThrowTH


$(wrapEmacsFunc "nonLocalExitClearTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 40)) |]
{-# LINE 198 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> IO () |])

{-# INLINE nonLocalExitClear #-}
nonLocalExitClear
  :: MonadIO m
  => Env
  -> m ()
nonLocalExitClear :: Env -> m ()
nonLocalExitClear = Env -> m ()
forall (m :: * -> *). MonadIO m => Env -> m ()
nonLocalExitClearTH


variadicFunctionArgs :: CPtrdiff
variadicFunctionArgs :: CPtrdiff
variadicFunctionArgs = (-CPtrdiff
2)
{-# LINE 210 "src/Data/Emacs/Module/Raw/Env.hsc" #-}

$(wrapEmacsFunc "makeFunctionTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 72)) |]
{-# LINE 213 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| forall a. Env -> CPtrdiff -> CPtrdiff -> FunPtr (RawFunctionType a) -> CString -> Ptr a -> IO RawValue |])

{-# INLINE makeFunction #-}
makeFunction
  :: forall m a. MonadIO m
  => Env
  -> CPtrdiff      -- ^ Minimum arity
  -> CPtrdiff      -- ^ Maximum arity
  -> RawFunction a -- ^ Implementation
  -> CString       -- ^ Documentation
  -> Ptr a         -- ^ Extra data
  -> m RawValue
makeFunction :: Env
-> CPtrdiff
-> CPtrdiff
-> RawFunction a
-> CString
-> Ptr a
-> m RawValue
makeFunction =
  (Env
 -> CPtrdiff
 -> CPtrdiff
 -> FunPtr (RawFunctionType a)
 -> CString
 -> Ptr a
 -> m RawValue)
-> Env
-> CPtrdiff
-> CPtrdiff
-> RawFunction a
-> CString
-> Ptr a
-> m RawValue
coerce
    (Env
-> CPtrdiff
-> CPtrdiff
-> FunPtr (RawFunctionType a)
-> CString
-> Ptr a
-> m RawValue
forall (m :: * -> *) a.
MonadIO m =>
Env
-> CPtrdiff
-> CPtrdiff
-> FunPtr (RawFunctionType a)
-> CString
-> Ptr a
-> m RawValue
makeFunctionTH ::
         Env
      -> CPtrdiff
      -> CPtrdiff
      -> FunPtr (RawFunctionType a)
      -> CString
      -> Ptr a
      -> m RawValue)


$(wrapEmacsFunc "funcallTH" Safe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 80)) |]
{-# LINE 239 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> CPtrdiff -> NonNullPtr RawValue -> IO RawValue |])

{-# INLINE funcall #-}
funcall
  :: MonadIO m
  => Env
  -> RawValue            -- ^ Function
  -> CPtrdiff            -- ^ Number of arguments
  -> NonNullPtr RawValue -- ^ Actual arguments
  -> m RawValue
funcall :: Env -> RawValue -> CPtrdiff -> NonNullPtr RawValue -> m RawValue
funcall = Env -> RawValue -> CPtrdiff -> NonNullPtr RawValue -> m RawValue
forall (m :: * -> *).
MonadIO m =>
Env -> RawValue -> CPtrdiff -> NonNullPtr RawValue -> m RawValue
funcallTH


$(wrapEmacsFunc "funcallPrimitiveTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 80)) |]
{-# LINE 254 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> CPtrdiff -> NonNullPtr RawValue -> IO RawValue |])

{-# INLINE funcallPrimitive #-}
funcallPrimitive
  :: MonadIO m
  => Env
  -> RawValue            -- ^ Function
  -> CPtrdiff            -- ^ Number of arguments
  -> NonNullPtr RawValue -- ^ Actual arguments
  -> m RawValue
funcallPrimitive :: Env -> RawValue -> CPtrdiff -> NonNullPtr RawValue -> m RawValue
funcallPrimitive = Env -> RawValue -> CPtrdiff -> NonNullPtr RawValue -> m RawValue
forall (m :: * -> *).
MonadIO m =>
Env -> RawValue -> CPtrdiff -> NonNullPtr RawValue -> m RawValue
funcallPrimitiveTH


$(wrapEmacsFunc "internTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 88)) |]
{-# LINE 269 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> CString -> IO RawValue |])

{-# INLINE intern #-}
intern
  :: MonadIO m
  => Env
  -> CString
  -> m RawValue
intern :: Env -> CString -> m RawValue
intern = Env -> CString -> m RawValue
forall (m :: * -> *). MonadIO m => Env -> CString -> m RawValue
internTH


$(wrapEmacsFunc "typeOfTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 96)) |]
{-# LINE 282 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> IO RawValue |])

{-# INLINE typeOf #-}
typeOf
  :: MonadIO m
  => Env
  -> RawValue
  -> m RawValue
typeOf :: Env -> RawValue -> m RawValue
typeOf = Env -> RawValue -> m RawValue
forall (m :: * -> *). MonadIO m => Env -> RawValue -> m RawValue
typeOfTH


$(wrapEmacsFunc "isNotNilTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 104)) |]
{-# LINE 295 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> IO CBoolean |])

{-# INLINE isNotNil #-}
isNotNil
  :: MonadIO m
  => Env
  -> RawValue
  -> m CBoolean
isNotNil :: Env -> RawValue -> m CBoolean
isNotNil = Env -> RawValue -> m CBoolean
forall (m :: * -> *). MonadIO m => Env -> RawValue -> m CBoolean
isNotNilTH


$(wrapEmacsFunc "eqTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 112)) |]
{-# LINE 308 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> RawValue -> IO CBoolean |])

{-# INLINE eq #-}
eq
  :: MonadIO m
  => Env
  -> RawValue
  -> RawValue
  -> m CBoolean
eq :: Env -> RawValue -> RawValue -> m CBoolean
eq = Env -> RawValue -> RawValue -> m CBoolean
forall (m :: * -> *).
MonadIO m =>
Env -> RawValue -> RawValue -> m CBoolean
eqTH


$(wrapEmacsFunc "extractIntegerTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 120)) |]
{-# LINE 322 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> IO CIntMax |])

{-# INLINE extractInteger #-}
extractInteger
  :: MonadIO m
  => Env
  -> RawValue
  -> m CIntMax
extractInteger :: Env -> RawValue -> m CIntMax
extractInteger = Env -> RawValue -> m CIntMax
forall (m :: * -> *). MonadIO m => Env -> RawValue -> m CIntMax
extractIntegerTH


$(wrapEmacsFunc "makeIntegerTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 128)) |]
{-# LINE 335 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> CIntMax -> IO RawValue |])

{-# INLINE makeInteger #-}
makeInteger
  :: MonadIO m
  => Env
  -> CIntMax
  -> m RawValue
makeInteger :: Env -> CIntMax -> m RawValue
makeInteger = Env -> CIntMax -> m RawValue
forall (m :: * -> *). MonadIO m => Env -> CIntMax -> m RawValue
makeIntegerTH


$(wrapEmacsFunc "extractFloatTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 136)) |]
{-# LINE 348 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> IO CDouble |])

{-# INLINE extractFloat #-}
extractFloat
  :: MonadIO m
  => Env
  -> RawValue
  -> m CDouble
extractFloat :: Env -> RawValue -> m CDouble
extractFloat = Env -> RawValue -> m CDouble
forall (m :: * -> *). MonadIO m => Env -> RawValue -> m CDouble
extractFloatTH


$(wrapEmacsFunc "makeFloatTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 144)) |]
{-# LINE 361 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> CDouble -> IO RawValue |])

{-# INLINE makeFloat #-}
makeFloat
  :: MonadIO m
  => Env
  -> CDouble
  -> m RawValue
makeFloat :: Env -> CDouble -> m RawValue
makeFloat = Env -> CDouble -> m RawValue
forall (m :: * -> *). MonadIO m => Env -> CDouble -> m RawValue
makeFloatTH


$(wrapEmacsFunc "copyStringContentsTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 152)) |]
{-# LINE 374 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> CString -> NonNullPtr CPtrdiff -> IO CBoolean |])

{-# INLINE copyStringContents #-}
-- |  Copy the content of the Lisp string VALUE to BUFFER as an utf8
-- null-terminated string.
--
-- SIZE must point to the total size of the buffer.  If BUFFER is
-- NULL or if SIZE is not big enough, write the required buffer size
-- to SIZE and return true.
--
-- Note that SIZE must include the last null byte (e.g. "abc" needs
-- a buffer of size 4).
--
-- Return true if the string was successfully copied.
copyStringContents
  :: MonadIO m
  => Env
  -> RawValue         -- ^ Emacs value that holds a string
  -> CString             -- ^ Destination, may be NULL
  -> NonNullPtr CPtrdiff -- ^ SIZE pointer
  -> m CBoolean
copyStringContents :: Env -> RawValue -> CString -> NonNullPtr CPtrdiff -> m CBoolean
copyStringContents = Env -> RawValue -> CString -> NonNullPtr CPtrdiff -> m CBoolean
forall (m :: * -> *).
MonadIO m =>
Env -> RawValue -> CString -> NonNullPtr CPtrdiff -> m CBoolean
copyStringContentsTH


$(wrapEmacsFunc "makeStringTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 160)) |]
{-# LINE 400 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> CString -> CPtrdiff -> IO RawValue |])

{-# INLINE makeString #-}
makeString
  :: MonadIO m
  => Env
  -> CString  -- ^ 0-terminated utf8-encoded string.
  -> CPtrdiff -- ^ Length.
  -> m RawValue
makeString :: Env -> CString -> CPtrdiff -> m RawValue
makeString = Env -> CString -> CPtrdiff -> m RawValue
forall (m :: * -> *).
MonadIO m =>
Env -> CString -> CPtrdiff -> m RawValue
makeStringTH


$(wrapEmacsFunc "makeUserPtrTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 168)) |]
{-# LINE 414 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| forall a. Env -> UserPtrFinaliser a -> Ptr a -> IO RawValue |])

{-# INLINE makeUserPtr #-}
makeUserPtr
  :: forall m a. MonadIO m
  => Env
  -> UserPtrFinaliser a
  -> Ptr a
  -> m RawValue
makeUserPtr :: Env -> UserPtrFinaliser a -> Ptr a -> m RawValue
makeUserPtr = Env -> UserPtrFinaliser a -> Ptr a -> m RawValue
forall (m :: * -> *) a.
MonadIO m =>
Env -> UserPtrFinaliser a -> Ptr a -> m RawValue
makeUserPtrTH


$(wrapEmacsFunc "getUserPtrTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 176)) |]
{-# LINE 428 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| forall a. Env -> RawValue -> IO (Ptr a) |])

{-# INLINE getUserPtr #-}
getUserPtr
  :: MonadIO m
  => Env
  -> RawValue
  -> m (Ptr a)
getUserPtr :: Env -> RawValue -> m (Ptr a)
getUserPtr = Env -> RawValue -> m (Ptr a)
forall (m :: * -> *) a. MonadIO m => Env -> RawValue -> m (Ptr a)
getUserPtrTH


$(wrapEmacsFunc "setUserPtrTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 184)) |]
{-# LINE 441 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| forall a. Env -> RawValue -> Ptr a -> IO () |])

{-# INLINE setUserPtr #-}
setUserPtr
  :: MonadIO m
  => Env
  -> RawValue
  -> Ptr a
  -> m ()
setUserPtr :: Env -> RawValue -> Ptr a -> m ()
setUserPtr = Env -> RawValue -> Ptr a -> m ()
forall (m :: * -> *) a.
MonadIO m =>
Env -> RawValue -> Ptr a -> m ()
setUserPtrTH


$(wrapEmacsFunc "getUserFinaliserTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 192)) |]
{-# LINE 455 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| forall a. Env -> RawValue -> IO (UserPtrFinaliser a) |])

{-# INLINE getUserFinaliser #-}
getUserFinaliser
  :: MonadIO m
  => Env
  -> RawValue
  -> m (UserPtrFinaliser a)
getUserFinaliser :: Env -> RawValue -> m (UserPtrFinaliser a)
getUserFinaliser = Env -> RawValue -> m (UserPtrFinaliser a)
forall (m :: * -> *) a.
MonadIO m =>
Env -> RawValue -> m (UserPtrFinaliser a)
getUserFinaliserTH


$(wrapEmacsFunc "setUserFinaliserTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 200)) |]
{-# LINE 468 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| forall a. Env -> RawValue -> UserPtrFinaliser a -> IO () |])

{-# INLINE setUserFinaliser #-}
setUserFinaliser
  :: MonadIO m
  => Env
  -> RawValue
  -> UserPtrFinaliser a
  -> m ()
setUserFinaliser :: Env -> RawValue -> UserPtrFinaliser a -> m ()
setUserFinaliser = Env -> RawValue -> UserPtrFinaliser a -> m ()
forall (m :: * -> *) a.
MonadIO m =>
Env -> RawValue -> UserPtrFinaliser a -> m ()
setUserFinaliserTH


$(wrapEmacsFunc "vecGetTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 208)) |]
{-# LINE 482 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> CPtrdiff -> IO RawValue |])

{-# INLINE vecGet #-}
vecGet
  :: MonadIO m
  => Env
  -> RawValue
  -> CPtrdiff
  -> m RawValue
vecGet :: Env -> RawValue -> CPtrdiff -> m RawValue
vecGet = Env -> RawValue -> CPtrdiff -> m RawValue
forall (m :: * -> *).
MonadIO m =>
Env -> RawValue -> CPtrdiff -> m RawValue
vecGetTH


$(wrapEmacsFunc "vecSetTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 216)) |]
{-# LINE 496 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> CPtrdiff -> RawValue -> IO () |])

{-# INLINE vecSet #-}
vecSet
  :: MonadIO m
  => Env
  -> RawValue
  -> CPtrdiff
  -> RawValue
  -> m ()
vecSet :: Env -> RawValue -> CPtrdiff -> RawValue -> m ()
vecSet = Env -> RawValue -> CPtrdiff -> RawValue -> m ()
forall (m :: * -> *).
MonadIO m =>
Env -> RawValue -> CPtrdiff -> RawValue -> m ()
vecSetTH


$(wrapEmacsFunc "vecSizeTH" Unsafe
   [e| ((\hsc_ptr -> peekByteOff hsc_ptr 224)) |]
{-# LINE 511 "src/Data/Emacs/Module/Raw/Env.hsc" #-}
   [t| Env -> RawValue -> IO CPtrdiff |])

{-# INLINE vecSize #-}
vecSize
  :: MonadIO m
  => Env
  -> RawValue
  -> m CPtrdiff
vecSize :: Env -> RawValue -> m CPtrdiff
vecSize = Env -> RawValue -> m CPtrdiff
forall (m :: * -> *). MonadIO m => Env -> RawValue -> m CPtrdiff
vecSizeTH