{-# OPTIONS_GHC -Wno-unused-do-bind #-}
{- |
Module      : Data.Aeson.JSONPath.Parser
Description : Parses the raw query to ADT
Copyright   : (c) 2024-2025 Taimoor Zaeem
License     : MIT
Maintainer  : Taimoor Zaeem <mtaimoorzaeem@gmail.com>
Stability   : Experimental
Portability : Portable

Parses raw query to Haskell Algebraic Data Types
-}
module Data.Aeson.JSONPath.Parser
  ( pQuery )
  where

import qualified Data.Text                      as T
import qualified Text.ParserCombinators.Parsec  as P

import Data.Functor                  (($>))
import Data.Char                     (ord, chr)
import Data.Maybe                    (isNothing, fromMaybe)
import Data.Scientific               (Scientific, scientific)
import GHC.Num                       (integerFromInt, integerToInt)
import Text.ParserCombinators.Parsec ((<|>))

import Data.Aeson.JSONPath.Query.Types

import Prelude

-- | Query parser
pQuery :: P.Parser Query
pQuery :: Parser Query
pQuery = Parser Query -> Parser Query
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Query
pRootQuery Parser Query -> ParsecT String () Identity () -> Parser Query
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT String () Identity ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
P.eof

pRootQuery :: P.Parser Query
pRootQuery :: Parser Query
pRootQuery = do
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'$'
  [QuerySegment]
segs <- ParsecT String () Identity QuerySegment
-> ParsecT String () Identity [QuerySegment]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
P.many (Parser String
pSpaces Parser String
-> ParsecT String () Identity QuerySegment
-> ParsecT String () Identity QuerySegment
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT String () Identity QuerySegment
pQuerySegment)
  Query -> Parser Query
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Query -> Parser Query) -> Query -> Parser Query
forall a b. (a -> b) -> a -> b
$ Query { queryType :: QueryType
queryType = QueryType
Root, querySegments :: [QuerySegment]
querySegments = [QuerySegment]
segs }

pCurrentQuery :: P.Parser Query
pCurrentQuery :: Parser Query
pCurrentQuery = do
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'@'
  [QuerySegment]
segs <- ParsecT String () Identity QuerySegment
-> ParsecT String () Identity [QuerySegment]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
P.many ParsecT String () Identity QuerySegment
pQuerySegment
  Query -> Parser Query
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Query -> Parser Query) -> Query -> Parser Query
forall a b. (a -> b) -> a -> b
$ Query { queryType :: QueryType
queryType = QueryType
Current, querySegments :: [QuerySegment]
querySegments = [QuerySegment]
segs }


pQuerySegment :: P.Parser QuerySegment
pQuerySegment :: ParsecT String () Identity QuerySegment
pQuerySegment = do
  Maybe String
dotdot <- Parser String -> ParsecT String () Identity (Maybe String)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
P.optionMaybe (Parser String -> Parser String
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Parser String -> Parser String) -> Parser String -> Parser String
forall a b. (a -> b) -> a -> b
$ String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"..")
  Segment
seg <- Bool -> Parser Segment
pSegment (Bool -> Parser Segment) -> Bool -> Parser Segment
forall a b. (a -> b) -> a -> b
$ Maybe String -> Bool
forall a. Maybe a -> Bool
isNothing Maybe String
dotdot
  let segType :: SegmentType
segType = if Maybe String -> Bool
forall a. Maybe a -> Bool
isNothing Maybe String
dotdot then SegmentType
Child else SegmentType
Descendant
  QuerySegment -> ParsecT String () Identity QuerySegment
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (QuerySegment -> ParsecT String () Identity QuerySegment)
-> QuerySegment -> ParsecT String () Identity QuerySegment
forall a b. (a -> b) -> a -> b
$ QuerySegment { segmentType :: SegmentType
segmentType = SegmentType
segType, segment :: Segment
segment = Segment
seg }

pSegment :: Bool -> P.Parser Segment
pSegment :: Bool -> Parser Segment
pSegment Bool
isChild = Parser Segment -> Parser Segment
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Segment
pBracketed
                Parser Segment -> Parser Segment -> Parser Segment
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Segment -> Parser Segment
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Bool -> Parser Segment
pDotted Bool
isChild)
                Parser Segment -> Parser Segment -> Parser Segment
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Segment -> Parser Segment
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Bool -> Parser Segment
pWildcardSeg Bool
isChild)


pBracketed :: P.Parser Segment
pBracketed :: Parser Segment
pBracketed = do
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'['
  Parser String
pSpaces
  Selector
sel <- Parser Selector
pSelector
  [Selector]
optionalSels <- Parser Selector -> ParsecT String () Identity [Selector]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
P.many Parser Selector
pCommaSepSelectors
  Parser String
