{-# LANGUAGE CPP, RankNTypes, MagicHash, BangPatterns #-}
{-# LANGUAGE Trustworthy #-}

#if defined(__GLASGOW_HASKELL__) && !defined(__HADDOCK__)
#include "MachDeps.h"
#endif

-----------------------------------------------------------------------------
-- |
-- Module      : Data.Binary.Get
-- Copyright   : Lennart Kolmodin
-- License     : BSD3-style (see LICENSE)
--
-- Maintainer  : Lennart Kolmodin <kolmodin@gmail.com>
-- Stability   : experimental
-- Portability : portable to Hugs and GHC.
--
-- The 'Get' monad. A monad for efficiently building structures from
-- encoded lazy ByteStrings.
--
-- Primitives are available to decode words of various sizes, both big and
-- little endian.
--
-- Let's decode binary data representing illustrated here.
-- In this example the values are in little endian.
--
-- > +------------------+--------------+-----------------+
-- > | 32 bit timestamp | 32 bit price | 16 bit quantity |
-- > +------------------+--------------+-----------------+
--
-- A corresponding Haskell value looks like this:
--
-- @
--data Trade = Trade
--  { timestamp :: !'Word32'
--  , price     :: !'Word32'
--  , qty       :: !'Word16'
--  } deriving ('Show')
-- @
--
-- The fields in @Trade@ are marked as strict (using @!@) since we don't need
-- laziness here. In practise, you would probably consider using the UNPACK
-- pragma as well.
-- <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#unpack-pragma>
--
-- Now, let's have a look at a decoder for this format.
--
-- @
--getTrade :: 'Get' Trade
--getTrade = do
--  timestamp <- 'getWord32le'
--  price     <- 'getWord32le'
--  quantity  <- 'getWord16le'
--  return '$!' Trade timestamp price quantity
-- @
--
-- Or even simpler using applicative style:
--
-- @
--getTrade' :: 'Get' Trade
--getTrade' = Trade '<$>' 'getWord32le' '<*>' 'getWord32le' '<*>' 'getWord16le'
-- @
--
-- There are two kinds of ways to execute this decoder, the lazy input
-- method and the incremental input method. Here we will use the lazy
-- input method.
--
-- Let's first define a function that decodes many @Trade@s.
--
-- @
--getTrades :: Get [Trade]
--getTrades = do
--  empty <- 'isEmpty'
--  if empty
--    then return []
--    else do trade <- getTrade
--            trades <- getTrades
--            return (trade:trades)
-- @
--
-- Finally, we run the decoder:
--
-- @
--lazyIOExample :: IO [Trade]
--lazyIOExample = do
--  input <- BL.readFile \"trades.bin\"
--  return ('runGet' getTrades input)
-- @
--
-- This decoder has the downside that it will need to read all the input before
-- it can return. On the other hand, it will not return anything until
-- it knows it could decode without any decoder errors.
--
-- You could also refactor to a left-fold, to decode in a more streaming fashion,
-- and get the following decoder. It will start to return data without knowing
-- that it can decode all input.
--
-- @
--incrementalExample :: BL.ByteString -> [Trade]
--incrementalExample input0 = go decoder input0
--  where
--    decoder = 'runGetIncremental' getTrade
--    go :: 'Decoder' Trade -> BL.ByteString -> [Trade]
--    go ('Done' leftover _consumed trade) input =
--      trade : go decoder (BL.chunk leftover input)
--    go ('Partial' k) input                     =
--      go (k . takeHeadChunk $ input) (dropHeadChunk input)
--    go ('Fail' _leftover _consumed msg) _input =
--      error msg
--
--takeHeadChunk :: BL.ByteString -> Maybe BS.ByteString
--takeHeadChunk lbs =
--  case lbs of
--    (BL.Chunk bs _) -> Just bs
--    _ -> Nothing
--
--dropHeadChunk :: BL.ByteString -> BL.ByteString
--dropHeadChunk lbs =
--  case lbs of
--    (BL.Chunk _ lbs') -> lbs'
--    _ -> BL.Empty
-- @
--
-- The @lazyIOExample@ uses lazy I/O to read the file from the disk, which is
-- not suitable in all applications, and certainly not if you need to read
-- from a socket which has higher likelihood to fail. To address these needs,
-- use the incremental input method like in @incrementalExample@.
-- For an example of how to read incrementally from a Handle,
-- see the implementation of 'Data.Binary.decodeFileOrFail'.
-----------------------------------------------------------------------------


module Data.Binary.Get (

    -- * The Get monad
      Get

    -- * The lazy input interface
    -- $lazyinterface
    , runGet
    , runGetOrFail
    , ByteOffset

    -- * The incremental input interface
    -- $incrementalinterface
    , Decoder(..)
    , runGetIncremental

    -- ** Providing input
    , pushChunk
    , pushChunks
    , pushEndOfInput

    -- * Decoding
    , skip
    , isEmpty
    , bytesRead
    , isolate
    , lookAhead
    , lookAheadM
    , lookAheadE
    , label

    -- ** ByteStrings
    , getByteString
    , getLazyByteString
    , getLazyByteStringNul
    , getRemainingLazyByteString

    -- ** Decoding Words
    , getWord8

    -- *** Big-endian decoding
    , getWord16be
    , getWord32be
    , getWord64be

    -- *** Little-endian decoding
    , getWord16le
    , getWord32le
    , getWord64le

    -- *** Host-endian, unaligned decoding
    , getWordhost
    , getWord16host
    , getWord32host
    , getWord64host

    -- ** Decoding Ints
    , getInt8

    -- *** Big-endian decoding
    , getInt16be
    , getInt32be
    , getInt64be

    -- *** Little-endian decoding
    , getInt16le
    , getInt32le
    , getInt64le

    -- *** Host-endian, unaligned decoding
    , getInthost
    , getInt16host
    , getInt32host
    , getInt64host

    -- ** Decoding Floats/Doubles
    , getFloatbe
    , getFloatle
    , getFloathost
    , getDoublebe
    , getDoublele
    , getDoublehost

    -- * Deprecated functions
    , runGetState -- DEPRECATED
    , remaining -- DEPRECATED
    , getBytes -- DEPRECATED
    ) where
#if ! MIN_VERSION_base(4,8,0)
import Control.Applicative
#endif

import Foreign
import qualified Data.ByteString as B
import qualified Data.ByteString.Unsafe as B
import qualified Data.ByteString.Lazy as L
import qualified Data.ByteString.Lazy.Internal as L

import Data.Binary.Get.Internal hiding ( Decoder(..), runGetIncremental )
import qualified Data.Binary.Get.Internal as I

-- needed for casting words to float/double
import Data.Binary.FloatCast (wordToFloat, wordToDouble)

-- $lazyinterface
-- The lazy interface consumes a single lazy 'L.ByteString'. It's the easiest
-- interface to get started with, but it doesn't support interleaving I\/O and
-- parsing, unless lazy I/O is used.
--
-- There is no way to provide more input other than the initial data. To be
-- able to incrementally give more data, see the incremental input interface.

-- $incrementalinterface
-- The incremental interface gives you more control over how input is
-- provided during parsing. This lets you e.g. interleave parsing and
-- I\/O.
--
-- The incremental interface consumes a strict 'B.ByteString' at a time, each
-- being part of the total amount of input. If your decoder needs more input to
-- finish it will return a 'Partial' with a continuation.
-- If there is no more input, provide it 'Nothing'.
--
-- 'Fail' will be returned if it runs into an error, together with a message,
-- the position and the remaining input.
-- If it succeeds it will return 'Done' with the resulting value,
-- the position and the remaining input.

-- | A decoder procuced by running a 'Get' monad.
data Decoder a = Fail !B.ByteString {-# UNPACK #-} !ByteOffset String
              -- ^ The decoder ran into an error. The decoder either used
              -- 'fail' or was not provided enough input. Contains any
              -- unconsumed input and the number of bytes consumed.
              | Partial (Maybe B.ByteString -> Decoder a)
              -- ^ The decoder has consumed the available input and needs
              -- more to continue. Provide 'Just' if more input is available
              -- and 'Nothing' otherwise, and you will get a new 'Decoder'.
              | Done !B.ByteString {-# UNPACK #-} !ByteOffset a
              -- ^ The decoder has successfully finished. Except for the
              -- output value you also get any unused input as well as the
              -- number of bytes consumed.

-- | Run a 'Get' monad. See 'Decoder' for what to do next, like providing
-- input, handling decoder errors and to get the output value.
-- Hint: Use the helper functions 'pushChunk', 'pushChunks' and
-- 'pushEndOfInput'.
runGetIncremental :: Get a -> Decoder a
runGetIncremental :: forall a. Get a -> Decoder a
runGetIncremental = forall a. Decoder a -> Decoder a
calculateOffset forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Get a -> Decoder a
I.runGetIncremental

calculateOffset :: I.Decoder a -> Decoder a
calculateOffset :: forall a. Decoder a -> Decoder a
calculateOffset Decoder a
r0 = forall {a}. Decoder a -> Int64 -> Decoder a
go Decoder a
r0 Int64
0
  where
  go :: Decoder a -> Int64 -> Decoder a
go Decoder a
r !Int64
acc = case Decoder a
r of
                I.Done ByteString
inp a
a -> forall a. ByteString -> Int64 -> a -> Decoder a
Done ByteString
inp (Int64
acc forall a. Num a => a -> a -> a
- forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
B.length ByteString
inp)) a
a
                I.Fail ByteString
inp String
s -> forall a. ByteString -> Int64 -> String -> Decoder a
Fail ByteString
inp (Int64
acc forall a. Num a => a -> a -> a
- forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
B.length ByteString
inp)) String
s
                I.Partial Maybe ByteString -> Decoder a
k ->
                    forall a. (Maybe ByteString -> Decoder a) -> Decoder a
Partial forall a b. (a -> b) -> a -> b
$ \Maybe ByteString
ms ->
                      case Maybe ByteString
ms of
                        Maybe ByteString
Nothing -> Decoder a -> Int64 -> Decoder a
go (Maybe ByteString -> Decoder a
k forall a. Maybe a
Nothing) Int64
acc
                        Just ByteString
i -> Decoder a -> Int64 -> Decoder a
go (Maybe ByteString -> Decoder a
k Maybe ByteString
ms) (Int64
acc forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
B.length ByteString
i))
                I.BytesRead Int64
unused Int64 -> Decoder a
k ->
                    Decoder a -> Int64 -> Decoder a
go (Int64 -> Decoder a
k forall a b. (a -> b) -> a -> b
$! (Int64
acc forall a. Num a => a -> a -> a
- Int64
unused)) Int64
acc

-- | DEPRECATED. Provides compatibility with previous versions of this library.
-- Run a 'Get' monad and return a tuple with three values.
-- The first value is the result of the decoder. The second and third are the
-- unused input, and the number of consumed bytes.
{-# DEPRECATED runGetState "Use runGetIncremental instead. This function will be removed." #-}
runGetState :: Get a -> L.ByteString -> ByteOffset -> (a, L.ByteString, ByteOffset)
runGetState :: forall a. Get a -> ByteString -> Int64 -> (a, ByteString, Int64)
runGetState Get a
g ByteString
lbs0 Int64
pos' = forall {a}. Decoder a -> ByteString -> (a, ByteString, Int64)
go (forall a. Get a -> Decoder a
runGetIncremental Get a
g) ByteString
lbs0
  where
  go :: Decoder a -> ByteString -> (a, ByteString, Int64)
go (Done ByteString
s Int64
pos a
a) ByteString
lbs = (a
a, ByteString -> ByteString -> ByteString
L.chunk ByteString
s ByteString
lbs, Int64
posforall a. Num a => a -> a -> a
+Int64
pos')
  go (Partial Maybe ByteString -> Decoder a
k) ByteString
lbs = Decoder a -> ByteString -> (a, ByteString, Int64)
go (Maybe ByteString -> Decoder a
k (ByteString -> Maybe ByteString
takeHeadChunk ByteString
lbs)) (ByteString -> ByteString
dropHeadChunk ByteString
lbs)
  go (Fail ByteString
_ Int64
pos String
msg) ByteString
_ =
    forall a. HasCallStack => String -> a
error (String
"Data.Binary.Get.runGetState at position " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int64
pos forall a. [a] -> [a] -> [a]
++ String
": " forall a. [a] -> [a] -> [a]
++ String
msg)

takeHeadChunk :: L.ByteString -> Maybe B.ByteString
takeHeadChunk :: ByteString -> Maybe ByteString
takeHeadChunk ByteString
lbs =
  case ByteString
lbs of
    (L.Chunk ByteString
bs ByteString
_) -> forall a. a -> Maybe a
Just ByteString
bs
    ByteString
_ -> forall a. Maybe a
Nothing

dropHeadChunk :: L.ByteString -> L.ByteString
dropHeadChunk :: ByteString -> ByteString
dropHeadChunk ByteString
lbs =
  case ByteString
lbs of
    (L.Chunk ByteString
_ ByteString
lbs') -> ByteString
lbs'
    ByteString
_ -> ByteString
L.Empty

-- | Run a 'Get' monad and return 'Left' on failure and 'Right' on
-- success. In both cases any unconsumed input and the number of bytes
-- consumed is returned. In the case of failure, a human-readable
-- error message is included as well.
--
-- @since 0.6.4.0
runGetOrFail :: Get a -> L.ByteString
             -> Either (L.ByteString, ByteOffset, String) (L.ByteString, ByteOffset, a)
runGetOrFail :: forall a.
Get a
-> ByteString
-> Either (ByteString, Int64, String) (ByteString, Int64, a)
runGetOrFail Get a
g ByteString
lbs0 = forall {c}.
Decoder c
-> ByteString
-> Either (ByteString, Int64, String) (ByteString, Int64, c)
feedAll (forall a. Get a -> Decoder a
runGetIncremental Get a
g) ByteString
lbs0
  where
  feedAll :: Decoder c
-> ByteString
-> Either (ByteString, Int64, String) (ByteString, Int64, c)
feedAll (Done ByteString
bs Int64
pos c
x) ByteString
lbs = forall a b. b -> Either a b
Right (ByteString -> ByteString -> ByteString
L.chunk ByteString
bs ByteString
lbs, Int64
pos, c
x)
  feedAll (Partial Maybe ByteString -> Decoder c
k) ByteString
lbs = Decoder c
-> ByteString
-> Either (ByteString, Int64, String) (ByteString, Int64, c)
feedAll (Maybe ByteString -> Decoder c
k (ByteString -> Maybe ByteString
takeHeadChunk ByteString
lbs)) (ByteString -> ByteString
dropHeadChunk ByteString
lbs)
  feedAll (Fail ByteString
x Int64
pos String
msg) ByteString
xs = forall a b. a -> Either a b
Left (ByteString -> ByteString -> ByteString
L.chunk ByteString
x ByteString
xs, Int64
pos, String
msg)

-- | An offset, counted in bytes.
type ByteOffset = Int64

-- | The simplest interface to run a 'Get' decoder. If the decoder runs into
-- an error, calls 'fail', or runs out of input, it will call 'error'.
runGet :: Get a -> L.ByteString -> a
runGet :: forall a. Get a -> ByteString -> a
runGet Get a
g ByteString
lbs0 = forall {a}. Decoder a -> ByteString -> a
feedAll (forall a. Get a -> Decoder a
runGetIncremental Get a
g) ByteString
lbs0
  where
  feedAll :: Decoder a -> ByteString -> a
feedAll (Done ByteString
_ Int64
_ a
x) ByteString
_ = a
x
  feedAll (Partial Maybe ByteString -> Decoder a
k) ByteString
lbs = Decoder a -> ByteString -> a
feedAll (Maybe ByteString -> Decoder a
k (ByteString -> Maybe ByteString
takeHeadChunk ByteString
lbs)) (ByteString -> ByteString
dropHeadChunk ByteString
lbs)
  feedAll (Fail ByteString
_ Int64
pos String
msg) ByteString
_ =
    forall a. HasCallStack => String -> a
error (String
"Data.Binary.Get.runGet at position " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int64
pos forall a. [a] -> [a] -> [a]
++ String
": " forall a. [a] -> [a] -> [a]
++ String
msg)


-- | Feed a 'Decoder' with more input. If the 'Decoder' is 'Done' or 'Fail' it
-- will add the input to 'B.ByteString' of unconsumed input.
--
-- @
--    'runGetIncremental' myParser \`pushChunk\` myInput1 \`pushChunk\` myInput2
-- @
pushChunk :: Decoder a -> B.ByteString -> Decoder a
pushChunk :: forall a. Decoder a -> ByteString -> Decoder a
pushChunk Decoder a
r ByteString
inp =
  case Decoder a
r of
    Done ByteString
inp0 Int64
p a
a -> forall a. ByteString -> Int64 -> a -> Decoder a
Done (ByteString
inp0 ByteString -> ByteString -> ByteString
`B.append` ByteString
inp) Int64
p a
a
    Partial Maybe ByteString -> Decoder a
k -> Maybe ByteString -> Decoder a
k (forall a. a -> Maybe a
Just ByteString
inp)
    Fail ByteString
inp0 Int64
p String
s -> forall a. ByteString -> Int64 -> String -> Decoder a
Fail (ByteString
inp0 ByteString -> ByteString -> ByteString
`B.append` ByteString
inp) Int64
p String
s


-- | Feed a 'Decoder' with more input. If the 'Decoder' is 'Done' or 'Fail' it
-- will add the input to 'L.ByteString' of unconsumed input.
--
-- @
--    'runGetIncremental' myParser \`pushChunks\` myLazyByteString
-- @
pushChunks :: Decoder a -> L.ByteString -> Decoder a
pushChunks :: forall a. Decoder a -> ByteString -> Decoder a
pushChunks Decoder a
r0 = forall {a}. Decoder a -> [ByteString] -> Decoder a
go Decoder a
r0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
L.toChunks
  where
  go :: Decoder a -> [ByteString] -> Decoder a
go Decoder a
r [] = Decoder a
r
  go (Done ByteString
inp Int64
pos a
a) [ByteString]
xs = forall a. ByteString -> Int64 -> a -> Decoder a
Done ([ByteString] -> ByteString
B.concat (ByteString
inpforall a. a -> [a] -> [a]
:[ByteString]
xs)) Int64
pos a
a
  go (Fail ByteString
inp Int64
pos String
s) [ByteString]
xs = forall a. ByteString -> Int64 -> String -> Decoder a
Fail ([ByteString] -> ByteString
B.concat (ByteString
inpforall a. a -> [a] -> [a]
:[ByteString]
xs)) Int64
pos String
s
  go (Partial Maybe ByteString -> Decoder a
k) (ByteString
x:[ByteString]
xs) = Decoder a -> [ByteString] -> Decoder a
go (Maybe ByteString -> Decoder a
k (forall a. a -> Maybe a
Just ByteString
x)) [ByteString]
xs

-- | Tell a 'Decoder' that there is no more input. This passes 'Nothing' to a
-- 'Partial' decoder, otherwise returns the decoder unchanged.
pushEndOfInput :: Decoder a -> Decoder a
pushEndOfInput :: forall a. Decoder a -> Decoder a
pushEndOfInput Decoder a
r =
  case Decoder a
r of
    Done ByteString
_ Int64
_ a
_ -> Decoder a
r
    Partial Maybe ByteString -> Decoder a
k -> Maybe ByteString -> Decoder a
k forall a. Maybe a
Nothing
    Fail ByteString
_ Int64
_ String
_ -> Decoder a
r

-- | Skip ahead @n@ bytes. Fails if fewer than @n@ bytes are available.
skip :: Int -> Get ()
skip :: Int -> Get ()
skip Int
n = forall s b.
s
-> Consume s
-> ([ByteString] -> b)
-> ([ByteString] -> Get b)
-> Get b
withInputChunks (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n) Consume Int64
consumeBytes (forall a b. a -> b -> a
const ()) forall a. [ByteString] -> Get a
failOnEOF

-- | An efficient get method for lazy ByteStrings. Fails if fewer than @n@
-- bytes are left in the input.
getLazyByteString :: Int64 -> Get L.ByteString
getLazyByteString :: Int64 -> Get ByteString
getLazyByteString Int64
n0 = forall s b.
s
-> Consume s
-> ([ByteString] -> b)
-> ([ByteString] -> Get b)
-> Get b
withInputChunks Int64
n0 Consume Int64
consumeBytes [ByteString] -> ByteString
L.fromChunks forall a. [ByteString] -> Get a
failOnEOF

consumeBytes :: Consume Int64
consumeBytes :: Consume Int64
consumeBytes Int64
n ByteString
str
  | forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
B.length ByteString
str) forall a. Ord a => a -> a -> Bool
>= Int64
n = forall a b. b -> Either a b
Right (Int -> ByteString -> (ByteString, ByteString)
B.splitAt (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
n) ByteString
str)
  | Bool
otherwise = forall a b. a -> Either a b
Left (Int64
n forall a. Num a => a -> a -> a
- forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
B.length ByteString
str))

consumeUntilNul :: Consume ()
consumeUntilNul :: Consume ()
consumeUntilNul ()
_ ByteString
str =
  case (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)
B.break (forall a. Eq a => a -> a -> Bool
==Word8
0) ByteString
str of
    (ByteString
want, ByteString
rest) | ByteString -> Bool
B.null ByteString
rest -> forall a b. a -> Either a b
Left ()
                 | Bool
otherwise -> forall a b. b -> Either a b
Right (ByteString
want, Int -> ByteString -> ByteString
B.drop Int
1 ByteString
rest)

consumeAll :: Consume ()
consumeAll :: Consume ()
consumeAll ()
_ ByteString
_ = forall a b. a -> Either a b
Left ()

resumeOnEOF :: [B.ByteString] -> Get L.ByteString
resumeOnEOF :: [ByteString] -> Get ByteString
resumeOnEOF = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ByteString] -> ByteString
L.fromChunks

-- | Get a lazy ByteString that is terminated with a NUL byte.
-- The returned string does not contain the NUL byte. Fails
-- if it reaches the end of input without finding a NUL.
getLazyByteStringNul :: Get L.ByteString
getLazyByteStringNul :: Get ByteString
getLazyByteStringNul = forall s b.
s
-> Consume s
-> ([ByteString] -> b)
-> ([ByteString] -> Get b)
-> Get b
withInputChunks () Consume ()
consumeUntilNul [ByteString] -> ByteString
L.fromChunks forall a. [ByteString] -> Get a
failOnEOF

-- | Get the remaining bytes as a lazy ByteString.
-- Note that this can be an expensive function to use as it forces reading
-- all input and keeping the string in-memory.
getRemainingLazyByteString :: Get L.ByteString
getRemainingLazyByteString :: Get ByteString
getRemainingLazyByteString = forall s b.
s
-> Consume s
-> ([ByteString] -> b)
-> ([ByteString] -> Get b)
-> Get b
withInputChunks () Consume ()
consumeAll [ByteString] -> ByteString
L.fromChunks [ByteString] -> Get ByteString
resumeOnEOF

------------------------------------------------------------------------
-- Primtives

-- helper, get a raw Ptr onto a strict ByteString copied out of the
-- underlying lazy byteString.

getPtr :: Storable a => Int -> Get a
getPtr :: forall a. Storable a => Int -> Get a
getPtr Int
n = forall a. Int -> (Ptr a -> IO a) -> Get a
readNWith Int
n forall a. Storable a => Ptr a -> IO a
peek
{-# INLINE getPtr #-}

-- | Read a Word8 from the monad state
getWord8 :: Get Word8
getWord8 :: Get Word8
getWord8 = forall a. Int -> (ByteString -> a) -> Get a
readN Int
1 ByteString -> Word8
B.unsafeHead
{-# INLINE[2] getWord8 #-}

-- | Read an Int8 from the monad state
getInt8 :: Get Int8
getInt8 :: Get Int8
getInt8 = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word8
getWord8
{-# INLINE getInt8 #-}


-- force GHC to inline getWordXX
{-# RULES
"getWord8/readN" getWord8 = readN 1 B.unsafeHead
"getWord16be/readN" getWord16be = readN 2 word16be
"getWord16le/readN" getWord16le = readN 2 word16le
"getWord32be/readN" getWord32be = readN 4 word32be
"getWord32le/readN" getWord32le = readN 4 word32le
"getWord64be/readN" getWord64be = readN 8 word64be
"getWord64le/readN" getWord64le = readN 8 word64le #-}

-- | Read a Word16 in big endian format
getWord16be :: Get Word16
getWord16be :: Get Word16
getWord16be = forall a. Int -> (ByteString -> a) -> Get a
readN Int
2 ByteString -> Word16
word16be

word16be :: B.ByteString -> Word16
word16be :: ByteString -> Word16
word16be = \ByteString
s ->
        (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
0) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
8) forall a. Bits a => a -> a -> a
.|.
        (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
1))
{-# INLINE[2] getWord16be #-}
{-# INLINE word16be #-}

-- | Read a Word16 in little endian format
getWord16le :: Get Word16
getWord16le :: Get Word16
getWord16le = forall a. Int -> (ByteString -> a) -> Get a
readN Int
2 ByteString -> Word16
word16le

word16le :: B.ByteString -> Word16
word16le :: ByteString -> Word16
word16le = \ByteString
s ->
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
1) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
8) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
0) )
{-# INLINE[2] getWord16le #-}
{-# INLINE word16le #-}

-- | Read a Word32 in big endian format
getWord32be :: Get Word32
getWord32be :: Get Word32
getWord32be = forall a. Int -> (ByteString -> a) -> Get a
readN Int
4 ByteString -> Word32
word32be

word32be :: B.ByteString -> Word32
word32be :: ByteString -> Word32
word32be = \ByteString
s ->
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
0) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
24) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
1) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
2) forall a. Bits a => a -> Int -> a
`unsafeShiftL`  Int
8) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
3) )
{-# INLINE[2] getWord32be #-}
{-# INLINE word32be #-}

-- | Read a Word32 in little endian format
getWord32le :: Get Word32
getWord32le :: Get Word32
getWord32le = forall a. Int -> (ByteString -> a) -> Get a
readN Int
4 ByteString -> Word32
word32le

word32le :: B.ByteString -> Word32
word32le :: ByteString -> Word32
word32le = \ByteString
s ->
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
3) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
24) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
2) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
1) forall a. Bits a => a -> Int -> a
`unsafeShiftL`  Int
8) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
0) )
{-# INLINE[2] getWord32le #-}
{-# INLINE word32le #-}

-- | Read a Word64 in big endian format
getWord64be :: Get Word64
getWord64be :: Get Word64
getWord64be = forall a. Int -> (ByteString -> a) -> Get a
readN Int
8 ByteString -> Word64
word64be

word64be :: B.ByteString -> Word64
word64be :: ByteString -> Word64
word64be = \ByteString
s ->
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
0) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
56) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
1) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
48) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
2) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
40) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
3) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
32) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
4) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
24) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
5) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
6) forall a. Bits a => a -> Int -> a
`unsafeShiftL`  Int
8) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
7) )
{-# INLINE[2] getWord64be #-}
{-# INLINE word64be #-}

-- | Read a Word64 in little endian format
getWord64le :: Get Word64
getWord64le :: Get Word64
getWord64le = forall a. Int -> (ByteString -> a) -> Get a
readN Int
8 ByteString -> Word64
word64le

word64le :: B.ByteString -> Word64
word64le :: ByteString -> Word64
word64le = \ByteString
s ->
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
7) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
56) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
6) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
48) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
5) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
40) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
4) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
32) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
3) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
24) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
2) forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
16) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
1) forall a. Bits a => a -> Int -> a
`unsafeShiftL`  Int
8) forall a. Bits a => a -> a -> a
.|.
              (forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString
s ByteString -> Int -> Word8
`B.unsafeIndex` Int
0) )
{-# INLINE[2] getWord64le #-}
{-# INLINE word64le #-}


-- | Read an Int16 in big endian format.
getInt16be :: Get Int16
getInt16be :: Get Int16
getInt16be = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word16
getWord16be
{-# INLINE getInt16be #-}

-- | Read an Int32 in big endian format.
getInt32be :: Get Int32
getInt32be :: Get Int32
getInt32be =  forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word32
getWord32be
{-# INLINE getInt32be #-}

-- | Read an Int64 in big endian format.
getInt64be :: Get Int64
getInt64be :: Get Int64
getInt64be = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word64
getWord64be
{-# INLINE getInt64be #-}


-- | Read an Int16 in little endian format.
getInt16le :: Get Int16
getInt16le :: Get Int16
getInt16le = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word16
getWord16le
{-# INLINE getInt16le #-}

-- | Read an Int32 in little endian format.
getInt32le :: Get Int32
getInt32le :: Get Int32
getInt32le =  forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word32
getWord32le
{-# INLINE getInt32le #-}

-- | Read an Int64 in little endian format.
getInt64le :: Get Int64
getInt64le :: Get Int64
getInt64le = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word64
getWord64le
{-# INLINE getInt64le #-}


------------------------------------------------------------------------
-- Host-endian reads

-- | /O(1)./ Read a single native machine word. The word is read in
-- host order, host endian form, for the machine you're on. On a 64 bit
-- machine the Word is an 8 byte value, on a 32 bit machine, 4 bytes.
getWordhost :: Get Word
getWordhost :: Get Word
getWordhost = forall a. Storable a => Int -> Get a
getPtr (forall a. Storable a => a -> Int
sizeOf (forall a. HasCallStack => a
undefined :: Word))
{-# INLINE getWordhost #-}

-- | /O(1)./ Read a 2 byte Word16 in native host order and host endianness.
getWord16host :: Get Word16
getWord16host :: Get Word16
getWord16host = forall a. Storable a => Int -> Get a
getPtr (forall a. Storable a => a -> Int
sizeOf (forall a. HasCallStack => a
undefined :: Word16))
{-# INLINE getWord16host #-}

-- | /O(1)./ Read a Word32 in native host order and host endianness.
getWord32host :: Get Word32
getWord32host :: Get Word32
getWord32host = forall a. Storable a => Int -> Get a
getPtr  (forall a. Storable a => a -> Int
sizeOf (forall a. HasCallStack => a
undefined :: Word32))
{-# INLINE getWord32host #-}

-- | /O(1)./ Read a Word64 in native host order and host endianess.
getWord64host   :: Get Word64
getWord64host :: Get Word64
getWord64host = forall a. Storable a => Int -> Get a
getPtr  (forall a. Storable a => a -> Int
sizeOf (forall a. HasCallStack => a
undefined :: Word64))
{-# INLINE getWord64host #-}

-- | /O(1)./ Read a single native machine word in native host
-- order. It works in the same way as 'getWordhost'.
getInthost :: Get Int
getInthost :: Get Int
getInthost = forall a. Storable a => Int -> Get a
getPtr (forall a. Storable a => a -> Int
sizeOf (forall a. HasCallStack => a
undefined :: Int))
{-# INLINE getInthost #-}

-- | /O(1)./ Read a 2 byte Int16 in native host order and host endianness.
getInt16host :: Get Int16
getInt16host :: Get Int16
getInt16host = forall a. Storable a => Int -> Get a
getPtr (forall a. Storable a => a -> Int
sizeOf (forall a. HasCallStack => a
undefined :: Int16))
{-# INLINE getInt16host #-}

-- | /O(1)./ Read an Int32 in native host order and host endianness.
getInt32host :: Get Int32
getInt32host :: Get Int32
getInt32host = forall a. Storable a => Int -> Get a
getPtr  (forall a. Storable a => a -> Int
sizeOf (forall a. HasCallStack => a
undefined :: Int32))
{-# INLINE getInt32host #-}

-- | /O(1)./ Read an Int64 in native host order and host endianess.
getInt64host   :: Get Int64
getInt64host :: Get Int64
getInt64host = forall a. Storable a => Int -> Get a
getPtr  (forall a. Storable a => a -> Int
sizeOf (forall a. HasCallStack => a
undefined :: Int64))
{-# INLINE getInt64host #-}


------------------------------------------------------------------------
-- Double/Float reads

-- | Read a 'Float' in big endian IEEE-754 format.
getFloatbe :: Get Float
getFloatbe :: Get Float
getFloatbe = Word32 -> Float
wordToFloat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word32
getWord32be
{-# INLINE getFloatbe #-}

-- | Read a 'Float' in little endian IEEE-754 format.
getFloatle :: Get Float
getFloatle :: Get Float
getFloatle = Word32 -> Float
wordToFloat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word32
getWord32le
{-# INLINE getFloatle #-}

-- | Read a 'Float' in IEEE-754 format and host endian.
getFloathost :: Get Float
getFloathost :: Get Float
getFloathost = Word32 -> Float
wordToFloat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word32
getWord32host
{-# INLINE getFloathost #-}

-- | Read a 'Double' in big endian IEEE-754 format.
getDoublebe :: Get Double
getDoublebe :: Get Double
getDoublebe = Word64 -> Double
wordToDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word64
getWord64be
{-# INLINE getDoublebe #-}

-- | Read a 'Double' in little endian IEEE-754 format.
getDoublele :: Get Double
getDoublele :: Get Double
getDoublele = Word64 -> Double
wordToDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word64
getWord64le
{-# INLINE getDoublele #-}

-- | Read a 'Double' in IEEE-754 format and host endian.
getDoublehost :: Get Double
getDoublehost :: Get Double
getDoublehost = Word64 -> Double
wordToDouble forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word64
getWord64host
{-# INLINE getDoublehost #-}