{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
module LLVM.Extra.Multi.Value.Storable (
   -- * Basic class
   C(load, store),
   storeNext,
   modify,

   -- * Classes for tuples and vectors
   Tuple(..),
   Vector(..),
   TupleVector(..),

   -- * Standard method implementations
   loadTraversable,
   loadApplicative,
   storeFoldable,

   -- * Pointer handling
   Storable.advancePtr,
   Storable.incrementPtr,
   Storable.decrementPtr,

   -- * Loops over Storable arrays
   Array.arrayLoop,
   Array.arrayLoop2,
   Array.arrayLoopMaybeCont,
   Array.arrayLoopMaybeCont2,
   ) where

import qualified LLVM.Extra.Storable.Private as Storable
import qualified LLVM.Extra.Storable.Array as Array
import LLVM.Extra.Storable.Private
         (BytePtr, advancePtrStatic, incPtrState, incrementPtr, update,
          castFromBytePtr, castToBytePtr,
          runElements, elementOffset, castElementPtr,
          assemblePrimitive, disassemblePrimitive, proxyFromElement3)

import qualified LLVM.Extra.Multi.Vector as MultiVector
import qualified LLVM.Extra.Multi.Value as MultiValue
import qualified LLVM.Extra.ArithmeticPrivate as A

import qualified LLVM.ExecutionEngine as EE
import qualified LLVM.Util.Proxy as LP
import qualified LLVM.Core as LLVM
import LLVM.Core (CodeGenFunction, Value)

import qualified Type.Data.Num.Decimal as TypeNum

import qualified Control.Monad.Trans.Class as MT
import qualified Control.Monad.Trans.Reader as MR
import qualified Control.Monad.Trans.State as MS
import qualified Control.Applicative.HT as App
import qualified Control.Functor.HT as FuncHT
import Control.Monad (foldM, replicateM, replicateM_, (<=<))
import Control.Applicative (Applicative, pure, (<$>))

import qualified Foreign.Storable.Record.Tuple as StoreTuple
import qualified Foreign.Storable as Store
import Foreign.Ptr (Ptr)

import qualified Data.NonEmpty.Class as NonEmptyC
import qualified Data.Traversable as Trav
import qualified Data.Foldable as Fold
import Data.Orphans ()
import Data.Tuple.HT (uncurry3)
import Data.Complex (Complex)
import Data.Word (Word8, Word16, Word32, Word64, Word)
import Data.Int  (Int8,  Int16,  Int32,  Int64)
import Data.Bool8 (Bool8)



class (Store.Storable a, MultiValue.C a) => C a where
   {-
   Not all Storable types have a compatible LLVM type,
   or even more, one LLVM type that is compatible on all platforms.
   -}
   load :: Value (Ptr a) -> CodeGenFunction r (MultiValue.T a)
   store :: MultiValue.T a -> Value (Ptr a) -> CodeGenFunction r ()

storeNext ::
   (C a, Value (Ptr a) ~ ptr) => MultiValue.T a -> ptr -> CodeGenFunction r ptr
storeNext :: forall a ptr r.
(C a, Value (Ptr a) ~ ptr) =>
T a -> ptr -> CodeGenFunction r ptr
storeNext T a
a ptr
ptr  =  T a -> Value (Ptr a) -> CodeGenFunction r ()
forall r. T a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r. C a => T a -> Value (Ptr a) -> CodeGenFunction r ()
store T a
a ptr
Value (Ptr a)
ptr CodeGenFunction r ()
-> CodeGenFunction r ptr -> CodeGenFunction r ptr
forall a b.
CodeGenFunction r a -> CodeGenFunction r b -> CodeGenFunction r b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ptr -> CodeGenFunction r ptr
forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
ptr -> CodeGenFunction r ptr
incrementPtr ptr
ptr

modify ::
   (C a, MultiValue.T a ~ al) =>
   (al -> CodeGenFunction r al) ->
   Value (Ptr a) -> CodeGenFunction r ()
modify :: forall a al r.
(C a, T a ~ al) =>
(al -> CodeGenFunction r al)
-> Value (Ptr a) -> CodeGenFunction r ()
modify al -> CodeGenFunction r al
f Value (Ptr a)
ptr  =  (T a -> Value (Ptr a) -> CodeGenFunction r ())
-> Value (Ptr a) -> T a -> CodeGenFunction r ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip T a -> Value (Ptr a) -> CodeGenFunction r ()
forall r. T a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r. C a => T a -> Value (Ptr a) -> CodeGenFunction r ()
store Value (Ptr a)
ptr (T a -> CodeGenFunction r ())
-> CodeGenFunction r (T a) -> CodeGenFunction r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< al -> CodeGenFunction r al
al -> CodeGenFunction r (T a)
f (al -> CodeGenFunction r (T a))
-> CodeGenFunction r al -> CodeGenFunction r (T a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr a) -> CodeGenFunction r (T a)
forall r. Value (Ptr a) -> CodeGenFunction r (T a)
forall a r. C a => Value (Ptr a) -> CodeGenFunction r (T a)
load Value (Ptr a)
ptr


instance
   (EE.Marshal a, LLVM.IsConst a, LLVM.IsFirstClass a) =>
      C (EE.Stored a) where
   load :: forall r.
Value (Ptr (Stored a)) -> CodeGenFunction r (T (Stored a))
load = (Value a -> T (Stored a))
-> CodeGenFunction r (Value a) -> CodeGenFunction r (T (Stored a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value a -> T (Stored a)
Repr (Stored a) -> T (Stored a)
forall a. Repr a -> T a
MultiValue.Cons (CodeGenFunction r (Value a) -> CodeGenFunction r (T (Stored a)))
-> (Value (Ptr a) -> CodeGenFunction r (Value a))
-> Value (Ptr a)
-> CodeGenFunction r (T (Stored a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value (Ptr a) -> CodeGenFunction r (Value a)
forall a r.
IsType a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
LLVM.load (Value (Ptr a) -> CodeGenFunction r (T (Stored a)))
-> (Value (Ptr (Stored a)) -> CodeGenFunction r (Value (Ptr a)))
-> Value (Ptr (Stored a))
-> CodeGenFunction r (T (Stored a))
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Value (Ptr (Stored a)) -> CodeGenFunction r (Value (Ptr a))
forall a r.
IsType a =>
Value (Ptr (Stored a)) -> CodeGenFunction r (Value (Ptr a))
castFromStoredPtr
   store :: forall r.
T (Stored a) -> Value (Ptr (Stored a)) -> CodeGenFunction r ()
store (MultiValue.Cons Repr (Stored a)
a) = Value a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r.
IsType a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
LLVM.store Value a
Repr (Stored a)
a (Value (Ptr a) -> CodeGenFunction r ())
-> (Value (Ptr (Stored a)) -> CodeGenFunction r (Value (Ptr a)))
-> Value (Ptr (Stored a))
-> CodeGenFunction r ()
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Value (Ptr (Stored a)) -> CodeGenFunction r (Value (Ptr a))
forall a r.
IsType a =>
Value (Ptr (Stored a)) -> CodeGenFunction r (Value (Ptr a))
castFromStoredPtr

castFromStoredPtr ::
   (LLVM.IsType a) =>
   Value (Ptr (EE.Stored a)) -> CodeGenFunction r (Value (LLVM.Ptr a))
castFromStoredPtr :: forall a r.
IsType a =>
Value (Ptr (Stored a)) -> CodeGenFunction r (Value (Ptr a))
castFromStoredPtr = Value (Ptr (Stored a)) -> CodeGenFunction r (Value (Ptr a))
forall (value :: * -> *) a b r.
(ValueCons value, IsSized a, IsSized b, SizeOf a ~ SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.bitcast


loadPrimitive ::
   (LLVM.Storable a, MultiValue.Repr a ~ LLVM.Value a) =>
   Value (Ptr a) -> CodeGenFunction r (MultiValue.T a)
loadPrimitive :: forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive Value (Ptr a)
ptr = (Value a -> T a)
-> CodeGenFunction r (Value a) -> CodeGenFunction r (T a)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value a -> T a
Repr a -> T a
forall a. Repr a -> T a
MultiValue.Cons (CodeGenFunction r (Value a) -> CodeGenFunction r (T a))
-> CodeGenFunction r (Value a) -> CodeGenFunction r (T a)
forall a b. (a -> b) -> a -> b
$ Value (Ptr a) -> CodeGenFunction r (Value a)
forall a r.
IsType a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
LLVM.load (Value (Ptr a) -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value (Ptr a)) -> CodeGenFunction r (Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
forall (value :: * -> *) a b r.
(ValueCons value, IsSized a, IsSized b, SizeOf a ~ SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.bitcast Value (Ptr a)
ptr

storePrimitive ::
   (LLVM.Storable a, MultiValue.Repr a ~ LLVM.Value a) =>
   MultiValue.T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive :: forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive (MultiValue.Cons Repr a
a) Value (Ptr a)
ptr = Value a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r.
IsType a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
LLVM.store Value a
Repr a
a (Value (Ptr a) -> CodeGenFunction r ())
-> CodeGenFunction r (Value (Ptr a)) -> CodeGenFunction r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
forall (value :: * -> *) a b r.
(ValueCons value, IsSized a, IsSized b, SizeOf a ~ SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.bitcast Value (Ptr a)
ptr

instance C Float where
   load :: forall r. Value (Ptr Float) -> CodeGenFunction r (T Float)
load = Value (Ptr Float) -> CodeGenFunction r (T Float)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Float -> Value (Ptr Float) -> CodeGenFunction r ()
store = T Float -> Value (Ptr Float) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Double where
   load :: forall r. Value (Ptr Double) -> CodeGenFunction r (T Double)
load = Value (Ptr Double) -> CodeGenFunction r (T Double)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Double -> Value (Ptr Double) -> CodeGenFunction r ()
store = T Double -> Value (Ptr Double) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Word where
   load :: forall r. Value (Ptr Word) -> CodeGenFunction r (T Word)
load = Value (Ptr Word) -> CodeGenFunction r (T Word)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Word -> Value (Ptr Word) -> CodeGenFunction r ()
store = T Word -> Value (Ptr Word) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Word8 where
   load :: forall r. Value (Ptr Word8) -> CodeGenFunction r (T Word8)
load = Value (Ptr Word8) -> CodeGenFunction r (T Word8)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Word8 -> Value (Ptr Word8) -> CodeGenFunction r ()
store = T Word8 -> Value (Ptr Word8) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Word16 where
   load :: forall r. Value (Ptr Word16) -> CodeGenFunction r (T Word16)
load = Value (Ptr Word16) -> CodeGenFunction r (T Word16)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Word16 -> Value (Ptr Word16) -> CodeGenFunction r ()
store = T Word16 -> Value (Ptr Word16) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Word32 where
   load :: forall r. Value (Ptr Word32) -> CodeGenFunction r (T Word32)
load = Value (Ptr Word32) -> CodeGenFunction r (T Word32)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Word32 -> Value (Ptr Word32) -> CodeGenFunction r ()
store = T Word32 -> Value (Ptr Word32) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Word64 where
   load :: forall r. Value (Ptr Word64) -> CodeGenFunction r (T Word64)
load = Value (Ptr Word64) -> CodeGenFunction r (T Word64)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Word64 -> Value (Ptr Word64) -> CodeGenFunction r ()
store = T Word64 -> Value (Ptr Word64) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Int where
   load :: forall r. Value (Ptr Int) -> CodeGenFunction r (T Int)
load = Value (Ptr Int) -> CodeGenFunction r (T Int)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Int -> Value (Ptr Int) -> CodeGenFunction r ()
store = T Int -> Value (Ptr Int) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Int8 where
   load :: forall r. Value (Ptr Int8) -> CodeGenFunction r (T Int8)
load = Value (Ptr Int8) -> CodeGenFunction r (T Int8)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Int8 -> Value (Ptr Int8) -> CodeGenFunction r ()
store = T Int8 -> Value (Ptr Int8) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Int16 where
   load :: forall r. Value (Ptr Int16) -> CodeGenFunction r (T Int16)
load = Value (Ptr Int16) -> CodeGenFunction r (T Int16)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Int16 -> Value (Ptr Int16) -> CodeGenFunction r ()
store = T Int16 -> Value (Ptr Int16) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Int32 where
   load :: forall r. Value (Ptr Int32) -> CodeGenFunction r (T Int32)
load = Value (Ptr Int32) -> CodeGenFunction r (T Int32)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Int32 -> Value (Ptr Int32) -> CodeGenFunction r ()
store = T Int32 -> Value (Ptr Int32) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

instance C Int64 where
   load :: forall r. Value (Ptr Int64) -> CodeGenFunction r (T Int64)
load = Value (Ptr Int64) -> CodeGenFunction r (T Int64)
forall a r.
(Storable a, Repr a ~ Value a) =>
Value (Ptr a) -> CodeGenFunction r (T a)
loadPrimitive; store :: forall r. T Int64 -> Value (Ptr Int64) -> CodeGenFunction r ()
store = T Int64 -> Value (Ptr Int64) -> CodeGenFunction r ()
forall a r.
(Storable a, Repr a ~ Value a) =>
T a -> Value (Ptr a) -> CodeGenFunction r ()
storePrimitive

{- |
Not very efficient implementation
because we want to adapt to @sizeOf Bool@ dynamically.
Unfortunately, LLVM-9's optimizer does not recognize the instruction pattern.
Better use 'Bool8' for booleans.
-}
instance C Bool where
   load :: forall r. Value (Ptr Bool) -> CodeGenFunction r (T Bool)
load Value (Ptr Bool)
ptr = do
      BytePtr
bytePtr <- Value (Ptr Bool) -> CodeGenFunction r BytePtr
forall a r. Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr Value (Ptr Bool)
ptr
      [Value Word8]
bytes <-
         (StateT BytePtr (CodeGenFunction r) [Value Word8]
 -> BytePtr -> CodeGenFunction r [Value Word8])
-> BytePtr
-> StateT BytePtr (CodeGenFunction r) [Value Word8]
-> CodeGenFunction r [Value Word8]
forall a b c. (a -> b -> c) -> b -> a -> c
flip StateT BytePtr (CodeGenFunction r) [Value Word8]
-> BytePtr -> CodeGenFunction r [Value Word8]
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT BytePtr
bytePtr (StateT BytePtr (CodeGenFunction r) [Value Word8]
 -> CodeGenFunction r [Value Word8])
-> StateT BytePtr (CodeGenFunction r) [Value Word8]
-> CodeGenFunction r [Value Word8]
forall a b. (a -> b) -> a -> b
$
            Int
-> StateT BytePtr (CodeGenFunction r) (Value Word8)
-> StateT BytePtr (CodeGenFunction r) [Value Word8]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM (Bool -> Int
forall a. Storable a => a -> Int
Store.sizeOf (Bool
False :: Bool))
               (CodeGenFunction r (Value Word8)
-> StateT BytePtr (CodeGenFunction r) (Value Word8)
forall (m :: * -> *) a. Monad m => m a -> StateT BytePtr m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r (Value Word8)
 -> StateT BytePtr (CodeGenFunction r) (Value Word8))
-> (BytePtr -> CodeGenFunction r (Value Word8))
-> BytePtr
-> StateT BytePtr (CodeGenFunction r) (Value Word8)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BytePtr -> CodeGenFunction r (Value Word8)
forall a r.
IsType a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
LLVM.load (BytePtr -> StateT BytePtr (CodeGenFunction r) (Value Word8))
-> StateT BytePtr (CodeGenFunction r) BytePtr
-> StateT BytePtr (CodeGenFunction r) (Value Word8)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< StateT BytePtr (CodeGenFunction r) BytePtr
forall r. StateT BytePtr (CodeGenFunction r) BytePtr
incPtrState)
      let zero :: Value Word8
zero = Word8 -> Value Word8
forall a. IsConst a => a -> Value a
LLVM.valueOf Word8
0
      Value Word8
mask <- (Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8))
-> Value Word8 -> [Value Word8] -> CodeGenFunction r (Value Word8)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM Value Word8 -> Value Word8 -> CodeGenFunction r (Value Word8)
forall a r.
IsInteger a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.or Value Word8
zero [Value Word8]
bytes
      Value Bool -> T Bool
Repr Bool -> T Bool
forall a. Repr a -> T a
MultiValue.Cons (Value Bool -> T Bool)
-> CodeGenFunction r (Value Bool) -> CodeGenFunction r (T Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CmpPredicate
-> Value Word8 -> Value Word8 -> CodeGenFunction r (Value Bool)
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpNE Value Word8
mask Value Word8
zero
   store :: forall r. T Bool -> Value (Ptr Bool) -> CodeGenFunction r ()
store (MultiValue.Cons Repr Bool
b) Value (Ptr Bool)
ptr = do
      BytePtr
bytePtr <- Value (Ptr Bool) -> CodeGenFunction r BytePtr
forall a r. Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr Value (Ptr Bool)
ptr
      Value Word8
byte <- Value Bool -> CodeGenFunction r (Value Word8)
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsInteger b, ShapeOf a ~ ShapeOf b,
 IsSized a, IsSized b, SizeOf a :<: SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.sext Value Bool
Repr Bool
b
      (StateT BytePtr (CodeGenFunction r) ()
 -> BytePtr -> CodeGenFunction r ())
-> BytePtr
-> StateT BytePtr (CodeGenFunction r) ()
-> CodeGenFunction r ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip StateT BytePtr (CodeGenFunction r) ()
-> BytePtr -> CodeGenFunction r ()
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT BytePtr
bytePtr (StateT BytePtr (CodeGenFunction r) () -> CodeGenFunction r ())
-> StateT BytePtr (CodeGenFunction r) () -> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$
         Int
-> StateT BytePtr (CodeGenFunction r) ()
-> StateT BytePtr (CodeGenFunction r) ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ (Bool -> Int
forall a. Storable a => a -> Int
Store.sizeOf (Bool
False :: Bool))
            (CodeGenFunction r () -> StateT BytePtr (CodeGenFunction r) ()
forall (m :: * -> *) a. Monad m => m a -> StateT BytePtr m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r () -> StateT BytePtr (CodeGenFunction r) ())
-> (BytePtr -> CodeGenFunction r ())
-> BytePtr
-> StateT BytePtr (CodeGenFunction r) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value Word8 -> BytePtr -> CodeGenFunction r ()
forall a r.
IsType a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
LLVM.store Value Word8
byte (BytePtr -> StateT BytePtr (CodeGenFunction r) ())
-> StateT BytePtr (CodeGenFunction r) BytePtr
-> StateT BytePtr (CodeGenFunction r) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< StateT BytePtr (CodeGenFunction r) BytePtr
forall r. StateT BytePtr (CodeGenFunction r) BytePtr
incPtrState)

instance C Bool8 where
   load :: forall r. Value (Ptr Bool8) -> CodeGenFunction r (T Bool8)
load Value (Ptr Bool8)
ptr =
      (Value Bool -> T Bool8)
-> CodeGenFunction r (Value Bool) -> CodeGenFunction r (T Bool8)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value Bool -> T Bool8
Repr Bool8 -> T Bool8
forall a. Repr a -> T a
MultiValue.Cons (CodeGenFunction r (Value Bool) -> CodeGenFunction r (T Bool8))
-> CodeGenFunction r (Value Bool) -> CodeGenFunction r (T Bool8)
forall a b. (a -> b) -> a -> b
$
      CmpPredicate
-> Value Word8 -> Value Word8 -> CodeGenFunction r (Value Bool)
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpNE (Word8 -> Value Word8
forall a. IsConst a => a -> Value a
LLVM.valueOf Word8
0) (Value Word8 -> CodeGenFunction r (Value Bool))
-> CodeGenFunction r (Value Word8)
-> CodeGenFunction r (Value Bool)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< BytePtr -> CodeGenFunction r (Value Word8)
forall a r.
IsType a =>
Value (Ptr a) -> CodeGenFunction r (Value a)
LLVM.load (BytePtr -> CodeGenFunction r (Value Word8))
-> CodeGenFunction r BytePtr -> CodeGenFunction r (Value Word8)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr Bool8) -> CodeGenFunction r BytePtr
forall a r. Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr Value (Ptr Bool8)
ptr
   store :: forall r. T Bool8 -> Value (Ptr Bool8) -> CodeGenFunction r ()
store (MultiValue.Cons Repr Bool8
b) Value (Ptr Bool8)
ptr = do
      Value Word8
byte <- Value Bool -> CodeGenFunction r (Value Word8)
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsInteger b, ShapeOf a ~ ShapeOf b,
 IsSized a, IsSized b, SizeOf a :<: SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.zext Value Bool
Repr Bool8
b
      Value Word8 -> BytePtr -> CodeGenFunction r ()
forall a r.
IsType a =>
Value a -> Value (Ptr a) -> CodeGenFunction r ()
LLVM.store Value Word8
byte (BytePtr -> CodeGenFunction r ())
-> CodeGenFunction r BytePtr -> CodeGenFunction r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr Bool8) -> CodeGenFunction r BytePtr
forall a r. Value (Ptr a) -> CodeGenFunction r BytePtr
castToBytePtr Value (Ptr Bool8)
ptr

instance (C a) => C (Complex a) where
   load :: forall r.
Value (Ptr (Complex a)) -> CodeGenFunction r (T (Complex a))
load = Value (Ptr (Complex a)) -> CodeGenFunction r (T (Complex a))
forall (f :: * -> *) a fa r.
(Applicative f, Traversable f, C a, Repr fa ~ f (Repr a)) =>
Value (Ptr (f a)) -> CodeGenFunction r (T fa)
loadApplicative; store :: forall r.
T (Complex a) -> Value (Ptr (Complex a)) -> CodeGenFunction r ()
store = T (Complex a) -> Value (Ptr (Complex a)) -> CodeGenFunction r ()
forall (f :: * -> *) a fa r.
(Foldable f, C a, Repr fa ~ f (Repr a)) =>
T fa -> Value (Ptr (f a)) -> CodeGenFunction r ()
storeFoldable



instance (Tuple tuple) => C (StoreTuple.Tuple tuple) where
   load :: forall r.
Value (Ptr (Tuple tuple)) -> CodeGenFunction r (T (Tuple tuple))
load Value (Ptr (Tuple tuple))
ptr = T tuple -> T (Tuple tuple)
forall tuple. T tuple -> T (Tuple tuple)
MultiValue.tuple (T tuple -> T (Tuple tuple))
-> CodeGenFunction r (T tuple)
-> CodeGenFunction r (T (Tuple tuple))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value (Ptr (Tuple tuple)) -> CodeGenFunction r (T tuple)
forall r. Value (Ptr (Tuple tuple)) -> CodeGenFunction r (T tuple)
forall tuple r.
Tuple tuple =>
Value (Ptr (Tuple tuple)) -> CodeGenFunction r (T tuple)
loadTuple Value (Ptr (Tuple tuple))
ptr
   store :: forall r.
T (Tuple tuple)
-> Value (Ptr (Tuple tuple)) -> CodeGenFunction r ()
store = T tuple -> Value (Ptr (Tuple tuple)) -> CodeGenFunction r ()
forall r.
T tuple -> Value (Ptr (Tuple tuple)) -> CodeGenFunction r ()
forall tuple r.
Tuple tuple =>
T tuple -> Value (Ptr (Tuple tuple)) -> CodeGenFunction r ()
storeTuple (T tuple -> Value (Ptr (Tuple tuple)) -> CodeGenFunction r ())
-> (T (Tuple tuple) -> T tuple)
-> T (Tuple tuple)
-> Value (Ptr (Tuple tuple))
-> CodeGenFunction r ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T (Tuple tuple) -> T tuple
forall tuple. T (Tuple tuple) -> T tuple
MultiValue.untuple

class (StoreTuple.Storable tuple, MultiValue.C tuple) => Tuple tuple where
   loadTuple ::
      Value (Ptr (StoreTuple.Tuple tuple)) ->
      CodeGenFunction r (MultiValue.T tuple)
   storeTuple ::
      MultiValue.T tuple ->
      Value (Ptr (StoreTuple.Tuple tuple)) ->
      CodeGenFunction r ()

instance (C a, C b) => Tuple (a,b) where
   loadTuple :: forall r.
Value (Ptr (Tuple (a, b))) -> CodeGenFunction r (T (a, b))
loadTuple Value (Ptr (Tuple (a, b)))
ptr =
      Value (Ptr (Tuple (a, b)))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b))
-> CodeGenFunction r (T (a, b))
forall a r c.
Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
-> CodeGenFunction r c
runElements Value (Ptr (Tuple (a, b)))
ptr (ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b))
 -> CodeGenFunction r (T (a, b)))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b))