pSpaces
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
']'
  Segment -> Parser Segment
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Segment -> Parser Segment) -> Segment -> Parser Segment
forall a b. (a -> b) -> a -> b
$ [Selector] -> Segment
Bracketed (Selector
selSelector -> [Selector] -> [Selector]
forall a. a -> [a] -> [a]
:[Selector]
optionalSels)
    where
      pCommaSepSelectors :: P.Parser Selector
      pCommaSepSelectors :: Parser Selector
pCommaSepSelectors = Parser Selector -> Parser Selector
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Parser Selector -> Parser Selector)
-> Parser Selector -> Parser Selector
forall a b. (a -> b) -> a -> b
$ Parser String
pSpaces Parser String
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
',' ParsecT String () Identity Char -> Parser String -> Parser String
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser String
pSpaces Parser String -> Parser Selector -> Parser Selector
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Selector
pSelector


pDotted :: Bool -> P.Parser Segment
pDotted :: Bool -> Parser Segment
pDotted Bool
isChild = do
  (if Bool
isChild then String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"." else String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"")
  ParsecT String () Identity Char -> ParsecT String () Identity Char
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
P.lookAhead (ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.letter ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> String -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"_" ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char
pUnicodeChar)
  Text
key <- String -> Text
T.pack (String -> Text)
-> Parser String -> ParsecT String () Identity Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Char -> Parser String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
P.many1 (ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.alphaNum ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> String -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"_" ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char
pUnicodeChar)
  Segment -> Parser Segment
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Segment -> Parser Segment) -> Segment -> Parser Segment
forall a b. (a -> b) -> a -> b
$ Text -> Segment
Dotted Text
key


pWildcardSeg :: Bool -> P.Parser Segment
pWildcardSeg :: Bool -> Parser Segment
pWildcardSeg Bool
isChild = (if Bool
isChild then String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"." else String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"") Parser String
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'*' ParsecT String () Identity Char -> Segment -> Parser Segment
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Segment
WildcardSegment
  
pSelector :: P.Parser Selector
pSelector :: Parser Selector
pSelector = Parser Selector -> Parser Selector
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Selector
pName
         Parser Selector -> Parser Selector -> Parser Selector
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Selector -> Parser Selector
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Selector
pSlice 
         Parser Selector -> Parser Selector -> Parser Selector
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Selector -> Parser Selector
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Selector
pIndex
         Parser Selector -> Parser Selector -> Parser Selector
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Selector -> Parser Selector
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Selector
pWildcardSel
         Parser Selector -> Parser Selector -> Parser Selector
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Selector -> Parser Selector
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Selector
pFilter

pName :: P.Parser Selector
pName :: Parser Selector
pName = Text -> Selector
Name (Text -> Selector) -> (String -> Text) -> String -> Selector
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack (String -> Selector) -> Parser String -> Parser Selector
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser String -> Parser String
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser String
pSingleQuotted Parser String -> Parser String -> Parser String
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser String -> Parser String
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser String
pDoubleQuotted)

pIndex :: P.Parser Selector
pIndex :: Parser Selector
pIndex = Int -> Selector
Index (Int -> Selector)
-> ParsecT String () Identity Int -> Parser Selector
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Int
pSignedInt

pSlice :: P.Parser Selector
pSlice :: Parser Selector
pSlice = do
  Maybe Int
start <- ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
P.optionMaybe (ParsecT String () Identity Int
pSignedInt ParsecT String () Identity Int
-> Parser String -> ParsecT String () Identity Int
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser String
pSpaces)
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
':'
  Parser String
pSpaces
  Maybe Int
end <- ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
P.optionMaybe (ParsecT String () Identity Int
pSignedInt ParsecT String () Identity Int
-> Parser String -> ParsecT String () Identity Int
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser String
pSpaces)
  Maybe (Maybe Int)
step <- ParsecT String () Identity (Maybe Int)
-> ParsecT String () Identity (Maybe (Maybe Int))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
P.optionMaybe (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
':' ParsecT String () Identity Char
-> ParsecT String () Identity (Maybe Int)
-> ParsecT String () Identity (Maybe Int)
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
P.optionMaybe (Parser String
pSpaces Parser String
-> ParsecT String () Identity Int -> ParsecT String () Identity Int
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT String () Identity Int
pSignedInt))
  Selector -> Parser Selector
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Selector -> Parser Selector) -> Selector -> Parser Selector
forall a b. (a -> b) -> a -> b
$ (Maybe Int, Maybe Int, Int) -> Selector
ArraySlice (Maybe Int
start, Maybe Int
end, case Maybe (Maybe Int)
step of
    Just (Just Int
n) -> Int
n
    Maybe (Maybe Int)
_ -> Int
1)


pWildcardSel :: P.Parser Selector
pWildcardSel :: Parser Selector
pWildcardSel = Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'*' ParsecT String () Identity Char -> Selector -> Parser Selector
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Selector
WildcardSelector


pFilter :: P.Parser Selector
pFilter :: Parser Selector
pFilter = do
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'?'
  Parser String
pSpaces
  LogicalOrExpr -> Selector
