module Z.Data.Array.QQ
(
arrASCII
, arrW8, arrW16, arrW32, arrW64, arrWord
, arrI8, arrI16, arrI32, arrI64, arrInt
, 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
asciiLiteral :: (ExpQ -> ExpQ -> ExpQ)
-> String
-> ExpQ
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 :: 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#)
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
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 :: 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)
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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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")