More unsafe checks
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Wed, 2 Dec 2009 14:49:44 +0000 (14:49 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Wed, 2 Dec 2009 14:49:44 +0000 (14:49 +0000)
Data/Vector/Primitive/Mutable.hs
Data/Vector/Storable/Mutable.hs

index 227fdf3..6f6bb3c 100644 (file)
@@ -21,17 +21,21 @@ import           Data.Primitive ( Prim, sizeOf )
 import           Control.Monad.Primitive
 import           Control.Monad.ST ( ST )
 
+#include "vector.h"
+
 -- | Mutable unboxed vectors. They live in the 'ST' monad.
 data MVector m a = MVector {-# UNPACK #-} !Int
-                         {-# UNPACK #-} !Int
-                         {-# UNPACK #-} !(MutableByteArray m)
+                           {-# UNPACK #-} !Int
+                           {-# UNPACK #-} !(MutableByteArray m)
 
 type IOVector = MVector IO
 type STVector s = MVector (ST s)
 
 instance Prim a => G.MVectorPure (MVector m) a where
   length (MVector _ n _) = n
-  unsafeSlice (MVector i _ arr) j m = MVector (i+j) m arr
+  unsafeSlice (MVector i n arr) j m
+    = UNSAFE_CHECK(checkSlice) "unsafeSlice" j m n
+    $ MVector (i+j) m arr
 
   {-# INLINE overlaps #-}
   overlaps (MVector i m arr1) (MVector j n arr2)
@@ -43,15 +47,18 @@ instance Prim a => G.MVectorPure (MVector m) a where
 
 instance (Prim a, PrimMonad m) => G.MVector (MVector m) m a where
   {-# INLINE unsafeNew #-}
-  unsafeNew n = do
+  unsafeNew n = UNSAFE_CHECK(checkLength) "unsafeNew" n
+              $ do
                   arr <- newByteArray (n * sizeOf (undefined :: a))
                   return (MVector 0 n arr)
 
   {-# INLINE unsafeRead #-}
-  unsafeRead (MVector i _ arr) j = readByteArray arr (i+j)
+  unsafeRead (MVector i n arr) j = UNSAFE_CHECK(checkIndex) "unsafeRead" j n
+                                 $ readByteArray arr (i+j)
 
   {-# INLINE unsafeWrite #-}
-  unsafeWrite (MVector i _ arr) j x = writeByteArray arr (i+j) x
+  unsafeWrite (MVector i n arr) j x = UNSAFE_CHECK(checkIndex) "unsafeWrite" j n
+                                    $ writeByteArray arr (i+j) x
 
   {-# INLINE clear #-}
   clear _ = return ()
index fd1d851..39f4f89 100644 (file)
@@ -20,17 +20,21 @@ import qualified Data.Vector.Generic.Mutable as G
 import Foreign.Storable
 import Foreign.ForeignPtr
 
+#include "vector.h"
+
 -- | Mutable 'Storable'-based vectors in the 'IO' monad.
 data MVector a = MVector {-# UNPACK #-} !Int
-                       {-# UNPACK #-} !Int
-                       {-# UNPACK #-} !(ForeignPtr a)
+                         {-# UNPACK #-} !Int
+                         {-# UNPACK #-} !(ForeignPtr a)
 
 instance G.MVectorPure MVector a where
   {-# INLINE length #-}
   length (MVector _ n _) = n
 
   {-# INLINE unsafeSlice #-}
-  unsafeSlice (MVector i _ p) j m = MVector (i+j) m p
+  unsafeSlice (MVector i n p) j m
+    = UNSAFE_CHECK(checkSlice) "unsafeSlice" j m n
+    $ MVector (i+j) m p
 
   -- FIXME: implement this properly
   {-# INLINE overlaps #-}
@@ -39,15 +43,18 @@ instance G.MVectorPure MVector a where
 
 instance Storable a => G.MVector MVector IO a where
   {-# INLINE unsafeNew #-}
-  unsafeNew n = MVector 0 n `fmap` mallocForeignPtrArray n
+  unsafeNew n = UNSAFE_CHECK(checkLength) "unsafeNew" n
+              $ MVector 0 n `fmap` mallocForeignPtrArray n
 
   {-# INLINE unsafeRead #-}
-  unsafeRead (MVector i n p) j = withForeignPtr p $ \ptr ->
-                                peekElemOff ptr (i+j)
+  unsafeRead (MVector i n p) j = UNSAFE_CHECK(checkIndex) "unsafeRead" j n
+                               $ withForeignPtr p $ \ptr ->
+                                 peekElemOff ptr (i+j)
      
   {-# INLINE unsafeWrite #-}
-  unsafeWrite (MVector i n p) j x = withForeignPtr p $ \ptr ->
-                                   pokeElemOff ptr (i+j) x 
+  unsafeWrite (MVector i n p) j x = UNSAFE_CHECK(checkIndex) "unsafeWrite" j n
+                                  $ withForeignPtr p $ \ptr ->
+                                    pokeElemOff ptr (i+j) x 
 
   {-# INLINE clear #-}
   clear _ = return ()