Filter (LogicalOrExpr -> Selector)
-> ParsecT String () Identity LogicalOrExpr -> Parser Selector
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity LogicalOrExpr
pLogicalOrExpr


pLogicalOrExpr :: P.Parser LogicalOrExpr
pLogicalOrExpr :: ParsecT String () Identity LogicalOrExpr
pLogicalOrExpr = do
  LogicalAndExpr
expr <- Parser LogicalAndExpr
pLogicalAndExpr
  [LogicalAndExpr]
optionalExprs <- Parser LogicalAndExpr
-> ParsecT String () Identity [LogicalAndExpr]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
P.many Parser LogicalAndExpr
pOrSepLogicalAndExprs
  LogicalOrExpr -> ParsecT String () Identity LogicalOrExpr
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (LogicalOrExpr -> ParsecT String () Identity LogicalOrExpr)
-> LogicalOrExpr -> ParsecT String () Identity LogicalOrExpr
forall a b. (a -> b) -> a -> b
$ [LogicalAndExpr] -> LogicalOrExpr
LogicalOr (LogicalAndExpr
exprLogicalAndExpr -> [LogicalAndExpr] -> [LogicalAndExpr]
forall a. a -> [a] -> [a]
:[LogicalAndExpr]
optionalExprs)
    where
      pOrSepLogicalAndExprs :: P.Parser LogicalAndExpr
      pOrSepLogicalAndExprs :: Parser LogicalAndExpr
pOrSepLogicalAndExprs = Parser LogicalAndExpr -> Parser LogicalAndExpr
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Parser LogicalAndExpr -> Parser LogicalAndExpr)
-> Parser LogicalAndExpr -> Parser LogicalAndExpr
forall a b. (a -> b) -> a -> b
$ Parser String
pSpaces Parser String -> Parser String -> Parser String
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"||" Parser String -> Parser String -> Parser String
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser String
pSpaces Parser String -> Parser LogicalAndExpr -> Parser LogicalAndExpr
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser LogicalAndExpr
pLogicalAndExpr

pLogicalAndExpr :: P.Parser LogicalAndExpr
pLogicalAndExpr :: Parser LogicalAndExpr
pLogicalAndExpr = do
  BasicExpr
expr <- Parser BasicExpr
pBasicExpr
  [BasicExpr]
optionalExprs <- Parser BasicExpr -> ParsecT String () Identity [BasicExpr]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
P.many Parser BasicExpr
pAndSepBasicExprs
  LogicalAndExpr -> Parser LogicalAndExpr
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (LogicalAndExpr -> Parser LogicalAndExpr)
-> LogicalAndExpr -> Parser LogicalAndExpr
forall a b. (a -> b) -> a -> b
$ [BasicExpr] -> LogicalAndExpr
LogicalAnd (BasicExpr
exprBasicExpr -> [BasicExpr] -> [BasicExpr]
forall a. a -> [a] -> [a]
:[BasicExpr]
optionalExprs)
    where
      pAndSepBasicExprs :: P.Parser BasicExpr
      pAndSepBasicExprs :: Parser BasicExpr
pAndSepBasicExprs = Parser BasicExpr -> Parser BasicExpr
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Parser BasicExpr -> Parser BasicExpr)
-> Parser BasicExpr -> Parser BasicExpr
forall a b. (a -> b) -> a -> b
$ Parser String
pSpaces Parser String -> Parser String -> Parser String
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"&&" Parser String -> Parser String -> Parser String
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser String
pSpaces Parser String -> Parser BasicExpr -> Parser BasicExpr
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser BasicExpr
pBasicExpr

pBasicExpr :: P.Parser BasicExpr
pBasicExpr :: Parser BasicExpr
pBasicExpr = Parser BasicExpr -> Parser BasicExpr
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser BasicExpr
pParenExpr
          Parser BasicExpr -> Parser BasicExpr -> Parser BasicExpr
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser BasicExpr -> Parser BasicExpr
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser BasicExpr
pComparisonExpr
          Parser BasicExpr -> Parser BasicExpr -> Parser BasicExpr
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser BasicExpr -> Parser BasicExpr
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser BasicExpr
pTestExpr

pParenExpr :: P.Parser BasicExpr
pParenExpr :: Parser BasicExpr
pParenExpr = do
  Maybe Char
notOp <- ParsecT String () Identity Char
-> ParsecT String () Identity (Maybe Char)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
P.optionMaybe (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'!' ParsecT String () Identity Char
-> Parser String -> ParsecT String () Identity Char
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser String
pSpaces)
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'('
  Parser String
pSpaces
  LogicalOrExpr
expr <- ParsecT String () Identity LogicalOrExpr
pLogicalOrExpr
  Parser String
pSpaces
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
')'
  let parenExp :: BasicExpr
parenExp = if Maybe Char -> Bool
forall a. Maybe a -> Bool
isNothing Maybe Char
notOp then LogicalOrExpr -> BasicExpr
Paren LogicalOrExpr
expr else LogicalOrExpr -> BasicExpr
NotParen LogicalOrExpr
expr
  BasicExpr -> Parser BasicExpr
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return BasicExpr
parenExp

