[project @ 2002-05-15 09:00:00 by chak]

* Added the options `-ffi' and `-fffi', which switch on FFI support
  (`-fglasgow-exts' implies `-fffi').

  NB: Strictly speaking `-fffi' is the correct name; however, `-ffi' is
      supported as an alternative spelling.

* `-fglasgow-exts' no longer enables the `with' keyword for implicit
  parameters.  To use `with' as a keyword, the additional option `-fwith' has
  to be supplied.  (Note that SimonM recently enabled the use of `let' instead
  of `with'.)

  NB: This might prompt some makefile tweaks in libraries or regression tests.

* Renamed `Foreign.Marshal.Utils.withObject' to `Foreign.Marshal.Utils.with'
  as required by the FFI Addendum.  (The old name is still available, but
  marked as deprecated.)

* Added `realloc' to `Foreign.Marshal.Alloc' (tracking RC4 of the FFI
  Addendum).

Docu
~~~~
* Added `-ffi', `-fffi', and `-fwith' to the flag reference and the section
  describing options for Glasgow extensions

* Removed most of the FFI section in the User's Guide in favour of a reference
  to the Addendum plus a brief description of additional features supported by
  GHC.

  NB: The old material is still available at fptools/docs/, I merely removed
  the reference in the User's Guide.

diff --git a/Foreign/Marshal/Alloc.hs b/Foreign/Marshal/Alloc.hs
index e5c3aa3..1687c82 100644 (file)
--- a/Foreign/Marshal/Alloc.hs
+++ b/Foreign/Marshal/Alloc.hs
@@ -21,7 +21,8 @@ module Foreign.Marshal.Alloc (
   alloca,       -- :: Storable a =>        (Ptr a -> IO b) -> IO b
   allocaBytes,  -- ::               Int -> (Ptr a -> IO b) -> IO b
 
-  reallocBytes, -- :: Ptr a -> Int -> IO (Ptr a)
+  realloc,      -- :: Storable b => Ptr a        -> IO (Ptr b)
+  reallocBytes, -- ::              Ptr a -> Int -> IO (Ptr a)
 
   free          -- :: Ptr a -> IO ()
 ) where
@@ -93,6 +94,18 @@ allocaBytes      :: Int -> (Ptr a -> IO b) -> IO b
 allocaBytes size  = bracket (mallocBytes size) free
 #endif
 
+-- |Adjust a malloc\'ed storage area to the given size of the required type
+-- (corresponds to C\'s @realloc()@).
+--
+realloc :: Storable b => Ptr a -> IO (Ptr b)
+realloc  = doRealloc undefined
+  where
+    doRealloc           :: Storable b => b -> Ptr a -> IO (Ptr b)
+    doRealloc dummy ptr  = let
+                            size = fromIntegral (sizeOf dummy)
+                          in
+                          failWhenNULL "realloc" (_realloc ptr size)
+
 -- |Adjust a malloc\'ed storage area to the given size (equivalent to
 -- C\'s @realloc()@).
 --
@@ -128,5 +141,5 @@ failWhenNULL name f = do
 -- basic C routines needed for memory allocation
 --
 foreign import ccall unsafe "malloc"  _malloc  ::          CSize -> IO (Ptr a)
-foreign import ccall unsafe "realloc" _realloc :: Ptr a -> CSize -> IO (Ptr a)
+foreign import ccall unsafe "realloc" _realloc :: Ptr a -> CSize -> IO (Ptr b)
 foreign import ccall unsafe "free"    _free    :: Ptr a -> IO ()

diff --git a/Foreign/Marshal/Utils.hs b/Foreign/Marshal/Utils.hs
index e5ff7b1..08bee23 100644 (file)
--- a/Foreign/Marshal/Utils.hs
+++ b/Foreign/Marshal/Utils.hs
@@ -18,8 +18,7 @@ module Foreign.Marshal.Utils (
 
   -- ** Combined allocation and marshalling
   --
-  withObject,    -- :: Storable a => a -> (Ptr a -> IO b) -> IO b
-  {- FIXME: should be `with' -}
+  with,          -- :: Storable a => a -> (Ptr a -> IO b) -> IO b
   new,           -- :: Storable a => a -> IO (Ptr a)
 
   -- ** Marshalling of Boolean values (non-zero corresponds to 'True')
@@ -41,10 +40,14 @@ module Foreign.Marshal.Utils (
   withMany,      -- :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
 
   -- ** Haskellish interface to memcpy and memmove
-
   -- | (argument order: destination, source)
+  --
   copyBytes,     -- :: Ptr a -> Ptr a -> Int -> IO ()
-  moveBytes      -- :: Ptr a -> Ptr a -> Int -> IO ()
+  moveBytes,     -- :: Ptr a -> Ptr a -> Int -> IO ()
+
+  -- ** DEPRECATED FUNCTIONS (don\'t use; they may disappear at any time)
+  --
+  withObject     -- :: Storable a => a -> (Ptr a -> IO b) -> IO b
 ) where
 
 import Data.Maybe
@@ -76,14 +79,19 @@ new val  =
 --
 -- * see the life time constraints imposed by 'alloca'
 --
-{- FIXME: should be called `with' -}
-withObject       :: Storable a => a -> (Ptr a -> IO b) -> IO b
-withObject val f  =
+with       :: Storable a => a -> (Ptr a -> IO b) -> IO b
+with val f  =
   alloca $ \ptr -> do
     poke ptr val
     res <- f ptr
     return res
 
+-- old DEPRECATED name (don't use; may disappear at any time)
+--
+withObject :: Storable a => a -> (Ptr a -> IO b) -> IO b
+{-# DEPRECATED withObject "use `with' instead" #-}
+withObject  = with
+
 
 -- marshalling of Boolean values (non-zero corresponds to 'True')
 -- -----------------------------