{-|
Module      : Z.Data.Array.QQ
Description : Extra stuff for PrimArray related literals
Copyright   : (c) Dong Han, 2017-2018
License     : BSD
Maintainer  : winterland1989@gmail.com
Stability   : experimental
Portability : non-portable

This module provides functions for writing 'PrimArray' related literals 'QuasiQuote'.

@
> :set -XQuasiQuotes
> :t [arrASCII|asdfg|]
[arrASCII|asdfg|] :: PrimArray GHC.Word.Word8
> [arrASCII|asdfg|]
fromListN 5 [97,115,100,102,103]
> :t [arrI16|1,2,3,4,5|]
[arrI16|1,2,3,4,5|] :: PrimArray GHC.Int.Int16
> [arrI16|1,2,3,4,5|]
fromListN 5 [1,2,3,4,5]
@

-}

module Z.Data.Array.QQ
  ( -- * PrimArray literal quoters
    arrASCII
  , arrW8, arrW16, arrW32, arrW64, arrWord
  , arrI8, arrI16, arrI32, arrI64, arrInt
   -- * quoter helpers
  , asciiLiteral
  , utf8Literal
  , arrayLiteral
  , word8Literal
  , word16Literal
  , word32Literal
  , word64Literal
  , wordLiteral
  , int8Literal
  , int16Literal
  , int32Literal
  , int64Literal
  , intLiteral
  , word8ArrayFromAddr
  , word16ArrayFromAddr
  , word32ArrayFromAddr
  , word64ArrayFromAddr
  , wordArrayFromAddr
  , int8ArrayFromAddr
  , int16ArrayFromAddr
  , int32ArrayFromAddr
  , int64ArrayFromAddr
  , intArrayFromAddr
  ) where

#include "MachDeps.h"

import           Control.Monad
import           Data.Bits
import           Data.Char                 (ord)
import           Data.Primitive.PrimArray hiding (copyPtrToMutablePrimArray)
import           GHC.Exts
import           Data.Word
import           Data.Int
import           Language.Haskell.TH
import           Language.Haskell.TH.Quote
import           Z.Data.Array
import           Control.Monad.ST

