Copyright	(c) Sergey Vinokurov 2018
License	BSD3-style (see LICENSE)
Maintainer	serg.foo@gmail.com
Safe Haskell	None
Language	Haskell2010

Data.Emacs.Module.Env

Contents

enum emacs_funcall_exit
Wrappers around struct emacs_env fields
Expose functions to Emacs
Expose Haskell data to Emacs

Description

Synopsis

data Env
data FuncallExit a
- = FuncallExitReturn
- | FuncallExitSignal a
- | FuncallExitThrow a
funcallExitToNum :: Num a => FuncallExit b -> a
funcallExitFromNum :: (Eq a, Num a) => a -> Maybe (FuncallExit ())
newtype EnumFuncallExit = EnumFuncallExit {
- unEnumFuncallExit :: CInt
}
type UserPtrFinaliserType a = Ptr a -> IO ()
type UserPtrFinaliser a = FunPtr (UserPtrFinaliserType a)
isValidEnv :: MonadIO m => Env -> m Bool
makeGlobalRef :: forall m. MonadIO m => Env -> RawValue -> m GlobalRef
freeGlobalRef :: forall m. MonadIO m => Env -> GlobalRef -> m ()
nonLocalExitCheck :: MonadIO m => Env -> m EnumFuncallExit
nonLocalExitGet :: MonadIO m => Env -> NonNullPtr RawValue -> NonNullPtr RawValue -> m EnumFuncallExit
nonLocalExitSignal :: MonadIO m => Env -> RawValue -> RawValue -> m ()
nonLocalExitThrow :: MonadIO m => Env -> RawValue -> RawValue -> m ()
nonLocalExitClear :: MonadIO m => Env -> m ()
variadicFunctionArgs :: CPtrdiff
makeFunction :: forall m a. MonadIO m => Env -> CPtrdiff -> CPtrdiff -> RawFunction a -> CString -> Ptr a -> m RawValue
funcall :: MonadIO m => Env -> RawValue -> CPtrdiff -> NonNullPtr RawValue -> m RawValue
funcallPrimitive :: MonadIO m => Env -> RawValue -> CPtrdiff -> NonNullPtr RawValue -> m RawValue
intern :: MonadIO m => Env -> CString -> m RawValue
typeOf :: MonadIO m => Env -> RawValue -> m RawValue
isNotNil :: MonadIO m => Env -> RawValue -> m CBoolean
eq :: MonadIO m => Env -> RawValue -> RawValue -> m CBoolean
extractInteger :: MonadIO m => Env -> RawValue -> m CIntMax
makeInteger :: MonadIO m => Env -> CIntMax -> m RawValue
extractFloat :: MonadIO m => Env -> RawValue -> m CDouble
makeFloat :: MonadIO m => Env -> CDouble -> m RawValue
copyStringContents :: MonadIO m => Env -> RawValue -> CString -> NonNullPtr CPtrdiff -> m CBoolean
makeString :: MonadIO m => Env -> CString -> CPtrdiff -> m RawValue
makeUserPtr :: forall m a. MonadIO m => Env -> UserPtrFinaliser a -> Ptr a -> m RawValue
getUserPtr :: MonadIO m => Env -> RawValue -> m (Ptr a)
setUserPtr :: MonadIO m => Env -> RawValue -> Ptr a -> m ()
getUserFinaliser :: MonadIO m => Env -> RawValue -> m (UserPtrFinaliser a)
setUserFinaliser :: MonadIO m => Env -> RawValue -> UserPtrFinaliser a -> m ()
vecGet :: MonadIO m => Env -> RawValue -> CPtrdiff -> m RawValue
vecSet :: MonadIO m => Env -> RawValue -> CPtrdiff -> RawValue -> m ()
vecSize :: MonadIO m => Env -> RawValue -> m CPtrdiff
exportToEmacs :: RawFunctionType a -> IO (RawFunction a)
type RawFunctionType a = Env -> CPtrdiff -> Ptr RawValue -> Ptr a -> IO RawValue
data RawFunction a
freeStablePtrFinaliser :: UserPtrFinaliser a

Documentation

data Env #

Emacs environment, right from the 'emacs-module.h'.

enum emacs_funcall_exit

data FuncallExit a #

Possible Emacs function call outcomes. This is Haskell's version of

Constructors

FuncallExitReturn	Function has returned normally.
FuncallExitSignal a	Function has signaled an error using `signal`.
FuncallExitThrow a	Function has exit using `throw`.

Instances