pTestExpr :: P.Parser BasicExpr
pTestExpr :: Parser BasicExpr
pTestExpr = do
  Maybe Char
notOp <- ParsecT String () Identity Char
-> ParsecT String () Identity (Maybe Char)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
P.optionMaybe (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'!' ParsecT String () Identity Char
-> Parser String -> ParsecT String () Identity Char
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser String
pSpaces)
  Query
q <- Parser Query -> Parser Query
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Query
pRootQuery Parser Query -> Parser Query -> Parser Query
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Query -> Parser Query
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Query
pCurrentQuery
  let testExp :: BasicExpr
testExp = if Maybe Char -> Bool
forall a. Maybe a -> Bool
isNothing Maybe Char
notOp then Query -> BasicExpr
Test Query
q else Query -> BasicExpr
NotTest Query
q
  BasicExpr -> Parser BasicExpr
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return BasicExpr
testExp

pComparisonExpr :: P.Parser BasicExpr
pComparisonExpr :: Parser BasicExpr
pComparisonExpr = do
  Comparable
leftC <- Parser Comparable
pComparable
  Parser String
pSpaces
  ComparisonOp
compOp <- Parser ComparisonOp
pComparisonOp
  Parser String
pSpaces
  ComparisonExpr -> BasicExpr
Comparison (ComparisonExpr -> BasicExpr)
-> (Comparable -> ComparisonExpr) -> Comparable -> BasicExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Comparable -> ComparisonOp -> Comparable -> ComparisonExpr
Comp Comparable
leftC ComparisonOp
compOp (Comparable -> BasicExpr) -> Parser Comparable -> Parser BasicExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Comparable
pComparable

pComparisonOp :: P.Parser ComparisonOp
pComparisonOp :: Parser ComparisonOp
pComparisonOp = Parser ComparisonOp -> Parser ComparisonOp
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
">=" Parser String -> ComparisonOp -> Parser ComparisonOp
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ComparisonOp
GreaterOrEqual)
                Parser ComparisonOp -> Parser ComparisonOp -> Parser ComparisonOp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser ComparisonOp -> Parser ComparisonOp
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"<=" Parser String -> ComparisonOp -> Parser ComparisonOp
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ComparisonOp
LessOrEqual)
                Parser ComparisonOp -> Parser ComparisonOp -> Parser ComparisonOp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser ComparisonOp -> Parser ComparisonOp
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'>' ParsecT String () Identity Char
-> ComparisonOp -> Parser ComparisonOp
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ComparisonOp
Greater)
                Parser ComparisonOp -> Parser ComparisonOp -> Parser ComparisonOp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser ComparisonOp -> Parser ComparisonOp
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'<' ParsecT String () Identity Char
-> ComparisonOp -> Parser ComparisonOp
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ComparisonOp
Less)
                Parser ComparisonOp -> Parser ComparisonOp -> Parser ComparisonOp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser ComparisonOp -> Parser ComparisonOp
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"!=" Parser String -> ComparisonOp -> Parser ComparisonOp
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ComparisonOp
NotEqual)
                Parser ComparisonOp -> Parser ComparisonOp -> Parser ComparisonOp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser ComparisonOp -> Parser ComparisonOp
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"==" Parser String -> ComparisonOp -> Parser ComparisonOp
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ComparisonOp
Equal)

pComparable :: P.Parser Comparable
pComparable :: Parser Comparable
pComparable = Parser Comparable -> Parser Comparable
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Comparable
pCompLitString
              Parser Comparable -> Parser Comparable -> Parser Comparable
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Comparable -> Parser Comparable
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Comparable
pCompLitNum
              Parser Comparable -> Parser Comparable -> Parser Comparable
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Comparable -> Parser Comparable
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Comparable
pCompLitBool
              Parser Comparable -> Parser Comparable -> Parser Comparable
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Comparable -> Parser Comparable
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Comparable
pCompLitNull
              Parser Comparable -> Parser Comparable -> Parser Comparable
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Comparable -> Parser Comparable
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser Comparable
pCompSQ

pCompLitString :: P.Parser Comparable
pCompLitString :: Parser Comparable
pCompLitString = Text -> Comparable
CompLitString (Text -> Comparable) -> (String -> Text) -> String -> Comparable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack (String -> Comparable) -> Parser String -> Parser Comparable
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser String -> Parser String
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser String
pSingleQuotted Parser String -> Parser String -> Parser String
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser String -> Parser String
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser String
pDoubleQuotted)

pCompLitNum :: P.Parser Comparable
pCompLitNum :: Parser Comparable
pCompLitNum = Scientific -> Comparable
CompLitNum 
           (Scientific -> Comparable)
-> ParsecT String () Identity Scientific -> Parser Comparable
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ParsecT String () Identity Scientific
-> ParsecT String () Identity Scientific
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"-0" Parser String
-> Scientific -> ParsecT String () Identity Scientific
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> (Scientific
0 :: Scientific)) -- edge case
           ParsecT String () Identity Scientific