-> CodeGenFunction r (T (a, b))
forall a b. (a -> b) -> a -> b
$ ((T a, T b) -> T (a, b))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a, T b)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b))
forall a b.
(a -> b)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((T a -> T b -> T (a, b)) -> (T a, T b) -> T (a, b)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry T a -> T b -> T (a, b)
forall a b. T a -> T b -> T (a, b)
MultiValue.zip) (ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a, T b)
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b)))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a, T b)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b))
forall a b. (a -> b) -> a -> b
$
         (Proxy a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a),
 Proxy b -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T b))
-> (Proxy a, Proxy b)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a, T b)
forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c, b -> f d) -> (a, b) -> f (c, d)
App.mapPair (Proxy a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a)
forall a r.
C a =>
Proxy a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a)
loadElement, Proxy b -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T b)
forall a r.
C a =>
Proxy a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a)
loadElement) ((Proxy a, Proxy b)
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a, T b))
-> (Proxy a, Proxy b)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a, T b)
forall a b. (a -> b) -> a -> b
$
         Proxy (a, b) -> (Proxy a, Proxy b)
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
FuncHT.unzip (Proxy (a, b) -> (Proxy a, Proxy b))
-> Proxy (a, b) -> (Proxy a, Proxy b)
forall a b. (a -> b) -> a -> b
$ Value (Ptr (Tuple (a, b))) -> Proxy (a, b)
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Tuple (a, b)))
ptr
   storeTuple :: forall r.