-- $asciiLiteralExample
-- @
-- arrASCII :: QuasiQuoter
-- arrASCII = QuasiQuoter
--     (asciiLiteral $ \ len addr -> [| word8ArrayFromAddr $(len) $(addr) |])
--     ...
--
-- word8ArrayFromAddr :: Int -> Addr# -> PrimArray Word8
-- {-# INLINE word8ArrayFromAddr #-}
-- word8ArrayFromAddr l addr# = runST $ do
--     mba <- newPrimArray (I# l)
--     copyPtrToMutablePrimArray mba 0 (Ptr addr#) l
--     unsafeFreezePrimArray mba
-- @

-- | Construct data with ASCII encoded literals.
--
-- Provide a packing function, return a packing expression. Example usage:
--
-- $asciiLiteralExample
asciiLiteral :: (ExpQ -> ExpQ -> ExpQ) -- ^ Construction function which receive a byte
                                       --   length 'Int' and a 'Addr#' 'LitE' expression.
             -> String                 -- ^ Quoter input
             -> ExpQ                   -- ^ Final Quoter
asciiLiteral :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
asciiLiteral ExpQ -> ExpQ -> ExpQ
k [Char]
str = ExpQ -> ExpQ -> ExpQ
k (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lit -> Exp
LitE  forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Lit
IntegerL forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
str)
                       ((Lit -> Exp
LitE forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> Lit
StringPrimL) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` [Char] -> Q [Word8]
check [Char]
str)
  where
    check :: String -> Q [Word8]
    check :: [Char] -> Q [Word8]
check [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    check (Char
c:[Char]
cs) = do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Char -> Int
ord Char
c forall a. Ord a => a -> a -> Bool
> Int
0xFF) forall a b. (a -> b) -> a -> b
$
            forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"character '" forall a. [a] -> [a] -> [a]
++ [Char
c] forall a. [a] -> [a] -> [a]
++ [Char]
"' is have out of range in ASCII literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str
        [Word8]
cs' <- [Char] -> Q [Word8]
check [Char]
cs
        forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (Integral a, Num b) => a -> b
fromIntegral (Char -> Int
ord Char
c)forall a. a -> [a] -> [a]
:[Word8]
cs')


-- | @[arrASCII|asdfg|] :: PrimArray Word8@
arrASCII :: QuasiQuoter
arrASCII :: QuasiQuoter
arrASCII = ([Char] -> ExpQ)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    ((ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
asciiLiteral forall a b. (a -> b) -> a -> b
$ \ ExpQ
len ExpQ
addr -> [| word8ArrayFromAddr $(len) $(addr) |])
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrASCII as a pattern")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrASCII as a type")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrASCII as a dec")

word8ArrayFromAddr :: Int -> Addr# -> PrimArray Word8
{-# INLINABLE word8ArrayFromAddr #-}
word8ArrayFromAddr :: Int -> Addr# -> PrimArray Word8
word8ArrayFromAddr Int
l Addr#
addr# = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MutablePrimArray s Word8
mba <- forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
Int -> m (MutablePrimArray (PrimState m) a)
newPrimArray Int
l
    forall (m :: * -> *) a.
(PrimMonad m, Prim a, HasCallStack) =>
MutablePrimArray (PrimState m) a -> Int -> Ptr a -> Int -> m ()
copyPtrToMutablePrimArray MutablePrimArray s Word8
mba Int
0 (forall a. Addr# -> Ptr a
Ptr Addr#
addr#) Int
l
    forall (m :: * -> *) a.
PrimMonad m =>
MutablePrimArray (PrimState m) a -> m (PrimArray a)
unsafeFreezePrimArray MutablePrimArray s Word8
mba

int8ArrayFromAddr :: Int -> Addr# -> PrimArray Int8
{-# INLINE int8ArrayFromAddr #-}
int8ArrayFromAddr :: Int -> Addr# -> PrimArray Int8
int8ArrayFromAddr Int
l Addr#
addr# = forall (arr :: * -> *) a b. (Arr arr a, Cast a b) => arr a -> arr b
castArray (Int -> Addr# -> PrimArray Word8
word8ArrayFromAddr Int
l Addr#
addr#)


-- | Construct data with UTF8 encoded literals.
--
-- See 'asciiLiteral'
utf8Literal :: (ExpQ -> ExpQ -> ExpQ) -> String -> ExpQ
utf8Literal :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
utf8Literal ExpQ -> ExpQ -> ExpQ
k [Char]
str = ExpQ -> ExpQ -> ExpQ
k (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lit -> Exp
LitE  forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Lit
IntegerL forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
str)
                      ((Lit -> Exp
LitE forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> Lit
StringPrimL) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` [Char] -> Q [Word8]
check [Char]
str)
  where
    check :: String -> Q [Word8]
    check :: [Char] -> Q [Word8]
check [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    check (Char
c:[Char]
cs) = case Char -> Int
ord Char
c of
        Int
n
            | Int
n forall a. Ord a => a -> a -> Bool
<= Int
0x0000007F -> do
                let w :: Word8
w = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n
                [Word8]
ws <- [Char] -> Q [Word8]
check [Char]
cs
                forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
wforall a. a -> [a] -> [a]
:[Word8]
ws)
            | Int
n forall a. Ord a => a -> a -> Bool
<= Int
0x000007FF -> do
                let w1 :: Word8
w1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0xC0 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> Int -> a
`shiftR` Int
6)
                    w2 :: Word8
w2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0x80 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> a -> a
.&. Int
0x3F)
                [Word8]
ws <- [Char] -> Q [Word8]
check [Char]
cs
                forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
w1forall a. a -> [a] -> [a]
:Word8
w2forall a. a -> [a] -> [a]
:[Word8]
ws)
            | Int
n forall a. Ord a => a -> a -> Bool
<= Int
0x0000D7FF -> do
                let w1 :: Word8
w1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0xE0 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> Int -> a
`shiftR` Int
12)
                    w2 :: Word8
w2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0x80 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> Int -> a
`shiftR` Int
6 forall a. Bits a => a -> a -> a
.&. Int
0x3F)
                    w3 :: Word8
w3 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0x80 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> a -> a
.&. Int
0x3F)
                [Word8]
ws <- [Char] -> Q [Word8]
check [Char]
cs
                forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
w1forall a. a -> [a] -> [a]
:Word8
w2forall a. a -> [a] -> [a]
:Word8
w3forall a. a -> [a] -> [a]
:[Word8]
ws)
            | Int
n forall a. Ord a => a -> a -> Bool
<= Int
0x0000DFFF -> do
                forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"character '" forall a. [a] -> [a] -> [a]
++ [Char
c] forall a. [a] -> [a] -> [a]
++ [Char]
"' is have out of range in UTF-8 literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str
            | Int
n forall a. Ord a => a -> a -> Bool
<= Int
0x0000FFFF -> do
                let w1 :: Word8
w1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0xE0 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> Int -> a
`shiftR` Int
12)
                    w2 :: Word8
w2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0x80 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> Int -> a
`shiftR` Int
6 forall a. Bits a => a -> a -> a
.&. Int
0x3F)
                    w3 :: Word8