-> ParsecT String () Identity Scientific
-> ParsecT String () Identity Scientific
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Scientific
-> ParsecT String () Identity Scientific
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity Scientific
pDoubleScientific 
           ParsecT String () Identity Scientific
-> ParsecT String () Identity Scientific
-> ParsecT String () Identity Scientific
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Scientific
-> ParsecT String () Identity Scientific
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity Scientific
pScientific)

pCompLitBool :: P.Parser Comparable
pCompLitBool :: Parser Comparable
pCompLitBool = Bool -> Comparable
CompLitBool (Bool -> Comparable)
-> ParsecT String () Identity Bool -> Parser Comparable
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ParsecT String () Identity Bool -> ParsecT String () Identity Bool
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"true" Parser String -> Bool -> ParsecT String () Identity Bool
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool
True) ParsecT String () Identity Bool
-> ParsecT String () Identity Bool
-> ParsecT String () Identity Bool
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Bool -> ParsecT String () Identity Bool
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"false" Parser String -> Bool -> ParsecT String () Identity Bool
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool
False))

pCompLitNull :: P.Parser Comparable
pCompLitNull :: Parser Comparable
pCompLitNull = String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"null" Parser String -> Comparable -> Parser Comparable
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Comparable
CompLitNull

pCompSQ :: P.Parser Comparable
pCompSQ :: Parser Comparable
pCompSQ = SingularQuery -> Comparable
CompSQ (SingularQuery -> Comparable)
-> ParsecT String () Identity SingularQuery -> Parser Comparable
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ParsecT String () Identity SingularQuery
-> ParsecT String () Identity SingularQuery
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity SingularQuery
pCurrentSingleQ ParsecT String () Identity SingularQuery
-> ParsecT String () Identity SingularQuery
-> ParsecT String () Identity SingularQuery
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity SingularQuery
-> ParsecT String () Identity SingularQuery
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity SingularQuery
pRootSingleQ)

pCurrentSingleQ :: P.Parser SingularQuery
pCurrentSingleQ :: ParsecT String () Identity SingularQuery
pCurrentSingleQ = do
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'@'
  [SingularQuerySegment]
segs <- ParsecT String () Identity SingularQuerySegment
-> ParsecT String () Identity [SingularQuerySegment]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
P.many ParsecT String () Identity SingularQuerySegment
pSingularQuerySegment
  SingularQuery -> ParsecT String () Identity SingularQuery
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (SingularQuery -> ParsecT String () Identity SingularQuery)
-> SingularQuery -> ParsecT String () Identity SingularQuery
forall a b. (a -> b) -> a -> b
$ SingularQuery { singularQueryType :: SingularQueryType
singularQueryType = SingularQueryType
CurrentSQ, singularQuerySegments :: [SingularQuerySegment]
singularQuerySegments = [SingularQuerySegment]
segs }

pRootSingleQ :: P.Parser SingularQuery
pRootSingleQ :: ParsecT String () Identity SingularQuery
pRootSingleQ = do
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'$'
  [SingularQuerySegment]
segs <- ParsecT String () Identity SingularQuerySegment
-> ParsecT String () Identity [SingularQuerySegment]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
P.many ParsecT String () Identity SingularQuerySegment
pSingularQuerySegment
  SingularQuery -> ParsecT String () Identity SingularQuery
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (SingularQuery -> ParsecT String () Identity SingularQuery)
-> SingularQuery -> ParsecT String () Identity SingularQuery
forall a b. (a -> b) -> a -> b
$ SingularQuery { singularQueryType :: SingularQueryType
singularQueryType = SingularQueryType
RootSQ, singularQuerySegments :: [SingularQuerySegment]
singularQuerySegments = [SingularQuerySegment]
segs }

pSingularQuerySegment :: P.Parser SingularQuerySegment
pSingularQuerySegment :: ParsecT String () Identity SingularQuerySegment
pSingularQuerySegment = ParsecT String () Identity SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity SingularQuerySegment
pSingularQNameSeg ParsecT String () Identity SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity SingularQuerySegment
pSingularQIndexSeg

pSingularQNameSeg :: P.Parser SingularQuerySegment
pSingularQNameSeg :: ParsecT String () Identity SingularQuerySegment
pSingularQNameSeg = ParsecT String () Identity SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity SingularQuerySegment
pSingularQNameBracketed ParsecT String () Identity SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity SingularQuerySegment
pSingularQNameDotted
  where
    pSingularQNameBracketed :: ParsecT String () Identity SingularQuerySegment
pSingularQNameBracketed = do
      Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'['
      Text
name <- String -> Text
T.pack (String -> Text)
-> Parser String -> ParsecT String () Identity Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser String -> Parser String
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser String
pSingleQuotted Parser String -> Parser String -> Parser String
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser String -> Parser String
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try Parser String
pDoubleQuotted)
      Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