Functor FuncallExit #
Instance details Defined in Data.Emacs.Module.Env.Functions Methods fmap :: (a -> b) -> FuncallExit a -> FuncallExit b # (<$) :: a -> FuncallExit b -> FuncallExit a #
Foldable FuncallExit #
Instance details Defined in Data.Emacs.Module.Env.Functions Methods fold :: Monoid m => FuncallExit m -> m # foldMap :: Monoid m => (a -> m) -> FuncallExit a -> m # foldr :: (a -> b -> b) -> b -> FuncallExit a -> b # foldr' :: (a -> b -> b) -> b -> FuncallExit a -> b # foldl :: (b -> a -> b) -> b -> FuncallExit a -> b # foldl' :: (b -> a -> b) -> b -> FuncallExit a -> b # foldr1 :: (a -> a -> a) -> FuncallExit a -> a # foldl1 :: (a -> a -> a) -> FuncallExit a -> a # toList :: FuncallExit a -> [a] # null :: FuncallExit a -> Bool # length :: FuncallExit a -> Int # elem :: Eq a => a -> FuncallExit a -> Bool # maximum :: Ord a => FuncallExit a -> a # minimum :: Ord a => FuncallExit a -> a # sum :: Num a => FuncallExit a -> a # product :: Num a => FuncallExit a -> a #
Traversable FuncallExit #
Instance details Defined in Data.Emacs.Module.Env.Functions Methods traverse :: Applicative f => (a -> f b) -> FuncallExit a -> f (FuncallExit b) # sequenceA :: Applicative f => FuncallExit (f a) -> f (FuncallExit a) # mapM :: Monad m => (a -> m b) -> FuncallExit a -> m (FuncallExit b) # sequence :: Monad m => FuncallExit (m a) -> m (FuncallExit a) #
Eq a => Eq (FuncallExit a) #
Instance details Defined in Data.Emacs.Module.Env.Functions Methods (==) :: FuncallExit a -> FuncallExit a -> Bool # (/=) :: FuncallExit a -> FuncallExit a -> Bool #
Data a => Data (FuncallExit a) #
Instance details Defined in Data.Emacs.Module.Env.Functions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FuncallExit a -> c (FuncallExit a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FuncallExit a) # toConstr :: FuncallExit a -> Constr # dataTypeOf :: FuncallExit a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FuncallExit a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FuncallExit a)) # gmapT :: (forall b. Data b => b -> b) -> FuncallExit a -> FuncallExit a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FuncallExit a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FuncallExit a -> r # gmapQ :: (forall d. Data d => d -> u) -> FuncallExit a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FuncallExit a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FuncallExit a -> m (FuncallExit a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncallExit a -> m (FuncallExit a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FuncallExit a -> m (FuncallExit a) #
Ord a => Ord (FuncallExit a) #
Instance details Defined in Data.Emacs.Module.Env.Functions Methods compare :: FuncallExit a -> FuncallExit a -> Ordering # (<) :: FuncallExit a -> FuncallExit a -> Bool # (<=) :: FuncallExit a -> FuncallExit a -> Bool # (>) :: FuncallExit a -> FuncallExit a -> Bool # (>=) :: FuncallExit a -> FuncallExit a -> Bool # max :: FuncallExit a -> FuncallExit a -> FuncallExit a # min :: FuncallExit a -> FuncallExit a -> FuncallExit a #
Show a => Show (FuncallExit a) #
Instance details Defined in Data.Emacs.Module.Env.Functions Methods showsPrec :: Int -> FuncallExit a -> ShowS # show :: FuncallExit a -> String # showList :: [FuncallExit a] -> ShowS #
Generic (FuncallExit a) #
Instance details Defined in Data.Emacs.Module.Env.Functions Associated Types type Rep (FuncallExit a) :: Type -> Type # Methods from :: FuncallExit a -> Rep (FuncallExit a) x # to :: Rep (FuncallExit a) x -> FuncallExit a #
Lift a => Lift (FuncallExit a) #
Instance details Defined in Data.Emacs.Module.Env.Functions Methods lift :: FuncallExit a -> Q Exp #
type Rep (FuncallExit a) #
Instance details Defined in Data.Emacs.Module.Env.Functions type Rep (FuncallExit a) = D1 (MetaData "FuncallExit" "Data.Emacs.Module.Env.Functions" "emacs-module-0.1.1-30FqcpCeiGh7ar9FTVkeSy" False) (C1 (MetaCons "FuncallExitReturn" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "FuncallExitSignal" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) :+: C1 (MetaCons "FuncallExitThrow" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))))