w3 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0x80 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> a -> a
.&. Int
0x3F)
                [Word8]
ws <- [Char] -> Q [Word8]
check [Char]
cs
                forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
w1forall a. a -> [a] -> [a]
:Word8
w2forall a. a -> [a] -> [a]
:Word8
w3forall a. a -> [a] -> [a]
:[Word8]
ws)
            | Int
n forall a. Ord a => a -> a -> Bool
<= Int
0x0010FFFF -> do
                let w1 :: Word8
w1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0xF0 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> Int -> a
`shiftR` Int
18)
                    w2 :: Word8
w2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0x80 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> Int -> a
`shiftR` Int
12 forall a. Bits a => a -> a -> a
.&. Int
0x3F)
                    w3 :: Word8
w3 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0x80 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> Int -> a
`shiftR` Int
6 forall a. Bits a => a -> a -> a
.&. Int
0x3F)
                    w4 :: Word8
w4 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
0x80 forall a. Bits a => a -> a -> a
.|. (Int
n forall a. Bits a => a -> a -> a
.&. Int
0x3F)
                [Word8]
ws <- [Char] -> Q [Word8]
check [Char]
cs
                forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
w1forall a. a -> [a] -> [a]
:Word8
w2forall a. a -> [a] -> [a]
:Word8
w3forall a. a -> [a] -> [a]
:Word8
w4forall a. a -> [a] -> [a]
:[Word8]
ws)
            | Bool
otherwise ->
                forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"character '" forall a. [a] -> [a] -> [a]
++ [Char
c] forall a. [a] -> [a] -> [a]
++ [Char]
"' is have out of range in UTF-8 literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str


-- | Construct data with array literals @e.g. 1,2,3@.
arrayLiteral :: ([Integer] -> Q [Word8])
              -> (ExpQ -> ExpQ -> ExpQ)
              -> String -> ExpQ
