{-# OPTIONS_GHC -Wno-missing-export-lists #-}

{-# LANGUAGE FlexibleContexts #-}

module Burrito.Internal.Parse where

import qualified Burrito.Internal.Type.Character as Character
import qualified Burrito.Internal.Type.Digit as Digit
import qualified Burrito.Internal.Type.Expression as Expression
import qualified Burrito.Internal.Type.Field as Field
import qualified Burrito.Internal.Type.Literal as Literal
import qualified Burrito.Internal.Type.MaxLength as MaxLength
import qualified Burrito.Internal.Type.Modifier as Modifier
import qualified Burrito.Internal.Type.Name as Name
import qualified Burrito.Internal.Type.Operator as Operator
import qualified Burrito.Internal.Type.Template as Template
import qualified Burrito.Internal.Type.Token as Token
import qualified Burrito.Internal.Type.Variable as Variable
import qualified Data.Char as Char
import qualified Data.Ix as Ix
import qualified Data.List.NonEmpty as NonEmpty
import qualified Text.Parsec as Parsec
import qualified Text.Read as Read

-- | Attempts to parse a string as a URI template. If parsing fails, this will
-- return @Nothing@. Otherwise it will return @Just@ the parsed template.
--
-- Parsing will usually succeed, but it can fail if the input string contains
-- characters that are not valid in IRIs (like @^@) or if the input string
-- contains an invalid template expression (like @{!}@). To include characters
-- that aren't valid in IRIs, percent encode them (like @%5E@).
--
-- >>> parse "invalid template"
-- Nothing
-- >>> parse "valid-template"
-- Just (Template ...)
parse :: String -> Maybe Template.Template
parse :: String -> Maybe Template
parse = (ParseError -> Maybe Template)
-> (Template -> Maybe Template)
-> Either ParseError Template
-> Maybe Template
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe Template -> ParseError -> Maybe Template
forall a b. a -> b -> a
const Maybe Template
forall a. Maybe a
Nothing) Template -> Maybe Template
forall a. a -> Maybe a
Just (Either ParseError Template -> Maybe Template)
-> (String -> Either ParseError Template)
-> String
-> Maybe Template
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parsec String () Template
-> String -> String -> Either ParseError Template
forall s t a.
Stream s Identity t =>
Parsec s () a -> String -> s -> Either ParseError a
Parsec.parse Parsec String () Template
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Template
template String
""

template :: Parsec.Stream s m Char => Parsec.ParsecT s u m Template.Template
template :: ParsecT s u m Template
template = [Token] -> Template
Template.Template ([Token] -> Template)
-> ParsecT s u m [Token] -> ParsecT s u m Template
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m Token -> ParsecT s u m [Token]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
Parsec.many ParsecT s u m Token
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Token
token ParsecT s u m Template
-> ParsecT s u m () -> ParsecT s u m Template
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT s u m ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
Parsec.eof

token :: Parsec.Stream s m Char => Parsec.ParsecT s u m Token.Token
token :: ParsecT s u m Token
token = ParsecT s u m Token -> ParsecT s u m Token -> ParsecT s u m Token
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
choice (Expression -> Token
Token.Expression (Expression -> Token)
-> ParsecT s u m Expression -> ParsecT s u m Token
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m Expression
forall s (m :: * -> *) u.
Stream s m Char =>
ParsecT s u m Expression
expression) (Literal -> Token
Token.Literal (Literal -> Token) -> ParsecT s u m Literal -> ParsecT s u m Token
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m Literal
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Literal
literal)

choice
  :: Parsec.ParsecT s u m a -> Parsec.ParsecT s u m a -> Parsec.ParsecT s u m a
choice :: ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
choice = ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
(Parsec.<|>)

expression
  :: Parsec.Stream s m Char => Parsec.ParsecT s u m Expression.Expression
expression :: ParsecT s u m Expression
expression =
  ParsecT s u m Char
-> ParsecT s u m Char
-> ParsecT s u m Expression
-> ParsecT s u m Expression
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
Parsec.between (Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'{') (Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'}')
    (ParsecT s u m Expression -> ParsecT s u m Expression)
-> ParsecT s u m Expression -> ParsecT s u m Expression
forall a b. (a -> b) -> a -> b
$ Operator -> NonEmpty Variable -> Expression
Expression.Expression
    (Operator -> NonEmpty Variable -> Expression)
-> ParsecT s u m Operator
-> ParsecT s u m (NonEmpty Variable -> Expression)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m Operator
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Operator
operator
    ParsecT s u m (NonEmpty Variable -> Expression)
-> ParsecT s u m (NonEmpty Variable) -> ParsecT s u m Expression
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT s u m Variable
-> ParsecT s u m Char -> ParsecT s u m (NonEmpty Variable)
forall s u (m :: * -> *) a x.
ParsecT s u m a -> ParsecT s u m x -> ParsecT s u m (NonEmpty a)
sepBy1 ParsecT s u m Variable
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Variable
variable (Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
',')

operator :: Parsec.Stream s m Char => Parsec.ParsecT s u m Operator.Operator
operator :: ParsecT s u m Operator
operator = Operator -> ParsecT s u m Operator -> ParsecT s u m Operator
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
Parsec.option Operator
Operator.None (ParsecT s u m Operator -> ParsecT s u m Operator)
-> ParsecT s u m Operator -> ParsecT s u m Operator
forall a b. (a -> b) -> a -> b
$ [ParsecT s u m Operator] -> ParsecT s u m Operator
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
Parsec.choice
  [ Operator
Operator.Ampersand Operator -> ParsecT s u m Char -> ParsecT s u m Operator
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'&'
  , Operator
Operator.FullStop Operator -> ParsecT s u m Char -> ParsecT s u m Operator
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'.'
  , Operator
Operator.NumberSign Operator -> ParsecT s u m Char -> ParsecT s u m Operator
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'#'
  , Operator
Operator.PlusSign Operator -> ParsecT s u m Char -> ParsecT s u m Operator
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'+'
  , Operator
Operator.QuestionMark Operator -> ParsecT s u m Char -> ParsecT s u m Operator
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'?'
  , Operator
Operator.Semicolon Operator -> ParsecT s u m Char -> ParsecT s u m Operator
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
';'
  , Operator
Operator.Solidus Operator -> ParsecT s u m Char -> ParsecT s u m Operator
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'/'
  ]

sepBy1
  :: Parsec.ParsecT s u m a
  -> Parsec.ParsecT s u m x
  -> Parsec.ParsecT s u m (NonEmpty.NonEmpty a)
sepBy1 :: ParsecT s u m a -> ParsecT s u m x -> ParsecT s u m (NonEmpty a)
sepBy1 ParsecT s u m a
p ParsecT s u m x
s = a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
(NonEmpty.:|) (a -> [a] -> NonEmpty a)
-> ParsecT s u m a -> ParsecT s u m ([a] -> NonEmpty a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m a
p ParsecT s u m ([a] -> NonEmpty a)
-> ParsecT s u m [a] -> ParsecT s u m (NonEmpty a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT s u m a -> ParsecT s u m [a]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
Parsec.many (ParsecT s u m x
s ParsecT s u m x -> ParsecT s u m a -> ParsecT s u m a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT s u m a
p)

variable :: Parsec.Stream s m Char => Parsec.ParsecT s u m Variable.Variable
variable :: ParsecT s u m Variable
variable = Name -> Modifier -> Variable
Variable.Variable (Name -> Modifier -> Variable)
-> ParsecT s u m Name -> ParsecT s u m (Modifier -> Variable)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m Name
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Name
name ParsecT s u m (Modifier -> Variable)
-> ParsecT s u m Modifier -> ParsecT s u m Variable
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT s u m Modifier
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Modifier
modifier

name :: Parsec.Stream s m Char => Parsec.ParsecT s u m Name.Name
name :: ParsecT s u m Name
name = NonEmpty Field -> Name
Name.Name (NonEmpty Field -> Name)
-> ParsecT s u m (NonEmpty Field) -> ParsecT s u m Name
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m Field
-> ParsecT s u m Char -> ParsecT s u m (NonEmpty Field)
forall s u (m :: * -> *) a x.
ParsecT s u m a -> ParsecT s u m x -> ParsecT s u m (NonEmpty a)
sepBy1 ParsecT s u m Field
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Field
field (Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'.')

field :: Parsec.Stream s m Char => Parsec.ParsecT s u m Field.Field
field :: ParsecT s u m Field
field = NonEmpty (Character Field) -> Field
Field.Field (NonEmpty (Character Field) -> Field)
-> ParsecT s u m (NonEmpty (Character Field))
-> ParsecT s u m Field
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m (Character Field)
-> ParsecT s u m (NonEmpty (Character Field))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m (NonEmpty a)
nonEmpty ParsecT s u m (Character Field)
forall s (m :: * -> *) u.
Stream s m Char =>
ParsecT s u m (Character Field)
fieldCharacter

nonEmpty
  :: Parsec.ParsecT s u m a -> Parsec.ParsecT s u m (NonEmpty.NonEmpty a)
nonEmpty :: ParsecT s u m a -> ParsecT s u m (NonEmpty a)
nonEmpty ParsecT s u m a
p = a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
(NonEmpty.:|) (a -> [a] -> NonEmpty a)
-> ParsecT s u m a -> ParsecT s u m ([a] -> NonEmpty a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m a
p ParsecT s u m ([a] -> NonEmpty a)
-> ParsecT s u m [a] -> ParsecT s u m (NonEmpty a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT s u m a -> ParsecT s u m [a]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
Parsec.many ParsecT s u m a
p

fieldCharacter
  :: Parsec.Stream s m Char
  => Parsec.ParsecT s u m (Character.Character Field.Field)
fieldCharacter :: ParsecT s u m (Character Field)
fieldCharacter = ParsecT s u m (Character Field)
-> ParsecT s u m (Character Field)
-> ParsecT s u m (Character Field)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
choice ParsecT s u m (Character Field)
forall s (m :: * -> *) u tag.
Stream s m Char =>
ParsecT s u m (Character tag)
encodedCharacter ((Char -> Bool) -> ParsecT s u m (Character Field)
forall s (m :: * -> *) u tag.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m (Character tag)
unencodedCharacter Char -> Bool
isFieldCharacter)

encodedCharacter
  :: Parsec.Stream s m Char => Parsec.ParsecT s u m (Character.Character tag)
encodedCharacter :: ParsecT s u m (Character tag)
encodedCharacter = Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'%' ParsecT s u m Char
-> ParsecT s u m (Character tag) -> ParsecT s u m (Character tag)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Digit -> Digit -> Character tag
forall tag. Digit -> Digit -> Character tag
Character.Encoded (Digit -> Digit -> Character tag)
-> ParsecT s u m Digit -> ParsecT s u m (Digit -> Character tag)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m Digit
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Digit
digit ParsecT s u m (Digit -> Character tag)
-> ParsecT s u m Digit -> ParsecT s u m (Character tag)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT s u m Digit
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Digit
digit

digit :: Parsec.Stream s m Char => Parsec.ParsecT s u m Digit.Digit
digit :: ParsecT s u m Digit
digit = do
  Char
x <- (Char -> Bool) -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
Parsec.satisfy Char -> Bool
Char.isHexDigit
  ParsecT s u m Digit
-> (Digit -> ParsecT s u m Digit)
-> Maybe Digit
-> ParsecT s u m Digit
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> ParsecT s u m Digit
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"invalid Digit") Digit -> ParsecT s u m Digit
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Digit -> ParsecT s u m Digit)
-> Maybe Digit -> ParsecT s u m Digit
forall a b. (a -> b) -> a -> b
$ Char -> Maybe Digit
Digit.fromChar Char
x

unencodedCharacter
  :: Parsec.Stream s m Char
  => (Char -> Bool)
  -> Parsec.ParsecT s u m (Character.Character tag)
unencodedCharacter :: (Char -> Bool) -> ParsecT s u m (Character tag)
unencodedCharacter = (Char -> Character tag)
-> ParsecT s u m Char -> ParsecT s u m (Character tag)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Char -> Character tag
forall tag. Char -> Character tag
Character.Unencoded (ParsecT s u m Char -> ParsecT s u m (Character tag))
-> ((Char -> Bool) -> ParsecT s u m Char)
-> (Char -> Bool)
-> ParsecT s u m (Character tag)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
Parsec.satisfy

isFieldCharacter :: Char -> Bool
isFieldCharacter :: Char -> Bool
isFieldCharacter Char
x = case Char
x of
  Char
'_' -> Bool
True
  Char
_ -> Char -> Bool
Char.isAsciiUpper Char
x Bool -> Bool -> Bool
|| Char -> Bool
Char.isAsciiLower Char
x Bool -> Bool -> Bool
|| Char -> Bool
Char.isDigit Char
x

modifier :: Parsec.Stream s m Char => Parsec.ParsecT s u m Modifier.Modifier
modifier :: ParsecT s u m Modifier
modifier = Modifier -> ParsecT s u m Modifier -> ParsecT s u m Modifier
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
Parsec.option Modifier
Modifier.None (ParsecT s u m Modifier -> ParsecT s u m Modifier)
-> ParsecT s u m Modifier -> ParsecT s u m Modifier
forall a b. (a -> b) -> a -> b
$ [ParsecT s u m Modifier] -> ParsecT s u m Modifier
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
Parsec.choice
  [ Modifier
Modifier.Asterisk Modifier -> ParsecT s u m Char -> ParsecT s u m Modifier
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'*'
  , Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
':' ParsecT s u m Char
-> ParsecT s u m Modifier -> ParsecT s u m Modifier
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> MaxLength -> Modifier
Modifier.Colon (MaxLength -> Modifier)
-> ParsecT s u m MaxLength -> ParsecT s u m Modifier
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m MaxLength
forall s (m :: * -> *) u.
Stream s m Char =>
ParsecT s u m MaxLength
maxLength
  ]

maxLength :: Parsec.Stream s m Char => Parsec.ParsecT s u m MaxLength.MaxLength
maxLength :: ParsecT s u m MaxLength
maxLength = do
  Char
x <- (Char -> Bool) -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
Parsec.satisfy ((Char -> Bool) -> ParsecT s u m Char)
-> (Char -> Bool) -> ParsecT s u m Char
forall a b. (a -> b) -> a -> b
$ (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'1', Char
'9')
  String
xs <- ParsecT s u m Char -> ParsecT s u m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
Parsec.many (ParsecT s u m Char -> ParsecT s u m String)
-> ParsecT s u m Char -> ParsecT s u m String
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
Parsec.satisfy Char -> Bool
Char.isDigit
  Int
n <- ParsecT s u m Int
-> (Int -> ParsecT s u m Int) -> Maybe Int -> ParsecT s u m Int
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> ParsecT s u m Int
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"invalid MaxLength") Int -> ParsecT s u m Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Int -> ParsecT s u m Int)
-> (String -> Maybe Int) -> String -> ParsecT s u m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Maybe Int
forall a. Read a => String -> Maybe a
Read.readMaybe (String -> ParsecT s u m Int) -> String -> ParsecT s u m Int
forall a b. (a -> b) -> a -> b
$ Char
x Char -> String -> String
forall a. a -> [a] -> [a]
: String
xs
  if Int -> Bool
isMaxLength Int
n
    then MaxLength -> ParsecT s u m MaxLength
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MaxLength -> ParsecT s u m MaxLength)
-> MaxLength -> ParsecT s u m MaxLength
forall a b. (a -> b) -> a -> b
$ Int -> MaxLength
MaxLength.MaxLength Int
n
    else String -> ParsecT s u m MaxLength
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"invalid MaxLength"

