Movatterモバイル変換

{-# LANGUAGE Unsafe #-}-- |-- Module      : Data.ByteString.Unsafe-- Copyright   : (c) Don Stewart 2006-2008--               (c) Duncan Coutts 2006-2011-- License     : BSD-style-- Maintainer  : dons00@gmail.com, duncan@community.haskell.org-- Stability   : provisional-- Portability : non-portable---- A module containing unsafe 'ByteString' operations.---- While these functions have a stable API and you may use these functions in-- applications, do carefully consider the documented pre-conditions;-- incorrect use can break referential transparency or worse.--moduleData.ByteString.Unsafe(-- * Unchecked accessunsafeHead,unsafeTail,unsafeInit,unsafeLast,unsafeIndex,unsafeTake,unsafeDrop,-- * Low level interaction with CStrings-- ** Using ByteStrings with functions for CStringsunsafeUseAsCString,unsafeUseAsCStringLen,-- ** Converting CStrings to ByteStringsunsafePackCString,unsafePackCStringLen,unsafePackMallocCString,unsafePackMallocCStringLen,unsafePackAddress,unsafePackAddressLen,unsafePackCStringFinalizer,unsafeFinalize,)whereimportData.ByteString.InternalimportForeign.ForeignPtr(newForeignPtr_,newForeignPtr,withForeignPtr)importForeign.Storable(Storable(..))importForeign.C.String(CString,CStringLen)importControl.Exception(assert)importData.Word(Word8)importqualifiedForeign.ForeignPtrasFC(finalizeForeignPtr)importqualifiedForeign.ConcurrentasFC(newForeignPtr)importGHC.Exts(Addr#)importGHC.Ptr(Ptr(..),castPtr)-- ------------------------------------------------------------------------- Extensions to the basic interface---- | A variety of 'head' for non-empty ByteStrings. 'unsafeHead' omits the-- check for the empty case, so there is an obligation on the programmer-- to provide a proof that the ByteString is non-empty.unsafeHead::ByteString->Word8unsafeHead :: ByteString -> Word8unsafeHead(BSForeignPtr Word8xIntl)=Bool -> Word8 -> Word8forall a. (?callStack::CallStack) => Bool -> a -> aassert(IntlInt -> Int -> Boolforall a. Ord a => a -> a -> Bool>Int0)(Word8 -> Word8) -> Word8 -> Word8forall a b. (a -> b) -> a -> b$IO Word8 -> Word8forall a. IO a -> aaccursedUnutterablePerformIO(IO Word8 -> Word8) -> IO Word8 -> Word8forall a b. (a -> b) -> a -> b$ForeignPtr Word8 -> (Ptr Word8 -> IO Word8) -> IO Word8forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO bunsafeWithForeignPtrForeignPtr Word8x((Ptr Word8 -> IO Word8) -> IO Word8)-> (Ptr Word8 -> IO Word8) -> IO Word8forall a b. (a -> b) -> a -> b$\Ptr Word8p->Ptr Word8 -> IO Word8forall a. Storable a => Ptr a -> IO apeekPtr Word8p{-# INLINEunsafeHead#-}-- | A variety of 'tail' for non-empty ByteStrings. 'unsafeTail' omits the-- check for the empty case. As with 'unsafeHead', the programmer must-- provide a separate proof that the ByteString is non-empty.unsafeTail::ByteString->ByteStringunsafeTail :: ByteString -> ByteStringunsafeTail(BSForeignPtr Word8psIntl)=Bool -> ByteString -> ByteStringforall a. (?callStack::CallStack) => Bool -> a -> aassert(IntlInt -> Int -> Boolforall a. Ord a => a -> a -> Bool>Int0)(ByteString -> ByteString) -> ByteString -> ByteStringforall a b. (a -> b) -> a -> b$ForeignPtr Word8 -> Int -> ByteStringBS(ForeignPtr Word8 -> Int -> ForeignPtr Word8forall a b. ForeignPtr a -> Int -> ForeignPtr bplusForeignPtrForeignPtr Word8psInt1)(IntlInt -> Int -> Intforall a. Num a => a -> a -> a-Int1){-# INLINEunsafeTail#-}-- | A variety of 'init' for non-empty ByteStrings. 'unsafeInit' omits the-- check for the empty case. As with 'unsafeHead', the programmer must-- provide a separate proof that the ByteString is non-empty.unsafeInit::ByteString->ByteStringunsafeInit :: ByteString -> ByteStringunsafeInit(BSForeignPtr Word8psIntl)=Bool -> ByteString -> ByteStringforall a. (?callStack::CallStack) => Bool -> a -> aassert(IntlInt -> Int -> Boolforall a. Ord a => a -> a -> Bool>Int0)(ByteString -> ByteString) -> ByteString -> ByteStringforall a b. (a -> b) -> a -> b$ForeignPtr Word8 -> Int -> ByteStringBSForeignPtr Word8ps(IntlInt -> Int -> Intforall a. Num a => a -> a -> a-Int1){-# INLINEunsafeInit#-}-- | A variety of 'last' for non-empty ByteStrings. 'unsafeLast' omits the-- check for the empty case. As with 'unsafeHead', the programmer must-- provide a separate proof that the ByteString is non-empty.unsafeLast::ByteString->Word8unsafeLast :: ByteString -> Word8unsafeLast(BSForeignPtr Word8xIntl)=Bool -> Word8 -> Word8forall a. (?callStack::CallStack) => Bool -> a -> aassert(IntlInt -> Int -> Boolforall a. Ord a => a -> a -> Bool>Int0)(Word8 -> Word8) -> Word8 -> Word8forall a b. (a -> b) -> a -> b$IO Word8 -> Word8forall a. IO a -> aaccursedUnutterablePerformIO(IO Word8 -> Word8) -> IO Word8 -> Word8forall a b. (a -> b) -> a -> b$ForeignPtr Word8 -> (Ptr Word8 -> IO Word8) -> IO Word8forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO bunsafeWithForeignPtrForeignPtr Word8x((Ptr Word8 -> IO Word8) -> IO Word8)-> (Ptr Word8 -> IO Word8) -> IO Word8forall a b. (a -> b) -> a -> b$\Ptr Word8p->Ptr Word8 -> Int -> IO Word8forall b. Ptr b -> Int -> IO Word8forall a b. Storable a => Ptr b -> Int -> IO apeekByteOffPtr Word8p(IntlInt -> Int -> Intforall a. Num a => a -> a -> a-Int1){-# INLINEunsafeLast#-}-- | Unsafe 'ByteString' index (subscript) operator, starting from 0, returning a 'Word8'-- This omits the bounds check, which means there is an accompanying-- obligation on the programmer to ensure the bounds are checked in some-- other way.unsafeIndex::ByteString->Int->Word8unsafeIndex :: ByteString -> Int -> Word8unsafeIndex(BSForeignPtr Word8xIntl)Inti=Bool -> Word8 -> Word8forall a. (?callStack::CallStack) => Bool -> a -> aassert(IntiInt -> Int -> Boolforall a. Ord a => a -> a -> Bool>=Int0Bool -> Bool -> Bool&&IntiInt -> Int -> Boolforall a. Ord a => a -> a -> Bool<Intl)(Word8 -> Word8) -> Word8 -> Word8forall a b. (a -> b) -> a -> b$IO Word8 -> Word8forall a. IO a -> aaccursedUnutterablePerformIO(IO Word8 -> Word8) -> IO Word8 -> Word8forall a b. (a -> b) -> a -> b$ForeignPtr Word8 -> (Ptr Word8 -> IO Word8) -> IO Word8forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO bunsafeWithForeignPtrForeignPtr Word8x((Ptr Word8 -> IO Word8) -> IO Word8)-> (Ptr Word8 -> IO Word8) -> IO Word8forall a b. (a -> b) -> a -> b$\Ptr Word8p->Ptr Word8 -> Int -> IO Word8forall b. Ptr b -> Int -> IO Word8forall a b. Storable a => Ptr b -> Int -> IO apeekByteOffPtr Word8pInti{-# INLINEunsafeIndex#-}-- | A variety of 'take' which omits the checks on @n@ so there is an-- obligation on the programmer to provide a proof that @0 <= n <= 'length' xs@.unsafeTake::Int->ByteString->ByteStringunsafeTake :: Int -> ByteString -> ByteStringunsafeTakeIntn(BSForeignPtr Word8xIntl)=Bool -> ByteString -> ByteStringforall a. (?callStack::CallStack) => Bool -> a -> aassert(Int0Int -> Int -> Boolforall a. Ord a => a -> a -> Bool<=IntnBool -> Bool -> Bool&&IntnInt -> Int -> Boolforall a. Ord a => a -> a -> Bool<=Intl)(ByteString -> ByteString) -> ByteString -> ByteStringforall a b. (a -> b) -> a -> b$ForeignPtr Word8 -> Int -> ByteStringBSForeignPtr Word8xIntn{-# INLINEunsafeTake#-}-- | A variety of 'drop' which omits the checks on @n@ so there is an-- obligation on the programmer to provide a proof that @0 <= n <= 'length' xs@.unsafeDrop::Int->ByteString->ByteStringunsafeDrop :: Int -> ByteString -> ByteStringunsafeDropIntn(BSForeignPtr Word8xIntl)=Bool -> ByteString -> ByteStringforall a. (?callStack::CallStack) => Bool -> a -> aassert(Int0Int -> Int -> Boolforall a. Ord a => a -> a -> Bool<=IntnBool -> Bool -> Bool&&IntnInt -> Int -> Boolforall a. Ord a => a -> a -> Bool<=Intl)(ByteString -> ByteString) -> ByteString -> ByteStringforall a b. (a -> b) -> a -> b$ForeignPtr Word8 -> Int -> ByteStringBS(ForeignPtr Word8 -> Int -> ForeignPtr Word8forall a b. ForeignPtr a -> Int -> ForeignPtr bplusForeignPtrForeignPtr Word8xIntn)(IntlInt -> Int -> Intforall a. Num a => a -> a -> a-Intn){-# INLINEunsafeDrop#-}-- | /O(1)/ 'unsafePackAddressLen' provides constant-time construction of-- 'ByteString's, which is ideal for string literals. It packs a sequence-- of bytes into a 'ByteString', given a raw 'Addr#' to the string, and-- the length of the string.---- This function is /unsafe/ in two ways:---- * the length argument is assumed to be correct. If the length-- argument is incorrect, it is possible to overstep the end of the-- byte array.---- * if the underlying 'Addr#' is later modified, this change will be-- reflected in the resulting 'ByteString', breaking referential-- transparency.---- If in doubt, don't use this function.--unsafePackAddressLen::Int->Addr#->IOByteStringunsafePackAddressLen :: Int -> Addr# -> IO ByteStringunsafePackAddressLenIntlenAddr#addr#=doForeignPtr Word8p<-Ptr Word8 -> IO (ForeignPtr Word8)forall a. Ptr a -> IO (ForeignPtr a)newForeignPtr_(Addr# -> Ptr Word8forall a. Addr# -> Ptr aPtrAddr#addr#)ByteString -> IO ByteStringforall a. a -> IO aforall (m :: * -> *) a. Monad m => a -> m areturn(ByteString -> IO ByteString) -> ByteString -> IO ByteStringforall a b. (a -> b) -> a -> b$ForeignPtr Word8 -> Int -> ByteStringBSForeignPtr Word8pIntlen{-# INLINEunsafePackAddressLen#-}-- | /O(1)/ Construct a 'ByteString' given a Ptr Word8 to a buffer, a-- length, and an IO action representing a finalizer. This function is-- not available on Hugs.---- This function is /unsafe/, it is possible to break referential-- transparency by modifying the underlying buffer pointed to by the-- first argument. Any changes to the original buffer will be reflected-- in the resulting 'ByteString'.--unsafePackCStringFinalizer::PtrWord8->Int->IO()->IOByteStringunsafePackCStringFinalizer :: Ptr Word8 -> Int -> IO () -> IO ByteStringunsafePackCStringFinalizerPtr Word8pIntlIO ()f=doForeignPtr Word8fp<-Ptr Word8 -> IO () -> IO (ForeignPtr Word8)forall a. Ptr a -> IO () -> IO (ForeignPtr a)FC.newForeignPtrPtr Word8pIO ()fByteString -> IO ByteStringforall a. a -> IO aforall (m :: * -> *) a. Monad m => a -> m areturn(ByteString -> IO ByteString) -> ByteString -> IO ByteStringforall a b. (a -> b) -> a -> b$ForeignPtr Word8 -> Int -> ByteStringBSForeignPtr Word8fpIntl-- | Explicitly run the finaliser associated with a 'ByteString'.-- References to this value after finalisation may generate invalid memory-- references.---- This function is /unsafe/, as there may be other-- 'ByteString's referring to the same underlying pages. If you use-- this, you need to have a proof of some kind that all 'ByteString's-- ever generated from the underlying byte array are no longer live.--unsafeFinalize::ByteString->IO()unsafeFinalize :: ByteString -> IO ()unsafeFinalize(BSForeignPtr Word8pInt_)=ForeignPtr Word8 -> IO ()forall a. ForeignPtr a -> IO ()FC.finalizeForeignPtrForeignPtr Word8p-------------------------------------------------------------------------- Packing CStrings into ByteStrings-- | /O(n)/ Build a 'ByteString' from a 'CString'. This value will have /no/-- finalizer associated to it, and will not be garbage collected by-- Haskell. The ByteString length is calculated using /strlen(3)/,-- and thus the complexity is a /O(n)/.---- This function is /unsafe/. If the 'CString' is later modified, this-- change will be reflected in the resulting 'ByteString', breaking-- referential transparency.--unsafePackCString::CString->IOByteStringunsafePackCString :: CString -> IO ByteStringunsafePackCStringCStringcstr=doForeignPtr Word8fp<-Ptr Word8 -> IO (ForeignPtr Word8)forall a. Ptr a -> IO (ForeignPtr a)newForeignPtr_(CString -> Ptr Word8forall a b. Ptr a -> Ptr bcastPtrCStringcstr)CSizel<-CString -> IO CSizec_strlenCStringcstrByteString -> IO ByteStringforall a. a -> IO aforall (m :: * -> *) a. Monad m => a -> m areturn(ByteString -> IO ByteString) -> ByteString -> IO ByteStringforall a b. (a -> b) -> a -> b$!ForeignPtr Word8 -> Int -> ByteStringBSForeignPtr Word8fp(CSize -> Intforall a b. (Integral a, Num b) => a -> bfromIntegralCSizel)-- | /O(1)/ Build a 'ByteString' from a 'CStringLen'. This value will-- have /no/ finalizer associated with it, and will not be garbage-- collected by Haskell. This operation has /O(1)/ complexity as we-- already know the final size, so no /strlen(3)/ is required.---- This function is /unsafe/. If the original 'CStringLen' is later-- modified, this change will be reflected in the resulting 'ByteString',-- breaking referential transparency.--unsafePackCStringLen::CStringLen->IOByteStringunsafePackCStringLen :: CStringLen -> IO ByteStringunsafePackCStringLen(CStringptr,Intlen)=doForeignPtr Word8fp<-Ptr Word8 -> IO (ForeignPtr Word8)forall a. Ptr a -> IO (ForeignPtr a)newForeignPtr_(CString -> Ptr Word8forall a b. Ptr a -> Ptr bcastPtrCStringptr)ByteString -> IO ByteStringforall a. a -> IO aforall (m :: * -> *) a. Monad m => a -> m areturn(ByteString -> IO ByteString) -> ByteString -> IO ByteStringforall a b. (a -> b) -> a -> b$!ForeignPtr Word8 -> Int -> ByteStringBSForeignPtr Word8fp(Int -> Intforall a b. (Integral a, Num b) => a -> bfromIntegralIntlen)-- | /O(n)/ Build a 'ByteString' from a malloced 'CString'. This value will-- have a @free(3)@ finalizer associated to it.---- This function is /unsafe/. If the original 'CString' is later-- modified, this change will be reflected in the resulting 'ByteString',-- breaking referential transparency.---- This function is also unsafe if you call its finalizer twice,-- which will result in a /double free/ error, or if you pass it-- a 'CString' not allocated with 'Foreign.Marshal.Alloc.malloc'.--unsafePackMallocCString::CString->IOByteStringunsafePackMallocCString :: CString -> IO ByteStringunsafePackMallocCStringCStringcstr=doForeignPtr Word8fp<-FinalizerPtr Word8 -> Ptr Word8 -> IO (ForeignPtr Word8)forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)newForeignPtrFinalizerPtr Word8c_free_finalizer(CString -> Ptr Word8forall a b. Ptr a -> Ptr bcastPtrCStringcstr)CSizelen<-CString -> IO CSizec_strlenCStringcstrByteString -> IO ByteStringforall a. a -> IO aforall (m :: * -> *) a. Monad m => a -> m areturn(ByteString -> IO ByteString) -> ByteString -> IO ByteStringforall a b. (a -> b) -> a -> b$!ForeignPtr Word8 -> Int -> ByteStringBSForeignPtr Word8fp(CSize -> Intforall a b. (Integral a, Num b) => a -> bfromIntegralCSizelen)-- | /O(1)/ Build a 'ByteString' from a malloced 'CStringLen'. This-- value will have a @free(3)@ finalizer associated to it.---- This function is /unsafe/. If the original 'CString' is later-- modified, this change will be reflected in the resulting 'ByteString',-- breaking referential transparency.---- This function is also unsafe if you call its finalizer twice,-- which will result in a /double free/ error, or if you pass it-- a 'CString' not allocated with 'Foreign.Marshal.Alloc.malloc'.--unsafePackMallocCStringLen::CStringLen->IOByteStringunsafePackMallocCStringLen :: CStringLen -> IO ByteStringunsafePackMallocCStringLen(CStringcstr,Intlen)=doForeignPtr Word8fp<-FinalizerPtr Word8 -> Ptr Word8 -> IO (ForeignPtr Word8)forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)newForeignPtrFinalizerPtr Word8c_free_finalizer(CString -> Ptr Word8forall a b. Ptr a -> Ptr bcastPtrCStringcstr)ByteString -> IO ByteStringforall a. a -> IO aforall (m :: * -> *) a. Monad m => a -> m areturn(ByteString -> IO ByteString) -> ByteString -> IO ByteStringforall a b. (a -> b) -> a -> b$!ForeignPtr Word8 -> Int -> ByteStringBSForeignPtr Word8fpIntlen-- ----------------------------------------------------------------------- | /O(1) construction/ Use a 'ByteString' with a function requiring a-- 'CString'.---- This function does zero copying, and merely unwraps a 'ByteString' to-- appear as a 'CString'. It is /unsafe/ in two ways:---- * After calling this function the 'CString' shares the underlying-- byte buffer with the original 'ByteString'. Thus modifying the-- 'CString', either in C, or using poke, will cause the contents of the-- 'ByteString' to change, breaking referential transparency. Other-- 'ByteString's created by sharing (such as those produced via 'take'-- or 'drop') will also reflect these changes. Modifying the 'CString'-- will break referential transparency. To avoid this, use-- 'Data.ByteString.useAsCString', which makes a copy of the original 'ByteString'.---- * 'CString's are often passed to functions that require them to be-- null-terminated. If the original 'ByteString' wasn't null terminated,-- neither will the 'CString' be. It is the programmers responsibility-- to guarantee that the 'ByteString' is indeed null terminated. If in-- doubt, use 'Data.ByteString.useAsCString'.---- * The memory may freed at any point after the subcomputation-- terminates, so the pointer to the storage must *not* be used-- after this.--unsafeUseAsCString::ByteString->(CString->IOa)->IOaunsafeUseAsCString :: forall a. ByteString -> (CString -> IO a) -> IO aunsafeUseAsCString(BSForeignPtr Word8psInt_)CString -> IO aaction=ForeignPtr Word8 -> (Ptr Word8 -> IO a) -> IO aforall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO bwithForeignPtrForeignPtr Word8ps((Ptr Word8 -> IO a) -> IO a) -> (Ptr Word8 -> IO a) -> IO aforall a b. (a -> b) -> a -> b$\Ptr Word8p->CString -> IO aaction(Ptr Word8 -> CStringforall a b. Ptr a -> Ptr bcastPtrPtr Word8p)-- Cannot use unsafeWithForeignPtr, because action can diverge-- | /O(1) construction/ Use a 'ByteString' with a function requiring a-- 'CStringLen'.---- This function does zero copying, and merely unwraps a 'ByteString' to-- appear as a 'CStringLen'. It is /unsafe/:---- * After calling this function the 'CStringLen' shares the underlying-- byte buffer with the original 'ByteString'. Thus modifying the-- 'CStringLen', either in C, or using poke, will cause the contents of the-- 'ByteString' to change, breaking referential transparency. Other-- 'ByteString's created by sharing (such as those produced via 'take'-- or 'drop') will also reflect these changes. Modifying the 'CStringLen'-- will break referential transparency. To avoid this, use-- 'Data.ByteString.useAsCStringLen', which makes a copy of the original 'ByteString'.---- If 'Data.ByteString.empty' is given, it will pass @('Foreign.Ptr.nullPtr', 0)@.unsafeUseAsCStringLen::ByteString->(CStringLen->IOa)->IOaunsafeUseAsCStringLen :: forall a. ByteString -> (CStringLen -> IO a) -> IO aunsafeUseAsCStringLen(BSForeignPtr Word8psIntl)CStringLen -> IO aaction=ForeignPtr Word8 -> (Ptr Word8 -> IO a) -> IO aforall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO bwithForeignPtrForeignPtr Word8ps((Ptr Word8 -> IO a) -> IO a) -> (Ptr Word8 -> IO a) -> IO aforall a b. (a -> b) -> a -> b$\Ptr Word8p->CStringLen -> IO aaction(Ptr Word8 -> CStringforall a b. Ptr a -> Ptr bcastPtrPtr Word8p,Intl)-- Cannot use unsafeWithForeignPtr, because action can diverge