{-# OPTIONS  #-}
-----------------------------------------------------------------------------
-- |
-- Module      : Language.Python.Common.ParserMonad 
-- Copyright   : (c) 2009 Bernie Pope 
-- License     : BSD-style
-- Maintainer  : bjpop@csse.unimelb.edu.au
-- Stability   : experimental
-- Portability : ghc
--
-- Monad support for Python parser and lexer. 
-----------------------------------------------------------------------------

module Language.Python.Common.ParserMonad 
   ( P
   , execParser
   , execParserKeepComments
   , runParser
   , thenP
   , returnP
   , setLocation
   , getLocation
   , getInput
   , setInput
   , getLastToken
   , setLastToken
   , setLastEOL
   , getLastEOL
   , ParseError (..)
   , ParseState (..)
   , initialState
   , pushStartCode
   , popStartCode
   , getStartCode
   , getIndent
   , pushIndent
   , popIndent
   , getIndentStackDepth
   , getParen
   , pushParen
   , popParen
   , getParenStackDepth
   , addComment
   , getComments
   , spanError
   , throwError
   ) where

import Language.Python.Common.SrcLocation (SrcLocation (..), SrcSpan (..), Span (..))
import Language.Python.Common.Token (Token (..))
import Language.Python.Common.ParseError (ParseError (..))
import Control.Applicative ((<$>))
import Control.Monad.State.Class
import Control.Monad.State.Strict as State
import Language.Python.Common.Pretty

internalError :: String -> P a 
internalError :: forall a. String -> P a
internalError = ParseError -> P a
forall a. ParseError -> P a
throwError (ParseError -> P a) -> (String -> ParseError) -> String -> P a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ParseError
StrError 

spanError :: Span a => a -> String -> P b 
spanError :: forall a b. Span a => a -> String -> P b
spanError a
x String
str = ParseError -> P b
forall a. ParseError -> P a
throwError (ParseError -> P b) -> ParseError -> P b
forall a b. (a -> b) -> a -> b
$ String -> ParseError
StrError (String -> ParseError) -> String -> ParseError
forall a b. (a -> b) -> a -> b
$ [String] -> String
unwords [SrcSpan -> String
forall a. Pretty a => a -> String
prettyText (SrcSpan -> String) -> SrcSpan -> String
forall a b. (a -> b) -> a -> b
$ a -> SrcSpan
forall a. Span a => a -> SrcSpan
getSpan a
x, String
str]

data ParseState = 
   ParseState 
   { ParseState -> SrcLocation
location :: !SrcLocation -- position at current input location
   , ParseState -> String
input :: !String         -- the current input
   , ParseState -> Token
previousToken :: !Token  -- the previous token
   , ParseState -> [Int]
startCodeStack :: [Int]  -- a stack of start codes for the state of the lexer
   , ParseState -> [Int]
indentStack :: [Int]     -- a stack of source column positions of indentation levels
   , ParseState -> [Token]
parenStack :: [Token]    -- a stack of parens and brackets for indentation handling
   , ParseState -> SrcSpan
lastEOL :: !SrcSpan      -- location of the most recent end-of-line encountered
   , ParseState -> [Token]
comments :: [Token]      -- accumulated comments 
   }
   deriving Int -> ParseState -> ShowS
[ParseState] -> ShowS
ParseState -> String
(Int -> ParseState -> ShowS)
-> (ParseState -> String)
-> ([ParseState] -> ShowS)
-> Show ParseState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ParseState -> ShowS
showsPrec :: Int -> ParseState -> ShowS
$cshow :: ParseState -> String
show :: ParseState -> String
$cshowList :: [ParseState] -> ShowS
showList :: [ParseState] -> ShowS
Show

initToken :: Token
initToken :: Token
initToken = SrcSpan -> Token
NewlineToken SrcSpan
SpanEmpty 

initialState :: SrcLocation -> String -> [Int] -> ParseState
initialState :: SrcLocation -> String -> [Int] -> ParseState
initialState SrcLocation
initLoc String
inp [Int]
scStack
   = ParseState 
   { location :: SrcLocation
location = SrcLocation
initLoc 
   , input :: String
input = String
inp
   , previousToken :: Token
previousToken = Token
initToken
   , startCodeStack :: [Int]
startCodeStack = [Int]
scStack
   , indentStack :: [Int]
indentStack = [Int
1]
   , parenStack :: [Token]
parenStack = []
   , lastEOL :: SrcSpan
lastEOL = SrcSpan
SpanEmpty 
   , comments :: [Token]
comments = []
   }

type P a = StateT ParseState (Either ParseError) a

throwError :: ParseError -> P a
throwError :: forall a. ParseError -> P a
throwError = Either ParseError a -> StateT ParseState (Either ParseError) a
forall (m :: * -> *) a. Monad m => m a -> StateT ParseState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Either ParseError a -> StateT ParseState (Either ParseError) a)
-> (ParseError -> Either ParseError a)
-> ParseError
-> StateT ParseState (Either ParseError) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError -> Either ParseError a
forall a b. a -> Either a b
Left