']'
      SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (SingularQuerySegment
 -> ParsecT String () Identity SingularQuerySegment)
-> SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall a b. (a -> b) -> a -> b
$ Text -> SingularQuerySegment
NameSQSeg Text
name

    pSingularQNameDotted :: ParsecT String () Identity SingularQuerySegment
pSingularQNameDotted = do
      Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'.'
      ParsecT String () Identity Char -> ParsecT String () Identity Char
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
P.lookAhead (ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.letter ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> String -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"_" ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char
pUnicodeChar)
      Text
name <- String -> Text
T.pack (String -> Text)
-> Parser String -> ParsecT String () Identity Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Char -> Parser String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
P.many1 (ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.alphaNum ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> String -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"_" ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char
pUnicodeChar)
      SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (SingularQuerySegment
 -> ParsecT String () Identity SingularQuerySegment)
-> SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall a b. (a -> b) -> a -> b
$ Text -> SingularQuerySegment
NameSQSeg Text
name

pSingularQIndexSeg :: P.Parser SingularQuerySegment
pSingularQIndexSeg :: ParsecT String () Identity SingularQuerySegment
pSingularQIndexSeg = do
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'['
  Int
idx <- ParsecT String () Identity Int
pSignedInt
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
']'
  SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (SingularQuerySegment
 -> ParsecT String () Identity SingularQuerySegment)
-> SingularQuerySegment
-> ParsecT String () Identity SingularQuerySegment
forall a b. (a -> b) -> a -> b
$ Int -> SingularQuerySegment
IndexSQSeg Int
idx

pSignedInt :: P.Parser Int
pSignedInt :: ParsecT String () Identity Int
pSignedInt = do
  ParsecT String () Identity () -> ParsecT String () Identity ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
P.notFollowedBy (String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"-0" Parser String
-> ParsecT String () Identity () -> ParsecT String () Identity ()
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT String () Identity Char -> ParsecT String () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
P.optional ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.digit) -- no leading -011... etc
  ParsecT String () Identity Char -> ParsecT String () Identity ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
P.notFollowedBy (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char   Char
'0' ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.digit) -- no leading 011... etc
  Maybe Char
sign <- ParsecT String () Identity Char
-> ParsecT String () Identity (Maybe Char)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
P.optionMaybe (ParsecT String () Identity Char
 -> ParsecT String () Identity (Maybe Char))
-> ParsecT String () Identity Char
-> ParsecT String () Identity (Maybe Char)
forall a b. (a -> b) -> a -> b
$ Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'-'
  Integer
num <- (String -> Integer
forall a. Read a => String -> a
read (String -> Integer)
-> Parser String -> ParsecT String () Identity Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Char -> Parser String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
P.many1 ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.digit) :: P.Parser Integer
  Integer -> Maybe Char -> ParsecT String () Identity Int
forall {m :: * -> *} {a}.
MonadFail m =>
Integer -> Maybe a -> m Int
checkNumOutOfRange Integer
num Maybe Char
sign
  where
    minInt :: Integer
minInt = -Integer
9007199254740991
    maxInt :: Integer
maxInt = Integer
9007199254740991
    checkNumOutOfRange :: Integer -> Maybe a -> m Int
checkNumOutOfRange Integer
num (Just a
_) =
      if -Integer
num Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
minInt then String -> m Int
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"out of range"
      else Int -> m Int
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> m Int) -> Int -> m Int
forall a b. (a -> b) -> a -> b
$ Integer -> Int
integerToInt (-Integer
num)

    checkNumOutOfRange Integer
num Maybe a
Nothing =
      if Integer
num Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
maxInt then String -> m Int
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"out of range"
      else Int -> m Int
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> m Int) -> Int -> m Int
forall a b. (a -> b) -> a -> b
$ Integer -> Int
integerToInt Integer
num

-- TODO: Fix Double parse error  "1.12e+23"
pScientific :: P.Parser Scientific
pScientific :: ParsecT String () Identity Scientific
pScientific = do
  Int
mantissa <- ParsecT String () Identity Int
pSignedInt
  Maybe Int
expo <- ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
P.optionMaybe (String -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"eE" ParsecT String () Identity Char
-> ParsecT String () Identity Int -> ParsecT String () Identity Int
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT String () Identity Int
pExponent)
  Scientific -> ParsecT String () Identity Scientific
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Scientific -> ParsecT String () Identity Scientific)
-> Scientific -> ParsecT String () Identity Scientific
forall a b. (a -> b) -> a -> b
$ Integer -> Int -> Scientific
scientific (Int -> Integer
integerFromInt Int
mantissa) (Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
0 Maybe Int
expo)

pDoubleScientific :: P.Parser Scientific
pDoubleScientific :: ParsecT String () Identity Scientific
pDoubleScientific = do
  String
whole <- ParsecT String () Identity Char -> Parser String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
P.many1 ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.digit
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'.'
  String
