From 6e9831fee1a4f0523bccf3ff8873fc9677f871d6 Mon Sep 17 00:00:00 2001
From: chak <unknown>
Date: Wed, 15 May 2002 09:00:00 +0000
Subject: [PATCH] [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.
---
 Foreign/Marshal/Alloc.hs |   17 +++++++++++++++--
 Foreign/Marshal/Utils.hs |   22 +++++++++++++++-------
 2 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/Foreign/Marshal/Alloc.hs b/Foreign/Marshal/Alloc.hs
index e5c3aa3..1687c82 100644
--- 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
--- 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')
 -- -----------------------------
-- 
1.7.10.4