funcallExitToNum :: Num a => FuncallExit b -> a #

funcallExitFromNum :: (Eq a, Num a) => a -> Maybe (FuncallExit ()) #

Wrappers around struct emacs_env fields

newtype EnumFuncallExit #

Constructors

EnumFuncallExit
Fields unEnumFuncallExit :: CInt

type UserPtrFinaliserType a = Ptr a -> IO () #

type UserPtrFinaliser a = FunPtr (UserPtrFinaliserType a) #

isValidEnv :: MonadIO m => Env -> m Bool #

Check wheter passed emacs_env structure has expected size so that we will be able to access all of its fields.

makeGlobalRef :: forall m. MonadIO m => Env -> RawValue -> m GlobalRef #

freeGlobalRef :: forall m. MonadIO m => Env -> GlobalRef -> m () #

nonLocalExitCheck :: MonadIO m => Env -> m EnumFuncallExit #

nonLocalExitGet #

Arguments

:: MonadIO m
=> Env
-> NonNullPtr RawValue	Symbol output
-> NonNullPtr RawValue	Data output
-> m EnumFuncallExit

nonLocalExitSignal #

Arguments

:: MonadIO m
=> Env
-> RawValue	Error symbol
-> RawValue	Error data
-> m ()

nonLocalExitThrow #

Arguments

:: MonadIO m
=> Env
-> RawValue	Tag, a symbol
-> RawValue	Value
-> m ()

nonLocalExitClear :: MonadIO m => Env -> m () #

variadicFunctionArgs :: CPtrdiff #

makeFunction #

Arguments

:: MonadIO m
=> Env
-> CPtrdiff	Minimum arity
-> CPtrdiff	Maximum arity
-> RawFunction a	Implementation
-> CString	Documentation
-> Ptr a	Extra data
-> m RawValue

funcall #

Arguments

:: MonadIO m
=> Env
-> RawValue	Function
-> CPtrdiff	Number of arguments
-> NonNullPtr RawValue	Actual arguments
-> m RawValue

funcallPrimitive #

Arguments

:: MonadIO m
=> Env
-> RawValue	Function
-> CPtrdiff	Number of arguments
-> NonNullPtr RawValue	Actual arguments
-> m RawValue

intern :: MonadIO m => Env -> CString -> m RawValue #

typeOf :: MonadIO m => Env -> RawValue -> m RawValue #

isNotNil :: MonadIO m => Env -> RawValue -> m CBoolean #

eq :: MonadIO m => Env -> RawValue -> RawValue -> m CBoolean #

extractInteger :: MonadIO m => Env -> RawValue -> m CIntMax #

makeInteger :: MonadIO m => Env -> CIntMax -> m RawValue #

extractFloat :: MonadIO m => Env -> RawValue -> m CDouble #

makeFloat :: MonadIO m => Env -> CDouble -> m RawValue #

copyStringContents #

Arguments

:: MonadIO m
=> Env
-> RawValue	Emacs value that holds a string
-> CString	Destination, may be NULL
-> NonNullPtr CPtrdiff	SIZE pointer
-> m CBoolean

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.

makeString #

Arguments

:: MonadIO m
=> Env
-> CString	0-terminated utf8-encoded string.
-> CPtrdiff	Length.
-> m RawValue

makeUserPtr :: forall m a. MonadIO m => Env -> UserPtrFinaliser a -> Ptr a -> m RawValue #

getUserPtr :: MonadIO m => Env -> RawValue -> m (Ptr a) #

setUserPtr :: MonadIO m => Env -> RawValue -> Ptr a -> m () #

getUserFinaliser :: MonadIO m => Env -> RawValue -> m (UserPtrFinaliser a) #

setUserFinaliser :: MonadIO m => Env -> RawValue -> UserPtrFinaliser a -> m () #

vecGet :: MonadIO m => Env -> RawValue -> CPtrdiff -> m RawValue #

vecSet :: MonadIO m => Env -> RawValue -> CPtrdiff -> RawValue -> m () #

vecSize :: MonadIO m => Env -> RawValue -> m CPtrdiff #

Expose functions to Emacs

exportToEmacs :: RawFunctionType a -> IO (RawFunction a) #

type RawFunctionType a = Env -> CPtrdiff -> Ptr RawValue -> Ptr a -> IO RawValue #

data RawFunction a #

Expose Haskell data to Emacs

freeStablePtrFinaliser :: UserPtrFinaliser a #

Pass to makeUserPtr so that Emacs will free the Haskell's stable pointer when the corresponding elisp value goes out of scope.