T (a, b) -> Value (Ptr (Tuple (a, b))) -> CodeGenFunction r ()
storeTuple = (T a -> T b -> Value (Ptr (Tuple (a, b))) -> CodeGenFunction r ())
-> T (a, b) -> Value (Ptr (Tuple (a, b))) -> CodeGenFunction r ()
forall a b c. (T a -> T b -> c) -> T (a, b) -> c
MultiValue.uncurry ((T a -> T b -> Value (Ptr (Tuple (a, b))) -> CodeGenFunction r ())
 -> T (a, b) -> Value (Ptr (Tuple (a, b))) -> CodeGenFunction r ())
-> (T a
    -> T b -> Value (Ptr (Tuple (a, b))) -> CodeGenFunction r ())
-> T (a, b)
-> Value (Ptr (Tuple (a, b)))
-> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$ \T a
a T b
b Value (Ptr (Tuple (a, b)))
ptr ->
      case Proxy (a, b) -> (Proxy a, Proxy b)
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
FuncHT.unzip (Proxy (a, b) -> (Proxy a, Proxy b))
-> Proxy (a, b) -> (Proxy a, Proxy b)
forall a b. (a -> b) -> a -> b
$ Value (Ptr (Tuple (a, b))) -> Proxy (a, b)
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Tuple (a, b)))
ptr of
         (Proxy a
pa,Proxy b
pb) -> Value (Ptr (Tuple (a, b)))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> CodeGenFunction r ()
forall a r c.
Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
-> CodeGenFunction r c
runElements Value (Ptr (Tuple (a, b)))
ptr (ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
 -> CodeGenFunction r ())
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$ Proxy a
-> T a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a r.
C a =>
Proxy a
-> T a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy a
pa T a
a ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a b.
ReaderT BytePtr (StateT Int (CodeGenFunction r)) a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Proxy b
-> T b -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a r.
C a =>
Proxy a
-> T a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy b
pb T b
b

instance (C a, C b, C c) => Tuple (a,b,c) where
   loadTuple :: forall r.
Value (Ptr (Tuple (a, b, c))) -> CodeGenFunction r (T (a, b, c))
loadTuple Value (Ptr (Tuple (a, b, c)))
ptr =
      Value (Ptr (Tuple (a, b, c)))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b, c))
-> CodeGenFunction r (T (a, b, c))
forall a r c.
Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
-> CodeGenFunction r c
runElements Value (Ptr (Tuple (a, b, c)))
ptr (ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b, c))
 -> CodeGenFunction r (T (a, b, c)))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b, c))
-> CodeGenFunction r (T (a, b, c))
forall a b. (a -> b) -> a -> b
$ ((T a, T b, T c) -> T (a, b, c))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a, T b, T c)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b, c))
forall a b.
(a -> b)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((T a -> T b -> T c -> T (a, b, c))
-> (T a, T b, T c) -> T (a, b, c)
forall a b c d. (a -> b -> c -> d) -> (a, b, c) -> d
uncurry3 T a -> T b -> T c -> T (a, b, c)
forall a b c. T a -> T b -> T c -> T (a, b, c)
MultiValue.zip3) (ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a, T b, T c)
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b, c)))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a, T b, T c)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T (a, b, c))
forall a b. (a -> b) -> a -> b
$
         (Proxy a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a),
 Proxy b -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T b),
 Proxy c -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T c))
