{-# language UnboxedTuples #-}

{-|
This module implements a `Parser` supporting an `Int` reader environment, custom error types, and an
`Int` state.
-}

module FlatParse.Stateful (
  -- * Parser types and constructors
    type Parser(..)
  , type Res#
  , pattern OK#
  , pattern Fail#
  , pattern Err#
  , Result(..)

  -- * Running parsers
  , runParser
  , runParserS

  -- * Actions on the state and the environment
  , get
  , put
  , modify
  , ask
  , local

  -- * Errors and failures
  , empty
  , err
  , lookahead
  , fails
  , try
  , optional
  , optional_
  , optioned
  , cut
  , cutting

  -- * Basic lexing and parsing
  , eof
  , char
  , byte
  , bytes
  , string
  , switch
  , switchWithPost
  , rawSwitchWithPost
  , satisfy
  , satisfy_
  , satisfyASCII
  , satisfyASCII_
  , fusedSatisfy
  , fusedSatisfy_
  , anyWord8
  , anyWord8_
  , anyWord16
  , anyWord16_
  , anyWord32
  , anyWord32_
  , anyWord
  , anyWord_
  , anyChar
  , anyChar_
  , anyCharASCII
  , anyCharASCII_
  , isDigit
  , isGreekLetter
  , isLatinLetter
  , FlatParse.Stateful.readInt
  , FlatParse.Stateful.readInteger

  -- * Combinators
  , (<|>)
  , branch
  , chainl
  , chainr
  , many
  , many_
  , some
  , some_
  , notFollowedBy

  -- * Positions and spans
  , Pos(..)
  , Span(..)
  , getPos
  , setPos
  , endPos
  , spanOf
  , spanned
  , byteStringOf
  , byteStringed
  , inSpan

  -- ** Position and span conversions
  , Basic.validPos
  , Basic.posLineCols
  , unsafeSpanToByteString
  , Basic.unsafeSlice
  , Basic.mkPos
  , Basic.lines

  -- * Getting the rest of the input
  , takeLine
  , traceLine
  , takeRest
  , traceRest

  -- * `String` conversions
  , packUTF8
  , unpackUTF8

  -- * Internal functions
  , ensureBytes#
  , scan8#
  , scan16#
  , scan32#
  , scan64#
  , scanAny8#
  , scanBytes#
  , setBack#

  ) where

import Control.Monad
import Data.Foldable
import Data.Map (Map)
import GHC.Exts
import Language.Haskell.TH
import System.IO.Unsafe
import GHC.ForeignPtr

import qualified Data.ByteString as B
import qualified Data.ByteString.Internal as B
import qualified Data.ByteString.Unsafe as B
import qualified Data.Map.Strict as M

import FlatParse.Internal

import qualified FlatParse.Basic as Basic

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

-- | Primitive result of a parser. Possible results are given by `OK#`, `Err#` and `Fail#`
--   pattern synonyms.
type Res# e a =
  (#
    (# a, Addr#, Int# #)
  | (# #)
  | (# e #)
  #)

-- | Contains return value, pointer to the rest of the input buffer and the nex `Int`
--   state.
pattern OK# :: a -> Addr# -> Int# -> Res# e a
pattern $bOK# :: a -> Addr# -> Int# -> Res# e a
$mOK# :: forall r a e.
Res# e a -> (a -> Addr# -> Int# -> r) -> (Void# -> r) -> r
OK# a s n = (# (# a, s, n #) | | #)

-- | Constructor for errors which are by default non-recoverable.
pattern Err# :: e -> Res# e a
pattern $bErr# :: e -> Res# e a
$mErr# :: forall r e a. Res# e a -> (e -> r) -> (Void# -> r) -> r
Err# e = (# | | (# e #) #)

-- | Constructor for recoverable failure.
pattern Fail# :: Res# e a
pattern $bFail# :: Void# -> forall e a. Res# e a
$mFail# :: forall r e a. Res# e a -> (Void# -> r) -> (Void# -> r) -> r
Fail# = (# | (# #) | #)
{-# complete OK#, Err#, Fail# #-}

-- | @Parser e a@ has an error type @e@ and a return type @a@.
newtype Parser e a = Parser {Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# :: ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a}

instance Functor (Parser e) where
  fmap :: (a -> b) -> Parser e a -> Parser e b
fmap a -> b
f (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
g) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b)
-> Parser e b
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
g ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    OK# a
a Addr#
s Int#
n -> let !b :: b
b = a -> b
f a
a in b -> Addr# -> Int# -> Res# e b
forall a e. a -> Addr# -> Int# -> Res# e a
OK# b
b Addr#
s Int#
n
    Res# e a
x         -> Res# e a -> Res# e b
unsafeCoerce# Res# e a
x
  {-# inline fmap #-}

  <$ :: a -> Parser e b -> Parser e a
(<$) a
a' (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
g) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
g ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    OK# b
a Addr#
s Int#
n -> a -> Addr# -> Int# -> Res# e a
forall a e. a -> Addr# -> Int# -> Res# e a
OK# a
a' Addr#
s Int#
n
    Res# e b
x         -> Res# e b -> Res# e a
unsafeCoerce# Res# e b
x
  {-# inline (<$) #-}

instance Applicative (Parser e) where
  pure :: a -> Parser e a
pure a
a = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> a -> Addr# -> Int# -> Res# e a
forall a e. a -> Addr# -> Int# -> Res# e a
OK# a
a Addr#
s Int#
n
  {-# inline pure #-}
  Parser ForeignPtrContents
-> Int# -> Addr# -> Addr# -> Int# -> Res# e (a -> b)
ff <*> :: Parser e (a -> b) -> Parser e a -> Parser e b
<*> Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
fa = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b)
-> Parser e b
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents
-> Int# -> Addr# -> Addr# -> Int# -> Res# e (a -> b)
ff ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    OK# a -> b
f Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
fa ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
      OK# a
a Addr#
s Int#
n  -> let !b :: b
b = a -> b
f a
a in b -> Addr# -> Int# -> Res# e b
forall a e. a -> Addr# -> Int# -> Res# e a
OK# b
b Addr#
s Int#
n
      Res# e a
x          -> Res# e a -> Res# e b
unsafeCoerce# Res# e a
x
    Res# e (a -> b)
x -> Res# e (a -> b) -> Res# e b
unsafeCoerce# Res# e (a -> b)
x
  {-# inline (<*>) #-}
  Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
fa <* :: Parser e a -> Parser e b -> Parser e a
<* Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
fb = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
fa ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    OK# a
a Addr#
s Int#
n   -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
fb ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
      OK# b
b Addr#
s Int#
n -> a -> Addr# -> Int# -> Res# e a
forall a e. a -> Addr# -> Int# -> Res# e a
OK# a
a Addr#
s Int#
n
      Res# e b
x -> Res# e b -> Res# e a
unsafeCoerce# Res# e b
x
    Res# e a
x -> Res# e a -> Res# e a
unsafeCoerce# Res# e a
x
  {-# inline (<*) #-}
  Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
fa *> :: Parser e a -> Parser e b -> Parser e b
*> Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
fb = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b)
-> Parser e b
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
fa ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    OK# a
a Addr#
s Int#
n -> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
fb ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n
    Res# e a
x         -> Res# e a -> Res# e b
unsafeCoerce# Res# e a
x
  {-# inline (*>) #-}

instance Monad (Parser e) where
  return :: a -> Parser e a
return = a -> Parser e a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
  {-# inline return #-}
  Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
fa >>= :: Parser e a -> (a -> Parser e b) -> Parser e b
>>= a -> Parser e b
f = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b)
-> Parser e b
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
fa ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    OK# a
a Addr#
s Int#
n -> Parser e b
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# (a -> Parser e b
f a
a) ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n
    Res# e a
x         -> Res# e a -> Res# e b
unsafeCoerce# Res# e a
x
  {-# inline (>>=) #-}
  >> :: Parser e a -> Parser e b -> Parser e b
(>>) = Parser e a -> Parser e b -> Parser e b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
(*>)
  {-# inline (>>) #-}

-- | Higher-level boxed data type for parsing results.
data Result e a =
    OK a Int !(B.ByteString)  -- ^ Contains return value, last `Int` state, unconsumed input.
  | Fail                      -- ^ Recoverable-by-default failure.
  | Err !e                    -- ^ Unrecoverble-by-default error.
  deriving Int -> Result e a -> ShowS
[Result e a] -> ShowS
Result e a -> String
(Int -> Result e a -> ShowS)
-> (Result e a -> String)
-> ([Result e a] -> ShowS)
-> Show (Result e a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall e a. (Show a, Show e) => Int -> Result e a -> ShowS
forall e a. (Show a, Show e) => [Result e a] -> ShowS
forall e a. (Show a, Show e) => Result e a -> String
showList :: [Result e a] -> ShowS
$cshowList :: forall e a. (Show a, Show e) => [Result e a] -> ShowS
show :: Result e a -> String
$cshow :: forall e a. (Show a, Show e) => Result e a -> String
showsPrec :: Int -> Result e a -> ShowS
$cshowsPrec :: forall e a. (Show a, Show e) => Int -> Result e a -> ShowS
Show

instance Functor (Result e) where
  fmap :: (a -> b) -> Result e a -> Result e b
fmap a -> b
f (OK a
a Int
s ByteString
n) = let !b :: b
b = a -> b
f a
a in b -> Int -> ByteString -> Result e b
forall e a. a -> Int -> ByteString -> Result e a
OK b
b Int
s ByteString
n
  fmap a -> b
f Result e a
r          = Result e a -> Result e b
unsafeCoerce# Result e a
r
  {-# inline fmap #-}
  <$ :: a -> Result e b -> Result e a
(<$) a
a (OK b
_ Int
s ByteString
n) = a -> Int -> ByteString -> Result e a
forall e a. a -> Int -> ByteString -> Result e a
OK a
a Int
s ByteString
n
  (<$) a
_ Result e b
r          = Result e b -> Result e a
unsafeCoerce# Result e b
r
  {-# inline (<$) #-}

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

-- | Run a parser. The first `Int` argument is the reader environment, while the second one is the
--   state.
runParser :: Parser e a -> Int -> Int -> B.ByteString -> Result e a
runParser :: Parser e a -> Int -> Int -> ByteString -> Result e a
runParser (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) (I# Int#
r) (I# Int#
n) b :: ByteString
b@(B.PS (ForeignPtr Addr#
_ ForeignPtrContents
fp) Int
_ (I# Int#
len)) = IO (Result e a) -> Result e a
forall a. IO a -> a
unsafeDupablePerformIO do
  ByteString -> (CString -> IO (Result e a)) -> IO (Result e a)
forall a. ByteString -> (CString -> IO a) -> IO a
B.unsafeUseAsCString ByteString
b \(Ptr Addr#
buf) -> do
    let end :: Addr#
end = Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
len
    case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
end Addr#
buf Int#
n of
      Err# e
e ->
        Result e a -> IO (Result e a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (e -> Result e a
forall e a. e -> Result e a
Err e
e)
      OK# a
a Addr#
s Int#
n -> do
        let offset :: Int#
offset = Addr# -> Addr# -> Int#
minusAddr# Addr#
s Addr#
buf
        Result e a -> IO (Result e a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> Int -> ByteString -> Result e a
forall e a. a -> Int -> ByteString -> Result e a
OK a
a (Int# -> Int
I# Int#
n) (Int -> ByteString -> ByteString
B.drop (Int# -> Int
I# Int#
offset) ByteString
b))
      Res# e a
Fail# ->
        Result e a -> IO (Result e a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Result e a
forall e a. Result e a
Fail
{-# inlinable runParser #-}

-- | Run a parser on a `String` input. Reminder: @OverloadedStrings@ for `B.ByteString` does not
--   yield a valid UTF-8 encoding! For non-ASCII `B.ByteString` literal input, use `runParserS` or
--   `packUTF8` for testing.
runParserS :: Parser e a -> Int -> Int -> String -> Result e a
runParserS :: Parser e a -> Int -> Int -> String -> Result e a
runParserS Parser e a
pa Int
r !Int
n String
s = Parser e a -> Int -> Int -> ByteString -> Result e a
forall e a. Parser e a -> Int -> Int -> ByteString -> Result e a
runParser Parser e a
pa Int
r Int
n (String -> ByteString
packUTF8 String
s)

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

-- | Query the `Int` state.
get :: Parser e Int
get :: Parser e Int
get = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Int)
-> Parser e Int
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> Int -> Addr# -> Int# -> Res# e Int
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Int# -> Int
I# Int#
n) Addr#
s Int#
n
{-# inline get #-}

-- | Write the `Int` state.
put :: Int -> Parser e ()
put :: Int -> Parser e ()
put (I# Int#
n) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
_ -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () Addr#
s Int#
n
{-# inline put #-}

-- | Modify the `Int` state.
modify :: (Int -> Int) -> Parser e ()
modify :: (Int -> Int) -> Parser e ()
modify Int -> Int
f = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n ->
  case Int -> Int
f (Int# -> Int
I# Int#
n) of
    I# Int#
n -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () Addr#
s Int#
n
{-# inline modify #-}

-- | Query the `Int` environment.
ask :: Parser e Int
ask :: Parser e Int
ask = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Int)
-> Parser e Int
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> Int -> Addr# -> Int# -> Res# e Int
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Int# -> Int
I# Int#
r) Addr#
s Int#
n
{-# inline ask #-}

-- | Run a parser in a modified environment.
local :: (Int -> Int) -> Parser e a -> Parser e a
local :: (Int -> Int) -> Parser e a -> Parser e a
local Int -> Int
f (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
g) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> let !(I# Int#
r') = Int -> Int
f (Int# -> Int
I# Int#
r) in ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
g ForeignPtrContents
fp Int#
r' Addr#
eob Addr#
s Int#
n
{-# inline local #-}

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

-- | The failing parser. By default, parser choice `(<|>)` arbitrarily backtracks
--   on parser failure.
empty :: Parser e a
empty :: Parser e a
empty = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> Res# e a
forall e a. Res# e a
Fail#
{-# inline empty #-}

-- | Throw a parsing error. By default, parser choice `(<|>)` can't backtrack
--   on parser error. Use `try` to convert an error to a recoverable failure.
err :: e -> Parser e a
err :: e -> Parser e a
err e
e = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> e -> Res# e a
forall e a. e -> Res# e a
Err# e
e
{-# inline err #-}

-- | Save the parsing state, then run a parser, then restore the state.
lookahead :: Parser e a -> Parser e a
lookahead :: Parser e a -> Parser e a
lookahead (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n ->
  case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    OK# a
a Addr#
_ Int#
_ -> a -> Addr# -> Int# -> Res# e a
forall a e. a -> Addr# -> Int# -> Res# e a
OK# a
a Addr#
s Int#
n
    Res# e a
x         -> Res# e a
x
{-# inline lookahead #-}

-- | Convert a parsing failure to a success.
fails :: Parser e a -> Parser e ()
fails :: Parser e a -> Parser e ()
fails (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n ->
  case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    OK# a
_ Addr#
_ Int#
_ -> Res# e ()
forall e a. Res# e a
Fail#
    Res# e a
Fail#     -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () Addr#
s Int#
n
    Err# e
e    -> e -> Res# e ()
forall e a. e -> Res# e a
Err# e
e
{-# inline fails #-}

-- | Convert a parsing error into failure.
try :: Parser e a -> Parser e a
try :: Parser e a -> Parser e a
try (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
  Err# e
_ -> Res# e a
forall e a. Res# e a
Fail#
  Res# e a
x      -> Res# e a
x
{-# inline try #-}

-- | Convert a parsing failure to a `Maybe`. If possible, use `optioned` instead.
optional :: Parser e a -> Parser e (Maybe a)
optional :: Parser e a -> Parser e (Maybe a)
optional Parser e a
p = (a -> Maybe a
forall k1. k1 -> Maybe k1
Just (a -> Maybe a) -> Parser e a -> Parser e (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser e a
p) Parser e (Maybe a) -> Parser e (Maybe a) -> Parser e (Maybe a)
forall e a. Parser e a -> Parser e a -> Parser e a
<|> Maybe a -> Parser e (Maybe a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe a
forall k1. Maybe k1
Nothing
{-# inline optional #-}

-- | Convert a parsing failure to a `()`.
optional_ :: Parser e a -> Parser e ()
optional_ :: Parser e a -> Parser e ()
optional_ Parser e a
p = (() () -> Parser e a -> Parser e ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Parser e a
p) Parser e () -> Parser e () -> Parser e ()
forall e a. Parser e a -> Parser e a -> Parser e a
<|> () -> Parser e ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
{-# inline optional_ #-}

-- | CPS'd version of `optional`. This is usually more efficient, since it gets rid of the
--   extra `Maybe` allocation.
optioned :: Parser e a -> (a -> Parser e b) -> Parser e b -> Parser e b
optioned :: Parser e a -> (a -> Parser e b) -> Parser e b -> Parser e b
optioned (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) a -> Parser e b
just (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
nothing) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b)
-> Parser e b
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
  OK# a
a Addr#
s Int#
n -> Parser e b
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# (a -> Parser e b
just a
a) ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n
  Res# e a
Fail#     -> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
nothing ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n
  Err# e
e    -> e -> Res# e b
forall e a. e -> Res# e a
Err# e
e
{-# inline optioned #-}

-- | Convert a parsing failure to an error.
cut :: Parser e a -> e -> Parser e a
cut :: Parser e a -> e -> Parser e a
cut (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) e
e = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
  Res# e a
Fail# -> e -> Res# e a
forall e a. e -> Res# e a
Err# e
e
  Res# e a
x     -> Res# e a
x
{-# inline cut #-}

-- | Run the parser, if we get a failure, throw the given error, but if we get an error, merge the
--   inner and the newly given errors using the @e -> e -> e@ function. This can be useful for
--   implementing parsing errors which may propagate hints or accummulate contextual information.
cutting :: Parser e a -> e -> (e -> e -> e) -> Parser e a
cutting :: Parser e a -> e -> (e -> e -> e) -> Parser e a
cutting (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) e
e e -> e -> e
merge = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
  Res# e a
Fail#   -> e -> Res# e a
forall e a. e -> Res# e a
Err# e
e
  Err# e
e' -> let !e'' :: e
e'' = e -> e -> e
merge e
e' e
e in e -> Res# e a
forall e a. e -> Res# e a
Err# e
e''
  Res# e a
x       -> Res# e a
x
{-# inline cutting #-}

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


-- | Succeed if the input is empty.
eof :: Parser e ()
eof :: Parser e ()
eof = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob Addr#
s of
  Int#
1# -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () Addr#
s Int#
n
  Int#
_  -> Res# e ()
forall e a. Res# e a
Fail#
{-# inline eof #-}

-- | Parse a UTF-8 character literal. This is a template function, you can use it as
--   @$(char \'x\')@, for example, and the splice in this case has type @Parser e ()@.
char :: Char -> Q Exp
char :: Char -> Q Exp
char Char
c = String -> Q Exp
string [Char
c]

-- | Read a byte.
byte :: Word -> Parser e ()
byte :: Word -> Parser e ()
byte (W# Word#
w) = Int -> Parser e ()
forall e. Int -> Parser e ()
ensureBytes# Int
1 Parser e () -> Parser e () -> Parser e ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word -> Parser e ()
forall e. Word -> Parser e ()
scan8# (Word# -> Word
W# Word#
w)
{-# inline byte #-}

-- | Read a sequence of bytes. This is a template function, you can use it as @$(bytes [3, 4, 5])@,
--   for example, and the splice has type @Parser e ()@.
bytes :: [Word] -> Q Exp
bytes :: [Word] -> Q Exp
bytes [Word]
bytes = do
  let !len :: Int
len = [Word] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Word]
bytes
  [| ensureBytes# len >> $(scanBytes# bytes) |]

-- | Parse a UTF-8 string literal. This is a template function, you can use it as @$(string "foo")@,
--   for example, and the splice has type @Parser e ()@.
string :: String -> Q Exp
string :: String -> Q Exp
string String
str = [Word] -> Q Exp
bytes (String -> [Word]
strToBytes String
str)

{-|
This is a template function which makes it possible to branch on a collection of string literals in
an efficient way. By using `switch`, such branching is compiled to a trie of primitive parsing
operations, which has optimized control flow, vectorized reads and grouped checking for needed input
bytes.

The syntax is slightly magical, it overloads the usual @case@ expression. An example:

@
    $(switch [| case _ of
        "foo" -> pure True
        "bar" -> pure False |])
@

The underscore is mandatory in @case _ of@. Each branch must be a string literal, but optionally
we may have a default case, like in

@
    $(switch [| case _ of
        "foo" -> pure 10
        "bar" -> pure 20
        _     -> pure 30 |])
@

All case right hand sides must be parsers with the same type. That type is also the type
of the whole `switch` expression.

A `switch` has longest match semantics, and the order of cases does not matter, except for
the default case, which may only appear as the last case.

If a `switch` does not have a default case, and no case matches the input, then it returns with
failure, \without\ having consumed any input. A fallthrough to the default case also does not
consume any input.
-}
switch :: Q Exp -> Q Exp
switch :: Q Exp -> Q Exp
switch = Maybe (Q Exp) -> Q Exp -> Q Exp
switchWithPost Maybe (Q Exp)
forall k1. Maybe k1
Nothing

{-|
Switch expression with an optional first argument for performing a post-processing action after
every successful branch matching. For example, if we have @ws :: Parser e ()@ for a
whitespace parser, we might want to consume whitespace after matching on any of the switch
cases. For that case, we can define a "lexeme" version of `switch` as follows.

@
  switch' :: Q Exp -> Q Exp
  switch' = switchWithPost (Just [| ws |])
@

Note that this @switch'@ function cannot be used in the same module it's defined in, because of the
stage restriction of Template Haskell.
-}
switchWithPost :: Maybe (Q Exp) -> Q Exp -> Q Exp
switchWithPost :: Maybe (Q Exp) -> Q Exp -> Q Exp
switchWithPost Maybe (Q Exp)
postAction Q Exp
exp = do
  !Maybe Exp
postAction <- Maybe (Q Exp) -> Q (Maybe Exp)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence Maybe (Q Exp)
postAction
  (![(String, Exp)]
cases, !Maybe Exp
fallback) <- Q Exp -> Q ([(String, Exp)], Maybe Exp)
parseSwitch Q Exp
exp
  (Map (Maybe Int) Exp, Trie' (Maybe Int, Int, Maybe Int)) -> Q Exp
genTrie ((Map (Maybe Int) Exp, Trie' (Maybe Int, Int, Maybe Int)) -> Q Exp)
-> (Map (Maybe Int) Exp, Trie' (Maybe Int, Int, Maybe Int))
-> Q Exp
forall a b. (a -> b) -> a -> b
$! Maybe Exp
-> [(String, Exp)]
-> Maybe Exp
-> (Map (Maybe Int) Exp, Trie' (Maybe Int, Int, Maybe Int))
genSwitchTrie' Maybe Exp
postAction [(String, Exp)]
cases Maybe Exp
fallback

-- | Version of `switchWithPost` without syntactic sugar. The second argument is the
--   list of cases, the third is the default case.
rawSwitchWithPost :: Maybe (Q Exp) -> [(String, Q Exp)] -> Maybe (Q Exp) -> Q Exp
rawSwitchWithPost :: Maybe (Q Exp) -> [(String, Q Exp)] -> Maybe (Q Exp) -> Q Exp
rawSwitchWithPost Maybe (Q Exp)
postAction [(String, Q Exp)]
cases Maybe (Q Exp)
fallback = do
  !Maybe Exp
postAction <- Maybe (Q Exp) -> Q (Maybe Exp)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence Maybe (Q Exp)
postAction
  ![(String, Exp)]
cases <- [(String, Q Exp)]
-> ((String, Q Exp) -> Q (String, Exp)) -> Q [(String, Exp)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(String, Q Exp)]
cases \(String
str, Q Exp
rhs) -> (String
str,) (Exp -> (String, Exp)) -> Q Exp -> Q (String, Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Q Exp
rhs
  !Maybe Exp
fallback <- Maybe (Q Exp) -> Q (Maybe Exp)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence Maybe (Q Exp)
fallback
  (Map (Maybe Int) Exp, Trie' (Maybe Int, Int, Maybe Int)) -> Q Exp
genTrie ((Map (Maybe Int) Exp, Trie' (Maybe Int, Int, Maybe Int)) -> Q Exp)
-> (Map (Maybe Int) Exp, Trie' (Maybe Int, Int, Maybe Int))
-> Q Exp
forall a b. (a -> b) -> a -> b
$! Maybe Exp
-> [(String, Exp)]
-> Maybe Exp
-> (Map (Maybe Int) Exp, Trie' (Maybe Int, Int, Maybe Int))
genSwitchTrie' Maybe Exp
postAction [(String, Exp)]
cases Maybe Exp
fallback

-- | Parse a UTF-8 `Char` for which a predicate holds.
satisfy :: (Char -> Bool) -> Parser e Char
satisfy :: (Char -> Bool) -> Parser e Char
satisfy Char -> Bool
f = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Char)
-> Parser e Char
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case Parser Any Char
-> ForeignPtrContents
-> Int#
-> Addr#
-> Addr#
-> Int#
-> Res# Any Char
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# Parser Any Char
forall e. Parser e Char
anyChar ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
  OK# Char
c Addr#
s Int#
n | Char -> Bool
f Char
c -> Char -> Addr# -> Int# -> Res# e Char
forall a e. a -> Addr# -> Int# -> Res# e a
OK# Char
c Addr#
s Int#
n
  Res# Any Char
_               -> Res# e Char
forall e a. Res# e a
Fail#
{-#  inline satisfy #-}

-- | Skip a UTF-8 `Char` for which a predicate holds.
satisfy_ :: (Char -> Bool) -> Parser e ()
satisfy_ :: (Char -> Bool) -> Parser e ()
satisfy_ Char -> Bool
f = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case Parser Any Char
-> ForeignPtrContents
-> Int#
-> Addr#
-> Addr#
-> Int#
-> Res# Any Char
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# Parser Any Char
forall e. Parser e Char
anyChar ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
  OK# Char
c Addr#
s Int#
n | Char -> Bool
f Char
c -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () Addr#
s Int#
n
  Res# Any Char
_               -> Res# e ()
forall e a. Res# e a
Fail#
{-#  inline satisfy_ #-}

-- | Parse an ASCII `Char` for which a predicate holds. Assumption: the predicate must only return
--   `True` for ASCII-range characters. Otherwise this function might read a 128-255 range byte,
--   thereby breaking UTF-8 decoding.
satisfyASCII :: (Char -> Bool) -> Parser e Char
satisfyASCII :: (Char -> Bool) -> Parser e Char
satisfyASCII Char -> Bool
f = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Char)
-> Parser e Char
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob Addr#
s of
  Int#
1# -> Res# e Char
forall e a. Res# e a
Fail#
  Int#
_  -> case Addr# -> Char#
derefChar8# Addr#
s of
    Char#
c1 | Char -> Bool
f (Char# -> Char
C# Char#
c1) -> Char -> Addr# -> Int# -> Res# e Char
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Char# -> Char
C# Char#
c1) (Addr# -> Int# -> Addr#
plusAddr# Addr#
s Int#
1#) Int#
n
       | Bool
otherwise -> Res# e Char
forall e a. Res# e a
Fail#
{-#  inline satisfyASCII #-}

-- | Skip an ASCII `Char` for which a predicate holds.  Assumption: the
--   predicate must only return `True` for ASCII-range characters.
satisfyASCII_ :: (Char -> Bool) -> Parser e ()
satisfyASCII_ :: (Char -> Bool) -> Parser e ()
satisfyASCII_ Char -> Bool
f = () () -> Parser e Char -> Parser e ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (Char -> Bool) -> Parser e Char
forall e. (Char -> Bool) -> Parser e Char
satisfyASCII Char -> Bool
f
{-# inline satisfyASCII_ #-}

-- | This is a variant of `satisfy` which allows more optimization. We can pick four testing
--   functions for the four cases for the possible number of bytes in the UTF-8 character. So in
--   @fusedSatisfy f1 f2 f3 f4@, if we read a one-byte character, the result is scrutinized with
--   @f1@, for two-bytes, with @f2@, and so on. This can result in dramatic lexing speedups.
--
--   For example, if we want to accept any letter, the naive solution would be to use
--   `Data.Char.isLetter`, but this accesses a large lookup table of Unicode character classes. We
--   can do better with @fusedSatisfy isLatinLetter isLetter isLetter isLetter@, since here the
--   `isLatinLetter` is inlined into the UTF-8 decoding, and it probably handles a great majority of
--   all cases without accessing the character table.
fusedSatisfy :: (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> Parser e Char
fusedSatisfy :: (Char -> Bool)
-> (Char -> Bool)
-> (Char -> Bool)
-> (Char -> Bool)
-> Parser e Char
fusedSatisfy Char -> Bool
f1 Char -> Bool
f2 Char -> Bool
f3 Char -> Bool
f4 = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Char)
-> Parser e Char
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
buf Int#
n -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob Addr#
buf of
  Int#
1# -> Res# e Char
forall e a. Res# e a
Fail#
  Int#
_  -> case Addr# -> Char#
derefChar8# Addr#
buf of
    Char#
c1 -> case Char#
c1 Char# -> Char# -> Int#
`leChar#` Char#
'\x7F'# of
      Int#
1# | Char -> Bool
f1 (Char# -> Char
C# Char#
c1) -> Char -> Addr# -> Int# -> Res# e Char
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Char# -> Char
C# Char#
c1) (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
1#) Int#
n
         | Bool
otherwise  -> Res# e Char
forall e a. Res# e a
Fail#
      Int#
_  -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
1#) of
        Int#
1# -> Res# e Char
forall e a. Res# e a
Fail#
        Int#
_ -> case Addr# -> Int# -> Char#
indexCharOffAddr# Addr#
buf Int#
1# of
          Char#
c2 -> case Char#
c1 Char# -> Char# -> Int#
`leChar#` Char#
'\xDF'# of
            Int#
1# ->
              let resc :: Char
resc = Char# -> Char
C# (Int# -> Char#
chr# (((Char# -> Int#
ord# Char#
c1 Int# -> Int# -> Int#
-# Int#
0xC0#) Int# -> Int# -> Int#
`uncheckedIShiftL#` Int#
6#) Int# -> Int# -> Int#
`orI#`
                                   (Char# -> Int#
ord# Char#
c2 Int# -> Int# -> Int#
-# Int#
0x80#)))
              in case Char -> Bool
f2 Char
resc of
                   Bool
True -> Char -> Addr# -> Int# -> Res# e Char
forall a e. a -> Addr# -> Int# -> Res# e a
OK# Char
resc (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
2#) Int#
n
                   Bool
_    -> Res# e Char
forall e a. Res# e a
Fail#
            Int#
_ -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
2#) of
              Int#
1# -> Res# e Char
forall e a. Res# e a
Fail#
              Int#
_  -> case Addr# -> Int# -> Char#
indexCharOffAddr# Addr#
buf Int#
2# of
                Char#
c3 -> case Char#
c1 Char# -> Char# -> Int#
`leChar#` Char#
'\xEF'# of
                  Int#
1# ->
                    let resc :: Char
resc = Char# -> Char
C# (Int# -> Char#
chr# (((Char# -> Int#
ord# Char#
c1 Int# -> Int# -> Int#
-# Int#
0xE0#) Int# -> Int# -> Int#
`uncheckedIShiftL#` Int#
12#) Int# -> Int# -> Int#
`orI#`
                                         ((Char# -> Int#
ord# Char#
c2 Int# -> Int# -> Int#
-# Int#
0x80#) Int# -> Int# -> Int#
`uncheckedIShiftL#`  Int#
6#) Int# -> Int# -> Int#
`orI#`
                                         (Char# -> Int#
ord# Char#
c3 Int# -> Int# -> Int#
-# Int#
0x80#)))
                    in case Char -> Bool
f3 Char
resc of
                         Bool
True -> Char -> Addr# -> Int# -> Res# e Char
forall a e. a -> Addr# -> Int# -> Res# e a
OK# Char
resc (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
3#) Int#
n
                         Bool
_    -> Res# e Char
forall e a. Res# e a
Fail#
                  Int#
_ -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
3#) of
                    Int#
1# -> Res# e Char
forall e a. Res# e a
Fail#
                    Int#
_  -> case Addr# -> Int# -> Char#
indexCharOffAddr# Addr#
buf Int#
3# of
                      Char#
c4 ->
                        let resc :: Char
resc = Char# -> Char
C# (Int# -> Char#
chr# (((Char# -> Int#
ord# Char#
c1 Int# -> Int# -> Int#
-# Int#
0xF0#) Int# -> Int# -> Int#
`uncheckedIShiftL#` Int#
18#) Int# -> Int# -> Int#
`orI#`
                                             ((Char# -> Int#
ord# Char#
c2 Int# -> Int# -> Int#
-# Int#
0x80#) Int# -> Int# -> Int#
`uncheckedIShiftL#` Int#
12#) Int# -> Int# -> Int#
`orI#`
                                             ((Char# -> Int#
ord# Char#
c3 Int# -> Int# -> Int#
-# Int#
0x80#) Int# -> Int# -> Int#
`uncheckedIShiftL#`  Int#
6#) Int# -> Int# -> Int#
`orI#`
                                              (Char# -> Int#
ord# Char#
c4 Int# -> Int# -> Int#
-# Int#
0x80#)))
                        in case Char -> Bool
f4 Char
resc of
                             Bool
True -> Char -> Addr# -> Int# -> Res# e Char
forall a e. a -> Addr# -> Int# -> Res# e a
OK# Char
resc (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
4#) Int#
n
                             Bool
_    -> Res# e Char
forall e a. Res# e a
Fail#
{-# inline fusedSatisfy #-}

-- | Skipping variant of `fusedSatisfy`.
fusedSatisfy_ :: (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> Parser e ()
fusedSatisfy_ :: (Char -> Bool)
-> (Char -> Bool)
-> (Char -> Bool)
-> (Char -> Bool)
-> Parser e ()
fusedSatisfy_ Char -> Bool
f1 Char -> Bool
f2 Char -> Bool
f3 Char -> Bool
f4 = () () -> Parser e Char -> Parser e ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (Char -> Bool)
-> (Char -> Bool)
-> (Char -> Bool)
-> (Char -> Bool)
-> Parser e Char
forall e.
(Char -> Bool)
-> (Char -> Bool)
-> (Char -> Bool)
-> (Char -> Bool)
-> Parser e Char
fusedSatisfy Char -> Bool
f1 Char -> Bool
f2 Char -> Bool
f3 Char -> Bool
f4
{-# inline fusedSatisfy_ #-}

-- | Parse any byte.
anyWord8 :: Parser e Word
anyWord8 :: Parser e Word
anyWord8 = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Word)
-> Parser e Word
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
buf Int#
n -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob Addr#
buf of
  Int#
1# -> Res# e Word
forall e a. Res# e a
Fail#
  Int#
_  -> case Addr# -> Int# -> Word#
indexWord8OffAddr Addr#
buf Int#
0# of
    Word#
w -> Word -> Addr# -> Int# -> Res# e Word
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Word# -> Word
W# Word#
w) (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
1#) Int#
n
{-# inline anyWord8 #-}

-- | Skip any byte.
anyWord8_ :: Parser e ()
anyWord8_ :: Parser e ()
anyWord8_ = () () -> Parser e Word -> Parser e ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Parser e Word
forall e. Parser e Word
anyWord8
{-# inline anyWord8_ #-}

-- | Parse any `Word16`.
anyWord16 :: Parser e Word
anyWord16 :: Parser e Word
anyWord16 = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Word)
-> Parser e Word
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
buf Int#
n -> case Int#
2# Int# -> Int# -> Int#
<=# Addr# -> Addr# -> Int#
minusAddr# Addr#
eob Addr#
buf of
  Int#
0# -> Res# e Word
forall e a. Res# e a
Fail#
  Int#
_  -> case Addr# -> Int# -> Word#
indexWord16OffAddr Addr#
buf Int#
0# of
    Word#
w -> Word -> Addr# -> Int# -> Res# e Word
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Word# -> Word
W# Word#
w) (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
2#) Int#
n
{-# inline anyWord16 #-}

-- | Skip any `Word16`.
anyWord16_ :: Parser e ()
anyWord16_ :: Parser e ()
anyWord16_ = () () -> Parser e Word -> Parser e ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Parser e Word
forall e. Parser e Word
anyWord16
{-# inline anyWord16_ #-}

-- | Parse any `Word32`.
anyWord32 :: Parser e Word
anyWord32 :: Parser e Word
anyWord32 = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Word)
-> Parser e Word
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
buf Int#
n -> case Int#
4# Int# -> Int# -> Int#
<=# Addr# -> Addr# -> Int#
minusAddr# Addr#
eob Addr#
buf of
  Int#
0# -> Res# e Word
forall e a. Res# e a
Fail#
  Int#
_  -> case Addr# -> Int# -> Word#
indexWord32OffAddr Addr#
buf Int#
0# of
    Word#
w -> Word -> Addr# -> Int# -> Res# e Word
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Word# -> Word
W# Word#
w) (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
4#) Int#
n
{-# inline anyWord32 #-}

-- | Skip any `Word32`.
anyWord32_ :: Parser e ()
anyWord32_ :: Parser e ()
anyWord32_ = () () -> Parser e Word -> Parser e ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Parser e Word
forall e. Parser e Word
anyWord32
{-# inline anyWord32_ #-}

-- | Parse any `Word`.
anyWord :: Parser e Word
anyWord :: Parser e Word
anyWord = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Word)
-> Parser e Word
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
buf Int#
n -> case Int#
8# Int# -> Int# -> Int#
<=# Addr# -> Addr# -> Int#
minusAddr# Addr#
eob Addr#
buf of
  Int#
0# -> Res# e Word
forall e a. Res# e a
Fail#
  Int#
_  -> case Addr# -> Int# -> Word#
indexWordOffAddr# Addr#
buf Int#
0# of
    Word#
w -> Word -> Addr# -> Int# -> Res# e Word
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Word# -> Word
W# Word#
w) (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
8#) Int#
n
{-# inline anyWord #-}

-- | Skip any `Word`.
anyWord_ :: Parser e ()
anyWord_ :: Parser e ()
anyWord_ = () () -> Parser e Word -> Parser e ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Parser e Word
forall e. Parser e Word
anyWord
{-# inline anyWord_ #-}

-- | Parse any UTF-8-encoded `Char`.
anyChar :: Parser e Char
anyChar :: Parser e Char
anyChar = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Char)
-> Parser e Char
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
buf Int#
n -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob Addr#
buf of
  Int#
1# -> Res# e Char
forall e a. Res# e a
Fail#
  Int#
_  -> case Addr# -> Char#
derefChar8# Addr#
buf of
    Char#
c1 -> case Char#
c1 Char# -> Char# -> Int#
`leChar#` Char#
'\x7F'# of
      Int#
1# -> Char -> Addr# -> Int# -> Res# e Char
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Char# -> Char
C# Char#
c1) (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
1#) Int#
n
      Int#
_  -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
1#) of
        Int#
1# -> Res# e Char
forall e a. Res# e a
Fail#
        Int#
_ -> case Addr# -> Int# -> Char#
indexCharOffAddr# Addr#
buf Int#
1# of
          Char#
c2 -> case Char#
c1 Char# -> Char# -> Int#
`leChar#` Char#
'\xDF'# of
            Int#
1# ->
              let resc :: Int#
resc = ((Char# -> Int#
ord# Char#
c1 Int# -> Int# -> Int#
-# Int#
0xC0#) Int# -> Int# -> Int#
`uncheckedIShiftL#` Int#
6#) Int# -> Int# -> Int#
`orI#`
                          (Char# -> Int#
ord# Char#
c2 Int# -> Int# -> Int#
-# Int#
0x80#)
              in Char -> Addr# -> Int# -> Res# e Char
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Char# -> Char
C# (Int# -> Char#
chr# Int#
resc)) (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
2#) Int#
n
            Int#
_ -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
2#) of
              Int#
1# -> Res# e Char
forall e a. Res# e a
Fail#
              Int#
_  -> case Addr# -> Int# -> Char#
indexCharOffAddr# Addr#
buf Int#
2# of
                Char#
c3 -> case Char#
c1 Char# -> Char# -> Int#
`leChar#` Char#
'\xEF'# of
                  Int#
1# ->
                    let resc :: Int#
resc = ((Char# -> Int#
ord# Char#
c1 Int# -> Int# -> Int#
-# Int#
0xE0#) Int# -> Int# -> Int#
`uncheckedIShiftL#` Int#
12#) Int# -> Int# -> Int#
`orI#`
                               ((Char# -> Int#
ord# Char#
c2 Int# -> Int# -> Int#
-# Int#
0x80#) Int# -> Int# -> Int#
`uncheckedIShiftL#`  Int#
6#) Int# -> Int# -> Int#
`orI#`
                                (Char# -> Int#
ord# Char#
c3 Int# -> Int# -> Int#
-# Int#
0x80#)
                    in Char -> Addr# -> Int# -> Res# e Char
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Char# -> Char
C# (Int# -> Char#
chr# Int#
resc)) (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
3#) Int#
n
                  Int#
_ -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
3#) of
                    Int#
1# -> Res# e Char
forall e a. Res# e a
Fail#
                    Int#
_  -> case Addr# -> Int# -> Char#
indexCharOffAddr# Addr#
buf Int#
3# of
                      Char#
c4 ->
                        let resc :: Int#
resc = ((Char# -> Int#
ord# Char#
c1 Int# -> Int# -> Int#
-# Int#
0xF0#) Int# -> Int# -> Int#
`uncheckedIShiftL#` Int#
18#) Int# -> Int# -> Int#
`orI#`
                                   ((Char# -> Int#
ord# Char#
c2 Int# -> Int# -> Int#
-# Int#
0x80#) Int# -> Int# -> Int#
`uncheckedIShiftL#` Int#
12#) Int# -> Int# -> Int#
`orI#`
                                   ((Char# -> Int#
ord# Char#
c3 Int# -> Int# -> Int#
-# Int#
0x80#) Int# -> Int# -> Int#
`uncheckedIShiftL#`  Int#
6#) Int# -> Int# -> Int#
`orI#`
                                    (Char# -> Int#
ord# Char#
c4 Int# -> Int# -> Int#
-# Int#
0x80#)
                        in Char -> Addr# -> Int# -> Res# e Char
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Char# -> Char
C# (Int# -> Char#
chr# Int#
resc)) (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
4#) Int#
n
{-# inline anyChar #-}

-- | Skip any UTF-8-encoded `Char`.
anyChar_ :: Parser e ()
anyChar_ :: Parser e ()
anyChar_ = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
buf Int#
n -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob Addr#
buf of
  Int#
1# -> Res# e ()
forall e a. Res# e a
Fail#
  Int#
_  -> case Addr# -> Char#
derefChar8# Addr#
buf of
    Char#
c1 -> case Char#
c1 Char# -> Char# -> Int#
`leChar#` Char#
'\x7F'# of
      Int#
1# -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
1#) Int#
n
      Int#
_  ->
        let buf' :: Addr#
buf' =
              case Char#
c1 Char# -> Char# -> Int#
`leChar#` Char#
'\xDF'# of
                Int#
1# -> Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
2#
                Int#
_  -> case Char#
c1 Char# -> Char# -> Int#
`leChar#` Char#
'\xEF'# of
                    Int#
1# -> Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
3#
                    Int#
_ ->  Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
4#
        in case Addr# -> Addr# -> Int#
leAddr# Addr#
buf' Addr#
eob of
             Int#
1# -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () Addr#
buf' Int#
n
             Int#
_  -> Res# e ()
forall e a. Res# e a
Fail#
{-# inline anyChar_ #-}


-- | Parse any `Char` in the ASCII range, fail if the next input character is not in the range.
--   This is more efficient than `anyChar` if we are only working with ASCII.
anyCharASCII :: Parser e Char
anyCharASCII :: Parser e Char
anyCharASCII = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Char)
-> Parser e Char
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
buf Int#
n -> case Addr# -> Addr# -> Int#
eqAddr# Addr#
eob Addr#
buf of
  Int#
1# -> Res# e Char
forall e a. Res# e a
Fail#
  Int#
_  -> case Addr# -> Char#
derefChar8# Addr#
buf of
    Char#
c1 -> case Char#
c1 Char# -> Char# -> Int#
`leChar#` Char#
'\x7F'# of
      Int#
1# -> Char -> Addr# -> Int# -> Res# e Char
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Char# -> Char
C# Char#
c1) (Addr# -> Int# -> Addr#
plusAddr# Addr#
buf Int#
1#) Int#
n
      Int#
_  -> Res# e Char
forall e a. Res# e a
Fail#
{-# inline anyCharASCII #-}

-- | Skip any `Char` in the ASCII range. More efficient than `anyChar_` if we're working only with
--   ASCII.
anyCharASCII_ :: Parser e ()
anyCharASCII_ :: Parser e ()
anyCharASCII_ = () () -> Parser e Char -> Parser e ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Parser e Char
forall e. Parser e Char
anyCharASCII
{-# inline anyCharASCII_ #-}

-- | Read an `Int` from the input, as a non-empty digit sequence. The `Int` may
--   overflow in the result.
readInt :: Parser e Int
readInt :: Parser e Int
readInt = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Int)
-> Parser e Int
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n -> case Addr# -> Addr# -> (# (# #) | (# Int#, Addr# #) #)
FlatParse.Internal.readInt Addr#
eob Addr#
s of
  (# (##) | #)        -> Res# e Int
forall e a. Res# e a
Fail#
  (# | (# Int#
i, Addr#
s' #) #) -> Int -> Addr# -> Int# -> Res# e Int
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Int# -> Int
I# Int#
i) Addr#
s' Int#
n
{-# inline readInt #-}

-- | Read an `Integer` from the input, as a non-empty digit sequence.
readInteger :: Parser e Integer
readInteger :: Parser e Integer
readInteger = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Integer)
-> Parser e Integer
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents
-> Addr# -> Addr# -> (# (# #) | (# Integer, Addr# #) #)
FlatParse.Internal.readInteger ForeignPtrContents
fp Addr#
eob Addr#
s of
  (# (##) | #)        -> Res# e Integer
forall e a. Res# e a
Fail#
  (# | (# Integer
i, Addr#
s' #) #) -> Integer -> Addr# -> Int# -> Res# e Integer
forall a e. a -> Addr# -> Int# -> Res# e a
OK# Integer
i Addr#
s' Int#
n
{-# inline readInteger #-}


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

-- | Choose between two parsers. If the first parser fails, try the second one, but if the first one
--   throws an error, propagate the error.
infixr 6 <|>
(<|>) :: Parser e a -> Parser e a -> Parser e a
<|> :: Parser e a -> Parser e a -> Parser e a
(<|>) (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
g) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n ->
  case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    Res# e a
Fail# -> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
g ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n
    Res# e a
x     -> Res# e a
x
{-# inline (<|>) #-}

-- | Branch on a parser: if the first argument succeeds, continue with the second, else with the third.
--   This can produce slightly more efficient code than `(<|>)`. Moreover, `ḃranch` does not
--   backtrack from the true/false cases.
branch :: Parser e a -> Parser e b -> Parser e b -> Parser e b
branch :: Parser e a -> Parser e b -> Parser e b -> Parser e b
branch Parser e a
pa Parser e b
pt Parser e b
pf = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b)
-> Parser e b
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# Parser e a
pa ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
  OK# a
_ Addr#
s Int#
n -> Parser e b
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# Parser e b
pt ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n
  Res# e a
Fail#     -> Parser e b
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# Parser e b
pf ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n
  Err# e
e    -> e -> Res# e b
forall e a. e -> Res# e a
Err# e
e
{-# inline branch #-}

-- | An analogue of the list `foldl` function: first parse a @b@, then parse zero or more @a@-s,
--   and combine the results in a left-nested way by the @b -> a -> b@ function. Note: this is not
--   the usual `chainl` function from the parsec libraries!
chainl :: (b -> a -> b) -> Parser e b -> Parser e a -> Parser e b
chainl :: (b -> a -> b) -> Parser e b -> Parser e a -> Parser e b
chainl b -> a -> b
f Parser e b
start Parser e a
elem = Parser e b
start Parser e b -> (b -> Parser e b) -> Parser e b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> Parser e b
go where
  go :: b -> Parser e b
go b
b = do {!a
a <- Parser e a
elem; b -> Parser e b
go (b -> Parser e b) -> b -> Parser e b
forall a b. (a -> b) -> a -> b
$! b -> a -> b
f b
b a
a} Parser e b -> Parser e b -> Parser e b
forall e a. Parser e a -> Parser e a -> Parser e a
<|> b -> Parser e b
forall (f :: * -> *) a. Applicative f => a -> f a
pure b
b
{-# inline chainl #-}

-- | An analogue of the list `foldr` function: parse zero or more @a@-s, terminated by a @b@, and
--   combine the results in a right-nested way using the @a -> b -> b@ function. Note: this is not
--   the usual `chainr` function from the parsec libraries!
chainr :: (a -> b -> b) -> Parser e a -> Parser e b -> Parser e b
chainr :: (a -> b -> b) -> Parser e a -> Parser e b -> Parser e b
chainr a -> b -> b
f (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
elem) (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
end) = Parser e b
go where
  go :: Parser e b
go = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b)
-> Parser e b
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
elem ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    OK# a
a Addr#
s Int#
n -> case Parser e b
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# Parser e b
go ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
      OK# b
b Addr#
s Int#
n -> let !b' :: b
b' = a -> b -> b
f a
a b
b in b -> Addr# -> Int# -> Res# e b
forall a e. a -> Addr# -> Int# -> Res# e a
OK# b
b' Addr#
s Int#
n
      Res# e b
x         -> Res# e b
x
    Res# e a
Fail# -> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
end ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n
    Err# e
e -> e -> Res# e b
forall e a. e -> Res# e a
Err# e
e
{-# inline chainr #-}

-- | Run a parser zero or more times, collect the results in a list. Note: for optimal performance,
--   try to avoid this. Often it is possible to get rid of the intermediate list by using a
--   combinator or a custom parser.
many :: Parser e a -> Parser e [a]
many :: Parser e a -> Parser e [a]
many (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) = Parser e [a]
go where
  go :: Parser e [a]
go = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e [a])
-> Parser e [a]
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    OK# a
a Addr#
s Int#
n -> case Parser e [a]
-> ForeignPtrContents
-> Int#
-> Addr#
-> Addr#
-> Int#
-> Res# e [a]
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# Parser e [a]
go ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
                   OK# [a]
as Addr#
s Int#
n -> [a] -> Addr# -> Int# -> Res# e [a]
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (a
aa -> [a] -> [a]
forall k1. k1 -> [k1] -> [k1]
:[a]
as) Addr#
s Int#
n
                   Res# e [a]
x          -> Res# e [a]
x
    Res# e a
Fail#  -> [a] -> Addr# -> Int# -> Res# e [a]
forall a e. a -> Addr# -> Int# -> Res# e a
OK# [] Addr#
s Int#
n
    Err# e
e -> e -> Res# e [a]
forall e a. e -> Res# e a
Err# e
e
{-# inline many #-}

-- | Skip a parser zero or more times.
many_ :: Parser e a -> Parser e ()
many_ :: Parser e a -> Parser e ()
many_ (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) = Parser e ()
go where
  go :: Parser e ()
go = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
    OK# a
a Addr#
s Int#
n -> Parser e ()
-> ForeignPtrContents
-> Int#
-> Addr#
-> Addr#
-> Int#
-> Res# e ()
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# Parser e ()
go ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n
    Res# e a
Fail#     -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () Addr#
s Int#
n
    Err# e
e    -> e -> Res# e ()
forall e a. e -> Res# e a
Err# e
e
{-# inline many_ #-}

-- | Run a parser one or more times, collect the results in a list. Note: for optimal performance,
--   try to avoid this. Often it is possible to get rid of the intermediate list by using a
--   combinator or a custom parser.
some :: Parser e a -> Parser e [a]
some :: Parser e a -> Parser e [a]
some Parser e a
p = (:) (a -> [a] -> [a]) -> Parser e a -> Parser e ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser e a
p Parser e ([a] -> [a]) -> Parser e [a] -> Parser e [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser e a -> Parser e [a]
forall e a. Parser e a -> Parser e [a]
many Parser e a
p
{-# inline some #-}

-- | Skip a parser one or more times.
some_ :: Parser e a -> Parser e ()
some_ :: Parser e a -> Parser e ()
some_ Parser e a
pa = Parser e a
pa Parser e a -> Parser e () -> Parser e ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser e a -> Parser e ()
forall e a. Parser e a -> Parser e ()
many_ Parser e a
pa
{-# inline some_ #-}

-- | Succeed if the first parser succeeds and the second one fails. The parsing
--   state is restored to the point of the first argument's success.
notFollowedBy :: Parser e a -> Parser e b -> Parser e a
notFollowedBy :: Parser e a -> Parser e b -> Parser e a
notFollowedBy Parser e a
p1 Parser e b
p2 = Parser e a
p1 Parser e a -> Parser e () -> Parser e a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser e () -> Parser e ()
forall e a. Parser e a -> Parser e a
lookahead (Parser e b -> Parser e ()
forall e a. Parser e a -> Parser e ()
fails Parser e b
p2)
{-# inline notFollowedBy #-}


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

-- | Get the current position in the input.
getPos :: Parser e Pos
getPos :: Parser e Pos
getPos = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Pos)
-> Parser e Pos
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> Pos -> Addr# -> Int# -> Res# e Pos
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Addr# -> Addr# -> Pos
addrToPos# Addr#
eob Addr#
s) Addr#
s Int#
n
{-# inline getPos #-}

-- | Set the input position. Warning: this can result in crashes if the position points outside the
--   current buffer. It is always safe to `setPos` values which came from `getPos` with the current
--   input.
setPos :: Pos -> Parser e ()
setPos :: Pos -> Parser e ()
setPos Pos
s = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
_ Int#
n -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () (Addr# -> Pos -> Addr#
posToAddr# Addr#
eob Pos
s) Int#
n
{-# inline setPos #-}

-- | The end of the input.
endPos :: Pos
endPos :: Pos
endPos = Int -> Pos
Pos Int
0
{-# inline endPos #-}


-- | Return the consumed span of a parser. Use `spanned` if possible for better efficiency.
spanOf :: Parser e a -> Parser e Span
spanOf :: Parser e a -> Parser e Span
spanOf (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Span)
-> Parser e Span
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
  OK# a
a Addr#
s' Int#
n -> Span -> Addr# -> Int# -> Res# e Span
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Pos -> Pos -> Span
Span (Addr# -> Addr# -> Pos
addrToPos# Addr#
eob Addr#
s) (Addr# -> Addr# -> Pos
addrToPos# Addr#
eob Addr#
s')) Addr#
s' Int#
n
  Res# e a
x          -> Res# e a -> Res# e Span
unsafeCoerce# Res# e a
x
{-# inline spanOf #-}

-- | Bind the result together with the span of the result. CPS'd version of `spanOf`
--   for better unboxing.
spanned :: Parser e a -> (a -> Span -> Parser e b) -> Parser e b
spanned :: Parser e a -> (a -> Span -> Parser e b) -> Parser e b
spanned (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) a -> Span -> Parser e b
g = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b)
-> Parser e b
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
  OK# a
a Addr#
s' Int#
n -> Parser e b
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# (a -> Span -> Parser e b
g a
a (Pos -> Pos -> Span
Span (Addr# -> Addr# -> Pos
addrToPos# Addr#
eob Addr#
s) (Addr# -> Addr# -> Pos
addrToPos# Addr#
eob Addr#
s'))) ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s' Int#
n
  Res# e a
x          -> Res# e a -> Res# e b
unsafeCoerce# Res# e a
x
{-# inline spanned #-}

-- | Return the `B.ByteString` consumed by a parser. Note: it's more efficient to use `spanOf` and
--   `spanned` instead.
byteStringOf :: Parser e a -> Parser e B.ByteString
byteStringOf :: Parser e a -> Parser e ByteString
byteStringOf (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e ByteString)
-> Parser e ByteString
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
  OK# a
a Addr#
s' Int#
n -> ByteString -> Addr# -> Int# -> Res# e ByteString
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (ForeignPtr Word8 -> Int -> Int -> ByteString
B.PS (Addr# -> ForeignPtrContents -> ForeignPtr Word8
forall a. Addr# -> ForeignPtrContents -> ForeignPtr a
ForeignPtr Addr#
s ForeignPtrContents
fp) Int
0 (Int# -> Int
I# (Addr# -> Addr# -> Int#
minusAddr# Addr#
s' Addr#
s))) Addr#
s' Int#
n
  Res# e a
x          -> Res# e a -> Res# e ByteString
unsafeCoerce# Res# e a
x
{-# inline byteStringOf #-}

-- | CPS'd version of `byteStringOf`. Can be more efficient, because the result is more eagerly unboxed
--   by GHC. It's more efficient to use `spanOf` or `spanned` instead.
byteStringed :: Parser e a -> (a -> B.ByteString -> Parser e b) -> Parser e b
byteStringed :: Parser e a -> (a -> ByteString -> Parser e b) -> Parser e b
byteStringed (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) a -> ByteString -> Parser e b
g = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b)
-> Parser e b
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s Int#
n of
  OK# a
a Addr#
s' Int#
n -> Parser e b
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e b
forall e a.
Parser e a
-> ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
runParser# (a -> ByteString -> Parser e b
g a
a (ForeignPtr Word8 -> Int -> Int -> ByteString
B.PS (Addr# -> ForeignPtrContents -> ForeignPtr Word8
forall a. Addr# -> ForeignPtrContents -> ForeignPtr a
ForeignPtr Addr#
s ForeignPtrContents
fp) Int
0 (Int# -> Int
I# (Addr# -> Addr# -> Int#
minusAddr# Addr#
s' Addr#
s)))) ForeignPtrContents
fp Int#
r Addr#
eob Addr#
s' Int#
n
  Res# e a
x          -> Res# e a -> Res# e b
unsafeCoerce# Res# e a
x
{-# inline byteStringed #-}

-- | Create a `B.ByteString` from a `Span`. The result is invalid is the `Span` points
--   outside the current buffer, or if the `Span` start is greater than the end position.
unsafeSpanToByteString :: Span -> Parser e B.ByteString
unsafeSpanToByteString :: Span -> Parser e ByteString
unsafeSpanToByteString (Span Pos
l Pos
r) =
  Parser e ByteString -> Parser e ByteString
forall e a. Parser e a -> Parser e a
lookahead (Pos -> Parser e ()
forall e. Pos -> Parser e ()
setPos Pos
l Parser e () -> Parser e ByteString -> Parser e ByteString
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser e () -> Parser e ByteString
forall e a. Parser e a -> Parser e ByteString
byteStringOf (Pos -> Parser e ()
forall e. Pos -> Parser e ()
setPos Pos
r))
{-# inline unsafeSpanToByteString #-}


-- | Run a parser in a given input span. The input position and the `Int` state is restored after
--   the parser is finished, so `inSpan` does not consume input and has no side effect.  Warning:
--   this operation may crash if the given span points outside the current parsing buffer. It's
--   always safe to use `inSpan` if the span comes from a previous `spanned` or `spanOf` call on
--   the current input.
inSpan :: Span -> Parser e a -> Parser e a
inSpan :: Span -> Parser e a -> Parser e a
inSpan (Span Pos
s Pos
eob) (Parser ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob' Addr#
s' Int#
n' ->
  case ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a
f ForeignPtrContents
fp Int#
r (Addr# -> Pos -> Addr#
posToAddr# Addr#
eob' Pos
eob) (Addr# -> Pos -> Addr#
posToAddr# Addr#
eob' Pos
s) Int#
n' of
    OK# a
a Addr#
_ Int#
_ -> a -> Addr# -> Int# -> Res# e a
forall a e. a -> Addr# -> Int# -> Res# e a
OK# a
a Addr#
s' Int#
n'
    Res# e a
x         -> Res# e a -> Res# e a
unsafeCoerce# Res# e a
x
{-# inline inSpan #-}


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

-- | Parse the rest of the current line as a `String`. Assumes UTF-8 encoding,
--   throws an error if the encoding is invalid.
takeLine :: Parser e String
takeLine :: Parser e String
takeLine =
  Parser e ()
-> Parser e String -> Parser e String -> Parser e String
forall e a b. Parser e a -> Parser e b -> Parser e b -> Parser e b
branch Parser e ()
forall e. Parser e ()
eof (String -> Parser e String
forall (f :: * -> *) a. Applicative f => a -> f a
pure String
"") do
  Char
c <- Parser e Char
forall e. Parser e Char
anyChar
  case Char
c of
    Char
'\n' -> String -> Parser e String
forall (f :: * -> *) a. Applicative f => a -> f a
pure String
""
    Char
_    -> (Char
cChar -> ShowS
forall k1. k1 -> [k1] -> [k1]
:) ShowS -> Parser e String -> Parser e String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser e String
forall e. Parser e String
takeLine

-- | Parse the rest of the current line as a `String`, but restore the parsing state.
--   Assumes UTF-8 encoding. This can be used for debugging.
traceLine :: Parser e String
traceLine :: Parser e String
traceLine = Parser e String -> Parser e String
forall e a. Parser e a -> Parser e a
lookahead Parser e String
forall e. Parser e String
takeLine

-- | Take the rest of the input as a `String`. Assumes UTF-8 encoding.
takeRest :: Parser e String
takeRest :: Parser e String
takeRest = ((:) (Char -> ShowS) -> Parser e Char -> Parser e ShowS
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser e Char
forall e. Parser e Char
anyChar Parser e ShowS -> Parser e String -> Parser e String
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser e String
forall e. Parser e String
takeRest) Parser e String -> Parser e String -> Parser e String
forall e a. Parser e a -> Parser e a -> Parser e a
<|> String -> Parser e String
forall (f :: * -> *) a. Applicative f => a -> f a
pure []

-- | Get the rest of the input as a `String`, but restore the parsing state. Assumes UTF-8 encoding.
--   This can be used for debugging.
traceRest :: Parser e String
traceRest :: Parser e String
traceRest = Parser e String -> Parser e String
forall e a. Parser e a -> Parser e a
lookahead Parser e String
forall e. Parser e String
traceRest

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

-- | Convert an UTF-8-coded `B.ByteString` to a `String`.
unpackUTF8 :: B.ByteString -> String
unpackUTF8 :: ByteString -> String
unpackUTF8 ByteString
str = case Parser Any String -> Int -> Int -> ByteString -> Result Any String
forall e a. Parser e a -> Int -> Int -> ByteString -> Result e a
runParser Parser Any String
forall e. Parser e String
takeRest Int
0 Int
0 ByteString
str of
  OK String
a Int
_ ByteString
_ -> String
a
  Result Any String
_        -> ShowS
forall a. HasCallStack => String -> a
error String
"unpackUTF8: invalid encoding"

-- | Check that the input has at least the given number of bytes.
ensureBytes# :: Int -> Parser e ()
ensureBytes# :: Int -> Parser e ()
ensureBytes# (I# Int#
len) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n ->
  case Int#
len  Int# -> Int# -> Int#
<=# Addr# -> Addr# -> Int#
minusAddr# Addr#
eob Addr#
s of
    Int#
1# -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () Addr#
s Int#
n
    Int#
_  -> Res# e ()
forall e a. Res# e a
Fail#
{-# inline ensureBytes# #-}

-- | Unsafely read a concrete byte from the input. It's not checked that the input has
--   enough bytes.
scan8# :: Word -> Parser e ()
scan8# :: Word -> Parser e ()
scan8# (W# Word#
c) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n ->
  case Addr# -> Int# -> Word#
indexWord8OffAddr Addr#
s Int#
0# of
    Word#
c' -> case Word# -> Word# -> Int#
eqWord# Word#
c Word#
c' of
      Int#
1# -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () (Addr# -> Int# -> Addr#
plusAddr# Addr#
s Int#
1#) Int#
n
      Int#
_  -> Res# e ()
forall e a. Res# e a
Fail#
{-# inline scan8# #-}

-- | Unsafely read two concrete bytes from the input. It's not checked that the input has
--   enough bytes.
scan16# :: Word -> Parser e ()
scan16# :: Word -> Parser e ()
scan16# (W# Word#
c) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n ->
  case Addr# -> Int# -> Word#
indexWord16OffAddr Addr#
s Int#
0# of
    Word#
c' -> case Word# -> Word# -> Int#
eqWord# Word#
c Word#
c' of
      Int#
1# -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () (Addr# -> Int# -> Addr#
plusAddr# Addr#
s Int#
2#) Int#
n
      Int#
_  -> Res# e ()
forall e a. Res# e a
Fail#
{-# inline scan16# #-}

-- | Unsafely read four concrete bytes from the input. It's not checked that the input has
--   enough bytes.
scan32# :: Word -> Parser e ()
scan32# :: Word -> Parser e ()
scan32# (W# Word#
c) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n ->
  case Addr# -> Int# -> Word#
indexWord32OffAddr Addr#
s Int#
0# of
    Word#
c' -> case Word# -> Word# -> Int#
eqWord# Word#
c Word#
c' of
      Int#
1# -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () (Addr# -> Int# -> Addr#
plusAddr# Addr#
s Int#
4#) Int#
n
      Int#
_  -> Res# e ()
forall e a. Res# e a
Fail#
{-# inline scan32# #-}

-- | Unsafely read eight concrete bytes from the input. It's not checked that the input has
--   enough bytes.
scan64# :: Word -> Parser e ()
scan64# :: Word -> Parser e ()
scan64# (W# Word#
c) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n ->
  case Addr# -> Int# -> Word#
indexWord64OffAddr Addr#
s Int#
0# of
    Word#
c' -> case Word# -> Word# -> Int#
eqWord# Word#
c Word#
c' of
      Int#
1# -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () (Addr# -> Int# -> Addr#
plusAddr# Addr#
s Int#
8#) Int#
n
      Int#
_  -> Res# e ()
forall e a. Res# e a
Fail#
{-# inline scan64# #-}

-- | Unsafely read and return a byte from the input. It's not checked that the input is non-empty.
scanAny8# :: Parser e Word
scanAny8# :: Parser e Word
scanAny8# = (ForeignPtrContents
 -> Int# -> Addr# -> Addr# -> Int# -> Res# e Word)
-> Parser e Word
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n -> Word -> Addr# -> Int# -> Res# e Word
forall a e. a -> Addr# -> Int# -> Res# e a
OK# (Word# -> Word
W# (Addr# -> Int# -> Word#
indexWord8OffAddr Addr#
s Int#
0#)) (Addr# -> Int# -> Addr#
plusAddr# Addr#
s Int#
1#) Int#
n
{-# inline scanAny8# #-}

scanPartial64# :: Int -> Word -> Parser e ()
scanPartial64# :: Int -> Word -> Parser e ()
scanPartial64# (I# Int#
len) (W# Word#
w) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n ->
  case Addr# -> Int# -> Word#
indexWordOffAddr# Addr#
s Int#
0# of
    Word#
w' -> case Int# -> Int# -> Int#
uncheckedIShiftL# (Int#
8# Int# -> Int# -> Int#
-# Int#
len) Int#
3# of
      Int#
sh -> case Word# -> Int# -> Word#
uncheckedShiftL# Word#
w' Int#
sh of
        Word#
w' -> case Word# -> Int# -> Word#
uncheckedShiftRL# Word#
w' Int#
sh of
          Word#
w' -> case Word# -> Word# -> Int#
eqWord# Word#
w Word#
w' of
            Int#
1# -> () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () (Addr# -> Int# -> Addr#
plusAddr# Addr#
s Int#
len) Int#
n
            Int#
_  -> Res# e ()
forall e a. Res# e a
Fail#
{-# inline scanPartial64# #-}

-- | Decrease the current input position by the given number of bytes.
setBack# :: Int -> Parser e ()
setBack# :: Int -> Parser e ()
setBack# (I# Int#
i) = (ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e ())
-> Parser e ()
forall e a.
(ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a)
-> Parser e a
Parser \ForeignPtrContents
fp !Int#
r Addr#
eob Addr#
s Int#
n ->
  () -> Addr# -> Int# -> Res# e ()
forall a e. a -> Addr# -> Int# -> Res# e a
OK# () (Addr# -> Int# -> Addr#
plusAddr# Addr#
s (Int# -> Int#
negateInt# Int#
i)) Int#
n
{-# inline setBack# #-}

-- | Template function, creates a @Parser e ()@ which unsafely scans a given
--   sequence of bytes.
scanBytes# :: [Word] -> Q Exp
scanBytes# :: [Word] -> Q Exp
scanBytes# [Word]
bytes = do
  let !([Word]
leading, [Word]
w8s) = [Word] -> ([Word], [Word])
splitBytes [Word]
bytes
      !scanw8s :: Q Exp
scanw8s        = [Word] -> Q Exp
forall t. Lift t => [t] -> Q Exp
go [Word]
w8s where
                         go :: [t] -> Q Exp
go (t
w8:[] ) = [| scan64# w8 |]
                         go (t
w8:[t]
w8s) = [| scan64# w8 >> $(go w8s) |]
                         go []       = [| pure () |]
  case [Word]
w8s of
    [] -> [Word] -> Q Exp
go [Word]
leading
          where
            go :: [Word] -> Q Exp
go (Word
a:Word
b:Word
c:Word
d:[]) = let !w :: Word
w = [Word] -> Word
packBytes [Word
a, Word
b, Word
c, Word
d] in [| scan32# w |]
            go (Word
a:Word
b:Word
c:Word
d:[Word]
ws) = let !w :: Word
w = [Word] -> Word
packBytes [Word
a, Word
b, Word
c, Word
d] in [| scan32# w >> $(go ws) |]
            go (Word
a:Word
b:[])     = let !w :: Word
w = [Word] -> Word
packBytes [Word
a, Word
b]       in [| scan16# w |]
            go (Word
a:Word
b:[Word]
ws)     = let !w :: Word
w = [Word] -> Word
packBytes [Word
a, Word
b]       in [| scan16# w >> $(go ws) |]
            go (Word
a:[])       = [| scan8# a |]
            go []           = [| pure () |]
    [Word]
_  -> case [Word]
leading of

      []              -> Q Exp
scanw8s
      [Word
a]             -> [| scan8# a >> $scanw8s |]
      ws :: [Word]
ws@[Word
a, Word
b]       -> let !w :: Word
w = [Word] -> Word
packBytes [Word]
ws in [| scan16# w >> $scanw8s |]
      ws :: [Word]
ws@[Word
a, Word
b, Word
c, Word
d] -> let !w :: Word
w = [Word] -> Word
packBytes [Word]
ws in [| scan32# w >> $scanw8s |]
      [Word]
ws              -> let !w :: Word
w = [Word] -> Word
packBytes [Word]
ws
                             !l :: Int
l = [Word] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Word]
ws
                         in [| scanPartial64# l w >> $scanw8s |]


-- Switching code generation
--------------------------------------------------------------------------------

#if MIN_VERSION_base(4,15,0)
mkDoE = DoE Nothing
{-# inline mkDoE #-}
#else
mkDoE :: [Stmt] -> Exp
mkDoE = [Stmt] -> Exp
DoE
{-# inline mkDoE #-}
#endif

genTrie :: (Map (Maybe Int) Exp, Trie' (Rule, Int, Maybe Int)) -> Q Exp
genTrie :: (Map (Maybe Int) Exp, Trie' (Maybe Int, Int, Maybe Int)) -> Q Exp
genTrie (Map (Maybe Int) Exp
rules, Trie' (Maybe Int, Int, Maybe Int)
t) = do
  Map (Maybe Int) (Name, Exp)
branches <- (Exp -> Q (Name, Exp))
-> Map (Maybe Int) Exp -> Q (Map (Maybe Int) (Name, Exp))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (\Exp
e -> (,) (Name -> Exp -> (Name, Exp)) -> Q Name -> Q (Exp -> (Name, Exp))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (String -> Q Name
newName String
"rule") Q (Exp -> (Name, Exp)) -> Q Exp -> Q (Name, Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Exp -> Q Exp
forall (f :: * -> *) a. Applicative f => a -> f a
pure Exp
e) Map (Maybe Int) Exp
rules

  let ix :: Map a p -> a -> p
ix Map a p
m a
k = case a -> Map a p -> Maybe p
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup a
k Map a p
m of
        Maybe p
Nothing -> String -> p
forall a. HasCallStack => String -> a
error (String
"key not in map: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
k)
        Just p
a  -> p
a

  let ensure :: Maybe Int -> Maybe (Q Exp)
      ensure :: Maybe Int -> Maybe (Q Exp)
ensure = (Int -> Q Exp) -> Maybe Int -> Maybe (Q Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Int
n -> [| ensureBytes# n |])

      fallback :: Rule -> Int ->  Q Exp
      fallback :: Maybe Int -> Int -> Q Exp
fallback Maybe Int
rule Int
0 = Exp -> Q Exp
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Exp -> Q Exp) -> Exp -> Q Exp
forall a b. (a -> b) -> a -> b
$ Name -> Exp
VarE (Name -> Exp) -> Name -> Exp
forall a b. (a -> b) -> a -> b
$ (Name, Exp) -> Name
forall a b. (a, b) -> a
fst ((Name, Exp) -> Name) -> (Name, Exp) -> Name
forall a b. (a -> b) -> a -> b
$ Map (Maybe Int) (Name, Exp) -> Maybe Int -> (Name, Exp)
forall a p. (Ord a, Show a) => Map a p -> a -> p
ix Map (Maybe Int) (Name, Exp)
branches Maybe Int
rule
      fallback Maybe Int
rule Int
n = [| setBack# n >> $(pure $ VarE $ fst $ ix branches rule) |]

  let go :: Trie' (Rule, Int, Maybe Int) -> Q Exp
      go :: Trie' (Maybe Int, Int, Maybe Int) -> Q Exp
go = \case
        Branch' (Maybe Int
r, Int
n, Maybe Int
alloc) Map Word (Trie' (Maybe Int, Int, Maybe Int))
ts
          | Map Word (Trie' (Maybe Int, Int, Maybe Int)) -> Bool
forall k a. Map k a -> Bool
M.null Map Word (Trie' (Maybe Int, Int, Maybe Int))
ts -> Exp -> Q Exp
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Exp -> Q Exp) -> Exp -> Q Exp
forall a b. (a -> b) -> a -> b
$ Name -> Exp
VarE (Name -> Exp) -> Name -> Exp
forall a b. (a -> b) -> a -> b
$ (Name, Exp) -> Name
forall a b. (a, b) -> a
fst ((Name, Exp) -> Name) -> (Name, Exp) -> Name
forall a b. (a -> b) -> a -> b
$ Map (Maybe Int) (Name, Exp)
branches Map (Maybe Int) (Name, Exp) -> Maybe Int -> (Name, Exp)
forall k a. Ord k => Map k a -> k -> a
M.! Maybe Int
r
          | Bool
otherwise -> do
              ![(Word, Exp)]
next         <- (((Word, Trie' (Maybe Int, Int, Maybe Int)) -> Q (Word, Exp))
-> [(Word, Trie' (Maybe Int, Int, Maybe Int))] -> Q [(Word, Exp)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (((Word, Trie' (Maybe Int, Int, Maybe Int)) -> Q (Word, Exp))
 -> [(Word, Trie' (Maybe Int, Int, Maybe Int))] -> Q [(Word, Exp)])
-> ((Trie' (Maybe Int, Int, Maybe Int) -> Q Exp)
    -> (Word, Trie' (Maybe Int, Int, Maybe Int)) -> Q (Word, Exp))
-> (Trie' (Maybe Int, Int, Maybe Int) -> Q Exp)
-> [(Word, Trie' (Maybe Int, Int, Maybe Int))]
-> Q [(Word, Exp)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Trie' (Maybe Int, Int, Maybe Int) -> Q Exp)
-> (Word, Trie' (Maybe Int, Int, Maybe Int)) -> Q (Word, Exp)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse) Trie' (Maybe Int, Int, Maybe Int) -> Q Exp
go (Map Word (Trie' (Maybe Int, Int, Maybe Int))
-> [(Word, Trie' (Maybe Int, Int, Maybe Int))]
forall k a. Map k a -> [(k, a)]
M.toList Map Word (Trie' (Maybe Int, Int, Maybe Int))
ts)
              !Exp
defaultCase  <- Maybe Int -> Int -> Q Exp
fallback Maybe Int
r (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)

              let cases :: Exp
cases = [Stmt] -> Exp
mkDoE ([Stmt] -> Exp) -> [Stmt] -> Exp
forall a b. (a -> b) -> a -> b
$
                    [Pat -> Exp -> Stmt
BindS (Name -> Pat
VarP (String -> Name
mkName String
"c")) (Name -> Exp
VarE 'scanAny8#),
                      Exp -> Stmt
NoBindS (Exp -> [Match] -> Exp
CaseE (Name -> Exp
VarE (String -> Name
mkName String
"c"))
                         (((Word, Exp) -> Match) -> [(Word, Exp)] -> [Match]
forall a b. (a -> b) -> [a] -> [b]
map (\(Word
w, Exp
t) ->
                                 Pat -> Body -> [Dec] -> Match
Match (Lit -> Pat
LitP (Integer -> Lit
IntegerL (Word -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
w)))
                                       (Exp -> Body
NormalB Exp
t)
                                       [])
                              [(Word, Exp)]
next
                          [Match] -> [Match] -> [Match]
forall a. [a] -> [a] -> [a]
++ [Pat -> Body -> [Dec] -> Match
Match Pat
WildP (Exp -> Body
NormalB Exp
defaultCase) []]))]

              case Maybe Int -> Maybe (Q Exp)
ensure Maybe Int
alloc of
                Maybe (Q Exp)
Nothing    -> Exp -> Q Exp
forall (f :: * -> *) a. Applicative f => a -> f a
pure Exp
cases
                Just Q Exp
alloc -> [| branch $alloc $(pure cases) $(fallback r n) |]

        Path (Maybe Int
r, Int
n, Maybe Int
alloc) [Word]
ws Trie' (Maybe Int, Int, Maybe Int)
t ->
          case Maybe Int -> Maybe (Q Exp)
ensure Maybe Int
alloc of
            Maybe (Q Exp)
Nothing    -> [| branch $(scanBytes# ws) $(go t) $(fallback r n)|]
            Just Q Exp
alloc -> [| branch ($alloc >> $(scanBytes# ws)) $(go t) $(fallback r n) |]

  [DecQ] -> Q Exp -> Q Exp
letE
    (((Name, Exp) -> DecQ) -> [(Name, Exp)] -> [DecQ]
forall a b. (a -> b) -> [a] -> [b]
map (\(Name
x, Exp
rhs) -> PatQ -> BodyQ -> [DecQ] -> DecQ
valD (Name -> PatQ
varP Name
x) (Q Exp -> BodyQ
normalB (Exp -> Q Exp
forall (f :: * -> *) a. Applicative f => a -> f a
pure Exp
rhs)) []) (Map (Maybe Int) (Name, Exp) -> [(Name, Exp)]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Data.Foldable.toList Map (Maybe Int) (Name, Exp)
branches))
    (Trie' (Maybe Int, Int, Maybe Int) -> Q Exp
go Trie' (Maybe Int, Int, Maybe Int)
t)

parseSwitch :: Q Exp -> Q ([(String, Exp)], Maybe Exp)
parseSwitch :: Q Exp -> Q ([(String, Exp)], Maybe Exp)
parseSwitch Q Exp
exp = Q Exp
exp Q Exp
-> (Exp -> Q ([(String, Exp)], Maybe Exp))
-> Q ([(String, Exp)], Maybe Exp)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
  CaseE (UnboundVarE Name
_) []    -> String -> Q ([(String, Exp)], Maybe Exp)
forall a. HasCallStack => String -> a
error String
"switch: empty clause list"
  CaseE (UnboundVarE Name
_) [Match]
cases -> do
    (![Match]
cases, !Match
last) <- ([Match], Match) -> Q ([Match], Match)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Match] -> [Match]
forall a. [a] -> [a]
init [Match]
cases, [Match] -> Match
forall a. [a] -> a
last [Match]
cases)
    ![(String, Exp)]
cases <- [Match] -> (Match -> Q (String, Exp)) -> Q [(String, Exp)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Match]
cases \case
      Match (LitP (StringL String
str)) (NormalB Exp
rhs) [] -> (String, Exp) -> Q (String, Exp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String
str, Exp
rhs)
      Match
_ -> String -> Q (String, Exp)
forall a. HasCallStack => String -> a
error String
"switch: expected a match clause on a string literal"
    (![(String, Exp)]
cases, !Maybe Exp
last) <- case Match
last of
      Match (LitP (StringL String
str)) (NormalB Exp
rhs) [] -> ([(String, Exp)], Maybe Exp) -> Q ([(String, Exp)], Maybe Exp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([(String, Exp)]
cases [(String, Exp)] -> [(String, Exp)] -> [(String, Exp)]
forall a. [a] -> [a] -> [a]
++ [(String
str, Exp
rhs)], Maybe Exp
forall k1. Maybe k1
Nothing)
      Match Pat
WildP                (NormalB Exp
rhs) [] -> ([(String, Exp)], Maybe Exp) -> Q ([(String, Exp)], Maybe Exp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([(String, Exp)]
cases, Exp -> Maybe Exp
forall k1. k1 -> Maybe k1
Just Exp
rhs)
      Match
_ -> String -> Q ([(String, Exp)], Maybe Exp)
forall a. HasCallStack => String -> a
error String
"switch: expected a match clause on a string literal or a wildcard"
    ([(String, Exp)], Maybe Exp) -> Q ([(String, Exp)], Maybe Exp)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([(String, Exp)]
cases, Maybe Exp
last)
  Exp
_ -> String -> Q ([(String, Exp)], Maybe Exp)
forall a. HasCallStack => String -> a
error String
"switch: expected a \"case _ of\" expression"

genSwitchTrie' :: Maybe Exp -> [(String, Exp)] -> Maybe Exp
              -> (Map (Maybe Int) Exp, Trie' (Rule, Int, Maybe Int))
genSwitchTrie' :: Maybe Exp
-> [(String, Exp)]
-> Maybe Exp
-> (Map (Maybe Int) Exp, Trie' (Maybe Int, Int, Maybe Int))
genSwitchTrie' Maybe Exp
postAction [(String, Exp)]
cases Maybe Exp
fallback =

  let (![(Maybe Int, Exp)]
branches, ![(Int, String)]
strings) = [((Maybe Int, Exp), (Int, String))]
-> ([(Maybe Int, Exp)], [(Int, String)])
forall a b. [(a, b)] -> ([a], [b])
unzip do
        (!Int
i, (!String
str, !Exp
rhs)) <- [Int] -> [(String, Exp)] -> [(Int, (String, Exp))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] [(String, Exp)]
cases
        case Maybe Exp
postAction of
          Maybe Exp
Nothing    -> ((Maybe Int, Exp), (Int, String))
-> [((Maybe Int, Exp), (Int, String))]
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Int -> Maybe Int
forall k1. k1 -> Maybe k1
Just Int
i, Exp
rhs), (Int
i, String
str))
          Just !Exp
post -> ((Maybe Int, Exp), (Int, String))
-> [((Maybe Int, Exp), (Int, String))]
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Int -> Maybe Int
forall k1. k1 -> Maybe k1
Just Int
i, (Name -> Exp
VarE '(>>)) Exp -> Exp -> Exp
`AppE` Exp
post Exp -> Exp -> Exp
`AppE` Exp
rhs), (Int
i, String
str))

      !m :: Map (Maybe Int) Exp
m    =  [(Maybe Int, Exp)] -> Map (Maybe Int) Exp
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ((Maybe Int
forall k1. Maybe k1
Nothing, Exp -> (Exp -> Exp) -> Maybe Exp -> Exp
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Name -> Exp
VarE 'empty) Exp -> Exp
forall a. a -> a
id Maybe Exp
fallback) (Maybe Int, Exp) -> [(Maybe Int, Exp)] -> [(Maybe Int, Exp)]
forall k1. k1 -> [k1] -> [k1]
: [(Maybe Int, Exp)]
branches)
      !trie :: Trie' (Maybe Int, Int, Maybe Int)
trie = [(Int, String)] -> Trie' (Maybe Int, Int, Maybe Int)
compileTrie [(Int, String)]
strings
  in (Map (Maybe Int) Exp
m , Trie' (Maybe Int, Int, Maybe Int)
trie)