isMaxLength :: Int -> Bool
isMaxLength :: Int -> Bool
isMaxLength = (Int, Int) -> Int -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Int
1, Int
9999)

literal :: Parsec.Stream s m Char => Parsec.ParsecT s u m Literal.Literal
literal :: ParsecT s u m Literal
literal = NonEmpty (Character Literal) -> Literal
Literal.Literal (NonEmpty (Character Literal) -> Literal)
-> ParsecT s u m (NonEmpty (Character Literal))
-> ParsecT s u m Literal
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT s u m (Character Literal)
-> ParsecT s u m (NonEmpty (Character Literal))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m (NonEmpty a)
nonEmpty ParsecT s u m (Character Literal)
forall s (m :: * -> *) u.
Stream s m Char =>
ParsecT s u m (Character Literal)
literalCharacter

literalCharacter
  :: Parsec.Stream s m Char
  => Parsec.ParsecT s u m (Character.Character Literal.Literal)
literalCharacter :: ParsecT s u m (Character Literal)
literalCharacter =
  ParsecT s u m (Character Literal)
-> ParsecT s u m (Character Literal)
-> ParsecT s u m (Character Literal)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
choice ParsecT s u m (Character Literal)
forall s (m :: * -> *) u tag.
Stream s m Char =>
ParsecT s u m (Character tag)
encodedCharacter ((Char -> Bool) -> ParsecT s u m (Character Literal)
forall s (m :: * -> *) u tag.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m (Character tag)
unencodedCharacter Char -> Bool
isLiteralCharacter)