-> (Proxy a, Proxy b, Proxy c)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a, T b, T c)
forall (m :: * -> *) a d b e c f.
Applicative m =>
(a -> m d, b -> m e, c -> m f) -> (a, b, c) -> m (d, e, f)
App.mapTriple (Proxy a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a)
forall a r.
C a =>
Proxy a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a)
loadElement, Proxy b -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T b)
forall a r.
C a =>
Proxy a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a)
loadElement, Proxy c -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T c)
forall a r.
C a =>
Proxy a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a)
loadElement) ((Proxy a, Proxy b, Proxy c)
 -> ReaderT
      BytePtr (StateT Int (CodeGenFunction r)) (T a, T b, T c))
-> (Proxy a, Proxy b, Proxy c)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a, T b, T c)
forall a b. (a -> b) -> a -> b
$
         Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c)
forall (f :: * -> *) a b c.
Functor f =>
f (a, b, c) -> (f a, f b, f c)
FuncHT.unzip3 (Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c))
-> Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c)
forall a b. (a -> b) -> a -> b
$ Value (Ptr (Tuple (a, b, c))) -> Proxy (a, b, c)
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Tuple (a, b, c)))
ptr
   storeTuple :: forall r.
T (a, b, c)
-> Value (Ptr (Tuple (a, b, c))) -> CodeGenFunction r ()
storeTuple = (T a
 -> T b
 -> T c
 -> Value (Ptr (Tuple (a, b, c)))
 -> CodeGenFunction r ())
-> T (a, b, c)
-> Value (Ptr (Tuple (a, b, c)))
-> CodeGenFunction r ()
forall a b c d. (T a -> T b -> T c -> d) -> T (a, b, c) -> d
MultiValue.uncurry3 ((T a
  -> T b
  -> T c
  -> Value (Ptr (Tuple (a, b, c)))
  -> CodeGenFunction r ())
 -> T (a, b, c)
 -> Value (Ptr (Tuple (a, b, c)))
 -> CodeGenFunction r ())
-> (T a
    -> T b
    -> T c
    -> Value (Ptr (Tuple (a, b, c)))
    -> CodeGenFunction r ())
-> T (a, b, c)
-> Value (Ptr (Tuple (a, b, c)))
-> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$ \T a
a T b
b T c
c Value (Ptr (Tuple (a, b, c)))
ptr ->
      case Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c)
forall (f :: * -> *) a b c.
Functor f =>
f (a, b, c) -> (f a, f b, f c)
FuncHT.unzip3 (Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c))
-> Proxy (a, b, c) -> (Proxy a, Proxy b, Proxy c)
forall a b. (a -> b) -> a -> b
$ Value (Ptr (Tuple (a, b, c))) -> Proxy (a, b, c)
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Tuple (a, b, c)))
ptr of
         (Proxy a
pa,Proxy b
pb,Proxy c
pc) ->
            Value (Ptr (Tuple (a, b, c)))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> CodeGenFunction r ()
forall a r c.
Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) c
-> CodeGenFunction r c
runElements Value (Ptr (Tuple (a, b, c)))
ptr (ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
 -> CodeGenFunction r ())
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$
               Proxy a
-> T a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a r.
C a =>
Proxy a
-> T a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy a
pa T a
a ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a b.
ReaderT BytePtr (StateT Int (CodeGenFunction r)) a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Proxy b
-> T b -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a r.
C a =>
Proxy a
-> T a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy b
pb T b
b ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a b.
ReaderT BytePtr (StateT Int (CodeGenFunction r)) a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Proxy c
-> T c -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall a r.
C a =>
Proxy a
-> T a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy c
pc T c
c

loadElement ::
   (C a) =>
   LP.Proxy a ->
   MR.ReaderT BytePtr (MS.StateT Int (CodeGenFunction r)) (MultiValue.T a)
loadElement :: forall a r.
C a =>
Proxy a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a)
loadElement Proxy a
proxy =
   StateT Int (CodeGenFunction r) (T a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a)
forall (m :: * -> *) a. Monad m => m a -> ReaderT BytePtr m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (StateT Int (CodeGenFunction r) (T a)
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a))
-> (Value (Ptr a) -> StateT Int (CodeGenFunction r) (T a))
-> Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CodeGenFunction r (T a) -> StateT Int (CodeGenFunction r) (T a)
forall (m :: * -> *) a. Monad m => m a -> StateT Int m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r (T a) -> StateT Int (CodeGenFunction r) (T a))
-> (Value (Ptr a) -> CodeGenFunction r (T a))
-> Value (Ptr a)
-> StateT Int (CodeGenFunction r) (T a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value (Ptr a) -> CodeGenFunction r (T a)
forall r. Value (Ptr a) -> CodeGenFunction r (T a)
forall a r. C a => Value (Ptr a) -> CodeGenFunction r (T a)
load (Value (Ptr a)
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (T a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
elementPtr Proxy a
proxy

storeElement ::
   (C a) =>
   LP.Proxy a -> MultiValue.T a ->
   MR.ReaderT BytePtr (MS.StateT Int (CodeGenFunction r)) ()
storeElement :: forall a r.
C a =>
Proxy a
-> T a -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
storeElement Proxy a
proxy T a
a =
   StateT Int (CodeGenFunction r) ()
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall (m :: * -> *) a. Monad m => m a -> ReaderT BytePtr m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (StateT Int (CodeGenFunction r) ()
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ())
-> (Value (Ptr a) -> StateT Int (CodeGenFunction r) ())
-> Value (Ptr a)
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CodeGenFunction r () -> StateT Int (CodeGenFunction r) ()
forall (m :: * -> *) a. Monad m => m a -> StateT Int m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r () -> StateT Int (CodeGenFunction r) ())
-> (Value (Ptr a) -> CodeGenFunction r ())
-> Value (Ptr a)
-> StateT Int (CodeGenFunction r) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T a -> Value (Ptr a) -> CodeGenFunction r ()
forall r. T a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r. C a => T a -> Value (Ptr a) -> CodeGenFunction r ()
store T a
a (Value (Ptr a)
 -> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ())
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
elementPtr Proxy a
proxy

elementPtr ::
   (C a) =>
   LP.Proxy a ->
   MR.ReaderT BytePtr
      (MS.StateT Int (CodeGenFunction r)) (LLVM.Value (Ptr a))
elementPtr :: forall a r.
C a =>
Proxy a
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
elementPtr Proxy a
proxy = do
   BytePtr
ptr <- ReaderT BytePtr (StateT Int (CodeGenFunction r)) BytePtr
forall (m :: * -> *) r. Monad m => ReaderT r m r
MR.ask
   StateT Int (CodeGenFunction r) (Value (Ptr a))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
forall (m :: * -> *) a. Monad m => m a -> ReaderT BytePtr m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (StateT Int (CodeGenFunction r) (Value (Ptr a))
 -> ReaderT
      BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a)))
-> StateT Int (CodeGenFunction r) (Value (Ptr a))
-> ReaderT BytePtr (StateT Int (CodeGenFunction r)) (Value (Ptr a))
forall a b. (a -> b) -> a -> b
$ do
      Int
offset <- Proxy a -> StateT Int (CodeGenFunction r) Int
forall (m :: * -> *) a.
(Monad m, Storable a) =>
Proxy a -> StateT Int m Int
elementOffset Proxy a
proxy
      CodeGenFunction r (Value (Ptr a))
-> StateT Int (CodeGenFunction r) (Value (Ptr a))
forall (m :: * -> *) a. Monad m => m a -> StateT Int m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r (Value (Ptr a))
 -> StateT Int (CodeGenFunction r) (Value (Ptr a)))
