{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings     #-}

module HaskellWorks.Data.Json.Internal.Standard.Token.Tokenize
    ( IsChar(..)
    , JsonToken(..)
    , ParseJson(..)
    ) where

import Control.Applicative
import Data.Bits
import Data.Char
import Data.Word
import Data.Word8
import HaskellWorks.Data.Char.IsChar
import HaskellWorks.Data.Json.Internal.Token.Types
import HaskellWorks.Data.Parser                    ((<?>))

import qualified Data.Attoparsec.ByteString.Char8 as BC
import qualified Data.Attoparsec.Combinator       as AC
import qualified Data.Attoparsec.Types            as T
import qualified Data.ByteString                  as BS
import qualified HaskellWorks.Data.Parser         as P

{- HLINT ignore "Reduce duplication" -}

hexDigitNumeric :: P.Parser t u => T.Parser t Int
hexDigitNumeric :: forall t u. Parser t u => Parser t Int
hexDigitNumeric = do
  Char
c <- forall t e. Parser t e => (Char -> Bool) -> Parser t Char
P.satisfyChar (\Char
c -> Char
'0' forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c forall a. Ord a => a -> a -> Bool
<= Char
'9')
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Char -> Int
ord Char
c forall a. Num a => a -> a -> a
- Char -> Int
ord Char
'0'

hexDigitAlphaLower :: P.Parser t u => T.Parser t Int
hexDigitAlphaLower :: forall t u. Parser t u => Parser t Int
hexDigitAlphaLower = do
  Char
c <- forall t e. Parser t e => (Char -> Bool) -> Parser t Char
P.satisfyChar (\Char
c -> Char
'a' forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c forall a. Ord a => a -> a -> Bool
<= Char
'z')
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Char -> Int
ord Char
c forall a. Num a => a -> a -> a
- Char -> Int
ord Char
'a' forall a. Num a => a -> a -> a
+ Int
10

hexDigitAlphaUpper :: P.Parser t u => T.Parser t Int
hexDigitAlphaUpper :: forall t u. Parser t u => Parser t Int
hexDigitAlphaUpper = do
  Char
c <- forall t e. Parser t e => (Char -> Bool) -> Parser t Char
P.satisfyChar (\Char
c -> Char
'A' forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c forall a. Ord a => a -> a -> Bool
<= Char
'Z')
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Char -> Int
ord Char
c forall a. Num a => a -> a -> a
- Char -> Int
ord Char
'A' forall a. Num a => a -> a -> a
+ Int
10

hexDigit :: P.Parser t u => T.Parser t Int
hexDigit :: forall t u. Parser t u => Parser t Int
hexDigit = forall t u. Parser t u => Parser t Int
hexDigitNumeric forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall t u. Parser t u => Parser t Int
hexDigitAlphaLower forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall t u. Parser t u => Parser t Int
hexDigitAlphaUpper

class ParseJson t s d where
  parseJsonTokenString :: T.Parser t (JsonToken s d)
  parseJsonToken :: T.Parser t (JsonToken s d)
  parseJsonTokenBraceL :: T.Parser t (JsonToken s d)
  parseJsonTokenBraceR :: T.Parser t (JsonToken s d)
  parseJsonTokenBracketL :: T.Parser t (JsonToken s d)
  parseJsonTokenBracketR :: T.Parser t (JsonToken s d)
  parseJsonTokenComma :: T.Parser t (JsonToken s d)
  parseJsonTokenColon :: T.Parser t (JsonToken s d)
  parseJsonTokenWhitespace :: T.Parser t (JsonToken s d)
  parseJsonTokenNull :: T.Parser t (JsonToken s d)
  parseJsonTokenBoolean :: T.Parser t (JsonToken s d)
  parseJsonTokenDouble :: T.Parser t (JsonToken s d)

  parseJsonToken =
    forall t s d. ParseJson t s d => Parser t (JsonToken s d)
parseJsonTokenString     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall t s d. ParseJson t s d => Parser t (JsonToken s d)
parseJsonTokenBraceL     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall t s d. ParseJson t s d => Parser t (JsonToken s d)
parseJsonTokenBraceR     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall t s d. ParseJson t s d => Parser t (JsonToken s d)
parseJsonTokenBracketL   forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall t s d. ParseJson t s d => Parser t (JsonToken s d)
parseJsonTokenBracketR   forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall t s d. ParseJson t s d => Parser t (JsonToken s d)
parseJsonTokenComma      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall t s d. ParseJson t s d => Parser t (JsonToken s d)
parseJsonTokenColon      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall t s d. ParseJson t s d => Parser t (JsonToken s d)
parseJsonTokenWhitespace forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall t s d. ParseJson t s d => Parser t (JsonToken s d)
parseJsonTokenNull       forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall t s d. ParseJson t s d => Parser t (JsonToken s d)
parseJsonTokenBoolean    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall t s d. ParseJson t s d => Parser t (JsonToken s d)
parseJsonTokenDouble

instance ParseJson BS.ByteString String Double where
  parseJsonTokenBraceL :: Parser ByteString (JsonToken String Double)
parseJsonTokenBraceL    = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"{" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenBraceL
  parseJsonTokenBraceR :: Parser ByteString (JsonToken String Double)
parseJsonTokenBraceR    = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"}" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenBraceR
  parseJsonTokenBracketL :: Parser ByteString (JsonToken String Double)
parseJsonTokenBracketL  = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"[" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenBracketL
  parseJsonTokenBracketR :: Parser ByteString (JsonToken String Double)
parseJsonTokenBracketR  = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"]" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenBracketR
  parseJsonTokenComma :: Parser ByteString (JsonToken String Double)
parseJsonTokenComma     = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"," forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenComma
  parseJsonTokenColon :: Parser ByteString (JsonToken String Double)
parseJsonTokenColon     = forall t e. Parser t e => t -> Parser t t
P.string ByteString
":" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenColon
  parseJsonTokenNull :: Parser ByteString (JsonToken String Double)
parseJsonTokenNull      = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"null" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenNull
  parseJsonTokenDouble :: Parser ByteString (JsonToken String Double)
parseJsonTokenDouble    = forall s d. d -> JsonToken s d
JsonTokenNumber forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall t e f. (Parser t e, Fractional f) => Parser t f
P.rational

  parseJsonTokenString :: Parser ByteString (JsonToken String Double)
parseJsonTokenString = do
    ByteString
_ <- forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\""
    String
value <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser ByteString Char
verbatimChar forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ByteString Char
escapedChar forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ByteString Char
escapedCode)
    ByteString