arrayLiteral :: ([Integer] -> Q [Word8])
-> (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
arrayLiteral [Integer] -> Q [Word8]
f ExpQ -> ExpQ -> ExpQ
k [Char]
str = do
    (Int
len, [Word8]
ws) <- [Char] -> Q (Int, [Word8])
parse [Char]
str
    ExpQ -> ExpQ -> ExpQ
k (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lit -> Exp
LitE  forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Lit
IntegerL forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
len) forall a b. (a -> b) -> a -> b
$ (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lit -> Exp
LitE forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> Lit
StringPrimL) [Word8]
ws
  where
    parse :: String -> Q (Int, [Word8])
    parse :: [Char] -> Q (Int, [Word8])
parse [Char]
str' = do
        case (forall a. Read a => ReadS [a]
readList :: ReadS [Integer]) ([Char]
"[" forall a. [a] -> [a] -> [a]
++ [Char]
str' forall a. [a] -> [a] -> [a]
++ [Char]
"]") of
            [([Integer]
is, [Char]
"")] -> (forall (t :: * -> *) a. Foldable t => t a -> Int
length [Integer]
is, ) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` [Integer] -> Q [Word8]
f [Integer]
is
            [([Integer], [Char])]
_ -> do Any
_ <- forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"can't parse vector literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str'
                    forall (m :: * -> *) a. Monad m => a -> m a
return (Int
0, [])

--------------------------------------------------------------------------------

#define ARRAY_LITERAL_DOC(T)  \
-- | Construct 'PrimArray' 'T' with array literals @e.g. 1,2,3@. See 'asciiLiteral'

ARRAY_LITERAL_DOC(Word8)
word8Literal :: (ExpQ -> ExpQ -> ExpQ) -> String -> ExpQ
word8Literal :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
word8Literal ExpQ -> ExpQ -> ExpQ
k [Char]
str = ([Integer] -> Q [Word8])
-> (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
arrayLiteral [Integer] -> Q [Word8]
checkW8 ExpQ -> ExpQ -> ExpQ
k [Char]
str
  where
    checkW8 :: [Integer] -> Q [Word8]
    checkW8 :: [Integer] -> Q [Word8]
checkW8 [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    checkW8 (Integer
i:[Integer]
is) = do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Integer
iforall a. Ord a => a -> a -> Bool
<Integer
0 Bool -> Bool -> Bool
|| Integer
i forall a. Ord a => a -> a -> Bool
> Integer
0xFF) forall a b. (a -> b) -> a -> b
$
            forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"integer " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Integer
i forall a. [a] -> [a] -> [a]
++ [Char]
" is out of Word8 range in literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str
        [Word8]
ws <- [Integer] -> Q [Word8]
checkW8 [Integer]
is
        let w :: Word8
w = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
wforall a. a -> [a] -> [a]
:[Word8]
ws)

-- | @[arrW8|1,2,3,4,5|] :: PrimArray Word8@
arrW8 :: QuasiQuoter
arrW8 :: QuasiQuoter
arrW8 = ([Char] -> ExpQ)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    ((ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
word8Literal forall a b. (a -> b) -> a -> b
$ \ ExpQ
len ExpQ
addr -> [| word8ArrayFromAddr $(len) $(addr) |])
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW8 as a pattern")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW8 as a type")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW8 as a dec")

ARRAY_LITERAL_DOC(Int8)
int8Literal :: (ExpQ -> ExpQ -> ExpQ) -> String -> ExpQ
int8Literal :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
int8Literal ExpQ -> ExpQ -> ExpQ
k [Char]
str = ([Integer] -> Q [Word8])
-> (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
arrayLiteral [Integer] -> Q [Word8]
checkI8 ExpQ -> ExpQ -> ExpQ
k [Char]
str
  where
    checkI8 :: [Integer] -> Q [Word8]
    checkI8 :: [Integer] -> Q [Word8]
checkI8 [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    checkI8 (Integer
i:[Integer]
is) = do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Integer
iforall a. Ord a => a -> a -> Bool
< (-Integer
0x80) Bool -> Bool -> Bool
|| Integer
i forall a. Ord a => a -> a -> Bool
> Integer
0x7F) forall a b. (a -> b) -> a -> b
$
            forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"integer " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Integer
i forall a. [a] -> [a] -> [a]
++ [Char]
" is out of Int8 range in literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str
        [Word8]
ws <- [Integer] -> Q [Word8]
checkI8 [Integer]
is
        let w :: Word8
w = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
wforall a. a -> [a] -> [a]
:[Word8]
ws)

-- | @[arrW8|1,2,3,4,5|] :: PrimArray Int8@
arrI8 :: QuasiQuoter
arrI8 :: QuasiQuoter
arrI8 = ([Char] -> ExpQ)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    ((ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
int8Literal forall a b. (a -> b) -> a -> b
$ \ ExpQ
len ExpQ
addr -> [| int8ArrayFromAddr $(len) $(addr) |])
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI8 as a pattern")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI8 as a type")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI8 as a dec")

--------------------------------------------------------------------------------

ARRAY_LITERAL_DOC(Word16)
word16Literal :: (ExpQ -> ExpQ -> ExpQ) -> String -> ExpQ
word16Literal :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
word16Literal ExpQ -> ExpQ -> ExpQ
k [Char]
str = ([Integer] -> Q [Word8])
-> (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
arrayLiteral [Integer] -> Q [Word8]
checkW16 ExpQ -> ExpQ -> ExpQ
k [Char]
str
  where
    checkW16 :: [Integer] -> Q [Word8]
    checkW16 :: [Integer] -> Q [Word8]
checkW16 [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    checkW16 (Integer
i:[Integer]
is) = do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Integer
iforall a. Ord a => a -> a -> Bool
<Integer
0 Bool -> Bool -> Bool
|| Integer
i forall a. Ord a => a -> a -> Bool
> Integer
0xFFFF) forall a b. (a -> b) -> a -> b
$
            forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"integer " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Integer
i forall a. [a] -> [a] -> [a]
++ [Char]
" is out of Word16 range in literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str
        [Word8]
ws <- [Integer] -> Q [Word8]
checkW16 [Integer]
is
        let w1 :: Word8
w1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w2 :: Word8
w2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
8 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
#ifdef WORDS_BIGENDIAN
        return (w2:w1:ws)
#else
        forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
w1forall a. a -> [a] -> [a]
:Word8
w2forall a. a -> [a] -> [a]
:[Word8]
ws)
#endif

-- | @[arrW16|1,2,3,4,5|] :: PrimArray Word16@
arrW16 :: QuasiQuoter
arrW16 :: QuasiQuoter
arrW16 = ([Char] -> ExpQ)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    ((ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
word16Literal forall a b. (a -> b) -> a -> b
$ \ ExpQ
len ExpQ
addr -> [| word16ArrayFromAddr $(len) $(addr) |])
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW16 as a pattern")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW16 as a type")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW16 as a dec")

word16ArrayFromAddr :: Int -> Addr# -> PrimArray Word16
{-# INLINE word16ArrayFromAddr #-}
word16ArrayFromAddr :: Int -> Addr# -> PrimArray Word16
word16ArrayFromAddr Int
l Addr#
addr# = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MArr PrimArray s Word16
mba <- forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s, HasCallStack) =>
Int -> m (MArr arr s a)
newArr Int
l
    forall (m :: * -> *) a.
(PrimMonad m, Prim a, HasCallStack) =>
MutablePrimArray (PrimState m) a -> Int -> Ptr a -> Int -> m ()
copyPtrToMutablePrimArray MArr PrimArray s Word16
mba Int
0 (forall a. Addr# -> Ptr a
Ptr Addr#
addr#) Int
l
    forall (m :: * -> *) a.
PrimMonad m =>
MutablePrimArray (PrimState m) a -> m (PrimArray a)
unsafeFreezePrimArray MArr PrimArray s Word16
mba

int16ArrayFromAddr :: Int -> Addr# -> PrimArray Int16
{-# INLINE int16ArrayFromAddr #-}
int16ArrayFromAddr :: Int -> Addr# -> PrimArray Int16
int16ArrayFromAddr Int
l Addr#
addr# = forall (arr :: * -> *) a b. (Arr arr a, Cast a b) => arr a -> arr b
castArray (Int -> Addr# -> PrimArray Word16
word16ArrayFromAddr Int
l Addr#
addr#)

ARRAY_LITERAL_DOC(Int16)
int16Literal :: (ExpQ -> ExpQ -> ExpQ) -> String -> ExpQ
int16Literal :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
int16Literal ExpQ -> ExpQ -> ExpQ
k [Char]
str = ([Integer] -> Q [Word8])
-> (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
arrayLiteral [Integer] -> Q [Word8]
checkI16 ExpQ -> ExpQ -> ExpQ
k [Char]
str
  where
    checkI16 :: [Integer] -> Q [Word8]
    checkI16 :: [Integer] -> Q [Word8]
checkI16 [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    checkI16 (Integer
i:[Integer]
is) = do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Integer
iforall a. Ord a => a -> a -> Bool
<(-Integer
0x8000) Bool -> Bool -> Bool
|| Integer
iforall a. Ord a => a -> a -> Bool
>Integer
0x7FFF) forall a b. (a -> b) -> a -> b
$
            forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"integer " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Integer
i forall a. [a] -> [a] -> [a]
++ [Char]
" is out of Int16 range in literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str
        [Word8]
ws <- [Integer] -> Q [Word8]
checkI16 [Integer]
is
        let w1 :: Word8
w1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w2 :: Word8
w2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
8 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
#ifdef WORDS_BIGENDIAN
        return (w2:w1:ws)
#else
        forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
w1forall a. a -> [a] -> [a]
:Word8
w2forall a. a -> [a] -> [a]
:[Word8]
ws)
#endif

-- | @[arrI16|1,2,3,4,5|] :: PrimArray Int16@
arrI16 :: QuasiQuoter
arrI16 :: QuasiQuoter
arrI16 = ([Char] -> ExpQ)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    ((ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
word16Literal forall a b. (a -> b) -> a -> b
$ \ ExpQ
len ExpQ
addr -> [| int16ArrayFromAddr $(len) $(addr) |])
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI16 as a pattern")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI16 as a type")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI16 as a dec")
--------------------------------------------------------------------------------

ARRAY_LITERAL_DOC(Word32)
word32Literal :: (ExpQ -> ExpQ -> ExpQ) -> String -> ExpQ
word32Literal :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
word32Literal ExpQ -> ExpQ -> ExpQ
k [Char]
str = ([Integer] -> Q [Word8])
-> (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
arrayLiteral [Integer] -> Q [Word8]
checkW32 ExpQ -> ExpQ -> ExpQ
k [Char]
str
  where
    checkW32 :: [Integer] -> Q [Word8]
    checkW32 :: [Integer] -> Q [Word8]
checkW32 [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    checkW32 (Integer
i:[Integer]
is) = do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Integer
iforall a. Ord a => a -> a -> Bool
<Integer
0 Bool -> Bool -> Bool
|| Integer
i forall a. Ord a => a -> a -> Bool
> Integer
0xFFFFFFFF) forall a b. (a -> b) -> a -> b
$
            forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"integer " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Integer
i forall a. [a] -> [a] -> [a]
++ [Char]
" is out of Word32 range in literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str
        [Word8]
ws <- [Integer] -> Q [Word8]
checkW32 [Integer]
is
        let w1 :: Word8
w1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w2 :: Word8
w2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
8 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w3 :: Word8
w3 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
16 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w4 :: Word8
w4 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
24 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
#ifdef WORDS_BIGENDIAN
        return (w4:w3:w2:w1:ws)
#else
        forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
w1forall a. a -> [a] -> [a]
:Word8
w2forall a. a -> [a] -> [a]
:Word8
w3forall a. a -> [a] -> [a]
:Word8
w4forall a. a -> [a] -> [a]
:[Word8]
ws)
#endif

-- | @[arrW32|1,2,3,4,5|] :: PrimArray Word32@
arrW32 :: QuasiQuoter
arrW32 :: QuasiQuoter
arrW32 = ([Char] -> ExpQ)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    ((ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
word32Literal forall a b. (a -> b) -> a -> b
$ \ ExpQ
len ExpQ
addr -> [| word32ArrayFromAddr $(len) $(addr) |])
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW32 as a pattern")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW32 as a type")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW32 as a dec")

word32ArrayFromAddr :: Int -> Addr# -> PrimArray Word32
{-# INLINE word32ArrayFromAddr #-}
word32ArrayFromAddr :: Int -> Addr# -> PrimArray Word32
word32ArrayFromAddr Int
l Addr#
addr# = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MArr PrimArray s Word32
mba <- forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s, HasCallStack) =>
Int -> m (MArr arr s a)
newArr Int
l
    forall (m :: * -> *) a.
(PrimMonad m, Prim a, HasCallStack) =>
MutablePrimArray (PrimState m) a -> Int -> Ptr a -> Int -> m ()
copyPtrToMutablePrimArray MArr PrimArray s Word32
mba Int
0 (forall a. Addr# -> Ptr a
Ptr Addr#
addr#) Int
l
    forall (m :: * -> *) a.
PrimMonad m =>
MutablePrimArray (PrimState m) a -> m (PrimArray a)
unsafeFreezePrimArray MArr PrimArray s Word32
mba

int32ArrayFromAddr :: Int -> Addr# -> PrimArray Int32
{-# INLINE int32ArrayFromAddr #-}
int32ArrayFromAddr :: Int -> Addr# -> PrimArray Int32
int32ArrayFromAddr Int
l Addr#
addr# = forall (arr :: * -> *) a b. (Arr arr a, Cast a b) => arr a -> arr b
castArray (Int -> Addr# -> PrimArray Word32
word32ArrayFromAddr Int
l Addr#
addr#)

ARRAY_LITERAL_DOC(Int32)
int32Literal :: (ExpQ -> ExpQ -> ExpQ) -> String -> ExpQ
int32Literal :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
int32Literal ExpQ -> ExpQ -> ExpQ
k [Char]
str = ([Integer] -> Q [Word8])
-> (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
arrayLiteral [Integer] -> Q [Word8]
checkI32 ExpQ -> ExpQ -> ExpQ
k [Char]
str
  where
    checkI32 :: [Integer] -> Q [Word8]
    checkI32 :: [Integer] -> Q [Word8]
checkI32 [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    checkI32 (Integer
i:[Integer]
is) = do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Integer
iforall a. Ord a => a -> a -> Bool
<(-Integer
0x80000000) Bool -> Bool -> Bool
|| Integer
iforall a. Ord a => a -> a -> Bool
>Integer
0x7FFFFFFF) forall a b. (a -> b) -> a -> b
$
            forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"integer " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Integer
i forall a. [a] -> [a] -> [a]
++ [Char]
" is out of Int32 range in literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str
        [Word8]
ws <- [Integer] -> Q [Word8]
checkI32 [Integer]
is
        let w1 :: Word8
w1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w2 :: Word8
w2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
8 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w3 :: Word8
w3 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
16 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w4 :: Word8
w4 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
24 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
#ifdef WORDS_BIGENDIAN
        return (w4:w3:w2:w1:ws)
#else
        forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
w1forall a. a -> [a] -> [a]
:Word8
w2forall a. a -> [a] -> [a]
:Word8
w3forall a. a -> [a] -> [a]
:Word8
w4forall a. a -> [a] -> [a]
:[Word8]
ws)
#endif

-- | @[arrI32|1,2,3,4,5|] :: PrimArray Int32@
arrI32 :: QuasiQuoter
arrI32 :: QuasiQuoter
arrI32 = ([Char] -> ExpQ)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    ((ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
int32Literal forall a b. (a -> b) -> a -> b
$ \ ExpQ
len ExpQ
addr -> [| int32ArrayFromAddr $(len) $(addr) |])
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI32 as a pattern")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI32 as a type")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI32 as a dec")

--------------------------------------------------------------------------------

ARRAY_LITERAL_DOC(Word64)
word64Literal :: (ExpQ -> ExpQ -> ExpQ) -> String -> ExpQ
word64Literal :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
word64Literal ExpQ -> ExpQ -> ExpQ
k [Char]
str = ([Integer] -> Q [Word8])
-> (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
arrayLiteral [Integer] -> Q [Word8]
checkW64 ExpQ -> ExpQ -> ExpQ
k [Char]
str
  where
    checkW64 :: [Integer] -> Q [Word8]
    checkW64 :: [Integer] -> Q [Word8]
checkW64 [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    checkW64 (Integer
i:[Integer]
is) = do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Integer
iforall a. Ord a => a -> a -> Bool
<Integer
0 Bool -> Bool -> Bool
|| Integer
i forall a. Ord a => a -> a -> Bool
> Integer
0xFFFFFFFFFFFFFFFF) forall a b. (a -> b) -> a -> b
$
            forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"integer " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Integer
i forall a. [a] -> [a] -> [a]
++ [Char]
" is out of Word64 range in literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str
        [Word8]
ws <- [Integer] -> Q [Word8]
checkW64 [Integer]
is
        let w1 :: Word8
w1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w2 :: Word8
w2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
8 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w3 :: Word8
w3 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
16 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w4 :: Word8
w4 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
24 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w5 :: Word8
w5 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
32 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w6 :: Word8
w6 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
40 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w7 :: Word8
w7 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
48 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w8 :: Word8
w8 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
56 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
#ifdef WORDS_BIGENDIAN
        return (w8:w7:w6:w5:w4:w3:w2:w1:ws)
#else
        forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
w1forall a. a -> [a] -> [a]
:Word8
w2forall a. a -> [a] -> [a]
:Word8
w3forall a. a -> [a] -> [a]
:Word8
w4forall a. a -> [a] -> [a]
:Word8
w5forall a. a -> [a] -> [a]
:Word8
w6forall a. a -> [a] -> [a]
:Word8
w7forall a. a -> [a] -> [a]
:Word8
w8forall a. a -> [a] -> [a]
:[Word8]
ws)
#endif

-- | @[arrW64|1,2,3,4,5|] :: PrimArray Word64@
arrW64 :: QuasiQuoter
arrW64 :: QuasiQuoter
arrW64 = ([Char] -> ExpQ)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    ((ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
word64Literal forall a b. (a -> b) -> a -> b
$ \ ExpQ
len ExpQ
addr -> [| word64ArrayFromAddr $(len) $(addr) |])
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW64 as a pattern")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW64 as a type")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrW64 as a dec")

word64ArrayFromAddr :: Int -> Addr# -> PrimArray Word64
{-# INLINABLE word64ArrayFromAddr #-}
word64ArrayFromAddr :: Int -> Addr# -> PrimArray Word64
word64ArrayFromAddr Int
l Addr#
addr# = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MArr PrimArray s Word64
mba <- forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s, HasCallStack) =>
Int -> m (MArr arr s a)
newArr Int
l
    forall (m :: * -> *) a.
(PrimMonad m, Prim a, HasCallStack) =>
MutablePrimArray (PrimState m) a -> Int -> Ptr a -> Int -> m ()
copyPtrToMutablePrimArray MArr PrimArray s Word64
mba Int
0 (forall a. Addr# -> Ptr a
Ptr Addr#
addr#) Int
l
    forall (m :: * -> *) a.
PrimMonad m =>
MutablePrimArray (PrimState m) a -> m (PrimArray a)
unsafeFreezePrimArray MArr PrimArray s Word64
mba

int64ArrayFromAddr :: Int -> Addr# -> PrimArray Int64
{-# INLINE int64ArrayFromAddr #-}
int64ArrayFromAddr :: Int -> Addr# -> PrimArray Int64
int64ArrayFromAddr Int
l Addr#
addr# = forall (arr :: * -> *) a b. (Arr arr a, Cast a b) => arr a -> arr b
castArray (Int -> Addr# -> PrimArray Word64
word64ArrayFromAddr Int
l Addr#
addr#)

ARRAY_LITERAL_DOC(Int64)
int64Literal :: (ExpQ -> ExpQ -> ExpQ) -> String -> ExpQ
int64Literal :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
int64Literal ExpQ -> ExpQ -> ExpQ
k [Char]
str = ([Integer] -> Q [Word8])
-> (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
arrayLiteral [Integer] -> Q [Word8]
checkI64 ExpQ -> ExpQ -> ExpQ
k [Char]
str
  where
    checkI64 :: [Integer] -> Q [Word8]
    checkI64 :: [Integer] -> Q [Word8]
checkI64 [] = forall (m :: * -> *) a. Monad m => a -> m a
return []
    checkI64 (Integer
i:[Integer]
is) = do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Integer
iforall a. Ord a => a -> a -> Bool
<(-Integer
0x8000000000000000) Bool -> Bool -> Bool
|| Integer
i forall a. Ord a => a -> a -> Bool
> Integer
0x7FFFFFFFFFFFFFFF) forall a b. (a -> b) -> a -> b
$
            forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"integer " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Integer
i forall a. [a] -> [a] -> [a]
++ [Char]
" is out of Int64 range in literal:" forall a. [a] -> [a] -> [a]
++ [Char]
str
        [Word8]
ws <- [Integer] -> Q [Word8]
checkI64 [Integer]
is
        let w1 :: Word8
w1 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w2 :: Word8
w2 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
8 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w3 :: Word8
w3 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
16 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w4 :: Word8
w4 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
24 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w5 :: Word8
w5 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
32 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w6 :: Word8
w6 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
40 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w7 :: Word8
w7 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
48 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
            w8 :: Word8
w8 = forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
i forall a. Bits a => a -> Int -> a
`shiftR` Int
56 forall a. Bits a => a -> a -> a
.&. Integer
0xFF)
#ifdef WORDS_BIGENDIAN
        return (w8:w7:w6:w5:w4:w3:w2:w1:ws)
#else
        forall (m :: * -> *) a. Monad m => a -> m a
return (Word8
w1forall a. a -> [a] -> [a]
:Word8
w2forall a. a -> [a] -> [a]
:Word8
w3forall a. a -> [a] -> [a]
:Word8
w4forall a. a -> [a] -> [a]
:Word8
w5forall a. a -> [a] -> [a]
:Word8
w6forall a. a -> [a] -> [a]
:Word8
w7forall a. a -> [a] -> [a]
:Word8
w8forall a. a -> [a] -> [a]
:[Word8]
ws)
#endif

-- | @[arrI64|1,2,3,4,5|] :: PrimArray Int64@
arrI64 :: QuasiQuoter
arrI64 :: QuasiQuoter
arrI64 = ([Char] -> ExpQ)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    ((ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
int64Literal forall a b. (a -> b) -> a -> b
$ \ ExpQ
len ExpQ
addr -> [| int64ArrayFromAddr $(len) $(addr) |])
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI64 as a pattern")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI64 as a type")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrI64 as a dec")

--------------------------------------------------------------------------------

wordArrayFromAddr :: Int -> Addr# -> PrimArray Word
{-# INLINE wordArrayFromAddr #-}
wordArrayFromAddr :: Int -> Addr# -> PrimArray Word
wordArrayFromAddr Int
l Addr#
addr# =
#if SIZEOF_HSWORD == 8
    unsafeCoerce# :: forall a b. a -> b
unsafeCoerce# (Int -> Addr# -> PrimArray Word64
word64ArrayFromAddr Int
l Addr#
addr#)
#else
    unsafeCoerce# (word32ArrayFromAddr l addr#)
#endif

intArrayFromAddr :: Int -> Addr# -> PrimArray Int
{-# INLINE intArrayFromAddr #-}
intArrayFromAddr :: Int -> Addr# -> PrimArray Int
intArrayFromAddr Int
l Addr#
addr# =
#if SIZEOF_HSWORD == 8
    unsafeCoerce# :: forall a b. a -> b
unsafeCoerce# (Int -> Addr# -> PrimArray Int64
int64ArrayFromAddr Int
l Addr#
addr#)
#else
    unsafeCoerce# (int32ArrayFromAddr l addr#)
#endif

ARRAY_LITERAL_DOC(Word)
wordLiteral :: (ExpQ -> ExpQ -> ExpQ) -> String -> ExpQ
wordLiteral :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
wordLiteral =
#if SIZEOF_HSWORD == 8
    (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
word64Literal
#else
    word32Literal
#endif

ARRAY_LITERAL_DOC(Int)
intLiteral :: (ExpQ -> ExpQ -> ExpQ) -> String -> ExpQ
intLiteral :: (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
intLiteral =
#if SIZEOF_HSWORD == 8
    (ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
int64Literal
#else
    int32Literal
#endif

-- | @[arrWord|1,2,3,4,5|] :: PrimArray Word@
arrWord :: QuasiQuoter
arrWord :: QuasiQuoter
arrWord = ([Char] -> ExpQ)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    ((ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
wordLiteral forall a b. (a -> b) -> a -> b
$ \ ExpQ
len ExpQ
addr -> [| wordArrayFromAddr $(len) $(addr) |])
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrWord as a pattern")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrWord as a type")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrWord as a dec")

-- | @[arrInt|1,2,3,4,5|] :: PrimArray Int@
arrInt :: QuasiQuoter
arrInt :: QuasiQuoter
arrInt = ([Char] -> ExpQ)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter
    ((ExpQ -> ExpQ -> ExpQ) -> [Char] -> ExpQ
intLiteral forall a b. (a -> b) -> a -> b
$ \ ExpQ
len ExpQ
addr -> [| intArrayFromAddr $(len) $(addr) |])
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrInt as a pattern")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrInt as a type")
    (forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot use arrInt as a dec")

--------------------------------------------------------------------------------