-> CodeGenFunction r (Value (Ptr a))
-> StateT Int (CodeGenFunction r) (Value (Ptr a))
forall a b. (a -> b) -> a -> b
$ BytePtr -> CodeGenFunction r (Value (Ptr a))
forall r a. BytePtr -> CodeGenFunction r (Value (Ptr a))
castFromBytePtr (BytePtr -> CodeGenFunction r (Value (Ptr a)))
-> CodeGenFunction r BytePtr -> CodeGenFunction r (Value (Ptr a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< BytePtr
-> (Int, ())
-> CodeGenFunction r (Value (Ptr (ElementPtrType Word8 ())))
forall a o i r.
(GetElementPtr o i, IsType o, IsIndexArg a) =>
Value (Ptr o)
-> (a, i) -> CodeGenFunction r (Value (Ptr (ElementPtrType o i)))
LLVM.getElementPtr BytePtr
ptr (Int
offset, ())


instance
   (TypeNum.Positive n, Vector a) =>
      C (LLVM.Vector n a) where
   load :: forall r.
Value (Ptr (Vector n a)) -> CodeGenFunction r (T (Vector n a))
load Value (Ptr (Vector n a))
ptr =
      (Repr n a -> T (Vector n a))
-> CodeGenFunction r (Repr n a)
-> CodeGenFunction r (T (Vector n a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Repr (Vector n a) -> T (Vector n a)
Repr n a -> T (Vector n a)
forall a. Repr a -> T a
MultiValue.Cons (CodeGenFunction r (Repr n a)
 -> CodeGenFunction r (T (Vector n a)))
-> CodeGenFunction r (Repr n a)
-> CodeGenFunction r (T (Vector n a))
forall a b. (a -> b) -> a -> b
$
      Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
forall n r.
Positive n =>
Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
assembleVector (Value (Ptr (Vector n a)) -> Proxy a
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Vector n a))
ptr) (Vector n (Repr a) -> CodeGenFunction r (Repr n a))
-> CodeGenFunction r (Vector n (Repr a))
-> CodeGenFunction r (Repr n a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Ptr (Vector n a)) -> CodeGenFunction r (Vector n (Repr a))
forall (f :: * -> *) a r.
(Applicative f, Traversable f, C a) =>
Value (Ptr (f a)) -> CodeGenFunction r (f (Repr a))
loadApplicativeRepr Value (Ptr (Vector n a))
ptr
   store :: forall r.
T (Vector n a) -> Value (Ptr (Vector n a)) -> CodeGenFunction r ()
store (MultiValue.Cons Repr (Vector n a)
a) Value (Ptr (Vector n a))
ptr =
      (Vector n (Repr a)
 -> Value (Ptr (Vector n a)) -> CodeGenFunction r ())
-> Value (Ptr (Vector n a))
-> Vector n (Repr a)
-> CodeGenFunction r ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip Vector n (Repr a)
-> Value (Ptr (Vector n a)) -> CodeGenFunction r ()
forall (f :: * -> *) a r.
(Foldable f, C a) =>
f (Repr a) -> Value (Ptr (f a)) -> CodeGenFunction r ()
storeFoldableRepr Value (Ptr (Vector n a))
ptr
         (Vector n (Repr a) -> CodeGenFunction r ())
-> CodeGenFunction r (Vector n (Repr a)) -> CodeGenFunction r ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
forall n r.
Positive n =>
Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
disassembleVector (Value (Ptr (Vector n a)) -> Proxy a
forall (f :: * -> *) (g :: * -> *) (h :: * -> *) a.
f (g (h a)) -> Proxy a
proxyFromElement3 Value (Ptr (Vector n a))
ptr) Repr (Vector n a)
Repr n a
a

class (C a, MultiVector.C a) => Vector a where
   assembleVector ::
      (TypeNum.Positive n) =>
      LP.Proxy a -> LLVM.Vector n (MultiValue.Repr a) ->
      CodeGenFunction r (MultiVector.Repr n a)
   disassembleVector ::
      (TypeNum.Positive n) =>
      LP.Proxy a -> MultiVector.Repr n a ->
      CodeGenFunction r (LLVM.Vector n (MultiValue.Repr a))

instance Vector Float where
   assembleVector :: forall n r.
Positive n =>
Proxy Float
-> Vector n (Repr Float) -> CodeGenFunction r (Repr n Float)
assembleVector Proxy Float
LP.Proxy = Vector n (Value Float)
-> CodeGenFunction r (Value (Vector n Float))
Vector n (Repr Float) -> CodeGenFunction r (Repr n Float)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Float
-> Repr n Float -> CodeGenFunction r (Vector n (Repr Float))
disassembleVector Proxy Float
LP.Proxy = Value (Vector n Float)
-> CodeGenFunction r (Vector n (Value Float))
Repr n Float -> CodeGenFunction r (Vector n (Repr Float))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Double where
   assembleVector :: forall n r.
Positive n =>
Proxy Double
-> Vector n (Repr Double) -> CodeGenFunction r (Repr n Double)
assembleVector Proxy Double
LP.Proxy = Vector n (Value Double)
-> CodeGenFunction r (Value (Vector n Double))
Vector n (Repr Double) -> CodeGenFunction r (Repr n Double)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Double
-> Repr n Double -> CodeGenFunction r (Vector n (Repr Double))
disassembleVector Proxy Double
LP.Proxy = Value (Vector n Double)
-> CodeGenFunction r (Vector n (Value Double))
Repr n Double -> CodeGenFunction r (Vector n (Repr Double))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Word where
   assembleVector :: forall n r.
Positive n =>
Proxy Word
-> Vector n (Repr Word) -> CodeGenFunction r (Repr n Word)
assembleVector Proxy Word
LP.Proxy = Vector n (Value Word) -> CodeGenFunction r (Value (Vector n Word))
Vector n (Repr Word) -> CodeGenFunction r (Repr n Word)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Word
-> Repr n Word -> CodeGenFunction r (Vector n (Repr Word))
disassembleVector Proxy Word
LP.Proxy = Value (Vector n Word) -> CodeGenFunction r (Vector n (Value Word))
Repr n Word -> CodeGenFunction r (Vector n (Repr Word))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Word8 where
   assembleVector :: forall n r.
Positive n =>
Proxy Word8
-> Vector n (Repr Word8) -> CodeGenFunction r (Repr n Word8)
assembleVector Proxy Word8
LP.Proxy = Vector n (Value Word8)
-> CodeGenFunction r (Value (Vector n Word8))
Vector n (Repr Word8) -> CodeGenFunction r (Repr n Word8)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Word8
-> Repr n Word8 -> CodeGenFunction r (Vector n (Repr Word8))
disassembleVector Proxy Word8
LP.Proxy = Value (Vector n Word8)
-> CodeGenFunction r (Vector n (Value Word8))
Repr n Word8 -> CodeGenFunction r (Vector n (Repr Word8))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Word16 where
   assembleVector :: forall n r.
Positive n =>
Proxy Word16
-> Vector n (Repr Word16) -> CodeGenFunction r (Repr n Word16)
assembleVector Proxy Word16
LP.Proxy = Vector n (Value Word16)
-> CodeGenFunction r (Value (Vector n Word16))
Vector n (Repr Word16) -> CodeGenFunction r (Repr n Word16)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Word16
-> Repr n Word16 -> CodeGenFunction r (Vector n (Repr Word16))
disassembleVector Proxy Word16
LP.Proxy = Value (Vector n Word16)
-> CodeGenFunction r (Vector n (Value Word16))
Repr n Word16 -> CodeGenFunction r (Vector n (Repr Word16))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Word32 where
   assembleVector :: forall n r.
Positive n =>
Proxy Word32
-> Vector n (Repr Word32) -> CodeGenFunction r (Repr n Word32)
assembleVector Proxy Word32
LP.Proxy = Vector n (Value Word32)
-> CodeGenFunction r (Value (Vector n Word32))
Vector n (Repr Word32) -> CodeGenFunction r (Repr n Word32)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Word32
-> Repr n Word32 -> CodeGenFunction r (Vector n (Repr Word32))
disassembleVector Proxy Word32
LP.Proxy = Value (Vector n Word32)
-> CodeGenFunction r (Vector n (Value Word32))
Repr n Word32 -> CodeGenFunction r (Vector n (Repr Word32))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Word64 where
   assembleVector :: forall n r.
Positive n =>
Proxy Word64
-> Vector n (Repr Word64) -> CodeGenFunction r (Repr n Word64)
assembleVector Proxy Word64
LP.Proxy = Vector n (Value Word64)
-> CodeGenFunction r (Value (Vector n Word64))
Vector n (Repr Word64) -> CodeGenFunction r (Repr n Word64)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Word64
-> Repr n Word64 -> CodeGenFunction r (Vector n (Repr Word64))
disassembleVector Proxy Word64
LP.Proxy = Value (Vector n Word64)
-> CodeGenFunction r (Vector n (Value Word64))
Repr n Word64 -> CodeGenFunction r (Vector n (Repr Word64))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Int where
   assembleVector :: forall n r.
Positive n =>
Proxy Int -> Vector n (Repr Int) -> CodeGenFunction r (Repr n Int)
assembleVector Proxy Int
LP.Proxy = Vector n (Value Int) -> CodeGenFunction r (Value (Vector n Int))
Vector n (Repr Int) -> CodeGenFunction r (Repr n Int)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Int -> Repr n Int -> CodeGenFunction r (Vector n (Repr Int))
disassembleVector Proxy Int
LP.Proxy = Value (Vector n Int) -> CodeGenFunction r (Vector n (Value Int))
Repr n Int -> CodeGenFunction r (Vector n (Repr Int))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Int8 where
   assembleVector :: forall n r.
Positive n =>
Proxy Int8
-> Vector n (Repr Int8) -> CodeGenFunction r (Repr n Int8)
assembleVector Proxy Int8
LP.Proxy = Vector n (Value Int8) -> CodeGenFunction r (Value (Vector n Int8))
Vector n (Repr Int8) -> CodeGenFunction r (Repr n Int8)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Int8
-> Repr n Int8 -> CodeGenFunction r (Vector n (Repr Int8))
disassembleVector Proxy Int8
LP.Proxy = Value (Vector n Int8) -> CodeGenFunction r (Vector n (Value Int8))
Repr n Int8 -> CodeGenFunction r (Vector n (Repr Int8))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Int16 where
   assembleVector :: forall n r.
Positive n =>
Proxy Int16
-> Vector n (Repr Int16) -> CodeGenFunction r (Repr n Int16)
assembleVector Proxy Int16
LP.Proxy = Vector n (Value Int16)
-> CodeGenFunction r (Value (Vector n Int16))
Vector n (Repr Int16) -> CodeGenFunction r (Repr n Int16)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Int16
-> Repr n Int16 -> CodeGenFunction r (Vector n (Repr Int16))
disassembleVector Proxy Int16
LP.Proxy = Value (Vector n Int16)
-> CodeGenFunction r (Vector n (Value Int16))
Repr n Int16 -> CodeGenFunction r (Vector n (Repr Int16))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Int32 where
   assembleVector :: forall n r.
Positive n =>
Proxy Int32
-> Vector n (Repr Int32) -> CodeGenFunction r (Repr n Int32)
assembleVector Proxy Int32
LP.Proxy = Vector n (Value Int32)
-> CodeGenFunction r (Value (Vector n Int32))
Vector n (Repr Int32) -> CodeGenFunction r (Repr n Int32)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Int32
-> Repr n Int32 -> CodeGenFunction r (Vector n (Repr Int32))
disassembleVector Proxy Int32
LP.Proxy = Value (Vector n Int32)
-> CodeGenFunction r (Vector n (Value Int32))
Repr n Int32 -> CodeGenFunction r (Vector n (Repr Int32))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Int64 where
   assembleVector :: forall n r.
Positive n =>
Proxy Int64
-> Vector n (Repr Int64) -> CodeGenFunction r (Repr n Int64)
assembleVector Proxy Int64
LP.Proxy = Vector n (Value Int64)
-> CodeGenFunction r (Value (Vector n Int64))
Vector n (Repr Int64) -> CodeGenFunction r (Repr n Int64)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Int64
-> Repr n Int64 -> CodeGenFunction r (Vector n (Repr Int64))
disassembleVector Proxy Int64
LP.Proxy = Value (Vector n Int64)
-> CodeGenFunction r (Vector n (Value Int64))
Repr n Int64 -> CodeGenFunction r (Vector n (Repr Int64))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Bool where
   assembleVector :: forall n r.
Positive n =>
Proxy Bool
-> Vector n (Repr Bool) -> CodeGenFunction r (Repr n Bool)
assembleVector Proxy Bool
LP.Proxy = Vector n (Value Bool) -> CodeGenFunction r (Value (Vector n Bool))
Vector n (Repr Bool) -> CodeGenFunction r (Repr n Bool)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Bool
-> Repr n Bool -> CodeGenFunction r (Vector n (Repr Bool))
disassembleVector Proxy Bool
LP.Proxy = Value (Vector n Bool) -> CodeGenFunction r (Vector n (Value Bool))
Repr n Bool -> CodeGenFunction r (Vector n (Repr Bool))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive

instance Vector Bool8 where
   assembleVector :: forall n r.
Positive n =>
Proxy Bool8
-> Vector n (Repr Bool8) -> CodeGenFunction r (Repr n Bool8)
assembleVector Proxy Bool8
LP.Proxy = Vector n (Value Bool) -> CodeGenFunction r (Value (Vector n Bool))
Vector n (Repr Bool8) -> CodeGenFunction r (Repr n Bool8)
forall n a r.
(Positive n, IsPrimitive a) =>
Vector n (Value a) -> CodeGenFunction r (Value (Vector n a))
assemblePrimitive
   disassembleVector :: forall n r.
Positive n =>
Proxy Bool8
-> Repr n Bool8 -> CodeGenFunction r (Vector n (Repr Bool8))
disassembleVector Proxy Bool8
LP.Proxy = Value (Vector n Bool) -> CodeGenFunction r (Vector n (Value Bool))
Repr n Bool8 -> CodeGenFunction r (Vector n (Repr Bool8))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Vector n (Value a))
disassemblePrimitive


instance
   (Tuple tuple, TupleVector tuple) =>
      Vector (StoreTuple.Tuple tuple) where
   assembleVector :: forall n r.
Positive n =>
Proxy (Tuple tuple)
-> Vector n (Repr (Tuple tuple))
-> CodeGenFunction r (Repr n (Tuple tuple))
assembleVector = Proxy tuple
-> Vector n (Repr tuple) -> CodeGenFunction r (Repr n tuple)
forall a n r.
(TupleVector a, Positive n) =>
Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
forall n r.
Positive n =>
Proxy tuple
-> Vector n (Repr tuple) -> CodeGenFunction r (Repr n tuple)
deinterleave (Proxy tuple
 -> Vector n (Repr tuple) -> CodeGenFunction r (Repr n tuple))
-> (Proxy (Tuple tuple) -> Proxy tuple)
-> Proxy (Tuple tuple)
-> Vector n (Repr tuple)
-> CodeGenFunction r (Repr n tuple)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Tuple tuple -> tuple) -> Proxy (Tuple tuple) -> Proxy tuple
forall a b. (a -> b) -> Proxy a -> Proxy b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Tuple tuple -> tuple
forall a. Tuple a -> a
StoreTuple.getTuple
   disassembleVector :: forall n r.
