{-#LANGUAGE TupleSections #-}
{-#LANGUAGE OverloadedStrings #-}
{-#LANGUAGE ScopedTypeVariables #-}
{-#LANGUAGE DeriveGeneric #-}
{-#LANGUAGE FlexibleInstances #-}
{-#LANGUAGE MultiParamTypeClasses #-}
-- | Ginger parser.
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 )

-- | Input type for the parser (source code).
type Source = String

-- | Used to resolve includes. Ginger will call this function whenever it
-- encounters an {% include %}, {% import %}, or {% extends %} directive.
-- If the required source code is not available, the resolver should return
-- @Nothing@, else @Just@ the source.
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
             ]

-- | Error information for Ginger parser errors.
data ParserError =
    ParserError
        { ParserError -> SourceName
peErrorMessage :: String -- ^ Human-readable error message
        , 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

-- | Formats a parser errror into something human-friendly.
-- If template source code is not provided, only the line and column numbers
-- and the error message are printed. If template source code is provided,
-- the offending source line is also printed, with a caret (@^@) marking the
-- exact location of the error.
formatParserError :: Maybe String -- ^ Template source code (not filename)
                  -> ParserError -- ^ Error to format
                  -> 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)
        ]

-- | Helper function to create a Ginger parser error from a Parsec error.
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)

-- | Parse Ginger source from a file. Both the initial template and all
-- subsequent includes are loaded through the provided 'IncludeResolver'. A
-- consequence of this is that if you pass a \"null resolver\" (like `const
-- (return Nothing)`), this function will always fail.
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 }

-- | Parse Ginger source from memory. The initial template is taken directly
-- from the provided 'Source', while all subsequent includes are loaded through
-- the provided 'IncludeResolver'.
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 }

-- | Parse Ginger source from a file. Flavor of 'parseGingerFile' that takes
-- additional 'ParserOptions'.
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

-- | Parse Ginger source from memory. Flavor of 'parseGinger' that takes
-- additional 'ParserOptions'.
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


-- | Delimiter configuration.
data Delimiters
    = Delimiters
        { Delimiters -> SourceName
delimOpenInterpolation :: String
        , Delimiters -> SourceName
delimCloseInterpolation :: String
        , Delimiters -> SourceName
delimOpenTag :: String
        , Delimiters -> SourceName
delimCloseTag :: String
        , Delimiters -> SourceName
delimOpenComment :: String
        , Delimiters -> SourceName
delimCloseComment :: String
        }

-- | Default delimiter configuration: @{{ }}@ for interpolation, @{% %}@ for
-- tags, @{# #}@ for comments.
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
        { -- | How to load templates / includes
          forall (m :: * -> *). ParserOptions m -> IncludeResolver m
poIncludeResolver :: IncludeResolver m
          -- | Current source file name, if any
        , forall (m :: * -> *). ParserOptions m -> Maybe SourceName
poSourceName :: Maybe SourceName
          -- | Disable newline stripping
        , forall (m :: * -> *). ParserOptions m -> Bool
poKeepTrailingNewline :: Bool
          -- | Enable auto-stripping of @{% block %}@s
        , forall (m :: * -> *). ParserOptions m -> Bool
poLStripBlocks :: Bool
          -- | Enable auto-trimming of @{% block %}@s
        , forall (m :: * -> *). ParserOptions m -> Bool
poTrimBlocks :: Bool
          -- | Interpolation, tag, and comment delimiters
        , forall (m :: * -> *). ParserOptions m -> Delimiters
poDelimiters :: Delimiters
        }

-- | Default parser options for a given resolver
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

-- include sourceName = templateBody <$> includeTemplate 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)
commentStmtP :: forall (m :: * -> *). Monad m => Parser m (Statement SourcePos)
commentStmtP = 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 ()
scriptCommentP :: forall (m :: * -> *). Monad m => Parser m ()
scriptCommentP = 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 ()
spacesOrComment :: forall (m :: * -> *). Monad m => Parser m ()
spacesOrComment = 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)
    -- No endif here: the parent {% if %} owns that one.
    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)
catchHeaderP :: forall (m :: * -> *).
Monad m =>
Parser m (Maybe VarName, Maybe VarName)
catchHeaderP = 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

-- TODO: try/catch/finally in script mode

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)

-- {% call (foo) bar(baz) %}quux{% endcall %}
--
-- is the same as:
--
-- {% scope %}
-- {% macro __lambda(foo) %}quux{% endmacro %}
-- {% set caller = __lambda %}
-- {{ bar(baz) }}
-- {% endscope %]
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 ()
openCommentP :: forall (m :: * -> *). Monad m => Parser m ()
openCommentP =
    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 ()
closeCommentP :: forall (m :: * -> *). Monad m => Parser m ()
closeCommentP =
    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

-- vim: sw=4