module Data.Binary.Parser.Char8 where
import Control.Applicative
import qualified Data.Binary.Get as BG
import Data.Binary.Get.Internal
import qualified Data.Binary.Parser.Word8 as W
import Data.ByteString (ByteString)
import qualified Data.ByteString as B
import Data.ByteString.Internal (c2w, w2c)
import qualified Data.ByteString.Unsafe as B
import Prelude hiding (takeWhile)
peekMaybe :: Get (Maybe Char)
peekMaybe :: Get (Maybe Char)
peekMaybe = (Word8 -> Char) -> Maybe Word8 -> Maybe Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word8 -> Char
w2c (Maybe Word8 -> Maybe Char)
-> Get (Maybe Word8) -> Get (Maybe Char)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get (Maybe Word8)
W.peekMaybe
{-# INLINE peekMaybe #-}
peek :: Get Char
peek :: Get Char
peek = Word8 -> Char
w2c (Word8 -> Char) -> Get Word8 -> Get Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word8
W.peek
{-# INLINE peek #-}
satisfy :: (Char -> Bool) -> Get Char
satisfy :: (Char -> Bool) -> Get Char
satisfy p :: Char -> Bool
p = Word8 -> Char
w2c (Word8 -> Char) -> Get Word8 -> Get Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word8 -> Bool) -> Get Word8
W.satisfy (Char -> Bool
p (Char -> Bool) -> (Word8 -> Char) -> Word8 -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE satisfy #-}
satisfyWith :: (Char -> a) -> (a -> Bool) -> Get a
satisfyWith :: (Char -> a) -> (a -> Bool) -> Get a
satisfyWith f :: Char -> a
f = (Word8 -> a) -> (a -> Bool) -> Get a
forall a. (Word8 -> a) -> (a -> Bool) -> Get a
W.satisfyWith (Char -> a
f (Char -> a) -> (Word8 -> Char) -> Word8 -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE satisfyWith #-}
char :: Char -> Get ()
char :: Char -> Get ()
char c :: Char
c = Word8 -> Get ()
W.word8 (Char -> Word8
c2w Char
c)
{-# INLINE char #-}
anyChar :: Get Char
anyChar :: Get Char
anyChar = Word8 -> Char
w2c (Word8 -> Char) -> Get Word8 -> Get Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word8
BG.getWord8
{-# INLINE anyChar #-}
skipChar :: (Char -> Bool) -> Get ()
skipChar :: (Char -> Bool) -> Get ()
skipChar p :: Char -> Bool
p = (Word8 -> Bool) -> Get ()
W.skipWord8 (Char -> Bool
p (Char -> Bool) -> (Word8 -> Char) -> Word8 -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE skipChar #-}
takeTill :: (Char -> Bool) -> Get ByteString
takeTill :: (Char -> Bool) -> Get ByteString
takeTill p :: Char -> Bool
p = (Word8 -> Bool) -> Get ByteString
W.takeTill (Char -> Bool
p (Char -> Bool) -> (Word8 -> Char) -> Word8 -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE takeTill #-}
takeWhile :: (Char -> Bool) -> Get ByteString
takeWhile :: (Char -> Bool) -> Get ByteString
takeWhile p :: Char -> Bool
p = (Word8 -> Bool) -> Get ByteString
W.takeWhile (Char -> Bool
p (Char -> Bool) -> (Word8 -> Char) -> Word8 -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE takeWhile #-}
takeWhile1 :: (Char -> Bool) -> Get ByteString
takeWhile1 :: (Char -> Bool) -> Get ByteString
takeWhile1 p :: Char -> Bool
p = (Word8 -> Bool) -> Get ByteString
W.takeWhile1 (Char -> Bool
p (Char -> Bool) -> (Word8 -> Char) -> Word8 -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE takeWhile1 #-}
skipWhile :: (Char -> Bool) -> Get ()
skipWhile :: (Char -> Bool) -> Get ()
skipWhile p :: Char -> Bool
p = (Word8 -> Bool) -> Get ()
W.skipWhile (Char -> Bool
p (Char -> Bool) -> (Word8 -> Char) -> Word8 -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Char
w2c)
{-# INLINE skipWhile #-}
stringCI :: ByteString -> Get ByteString
stringCI :: ByteString -> Get ByteString
stringCI bs :: ByteString
bs = do
let l :: Int
l = ByteString -> Int
B.length ByteString
bs
Int -> Get ()
ensureN Int
l
ByteString
bs' <- Int -> ByteString -> ByteString
B.unsafeTake Int
l (ByteString -> ByteString) -> Get ByteString -> Get ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get ByteString
get
if (Word8 -> Word8) -> ByteString -> ByteString
B.map Word8 -> Word8
forall p. (Ord p, Num p) => p -> p
toLower ByteString
bs' ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== (Word8 -> Word8) -> ByteString -> ByteString
B.map Word8 -> Word8
forall p. (Ord p, Num p) => p -> p
toLower ByteString
bs
then ByteString -> Get ()
put (Int -> ByteString -> ByteString
B.unsafeDrop Int
l ByteString
bs') Get () -> Get ByteString -> Get ByteString
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ByteString -> Get ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
bs'
else String -> Get ByteString
forall (m :: * -> *) a. MonadFail m => String -> m a
fail "stringCI"
where
toLower :: p -> p
toLower w :: p
w | p
w p -> p -> Bool
forall a. Ord a => a -> a -> Bool
>= 65 Bool -> Bool -> Bool
&& p
w p -> p -> Bool
forall a. Ord a => a -> a -> Bool
<= 90 = p
w p -> p -> p
forall a. Num a => a -> a -> a
+ 32
| Bool
otherwise = p
w
{-# INLINE stringCI #-}
isSpace :: Char -> Bool
isSpace :: Char -> Bool
isSpace c :: Char
c = (Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== ' ') Bool -> Bool -> Bool
|| ('\t' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= '\r')
{-# INLINE isSpace #-}
isDigit :: Char -> Bool
isDigit :: Char -> Bool
isDigit c :: Char
c = Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= '0' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= '9'
{-# INLINE isDigit #-}
isHexDigit :: Char -> Bool
isHexDigit :: Char -> Bool
isHexDigit c :: Char
c = (Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= '0' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= '9') Bool -> Bool -> Bool
|| (Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= 'a' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= 'f') Bool -> Bool -> Bool
|| (Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= 'A' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= 'F')
{-# INLINE isHexDigit #-}
isHorizontalSpace :: Char -> Bool
isHorizontalSpace :: Char -> Bool
isHorizontalSpace c :: Char
c = Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== ' ' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '\t'
{-# INLINE isHorizontalSpace #-}
isEndOfLine :: Char -> Bool
isEndOfLine :: Char -> Bool
isEndOfLine c :: Char
c = Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '\r' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '\n'
{-# INLINE isEndOfLine #-}