module NHC.FFI
-------------------------------------------------------------------
-- {Int,Word}{8,16,32,64} are abstract and instances of Eq, Ord,
-- Num, Bounded, Real, Integral, Ix, Enum, Read, Show
-------------------------------------------------------------------
( Int8, Int16, Int32, Int64
, Word8, Word16, Word32, Word64
-------------------------------------------------------------------
-- `Addr' is now obsolete - use `Ptr a' instead.
-------------------------------------------------------------------
, Addr -- abstract, instance of: Eq, Ord, Enum, Show
, nullAddr -- :: Addr
, plusAddr -- :: Addr -> Int -> Addr
-------------------------------------------------------------------
-- `Ptr a' is a C pointer value.
-------------------------------------------------------------------
, Ptr -- abstract, instance of: Eq, Ord, Enum, Show
, nullPtr -- :: Ptr a
, castPtr -- :: Ptr a -> Ptr b
, plusPtr -- :: Ptr a -> Int -> Ptr b
, alignPtr -- :: Ptr a -> Int -> Ptr a
, minusPtr -- :: Ptr a -> Ptr b -> Int
-------------------------------------------------------------------
-- `FunPtr a' is a C function pointer value.
-------------------------------------------------------------------
, FunPtr -- abstract, instance of: Eq, Ord, Enum, Show
, nullFunPtr -- :: FunPtr a
, castFunPtr -- :: FunPtr a -> FunPtr b
, freeHaskellFunPtr -- :: FunPtr a -> IO ()
, castFunPtrToPtr -- :: FunPtr a -> Ptr b
, castPtrToFunPtr -- :: Ptr a -> FunPtr b
-------------------------------------------------------------------
-- The `Storable' class.
-------------------------------------------------------------------
, Storable
( sizeOf -- :: a -> Int
, alignment -- :: a -> Int
, peekElemOff -- :: Ptr a -> Int -> IO a
, pokeElemOff -- :: Ptr a -> Int -> a -> IO ()
, peekByteOff -- :: Ptr b -> Int -> IO a
, pokeByteOff -- :: Ptr b -> Int -> a -> IO ()
, peek -- :: Ptr a -> IO a
, poke -- :: Ptr a -> a -> IO ()
, destruct) -- :: Ptr a -> Io ()
-------------------------------------------------------------------
-- `ForeignObj' is now obsolete - use `ForeignPtr a' instead.
-------------------------------------------------------------------
, ForeignObj -- abstract, instance of: Eq
, newForeignObj -- :: Addr -> IO () -> IO ForeignObj
, makeForeignObj -- :: Addr -> IO () -> IO ForeignObj -- OBSOLETE
, foreignObjToAddr -- :: ForeignObj -> Addr
, freeForeignObj -- :: ForeignObj -> IO ()
, withForeignObj -- :: ForeignObj -> (Addr -> IO a) -> IO a
, touchForeignObj -- :: ForeignObj -> IO ()
-------------------------------------------------------------------
-- `ForeignPtr a' is a C pointer value with an associated finaliser.
-------------------------------------------------------------------
, ForeignPtr -- abstract, instance of: Eq
, FinalizerPtr -- type synonym for FunPtr (Ptr a -> IO ())
, newForeignPtr -- :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
, newForeignPtr_ -- :: Ptr a -> IO (ForeignPtr a)
, addForeignPtrFinalizer -- :: FinalizerPtr a -> ForeignPtr a -> IO ()
, withForeignPtr -- :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
, unsafeForeignPtrToPtr -- :: ForeignPtr a -> Ptr a
, touchForeignPtr -- :: ForeignPtr a -> IO ()
, castForeignPtr -- :: ForeignPtr a -> ForeignPtr b
, newConcForeignPtr -- :: IO () -> Ptr a -> IO (ForeignPtr a)
, addConcForeignPtrFinalizer -- :: IO () -> ForeignPtr a -> IO ()
-------------------------------------------------------------------
-- `StablePtr a' is a Haskell value passed to the foreign land.
-------------------------------------------------------------------
, StablePtr -- abstract
, newStablePtr -- :: a -> IO (StablePtr a)
, deRefStablePtr -- :: StablePtr a -> IO a
, freeStablePtr -- :: StablePtr a -> IO ()
, castStablePtrToPtr -- :: StablePtr a -> Ptr ()
, castPtrToStablePtr -- :: Ptr () -> StablePtr a
-------------------------------------------------------------------
-- `unsafePerformIO' is so commonly used, it should be exported.
-------------------------------------------------------------------
, unsafePerformIO -- :: IO a -> a
-------------------------------------------------------------------
-- nhc98's `PackedString' is a heap-allocated packed array of characters.
-------------------------------------------------------------------
, PackedString -- abstract
, toCString -- :: String -> PackedString
, fromCString -- :: PackedString -> String
-------------------------------------------------------------------
-- `CString' is a C-allocated C packed array of characters.
-------------------------------------------------------------------
, CString -- = Ptr CChar
, CStringLen -- = (CString, Int)
, peekCString -- :: CString -> IO String
, peekCStringLen -- :: CStringLen -> IO String
, newCString -- :: String -> IO CString
, newCStringLen -- :: String -> IO CStringLen
, withCString -- :: String -> (CString -> IO a) -> IO a
, withCStringLen -- :: String -> (CStringLen -> IO a) -> IO a
, castCharToCChar -- :: Char -> CChar
, castCCharToChar -- :: CChar -> Char
-------------------------------------------------------------------
-- nhc98's `CError' helps to build meaningful error messages.
-------------------------------------------------------------------
, getErrNo -- :: IO Int
, mkIOError -- :: String -> Maybe FilePath -> Maybe Handle
-- -> Int -> IOError
, throwIOError -- :: String -> Maybe FilePath -> Maybe Handle
-- -> Int -> IO a
-------------------------------------------------------------------
-- Various `CTypes'.
-------------------------------------------------------------------
, CChar(..) , CSChar(..) , CUChar(..)
, CShort(..) , CUShort(..)
, CInt(..) , CUInt(..)
, CLong(..) , CULong(..)
, CLLong(..) , CULLong(..)
, CFloat(..) , CDouble(..) , CLDouble(..)
-------------------------------------------------------------------
-- `CTypesExtra'.
-------------------------------------------------------------------
, CPtrdiff(..) , CSize(..) , CWchar(..)
, CSigAtomic(..) , CClock(..) , CTime(..)
, CFile , CFpos , CJmpBuf
-------------------------------------------------------------------
-- `MarshalAlloc' provides memory allocation routines.
-------------------------------------------------------------------
, malloc -- :: Storable a => IO (Ptr a)
, mallocBytes -- :: Int -> IO (Ptr a)
, alloca -- :: Storable a => (Ptr a -> IO b) -> IO b
, allocaBytes -- :: Int -> (Ptr a -> IO b) -> IO b
, realloc -- :: Storable b => Ptr a -> IO (Ptr b)
, reallocBytes -- :: Ptr a -> Int -> IO (Ptr a)
, free -- :: Ptr a -> IO ()
, finalizerFree -- :: FinalizerPtr a
-------------------------------------------------------------------
-- `MarshalArray' provides bulk memory allocation/storage routines.
-------------------------------------------------------------------
, mallocArray -- :: Storable a => Int -> IO (Ptr a)
, mallocArray0 -- :: Storable a => Int -> IO (Ptr a)
, allocaArray -- :: Storable a => Int -> (Ptr a -> IO b) -> IO b
, allocaArray0 -- :: Storable a => Int -> (Ptr a -> IO b) -> IO b
, reallocArray -- :: Storable a => Ptr a -> Int -> IO (Ptr a)
, reallocArray0 -- :: Storable a => Ptr a -> Int -> IO (Ptr a)
, peekArray -- :: Storable a => Int -> Ptr a -> IO [a]
, peekArray0 -- :: (Storable a, Eq a) => a -> Ptr a -> IO [a]
, pokeArray -- :: Storable a => Ptr a -> [a] -> IO ()
, pokeArray0 -- :: Storable a => a -> Ptr a -> [a] -> IO ()
, newArray -- :: Storable a => [a] -> IO (Ptr a)
, newArray0 -- :: Storable a => a -> [a] -> IO (Ptr a)
, withArray -- :: Storable a => [a] -> (Ptr a -> IO b) -> IO b
, withArray0 -- :: Storable a => a -> [a] -> (Ptr a -> IO b) -> IO b
, destructArray -- :: Storable a => Int -> Ptr a -> IO ()
, destructArray0 -- :: (Storable a, Eq a) => a -> Ptr a -> IO ()
, copyArray -- :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
, moveArray -- :: Storable a => Ptr a -> Ptr a -> Int -> IO ()
, lengthArray0 -- :: (Storable a, Eq a) => a -> Ptr a -> IO Int
, advancePtr -- :: Storable a => Ptr a -> Int -> Ptr a
-------------------------------------------------------------------
-- `MarshalUtils' provides utilities for basic marshalling.
-------------------------------------------------------------------
, with -- :: Storable a => a -> (Ptr a -> IO b) -> IO b
, new -- :: Storable a => a -> IO (Ptr a)
, fromBool -- :: Num a => Bool -> a
, toBool -- :: Num a => a -> Bool
, maybeNew -- :: ( a -> IO (Ptr a))
-- -> (Maybe a -> IO (Ptr a))
, maybeWith -- :: ( a -> (Ptr b -> IO c) -> IO c)
-- -> (Maybe a -> (Ptr b -> IO c) -> IO c)
, maybePeek -- :: (Ptr a -> IO b )
-- -> (Ptr a -> IO (Maybe b))
, withMany -- :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
, copyBytes -- :: Ptr a -> Ptr a -> Int -> IO ()
, moveBytes -- :: Ptr a -> Ptr a -> Int -> IO ()
-------------------------------------------------------------------
-- `MarshalError' provides utilities for basic error-handling.
-------------------------------------------------------------------
, throwIf -- :: (a -> Bool) -> (a -> String) -> IO a -> IO a
, throwIf_ -- :: (a -> Bool) -> (a -> String) -> IO a -> IO ()
, throwIfNeg -- :: (Ord a, Num a) => (a -> String) -> IO a -> IO a
, throwIfNeg_ -- :: (Ord a, Num a) => (a -> String) -> IO a -> IO ()
, throwIfNull -- :: String -> IO (Ptr a) -> IO (Ptr a)
, void -- IO a -> IO ()
) where
import Int -- sized (signed) Int types
import Word -- sized (unsigned) Word types
import Addr -- obsolete, C address (pointer) values
import Ptr -- C pointer values
import FunPtr -- C function pointer values
import Storable -- class defining storage sizes and routines
import ForeignObj -- obsolete, C address (pointer) + finaliser
import ForeignPtr -- C pointer values with finalisers
import StablePtr -- Haskell values passed to foreign land
import MarshalAlloc -- routines for memory allocation
import MarshalArray -- routines for bulk memory allocation/storage
import MarshalUtils -- routines for basic marshalling
import MarshalError -- routines for basic error-handling
import CTypes -- newtypes for various C basic types
import CTypesExtra -- types for various extra C types
import CStrings -- C pointer to array of char
import CString -- nhc98-only
import CError -- nhc98-only
import NHC.Internal (unsafePerformIO)
|
