{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE NoImplicitPrelude, MagicHash, UnboxedTuples #-}
{-# OPTIONS_HADDOCK not-home #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  GHC.Internal.Storable
-- Copyright   :  (c) The FFI task force, 2000-2002
-- License     :  see libraries/base/LICENSE
--
-- Maintainer  :  ffi@haskell.org
-- Stability   :  internal
-- Portability :  non-portable (GHC Extensions)
--
-- Helper functions for "Foreign.Storable"
--
-----------------------------------------------------------------------------

module GHC.Internal.Storable
        ( readWideCharOffPtr
        , readIntOffPtr
        , readWordOffPtr
        , readPtrOffPtr
        , readFunPtrOffPtr
        , readFloatOffPtr
        , readDoubleOffPtr
        , readStablePtrOffPtr
        , readInt8OffPtr
        , readInt16OffPtr
        , readInt32OffPtr
        , readInt64OffPtr
        , readWord8OffPtr
        , readWord16OffPtr
        , readWord32OffPtr
        , readWord64OffPtr
        , writeWideCharOffPtr
        , writeIntOffPtr
        , writeWordOffPtr
        , writePtrOffPtr
        , writeFunPtrOffPtr
        , writeFloatOffPtr
        , writeDoubleOffPtr
        , writeStablePtrOffPtr
        , writeInt8OffPtr
        , writeInt16OffPtr
        , writeInt32OffPtr
        , writeInt64OffPtr
        , writeWord8OffPtr
        , writeWord16OffPtr
        , writeWord32OffPtr
        , writeWord64OffPtr
        ) where

import GHC.Internal.Stable ( StablePtr(..) )
import GHC.Internal.Int
import GHC.Internal.Word
import GHC.Internal.Ptr
import GHC.Internal.Base

readWideCharOffPtr  :: Ptr Char          -> Int -> IO Char
readIntOffPtr       :: Ptr Int           -> Int -> IO Int
readWordOffPtr      :: Ptr Word          -> Int -> IO Word
readPtrOffPtr       :: Ptr (Ptr a)       -> Int -> IO (Ptr a)
readFunPtrOffPtr    :: Ptr (FunPtr a)    -> Int -> IO (FunPtr a)
readFloatOffPtr     :: Ptr Float         -> Int -> IO Float
readDoubleOffPtr    :: Ptr Double        -> Int -> IO Double
readStablePtrOffPtr :: Ptr (StablePtr a) -> Int -> IO (StablePtr a)
readInt8OffPtr      :: Ptr Int8          -> Int -> IO Int8
readInt16OffPtr     :: Ptr Int16         -> Int -> IO Int16
readInt32OffPtr     :: Ptr Int32         -> Int -> IO Int32
readInt64OffPtr     :: Ptr Int64         -> Int -> IO Int64
readWord8OffPtr     :: Ptr Word8         -> Int -> IO Word8
readWord16OffPtr    :: Ptr Word16        -> Int -> IO Word16
readWord32OffPtr    :: Ptr Word32        -> Int -> IO Word32
readWord64OffPtr    :: Ptr Word64        -> Int -> IO Word64

readWideCharOffPtr :: Ptr Char -> Int -> IO Char
readWideCharOffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Char #)) -> IO Char
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Char #)) -> IO Char)
-> (State# RealWorld -> (# State# RealWorld, Char #)) -> IO Char
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, Char# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
readWideCharOffAddr# Addr#
a Int#
i State# RealWorld
s  of (# State# RealWorld
s2, Char#
x #) -> (# State# RealWorld
s2, Char# -> Char
C# Char#
x #)
readIntOffPtr :: Ptr Int -> Int -> IO Int
readIntOffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Int #)) -> IO Int
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Int #)) -> IO Int)
-> (State# RealWorld -> (# State# RealWorld, Int #)) -> IO Int
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, Int# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Int# #)
readIntOffAddr# Addr#
a Int#
i State# RealWorld
s       of (# State# RealWorld
s2, Int#
x #) -> (# State# RealWorld
s2, Int# -> Int
I# Int#
x #)
readWordOffPtr :: Ptr Word -> Int -> IO Word
readWordOffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Word #)) -> IO Word
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Word #)) -> IO Word)
-> (State# RealWorld -> (# State# RealWorld, Word #)) -> IO Word
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, Word# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Word# #)
readWordOffAddr# Addr#
a Int#
i State# RealWorld
s      of (# State# RealWorld
s2, Word#
x #) -> (# State# RealWorld
s2, Word# -> Word
W# Word#
x #)
readPtrOffPtr :: forall a. Ptr (Ptr a) -> Int -> IO (Ptr a)
readPtrOffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Ptr a #)) -> IO (Ptr a)
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Ptr a #)) -> IO (Ptr a))
-> (State# RealWorld -> (# State# RealWorld, Ptr a #))
-> IO (Ptr a)
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, Addr# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Addr# #)
readAddrOffAddr# Addr#
a Int#
i State# RealWorld
s      of (# State# RealWorld
s2, Addr#
x #) -> (# State# RealWorld
s2, Addr# -> Ptr a
forall a. Addr# -> Ptr a
Ptr Addr#
x #)
readFunPtrOffPtr :: forall a. Ptr (FunPtr a) -> Int -> IO (FunPtr a)
readFunPtrOffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, FunPtr a #))
-> IO (FunPtr a)
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, FunPtr a #))
 -> IO (FunPtr a))
-> (State# RealWorld -> (# State# RealWorld, FunPtr a #))
-> IO (FunPtr a)
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, Addr# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Addr# #)
readAddrOffAddr# Addr#
a Int#
i State# RealWorld
s      of (# State# RealWorld
s2, Addr#
x #) -> (# State# RealWorld
s2, Addr# -> FunPtr a
forall a. Addr# -> FunPtr a
FunPtr Addr#
x #)
readFloatOffPtr :: Ptr Float -> Int -> IO Float
readFloatOffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Float #)) -> IO Float
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Float #)) -> IO Float)
-> (State# RealWorld -> (# State# RealWorld, Float #)) -> IO Float
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, Float# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
readFloatOffAddr# Addr#
a Int#
i State# RealWorld
s     of (# State# RealWorld
s2, Float#
x #) -> (# State# RealWorld
s2, Float# -> Float
F# Float#
x #)
readDoubleOffPtr :: Ptr Double -> Int -> IO Double
readDoubleOffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Double #)) -> IO Double
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Double #)) -> IO Double)
-> (State# RealWorld -> (# State# RealWorld, Double #))
-> IO Double
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr#
-> Int# -> State# RealWorld -> (# State# RealWorld, Double# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Double# #)
readDoubleOffAddr# Addr#
a Int#
i State# RealWorld
s    of (# State# RealWorld
s2, Double#
x #) -> (# State# RealWorld
s2, Double# -> Double
D# Double#
x #)
readStablePtrOffPtr :: forall a. Ptr (StablePtr a) -> Int -> IO (StablePtr a)
readStablePtrOffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, StablePtr a #))
-> IO (StablePtr a)
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, StablePtr a #))
 -> IO (StablePtr a))
-> (State# RealWorld -> (# State# RealWorld, StablePtr a #))
-> IO (StablePtr a)
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr#
-> Int# -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
forall d a.
Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
readStablePtrOffAddr# Addr#
a Int#
i State# RealWorld
s of (# State# RealWorld
s2, StablePtr# a
x #) -> (# State# RealWorld
s2, StablePtr# a -> StablePtr a
forall a. StablePtr# a -> StablePtr a
StablePtr StablePtr# a
x #)
readInt8OffPtr :: Ptr Int8 -> Int -> IO Int8
readInt8OffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Int8 #)) -> IO Int8
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Int8 #)) -> IO Int8)
-> (State# RealWorld -> (# State# RealWorld, Int8 #)) -> IO Int8
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, Int8# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Int8# #)
readInt8OffAddr# Addr#
a Int#
i State# RealWorld
s      of (# State# RealWorld
s2, Int8#
x #) -> (# State# RealWorld
s2, Int8# -> Int8
I8# Int8#
x #)
readWord8OffPtr :: Ptr Word8 -> Int -> IO Word8
readWord8OffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Word8 #)) -> IO Word8
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Word8 #)) -> IO Word8)
-> (State# RealWorld -> (# State# RealWorld, Word8 #)) -> IO Word8
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, Word8# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Word8# #)
readWord8OffAddr# Addr#
a Int#
i State# RealWorld
s     of (# State# RealWorld
s2, Word8#
x #) -> (# State# RealWorld
s2, Word8# -> Word8
W8# Word8#
x #)
readInt16OffPtr :: Ptr Int16 -> Int -> IO Int16
readInt16OffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Int16 #)) -> IO Int16
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Int16 #)) -> IO Int16)
-> (State# RealWorld -> (# State# RealWorld, Int16 #)) -> IO Int16
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, Int16# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Int16# #)
readInt16OffAddr# Addr#
a Int#
i State# RealWorld
s     of (# State# RealWorld
s2, Int16#
x #) -> (# State# RealWorld
s2, Int16# -> Int16
I16# Int16#
x #)
readWord16OffPtr :: Ptr Word16 -> Int -> IO Word16
readWord16OffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Word16 #)) -> IO Word16
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Word16 #)) -> IO Word16)
-> (State# RealWorld -> (# State# RealWorld, Word16 #))
-> IO Word16
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr#
-> Int# -> State# RealWorld -> (# State# RealWorld, Word16# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Word16# #)
readWord16OffAddr# Addr#
a Int#
i State# RealWorld
s    of (# State# RealWorld
s2, Word16#
x #) -> (# State# RealWorld
s2, Word16# -> Word16
W16# Word16#
x #)
readInt32OffPtr :: Ptr Int32 -> Int -> IO Int32
readInt32OffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Int32 #)) -> IO Int32
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Int32 #)) -> IO Int32)
-> (State# RealWorld -> (# State# RealWorld, Int32 #)) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, Int32# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Int32# #)
readInt32OffAddr# Addr#
a Int#
i State# RealWorld
s     of (# State# RealWorld
s2, Int32#
x #) -> (# State# RealWorld
s2, Int32# -> Int32
I32# Int32#
x #)
readWord32OffPtr :: Ptr Word32 -> Int -> IO Word32
readWord32OffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Word32 #)) -> IO Word32
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Word32 #)) -> IO Word32)
-> (State# RealWorld -> (# State# RealWorld, Word32 #))
-> IO Word32
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr#
-> Int# -> State# RealWorld -> (# State# RealWorld, Word32# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Word32# #)
readWord32OffAddr# Addr#
a Int#
i State# RealWorld
s    of (# State# RealWorld
s2, Word32#
x #) -> (# State# RealWorld
s2, Word32# -> Word32
W32# Word32#
x #)
readInt64OffPtr :: Ptr Int64 -> Int -> IO Int64
readInt64OffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Int64 #)) -> IO Int64
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Int64 #)) -> IO Int64)
-> (State# RealWorld -> (# State# RealWorld, Int64 #)) -> IO Int64
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> State# RealWorld -> (# State# RealWorld, Int64# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Int64# #)
readInt64OffAddr# Addr#
a Int#
i State# RealWorld
s     of (# State# RealWorld
s2, Int64#
x #) -> (# State# RealWorld
s2, Int64# -> Int64
I64# Int64#
x #)
readWord64OffPtr :: Ptr Word64 -> Int -> IO Word64
readWord64OffPtr (Ptr Addr#
a) (I# Int#
i)
  = (State# RealWorld -> (# State# RealWorld, Word64 #)) -> IO Word64
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, Word64 #)) -> IO Word64)
-> (State# RealWorld -> (# State# RealWorld, Word64 #))
-> IO Word64
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr#
-> Int# -> State# RealWorld -> (# State# RealWorld, Word64# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Word64# #)
readWord64OffAddr# Addr#
a Int#
i State# RealWorld
s    of (# State# RealWorld
s2, Word64#
x #) -> (# State# RealWorld
s2, Word64# -> Word64
W64# Word64#
x #)

writeWideCharOffPtr  :: Ptr Char          -> Int -> Char        -> IO ()
writeIntOffPtr       :: Ptr Int           -> Int -> Int         -> IO ()
writeWordOffPtr      :: Ptr Word          -> Int -> Word        -> IO ()
writePtrOffPtr       :: Ptr (Ptr a)       -> Int -> Ptr a       -> IO ()
writeFunPtrOffPtr    :: Ptr (FunPtr a)    -> Int -> FunPtr a    -> IO ()
writeFloatOffPtr     :: Ptr Float         -> Int -> Float       -> IO ()
writeDoubleOffPtr    :: Ptr Double        -> Int -> Double      -> IO ()
writeStablePtrOffPtr :: Ptr (StablePtr a) -> Int -> StablePtr a -> IO ()
writeInt8OffPtr      :: Ptr Int8          -> Int -> Int8        -> IO ()
writeInt16OffPtr     :: Ptr Int16         -> Int -> Int16       -> IO ()
writeInt32OffPtr     :: Ptr Int32         -> Int -> Int32       -> IO ()
writeInt64OffPtr     :: Ptr Int64         -> Int -> Int64       -> IO ()
writeWord8OffPtr     :: Ptr Word8         -> Int -> Word8       -> IO ()
writeWord16OffPtr    :: Ptr Word16        -> Int -> Word16      -> IO ()
writeWord32OffPtr    :: Ptr Word32        -> Int -> Word32      -> IO ()
writeWord64OffPtr    :: Ptr Word64        -> Int -> Word64      -> IO ()

writeWideCharOffPtr :: Ptr Char -> Int -> Char -> IO ()
writeWideCharOffPtr (Ptr Addr#
a) (I# Int#
i) (C# Char#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Char# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Char# -> State# d -> State# d
writeWideCharOffAddr# Addr#
a Int#
i Char#
x State# RealWorld
s  of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeIntOffPtr :: Ptr Int -> Int -> Int -> IO ()
writeIntOffPtr (Ptr Addr#
a) (I# Int#
i) (I# Int#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Int# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Int# -> State# d -> State# d
writeIntOffAddr# Addr#
a Int#
i Int#
x State# RealWorld
s       of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeWordOffPtr :: Ptr Word -> Int -> Word -> IO ()
writeWordOffPtr (Ptr Addr#
a) (I# Int#
i) (W# Word#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Word# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Word# -> State# d -> State# d
writeWordOffAddr# Addr#
a Int#
i Word#
x State# RealWorld
s      of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writePtrOffPtr :: forall a. Ptr (Ptr a) -> Int -> Ptr a -> IO ()
writePtrOffPtr (Ptr Addr#
a) (I# Int#
i) (Ptr Addr#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Addr# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Addr# -> State# d -> State# d
writeAddrOffAddr# Addr#
a Int#
i Addr#
x State# RealWorld
s      of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeFunPtrOffPtr :: forall a. Ptr (FunPtr a) -> Int -> FunPtr a -> IO ()
writeFunPtrOffPtr (Ptr Addr#
a) (I# Int#
i) (FunPtr Addr#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Addr# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Addr# -> State# d -> State# d
writeAddrOffAddr# Addr#
a Int#
i Addr#
x State# RealWorld
s      of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeFloatOffPtr :: Ptr Float -> Int -> Float -> IO ()
writeFloatOffPtr (Ptr Addr#
a) (I# Int#
i) (F# Float#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Float# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Float# -> State# d -> State# d
writeFloatOffAddr# Addr#
a Int#
i Float#
x State# RealWorld
s     of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeDoubleOffPtr :: Ptr Double -> Int -> Double -> IO ()
writeDoubleOffPtr (Ptr Addr#
a) (I# Int#
i) (D# Double#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Double# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Double# -> State# d -> State# d
writeDoubleOffAddr# Addr#
a Int#
i Double#
x State# RealWorld
s    of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeStablePtrOffPtr :: forall a. Ptr (StablePtr a) -> Int -> StablePtr a -> IO ()
writeStablePtrOffPtr (Ptr Addr#
a) (I# Int#
i) (StablePtr StablePtr# a
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr#
-> Int# -> StablePtr# a -> State# RealWorld -> State# RealWorld
forall a d. Addr# -> Int# -> StablePtr# a -> State# d -> State# d
writeStablePtrOffAddr# Addr#
a Int#
i StablePtr# a
x State# RealWorld
s of State# RealWorld
s2 -> (# State# RealWorld
s2 , () #)
writeInt8OffPtr :: Ptr Int8 -> Int -> Int8 -> IO ()
writeInt8OffPtr (Ptr Addr#
a) (I# Int#
i) (I8# Int8#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Int8# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Int8# -> State# d -> State# d
writeInt8OffAddr# Addr#
a Int#
i Int8#
x State# RealWorld
s      of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeWord8OffPtr :: Ptr Word8 -> Int -> Word8 -> IO ()
writeWord8OffPtr (Ptr Addr#
a) (I# Int#
i) (W8# Word8#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Word8# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Word8# -> State# d -> State# d
writeWord8OffAddr# Addr#
a Int#
i Word8#
x State# RealWorld
s     of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeInt16OffPtr :: Ptr Int16 -> Int -> Int16 -> IO ()
writeInt16OffPtr (Ptr Addr#
a) (I# Int#
i) (I16# Int16#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Int16# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Int16# -> State# d -> State# d
writeInt16OffAddr# Addr#
a Int#
i Int16#
x State# RealWorld
s     of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeWord16OffPtr :: Ptr Word16 -> Int -> Word16 -> IO ()
writeWord16OffPtr (Ptr Addr#
a) (I# Int#
i) (W16# Word16#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Word16# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Word16# -> State# d -> State# d
writeWord16OffAddr# Addr#
a Int#
i Word16#
x State# RealWorld
s    of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeInt32OffPtr :: Ptr Int32 -> Int -> Int32 -> IO ()
writeInt32OffPtr (Ptr Addr#
a) (I# Int#
i) (I32# Int32#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Int32# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Int32# -> State# d -> State# d
writeInt32OffAddr# Addr#
a Int#
i Int32#
x State# RealWorld
s     of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeWord32OffPtr :: Ptr Word32 -> Int -> Word32 -> IO ()
writeWord32OffPtr (Ptr Addr#
a) (I# Int#
i) (W32# Word32#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Word32# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Word32# -> State# d -> State# d
writeWord32OffAddr# Addr#
a Int#
i Word32#
x State# RealWorld
s    of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeInt64OffPtr :: Ptr Int64 -> Int -> Int64 -> IO ()
writeInt64OffPtr (Ptr Addr#
a) (I# Int#
i) (I64# Int64#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Int64# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Int64# -> State# d -> State# d
writeInt64OffAddr# Addr#
a Int#
i Int64#
x State# RealWorld
s     of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)
writeWord64OffPtr :: Ptr Word64 -> Int -> Word64 -> IO ()
writeWord64OffPtr (Ptr Addr#
a) (I# Int#
i) (W64# Word64#
x)
  = (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, () #)) -> IO ())
-> (State# RealWorld -> (# State# RealWorld, () #)) -> IO ()
forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s -> case Addr# -> Int# -> Word64# -> State# RealWorld -> State# RealWorld
forall d. Addr# -> Int# -> Word64# -> State# d -> State# d
writeWord64OffAddr# Addr#
a Int#
i Word64#
x State# RealWorld
s    of State# RealWorld
s2 -> (# State# RealWorld
s2, () #)