Positive n =>
Proxy (Tuple tuple)
-> Repr n (Tuple tuple)
-> CodeGenFunction r (Vector n (Repr (Tuple tuple)))
disassembleVector = Proxy tuple
-> Repr n tuple -> CodeGenFunction r (Vector n (Repr tuple))
forall a n r.
(TupleVector a, Positive n) =>
Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
forall n r.
Positive n =>
Proxy tuple
-> Repr n tuple -> CodeGenFunction r (Vector n (Repr tuple))
interleave (Proxy tuple
 -> Repr n tuple -> CodeGenFunction r (Vector n (Repr tuple)))
-> (Proxy (Tuple tuple) -> Proxy tuple)
-> Proxy (Tuple tuple)
-> Repr n tuple
-> CodeGenFunction r (Vector n (Repr tuple))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Tuple tuple -> tuple) -> Proxy (Tuple tuple) -> Proxy tuple
forall a b. (a -> b) -> Proxy a -> Proxy b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Tuple tuple -> tuple
forall a. Tuple a -> a
StoreTuple.getTuple


class (MultiVector.C a) => TupleVector a where
   deinterleave ::
      (TypeNum.Positive n) =>
      LP.Proxy a -> LLVM.Vector n (MultiValue.Repr a) ->
      CodeGenFunction r (MultiVector.Repr n a)
   interleave ::
      (TypeNum.Positive n) =>
      LP.Proxy a -> MultiVector.Repr n a ->
      CodeGenFunction r (LLVM.Vector n (MultiValue.Repr a))

instance (Vector a, Vector b) => TupleVector (a,b) where
   deinterleave :: forall n r.
Positive n =>
Proxy (a, b)
-> Vector n (Repr (a, b)) -> CodeGenFunction r (Repr n (a, b))
deinterleave = (Proxy a
 -> Proxy b
 -> Vector n (Repr (a, b))
 -> CodeGenFunction r (Repr n (a, b)))
-> Proxy (a, b)
-> Vector n (Repr (a, b))
-> CodeGenFunction r (Repr n (a, b))
forall (f :: * -> *) a b g.
Functor f =>
(f a -> f b -> g) -> f (a, b) -> g
FuncHT.uncurry ((Proxy a
  -> Proxy b
  -> Vector n (Repr (a, b))
  -> CodeGenFunction r (Repr n (a, b)))
 -> Proxy (a, b)
 -> Vector n (Repr (a, b))
 -> CodeGenFunction r (Repr n (a, b)))
-> (Proxy a
    -> Proxy b
    -> Vector n (Repr (a, b))
    -> CodeGenFunction r (Repr n (a, b)))
-> Proxy (a, b)
-> Vector n (Repr (a, b))
-> CodeGenFunction r (Repr n (a, b))
forall a b. (a -> b) -> a -> b
$ \Proxy a
pa Proxy b
pb -> (Vector n (Repr a)
 -> Vector n (Repr b) -> CodeGenFunction r (Repr n (a, b)))
-> Vector n (Repr a, Repr b) -> CodeGenFunction r (Repr n (a, b))
forall (f :: * -> *) a b g.
Functor f =>
(f a -> f b -> g) -> f (a, b) -> g
FuncHT.uncurry ((Vector n (Repr a)
  -> Vector n (Repr b) -> CodeGenFunction r (Repr n (a, b)))
 -> Vector n (Repr a, Repr b) -> CodeGenFunction r (Repr n (a, b)))
-> (Vector n (Repr a)
    -> Vector n (Repr b) -> CodeGenFunction r (Repr n (a, b)))
-> Vector n (Repr a, Repr b)
-> CodeGenFunction r (Repr n (a, b))
forall a b. (a -> b) -> a -> b
$ \Vector n (Repr a)
a Vector n (Repr b)
b ->
      (Repr n a -> Repr n b -> (Repr n a, Repr n b))
-> CodeGenFunction r (Repr n a)
-> CodeGenFunction r (Repr n b)
-> CodeGenFunction r (Repr n a, Repr n b)
forall (m :: * -> *) a b r.
Applicative m =>
(a -> b -> r) -> m a -> m b -> m r
App.lift2 (,) (Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
forall n r.
Positive n =>
Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
assembleVector Proxy a
pa Vector n (Repr a)
a) (Proxy b -> Vector n (Repr b) -> CodeGenFunction r (Repr n b)
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
forall n r.
Positive n =>
Proxy b -> Vector n (Repr b) -> CodeGenFunction r (Repr n b)
assembleVector Proxy b
pb Vector n (Repr b)
b)
   interleave :: forall n r.
Positive n =>
Proxy (a, b)
-> Repr n (a, b) -> CodeGenFunction r (Vector n (Repr (a, b)))
interleave = (Proxy a
 -> Proxy b
 -> Repr n (a, b)
 -> CodeGenFunction r (Vector n (Repr (a, b))))
-> Proxy (a, b)
-> Repr n (a, b)
-> CodeGenFunction r (Vector n (Repr (a, b)))
forall (f :: * -> *) a b g.
Functor f =>
(f a -> f b -> g) -> f (a, b) -> g
FuncHT.uncurry ((Proxy a
  -> Proxy b
  -> Repr n (a, b)
  -> CodeGenFunction r (Vector n (Repr (a, b))))
 -> Proxy (a, b)
 -> Repr n (a, b)
 -> CodeGenFunction r (Vector n (Repr (a, b))))
-> (Proxy a
    -> Proxy b
    -> Repr n (a, b)
    -> CodeGenFunction r (Vector n (Repr (a, b))))
-> Proxy (a, b)
-> Repr n (a, b)
-> CodeGenFunction r (Vector n (Repr (a, b)))
forall a b. (a -> b) -> a -> b
$ \Proxy a
pa Proxy b
pb (Repr n a
a,Repr n b
b) ->
      (Vector n (Repr a)
 -> Vector n (Repr b) -> Vector n (Repr a, Repr b))
-> CodeGenFunction r (Vector n (Repr a))
-> CodeGenFunction r (Vector n (Repr b))
-> CodeGenFunction r (Vector n (Repr a, Repr b))
forall (m :: * -> *) a b r.
Applicative m =>
(a -> b -> r) -> m a -> m b -> m r
App.lift2 ((Repr a -> Repr b -> (Repr a, Repr b))
-> Vector n (Repr a)
-> Vector n (Repr b)
-> Vector n (Repr a, Repr b)
forall (m :: * -> *) a b r.
Applicative m =>
(a -> b -> r) -> m a -> m b -> m r
App.lift2 (,))
         (Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
forall n r.
Positive n =>
Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
disassembleVector Proxy a
pa Repr n a
a) (Proxy b -> Repr n b -> CodeGenFunction r (Vector n (Repr b))
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
forall n r.
Positive n =>
Proxy b -> Repr n b -> CodeGenFunction r (Vector n (Repr b))
disassembleVector Proxy b
pb Repr n b
b)