execParser :: P a -> ParseState -> Either ParseError a
execParser :: forall a. P a -> ParseState -> Either ParseError a
execParser = StateT ParseState (Either ParseError) a
-> ParseState -> Either ParseError a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT 

execParserKeepComments :: P a -> ParseState -> Either ParseError (a, [Token])
execParserKeepComments :: forall a. P a -> ParseState -> Either ParseError (a, [Token])
execParserKeepComments P a
parser ParseState
state = 
   StateT ParseState (Either ParseError) (a, [Token])
-> ParseState -> Either ParseError (a, [Token])
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT (P a
parser P a
-> (a -> StateT ParseState (Either ParseError) (a, [Token]))
-> StateT ParseState (Either ParseError) (a, [Token])
forall a b.
StateT ParseState (Either ParseError) a
-> (a -> StateT ParseState (Either ParseError) b)
-> StateT ParseState (Either ParseError) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
x -> P [Token]
getComments P [Token]
-> ([Token] -> StateT ParseState (Either ParseError) (a, [Token]))
-> StateT ParseState (Either ParseError) (a, [Token])
forall a b.
StateT ParseState (Either ParseError) a
-> (a -> StateT ParseState (Either ParseError) b)
-> StateT ParseState (Either ParseError) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Token]
c -> (a, [Token]) -> StateT ParseState (Either ParseError) (a, [Token])
forall a. a -> StateT ParseState (Either ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
x, [Token]
c)) ParseState
state

runParser :: P a -> ParseState -> Either ParseError (a, ParseState)
runParser :: forall a. P a -> ParseState -> Either ParseError (a, ParseState)
runParser = StateT ParseState (Either ParseError) a
-> ParseState -> Either ParseError (a, ParseState)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT 

