module Text.Parsec.Prim
( P.unknownError
, P.sysUnExpectError
, unexpected
, ParsecT
, runParsecT
, P.mkPT
, Parsec
, P.Consumed(..)
, P.Reply(..)
, P.State(..)
, parsecMap
, parserReturn
, parserBind
, P.mergeErrorReply
, parserFail
, parserZero
, parserPlus
, (<?>)
, (<|>)
, label
, labels
, lookAhead
, Stream(..)
, tokens
, try
, token
, tokenPrim
, tokenPrimEx
, many
, skipMany
, manyAccum
, runPT
, runPTLog
, runP
, runParserT
, runParserTLog
, runParser
, parse
, parseTest
, parseTestLog
, P.getPosition
, P.getInput
, P.setPosition
, P.setInput
, getParserState
, setParserState
, updateParserState
, getState
, putState
, modifyState
, setState
, updateState
) where
import qualified Control.Applicative as Applicative (Alternative(..))
import Control.Monad()
import Control.Monad.Trans
import Control.Monad.Identity
import Control.Monad.Reader.Class
import Control.Monad.State.Class
import Control.Monad.Cont.Class
import Control.Monad.Error.Class
import Data.IORef
import Text.Parsec.Pos
import Text.Parsec.Error
import qualified Text.Parsec.Free as F
import qualified Text.Parsec.Free.Eval as F
import qualified Text.Parsec.Free.Log as F
import qualified "parsec" Text.Parsec.Prim as P
import "parsec" Text.Parsec.Prim (Stream, State(..))
type ParsecT = F.ParsecDSL
runParsecT :: ParsecT s u m a -> F.ParsecDSL s u m a
runParsecT = id
unexpected :: (Stream s m t) => String -> ParsecT s u m a
unexpected = F.unexpected
type Parsec s u = ParsecT s u Identity
parsecMap :: (a -> b) -> ParsecT s u m a -> ParsecT s u m b
parsecMap = fmap
parserReturn :: a -> ParsecT s u m a
parserReturn = return
parserBind :: ParsecT s u m a -> (a -> ParsecT s u m b) -> ParsecT s u m b
parserBind = (>>=)
parserFail :: String -> ParsecT s u m a
parserFail = F.parserFail
parserZero :: ParsecT s u m a
parserZero = F.parserZero
parserPlus :: ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
parserPlus = F.parserPlus
infix 0 <?>
infixr 1 <|>
(<?>) :: (ParsecT s u m a) -> String -> (ParsecT s u m a)
(<?>) = F.label
(<|>) :: (ParsecT s u m a) -> (ParsecT s u m a) -> (ParsecT s u m a)
(<|>) = parserPlus
label :: ParsecT s u m a -> String -> ParsecT s u m a
label = (<?>)
labels :: ParsecT s u m a -> [String] -> ParsecT s u m a
labels = F.labels
tokens :: (Monad m, Stream s m t, Eq t)
=> ([t] -> String)
-> (SourcePos -> [t] -> SourcePos)
-> [t]
-> ParsecT s u m [t]
tokens = F.tokens
try :: ParsecT s u m a -> ParsecT s u m a
try = F.try
lookAhead :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m a
lookAhead = F.lookAhead
token :: (Stream s Identity t)
=> (t -> String)
-> (t -> SourcePos)
-> (t -> Maybe a)
-> Parsec s u a
token showToken tokpos test = tokenPrim showToken nextpos test
where
nextpos _ tok ts = case runIdentity (P.uncons ts) of
Nothing -> tokpos tok
Just (tok',_) -> tokpos tok'
tokenPrim :: (Stream s m t)
=> (t -> String)
-> (SourcePos -> t -> s -> SourcePos)
-> (t -> Maybe a)
-> ParsecT s u m a
tokenPrim showToken nextpos test = tokenPrimEx showToken nextpos Nothing test
tokenPrimEx :: (Stream s m t)
=> (t -> String)
-> (SourcePos -> t -> s -> SourcePos)
-> Maybe (SourcePos -> t -> s -> u -> u)
-> (t -> Maybe a)
-> ParsecT s u m a
tokenPrimEx = F.tokenPrimEx
many :: ParsecT s u m a -> ParsecT s u m [a]
many = F.many
skipMany :: ParsecT s u m a -> ParsecT s u m ()
skipMany = F.skipMany
manyAccum :: (a -> [a] -> [a])
-> ParsecT s u m a
-> ParsecT s u m [a]
manyAccum = F.manyAccum
runPT :: (Monad m, Stream s m t)
=> ParsecT s u m a -> u -> SourceName -> s -> m (Either ParseError a)
runPT = P.runPT . F.eval (const id) id
runPTLog :: (MonadIO m, MonadReader F.LogType m, Stream s m t)
=> ParsecT s u m a -> u -> SourceName -> s
-> m (Either ParseError a)
runPTLog = P.runPT . F.evalLog
runP :: (Stream s Identity t)
=> Parsec s u a -> u -> SourceName -> s -> Either ParseError a
runP p u n s = runIdentity $ P.runPT (F.eval (const id) id p) u n s
runParserT :: (Stream s m t)
=> ParsecT s u m a -> u -> SourceName -> s -> m (Either ParseError a)
runParserT = runPT
runParserTLog :: (MonadIO m, MonadReader F.LogType m, Stream s m t)
=> ParsecT s u m a
-> u
-> SourceName
-> s
-> m (Either ParseError a)
runParserTLog = runPTLog
runParser :: (Stream s Identity t)
=> Parsec s u a -> u -> SourceName -> s -> Either ParseError a
runParser = runP
parse :: (Stream s Identity t)
=> Parsec s () a -> SourceName -> s -> Either ParseError a
parse p = runP p ()
parseTest :: (Stream s Identity t, Show a)
=> Parsec s () a -> s -> IO ()
parseTest p input
= case parse p "" input of
Left err -> do putStr "parse error at "
print err
Right x -> print x
parseTestLog :: (MonadIO m, MonadReader F.LogType m, Stream s m t, Show a)
=> ParsecT s () m a -> s -> m ()
parseTestLog p input = do
eres <- runPTLog p () "" input
liftIO $ case eres of
Left err -> do putStr "parse error at "
print err
Right x -> print x
getParserState :: Monad m => ParsecT s u m (State s u)
getParserState = F.getParserState
setParserState :: Monad m => State s u -> ParsecT s u m (State s u)
setParserState = F.setParserState
updateParserState :: Monad m => (State s u -> State s u) -> ParsecT s u m (State s u)
updateParserState = F.updateParserState
getState :: (Monad m) => ParsecT s u m u
getState = F.getState
putState :: (Monad m) => u -> ParsecT s u m ()
putState = F.putState
modifyState :: (Monad m) => (u -> u) -> ParsecT s u m ()
modifyState = F.modifyState
setState :: (Monad m) => u -> ParsecT s u m ()
setState = putState
updateState :: (Monad m) => (u -> u) -> ParsecT s u m ()
updateState = modifyState