instance (Vector a, Vector b, Vector c) => TupleVector (a,b,c) where
   deinterleave :: forall n r.
Positive n =>
Proxy (a, b, c)
-> Vector n (Repr (a, b, c))
-> CodeGenFunction r (Repr n (a, b, c))
deinterleave = (Proxy a
 -> Proxy b
 -> Proxy c
 -> Vector n (Repr (a, b, c))
 -> CodeGenFunction r (Repr n (a, b, c)))
-> Proxy (a, b, c)
-> Vector n (Repr (a, b, c))
-> CodeGenFunction r (Repr n (a, b, c))
forall (f :: * -> *) a b c g.
Functor f =>
(f a -> f b -> f c -> g) -> f (a, b, c) -> g
FuncHT.uncurry3 ((Proxy a
  -> Proxy b
  -> Proxy c
  -> Vector n (Repr (a, b, c))
  -> CodeGenFunction r (Repr n (a, b, c)))
 -> Proxy (a, b, c)
 -> Vector n (Repr (a, b, c))
 -> CodeGenFunction r (Repr n (a, b, c)))
-> (Proxy a
    -> Proxy b
    -> Proxy c
    -> Vector n (Repr (a, b, c))
    -> CodeGenFunction r (Repr n (a, b, c)))
-> Proxy (a, b, c)
-> Vector n (Repr (a, b, c))
-> CodeGenFunction r (Repr n (a, b, c))
forall a b. (a -> b) -> a -> b
$ \Proxy a
pa Proxy b
pb Proxy c
pc -> (Vector n (Repr a)
 -> Vector n (Repr b)
 -> Vector n (Repr c)
 -> CodeGenFunction r (Repr n (a, b, c)))
-> Vector n (Repr a, Repr b, Repr c)
-> CodeGenFunction r (Repr n (a, b, c))
forall (f :: * -> *) a b c g.
Functor f =>
(f a -> f b -> f c -> g) -> f (a, b, c) -> g
FuncHT.uncurry3 ((Vector n (Repr a)
  -> Vector n (Repr b)
  -> Vector n (Repr c)
  -> CodeGenFunction r (Repr n (a, b, c)))
 -> Vector n (Repr a, Repr b, Repr c)
 -> CodeGenFunction r (Repr n (a, b, c)))
-> (Vector n (Repr a)
    -> Vector n (Repr b)
    -> Vector n (Repr c)
    -> CodeGenFunction r (Repr n (a, b, c)))
-> Vector n (Repr a, Repr b, Repr c)
-> CodeGenFunction r (Repr n (a, b, c))
forall a b. (a -> b) -> a -> b
$ \Vector n (Repr a)
a Vector n (Repr b)
b Vector n (Repr c)
c ->
      (Repr n a
 -> Repr n b -> Repr n c -> (Repr n a, Repr n b, Repr n c))
-> CodeGenFunction r (Repr n a)
-> CodeGenFunction r (Repr n b)
-> CodeGenFunction r (Repr n c)
-> CodeGenFunction r (Repr n a, Repr n b, Repr n c)
forall (m :: * -> *) a b c r.
Applicative m =>
(a -> b -> c -> r) -> m a -> m b -> m c -> m r
App.lift3 (,,)
         (Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
forall n r.
Positive n =>
Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
assembleVector Proxy a
pa Vector n (Repr a)
a)
         (Proxy b -> Vector n (Repr b) -> CodeGenFunction r (Repr n b)
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
forall n r.
Positive n =>
Proxy b -> Vector n (Repr b) -> CodeGenFunction r (Repr n b)
assembleVector Proxy b
pb Vector n (Repr b)
b)
         (Proxy c -> Vector n (Repr c) -> CodeGenFunction r (Repr n c)
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Vector n (Repr a) -> CodeGenFunction r (Repr n a)
forall n r.
Positive n =>
Proxy c -> Vector n (Repr c) -> CodeGenFunction r (Repr n c)
assembleVector Proxy c
pc Vector n (Repr c)
c)
   interleave :: forall n r.
Positive n =>
Proxy (a, b, c)
-> Repr n (a, b, c)
-> CodeGenFunction r (Vector n (Repr (a, b, c)))
interleave = (Proxy a
 -> Proxy b
 -> Proxy c
 -> Repr n (a, b, c)
 -> CodeGenFunction r (Vector n (Repr (a, b, c))))
-> Proxy (a, b, c)
-> Repr n (a, b, c)
-> CodeGenFunction r (Vector n (Repr (a, b, c)))
forall (f :: * -> *) a b c g.
Functor f =>
(f a -> f b -> f c -> g) -> f (a, b, c) -> g
FuncHT.uncurry3 ((Proxy a
  -> Proxy b
  -> Proxy c
  -> Repr n (a, b, c)
  -> CodeGenFunction r (Vector n (Repr (a, b, c))))
 -> Proxy (a, b, c)
 -> Repr n (a, b, c)
 -> CodeGenFunction r (Vector n (Repr (a, b, c))))
-> (Proxy a
    -> Proxy b
    -> Proxy c
    -> Repr n (a, b, c)
    -> CodeGenFunction r (Vector n (Repr (a, b, c))))
-> Proxy (a, b, c)
-> Repr n (a, b, c)
-> CodeGenFunction r (Vector n (Repr (a, b, c)))
forall a b. (a -> b) -> a -> b
$ \Proxy a
pa Proxy b
pb Proxy c
pc (Repr n a
a,Repr n b
b,Repr n c
c) ->
      (Vector n (Repr a)
 -> Vector n (Repr b)
 -> Vector n (Repr c)
 -> Vector n (Repr a, Repr b, Repr c))
-> CodeGenFunction r (Vector n (Repr a))
-> CodeGenFunction r (Vector n (Repr b))
-> CodeGenFunction r (Vector n (Repr c))
-> CodeGenFunction r (Vector n (Repr a, Repr b, Repr c))
forall (m :: * -> *) a b c r.
Applicative m =>
(a -> b -> c -> r) -> m a -> m b -> m c -> m r
App.lift3 ((Repr a -> Repr b -> Repr c -> (Repr a, Repr b, Repr c))
-> Vector n (Repr a)
-> Vector n (Repr b)
-> Vector n (Repr c)
-> Vector n (Repr a, Repr b, Repr c)
forall (m :: * -> *) a b c r.
Applicative m =>
(a -> b -> c -> r) -> m a -> m b -> m c -> m r
App.lift3 (,,))
         (Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
forall n r.
Positive n =>
Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
disassembleVector Proxy a
pa Repr n a
a)
         (Proxy b -> Repr n b -> CodeGenFunction r (Vector n (Repr b))
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
forall n r.
Positive n =>
Proxy b -> Repr n b -> CodeGenFunction r (Vector n (Repr b))
disassembleVector Proxy b
pb Repr n b
b)
         (Proxy c -> Repr n c -> CodeGenFunction r (Vector n (Repr c))
forall a n r.
(Vector a, Positive n) =>
Proxy a -> Repr n a -> CodeGenFunction r (Vector n (Repr a))
forall n r.
Positive n =>
Proxy c -> Repr n c -> CodeGenFunction r (Vector n (Repr c))
disassembleVector Proxy c
pc Repr n c
c)


{-
instance Storable () available since base-4.9/GHC-8.0.
Before we need Data.Orphans.
-}
instance C () where
   load :: forall r. Value (Ptr ()) -> CodeGenFunction r (T ())
load Value (Ptr ())
_ptr = T () -> CodeGenFunction r (T ())
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (T () -> CodeGenFunction r (T ()))
-> T () -> CodeGenFunction r (T ())
forall a b. (a -> b) -> a -> b
$ Repr () -> T ()
forall a. Repr a -> T a
MultiValue.Cons ()
   store :: forall r. T () -> Value (Ptr ()) -> CodeGenFunction r ()
store (MultiValue.Cons ()) Value (Ptr ())
_ptr = () -> CodeGenFunction r ()
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


loadTraversable ::
   (NonEmptyC.Repeat f, Trav.Traversable f,
    C a, MultiValue.Repr fa ~ f (MultiValue.Repr a)) =>
   Value (Ptr (f a)) -> CodeGenFunction r (MultiValue.T fa)
loadTraversable :: forall (f :: * -> *) a fa r.
(Repeat f, Traversable f, C a, Repr fa ~ f (Repr a)) =>
Value (Ptr (f a)) -> CodeGenFunction r (T fa)
loadTraversable =
   (StateT (Value (Ptr a)) (CodeGenFunction r) (T fa)
-> Value (Ptr a) -> CodeGenFunction r (T fa)
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT (StateT (Value (Ptr a)) (CodeGenFunction r) (T fa)
 -> Value (Ptr a) -> CodeGenFunction r (T fa))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (T fa)
-> Value (Ptr a)
-> CodeGenFunction r (T fa)
forall a b. (a -> b) -> a -> b
$ (f (Repr a) -> T fa)
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (T fa)
forall a b.
(a -> b)
-> StateT (Value (Ptr a)) (CodeGenFunction r) a
-> StateT (Value (Ptr a)) (CodeGenFunction r) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f (Repr a) -> T fa
Repr fa -> T fa
forall a. Repr a -> T a
MultiValue.Cons (StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a))
 -> StateT (Value (Ptr a)) (CodeGenFunction r) (T fa))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (T fa)
forall a b. (a -> b) -> a -> b
$
    f (StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => f (m a) -> m (f a)
Trav.sequence (f (StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a))
 -> StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a)))