{-# INLINE returnP #-}
returnP :: a -> P a
returnP :: forall a. a -> StateT ParseState (Either ParseError) a
returnP = a -> StateT ParseState (Either ParseError) a
forall a. a -> StateT ParseState (Either ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return 

{-# INLINE thenP #-}
thenP :: P a -> (a -> P b) -> P b
thenP :: forall a b.
StateT ParseState (Either ParseError) a
-> (a -> StateT ParseState (Either ParseError) b)
-> StateT ParseState (Either ParseError) b
thenP = StateT ParseState (Either ParseError) a
-> (a -> StateT ParseState (Either ParseError) b)
-> StateT ParseState (Either ParseError) b
forall a b.
StateT ParseState (Either ParseError) a
-> (a -> StateT ParseState (Either ParseError) b)
-> StateT ParseState (Either ParseError) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(>>=)

{-
failP :: SrcSpan -> [String] -> P a
failP span strs = throwError (prettyText span ++ ": " ++ unwords strs) 
-}

setLastEOL :: SrcSpan -> P ()
setLastEOL :: SrcSpan -> P ()
setLastEOL SrcSpan
span = (StateType (StateT ParseState (Either ParseError))
 -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify ((StateType (StateT ParseState (Either ParseError))
  -> StateType (StateT ParseState (Either ParseError)))
 -> P ())
-> (StateType (StateT ParseState (Either ParseError))
    -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall a b. (a -> b) -> a -> b
$ \StateType (StateT ParseState (Either ParseError))
s -> StateType (StateT ParseState (Either ParseError))
ParseState
s { lastEOL :: SrcSpan
lastEOL = SrcSpan
span }

getLastEOL :: P SrcSpan
getLastEOL :: P SrcSpan
getLastEOL = (StateType (StateT ParseState (Either ParseError)) -> SrcSpan)
-> P SrcSpan
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> SrcSpan
ParseState -> SrcSpan
lastEOL

setLocation :: SrcLocation -> P ()
setLocation :: SrcLocation -> P ()
setLocation SrcLocation
loc = (StateType (StateT ParseState (Either ParseError))
 -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify ((StateType (StateT ParseState (Either ParseError))
  -> StateType (StateT ParseState (Either ParseError)))
 -> P ())
-> (StateType (StateT ParseState (Either ParseError))
    -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall a b. (a -> b) -> a -> b
$ \StateType (StateT ParseState (Either ParseError))
s -> StateType (StateT ParseState (Either ParseError))
ParseState
s { location :: SrcLocation
location = SrcLocation
loc } 

getLocation :: P SrcLocation
getLocation :: P SrcLocation
getLocation = (StateType (StateT ParseState (Either ParseError)) -> SrcLocation)
-> P SrcLocation
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> SrcLocation
ParseState -> SrcLocation
location 

getInput :: P String 
getInput :: P String
getInput = (StateType (StateT ParseState (Either ParseError)) -> String)
-> P String
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> String
ParseState -> String
input 

setInput :: String -> P ()
setInput :: String -> P ()
setInput String
inp = (StateType (StateT ParseState (Either ParseError))
 -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify ((StateType (StateT ParseState (Either ParseError))
  -> StateType (StateT ParseState (Either ParseError)))
 -> P ())
-> (StateType (StateT ParseState (Either ParseError))
    -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall a b. (a -> b) -> a -> b
$ \StateType (StateT ParseState (Either ParseError))
s -> StateType (StateT ParseState (Either ParseError))
ParseState
s { input :: String
input = String
inp }

getLastToken :: P Token
getLastToken :: P Token
getLastToken = (StateType (StateT ParseState (Either ParseError)) -> Token)
-> P Token
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> Token
ParseState -> Token
previousToken 

setLastToken :: Token -> P ()
setLastToken :: Token -> P ()
setLastToken Token
tok = (StateType (StateT ParseState (Either ParseError))
 -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify ((StateType (StateT ParseState (Either ParseError))
  -> StateType (StateT ParseState (Either ParseError)))
 -> P ())
-> (StateType (StateT ParseState (Either ParseError))
    -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall a b. (a -> b) -> a -> b
$ \StateType (StateT ParseState (Either ParseError))
s -> StateType (StateT ParseState (Either ParseError))
ParseState
s { previousToken :: Token
previousToken = Token
tok } 

pushStartCode :: Int -> P () 
pushStartCode :: Int -> P ()
pushStartCode Int
code = do
   [Int]
oldStack <- (StateType (StateT ParseState (Either ParseError)) -> [Int])
-> StateT ParseState (Either ParseError) [Int]
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> [Int]
ParseState -> [Int]
startCodeStack
   (StateType (StateT ParseState (Either ParseError))
 -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify ((StateType (StateT ParseState (Either ParseError))
  -> StateType (StateT ParseState (Either ParseError)))
 -> P ())
-> (StateType (StateT ParseState (Either ParseError))
    -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall a b. (a -> b) -> a -> b
$ \StateType (StateT ParseState (Either ParseError))
s -> StateType (StateT ParseState (Either ParseError))
ParseState
s { startCodeStack :: [Int]
startCodeStack = Int
code Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: [Int]
oldStack }

popStartCode :: P ()
popStartCode :: P ()
popStartCode = do
   [Int]
oldStack <- (StateType (StateT ParseState (Either ParseError)) -> [Int])
-> StateT ParseState (Either ParseError) [Int]
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> [Int]
ParseState -> [Int]
startCodeStack
   case [Int]
oldStack of
     [] -> String -> P ()
forall a. String -> P a
internalError String
"fatal error in lexer: attempt to pop empty start code stack"
     Int
_:[Int]
rest -> (StateType (StateT ParseState (Either ParseError))
 -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify ((StateType (StateT ParseState (Either ParseError))
  -> StateType (StateT ParseState (Either ParseError)))
 -> P ())
-> (StateType (StateT ParseState (Either ParseError))
    -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall a b. (a -> b) -> a -> b
$ \StateType (StateT ParseState (Either ParseError))
s -> StateType (StateT ParseState (Either ParseError))
ParseState
s { startCodeStack :: [Int]
startCodeStack = [Int]
rest }

getStartCode :: P Int
getStartCode :: P Int
getStartCode = do 
   [Int]
oldStack <- (StateType (StateT ParseState (Either ParseError)) -> [Int])
-> StateT ParseState (Either ParseError) [Int]
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> [Int]
ParseState -> [Int]
startCodeStack
   case [Int]
oldStack of
     [] -> String -> P Int
forall a. String -> P a
internalError String
"fatal error in lexer: start code stack empty on getStartCode"
     Int
code:[Int]
_ -> Int -> P Int
forall a. a -> StateT ParseState (Either ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
code 

pushIndent :: Int -> P () 
pushIndent :: Int -> P ()
pushIndent Int
indent = do 
   [Int]
oldStack <- (StateType (StateT ParseState (Either ParseError)) -> [Int])
-> StateT ParseState (Either ParseError) [Int]
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> [Int]
ParseState -> [Int]
indentStack
   (StateType (StateT ParseState (Either ParseError))
 -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify ((StateType (StateT ParseState (Either ParseError))
  -> StateType (StateT ParseState (Either ParseError)))
 -> P ())
-> (StateType (StateT ParseState (Either ParseError))
    -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall a b. (a -> b) -> a -> b
$ \StateType (StateT ParseState (Either ParseError))
s -> StateType (StateT ParseState (Either ParseError))
ParseState
s { indentStack :: [Int]
indentStack = Int
indent Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: [Int]
oldStack }

popIndent :: P ()
popIndent :: P ()
popIndent = do 
   [Int]
oldStack <- (StateType (StateT ParseState (Either ParseError)) -> [Int])
-> StateT ParseState (Either ParseError) [Int]
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> [Int]
ParseState -> [Int]
indentStack
   case [Int]
oldStack of
     [] -> String -> P ()
forall a. String -> P a
internalError String
"fatal error in lexer: attempt to pop empty indentation stack"
     Int
_:[Int]
rest -> (StateType (StateT ParseState (Either ParseError))
 -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify ((StateType (StateT ParseState (Either ParseError))
  -> StateType (StateT ParseState (Either ParseError)))
 -> P ())
-> (StateType (StateT ParseState (Either ParseError))
    -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall a b. (a -> b) -> a -> b
$ \StateType (StateT ParseState (Either ParseError))
s -> StateType (StateT ParseState (Either ParseError))
ParseState
s { indentStack :: [Int]
indentStack = [Int]
rest }

getIndent :: P Int
getIndent :: P Int
getIndent = do
   [Int]
oldStack <- (StateType (StateT ParseState (Either ParseError)) -> [Int])
-> StateT ParseState (Either ParseError) [Int]
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> [Int]
ParseState -> [Int]
indentStack 
   case [Int]
oldStack of
     [] -> String -> P Int
forall a. String -> P a
internalError String
"fatal error in lexer: indent stack empty on getIndent"
     Int
indent:[Int]
_ -> Int -> P Int
forall a. a -> StateT ParseState (Either ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
indent 

getIndentStackDepth :: P Int
getIndentStackDepth :: P Int
getIndentStackDepth = (StateType (StateT ParseState (Either ParseError)) -> Int) -> P Int
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets ([Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Int] -> Int) -> (ParseState -> [Int]) -> ParseState -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseState -> [Int]
indentStack)

pushParen :: Token -> P () 
pushParen :: Token -> P ()
pushParen Token
symbol = do
   [Token]
oldStack <- (StateType (StateT ParseState (Either ParseError)) -> [Token])
-> P [Token]
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> [Token]
ParseState -> [Token]
parenStack 
   (StateType (StateT ParseState (Either ParseError))
 -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify ((StateType (StateT ParseState (Either ParseError))
  -> StateType (StateT ParseState (Either ParseError)))
 -> P ())
-> (StateType (StateT ParseState (Either ParseError))
    -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall a b. (a -> b) -> a -> b
$ \StateType (StateT ParseState (Either ParseError))
s -> StateType (StateT ParseState (Either ParseError))
ParseState
s { parenStack :: [Token]
parenStack = Token
symbol Token -> [Token] -> [Token]
forall a. a -> [a] -> [a]
: [Token]
oldStack }

popParen :: P ()
popParen :: P ()
popParen = do
   [Token]
oldStack <- (StateType (StateT ParseState (Either ParseError)) -> [Token])
-> P [Token]
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> [Token]
ParseState -> [Token]
parenStack
   case [Token]
oldStack of
      [] -> String -> P ()
forall a. String -> P a
internalError String
"fatal error in lexer: attempt to pop empty paren stack"
      Token
_:[Token]
rest -> (StateType (StateT ParseState (Either ParseError))
 -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify ((StateType (StateT ParseState (Either ParseError))
  -> StateType (StateT ParseState (Either ParseError)))
 -> P ())
-> (StateType (StateT ParseState (Either ParseError))
    -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall a b. (a -> b) -> a -> b
$ \StateType (StateT ParseState (Either ParseError))
s -> StateType (StateT ParseState (Either ParseError))
ParseState
s { parenStack :: [Token]
parenStack = [Token]
rest }  

getParen :: P (Maybe Token)
getParen :: P (Maybe Token)
getParen = do
   [Token]
oldStack <- (StateType (StateT ParseState (Either ParseError)) -> [Token])
-> P [Token]
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> [Token]
ParseState -> [Token]
parenStack
   case [Token]
oldStack of
      [] -> Maybe Token -> P (Maybe Token)
forall a. a -> StateT ParseState (Either ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Token
forall a. Maybe a
Nothing 
      Token
symbol:[Token]
_ -> Maybe Token -> P (Maybe Token)
forall a. a -> StateT ParseState (Either ParseError) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Token -> P (Maybe Token)) -> Maybe Token -> P (Maybe Token)
forall a b. (a -> b) -> a -> b
$ Token -> Maybe Token
forall a. a -> Maybe a
Just Token
symbol

getParenStackDepth :: P Int
getParenStackDepth :: P Int
getParenStackDepth = (StateType (StateT ParseState (Either ParseError)) -> Int) -> P Int
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets ([Token] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Token] -> Int) -> (ParseState -> [Token]) -> ParseState -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseState -> [Token]
parenStack) 

addComment :: Token -> P ()
addComment :: Token -> P ()
addComment Token
c = do
   [Token]
oldComments <- (StateType (StateT ParseState (Either ParseError)) -> [Token])
-> P [Token]
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> [Token]
ParseState -> [Token]
comments
   (StateType (StateT ParseState (Either ParseError))
 -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall (m :: * -> *).
MonadState m =>
(StateType m -> StateType m) -> m ()
modify ((StateType (StateT ParseState (Either ParseError))
  -> StateType (StateT ParseState (Either ParseError)))
 -> P ())
-> (StateType (StateT ParseState (Either ParseError))
    -> StateType (StateT ParseState (Either ParseError)))
-> P ()
forall a b. (a -> b) -> a -> b
$ \StateType (StateT ParseState (Either ParseError))
s -> StateType (StateT ParseState (Either ParseError))
ParseState
s { comments :: [Token]
comments = Token
c Token -> [Token] -> [Token]
forall a. a -> [a] -> [a]
: [Token]
oldComments }

getComments :: P [Token]
getComments :: P [Token]
getComments = [Token] -> [Token]
forall a. [a] -> [a]
reverse ([Token] -> [Token]) -> P [Token] -> P [Token]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (StateType (StateT ParseState (Either ParseError)) -> [Token])
-> P [Token]
forall (m :: * -> *) a. MonadState m => (StateType m -> a) -> m a
gets StateType (StateT ParseState (Either ParseError)) -> [Token]
ParseState -> [Token]
comments