{-#LANGUAGE TupleSections #-}
{-#LANGUAGE OverloadedStrings #-}
{-#LANGUAGE ScopedTypeVariables #-}
{-#LANGUAGE DeriveGeneric #-}
{-#LANGUAGE FlexibleInstances #-}
{-#LANGUAGE MultiParamTypeClasses #-}
module Text.Ginger.Parse
( parseGinger
, parseGingerFile
, parseGinger'
, parseGingerFile'
, ParserError (..)
, ParserOptions (..)
, mkParserOptions
, Delimiters (..)
, defDelimiters
, formatParserError
, IncludeResolver
, Source, SourceName
, SourcePos (..)
, sourceName
, sourceLine
, sourceColumn
, setSourceName
)
where
import Text.Parsec ( ParseError (..)
, SourcePos (..)
, SourceName (..)
, sourceName
, sourceLine
, sourceColumn
, setSourceName
, ParsecT
, runParserT
, try, lookAhead
, manyTill, oneOf, string, notFollowedBy, between, sepBy
, eof, space, spaces, anyChar, noneOf, char
, choice, option, optionMaybe
, unexpected
, digit
, getState, modifyState, putState
, (<?>)
, getPosition
)
import Text.Parsec.Error ( errorMessages
, errorPos
, showErrorMessages
)
import Text.Ginger.AST
import Text.Ginger.Html ( unsafeRawHtml )
import Text.Ginger.GVal (GVal, ToGVal (..), dict, (~>))
import Control.Monad (when)
import Control.Monad.Reader ( ReaderT
, runReaderT
, ask, asks
)
import Control.Monad.Trans.Class ( lift )
import Control.Applicative
import Control.Exception (Exception)
import GHC.Generics
import Safe ( readMay )
import Data.Text (Text)
import Data.Maybe ( fromMaybe, catMaybes, listToMaybe )
import Data.Scientific ( Scientific )
import qualified Data.Text as Text
import Data.List ( foldr, nub, sort )
import Data.HashMap.Strict (HashMap)
import qualified Data.HashMap.Strict as HashMap
import Data.Default ( Default (..) )
import Data.Monoid ( (<>) )
import Data.Char (isSpace)
import System.FilePath ( takeDirectory, (</>) )
import Text.Printf ( printf )
type Source = String
type IncludeResolver m = SourceName -> m (Maybe Source)
instance ToGVal m SourcePos where
toGVal :: SourcePos -> GVal m
toGVal SourcePos
p =
forall (m :: * -> *). [Pair m] -> GVal m
dict [ VarName
"name" forall (m :: * -> *) a. ToGVal m a => VarName -> a -> Pair m
~> SourcePos -> SourceName
sourceName SourcePos
p
, VarName
"line" forall (m :: * -> *) a. ToGVal m a => VarName -> a -> Pair m
~> SourcePos -> Line
sourceLine SourcePos
p
, VarName
"column" forall (m :: * -> *) a. ToGVal m a => VarName -> a -> Pair m
~> SourcePos -> Line
sourceColumn SourcePos
p
]
data ParserError =
ParserError
{ ParserError -> SourceName
peErrorMessage :: String
, ParserError -> Maybe SourcePos
peSourcePosition :: Maybe SourcePos
}
deriving (Line -> ParserError -> ShowS
[ParserError] -> ShowS
ParserError -> SourceName
forall a.
(Line -> a -> ShowS)
-> (a -> SourceName) -> ([a] -> ShowS) -> Show a
showList :: [ParserError] -> ShowS
$cshowList :: [ParserError] -> ShowS
show :: ParserError -> SourceName
$cshow :: ParserError -> SourceName
showsPrec :: Line -> ParserError -> ShowS
$cshowsPrec :: Line -> ParserError -> ShowS
Show, forall x. Rep ParserError x -> ParserError
forall x. ParserError -> Rep ParserError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ParserError x -> ParserError
$cfrom :: forall x. ParserError -> Rep ParserError x
Generic)
instance Exception ParserError where
formatParserError :: Maybe String
-> ParserError
-> String
formatParserError :: Maybe SourceName -> ParserError -> SourceName
formatParserError Maybe SourceName
tplSrc ParserError
e =
let sourceLocation :: Maybe SourceName
sourceLocation = do
SourcePos
pos <- ParserError -> Maybe SourcePos
peSourcePosition ParserError
e
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall r. PrintfType r => SourceName -> r
printf SourceName
"%s:%i:%i\n"
(SourcePos -> SourceName
sourceName SourcePos
pos)
(SourcePos -> Line
sourceLine SourcePos
pos)
(SourcePos -> Line
sourceColumn SourcePos
pos)
markerLines :: Maybe SourceName
markerLines = do
[SourceName]
sourceLines <- SourceName -> [SourceName]
lines forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe SourceName
tplSrc
SourcePos
pos <- ParserError -> Maybe SourcePos
peSourcePosition ParserError
e
let lineNum :: Line
lineNum = SourcePos -> Line
sourceLine SourcePos
pos
SourceName
offendingLine <- forall a. [a] -> Maybe a
listToMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Line -> [a] -> [a]
drop (forall a. Enum a => a -> a
pred Line
lineNum) forall a b. (a -> b) -> a -> b
$ [SourceName]
sourceLines
let offendingColumn :: Line
offendingColumn = SourcePos -> Line
sourceColumn SourcePos
pos
forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. [SourceName] -> SourceName
unlines forall a b. (a -> b) -> a -> b
$
[ SourceName
offendingLine
, (forall a. Line -> a -> [a]
replicate (forall a. Enum a => a -> a
pred Line
offendingColumn) Char
' ') forall a. Semigroup a => a -> a -> a
<> SourceName
"^"
]
in [SourceName] -> SourceName
unlines forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Maybe a] -> [a]
catMaybes forall a b. (a -> b) -> a -> b
$
[ Maybe SourceName
sourceLocation
, Maybe SourceName
markerLines
, forall a. a -> Maybe a
Just (ParserError -> SourceName
peErrorMessage ParserError
e)
]
fromParsecError :: ParseError -> ParserError
fromParsecError :: ParseError -> ParserError
fromParsecError ParseError
e =
SourceName -> Maybe SourcePos -> ParserError
ParserError
(forall a. (a -> Bool) -> [a] -> [a]
dropWhile (forall a. Eq a => a -> a -> Bool
== Char
'\n') forall b c a. (b -> c) -> (a -> b) -> a -> c
.
SourceName
-> SourceName
-> SourceName
-> SourceName
-> SourceName
-> [Message]
-> SourceName
showErrorMessages
SourceName
"or"
SourceName
"unknown parse error"
SourceName
"expecting"
SourceName
"unexpected"
SourceName
"end of input"
forall a b. (a -> b) -> a -> b
$ ParseError -> [Message]
errorMessages ParseError
e)
(forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ ParseError -> SourcePos
errorPos ParseError
e)
parseGingerFile :: forall m. Monad m
=> IncludeResolver m
-> SourceName
-> m (Either ParserError (Template SourcePos))
parseGingerFile :: forall (m :: * -> *).
Monad m =>
IncludeResolver m
-> SourceName -> m (Either ParserError (Template SourcePos))
parseGingerFile IncludeResolver m
resolver SourceName
sourceName =
forall (m :: * -> *).
Monad m =>
ParserOptions m
-> SourceName -> m (Either ParserError (Template SourcePos))
parseGingerFile' ParserOptions m
opts SourceName
sourceName
where
opts :: ParserOptions m
opts :: ParserOptions m
opts =
(forall (m :: * -> *).
Monad m =>
IncludeResolver m -> ParserOptions m
mkParserOptions IncludeResolver m
resolver)
{ poSourceName :: Maybe SourceName
poSourceName = forall a. a -> Maybe a
Just SourceName
sourceName }
parseGinger :: forall m. Monad m
=> IncludeResolver m
-> Maybe SourceName
-> Source
-> m (Either ParserError (Template SourcePos))
parseGinger :: forall (m :: * -> *).
Monad m =>
IncludeResolver m
-> Maybe SourceName
-> SourceName
-> m (Either ParserError (Template SourcePos))
parseGinger IncludeResolver m
resolver Maybe SourceName
sourceName SourceName
source =
forall (m :: * -> *).
Monad m =>
ParserOptions m
-> SourceName -> m (Either ParserError (Template SourcePos))
parseGinger' ParserOptions m
opts SourceName
source
where
opts :: ParserOptions m
opts :: ParserOptions m
opts =
(forall (m :: * -> *).
Monad m =>
IncludeResolver m -> ParserOptions m
mkParserOptions IncludeResolver m
resolver)
{ poSourceName :: Maybe SourceName
poSourceName = Maybe SourceName
sourceName }
parseGingerFile' :: Monad m => ParserOptions m -> SourceName -> m (Either ParserError (Template SourcePos))
parseGingerFile' :: forall (m :: * -> *).
Monad m =>
ParserOptions m
-> SourceName -> m (Either ParserError (Template SourcePos))
parseGingerFile' ParserOptions m
opts' SourceName
fn = do
let opts :: ParserOptions m
opts = ParserOptions m
opts' { poSourceName :: Maybe SourceName
poSourceName = forall a. a -> Maybe a
Just SourceName
fn }
let resolve :: IncludeResolver m
resolve = forall (m :: * -> *). ParserOptions m -> IncludeResolver m
poIncludeResolver ParserOptions m
opts
Maybe SourceName
srcMay <- IncludeResolver m
resolve SourceName
fn
case Maybe SourceName
srcMay of
Maybe SourceName
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$
ParserError
{ peErrorMessage :: SourceName
peErrorMessage = SourceName
"Template source not found: " forall a. [a] -> [a] -> [a]
++ SourceName
fn
, peSourcePosition :: Maybe SourcePos
peSourcePosition = forall a. Maybe a
Nothing
}
Just SourceName
src -> forall (m :: * -> *).
Monad m =>
ParserOptions m
-> SourceName -> m (Either ParserError (Template SourcePos))
parseGinger' ParserOptions m
opts SourceName
src
parseGinger' :: Monad m => ParserOptions m -> Source -> m (Either ParserError (Template SourcePos))
parseGinger' :: forall (m :: * -> *).
Monad m =>
ParserOptions m
-> SourceName -> m (Either ParserError (Template SourcePos))
parseGinger' ParserOptions m
opts SourceName
src = do
Either ParseError (Template SourcePos)
result <-
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT
( forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> u -> SourceName -> s -> m (Either ParseError a)
runParserT
(forall (m :: * -> *). Monad m => Parser m (Template SourcePos)
templateP forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
`before` forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof)
ParseState
defParseState { psDelimiters :: Delimiters
psDelimiters = forall (m :: * -> *). ParserOptions m -> Delimiters
poDelimiters ParserOptions m
opts }
(forall a. a -> Maybe a -> a
fromMaybe SourceName
"<<unknown>>" forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). ParserOptions m -> Maybe SourceName
poSourceName ParserOptions m
opts)
SourceName
src
)
ParserOptions m
opts
case Either ParseError (Template SourcePos)
result of
Right Template SourcePos
t -> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ Template SourcePos
t
Left ParseError
e -> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ ParseError -> ParserError
fromParsecError ParseError
e
data Delimiters
= Delimiters
{ Delimiters -> SourceName
delimOpenInterpolation :: String
, Delimiters -> SourceName
delimCloseInterpolation :: String
, Delimiters -> SourceName
delimOpenTag :: String
, Delimiters -> SourceName
delimCloseTag :: String
, :: String
, :: String
}
defDelimiters :: Delimiters
defDelimiters :: Delimiters
defDelimiters
= Delimiters
{ delimOpenInterpolation :: SourceName
delimOpenInterpolation = SourceName
"{{"
, delimCloseInterpolation :: SourceName
delimCloseInterpolation = SourceName
"}}"
, delimOpenTag :: SourceName
delimOpenTag = SourceName
"{%"
, delimCloseTag :: SourceName
delimCloseTag = SourceName
"%}"
, delimOpenComment :: SourceName
delimOpenComment = SourceName
"{#"
, delimCloseComment :: SourceName
delimCloseComment = SourceName
"#}"
}
data ParserOptions m
= ParserOptions
{
forall (m :: * -> *). ParserOptions m -> IncludeResolver m
poIncludeResolver :: IncludeResolver m
, forall (m :: * -> *). ParserOptions m -> Maybe SourceName
poSourceName :: Maybe SourceName
, forall (m :: * -> *). ParserOptions m -> Bool
poKeepTrailingNewline :: Bool
, forall (m :: * -> *). ParserOptions m -> Bool
poLStripBlocks :: Bool
, forall (m :: * -> *). ParserOptions m -> Bool
poTrimBlocks :: Bool
, forall (m :: * -> *). ParserOptions m -> Delimiters
poDelimiters :: Delimiters
}
mkParserOptions :: Monad m => IncludeResolver m -> ParserOptions m
mkParserOptions :: forall (m :: * -> *).
Monad m =>
IncludeResolver m -> ParserOptions m
mkParserOptions IncludeResolver m
resolver =
ParserOptions
{ poIncludeResolver :: IncludeResolver m
poIncludeResolver = IncludeResolver m
resolver
, poSourceName :: Maybe SourceName
poSourceName = forall a. Maybe a
Nothing
, poKeepTrailingNewline :: Bool
poKeepTrailingNewline = Bool
False
, poLStripBlocks :: Bool
poLStripBlocks = Bool
False
, poTrimBlocks :: Bool
poTrimBlocks = Bool
False
, poDelimiters :: Delimiters
poDelimiters = Delimiters
defDelimiters
}
data ParseState
= ParseState
{ ParseState -> HashMap VarName (Block SourcePos)
psBlocks :: HashMap VarName (Block SourcePos)
, ParseState -> SourceName
psStripIndent :: String
, ParseState -> Delimiters
psDelimiters :: Delimiters
}
defParseState :: ParseState
defParseState :: ParseState
defParseState =
ParseState
{ psBlocks :: HashMap VarName (Block SourcePos)
psBlocks = forall k v. HashMap k v
HashMap.empty
, psStripIndent :: SourceName
psStripIndent = SourceName
""
, psDelimiters :: Delimiters
psDelimiters = Delimiters
defDelimiters
}
type Parser m a = ParsecT String ParseState (ReaderT (ParserOptions m) m) a
ignore :: Monad m => m a -> m ()
ignore :: forall (m :: * -> *) a. Monad m => m a -> m ()
ignore = (forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ())
ifFlag :: Monad m => (ParserOptions m -> Bool) -> Parser m () -> Parser m () -> Parser m ()
ifFlag :: forall (m :: * -> *).
Monad m =>
(ParserOptions m -> Bool)
-> Parser m () -> Parser m () -> Parser m ()
ifFlag ParserOptions m -> Bool
flag Parser m ()
yes Parser m ()
no = do
Bool
cond <- forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks ParserOptions m -> Bool
flag
if Bool
cond then Parser m ()
yes else Parser m ()
no
whenFlag :: Monad m => (ParserOptions m -> Bool) -> Parser m () -> Parser m ()
whenFlag :: forall (m :: * -> *).
Monad m =>
(ParserOptions m -> Bool) -> Parser m () -> Parser m ()
whenFlag ParserOptions m -> Bool
flag Parser m ()
yes = do
Bool
cond <- forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks ParserOptions m -> Bool
flag
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
cond Parser m ()
yes
unlessFlag :: Monad m => (ParserOptions m -> Bool) -> Parser m () -> Parser m ()
unlessFlag :: forall (m :: * -> *).
Monad m =>
(ParserOptions m -> Bool) -> Parser m () -> Parser m ()
unlessFlag ParserOptions m -> Bool
flag Parser m ()
no = do
Bool
cond <- forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks ParserOptions m -> Bool
flag
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not Bool
cond) Parser m ()
no
getResolver :: Monad m => Parser m (IncludeResolver m)
getResolver :: forall (m :: * -> *). Monad m => Parser m (IncludeResolver m)
getResolver = forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks forall (m :: * -> *). ParserOptions m -> IncludeResolver m
poIncludeResolver
include :: Monad m => SourceName -> Parser m (Statement SourcePos)
include :: forall (m :: * -> *).
Monad m =>
SourceName -> Parser m (Statement SourcePos)
include SourceName
sourceName =
forall a. a -> Template a -> Statement a
PreprocessedIncludeS
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *).
Monad m =>
SourceName -> Parser m (Template SourcePos)
includeTemplate SourceName
sourceName
includeTemplate :: Monad m => SourceName -> Parser m (Template SourcePos)
includeTemplate :: forall (m :: * -> *).
Monad m =>
SourceName -> Parser m (Template SourcePos)
includeTemplate SourceName
sourceName = do
IncludeResolver m
resolver <- forall (m :: * -> *). Monad m => Parser m (IncludeResolver m)
getResolver
SourceName
currentSource <- forall a. a -> Maybe a -> a
fromMaybe SourceName
"" forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks forall (m :: * -> *). ParserOptions m -> Maybe SourceName
poSourceName
let includeSourceName :: SourceName
includeSourceName = ShowS
takeDirectory SourceName
currentSource SourceName -> ShowS
</> SourceName
sourceName
ParserOptions m
opts <- forall r (m :: * -> *). MonadReader r m => m r
ask
Either ParserError (Template SourcePos)
pres <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *).
Monad m =>
ParserOptions m
-> SourceName -> m (Either ParserError (Template SourcePos))
parseGingerFile' ParserOptions m
opts SourceName
includeSourceName
case Either ParserError (Template SourcePos)
pres of
Right Template SourcePos
t -> forall (m :: * -> *) a. Monad m => a -> m a
return Template SourcePos
t
Left ParserError
err -> forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail (forall a. Show a => a -> SourceName
show ParserError
err)
reduceStatements :: SourcePos -> [(Statement SourcePos)] -> (Statement SourcePos)
reduceStatements :: SourcePos -> [Statement SourcePos] -> Statement SourcePos
reduceStatements SourcePos
pos [] = forall a. a -> Statement a
NullS SourcePos
pos
reduceStatements SourcePos
pos [Statement SourcePos
x] = Statement SourcePos
x
reduceStatements SourcePos
pos [Statement SourcePos]
xs = forall a. a -> [Statement a] -> Statement a
MultiS SourcePos
pos [Statement SourcePos]
xs
templateP :: Monad m => Parser m (Template SourcePos)
templateP :: forall (m :: * -> *). Monad m => Parser m (Template SourcePos)
templateP = forall (m :: * -> *). Monad m => Parser m (Template SourcePos)
derivedTemplateP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Template SourcePos)
baseTemplateP
derivedTemplateP :: Monad m => Parser m (Template SourcePos)
derivedTemplateP :: forall (m :: * -> *). Monad m => Parser m (Template SourcePos)
derivedTemplateP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
SourceName
parentName <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"extends" forall (m :: * -> *). Monad m => Parser m SourceName
stringLiteralP)
Template SourcePos
parentTemplate <- forall (m :: * -> *).
Monad m =>
SourceName -> Parser m (Template SourcePos)
includeTemplate SourceName
parentName
HashMap VarName (Block SourcePos)
topLevelBlocks <- forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HashMap.fromList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall (m :: * -> *).
Monad m =>
Parser m (VarName, Block SourcePos)
blockP
HashMap VarName (Block SourcePos)
nestedBlocks <- ParseState -> HashMap VarName (Block SourcePos)
psBlocks forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
let blocks :: HashMap VarName (Block SourcePos)
blocks = HashMap VarName (Block SourcePos)
topLevelBlocks forall a. Semigroup a => a -> a -> a
<> HashMap VarName (Block SourcePos)
nestedBlocks
forall (m :: * -> *) a. Monad m => a -> m a
return
Template
{ templateBody :: Statement SourcePos
templateBody = forall a. a -> Statement a
NullS SourcePos
pos
, templateParent :: Maybe (Template SourcePos)
templateParent = forall a. a -> Maybe a
Just Template SourcePos
parentTemplate
, templateBlocks :: HashMap VarName (Block SourcePos)
templateBlocks = HashMap VarName (Block SourcePos)
blocks
}
baseTemplateP :: Monad m => Parser m (Template SourcePos)
baseTemplateP :: forall (m :: * -> *). Monad m => Parser m (Template SourcePos)
baseTemplateP = do
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
HashMap VarName (Block SourcePos)
blocks <- ParseState -> HashMap VarName (Block SourcePos)
psBlocks forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
forall (m :: * -> *) a. Monad m => a -> m a
return
Template
{ templateBody :: Statement SourcePos
templateBody = Statement SourcePos
body
, templateParent :: Maybe (Template SourcePos)
templateParent = forall a. Maybe a
Nothing
, templateBlocks :: HashMap VarName (Block SourcePos)
templateBlocks = HashMap VarName (Block SourcePos)
blocks
}
isNullS :: Statement a -> Bool
isNullS (NullS a
_) = Bool
True
isNullS Statement a
_ = Bool
False
statementsP :: Monad m => Parser m (Statement SourcePos)
statementsP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
SourcePos -> [Statement SourcePos] -> Statement SourcePos
reduceStatements SourcePos
pos forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a}. Statement a -> Bool
isNullS) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementP)
scriptStatementsP :: Monad m => Parser m (Statement SourcePos)
scriptStatementsP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementsP = do
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
SourcePos -> [Statement SourcePos] -> Statement SourcePos
reduceStatements SourcePos
pos forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a}. Statement a -> Bool
isNullS) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP)
scriptStatementBlockP :: Monad m => Parser m (Statement SourcePos)
scriptStatementBlockP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementBlockP = do
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'{'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Statement SourcePos
inner <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementsP
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'}'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return Statement SourcePos
inner
statementP :: Monad m => Parser m (Statement SourcePos)
statementP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementP = forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
interpolationStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
commentStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
tryCatchStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
ifStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
switchStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
setStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
forStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
includeP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
macroStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
blockStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
callStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scopeStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
indentStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
literalStmtP
scriptStatementP :: Monad m => Parser m (Statement SourcePos)
scriptStatementP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP = forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementBlockP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptEchoStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptIfStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptSwitchStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptSetStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptForStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptIncludeP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptMacroStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptScopeStmtP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptExprStmtP
interpolationStmtP :: Monad m => Parser m (Statement SourcePos)
interpolationStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
interpolationStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *). Monad m => Parser m ()
openInterpolationP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
expr <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *). Monad m => Parser m ()
closeInterpolationP
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Expression a -> Statement a
InterpolationS SourcePos
pos Expression SourcePos
expr
scriptEchoStmtP :: Monad m => Parser m (Statement SourcePos)
scriptEchoStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptEchoStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"echo"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'('
Expression SourcePos
expr <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
')'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
';'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Expression a -> Statement a
InterpolationS SourcePos
pos Expression SourcePos
expr
literalStmtP :: Monad m => Parser m (Statement SourcePos)
literalStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
literalStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
SourceName
txt <- forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
manyTill forall (m :: * -> *). Monad m => Parser m SourceName
literalCharsP forall (m :: * -> *). Monad m => Parser m ()
endOfLiteralP
case SourceName
txt of
[] -> forall s (m :: * -> *) t u a.
Stream s m t =>
SourceName -> ParsecT s u m a
unexpected SourceName
"{{"
SourceName
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Html -> Statement a
LiteralS SourcePos
pos forall b c a. (b -> c) -> (a -> b) -> a -> c
. VarName -> Html
unsafeRawHtml forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceName -> VarName
Text.pack forall a b. (a -> b) -> a -> b
$ SourceName
txt
literalCharsP :: Monad m => Parser m [Char]
literalCharsP :: forall (m :: * -> *). Monad m => Parser m SourceName
literalCharsP = do
Delimiters
dlims <- ParseState -> Delimiters
psDelimiters forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
let forbiddenChars :: SourceName
forbiddenChars =
forall a. Eq a => [a] -> [a]
nub forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => [a] -> [a]
sort forall a b. (a -> b) -> a -> b
$
SourceName
" \t\r\n" forall a. [a] -> [a] -> [a]
++
Delimiters -> SourceName
delimOpenInterpolation Delimiters
dlims forall a. [a] -> [a] -> [a]
++
Delimiters -> SourceName
delimOpenComment Delimiters
dlims forall a. [a] -> [a] -> [a]
++
Delimiters -> SourceName
delimOpenTag Delimiters
dlims
(forall (f :: * -> *) a. Alternative f => f a -> f [a]
some forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
noneOf SourceName
forbiddenChars) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
(forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. a -> [a] -> [a]
:[]) forall (m :: * -> *). Monad m => Parser m Char
literalNewlineP) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
space forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
(forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. a -> [a] -> [a]
:[]) forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar)
literalNewlineP :: Monad m => Parser m Char
literalNewlineP :: forall (m :: * -> *). Monad m => Parser m Char
literalNewlineP = do
SourceName
stripStr <- ParseState -> SourceName
psStripIndent forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'\n'
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Bool
null SourceName
stripStr) (forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
stripStr)
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\n'
endOfLiteralP :: Monad m => Parser m ()
endOfLiteralP :: forall (m :: * -> *). Monad m => Parser m ()
endOfLiteralP =
(forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => Parser m ()
openInterpolationP) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
(forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => Parser m ()
openTagP) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
(forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => Parser m ()
openCommentP) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof
commentStmtP :: Monad m => Parser m (Statement SourcePos)
= do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *). Monad m => Parser m ()
openCommentP
forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
manyTill
( (forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
noneOf SourceName
"#" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. Monad m => a -> m a
return ())
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'#' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'}'))
)
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *). Monad m => Parser m ()
closeCommentP)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Statement a
NullS SourcePos
pos
scriptCommentP :: Monad m => Parser m ()
= do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'#' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'}')
forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
manyTill forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar forall (m :: * -> *). Monad m => Parser m Char
endl
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
spacesOrComment :: Monad m => Parser m ()
= do
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => Parser m ()
scriptCommentP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf SourceName
" \t\r\n" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. Monad m => a -> m a
return ())
forall (m :: * -> *) a. Monad m => a -> m a
return ()
scriptExprStmtP :: Monad m => Parser m (Statement SourcePos)
scriptExprStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptExprStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
Expression SourcePos
expr <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
';'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Expression a -> Statement a
ExpressionS SourcePos
pos Expression SourcePos
expr
endl :: Monad m => Parser m Char
endl :: forall (m :: * -> *). Monad m => Parser m Char
endl = forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'\n' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'\r' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'\n')
scriptStmtP :: Monad m => Parser m (Statement SourcePos)
scriptStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStmtP =
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
between
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"script")
(forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"endscript")
forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementsP
ifStmtP :: Monad m => Parser m (Statement SourcePos)
ifStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
ifStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
Expression SourcePos
condExpr <- forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"if" forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
Statement SourcePos
trueStmt <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
Statement SourcePos
falseStmt <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
elifBranchP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
elseBranchP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> Statement a
NullS forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition)
forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"endif"
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
a -> Expression a -> Statement a -> Statement a -> Statement a
IfS SourcePos
pos Expression SourcePos
condExpr Statement SourcePos
trueStmt Statement SourcePos
falseStmt
elseBranchP :: Monad m => Parser m (Statement SourcePos)
elseBranchP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
elseBranchP = do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"else"
forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
elifBranchP :: Monad m => Parser m (Statement SourcePos)
elifBranchP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
elifBranchP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
Expression SourcePos
condExpr <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"elif" forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
Statement SourcePos
trueStmt <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
Statement SourcePos
falseStmt <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
elifBranchP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
elseBranchP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> Statement a
NullS forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
a -> Expression a -> Statement a -> Statement a -> Statement a
IfS SourcePos
pos Expression SourcePos
condExpr Statement SourcePos
trueStmt Statement SourcePos
falseStmt
scriptIfStmtP :: Monad m => Parser m (Statement SourcePos)
scriptIfStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptIfStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"if"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'('
Expression SourcePos
condExpr <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
')'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Statement SourcePos
trueStmt <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Statement SourcePos
falseStmt <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptElifP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptElseP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> Statement a
NullS forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
a -> Expression a -> Statement a -> Statement a -> Statement a
IfS SourcePos
pos Expression SourcePos
condExpr Statement SourcePos
trueStmt Statement SourcePos
falseStmt
scriptElseP :: Monad m => Parser m (Statement SourcePos)
scriptElseP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptElseP = do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"else"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP
scriptElifP :: Monad m => Parser m (Statement SourcePos)
scriptElifP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptElifP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"elif"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'('
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
condExpr <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
')'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Statement SourcePos
trueStmt <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Statement SourcePos
falseStmt <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptElifP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptElseP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> Statement a
NullS forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
a -> Expression a -> Statement a -> Statement a -> Statement a
IfS SourcePos
pos Expression SourcePos
condExpr Statement SourcePos
trueStmt Statement SourcePos
falseStmt
tryCatchStmtP :: Monad m => Parser m (Statement SourcePos)
tryCatchStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
tryCatchStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"try"
Statement SourcePos
tryS <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
[CatchBlock SourcePos]
catchesS <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall (m :: * -> *). Monad m => Parser m (CatchBlock SourcePos)
catchBranchP
Statement SourcePos
finallyS <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
finallyBranchP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> Statement a
NullS forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition)
forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"endtry"
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
a -> Statement a -> [CatchBlock a] -> Statement a -> Statement a
TryCatchS SourcePos
pos Statement SourcePos
tryS [CatchBlock SourcePos]
catchesS Statement SourcePos
finallyS
catchBranchP :: Monad m => Parser m (CatchBlock SourcePos)
catchBranchP :: forall (m :: * -> *). Monad m => Parser m (CatchBlock SourcePos)
catchBranchP = do
(Maybe VarName
what, Maybe VarName
captureName) <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$
forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"catch" (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *).
Monad m =>
Parser m (Maybe VarName, Maybe VarName)
catchHeaderP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. Maybe a
Nothing, forall a. Maybe a
Nothing))
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
Maybe VarName -> Maybe VarName -> Statement a -> CatchBlock a
Catch Maybe VarName
what Maybe VarName
captureName Statement SourcePos
body
suchThat :: Monad m => (a -> Bool) -> Parser m a -> Parser m a
suchThat :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Parser m a -> Parser m a
suchThat a -> Bool
p Parser m a
action = do
a
val <- Parser m a
action
if a -> Bool
p a
val then forall (m :: * -> *) a. Monad m => a -> m a
return a
val else forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail SourceName
"Requirement not met"
catchHeaderP :: Monad m => Parser m (Maybe Text, Maybe VarName)
= do
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
Maybe VarName
what <- forall (m :: * -> *). Monad m => Parser m (Maybe VarName)
catchWhatP
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
Maybe VarName
captureName <- forall (m :: * -> *). Monad m => Parser m (Maybe VarName)
catchCaptureP
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (Maybe VarName
what, Maybe VarName
captureName)
catchWhatP :: Monad m => Parser m (Maybe Text)
catchWhatP :: forall (m :: * -> *). Monad m => Parser m (Maybe VarName)
catchWhatP =
(forall a. Maybe a
Nothing forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'*') forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
(forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceName -> VarName
Text.pack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *). Monad m => Parser m SourceName
stringLiteralP) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
(forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *). Monad m => Parser m VarName
identifierP)
catchCaptureP :: Monad m => Parser m (Maybe VarName)
catchCaptureP :: forall (m :: * -> *). Monad m => Parser m (Maybe VarName)
catchCaptureP = forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe forall a b. (a -> b) -> a -> b
$ do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"as" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy forall (m :: * -> *). Monad m => Parser m Char
identCharP)
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
forall (m :: * -> *). Monad m => Parser m VarName
identifierP
finallyBranchP :: Monad m => Parser m (Statement SourcePos)
finallyBranchP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
finallyBranchP = do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"finally"
forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
switchStmtP :: Monad m => Parser m (Statement SourcePos)
switchStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
switchStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
Expression SourcePos
pivotExpr <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"switch" forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
[(Expression SourcePos, Statement SourcePos)]
cases <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, Statement SourcePos)
switchCaseP
Statement SourcePos
def <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
switchDefaultP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> Statement a
NullS forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition)
forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"endswitch"
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
a
-> Expression a
-> [(Expression a, Statement a)]
-> Statement a
-> Statement a
SwitchS SourcePos
pos Expression SourcePos
pivotExpr [(Expression SourcePos, Statement SourcePos)]
cases Statement SourcePos
def
switchCaseP :: Monad m => Parser m ((Expression SourcePos), (Statement SourcePos))
switchCaseP :: forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, Statement SourcePos)
switchCaseP = do
Expression SourcePos
cmpExpr <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"case" forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"endcase"
forall (m :: * -> *) a. Monad m => a -> m a
return (Expression SourcePos
cmpExpr, Statement SourcePos
body)
switchDefaultP :: Monad m => Parser m (Statement SourcePos)
switchDefaultP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
switchDefaultP = do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"default") forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"enddefault"
scriptSwitchStmtP :: Monad m => Parser m (Statement SourcePos)
scriptSwitchStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptSwitchStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"switch"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'('
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
pivotExpr <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
')'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'{'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
[(Expression SourcePos, Statement SourcePos)]
cases <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, Statement SourcePos)
scriptSwitchCaseP
Statement SourcePos
def <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptSwitchDefaultP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> Statement a
NullS forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition)
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'}'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
a
-> Expression a
-> [(Expression a, Statement a)]
-> Statement a
-> Statement a
SwitchS SourcePos
pos Expression SourcePos
pivotExpr [(Expression SourcePos, Statement SourcePos)]
cases Statement SourcePos
def
scriptSwitchCaseP :: Monad m => Parser m ((Expression SourcePos), (Statement SourcePos))
scriptSwitchCaseP :: forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, Statement SourcePos)
scriptSwitchCaseP = do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"case"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
cmpExpr <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
':'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return (Expression SourcePos
cmpExpr, Statement SourcePos
body)
scriptSwitchDefaultP :: Monad m => Parser m (Statement SourcePos)
scriptSwitchDefaultP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptSwitchDefaultP = do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"default"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
':'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return Statement SourcePos
body
setStmtP :: Monad m => Parser m (Statement SourcePos)
setStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
setStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"set" (forall (m :: * -> *).
Monad m =>
SourcePos -> Parser m (Statement SourcePos)
setStmtInnerP SourcePos
pos)
setStmtInnerP :: Monad m => SourcePos -> Parser m (Statement SourcePos)
setStmtInnerP :: forall (m :: * -> *).
Monad m =>
SourcePos -> Parser m (Statement SourcePos)
setStmtInnerP SourcePos
pos = do
VarName
name <- forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'='
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
val <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> VarName -> Expression a -> Statement a
SetVarS SourcePos
pos VarName
name Expression SourcePos
val
scriptSetStmtP :: Monad m => Parser m (Statement SourcePos)
scriptSetStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptSetStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"set"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
VarName
name <- forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'='
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
val <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
';'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> VarName -> Expression a -> Statement a
SetVarS SourcePos
pos VarName
name Expression SourcePos
val
defineBlock :: VarName -> Block SourcePos -> ParseState -> ParseState
defineBlock :: VarName -> Block SourcePos -> ParseState -> ParseState
defineBlock VarName
name Block SourcePos
block ParseState
s =
ParseState
s { psBlocks :: HashMap VarName (Block SourcePos)
psBlocks = forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
HashMap.insert VarName
name Block SourcePos
block (ParseState -> HashMap VarName (Block SourcePos)
psBlocks ParseState
s) }
blockStmtP :: Monad m => Parser m (Statement SourcePos)
blockStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
blockStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
(VarName
name, Block SourcePos
block) <- forall (m :: * -> *).
Monad m =>
Parser m (VarName, Block SourcePos)
blockP
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
modifyState (VarName -> Block SourcePos -> ParseState -> ParseState
defineBlock VarName
name Block SourcePos
block)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> VarName -> Statement a
BlockRefS SourcePos
pos VarName
name
blockP :: Monad m => Parser m (VarName, (Block SourcePos))
blockP :: forall (m :: * -> *).
Monad m =>
Parser m (VarName, Block SourcePos)
blockP = do
VarName
name <- forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"block" forall (m :: * -> *). Monad m => Parser m VarName
identifierP
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"endblock" (forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string (VarName -> SourceName
Text.unpack VarName
name) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment)
forall (m :: * -> *) a. Monad m => a -> m a
return (VarName
name, forall a. Statement a -> Block a
Block Statement SourcePos
body)
macroStmtP :: Monad m => Parser m (Statement SourcePos)
macroStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
macroStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
(VarName
name, [VarName]
args) <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"macro" forall (m :: * -> *). Monad m => Parser m (VarName, [VarName])
macroHeadP
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"endmacro" (forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string (VarName -> SourceName
Text.unpack VarName
name) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> VarName -> Macro a -> Statement a
DefMacroS SourcePos
pos VarName
name (forall a. [VarName] -> Statement a -> Macro a
Macro [VarName]
args Statement SourcePos
body)
scriptMacroStmtP :: Monad m => Parser m (Statement SourcePos)
scriptMacroStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptMacroStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"macro"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
VarName
name <- forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
[VarName]
args <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m [a]
groupP SourceName
"(" SourceName
")" forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> VarName -> Macro a -> Statement a
DefMacroS SourcePos
pos VarName
name (forall a. [VarName] -> Statement a -> Macro a
Macro [VarName]
args Statement SourcePos
body)
macroHeadP :: Monad m => Parser m (VarName, [VarName])
macroHeadP :: forall (m :: * -> *). Monad m => Parser m (VarName, [VarName])
macroHeadP = do
VarName
name <- forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
[VarName]
args <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m [a]
groupP SourceName
"(" SourceName
")" forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return (VarName
name, [VarName]
args)
callStmtP :: Monad m => Parser m (Statement SourcePos)
callStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
callStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
([VarName]
callerArgs, Expression SourcePos
call) <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"call" forall (m :: * -> *).
Monad m =>
Parser m ([VarName], Expression SourcePos)
callHeadP
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"endcall"
forall (m :: * -> *) a. Monad m => a -> m a
return (
forall a. a -> Statement a -> Statement a
ScopedS SourcePos
pos (
forall a. a -> [Statement a] -> Statement a
MultiS SourcePos
pos
[ forall a. a -> VarName -> Macro a -> Statement a
DefMacroS SourcePos
pos VarName
"caller" (forall a. [VarName] -> Statement a -> Macro a
Macro [VarName]
callerArgs Statement SourcePos
body)
, forall a. a -> Expression a -> Statement a
InterpolationS SourcePos
pos Expression SourcePos
call
]))
callHeadP :: Monad m => Parser m ([Text], (Expression SourcePos))
callHeadP :: forall (m :: * -> *).
Monad m =>
Parser m ([VarName], Expression SourcePos)
callHeadP = do
[VarName]
callerArgs <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m [a]
groupP SourceName
"(" SourceName
")" forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
call <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return ([VarName]
callerArgs, Expression SourcePos
call)
scopeStmtP :: Monad m => Parser m (Statement SourcePos)
scopeStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scopeStmtP =
forall a. a -> Statement a -> Statement a
ScopedS
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> 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
between
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"scope")
(forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"endscope")
forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
indentStmtP :: Monad m => Parser m (Statement SourcePos)
indentStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
indentStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
Expression SourcePos
indentExpr <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"indent" forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
indentHeadP
SourceName
preIndent <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf SourceName
" \t")
ParseState
oldState <- forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
modifyState forall a b. (a -> b) -> a -> b
$ \ParseState
state ->
ParseState
state { psStripIndent :: SourceName
psStripIndent = SourceName
preIndent }
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
forall (m :: * -> *) u s. Monad m => u -> ParsecT s u m ()
putState ParseState
oldState
forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"endindent"
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Expression a -> Statement a -> Statement a
IndentS SourcePos
pos Expression SourcePos
indentExpr Statement SourcePos
body
indentHeadP :: Monad m => Parser m (Expression SourcePos)
indentHeadP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
indentHeadP =
(forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> VarName -> Expression a
StringLiteralE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure VarName
" ")) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
scriptScopeStmtP :: Monad m => Parser m (Statement SourcePos)
scriptScopeStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptScopeStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"scope"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall a. a -> Statement a -> Statement a
ScopedS SourcePos
pos forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP
forStmtP :: Monad m => Parser m (Statement SourcePos)
forStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
forStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
(Expression SourcePos
iteree, VarName
varNameVal, Maybe VarName
varNameIndex) <- forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"for" forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, VarName, Maybe VarName)
forHeadP
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
Maybe (Statement SourcePos)
elseBranchMay <- forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe forall a b. (a -> b) -> a -> b
$ do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"else"
forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
statementsP
forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
"endfor"
let forLoop :: Statement SourcePos
forLoop = forall a.
a
-> Maybe VarName
-> VarName
-> Expression a
-> Statement a
-> Statement a
ForS SourcePos
pos Maybe VarName
varNameIndex VarName
varNameVal Expression SourcePos
iteree Statement SourcePos
body
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall b a. b -> (a -> b) -> Maybe a -> b
maybe
Statement SourcePos
forLoop
(forall a.
a -> Expression a -> Statement a -> Statement a -> Statement a
IfS SourcePos
pos Expression SourcePos
iteree Statement SourcePos
forLoop)
Maybe (Statement SourcePos)
elseBranchMay
scriptForStmtP :: Monad m => Parser m (Statement SourcePos)
scriptForStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptForStmtP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"for"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'('
(Expression SourcePos
iteree, VarName
varNameVal, Maybe VarName
varNameIndex) <- forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, VarName, Maybe VarName)
forHeadP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
')'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Statement SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP
Maybe (Statement SourcePos)
elseBranchMay <- forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe forall a b. (a -> b) -> a -> b
$ do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"else"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP
let forLoop :: Statement SourcePos
forLoop = forall a.
a
-> Maybe VarName
-> VarName
-> Expression a
-> Statement a
-> Statement a
ForS SourcePos
pos Maybe VarName
varNameIndex VarName
varNameVal Expression SourcePos
iteree Statement SourcePos
body
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall b a. b -> (a -> b) -> Maybe a -> b
maybe
Statement SourcePos
forLoop
(forall a.
a -> Expression a -> Statement a -> Statement a -> Statement a
IfS SourcePos
pos Expression SourcePos
iteree Statement SourcePos
forLoop)
Maybe (Statement SourcePos)
elseBranchMay
includeP :: Monad m => Parser m (Statement SourcePos)
includeP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
includeP = do
SourceName
sourceName <- forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
"include" forall (m :: * -> *). Monad m => Parser m SourceName
stringLiteralP
forall (m :: * -> *).
Monad m =>
SourceName -> Parser m (Statement SourcePos)
include SourceName
sourceName
scriptIncludeP :: Monad m => Parser m (Statement SourcePos)
scriptIncludeP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptIncludeP = do
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"include"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'('
SourceName
sourceName <- forall (m :: * -> *). Monad m => Parser m SourceName
stringLiteralP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
')'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
';'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *).
Monad m =>
SourceName -> Parser m (Statement SourcePos)
include SourceName
sourceName
forHeadP :: Monad m => Parser m ((Expression SourcePos), VarName, Maybe VarName)
forHeadP :: forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, VarName, Maybe VarName)
forHeadP =
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, VarName, Maybe VarName)
forHeadInP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, VarName, Maybe VarName)
forHeadAsP) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"recursive" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment)
forIteratorP :: Monad m => Parser m (VarName, Maybe VarName)
forIteratorP :: forall (m :: * -> *). Monad m => Parser m (VarName, Maybe VarName)
forIteratorP = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *). Monad m => Parser m (VarName, Maybe VarName)
forIndexedIteratorP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *). Monad m => Parser m (VarName, Maybe VarName)
forSimpleIteratorP forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> SourceName
"iteration variables"
forIndexedIteratorP :: Monad m => Parser m (VarName, Maybe VarName)
forIndexedIteratorP :: forall (m :: * -> *). Monad m => Parser m (VarName, Maybe VarName)
forIndexedIteratorP = do
VarName
indexIdent <- forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
','
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
VarName
varIdent <- forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return (VarName
varIdent, forall a. a -> Maybe a
Just VarName
indexIdent)
forSimpleIteratorP :: Monad m => Parser m (VarName, Maybe VarName)
forSimpleIteratorP :: forall (m :: * -> *). Monad m => Parser m (VarName, Maybe VarName)
forSimpleIteratorP = do
VarName
varIdent <- forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return (VarName
varIdent, forall a. Maybe a
Nothing)
forHeadInP :: Monad m => Parser m ((Expression SourcePos), VarName, Maybe VarName)
forHeadInP :: forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, VarName, Maybe VarName)
forHeadInP = do
(VarName
varIdent, Maybe VarName
indexIdent) <- forall (m :: * -> *). Monad m => Parser m (VarName, Maybe VarName)
forIteratorP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"in"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
iteree <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *) a. Monad m => a -> m a
return (Expression SourcePos
iteree, VarName
varIdent, Maybe VarName
indexIdent)
forHeadAsP :: Monad m => Parser m ((Expression SourcePos), VarName, Maybe VarName)
forHeadAsP :: forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, VarName, Maybe VarName)
forHeadAsP = do
Expression SourcePos
iteree <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"as"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
(VarName
varIdent, Maybe VarName
indexIdent) <- forall (m :: * -> *). Monad m => Parser m (VarName, Maybe VarName)
forIteratorP
forall (m :: * -> *) a. Monad m => a -> m a
return (Expression SourcePos
iteree, VarName
varIdent, Maybe VarName
indexIdent)
fancyTagP :: Monad m => String -> Parser m a -> Parser m a
fancyTagP :: forall (m :: * -> *) a.
Monad m =>
SourceName -> Parser m a -> Parser m a
fancyTagP SourceName
tagName =
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
between
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *). Monad m => Parser m ()
openTagP
forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
tagName
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment)
forall (m :: * -> *). Monad m => Parser m ()
closeTagP
simpleTagP :: Monad m => String -> Parser m ()
simpleTagP :: forall (m :: * -> *). Monad m => SourceName -> Parser m ()
simpleTagP SourceName
tagName = forall (m :: * -> *). Monad m => Parser m ()
openTagP forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
tagName forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => Parser m ()
closeTagP
openInterpolationP :: Monad m => Parser m ()
openInterpolationP :: forall (m :: * -> *). Monad m => Parser m ()
openInterpolationP =
Delimiters -> SourceName
delimOpenInterpolation forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseState -> Delimiters
psDelimiters forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). Monad m => SourceName -> Parser m ()
openP
closeInterpolationP :: Monad m => Parser m ()
closeInterpolationP :: forall (m :: * -> *). Monad m => Parser m ()
closeInterpolationP =
Delimiters -> SourceName
delimCloseInterpolation forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseState -> Delimiters
psDelimiters forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). Monad m => SourceName -> Parser m ()
closeP
openCommentP :: Monad m => Parser m ()
=
Delimiters -> SourceName
delimOpenComment forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseState -> Delimiters
psDelimiters forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). Monad m => SourceName -> Parser m ()
openP
closeCommentP :: Monad m => Parser m ()
=
Delimiters -> SourceName
delimCloseComment forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseState -> Delimiters
psDelimiters forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). Monad m => SourceName -> Parser m ()
closeP
openTagP :: Monad m => Parser m ()
openTagP :: forall (m :: * -> *). Monad m => Parser m ()
openTagP =
Delimiters -> SourceName
delimOpenTag forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseState -> Delimiters
psDelimiters forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). Monad m => SourceName -> Parser m ()
openP
closeTagP :: Monad m => Parser m ()
closeTagP :: forall (m :: * -> *). Monad m => Parser m ()
closeTagP = do
Delimiters -> SourceName
delimCloseTag forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseState -> Delimiters
psDelimiters forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). Monad m => SourceName -> Parser m ()
closeP
forall (m :: * -> *).
Monad m =>
(ParserOptions m -> Bool) -> Parser m () -> Parser m ()
unlessFlag forall (m :: * -> *). ParserOptions m -> Bool
poKeepTrailingNewline
(forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => Parser m Char
literalNewlineP)
openP :: Monad m => String -> Parser m ()
openP :: forall (m :: * -> *). Monad m => SourceName -> Parser m ()
openP SourceName
c = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall (m :: * -> *). Monad m => SourceName -> Parser m ()
openWP SourceName
c)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall (m :: * -> *). Monad m => SourceName -> Parser m ()
openFWP SourceName
c)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall (m :: * -> *). Monad m => SourceName -> Parser m ()
openNWP SourceName
c)
openWP :: Monad m => String -> Parser m ()
openWP :: forall (m :: * -> *). Monad m => SourceName -> Parser m ()
openWP SourceName
c = forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall a b. (a -> b) -> a -> b
$ do
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string forall a b. (a -> b) -> a -> b
$ SourceName
c forall a. [a] -> [a] -> [a]
++ SourceName
"-"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
openFWP :: Monad m => String -> Parser m ()
openFWP :: forall (m :: * -> *). Monad m => SourceName -> Parser m ()
openFWP SourceName
c = forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall a b. (a -> b) -> a -> b
$ do
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string forall a b. (a -> b) -> a -> b
$ SourceName
c forall a. [a] -> [a] -> [a]
++ SourceName
"+"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
openNWP :: Monad m => String -> Parser m ()
openNWP :: forall (m :: * -> *). Monad m => SourceName -> Parser m ()
openNWP SourceName
c = forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *).
Monad m =>
(ParserOptions m -> Bool) -> Parser m () -> Parser m ()
whenFlag forall (m :: * -> *). ParserOptions m -> Bool
poLStripBlocks forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
c
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf SourceName
"+-"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
closeP :: Monad m => String -> Parser m ()
closeP :: forall (m :: * -> *). Monad m => SourceName -> Parser m ()
closeP SourceName
c = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall (m :: * -> *). Monad m => SourceName -> Parser m ()
closeWP SourceName
c)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall (m :: * -> *). Monad m => SourceName -> Parser m ()
closeFWP SourceName
c)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall (m :: * -> *). Monad m => SourceName -> Parser m ()
closeNWP SourceName
c)
closeWP :: Monad m => String -> Parser m ()
closeWP :: forall (m :: * -> *). Monad m => SourceName -> Parser m ()
closeWP SourceName
c = forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string forall a b. (a -> b) -> a -> b
$ Char
'-'forall a. a -> [a] -> [a]
:SourceName
c
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
closeFWP :: Monad m => String -> Parser m ()
closeFWP :: forall (m :: * -> *). Monad m => SourceName -> Parser m ()
closeFWP SourceName
c = forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string forall a b. (a -> b) -> a -> b
$ Char
'+'forall a. a -> [a] -> [a]
:SourceName
c
closeNWP :: Monad m => String -> Parser m ()
closeNWP :: forall (m :: * -> *). Monad m => SourceName -> Parser m ()
closeNWP SourceName
c = forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
c
forall (m :: * -> *).
Monad m =>
(ParserOptions m -> Bool) -> Parser m () -> Parser m ()
whenFlag forall (m :: * -> *). ParserOptions m -> Bool
poTrimBlocks forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
expressionP :: Monad m => Parser m (Expression SourcePos)
expressionP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP = forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
lambdaExprP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
ternaryExprP
lambdaExprP :: Monad m => Parser m (Expression SourcePos)
lambdaExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
lambdaExprP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
[VarName]
argNames <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'('
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
[VarName]
argNames <- forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
sepBy (forall (m :: * -> *). Monad m => Parser m ()
spacesOrCommentforall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => Parser m VarName
identifierP) (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => Parser m ()
spacesOrCommentforall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
',')
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
')'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"->"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return [VarName]
argNames
Expression SourcePos
body <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> [VarName] -> Expression a -> Expression a
LambdaE SourcePos
pos [VarName]
argNames Expression SourcePos
body
operativeExprP :: forall m. Monad m => Parser m (Expression SourcePos) -> [ (String, Text) ] -> Parser m (Expression SourcePos)
operativeExprP :: forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos)
-> [(SourceName, VarName)] -> Parser m (Expression SourcePos)
operativeExprP Parser m (Expression SourcePos)
operandP [(SourceName, VarName)]
operators = do
SourcePos
pos0 <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
Expression SourcePos
lhs <- Parser m (Expression SourcePos)
operandP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
[Expression SourcePos -> Expression SourcePos]
tails <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ SourcePos
-> Parser m (Expression SourcePos -> Expression SourcePos)
operativeTail SourcePos
pos0
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. (a -> b) -> a -> b
($)) Expression SourcePos
lhs [Expression SourcePos -> Expression SourcePos]
tails
where
opChars :: [Char]
opChars :: SourceName
opChars = forall a. Eq a => [a] -> [a]
nub forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => [a] -> [a]
sort forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ [(SourceName, VarName)]
operators
operativeTail :: SourcePos -> Parser m (Expression SourcePos -> Expression SourcePos)
operativeTail :: SourcePos
-> Parser m (Expression SourcePos -> Expression SourcePos)
operativeTail SourcePos
pos0 = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
VarName
funcName <-
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
(<|>) (forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail SourceName
"operator")
[ forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
op forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf SourceName
opChars)) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return VarName
fn | (SourceName
op, VarName
fn) <- [(SourceName, VarName)]
operators ]
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
rhs <- Parser m (Expression SourcePos)
operandP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return (\Expression SourcePos
lhs -> forall a.
a
-> Expression a -> [(Maybe VarName, Expression a)] -> Expression a
CallE SourcePos
pos0 (forall a. a -> VarName -> Expression a
VarE SourcePos
pos VarName
funcName) [(forall a. Maybe a
Nothing, Expression SourcePos
lhs), (forall a. Maybe a
Nothing, Expression SourcePos
rhs)])
ternaryExprP :: Monad m => Parser m (Expression SourcePos)
ternaryExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
ternaryExprP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
Expression SourcePos
expr1 <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
booleanExprP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *).
Monad m =>
SourcePos
-> Expression SourcePos -> Parser m (Expression SourcePos)
cTernaryTailP SourcePos
pos Expression SourcePos
expr1 forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *).
Monad m =>
SourcePos
-> Expression SourcePos -> Parser m (Expression SourcePos)
pyTernaryTailP SourcePos
pos Expression SourcePos
expr1 forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *) a. Monad m => a -> m a
return Expression SourcePos
expr1
cTernaryTailP :: Monad m => SourcePos -> (Expression SourcePos) -> Parser m (Expression SourcePos)
cTernaryTailP :: forall (m :: * -> *).
Monad m =>
SourcePos
-> Expression SourcePos -> Parser m (Expression SourcePos)
cTernaryTailP SourcePos
pos Expression SourcePos
condition = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'?'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
yesBranch <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
':'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
noBranch <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
a -> Expression a -> Expression a -> Expression a -> Expression a
TernaryE SourcePos
pos Expression SourcePos
condition Expression SourcePos
yesBranch Expression SourcePos
noBranch
pyTernaryTailP :: Monad m => SourcePos -> (Expression SourcePos) -> Parser m (Expression SourcePos)
pyTernaryTailP :: forall (m :: * -> *).
Monad m =>
SourcePos
-> Expression SourcePos -> Parser m (Expression SourcePos)
pyTernaryTailP SourcePos
pos Expression SourcePos
yesBranch = do
forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"if"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
condition <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
booleanExprP
forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"else"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
noBranch <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a.
a -> Expression a -> Expression a -> Expression a -> Expression a
TernaryE SourcePos
pos Expression SourcePos
condition Expression SourcePos
yesBranch Expression SourcePos
noBranch
booleanExprP :: Monad m => Parser m (Expression SourcePos)
booleanExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
booleanExprP =
forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos)
-> [(SourceName, VarName)] -> Parser m (Expression SourcePos)
operativeExprP
forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
comparativeExprP
[ (SourceName
"or", VarName
"any")
, (SourceName
"||", VarName
"any")
, (SourceName
"and", VarName
"all")
, (SourceName
"&&", VarName
"all")
]
comparativeExprP :: Monad m => Parser m (Expression SourcePos)
comparativeExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
comparativeExprP =
forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos)
-> [(SourceName, VarName)] -> Parser m (Expression SourcePos)
operativeExprP
forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
additiveExprP
[ (SourceName
"==", VarName
"equals")
, (SourceName
"!=", VarName
"nequals")
, (SourceName
">=", VarName
"greaterEquals")
, (SourceName
"<=", VarName
"lessEquals")
, (SourceName
">", VarName
"greater")
, (SourceName
"<", VarName
"less")
]
additiveExprP :: Monad m => Parser m (Expression SourcePos)
additiveExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
additiveExprP =
forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos)
-> [(SourceName, VarName)] -> Parser m (Expression SourcePos)
operativeExprP
forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
multiplicativeExprP
[ (SourceName
"+", VarName
"sum")
, (SourceName
"-", VarName
"difference")
, (SourceName
"~", VarName
"concat")
]
multiplicativeExprP :: Monad m => Parser m (Expression SourcePos)
multiplicativeExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
multiplicativeExprP =
forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos)
-> [(SourceName, VarName)] -> Parser m (Expression SourcePos)
operativeExprP
forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
postfixExprP
[ (SourceName
"*", VarName
"product")
, (SourceName
"//", VarName
"int_ratio")
, (SourceName
"/", VarName
"ratio")
, (SourceName
"%", VarName
"modulo")
]
postfixExprP :: Monad m => Parser m (Expression SourcePos)
postfixExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
postfixExprP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
Expression SourcePos
base <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
atomicExprP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
[Expression SourcePos -> Expression SourcePos]
postfixes <- forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *).
Monad m =>
SourcePos
-> Parser m (Expression SourcePos -> Expression SourcePos)
postfixP SourcePos
pos forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
`before`forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. (a -> b) -> a -> b
($)) Expression SourcePos
base [Expression SourcePos -> Expression SourcePos]
postfixes
postfixP :: Monad m => SourcePos -> Parser m ((Expression SourcePos) -> (Expression SourcePos))
postfixP :: forall (m :: * -> *).
Monad m =>
SourcePos
-> Parser m (Expression SourcePos -> Expression SourcePos)
postfixP SourcePos
pos = forall (m :: * -> *).
Monad m =>
SourcePos
-> Parser m (Expression SourcePos -> Expression SourcePos)
dotPostfixP SourcePos
pos
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos -> Expression SourcePos)
arrayAccessP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos -> Expression SourcePos)
funcCallP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos -> Expression SourcePos)
filterP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos -> Expression SourcePos)
testExprP
dotPostfixP :: Monad m => SourcePos -> Parser m ((Expression SourcePos) -> (Expression SourcePos))
dotPostfixP :: forall (m :: * -> *).
Monad m =>
SourcePos
-> Parser m (Expression SourcePos -> Expression SourcePos)
dotPostfixP SourcePos
pos = do
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'.'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
i <- forall a. a -> VarName -> Expression a
StringLiteralE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Expression SourcePos
e -> forall a. a -> Expression a -> Expression a -> Expression a
MemberLookupE SourcePos
pos Expression SourcePos
e Expression SourcePos
i
arrayAccessP :: Monad m => Parser m ((Expression SourcePos) -> (Expression SourcePos))
arrayAccessP :: forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos -> Expression SourcePos)
arrayAccessP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m a
bracedP SourceName
"[" SourceName
"]" (forall (m :: * -> *).
Monad m =>
SourcePos
-> Parser m (Expression SourcePos -> Expression SourcePos)
inner SourcePos
pos)
where
inner :: SourcePos
-> ParsecT
SourceName
ParseState
(ReaderT (ParserOptions m) m)
(Expression SourcePos -> Expression SourcePos)
inner SourcePos
pos = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (forall (m :: * -> *).
Monad m =>
SourcePos
-> Parser m (Expression SourcePos -> Expression SourcePos)
sliceInner SourcePos
pos) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *).
Monad m =>
SourcePos
-> Parser m (Expression SourcePos -> Expression SourcePos)
indexInner SourcePos
pos
sliceInner :: SourcePos
-> ParsecT
SourceName
ParseState
(ReaderT (ParserOptions m) m)
(Expression SourcePos -> Expression SourcePos)
sliceInner SourcePos
pos = do
Expression SourcePos
offset <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> Expression a
NullLiteralE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition)
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
':'
Expression SourcePos
length <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> Expression a
NullLiteralE forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Expression SourcePos
e ->
forall a.
a
-> Expression a -> [(Maybe VarName, Expression a)] -> Expression a
CallE
SourcePos
pos
(forall a. a -> VarName -> Expression a
VarE SourcePos
pos VarName
"slice")
[ (forall a. Maybe a
Nothing, Expression SourcePos
e)
, (forall a. Maybe a
Nothing, Expression SourcePos
offset)
, (forall a. Maybe a
Nothing, Expression SourcePos
length)
]
indexInner :: SourcePos
-> ParsecT
SourceName
ParseState
(ReaderT (ParserOptions m) m)
(Expression SourcePos -> Expression SourcePos)
indexInner SourcePos
pos = do
Expression SourcePos
i <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Expression SourcePos
e -> forall a. a -> Expression a -> Expression a -> Expression a
MemberLookupE SourcePos
pos Expression SourcePos
e Expression SourcePos
i
funcCallP :: Monad m => Parser m ((Expression SourcePos) -> (Expression SourcePos))
funcCallP :: forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos -> Expression SourcePos)
funcCallP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
[(Maybe VarName, Expression SourcePos)]
args <- forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m [a]
groupP SourceName
"(" SourceName
")" forall (m :: * -> *).
Monad m =>
Parser m (Maybe VarName, Expression SourcePos)
funcArgP
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Expression SourcePos
e -> forall a.
a
-> Expression a -> [(Maybe VarName, Expression a)] -> Expression a
CallE SourcePos
pos Expression SourcePos
e [(Maybe VarName, Expression SourcePos)]
args
funcArgP :: Monad m => Parser m (Maybe Text, (Expression SourcePos))
funcArgP :: forall (m :: * -> *).
Monad m =>
Parser m (Maybe VarName, Expression SourcePos)
funcArgP = forall (m :: * -> *).
Monad m =>
Parser m (Maybe VarName, Expression SourcePos)
namedFuncArgP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *).
Monad m =>
Parser m (Maybe VarName, Expression SourcePos)
positionalFuncArgP
namedFuncArgP :: Monad m => Parser m (Maybe Text, (Expression SourcePos))
namedFuncArgP :: forall (m :: * -> *).
Monad m =>
Parser m (Maybe VarName, Expression SourcePos)
namedFuncArgP = do
VarName
name <- forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => Parser m VarName
identifierP forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
`before` 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
between forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment (forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"=")
Expression SourcePos
expr <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just VarName
name, Expression SourcePos
expr)
positionalFuncArgP :: Monad m => Parser m (Maybe Text, (Expression SourcePos))
positionalFuncArgP :: forall (m :: * -> *).
Monad m =>
Parser m (Maybe VarName, Expression SourcePos)
positionalFuncArgP = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ (forall a. Maybe a
Nothing,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
filterP :: Monad m => Parser m ((Expression SourcePos) -> (Expression SourcePos))
filterP :: forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos -> Expression SourcePos)
filterP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'|'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
func <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
atomicExprP
[(Maybe VarName, Expression SourcePos)]
args <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m [a]
groupP SourceName
"(" SourceName
")" forall (m :: * -> *).
Monad m =>
Parser m (Maybe VarName, Expression SourcePos)
funcArgP
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Expression SourcePos
e -> forall a.
a
-> Expression a -> [(Maybe VarName, Expression a)] -> Expression a
CallE SourcePos
pos Expression SourcePos
func ((forall a. Maybe a
Nothing, Expression SourcePos
e)forall a. a -> [a] -> [a]
:[(Maybe VarName, Expression SourcePos)]
args)
testExprP :: Monad m => Parser m ((Expression SourcePos) -> (Expression SourcePos))
testExprP :: forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos -> Expression SourcePos)
testExprP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"is"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
funcName <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
atomicExprP
[(Maybe VarName, Expression SourcePos)]
args <- forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice [forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m [a]
groupP SourceName
"(" SourceName
")" forall (m :: * -> *).
Monad m =>
Parser m (Maybe VarName, Expression SourcePos)
funcArgP
, forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *).
Monad m =>
Parser m (Maybe VarName, Expression SourcePos)
funcArgP forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\(Maybe VarName, Expression SourcePos)
a -> forall (m :: * -> *) a. Monad m => a -> m a
return [(Maybe VarName, Expression SourcePos)
a])]
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ \Expression SourcePos
e -> forall a.
a
-> Expression a -> [(Maybe VarName, Expression a)] -> Expression a
CallE SourcePos
pos (forall a. Expression a -> Expression a
addIsPrefix Expression SourcePos
funcName) ((forall a. Maybe a
Nothing, Expression SourcePos
e)forall a. a -> [a] -> [a]
:[(Maybe VarName, Expression SourcePos)]
args)
where
addIsPrefix :: Expression a -> Expression a
addIsPrefix :: forall a. Expression a -> Expression a
addIsPrefix Expression a
expr = case Expression a
expr of
(VarE a
a VarName
text) -> forall a. a -> VarName -> Expression a
VarE a
a forall a b. (a -> b) -> a -> b
$ VarName -> VarName -> VarName
Text.append (SourceName -> VarName
Text.pack SourceName
"is_") VarName
text
Expression a
_ -> Expression a
expr
atomicExprP :: Monad m => Parser m (Expression SourcePos)
atomicExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
atomicExprP = forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
doExprP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
parenthesizedExprP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
objectExprP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
listExprP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
stringLiteralExprP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
numberLiteralExprP
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
varExprP
parenthesizedExprP :: Monad m => Parser m (Expression SourcePos)
parenthesizedExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
parenthesizedExprP =
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
between
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'(' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment)
(forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
')' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment)
forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
doExprP :: Monad m => Parser m (Expression SourcePos)
doExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
doExprP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
"do"
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Statement SourcePos
stmt <- forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
scriptStatementP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Statement a -> Expression a
DoE SourcePos
pos Statement SourcePos
stmt
listExprP :: Monad m => Parser m (Expression SourcePos)
listExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
listExprP =
forall a. a -> [Expression a] -> Expression a
ListE
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m [a]
groupP SourceName
"[" SourceName
"]" forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
objectExprP :: Monad m => Parser m (Expression SourcePos)
objectExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
objectExprP = forall a. a -> [(Expression a, Expression a)] -> Expression a
ObjectE
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m [a]
groupP SourceName
"{" SourceName
"}" forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, Expression SourcePos)
expressionPairP
expressionPairP :: Monad m => Parser m ((Expression SourcePos), (Expression SourcePos))
expressionPairP :: forall (m :: * -> *).
Monad m =>
Parser m (Expression SourcePos, Expression SourcePos)
expressionPairP = do
Expression SourcePos
a <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
':'
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
Expression SourcePos
b <- forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
expressionP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return (Expression SourcePos
a, Expression SourcePos
b)
groupP :: Monad m => String -> String -> Parser m a -> Parser m [a]
groupP :: forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m [a]
groupP SourceName
obr SourceName
cbr Parser m a
inner =
forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m a
bracedP SourceName
obr SourceName
cbr
(forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
sepBy (Parser m a
inner forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
`before` forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment) (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"," forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
`before` forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment))
bracedP :: Monad m => String -> String -> Parser m a -> Parser m a
bracedP :: forall (m :: * -> *) a.
Monad m =>
SourceName -> SourceName -> Parser m a -> Parser m a
bracedP SourceName
obr SourceName
cbr =
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
between
(forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
obr forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment)
(forall (m :: * -> *) a. Monad m => m a -> m ()
ignore forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
cbr forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment)
varExprP :: Monad m => Parser m (Expression SourcePos)
varExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
varExprP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
VarName
litName <- forall (m :: * -> *). Monad m => Parser m VarName
identifierP
forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ case VarName
litName of
VarName
"True" -> forall a. a -> Bool -> Expression a
BoolLiteralE SourcePos
pos Bool
True
VarName
"true" -> forall a. a -> Bool -> Expression a
BoolLiteralE SourcePos
pos Bool
True
VarName
"False" -> forall a. a -> Bool -> Expression a
BoolLiteralE SourcePos
pos Bool
False
VarName
"false" -> forall a. a -> Bool -> Expression a
BoolLiteralE SourcePos
pos Bool
False
VarName
"null" -> forall a. a -> Expression a
NullLiteralE SourcePos
pos
VarName
_ -> forall a. a -> VarName -> Expression a
VarE SourcePos
pos VarName
litName
identifierP :: Monad m => Parser m Text
identifierP :: forall (m :: * -> *). Monad m => Parser m VarName
identifierP =
SourceName -> VarName
Text.pack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (
(:)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf ([Char
'a'..Char
'z'] forall a. [a] -> [a] -> [a]
++ [Char
'A'..Char
'Z'] forall a. [a] -> [a] -> [a]
++ [Char
'_'])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall (m :: * -> *). Monad m => Parser m Char
identCharP)
identCharP :: Monad m => Parser m Char
identCharP :: forall (m :: * -> *). Monad m => Parser m Char
identCharP = forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf ([Char
'a'..Char
'z'] forall a. [a] -> [a] -> [a]
++ [Char
'A'..Char
'Z'] forall a. [a] -> [a] -> [a]
++ [Char
'_'] forall a. [a] -> [a] -> [a]
++ [Char
'0'..Char
'9'])
stringLiteralExprP :: Monad m => Parser m (Expression SourcePos)
stringLiteralExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
stringLiteralExprP =
forall a. a -> VarName -> Expression a
StringLiteralE
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (SourceName -> VarName
Text.pack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). Monad m => Parser m SourceName
stringLiteralP)
stringLiteralP :: Monad m => Parser m String
stringLiteralP :: forall (m :: * -> *). Monad m => Parser m SourceName
stringLiteralP = do
Char
d <- forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf [ Char
'\'', Char
'\"' ]
forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
manyTill forall (m :: * -> *). Monad m => Parser m Char
stringCharP (forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
d)
stringCharP :: Monad m => Parser m Char
stringCharP :: forall (m :: * -> *). Monad m => Parser m Char
stringCharP = do
Char
c1 <- forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar
case Char
c1 of
Char
'\\' -> do
Char
c2 <- forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar
case Char
c2 of
Char
'n' -> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\n'
Char
'r' -> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\r'
Char
'b' -> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\b'
Char
'v' -> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\v'
Char
'0' -> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\0'
Char
't' -> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\t'
Char
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return Char
c2
Char
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return Char
c1
numberLiteralExprP :: Monad m => Parser m (Expression SourcePos)
numberLiteralExprP :: forall (m :: * -> *). Monad m => Parser m (Expression SourcePos)
numberLiteralExprP = do
SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
SourceName
str <- forall (m :: * -> *). Monad m => Parser m SourceName
numberLiteralP
let nMay :: Maybe Scientific
nMay :: Maybe Scientific
nMay = forall a. Read a => SourceName -> Maybe a
readMay SourceName
str
case Maybe Scientific
nMay of
Just Scientific
n -> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Scientific -> Expression a
NumberLiteralE SourcePos
pos forall a b. (a -> b) -> a -> b
$ Scientific
n
Maybe Scientific
Nothing -> forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail forall a b. (a -> b) -> a -> b
$ SourceName
"Failed to parse " forall a. [a] -> [a] -> [a]
++ SourceName
str forall a. [a] -> [a] -> [a]
++ SourceName
" as a number"
numberLiteralP :: Monad m => Parser m String
numberLiteralP :: forall (m :: * -> *). Monad m => Parser m SourceName
numberLiteralP = do
SourceName
sign <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option SourceName
"" forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"-"
SourceName
integral <- forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
"0" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((:) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf [Char
'1'..Char
'9'] forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit)
SourceName
fractional <- forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option SourceName
"" forall a b. (a -> b) -> a -> b
$ (:) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'.' forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SourceName
sign forall a. [a] -> [a] -> [a]
++ SourceName
integral forall a. [a] -> [a] -> [a]
++ SourceName
fractional
followedBy :: Monad m => m b -> m a -> m a
followedBy :: forall (m :: * -> *) b a. Monad m => m b -> m a -> m a
followedBy m b
b m a
a = m a
a forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
x -> m b
b forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return a
x
before :: Monad m => m a -> m b -> m a
before :: forall (m :: * -> *) a b. Monad m => m a -> m b -> m a
before = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (m :: * -> *) b a. Monad m => m b -> m a -> m a
followedBy
keyword :: Monad m => String -> Parser m String
keyword :: forall (m :: * -> *). Monad m => SourceName -> Parser m SourceName
keyword SourceName
kw = do
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
kw
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy forall (m :: * -> *). Monad m => Parser m Char
identCharP
forall (m :: * -> *) a. Monad m => a -> m a
return SourceName
kw