-> f (StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a))
forall a b. (a -> b) -> a -> b
$ StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a)
-> f (StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a))
forall a. a -> f a
forall (f :: * -> *) a. Repeat f => a -> f a
NonEmptyC.repeat (StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a)
 -> f (StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a)))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a)
-> f (StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a))
forall a b. (a -> b) -> a -> b
$ StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a)
forall a al r.
(C a, Repr a ~ al) =>
StateT (Value (Ptr a)) (CodeGenFunction r) al
loadState)
      (Value (Ptr a) -> CodeGenFunction r (T fa))
-> (Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a)))
-> Value (Ptr (f a))
-> CodeGenFunction r (T fa)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
forall (f :: * -> *) a r.
Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
castElementPtr

loadApplicative ::
   (Applicative f, Trav.Traversable f,
    C a, MultiValue.Repr fa ~ f (MultiValue.Repr a)) =>
   Value (Ptr (f a)) -> CodeGenFunction r (MultiValue.T fa)
loadApplicative :: forall (f :: * -> *) a fa r.
(Applicative f, Traversable f, C a, Repr fa ~ f (Repr a)) =>
Value (Ptr (f a)) -> CodeGenFunction r (T fa)
loadApplicative = (f (Repr a) -> T fa)
-> CodeGenFunction r (f (Repr a)) -> CodeGenFunction r (T fa)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f (Repr a) -> T fa
Repr fa -> T fa
forall a. Repr a -> T a
MultiValue.Cons (CodeGenFunction r (f (Repr a)) -> CodeGenFunction r (T fa))
-> (Value (Ptr (f a)) -> CodeGenFunction r (f (Repr a)))
-> Value (Ptr (f a))
-> CodeGenFunction r (T fa)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value (Ptr (f a)) -> CodeGenFunction r (f (Repr a))
forall (f :: * -> *) a r.
(Applicative f, Traversable f, C a) =>
Value (Ptr (f a)) -> CodeGenFunction r (f (Repr a))
loadApplicativeRepr

loadApplicativeRepr ::
   (Applicative f, Trav.Traversable f, C a) =>
   Value (Ptr (f a)) -> CodeGenFunction r (f (MultiValue.Repr a))
loadApplicativeRepr :: forall (f :: * -> *) a r.
(Applicative f, Traversable f, C a) =>
Value (Ptr (f a)) -> CodeGenFunction r (f (Repr a))
loadApplicativeRepr =
   (StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a))
-> Value (Ptr a) -> CodeGenFunction r (f (Repr a))
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT (StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a))
 -> Value (Ptr a) -> CodeGenFunction r (f (Repr a)))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a))
-> Value (Ptr a)
-> CodeGenFunction r (f (Repr a))
forall a b. (a -> b) -> a -> b
$ f (StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => f (m a) -> m (f a)
Trav.sequence (f (StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a))
 -> StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a)))
-> f (StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a))
-> StateT (Value (Ptr a)) (CodeGenFunction r) (f (Repr a))
forall a b. (a -> b) -> a -> b
$ StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a)
-> f (StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a))
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure StateT (Value (Ptr a)) (CodeGenFunction r) (Repr a)
forall a al r.
(C a, Repr a ~ al) =>
StateT (Value (Ptr a)) (CodeGenFunction r) al
loadState) (Value (Ptr a) -> CodeGenFunction r (f (Repr a)))
-> (Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a)))
-> Value (Ptr (f a))
-> CodeGenFunction r (f (Repr a))
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
forall (f :: * -> *) a r.
Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
castElementPtr

loadState ::
   (C a, MultiValue.Repr a ~ al) =>
   MS.StateT (Value (Ptr a)) (CodeGenFunction r) al
loadState :: forall a al r.
(C a, Repr a ~ al) =>
StateT (Value (Ptr a)) (CodeGenFunction r) al
loadState =
   CodeGenFunction r al
-> StateT (Value (Ptr a)) (CodeGenFunction r) al
forall (m :: * -> *) a.
Monad m =>
m a -> StateT (Value (Ptr a)) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r al
 -> StateT (Value (Ptr a)) (CodeGenFunction r) al)
-> (Value (Ptr a) -> CodeGenFunction r al)
-> Value (Ptr a)
-> StateT (Value (Ptr a)) (CodeGenFunction r) al
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T a -> al) -> CodeGenFunction r (T a) -> CodeGenFunction r al
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(MultiValue.Cons Repr a
a) -> al
Repr a
a) (CodeGenFunction r (T a) -> CodeGenFunction r al)
-> (Value (Ptr a) -> CodeGenFunction r (T a))
-> Value (Ptr a)
-> CodeGenFunction r al
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value (Ptr a) -> CodeGenFunction r (T a)
forall r. Value (Ptr a) -> CodeGenFunction r (T a)
forall a r. C a => Value (Ptr a) -> CodeGenFunction r (T a)
load (Value (Ptr a) -> StateT (Value (Ptr a)) (CodeGenFunction r) al)
-> StateT (Value (Ptr a)) (CodeGenFunction r) (Value (Ptr a))
-> StateT (Value (Ptr a)) (CodeGenFunction r) al
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< StateT (Value (Ptr a)) (CodeGenFunction r) (Value (Ptr a))
forall a ptr r.
(C a, Value (Ptr a) ~ ptr) =>
StateT ptr (CodeGenFunction r) ptr
advancePtrState


storeFoldable ::
   (Fold.Foldable f, C a, MultiValue.Repr fa ~ f (MultiValue.Repr a)) =>
    MultiValue.T fa -> Value (Ptr (f a)) -> CodeGenFunction r ()
storeFoldable :: forall (f :: * -> *) a fa r.
(Foldable f, C a, Repr fa ~ f (Repr a)) =>
T fa -> Value (Ptr (f a)) -> CodeGenFunction r ()
storeFoldable (MultiValue.Cons Repr fa
xs) = f (Repr a) -> Value (Ptr (f a)) -> CodeGenFunction r ()
forall (f :: * -> *) a r.
(Foldable f, C a) =>
f (Repr a) -> Value (Ptr (f a)) -> CodeGenFunction r ()
storeFoldableRepr f (Repr a)
Repr fa
xs

storeFoldableRepr ::
   (Fold.Foldable f, C a) =>
   f (MultiValue.Repr a) -> Value (Ptr (f a)) -> CodeGenFunction r ()
storeFoldableRepr :: forall (f :: * -> *) a r.
(Foldable f, C a) =>
f (Repr a) -> Value (Ptr (f a)) -> CodeGenFunction r ()
storeFoldableRepr f (Repr a)
xs =
   StateT (Value (Ptr a)) (CodeGenFunction r) ()
-> Value (Ptr a) -> CodeGenFunction r ()
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
MS.evalStateT ((Repr a -> StateT (Value (Ptr a)) (CodeGenFunction r) ())
-> f (Repr a) -> StateT (Value (Ptr a)) (CodeGenFunction r) ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
Fold.mapM_ Repr a -> StateT (Value (Ptr a)) (CodeGenFunction r) ()
forall a al r.
(C a, Repr a ~ al) =>
al -> StateT (Value (Ptr a)) (CodeGenFunction r) ()
storeState f (Repr a)
xs) (Value (Ptr a) -> CodeGenFunction r ())
-> (Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a)))
-> Value (Ptr (f a))
-> CodeGenFunction r ()
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
forall (f :: * -> *) a r.
Value (Ptr (f a)) -> CodeGenFunction r (Value (Ptr a))
castElementPtr

storeState ::
   (C a, MultiValue.Repr a ~ al) =>
   al -> MS.StateT (Value (Ptr a)) (CodeGenFunction r) ()
storeState :: forall a al r.
(C a, Repr a ~ al) =>
al -> StateT (Value (Ptr a)) (CodeGenFunction r) ()
storeState al
a = CodeGenFunction r ()
-> StateT (Value (Ptr a)) (CodeGenFunction r) ()
forall (m :: * -> *) a.
Monad m =>
m a -> StateT (Value (Ptr a)) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
MT.lift (CodeGenFunction r ()
 -> StateT (Value (Ptr a)) (CodeGenFunction r) ())
-> (Value (Ptr a) -> CodeGenFunction r ())
-> Value (Ptr a)
-> StateT (Value (Ptr a)) (CodeGenFunction r) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T a -> Value (Ptr a) -> CodeGenFunction r ()
forall r. T a -> Value (Ptr a) -> CodeGenFunction r ()
forall a r. C a => T a -> Value (Ptr a) -> CodeGenFunction r ()
store (Repr a -> T a
forall a. Repr a -> T a
MultiValue.Cons al
Repr a
a) (Value (Ptr a) -> StateT (Value (Ptr a)) (CodeGenFunction r) ())
-> StateT (Value (Ptr a)) (CodeGenFunction r) (Value (Ptr a))
-> StateT (Value (Ptr a)) (CodeGenFunction r) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< StateT (Value (Ptr a)) (CodeGenFunction r) (Value (Ptr a))
forall a ptr r.
(C a, Value (Ptr a) ~ ptr) =>
StateT ptr (CodeGenFunction r) ptr
advancePtrState


advancePtrState ::
   (C a, Value (Ptr a) ~ ptr) =>
   MS.StateT ptr (CodeGenFunction r) ptr
advancePtrState :: forall a ptr r.
(C a, Value (Ptr a) ~ ptr) =>
StateT ptr (CodeGenFunction r) ptr
advancePtrState = (ptr -> CodeGenFunction r ptr)
-> StateT ptr (CodeGenFunction r) ptr
forall (m :: * -> *) a. Monad m => (a -> m a) -> StateT a m a
update ((ptr -> CodeGenFunction r ptr)
 -> StateT ptr (CodeGenFunction r) ptr)
-> (ptr -> CodeGenFunction r ptr)
-> StateT ptr (CodeGenFunction r) ptr
forall a b. (a -> b) -> a -> b
$ Int -> ptr -> CodeGenFunction r ptr
forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
Int -> ptr -> CodeGenFunction r ptr
advancePtrStatic Int
1