frac <- ParsecT String () Identity Char -> Parser String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
P.many1 ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.digit
  Maybe Int
expo <- ParsecT String () Identity Int
-> ParsecT String () Identity (Maybe Int)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
P.optionMaybe (String -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"eE" ParsecT String () Identity Char
-> ParsecT String () Identity Int -> ParsecT String () Identity Int
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT String () Identity Int
pExponent)
  let num :: Scientific
num = String -> Scientific
forall a. Read a => String -> a
read (String
whole String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"." String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
frac String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> (Int -> String) -> Maybe Int -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
"" (\Int
x -> String
"e" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
x) Maybe Int
expo) :: Scientific
  Scientific -> ParsecT String () Identity Scientific
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Scientific
num

pExponent :: P.Parser Int
pExponent :: ParsecT String () Identity Int
pExponent = do
  Maybe Char
sign <- ParsecT String () Identity Char
-> ParsecT String () Identity (Maybe Char)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
P.optionMaybe (String -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"+-")
  Int
num <- String -> Int
forall a. Read a => String -> a
read (String -> Int) -> Parser String -> ParsecT String () Identity Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Char -> Parser String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
P.many1 ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.digit
  Int -> ParsecT String () Identity Int
forall a. a -> ParsecT String () Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> ParsecT String () Identity Int)
-> Int -> ParsecT String () Identity Int
forall a b. (a -> b) -> a -> b
$ case Maybe Char
sign of
    Just Char
'-' -> -Int
num
    Maybe Char
_        -> Int
num

pUnicodeChar :: P.Parser Char
pUnicodeChar :: ParsecT String () Identity Char
pUnicodeChar = (Char -> Bool) -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
P.satisfy Char -> Bool
inRange
  where
    inRange :: Char -> Bool
inRange Char
c = let code :: Int
code = Char -> Int
ord Char
c in
      (Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0x80 Bool -> Bool -> Bool
&& Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0xD7FF) Bool -> Bool -> Bool
||
      (Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0xE000 Bool -> Bool -> Bool
&& Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x10FFFF)

-- https://www.rfc-editor.org/rfc/rfc9535#name-syntax
pSpaces :: P.Parser [Char]
pSpaces :: Parser String
pSpaces = ParsecT String () Identity Char -> Parser String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
P.many (String -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
" \n\r\t")

pSingleQuotted :: P.Parser String
pSingleQuotted :: Parser String
pSingleQuotted = Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'\'' ParsecT String () Identity Char -> Parser String -> Parser String
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT String () Identity Char -> Parser String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
P.many ParsecT String () Identity Char
inQuote Parser String -> ParsecT String () Identity Char -> Parser String
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'\''
  where
    inQuote :: ParsecT String () Identity Char
inQuote = ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity Char
pUnescaped
           ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'\"')
           ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"\\\'" Parser String -> Char -> ParsecT String () Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\'')
           ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity Char
pEscaped

pDoubleQuotted :: P.Parser String
pDoubleQuotted :: Parser String
pDoubleQuotted = Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'\"' ParsecT String () Identity Char -> Parser String -> Parser String
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT String () Identity Char -> Parser String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
P.many ParsecT String () Identity Char
inQuote Parser String -> ParsecT String () Identity Char -> Parser String
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'\"'
  where
    inQuote :: ParsecT String () Identity Char
inQuote = ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity Char
pUnescaped
           ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'\'')
           ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
P.string String
"\\\"" Parser String -> Char -> ParsecT String () Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\"')
           ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity Char
pEscaped

pUnescaped :: P.Parser Char
pUnescaped :: ParsecT String () Identity Char
pUnescaped = (Char -> Bool) -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
P.satisfy Char -> Bool
inRange
  where
    inRange :: Char -> Bool
inRange Char
c = let code :: Int
code = Char -> Int
ord Char
c in
      (Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0x20 Bool -> Bool -> Bool
&& Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x21) Bool -> Bool -> Bool
||
      (Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0x23 Bool -> Bool -> Bool
&& Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x26) Bool -> Bool -> Bool
||
      (Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0x28 Bool -> Bool -> Bool
&& Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x5B) Bool -> Bool -> Bool
||
      (Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0x5D Bool -> Bool -> Bool
&& Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0xD7FF) Bool -> Bool -> Bool
||
      (Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0xE000 Bool -> Bool -> Bool
&& Int
code Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0x10FFFF)

pEscaped :: P.Parser Char
pEscaped :: ParsecT String () Identity Char
pEscaped = do
  Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'\\'
  ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity Char
forall {u}. ParsecT String u Identity Char
pEscapees ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity Char
pHexUnicode
  where
    pEscapees :: ParsecT String u Identity Char
pEscapees = ParsecT String u Identity Char -> ParsecT String u Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'b' ParsecT String u Identity Char
-> Char -> ParsecT String u Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\b')
            ParsecT String u Identity Char
-> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'f' ParsecT String u Identity Char
-> Char -> ParsecT String u Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\f')
            ParsecT String u Identity Char
-> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'n' ParsecT String u Identity Char
-> Char -> ParsecT String u Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\n')
            ParsecT String u Identity Char
-> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'r' ParsecT String u Identity Char
-> Char -> ParsecT String u Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\r')
            ParsecT String u Identity Char
-> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
't' ParsecT String u Identity Char
-> Char -> ParsecT String u Identity Char
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Char
'\t')
            ParsecT String u Identity Char
-> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'/')
            ParsecT String u Identity Char
-> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try (Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'\\')

pHexUnicode :: P.Parser Char
pHexUnicode :: ParsecT String () Identity Char
pHexUnicode = ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity Char
forall {u}. ParsecT String u Identity Char
pNonSurrogate ParsecT String () Identity Char
-> ParsecT String () Identity Char
-> ParsecT String () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () Identity Char -> ParsecT String () Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String () Identity Char
forall {u}. ParsecT String u Identity Char
pSurrogatePair
  where
    pNonSurrogate :: ParsecT String u Identity Char
pNonSurrogate = ParsecT String u Identity Char -> ParsecT String u Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String u Identity Char
forall {u}. ParsecT String u Identity Char
pNonSurrogateFirst ParsecT String u Identity Char
-> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall tok st a. GenParser tok st a -> GenParser tok st a
P.try ParsecT String u Identity Char
forall {u}. ParsecT String u Identity Char
pNonSurrogateSecond
      where
        pNonSurrogateFirst :: ParsecT String u Identity Char
pNonSurrogateFirst = do
          Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'u'
          Char
c1 <- ParsecT String u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.digit ParsecT String u Identity Char
-> ParsecT String u Identity Char -> ParsecT String u Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> String -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"AaBbCcEeFf"
          Char
c2 <- ParsecT String u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.hexDigit
          Char
c3 <- ParsecT String u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.hexDigit
          Char
c4 <- ParsecT String u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.hexDigit
          Char -> ParsecT String u Identity Char
forall a. a -> ParsecT String u Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> ParsecT String u Identity Char)
-> Char -> ParsecT String u Identity Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr (String -> Int
forall a. Read a => String -> a
read (String
"0x" String -> String -> String
forall a. [a] -> [a] -> [a]
++ [Char
c1,Char
c2,Char
c3,Char
c4]) :: Int)

        pNonSurrogateSecond :: ParsecT String u Identity Char
pNonSurrogateSecond = do
          Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'u'
          Char
c1 <- String -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"Dd"
          Char
c2 <- String -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"01234567"
          Char
c3 <- ParsecT String u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.hexDigit
          Char
c4 <- ParsecT String u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.hexDigit
          Char -> ParsecT String u Identity Char
forall a. a -> ParsecT String u Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> ParsecT String u Identity Char)
-> Char -> ParsecT String u Identity Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr (String -> Int
forall a. Read a => String -> a
read (String
"0x" String -> String -> String
forall a. [a] -> [a] -> [a]
++ [Char
c1,Char
c2,Char
c3,Char
c4]) :: Int)

    pSurrogatePair :: ParsecT String u Identity Char
pSurrogatePair = do
      Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'u'
      Int
high <- ParsecT String u Identity Int
forall {u}. ParsecT String u Identity Int
pHighSurrogate
      Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'\\'
      Char -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'u'
      Int -> Int -> Char
fromHighAndLow Int
high (Int -> Char)
-> ParsecT String u Identity Int -> ParsecT String u Identity Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String u Identity Int
forall {u}. ParsecT String u Identity Int
pLowSurrogate
      where
        pHighSurrogate :: ParsecT String u Identity Int
pHighSurrogate = do
          Char
c1 <- String -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"Dd"
          Char
c2 <- String -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"89AaBb"
          Char
c3 <- ParsecT String u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.hexDigit
          Char
c4 <- ParsecT String u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.hexDigit
          Int -> ParsecT String u Identity Int
forall a. a -> ParsecT String u Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Int
forall a. Read a => String -> a
read (String
"0x" String -> String -> String
forall a. [a] -> [a] -> [a]
++ [Char
c1,Char
c2,Char
c3,Char
c4]) :: Int)

        pLowSurrogate :: ParsecT String u Identity Int
pLowSurrogate = do
          Char
c1 <- String -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"Dd"
          Char
c2 <- String -> ParsecT String u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
P.oneOf String
"CcDdEeFf"
          Char
c3 <- ParsecT String u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.hexDigit
          Char
c4 <- ParsecT String u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.hexDigit
          Int -> ParsecT String u Identity Int
forall a. a -> ParsecT String u Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Int
forall a. Read a => String -> a
read (String
"0x" String -> String -> String
forall a. [a] -> [a] -> [a]
++ [Char
c1,Char
c2,Char
c3,Char
c4]) :: Int)
          
        fromHighAndLow :: Int -> Int -> Char
fromHighAndLow Int
hi Int
lo = Int -> Char
chr (Int -> Char) -> Int -> Char
forall a b. (a -> b) -> a -> b
$ ((Int
hi Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0xD800) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
0x400) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Int
lo Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0xDC00) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0x10000