isLiteralCharacter :: Char -> Bool
isLiteralCharacter :: Char -> Bool
isLiteralCharacter Char
x = case Char
x of
  Char
' ' -> Bool
False
  Char
'"' -> Bool
False
  Char
'\'' -> Bool
False
  Char
'%' -> Bool
False
  Char
'<' -> Bool
False
  Char
'>' -> Bool
False
  Char
'\\' -> Bool
False
  Char
'^' -> Bool
False
  Char
'`' -> Bool
False
  Char
'{' -> Bool
False
  Char
'|' -> Bool
False
  Char
'}' -> Bool
False
  Char
_ ->
    (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\x20', Char
'\x7e') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\xa0', Char
'\xd7ff') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\xe000', Char
'\xf8ff') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\xf900', Char
'\xfdcf') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\xfdf0', Char
'\xffef') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\x10000', Char
'\x1fffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\x20000', Char
'\x2fffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\x30000', Char
'\x3fffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\x40000', Char
'\x4fffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\x50000', Char
'\x5fffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\x60000', Char
'\x6fffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\x70000', Char
'\x7fffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\x80000', Char
'\x8fffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\x90000', Char
'\x9fffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\xa0000', Char
'\xafffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\xb0000', Char
'\xbfffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\xc0000', Char
'\xcfffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\xd0000', Char
'\xdfffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\xe1000', Char
'\xefffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\xf0000', Char
'\xffffd') Char
x
      Bool -> Bool -> Bool
|| (Char, Char) -> Char -> Bool
forall a. Ix a => (a, a) -> a -> Bool
Ix.inRange (Char
'\x100000', Char
'\x10fffd') Char
x