Copyright | (c) The FFI task force 2001 |
---|---|
License | BSD-style (see the file libraries/base/LICENSE) |
Maintainer | [email protected] |
Stability | provisional |
Portability | portable |
Safe Haskell | Trustworthy |
Language | Haskell2010 |
This module provides typed pointers to foreign data. It is part of the Foreign Function Interface (FFI) and will normally be imported via the Foreign module.
A value of type Ptr a
represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a
.
The type a
will often be an instance of class Storable
which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a C struct
.
Generic1 (URec (Ptr ()) :: k -> Type) | Since: base-4.9.0.0 |
Eq (Ptr a) | Since: base-2.1 |
Data a => Data (Ptr a) | Since: base-4.8.0.0 |
Defined in Data.Data Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a) Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) Source toConstr :: Ptr a -> Constr Source dataTypeOf :: Ptr a -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) Source gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source | |
Ord (Ptr a) | Since: base-2.1 |
Show (Ptr a) | Since: base-2.1 |
Storable (Ptr a) | Since: base-2.1 |
Defined in Foreign.Storable | |
Functor (URec (Ptr ()) :: Type -> Type) | Since: base-4.9.0.0 |
Foldable (URec (Ptr ()) :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Foldable Methodsfold :: Monoid m => URec (Ptr ()) m -> m Source foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m Source foldMap' :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m Source foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b Source foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b Source foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b Source foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b Source foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a Source foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a Source toList :: URec (Ptr ()) a -> [a] Source null :: URec (Ptr ()) a -> Bool Source length :: URec (Ptr ()) a -> Int Source elem :: Eq a => a -> URec (Ptr ()) a -> Bool Source maximum :: Ord a => URec (Ptr ()) a -> a Source minimum :: Ord a => URec (Ptr ()) a -> a Source | |
Traversable (URec (Ptr ()) :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Traversable Methodstraverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b) Source sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a) Source mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b) Source sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a) Source | |
Eq (URec (Ptr ()) p) | Since: base-4.9.0.0 |
Ord (URec (Ptr ()) p) | Since: base-4.9.0.0 |
Defined in GHC.Generics Methodscompare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering Source (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source | |
Generic (URec (Ptr ()) p) | Since: base-4.9.0.0 |
data URec (Ptr ()) (p :: k) |
Used for marking occurrences of Since: base-4.9.0.0 |
type Rep1 (URec (Ptr ()) :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec (Ptr ()) p) | |
Defined in GHC.Generics |
The constant nullPtr
contains a distinguished value of Ptr
that is not associated with a valid memory location.
castPtr :: Ptr a -> Ptr b Source
The castPtr
function casts a pointer from one type to another.
plusPtr :: Ptr a -> Int -> Ptr b Source
Advances the given address by the given offset in bytes.
alignPtr :: Ptr a -> Int -> Ptr a Source
Given an arbitrary address and an alignment constraint, alignPtr
yields the next higher address that fulfills the alignment constraint. An alignment constraint x
is fulfilled by any address divisible by x
. This operation is idempotent.
minusPtr :: Ptr a -> Ptr b -> Int Source
Computes the offset required to get from the second to the first argument. We have
p2 == p1 `plusPtr` (p2 `minusPtr` p1)
A value of type FunPtr a
is a pointer to a function callable from foreign code. The type a
will normally be a foreign type, a function type with zero or more arguments where
Char
, Int
, Double
, Float
, Bool
, Int8
, Int16
, Int32
, Int64
, Word8
, Word16
, Word32
, Word64
, Ptr a
, FunPtr a
, StablePtr a
or a renaming of any of these using newtype
.IO t
where t
is a marshallable foreign type or ()
.A value of type FunPtr a
may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like
foreign import ccall "stdlib.h &free" p_free :: FunPtr (Ptr a -> IO ())
or a pointer to a Haskell function created using a wrapper stub declared to produce a FunPtr
of the correct type. For example:
type Compare = Int -> Int -> Bool foreign import ccall "wrapper" mkCompare :: Compare -> IO (FunPtr Compare)
Calls to wrapper stubs like mkCompare
allocate storage, which should be released with freeHaskellFunPtr
when no longer required.
To convert FunPtr
values to corresponding Haskell functions, one can define a dynamic stub for the specific foreign type, e.g.
type IntFunction = CInt -> IO () foreign import ccall "dynamic" mkFun :: FunPtr IntFunction -> IntFunction
Eq (FunPtr a) | |
Ord (FunPtr a) | |
Show (FunPtr a) | Since: base-2.1 |
Storable (FunPtr a) | Since: base-2.1 |
Defined in Foreign.Storable MethodssizeOf :: FunPtr a -> Int Source alignment :: FunPtr a -> Int Source peekElemOff :: Ptr (FunPtr a) -> Int -> IO (FunPtr a) Source pokeElemOff :: Ptr (FunPtr a) -> Int -> FunPtr a -> IO () Source peekByteOff :: Ptr b -> Int -> IO (FunPtr a) Source pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO () Source |
nullFunPtr :: FunPtr a Source
The constant nullFunPtr
contains a distinguished value of FunPtr
that is not associated with a valid memory location.
castFunPtr :: FunPtr a -> FunPtr b Source
Casts a FunPtr
to a FunPtr
of a different type.
castFunPtrToPtr :: FunPtr a -> Ptr b Source
Note: this is valid only on architectures where data and function pointers range over the same set of addresses, and should only be used for bindings to external libraries whose interface already relies on this assumption.
castPtrToFunPtr :: Ptr a -> FunPtr b Source
Note: this is valid only on architectures where data and function pointers range over the same set of addresses, and should only be used for bindings to external libraries whose interface already relies on this assumption.
freeHaskellFunPtr :: FunPtr a -> IO () Source
Release the storage associated with the given FunPtr
, which must have been obtained from a wrapper stub. This should be called whenever the return value from a foreign import wrapper function is no longer required; otherwise, the storage it uses will leak.
A signed integral type that can be losslessly converted to and from Ptr
. This type is also compatible with the C99 type intptr_t
, and can be marshalled to and from that type safely.
ptrToIntPtr :: Ptr a -> IntPtr Source
casts a Ptr
to an IntPtr
intPtrToPtr :: IntPtr -> Ptr a Source
casts an IntPtr
to a Ptr
An unsigned integral type that can be losslessly converted to and from Ptr
. This type is also compatible with the C99 type uintptr_t
, and can be marshalled to and from that type safely.
ptrToWordPtr :: Ptr a -> WordPtr Source
casts a Ptr
to a WordPtr
wordPtrToPtr :: WordPtr -> Ptr a Source
casts a WordPtr
to a Ptr
© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.8.3/docs/html/libraries/base-4.13.0.0/Foreign-Ptr.html