_ <- forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\""
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall s d. s -> JsonToken s d
JsonTokenString String
value
    where
      verbatimChar :: Parser ByteString Char
verbatimChar  = forall t e. Parser t e => (Char -> Bool) -> Parser t Char
P.satisfyChar (String -> Char -> Bool
BC.notInClass String
"\"\\") forall t e. Parser t e => Parser t Char -> String -> Parser t Char
<?> String
"invalid string character"
      escapedChar :: Parser ByteString Char
escapedChar   = do
        ByteString
_ <- forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\\"
        (   forall t e. Parser t e => Char -> Parser t Char
P.char Char
'"'  forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'"'  ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( forall t e. Parser t e => Char -> Parser t Char
P.char Char
'b'  forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\b' ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( forall t e. Parser t e => Char -> Parser t Char
P.char Char
'n'  forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\n' ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( forall t e. Parser t e => Char -> Parser t Char
P.char Char
'f'  forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\f' ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( forall t e. Parser t e => Char -> Parser t Char
P.char Char
'r'  forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\r' ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( forall t e. Parser t e => Char -> Parser t Char
P.char Char
't'  forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\t' ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( forall t e. Parser t e => Char -> Parser t Char
P.char Char
'\\' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\\' ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( forall t e. Parser t e => Char -> Parser t Char
P.char Char
'\'' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\'' ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( forall t e. Parser t e => Char -> Parser t Char
P.char Char
'/'  forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'/'  )
      escapedCode :: Parser ByteString Char
escapedCode   = do
        ByteString
_ <- forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\\u"
        Int
a <- forall t u. Parser t u => Parser t Int
hexDigit
        Int
b <- forall t u. Parser t u => Parser t Int
hexDigit
        Int
c <- forall t u. Parser t u => Parser t Int
hexDigit
        Int
d <- forall t u. Parser t u => Parser t Int
hexDigit
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int -> Char
chr forall a b. (a -> b) -> a -> b
$ Int
a forall a. Bits a => a -> Int -> a
`shift` Int
24 forall a. Bits a => a -> a -> a
.|. Int
b forall a. Bits a => a -> Int -> a
`shift` Int
16 forall a. Bits a => a -> a -> a
.|. Int
c forall a. Bits a => a -> Int -> a
`shift` Int
8 forall a. Bits a => a -> a -> a
.|. Int
d

  parseJsonTokenWhitespace :: Parser ByteString (JsonToken String Double)
parseJsonTokenWhitespace = do
    [ByteString]
_ <- forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
AC.many1' forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Alternative f => [f a] -> f a
BC.choice [forall t e. Parser t e => t -> Parser t t
P.string ByteString
" ", forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\t", forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\n", forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\r"]
    forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenWhitespace

  parseJsonTokenBoolean :: Parser ByteString (JsonToken String Double)
parseJsonTokenBoolean = forall {s} {d}. Parser ByteString (JsonToken s d)
true forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall {s} {d}. Parser ByteString (JsonToken s d)
false
    where true :: Parser ByteString (JsonToken s d)
true  = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"true"   forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return (forall s d. Bool -> JsonToken s d
JsonTokenBoolean Bool
True)
          false :: Parser ByteString (JsonToken s d)
false = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"false"  forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return (forall s d. Bool -> JsonToken s d
JsonTokenBoolean Bool
False)

instance ParseJson BS.ByteString BS.ByteString Double where
  parseJsonTokenBraceL :: Parser ByteString (JsonToken ByteString Double)
parseJsonTokenBraceL    = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"{" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenBraceL
  parseJsonTokenBraceR :: Parser ByteString (JsonToken ByteString Double)
parseJsonTokenBraceR    = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"}" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenBraceR
  parseJsonTokenBracketL :: Parser ByteString (JsonToken ByteString Double)
parseJsonTokenBracketL  = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"[" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenBracketL
  parseJsonTokenBracketR :: Parser ByteString (JsonToken ByteString Double)
parseJsonTokenBracketR  = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"]" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenBracketR
  parseJsonTokenComma :: Parser ByteString (JsonToken ByteString Double)
parseJsonTokenComma     = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"," forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenComma
  parseJsonTokenColon :: Parser ByteString (JsonToken ByteString Double)
parseJsonTokenColon     = forall t e. Parser t e => t -> Parser t t
P.string ByteString
":" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenColon
  parseJsonTokenNull :: Parser ByteString (JsonToken ByteString Double)
parseJsonTokenNull      = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"null" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenNull
  parseJsonTokenDouble :: Parser ByteString (JsonToken ByteString Double)
parseJsonTokenDouble    = forall s d. d -> JsonToken s d
JsonTokenNumber forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall t e f. (Parser t e, Fractional f) => Parser t f
P.rational

  parseJsonTokenString :: Parser ByteString (JsonToken ByteString Double)
parseJsonTokenString = do
    ByteString
_ <- forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\""
    [Word8]
value <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser ByteString Word8
verbatimChar forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ByteString Word8
escapedChar forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ByteString Word8
escapedCode)
    ByteString
_ <- forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\""
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall s d. s -> JsonToken s d
JsonTokenString forall a b. (a -> b) -> a -> b
$ [Word8] -> ByteString
BS.pack [Word8]
value
    where
      word :: Word8 -> T.Parser BS.ByteString Word8
      word :: Word8 -> Parser ByteString Word8
word Word8
w = forall t e. Parser t e => (e -> Bool) -> Parser t e
P.satisfy (forall a. Eq a => a -> a -> Bool
== Word8
w)
      verbatimChar :: T.Parser BS.ByteString Word8
      verbatimChar :: Parser ByteString Word8
verbatimChar  = forall t e. Parser t e => (e -> Bool) -> Parser t e
P.satisfy (\Word8
w -> Word8
w forall a. Eq a => a -> a -> Bool
/= Word8
_quotedbl Bool -> Bool -> Bool
&& Word8
w forall a. Eq a => a -> a -> Bool
/= Word8
_backslash) -- <?> "invalid string character"
      escapedChar :: T.Parser BS.ByteString Word8
      escapedChar :: Parser ByteString Word8
escapedChar   = do
        ByteString
_ <- forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\\"
        (   Word8 -> Parser ByteString Word8
word Word8
_quotedbl    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Word8
_quotedbl       ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( Word8 -> Parser ByteString Word8
word Word8
_b           forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Word8
0x08            ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( Word8 -> Parser ByteString Word8
word Word8
_n           forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Word8
_lf             ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( Word8 -> Parser ByteString Word8
word Word8
_f           forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Word8
_np             ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( Word8 -> Parser ByteString Word8
word Word8
_r           forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Word8
_cr             ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( Word8 -> Parser ByteString Word8
word Word8
_t           forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Word8
_tab            ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( Word8 -> Parser ByteString Word8
word Word8
_backslash   forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Word8
_backslash      ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( Word8 -> Parser ByteString Word8
word Word8
_quotesingle forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Word8
_quotesingle    ) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          ( Word8 -> Parser ByteString Word8
word Word8
_slash       forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Word8
_slash          )
      escapedCode :: T.Parser BS.ByteString Word8
      escapedCode :: Parser ByteString Word8
escapedCode   = do
        ByteString
_ <- forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\\u"
        Int
a <- forall t u. Parser t u => Parser t Int
hexDigit
        Int
b <- forall t u. Parser t u => Parser t Int
hexDigit
        Int
c <- forall t u. Parser t u => Parser t Int
hexDigit
        Int
d <- forall t u. Parser t u => Parser t Int
hexDigit
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Int
a forall a. Bits a => a -> Int -> a
`shift` Int
24 forall a. Bits a => a -> a -> a
.|. Int
b forall a. Bits a => a -> Int -> a
`shift` Int
16 forall a. Bits a => a -> a -> a
.|. Int
c forall a. Bits a => a -> Int -> a
`shift` Int
8 forall a. Bits a => a -> a -> a
.|. Int
d

  parseJsonTokenWhitespace :: Parser ByteString (JsonToken ByteString Double)
parseJsonTokenWhitespace = do
    [ByteString]
_ <- forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
AC.many1' forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Alternative f => [f a] -> f a
BC.choice [forall t e. Parser t e => t -> Parser t t
P.string ByteString
" ", forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\t", forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\n", forall t e. Parser t e => t -> Parser t t
P.string ByteString
"\r"]
    forall (m :: * -> *) a. Monad m => a -> m a
return forall s d. JsonToken s d
JsonTokenWhitespace

  parseJsonTokenBoolean :: Parser ByteString (JsonToken ByteString Double)
parseJsonTokenBoolean = forall {s} {d}. Parser ByteString (JsonToken s d)
true forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall {s} {d}. Parser ByteString (JsonToken s d)
false
    where
      true :: Parser ByteString (JsonToken s d)
true  = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"true"   forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return (forall s d. Bool -> JsonToken s d
JsonTokenBoolean Bool
True)
      false :: Parser ByteString (JsonToken s d)
false = forall t e. Parser t e => t -> Parser t t
P.string ByteString
"false"  forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return (forall s d. Bool -> JsonToken s d
JsonTokenBoolean Bool
False)