{-# LANGUAGE CPP #-}
{- |
Module      :  Text.ParserCombinators.Parsec.Prim
Copyright   :  (c) Daan Leijen 1999-2001
License     :  BSD-style (see the file LICENSE)

Maintainer  :  Christian Maeder <chr.maeder@web.de>
Stability   :  provisional
Portability :  portable

The primitive parser combinators.
-}

module Text.ParserCombinators.Parsec.Prim
  ( -- operators: label a parser, alternative
    (*>)
  , (<$)
  , (<$>)
  , (<*)
  , (<*>)
  , (<?>)
  , (<|>)
    -- basic types
  , GenParser
  , Parser
  , parse
  , parseFromFile
  , parseTest
  , runParser
    -- primitive parsers
  , label
  , labels
  , lookAhead
  , pzero
  , token
  , tokenPrim
  , tokenPrimEx
  , tokens
  , try
  , unexpected
    -- primitive because of space behaviour
  , many
  , skipMany
    -- user state manipulation
  , getState
  , setState
  , updateState
    -- state manipulation
  , State (..)
  , getInput
  , getParserState
  , getPosition
  , setInput
  , setParserState
  , setPosition
  ) where

import Text.ParserCombinators.Parsec.Error
import Text.ParserCombinators.Parsec.Pos

import Control.Applicative
import Control.Monad

#if __GLASGOW_HASKELL__ >= 801
import Control.Monad.Fail
#endif

infix 0 <?>

{- | The parser @p <?> msg@ behaves as parser @p@, but whenever the
parser @p@ fails /without consuming any input/, it replaces expect
error messages with the expect error message @msg@.

This is normally used at the end of a set alternatives where we want
to return an error message in terms of a higher level construct
rather than returning all possible characters. For example, if the
@expr@ parser from the 'try' example would fail, the error
message is: '...: expecting expression'. Without the @(\<?>)@
combinator, the message would be like '...: expecting \"let\" or
letter', which is less friendly. -}
(<?>) :: GenParser tok st a -> String -> GenParser tok st a
GenParser tok st a
p <?> :: GenParser tok st a -> String -> GenParser tok st a
<?> String
msg = GenParser tok st a -> String -> GenParser tok st a
forall tok st a. GenParser tok st a -> String -> GenParser tok st a
label GenParser tok st a
p String
msg

{- ---------------------------------------------------------
User state combinators
--------------------------------------------------------- -}

-- | Returns the current user state.
getState :: GenParser tok st st
getState :: GenParser tok st st
getState = State tok st -> st
forall tok st. State tok st -> st
stateUser (State tok st -> st)
-> GenParser tok st (State tok st) -> GenParser tok st st
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenParser tok st (State tok st)
forall tok st. GenParser tok st (State tok st)
getParserState

-- | @setState st@ set the user state to @st@.
setState :: st -> GenParser tok st ()
setState :: st -> GenParser tok st ()
setState st
st =
  () () -> GenParser tok st (State tok st) -> GenParser tok st ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (State tok st -> State tok st) -> GenParser tok st (State tok st)
forall tok st.
(State tok st -> State tok st) -> GenParser tok st (State tok st)
updateParserState (\ (State [tok]
input SourcePos
pos st
_) -> [tok] -> SourcePos -> st -> State tok st
forall tok st. [tok] -> SourcePos -> st -> State tok st
State [tok]
input SourcePos
pos st
st)

{- | @updateState f@ applies function @f@ to the user state. Suppose
that we want to count identifiers in a source, we could use the user
state as:

>  expr  = do
>    x <- identifier
>    updateState (+1)
>    return (Id x) -}
updateState :: (st -> st) -> GenParser tok st ()
updateState :: (st -> st) -> GenParser tok st ()
updateState st -> st
f =
  () () -> GenParser tok st (State tok st) -> GenParser tok st ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (State tok st -> State tok st) -> GenParser tok st (State tok st)
forall tok st.
(State tok st -> State tok st) -> GenParser tok st (State tok st)
updateParserState (\ (State [tok]
input SourcePos
pos st
user) -> [tok] -> SourcePos -> st -> State tok st
forall tok st. [tok] -> SourcePos -> st -> State tok st
State [tok]
input SourcePos
pos (st -> st
f st
user))

{- ---------------------------------------------------------
Parser state combinators
--------------------------------------------------------- -}

-- | Returns the current source position. See also 'SourcePos'.
getPosition :: GenParser tok st SourcePos
getPosition :: GenParser tok st SourcePos
getPosition = State tok st -> SourcePos
forall tok st. State tok st -> SourcePos
statePos (State tok st -> SourcePos)
-> GenParser tok st (State tok st) -> GenParser tok st SourcePos
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenParser tok st (State tok st)
forall tok st. GenParser tok st (State tok st)
getParserState

-- | Returns the current input
getInput :: GenParser tok st [tok]
getInput :: GenParser tok st [tok]
getInput = State tok st -> [tok]
forall tok st. State tok st -> [tok]
stateInput (State tok st -> [tok])
-> GenParser tok st (State tok st) -> GenParser tok st [tok]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenParser tok st (State tok st)
forall tok st. GenParser tok st (State tok st)
getParserState

-- | @setPosition pos@ sets the current source position to @pos@.
setPosition :: SourcePos -> GenParser tok st ()
setPosition :: SourcePos -> GenParser tok st ()
setPosition SourcePos
pos =
  () () -> GenParser tok st (State tok st) -> GenParser tok st ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (State tok st -> State tok st) -> GenParser tok st (State tok st)
forall tok st.
(State tok st -> State tok st) -> GenParser tok st (State tok st)
updateParserState (\ (State [tok]
input SourcePos
_ st
user) -> [tok] -> SourcePos -> st -> State tok st
forall tok st. [tok] -> SourcePos -> st -> State tok st
State [tok]
input SourcePos
pos st
user)

-- | @setInput input@ continues parsing with @input@.
setInput :: [tok] -> GenParser tok st ()
setInput :: [tok] -> GenParser tok st ()
setInput [tok]
input =
  () () -> GenParser tok st (State tok st) -> GenParser tok st ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (State tok st -> State tok st) -> GenParser tok st (State tok st)
forall tok st.
(State tok st -> State tok st) -> GenParser tok st (State tok st)
updateParserState (\ (State [tok]
_ SourcePos
pos st
user) -> [tok] -> SourcePos -> st -> State tok st
forall tok st. [tok] -> SourcePos -> st -> State tok st
State [tok]
input SourcePos
pos st
user)

-- | Returns the full parser state as a 'State' record.
getParserState :: GenParser tok st (State tok st)
getParserState :: GenParser tok st (State tok st)
getParserState = (State tok st -> State tok st) -> GenParser tok st (State tok st)
forall tok st.
(State tok st -> State tok st) -> GenParser tok st (State tok st)
updateParserState State tok st -> State tok st
forall a. a -> a
id

-- | @setParserState st@ set the full parser state to @st@.
setParserState :: State tok st -> GenParser tok st (State tok st)
setParserState :: State tok st -> GenParser tok st (State tok st)
setParserState State tok st
st = (State tok st -> State tok st) -> GenParser tok st (State tok st)
forall tok st.
(State tok st -> State tok st) -> GenParser tok st (State tok st)
updateParserState (State tok st -> State tok st -> State tok st
forall a b. a -> b -> a
const State tok st
st)


{- ---------------------------------------------------------
Parser definition.
GenParser tok st a:
General parser for tokens of type "tok",
a user state "st" and a result type "a"
--------------------------------------------------------- -}
type Parser a = GenParser Char () a

newtype GenParser tok st a = Parser
  { GenParser tok st a -> State tok st -> Consumed (Reply tok st a)
runP :: State tok st -> Consumed (Reply tok st a) }

data Consumed a
  = Consumed a                -- input is consumed
  | Empty !a                  -- no input is consumed

data Reply tok st a
  = Ok !a !(State tok st) ParseError    -- parsing succeeded with "a"
  | Error ParseError                    -- parsing failed

data State tok st = State
  { State tok st -> [tok]
stateInput :: [tok]
  , State tok st -> SourcePos
statePos :: !SourcePos
  , State tok st -> st
stateUser :: !st }

{- ---------------------------------------------------------
run a parser
--------------------------------------------------------- -}
parseFromFile :: Parser a -> SourceName -> IO (Either ParseError a)
parseFromFile :: Parser a -> String -> IO (Either ParseError a)
parseFromFile Parser a
p String
fname = do
  String
input <- String -> IO String
readFile String
fname
  Either ParseError a -> IO (Either ParseError a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Either ParseError a -> IO (Either ParseError a))
-> Either ParseError a -> IO (Either ParseError a)
forall a b. (a -> b) -> a -> b
$ Parser a -> String -> String -> Either ParseError a
forall tok a.
GenParser tok () a -> String -> [tok] -> Either ParseError a
parse Parser a
p String
fname String
input

{- | The expression @parseTest p input@ applies a parser @p@ against
input @input@ and prints the result to stdout. Used for testing
parsers. -}
parseTest :: Show a => GenParser tok () a -> [tok] -> IO ()
parseTest :: GenParser tok () a -> [tok] -> IO ()
parseTest GenParser tok () a
p [tok]
input = case GenParser tok () a -> () -> String -> [tok] -> Either ParseError a
forall tok st a.
GenParser tok st a -> st -> String -> [tok] -> Either ParseError a
runParser GenParser tok () a
p () String
"" [tok]
input of
  Left ParseError
err -> String -> IO ()
putStr String
"parse error at " IO () -> IO () -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParseError -> IO ()
forall a. Show a => a -> IO ()
print ParseError
err
  Right a
x -> a -> IO ()
forall a. Show a => a -> IO ()
print a
x

{- | @parse p filePath input@ runs a parser @p@ without user
state. The @filePath@ is only used in error messages and may be the
empty string. Returns either a 'ParseError' ('Left')
or a value of type @a@ ('Right').

>  main = case parse numbers "" "11, 2, 43" of
>           Left err -> print err
>           Right xs -> print (sum xs)
>
>  numbers = commaSep integer -}
parse :: GenParser tok () a -> SourceName -> [tok] -> Either ParseError a
parse :: GenParser tok () a -> String -> [tok] -> Either ParseError a
parse GenParser tok () a
p = GenParser tok () a -> () -> String -> [tok] -> Either ParseError a
forall tok st a.
GenParser tok st a -> st -> String -> [tok] -> Either ParseError a
runParser GenParser tok () a
p ()

{- | The most general way to run a parser. @runParser p state filePath
input@ runs parser @p@ on the input list of tokens @input@,
obtained from source @filePath@ with the initial user state @st@.
The @filePath@ is only used in error messages and may be the empty
string. Returns either a 'ParseError' ('Left') or a
value of type @a@ ('Right').

>  parseFromFile p fname = do
>    input <- readFile fname
>    return (runParser p () fname input) -}
runParser :: GenParser tok st a -> st -> SourceName -> [tok]
  -> Either ParseError a
runParser :: GenParser tok st a -> st -> String -> [tok] -> Either ParseError a
runParser GenParser tok st a
p st
st String
name [tok]
input =
  case Consumed (Reply tok st a) -> Reply tok st a
forall p. Consumed p -> p
parserReply (Consumed (Reply tok st a) -> Reply tok st a)
-> (State tok st -> Consumed (Reply tok st a))
-> State tok st
-> Reply tok st a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenParser tok st a -> State tok st -> Consumed (Reply tok st a)
forall tok st a.
GenParser tok st a -> State tok st -> Consumed (Reply tok st a)
runP GenParser tok st a
p (State tok st -> Reply tok st a) -> State tok st -> Reply tok st a
forall a b. (a -> b) -> a -> b
$ [tok] -> SourcePos -> st -> State tok st
forall tok st. [tok] -> SourcePos -> st -> State tok st
State [tok]
input (String -> SourcePos
initialPos String
name) st
st of
    Ok a
x State tok st
_ ParseError
_ -> a -> Either ParseError a
forall a b. b -> Either a b
Right a
x
    Error ParseError
err -> ParseError -> Either ParseError a
forall a b. a -> Either a b
Left ParseError
err

parserReply :: Consumed p -> p
parserReply :: Consumed p -> p
parserReply Consumed p
result = case Consumed p
result of
  Consumed p
reply -> p
reply
  Empty p
reply -> p
reply


{- ---------------------------------------------------------
Functor: fmap
--------------------------------------------------------- -}
instance Functor (GenParser tok st) where
  fmap :: (a -> b) -> GenParser tok st a -> GenParser tok st b
fmap a -> b
f GenParser tok st a
p = (a -> b) -> GenParser tok st a -> GenParser tok st b
forall a b tok st.
(a -> b) -> GenParser tok st a -> GenParser tok st b
parsecMap a -> b
f GenParser tok st a
p

parsecMap :: (a -> b) -> GenParser tok st a -> GenParser tok st b
parsecMap :: (a -> b) -> GenParser tok st a -> GenParser tok st b
parsecMap a -> b
f (Parser State tok st -> Consumed (Reply tok st a)
p) = (State tok st -> Consumed (Reply tok st b)) -> GenParser tok st b
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st b)) -> GenParser tok st b)
-> (State tok st -> Consumed (Reply tok st b))
-> GenParser tok st b
forall a b. (a -> b) -> a -> b
$ \ State tok st
state -> case State tok st -> Consumed (Reply tok st a)
p State tok st
state of
    Consumed Reply tok st a
reply -> Reply tok st b -> Consumed (Reply tok st b)
forall a. a -> Consumed a
Consumed (Reply tok st b -> Consumed (Reply tok st b))
-> Reply tok st b -> Consumed (Reply tok st b)
forall a b. (a -> b) -> a -> b
$ Reply tok st a -> Reply tok st b
forall tok st. Reply tok st a -> Reply tok st b
mapReply Reply tok st a
reply
    Empty Reply tok st a
reply -> Reply tok st b -> Consumed (Reply tok st b)
forall a. a -> Consumed a
Empty (Reply tok st b -> Consumed (Reply tok st b))
-> Reply tok st b -> Consumed (Reply tok st b)
forall a b. (a -> b) -> a -> b
$ Reply tok st a -> Reply tok st b
forall tok st. Reply tok st a -> Reply tok st b
mapReply Reply tok st a
reply
  where
    mapReply :: Reply tok st a -> Reply tok st b
mapReply Reply tok st a
reply = case Reply tok st a
reply of
      Ok a
x State tok st
state ParseError
err -> let fx :: b
fx = a -> b
f a
x in b -> Reply tok st b -> Reply tok st b
seq b
fx (Reply tok st b -> Reply tok st b)
-> Reply tok st b -> Reply tok st b
forall a b. (a -> b) -> a -> b
$ b -> State tok st -> ParseError -> Reply tok st b
forall tok st a. a -> State tok st -> ParseError -> Reply tok st a
Ok b
fx State tok st
state ParseError
err
      Error ParseError
err -> ParseError -> Reply tok st b
forall tok st a. ParseError -> Reply tok st a
Error ParseError
err

{- ---------------------------------------------------------
Monad: return, sequence (>>=) and fail
--------------------------------------------------------- -}
instance Monad (GenParser tok st) where
  return :: a -> GenParser tok st a
return = a -> GenParser tok st a
forall a tok st. a -> GenParser tok st a
parsecReturn
  >>= :: GenParser tok st a
-> (a -> GenParser tok st b) -> GenParser tok st b
(>>=) = GenParser tok st a
-> (a -> GenParser tok st b) -> GenParser tok st b
forall tok st a b.
GenParser tok st a
-> (a -> GenParser tok st b) -> GenParser tok st b
parsecBind
  >> :: GenParser tok st a -> GenParser tok st b -> GenParser tok st b
(>>) = GenParser tok st a -> GenParser tok st b -> GenParser tok st b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
(*>)
#if !MIN_VERSION_base (4, 13, 0)
  fail = parsecFail
#endif

#if __GLASGOW_HASKELL__ >= 801
instance MonadFail (GenParser tok st) where
  fail :: String -> GenParser tok st a
fail = String -> GenParser tok st a
forall tok st a. String -> GenParser tok st a
parsecFail
#endif

instance Applicative (GenParser tok st) where
  pure :: a -> GenParser tok st a
pure = a -> GenParser tok st a
forall a tok st. a -> GenParser tok st a
parsecReturn
  <*> :: GenParser tok st (a -> b)
-> GenParser tok st a -> GenParser tok st b
(<*>) = GenParser tok st (a -> b)
-> GenParser tok st a -> GenParser tok st b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap
  GenParser tok st a
p1 *> :: GenParser tok st a -> GenParser tok st b -> GenParser tok st b
*> GenParser tok st b
p2 = GenParser tok st a
p1 GenParser tok st a
-> (a -> GenParser tok st b) -> GenParser tok st b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= GenParser tok st b -> a -> GenParser tok st b
forall a b. a -> b -> a
const GenParser tok st b
p2
  GenParser tok st a
p1 <* :: GenParser tok st a -> GenParser tok st b -> GenParser tok st a
<* GenParser tok st b
p2 = GenParser tok st a
p1 GenParser tok st a
-> (a -> GenParser tok st a) -> GenParser tok st a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (a -> GenParser tok st b -> GenParser tok st a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ GenParser tok st b
p2)

parsecReturn :: a -> GenParser tok st a
parsecReturn :: a -> GenParser tok st a
parsecReturn a
x = (State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a)
-> (State tok st -> Consumed (Reply tok st a))
-> GenParser tok st a
forall a b. (a -> b) -> a -> b
$ \ State tok st
state -> Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (Reply tok st a -> Consumed (Reply tok st a))
-> (ParseError -> Reply tok st a)
-> ParseError
-> Consumed (Reply tok st a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> State tok st -> ParseError -> Reply tok st a
forall tok st a. a -> State tok st -> ParseError -> Reply tok st a
Ok a
x State tok st
state (ParseError -> Consumed (Reply tok st a))
-> ParseError -> Consumed (Reply tok st a)
forall a b. (a -> b) -> a -> b
$ State tok st -> ParseError
forall tok st. State tok st -> ParseError
unknownError State tok st
state

parsecBind :: GenParser tok st a -> (a -> GenParser tok st b)
  -> GenParser tok st b
parsecBind :: GenParser tok st a
-> (a -> GenParser tok st b) -> GenParser tok st b
parsecBind (Parser State tok st -> Consumed (Reply tok st a)
p) a -> GenParser tok st b
f = (State tok st -> Consumed (Reply tok st b)) -> GenParser tok st b
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st b)) -> GenParser tok st b)
-> (State tok st -> Consumed (Reply tok st b))
-> GenParser tok st b
forall a b. (a -> b) -> a -> b
$ \ State tok st
state -> case State tok st -> Consumed (Reply tok st a)
p State tok st
state of
  Consumed Reply tok st a
reply1 -> Reply tok st b -> Consumed (Reply tok st b)
forall a. a -> Consumed a
Consumed (Reply tok st b -> Consumed (Reply tok st b))
-> Reply tok st b -> Consumed (Reply tok st b)
forall a b. (a -> b) -> a -> b
$ case Reply tok st a
reply1 of
    Ok a
x State tok st
state1 ParseError
err1 -> case GenParser tok st b -> State tok st -> Consumed (Reply tok st b)
forall tok st a.
GenParser tok st a -> State tok st -> Consumed (Reply tok st a)
runP (a -> GenParser tok st b
f a
x) State tok st
state1 of
      Empty Reply tok st b
reply2 -> ParseError -> Reply tok st b -> Reply tok st b
forall tok st a. ParseError -> Reply tok st a -> Reply tok st a
mergeErrorReply ParseError
err1 Reply tok st b
reply2
      Consumed Reply tok st b
reply2 -> Reply tok st b
reply2
    Error ParseError
err1 -> ParseError -> Reply tok st b
forall tok st a. ParseError -> Reply tok st a
Error ParseError
err1
  Empty Reply tok st a
reply1 -> case Reply tok st a
reply1 of
    Ok a
x State tok st
state1 ParseError
err1 -> case GenParser tok st b -> State tok st -> Consumed (Reply tok st b)
forall tok st a.
GenParser tok st a -> State tok st -> Consumed (Reply tok st a)
runP (a -> GenParser tok st b
f a
x) State tok st
state1 of
      Empty Reply tok st b
reply2 -> Reply tok st b -> Consumed (Reply tok st b)
forall a. a -> Consumed a
Empty (ParseError -> Reply tok st b -> Reply tok st b
forall tok st a. ParseError -> Reply tok st a -> Reply tok st a
mergeErrorReply ParseError
err1 Reply tok st b
reply2)
      Consumed (Reply tok st b)
other -> Consumed (Reply tok st b)
other
    Error ParseError
err1 -> Reply tok st b -> Consumed (Reply tok st b)
forall a. a -> Consumed a
Empty (ParseError -> Reply tok st b
forall tok st a. ParseError -> Reply tok st a
Error ParseError
err1)

mergeErrorReply :: ParseError -> Reply tok st a -> Reply tok st a
mergeErrorReply :: ParseError -> Reply tok st a -> Reply tok st a
mergeErrorReply ParseError
err1 Reply tok st a
reply = case Reply tok st a
reply of
  Ok a
x State tok st
state ParseError
err2 -> a -> State tok st -> ParseError -> Reply tok st a
forall tok st a. a -> State tok st -> ParseError -> Reply tok st a
Ok a
x State tok st
state (ParseError -> ParseError -> ParseError
mergeError ParseError
err1 ParseError
err2)
  Error ParseError
err2 -> ParseError -> Reply tok st a
forall tok st a. ParseError -> Reply tok st a
Error (ParseError -> ParseError -> ParseError
mergeError ParseError
err1 ParseError
err2)

parsecFail :: String -> GenParser tok st a
parsecFail :: String -> GenParser tok st a
parsecFail String
msg =
  (State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a)
-> (State tok st -> Consumed (Reply tok st a))
-> GenParser tok st a
forall a b. (a -> b) -> a -> b
$ Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (Reply tok st a -> Consumed (Reply tok st a))
-> (State tok st -> Reply tok st a)
-> State tok st
-> Consumed (Reply tok st a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError -> Reply tok st a
forall tok st a. ParseError -> Reply tok st a
Error (ParseError -> Reply tok st a)
-> (State tok st -> ParseError) -> State tok st -> Reply tok st a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Message -> SourcePos -> ParseError
newErrorMessage (String -> Message
Message String
msg) (SourcePos -> ParseError)
-> (State tok st -> SourcePos) -> State tok st -> ParseError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State tok st -> SourcePos
forall tok st. State tok st -> SourcePos
statePos

{- ---------------------------------------------------------
MonadPlus: alternative (mplus) and mzero
--------------------------------------------------------- -}
instance MonadPlus (GenParser tok st) where
  mzero :: GenParser tok st a
mzero = GenParser tok st a
forall tok st a. GenParser tok st a
parsecZero
  mplus :: GenParser tok st a -> GenParser tok st a -> GenParser tok st a
mplus GenParser tok st a
p1 GenParser tok st a
p2 = GenParser tok st a -> GenParser tok st a -> GenParser tok st a
forall tok st a.
GenParser tok st a -> GenParser tok st a -> GenParser tok st a
parsecPlus GenParser tok st a
p1 GenParser tok st a
p2

instance Alternative (GenParser tok st) where
  <|> :: GenParser tok st a -> GenParser tok st a -> GenParser tok st a
(<|>) = GenParser tok st a -> GenParser tok st a -> GenParser tok st a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus
  empty :: GenParser tok st a
empty = GenParser tok st a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
  many :: GenParser tok st a -> GenParser tok st [a]
many = GenParser tok st a -> GenParser tok st [a]
forall tok st a. GenParser tok st a -> GenParser tok st [a]
manyAux

pzero :: GenParser tok st a
pzero :: GenParser tok st a
pzero = GenParser tok st a
forall tok st a. GenParser tok st a
parsecZero

{- | @parsecZero@ always fails without consuming any input. @parsecZero@ is
defined equal to the 'mzero' member of the 'MonadPlus' class and to the
'Control.Applicative.empty' member of the 'Control.Applicative.Applicative'
class. -}
parsecZero :: GenParser tok st a
parsecZero :: GenParser tok st a
parsecZero = (State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a)
-> (State tok st -> Consumed (Reply tok st a))
-> GenParser tok st a
forall a b. (a -> b) -> a -> b
$ Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (Reply tok st a -> Consumed (Reply tok st a))
-> (State tok st -> Reply tok st a)
-> State tok st
-> Consumed (Reply tok st a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError -> Reply tok st a
forall tok st a. ParseError -> Reply tok st a
Error (ParseError -> Reply tok st a)
-> (State tok st -> ParseError) -> State tok st -> Reply tok st a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State tok st -> ParseError
forall tok st. State tok st -> ParseError
unknownError

parsecPlus :: GenParser tok st a -> GenParser tok st a -> GenParser tok st a
parsecPlus :: GenParser tok st a -> GenParser tok st a -> GenParser tok st a
parsecPlus (Parser State tok st -> Consumed (Reply tok st a)
p1) (Parser State tok st -> Consumed (Reply tok st a)
p2) = (State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a)
-> (State tok st -> Consumed (Reply tok st a))
-> GenParser tok st a
forall a b. (a -> b) -> a -> b
$ \ State tok st
state -> case State tok st -> Consumed (Reply tok st a)
p1 State tok st
state of
  Empty (Error ParseError
err) -> case State tok st -> Consumed (Reply tok st a)
p2 State tok st
state of
    Empty Reply tok st a
reply -> Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (Reply tok st a -> Consumed (Reply tok st a))
-> Reply tok st a -> Consumed (Reply tok st a)
forall a b. (a -> b) -> a -> b
$ ParseError -> Reply tok st a -> Reply tok st a
forall tok st a. ParseError -> Reply tok st a -> Reply tok st a
mergeErrorReply ParseError
err Reply tok st a
reply
    Consumed (Reply tok st a)
consumed -> Consumed (Reply tok st a)
consumed
  Consumed (Reply tok st a)
other -> Consumed (Reply tok st a)
other

{- | The parser @try p@ behaves like parser @p@, except that it
pretends that it hasn't consumed any input when an error occurs.

This combinator is used whenever arbitrary look ahead is needed.
Since it pretends that it hasn't consumed any input when @p@ fails,
the ('<|>') combinator will try its second alternative even when the
first parser failed while consuming input.

The @try@ combinator can for example be used to distinguish
identifiers and reserved words. Both reserved words and identifiers
are a sequence of letters. Whenever we expect a certain reserved
word where we can also expect an identifier we have to use the @try@
combinator. Suppose we write:

>  expr        = letExpr <|> identifier <?> "expression"
>
>  letExpr     = string "let" *> ...
>  identifier  = many1 letter

If the user writes \"lexical\", the parser fails with: @unexpected
\'x\', expecting \'t\' in \"let\"@. Indeed, since the ('<|>') combinator
only tries alternatives when the first alternative hasn't consumed
input, the @identifier@ parser is never tried (because the prefix
\"le\" of the @string \"let\"@ parser is already consumed). The
right behaviour can be obtained by adding the @try@ combinator:

>  expr        = letExpr <|> identifier <?> "expression"
>
>  letExpr     = try (string "let") *>
>  identifier  = many1 letter -}
try :: GenParser tok st a -> GenParser tok st a
try :: GenParser tok st a -> GenParser tok st a
try (Parser State tok st -> Consumed (Reply tok st a)
p) = (State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a)
-> (State tok st -> Consumed (Reply tok st a))
-> GenParser tok st a
forall a b. (a -> b) -> a -> b
$ \ State tok st
state -> case State tok st -> Consumed (Reply tok st a)
p State tok st
state of
  Consumed (Error ParseError
err) -> Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (ParseError -> Reply tok st a
forall tok st a. ParseError -> Reply tok st a
Error ParseError
err)
  Consumed Reply tok st a
ok -> Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Consumed Reply tok st a
ok    -- was: Empty ok
  Consumed (Reply tok st a)
mty -> Consumed (Reply tok st a)
mty

-- | @lookAhead p@ parses @p@ without consuming any input.
lookAhead :: GenParser tok st a -> GenParser tok st a
lookAhead :: GenParser tok st a -> GenParser tok st a
lookAhead GenParser tok st a
p = (State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a)
-> (State tok st -> Consumed (Reply tok st a))
-> GenParser tok st a
forall a b. (a -> b) -> a -> b
$ \ State tok st
state -> case GenParser tok st a -> State tok st -> Consumed (Reply tok st a)
forall tok st a.
GenParser tok st a -> State tok st -> Consumed (Reply tok st a)
runP GenParser tok st a
p State tok st
state of
  Consumed (Ok a
r State tok st
_ ParseError
_) -> Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (Reply tok st a -> Consumed (Reply tok st a))
-> Reply tok st a -> Consumed (Reply tok st a)
forall a b. (a -> b) -> a -> b
$ a -> State tok st -> ParseError -> Reply tok st a
forall tok st a. a -> State tok st -> ParseError -> Reply tok st a
Ok a
r State tok st
state (ParseError -> Reply tok st a) -> ParseError -> Reply tok st a
forall a b. (a -> b) -> a -> b
$ State tok st -> ParseError
forall tok st. State tok st -> ParseError
unknownError State tok st
state
  Consumed (Reply tok st a)
reply -> Consumed (Reply tok st a)
reply

{- | The parser @token showTok posFromTok testTok@ accepts a token @t@
with result @x@ when the function @testTok t@ returns @'Just' x@. The
source position of the @t@ should be returned by @posFromTok t@ and
the token can be shown using @showTok t@.

This combinator is expressed in terms of 'tokenPrim'.
It is used to accept user defined token streams. For example,
suppose that we have a stream of basic tokens tupled with source
positions. We can than define a parser that accepts single tokens as:

>  mytoken x
>    = token showTok posFromTok testTok
>    where
>      showTok (pos,t)     = show t
>      posFromTok (pos,t)  = pos
>      testTok (pos,t)     = if x == t then Just t else Nothing -}
token :: (tok -> String) -> (tok -> SourcePos) -> (tok -> Maybe a)
  -> GenParser tok st a
token :: (tok -> String)
-> (tok -> SourcePos) -> (tok -> Maybe a) -> GenParser tok st a
token tok -> String
shw tok -> SourcePos
tokpos = (tok -> String)
-> (SourcePos -> tok -> [tok] -> SourcePos)
-> (tok -> Maybe a)
-> GenParser tok st a
forall tok a st.
(tok -> String)
-> (SourcePos -> tok -> [tok] -> SourcePos)
-> (tok -> Maybe a)
-> GenParser tok st a
tokenPrim tok -> String
shw SourcePos -> tok -> [tok] -> SourcePos
forall p. p -> tok -> [tok] -> SourcePos
nextpos where
    nextpos :: p -> tok -> [tok] -> SourcePos
nextpos p
_ tok
tok [tok]
ts = case [tok]
ts of
      tok
t : [tok]
_ -> tok -> SourcePos
tokpos tok
t
      [tok]
_ -> tok -> SourcePos
tokpos tok
tok

{- | The parser @token showTok nextPos testTok@ accepts a token @t@
with result @x@ when the function @testTok t@ returns @'Just' x@. The
token can be shown using @showTok t@. The position of the /next/
token should be returned when @nextPos@ is called with the current
source position @pos@, the current token @t@ and the rest of the
tokens @toks@, @nextPos pos t toks@.

This is the most primitive combinator for accepting tokens. For
example, the 'Text.Parsec.Char.char' parser could be implemented as:

>  char c
>    = tokenPrim showChar nextPos testChar
>    where
>      showChar x        = "'" ++ x ++ "'"
>      testChar x        = if x == c then Just x else Nothing
>      nextPos pos x xs  = updatePosChar pos x -}
tokenPrim :: (tok -> String) -> (SourcePos -> tok -> [tok] -> SourcePos)
  -> (tok -> Maybe a) -> GenParser tok st a
tokenPrim :: (tok -> String)
-> (SourcePos -> tok -> [tok] -> SourcePos)
-> (tok -> Maybe a)
-> GenParser tok st a
tokenPrim tok -> String
shw SourcePos -> tok -> [tok] -> SourcePos
nextpos = (tok -> String)
-> (SourcePos -> tok -> [tok] -> SourcePos)
-> Maybe (SourcePos -> tok -> [tok] -> st -> st)
-> (tok -> Maybe a)
-> GenParser tok st a
forall tok st a.
(tok -> String)
-> (SourcePos -> tok -> [tok] -> SourcePos)
-> Maybe (SourcePos -> tok -> [tok] -> st -> st)
-> (tok -> Maybe a)
-> GenParser tok st a
tokenPrimEx tok -> String
shw SourcePos -> tok -> [tok] -> SourcePos
nextpos Maybe (SourcePos -> tok -> [tok] -> st -> st)
forall a. Maybe a
Nothing

{- | The most primitive token recogniser. The expression
@tokenPrimEx show nextpos mbnextstate test@, recognises tokens when @test@
returns @Just x@ (and returns the value @x@). Tokens are shown in error
messages using @show@. The position is calculated using @nextpos@, and finally,
@mbnextstate@, can hold a function that updates the user state on every token
recognised (nice to count tokens :-).
The function is packed into a 'Maybe' type for performance reasons. -}
tokenPrimEx :: (tok -> String) -> (SourcePos -> tok -> [tok] -> SourcePos)
  -> Maybe (SourcePos -> tok -> [tok] -> st -> st) -> (tok -> Maybe a)
  -> GenParser tok st a
tokenPrimEx :: (tok -> String)
-> (SourcePos -> tok -> [tok] -> SourcePos)
-> Maybe (SourcePos -> tok -> [tok] -> st -> st)
-> (tok -> Maybe a)
-> GenParser tok st a
tokenPrimEx tok -> String
shw SourcePos -> tok -> [tok] -> SourcePos
nextpos Maybe (SourcePos -> tok -> [tok] -> st -> st)
mbNextState tok -> Maybe a
test = case Maybe (SourcePos -> tok -> [tok] -> st -> st)
mbNextState of
  Maybe (SourcePos -> tok -> [tok] -> st -> st)
Nothing -> (State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a)
-> (State tok st -> Consumed (Reply tok st a))
-> GenParser tok st a
forall a b. (a -> b) -> a -> b
$ \ (State [tok]
input SourcePos
pos st
user) -> case [tok]
input of
    tok
c : [tok]
cs -> case tok -> Maybe a
test tok
c of
      Just a
x -> let
        newpos :: SourcePos
newpos = SourcePos -> tok -> [tok] -> SourcePos
nextpos SourcePos
pos tok
c [tok]
cs
        newstate :: State tok st
newstate = [tok] -> SourcePos -> st -> State tok st
forall tok st. [tok] -> SourcePos -> st -> State tok st
State [tok]
cs SourcePos
newpos st
user
        in SourcePos -> Consumed (Reply tok st a) -> Consumed (Reply tok st a)
seq SourcePos
newpos (Consumed (Reply tok st a) -> Consumed (Reply tok st a))
-> (ParseError -> Consumed (Reply tok st a))
-> ParseError
-> Consumed (Reply tok st a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State tok st
-> Consumed (Reply tok st a) -> Consumed (Reply tok st a)
seq State tok st
newstate (Consumed (Reply tok st a) -> Consumed (Reply tok st a))
-> (ParseError -> Consumed (Reply tok st a))
-> ParseError
-> Consumed (Reply tok st a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
              Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Consumed (Reply tok st a -> Consumed (Reply tok st a))
-> (ParseError -> Reply tok st a)
-> ParseError
-> Consumed (Reply tok st a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> State tok st -> ParseError -> Reply tok st a
forall tok st a. a -> State tok st -> ParseError -> Reply tok st a
Ok a
x State tok st
newstate (ParseError -> Consumed (Reply tok st a))
-> ParseError -> Consumed (Reply tok st a)
forall a b. (a -> b) -> a -> b
$ SourcePos -> ParseError
newErrorUnknown SourcePos
newpos
      Maybe a
Nothing -> Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (String -> SourcePos -> Reply tok st a
forall tok st a. String -> SourcePos -> Reply tok st a
sysUnExpectError (tok -> String
shw tok
c) SourcePos
pos)
    [] -> Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (String -> SourcePos -> Reply tok st a
forall tok st a. String -> SourcePos -> Reply tok st a
sysUnExpectError String
"" SourcePos
pos)
  Just SourcePos -> tok -> [tok] -> st -> st
nextState -> (State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a)
-> (State tok st -> Consumed (Reply tok st a))
-> GenParser tok st a
forall a b. (a -> b) -> a -> b
$ \ (State [tok]
input SourcePos
pos st
user) -> case [tok]
input of
    tok
c : [tok]
cs -> case tok -> Maybe a
test tok
c of
      Just a
x -> let
        newpos :: SourcePos
newpos = SourcePos -> tok -> [tok] -> SourcePos
nextpos SourcePos
pos tok
c [tok]
cs
        newuser :: st
newuser = SourcePos -> tok -> [tok] -> st -> st
nextState SourcePos
pos tok
c [tok]
cs st
user
        newstate :: State tok st
newstate = [tok] -> SourcePos -> st -> State tok st
forall tok st. [tok] -> SourcePos -> st -> State tok st
State [tok]
cs SourcePos
newpos st
newuser
        in SourcePos -> Consumed (Reply tok st a) -> Consumed (Reply tok st a)
seq SourcePos
newpos (Consumed (Reply tok st a) -> Consumed (Reply tok st a))
-> (ParseError -> Consumed (Reply tok st a))
-> ParseError
-> Consumed (Reply tok st a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State tok st
-> Consumed (Reply tok st a) -> Consumed (Reply tok st a)
seq State tok st
newstate (Consumed (Reply tok st a) -> Consumed (Reply tok st a))
-> (ParseError -> Consumed (Reply tok st a))
-> ParseError
-> Consumed (Reply tok st a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
              Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Consumed (Reply tok st a -> Consumed (Reply tok st a))
-> (ParseError -> Reply tok st a)
-> ParseError
-> Consumed (Reply tok st a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> State tok st -> ParseError -> Reply tok st a
forall tok st a. a -> State tok st -> ParseError -> Reply tok st a
Ok a
x State tok st
newstate (ParseError -> Consumed (Reply tok st a))
-> ParseError -> Consumed (Reply tok st a)
forall a b. (a -> b) -> a -> b
$ SourcePos -> ParseError
newErrorUnknown SourcePos
newpos
      Maybe a
Nothing -> Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (Reply tok st a -> Consumed (Reply tok st a))
-> Reply tok st a -> Consumed (Reply tok st a)
forall a b. (a -> b) -> a -> b
$ String -> SourcePos -> Reply tok st a
forall tok st a. String -> SourcePos -> Reply tok st a
sysUnExpectError (tok -> String
shw tok
c) SourcePos
pos
    [] -> Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (Reply tok st a -> Consumed (Reply tok st a))
-> Reply tok st a -> Consumed (Reply tok st a)
forall a b. (a -> b) -> a -> b
$ String -> SourcePos -> Reply tok st a
forall tok st a. String -> SourcePos -> Reply tok st a
sysUnExpectError String
"" SourcePos
pos

label :: GenParser tok st a -> String -> GenParser tok st a
label :: GenParser tok st a -> String -> GenParser tok st a
label GenParser tok st a
p String
msg = GenParser tok st a -> [String] -> GenParser tok st a
forall tok st a.
GenParser tok st a -> [String] -> GenParser tok st a
labels GenParser tok st a
p [String
msg]

labels :: GenParser tok st a -> [String] -> GenParser tok st a
labels :: GenParser tok st a -> [String] -> GenParser tok st a
labels (Parser State tok st -> Consumed (Reply tok st a)
p) [String]
msgs = (State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a)
-> (State tok st -> Consumed (Reply tok st a))
-> GenParser tok st a
forall a b. (a -> b) -> a -> b
$ \ State tok st
state -> case State tok st -> Consumed (Reply tok st a)
p State tok st
state of
  Empty Reply tok st a
reply -> Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (Reply tok st a -> Consumed (Reply tok st a))
-> Reply tok st a -> Consumed (Reply tok st a)
forall a b. (a -> b) -> a -> b
$ case Reply tok st a
reply of
    Error ParseError
err -> ParseError -> Reply tok st a
forall tok st a. ParseError -> Reply tok st a
Error (ParseError -> Reply tok st a) -> ParseError -> Reply tok st a
forall a b. (a -> b) -> a -> b
$ ParseError -> [String] -> ParseError
setExpectErrors ParseError
err [String]
msgs
    Ok a
x State tok st
state1 ParseError
err -> if ParseError -> Bool
errorIsUnknown ParseError
err then Reply tok st a
reply else
      a -> State tok st -> ParseError -> Reply tok st a
forall tok st a. a -> State tok st -> ParseError -> Reply tok st a
Ok a
x State tok st
state1 (ParseError -> Reply tok st a) -> ParseError -> Reply tok st a
forall a b. (a -> b) -> a -> b
$ ParseError -> [String] -> ParseError
setExpectErrors ParseError
err [String]
msgs
  Consumed (Reply tok st a)
other -> Consumed (Reply tok st a)
other

-- | @updateParserState f@ applies function @f@ to the parser state.
updateParserState :: (State tok st -> State tok st)
  -> GenParser tok st (State tok st)
updateParserState :: (State tok st -> State tok st) -> GenParser tok st (State tok st)
updateParserState State tok st -> State tok st
f = (State tok st -> Consumed (Reply tok st (State tok st)))
-> GenParser tok st (State tok st)
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st (State tok st)))
 -> GenParser tok st (State tok st))
-> (State tok st -> Consumed (Reply tok st (State tok st)))
-> GenParser tok st (State tok st)
forall a b. (a -> b) -> a -> b
$ \ State tok st
state -> let newstate :: State tok st
newstate = State tok st -> State tok st
f State tok st
state in
  Reply tok st (State tok st)
-> Consumed (Reply tok st (State tok st))
forall a. a -> Consumed a
Empty (Reply tok st (State tok st)
 -> Consumed (Reply tok st (State tok st)))
-> (ParseError -> Reply tok st (State tok st))
-> ParseError
-> Consumed (Reply tok st (State tok st))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State tok st
-> State tok st -> ParseError -> Reply tok st (State tok st)
forall tok st a. a -> State tok st -> ParseError -> Reply tok st a
Ok State tok st
state State tok st
newstate (ParseError -> Consumed (Reply tok st (State tok st)))
-> ParseError -> Consumed (Reply tok st (State tok st))
forall a b. (a -> b) -> a -> b
$ State tok st -> ParseError
forall tok st. State tok st -> ParseError
unknownError State tok st
newstate

{- | The parser @unexpected msg@ always fails with an unexpected error
message @msg@ without consuming any input.

The parsers @fail@, ('<?>') and @unexpected@ are the three parsers
used to generate error messages. Of these, only ('<?>') is commonly
used. For an example of the use of @unexpected@, see the definition
of 'Text.ParserCombinators.Parsec.Combinator.notFollowedBy'. -}
unexpected :: String -> GenParser tok st a
unexpected :: String -> GenParser tok st a
unexpected String
msg =
  (State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a)
-> (State tok st -> Consumed (Reply tok st a))
-> GenParser tok st a
forall a b. (a -> b) -> a -> b
$ Reply tok st a -> Consumed (Reply tok st a)
forall a. a -> Consumed a
Empty (Reply tok st a -> Consumed (Reply tok st a))
-> (State tok st -> Reply tok st a)
-> State tok st
-> Consumed (Reply tok st a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError -> Reply tok st a
forall tok st a. ParseError -> Reply tok st a
Error (ParseError -> Reply tok st a)
-> (State tok st -> ParseError) -> State tok st -> Reply tok st a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Message -> SourcePos -> ParseError
newErrorMessage (String -> Message
UnExpect String
msg) (SourcePos -> ParseError)
-> (State tok st -> SourcePos) -> State tok st -> ParseError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State tok st -> SourcePos
forall tok st. State tok st -> SourcePos
statePos

setExpectErrors :: ParseError -> [String] -> ParseError
setExpectErrors :: ParseError -> [String] -> ParseError
setExpectErrors ParseError
err [String]
ms = case [String]
ms of
  [] -> Message -> ParseError -> ParseError
setErrorMessage (String -> Message
Expect String
"") ParseError
err
  [String
msg] -> Message -> ParseError -> ParseError
setErrorMessage (String -> Message
Expect String
msg) ParseError
err
  String
msg : [String]
msgs -> (String -> ParseError -> ParseError)
-> ParseError -> [String] -> ParseError
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (Message -> ParseError -> ParseError
addErrorMessage (Message -> ParseError -> ParseError)
-> (String -> Message) -> String -> ParseError -> ParseError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Message
Expect)
    (Message -> ParseError -> ParseError
setErrorMessage (String -> Message
Expect String
msg) ParseError
err) [String]
msgs

sysUnExpectError :: String -> SourcePos -> Reply tok st a
sysUnExpectError :: String -> SourcePos -> Reply tok st a
sysUnExpectError String
msg = ParseError -> Reply tok st a
forall tok st a. ParseError -> Reply tok st a
Error (ParseError -> Reply tok st a)
-> (SourcePos -> ParseError) -> SourcePos -> Reply tok st a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Message -> SourcePos -> ParseError
newErrorMessage (String -> Message
SysUnExpect String
msg)

unknownError :: State tok st -> ParseError
unknownError :: State tok st -> ParseError
unknownError = SourcePos -> ParseError
newErrorUnknown (SourcePos -> ParseError)
-> (State tok st -> SourcePos) -> State tok st -> ParseError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State tok st -> SourcePos
forall tok st. State tok st -> SourcePos
statePos

{- ---------------------------------------------------------
Parsers unfolded for space:
if many and skipMany are not defined as primitives,
they will overflow the stack on large inputs
--------------------------------------------------------- -}

{- | @manyAux p@ applies the parser @p@ /zero/ or more times. Returns a
list of the returned values of @p@.

>  identifier = do
>   c <- letter
>   cs <- many (alphaNum <|> char '_')
>   return (c : cs) -}
manyAux :: GenParser tok st a -> GenParser tok st [a]
manyAux :: GenParser tok st a -> GenParser tok st [a]
manyAux GenParser tok st a
p = do
  [a]
xs <- (a -> [a] -> [a]) -> GenParser tok st a -> GenParser tok st [a]
forall a tok st.
(a -> [a] -> [a]) -> GenParser tok st a -> GenParser tok st [a]
manyAccum (:) GenParser tok st a
p
  [a] -> GenParser tok st [a]
forall (m :: * -> *) a. Monad m => a -> m a
return ([a] -> [a]
forall a. [a] -> [a]
reverse [a]
xs)

{- | @skipMany p@ applies the parser @p@ /zero/ or more times, skipping
its result.

>  spaces = skipMany space -}
skipMany :: GenParser tok st a -> GenParser tok st ()
skipMany :: GenParser tok st a -> GenParser tok st ()
skipMany GenParser tok st a
p = () () -> GenParser tok st [a] -> GenParser tok st ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (a -> [a] -> [a]) -> GenParser tok st a -> GenParser tok st [a]
forall a tok st.
(a -> [a] -> [a]) -> GenParser tok st a -> GenParser tok st [a]
manyAccum (\ a
_ [a]
_ -> []) GenParser tok st a
p

manyAccum :: (a -> [a] -> [a]) -> GenParser tok st a -> GenParser tok st [a]
manyAccum :: (a -> [a] -> [a]) -> GenParser tok st a -> GenParser tok st [a]
manyAccum a -> [a] -> [a]
accum (Parser State tok st -> Consumed (Reply tok st a)
p) = (State tok st -> Consumed (Reply tok st [a]))
-> GenParser tok st [a]
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st [a]))
 -> GenParser tok st [a])
-> (State tok st -> Consumed (Reply tok st [a]))
-> GenParser tok st [a]
forall a b. (a -> b) -> a -> b
$ \ State tok st
state -> let
  errMty :: a
errMty = String -> a
forall a. HasCallStack => String -> a
error (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ String
"Text.ParserCombinators.Parsec.Prim.many: combinator "
    String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"'many' is applied to a parser that accepts an empty string."
  walk :: [a]
-> State tok st -> Consumed (Reply tok st a) -> Reply tok st [a]
walk [a]
xs State tok st
st Consumed (Reply tok st a)
r = case Consumed (Reply tok st a)
r of
    Empty (Error ParseError
err) -> [a] -> State tok st -> ParseError -> Reply tok st [a]
forall tok st a. a -> State tok st -> ParseError -> Reply tok st a
Ok [a]
xs State tok st
st ParseError
err
    Empty Reply tok st a
_ -> Reply tok st [a]
forall a. a
errMty
    Consumed (Error ParseError
err) -> ParseError -> Reply tok st [a]
forall tok st a. ParseError -> Reply tok st a
Error ParseError
err
    Consumed (Ok a
x State tok st
state' ParseError
_) -> let ys :: [a]
ys = a -> [a] -> [a]
accum a
x [a]
xs in
      [a] -> Reply tok st [a] -> Reply tok st [a]
seq [a]
ys (Reply tok st [a] -> Reply tok st [a])
-> (Consumed (Reply tok st a) -> Reply tok st [a])
-> Consumed (Reply tok st a)
-> Reply tok st [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a]
-> State tok st -> Consumed (Reply tok st a) -> Reply tok st [a]
walk [a]
ys State tok st
state' (Consumed (Reply tok st a) -> Reply tok st [a])
-> Consumed (Reply tok st a) -> Reply tok st [a]
forall a b. (a -> b) -> a -> b
$ State tok st -> Consumed (Reply tok st a)
p State tok st
state'
  in case State tok st -> Consumed (Reply tok st a)
p State tok st
state of
  Empty Reply tok st a
reply -> case Reply tok st a
reply of
    Ok {} -> Consumed (Reply tok st [a])
forall a. a
errMty
    Error ParseError
err -> Reply tok st [a] -> Consumed (Reply tok st [a])
forall a. a -> Consumed a
Empty ([a] -> State tok st -> ParseError -> Reply tok st [a]
forall tok st a. a -> State tok st -> ParseError -> Reply tok st a
Ok [] State tok st
state ParseError
err)
  Consumed (Reply tok st a)
consumed -> Reply tok st [a] -> Consumed (Reply tok st [a])
forall a. a -> Consumed a
Consumed (Reply tok st [a] -> Consumed (Reply tok st [a]))
-> Reply tok st [a] -> Consumed (Reply tok st [a])
forall a b. (a -> b) -> a -> b
$ [a]
-> State tok st -> Consumed (Reply tok st a) -> Reply tok st [a]
walk [] State tok st
state Consumed (Reply tok st a)
consumed

{- ---------------------------------------------------------
Parsers unfolded for speed:
tokens
--------------------------------------------------------- -}

{- specification of @tokens@:
tokens showss nextposs s
  = scan s
  where
    scan []       = return s
    scan (c:cs)   = do{ token show nextpos c <?> shows s; scan cs }

    show c        = shows [c]
    nextpos pos c = nextposs pos [c]
-}

tokens :: Eq tok => ([tok] -> String) -> (SourcePos -> [tok] -> SourcePos)
  -> [tok] -> GenParser tok st [tok]
tokens :: ([tok] -> String)
-> (SourcePos -> [tok] -> SourcePos)
-> [tok]
-> GenParser tok st [tok]
tokens [tok] -> String
shws SourcePos -> [tok] -> SourcePos
nextposs [tok]
s = (State tok st -> Consumed (Reply tok st [tok]))
-> GenParser tok st [tok]
forall tok st a.
(State tok st -> Consumed (Reply tok st a)) -> GenParser tok st a
Parser ((State tok st -> Consumed (Reply tok st [tok]))
 -> GenParser tok st [tok])
-> (State tok st -> Consumed (Reply tok st [tok]))
-> GenParser tok st [tok]
forall a b. (a -> b) -> a -> b
$ \ (State [tok]
input SourcePos
pos st
user) -> let
  ok :: [tok] -> Reply tok st [tok]
ok [tok]
cs = let
    newpos :: SourcePos
newpos = SourcePos -> [tok] -> SourcePos
nextposs SourcePos
pos [tok]
s
    newstate :: State tok st
newstate = [tok] -> SourcePos -> st -> State tok st
forall tok st. [tok] -> SourcePos -> st -> State tok st
State [tok]
cs SourcePos
newpos st
user
    in SourcePos -> Reply tok st [tok] -> Reply tok st [tok]
seq SourcePos
newpos (Reply tok st [tok] -> Reply tok st [tok])
-> (ParseError -> Reply tok st [tok])
-> ParseError
-> Reply tok st [tok]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State tok st -> Reply tok st [tok] -> Reply tok st [tok]
seq State tok st
newstate (Reply tok st [tok] -> Reply tok st [tok])
-> (ParseError -> Reply tok st [tok])
-> ParseError
-> Reply tok st [tok]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [tok] -> State tok st -> ParseError -> Reply tok st [tok]
forall tok st a. a -> State tok st -> ParseError -> Reply tok st a
Ok [tok]
s State tok st
newstate (ParseError -> Reply tok st [tok])
-> ParseError -> Reply tok st [tok]
forall a b. (a -> b) -> a -> b
$ SourcePos -> ParseError
newErrorUnknown SourcePos
newpos
  errMsg :: String -> Reply tok st a
errMsg String
m = ParseError -> Reply tok st a
forall tok st a. ParseError -> Reply tok st a
Error (ParseError -> Reply tok st a)
-> (ParseError -> ParseError) -> ParseError -> Reply tok st a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Message -> ParseError -> ParseError
setErrorMessage (String -> Message
Expect ([tok] -> String
shws [tok]
s)) (ParseError -> Reply tok st a) -> ParseError -> Reply tok st a
forall a b. (a -> b) -> a -> b
$ Message -> SourcePos -> ParseError
newErrorMessage
    (String -> Message
SysUnExpect String
m) SourcePos
pos
  errEof :: Reply tok st a
errEof = String -> Reply tok st a
forall tok st a. String -> Reply tok st a
errMsg String
""
  errExpect :: [tok] -> Reply tok st a
errExpect = String -> Reply tok st a
forall tok st a. String -> Reply tok st a
errMsg (String -> Reply tok st a)
-> ([tok] -> String) -> [tok] -> Reply tok st a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [tok] -> String
shws ([tok] -> String) -> ([tok] -> [tok]) -> [tok] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [tok] -> [tok]
forall a. [a] -> [a]
reverse
  walk :: [tok] -> [tok] -> [tok] -> Reply tok st [tok]
walk [tok]
r [tok]
xs [tok]
cs = case [tok]
xs of
    [] -> [tok] -> Reply tok st [tok]
forall tok. [tok] -> Reply tok st [tok]
ok [tok]
cs
    tok
x : [tok]
rs -> case [tok]
cs of
      [] -> [tok] -> Reply tok st [tok]
forall tok st a. [tok] -> Reply tok st a
errExpect [tok]
r
      tok
c : [tok]
ss -> if tok
x tok -> tok -> Bool
forall a. Eq a => a -> a -> Bool
== tok
c then [tok] -> [tok] -> [tok] -> Reply tok st [tok]
walk (tok
x tok -> [tok] -> [tok]
forall a. a -> [a] -> [a]
: [tok]
r) [tok]
rs [tok]
ss else [tok] -> Reply tok st [tok]
forall tok st a. [tok] -> Reply tok st a
errExpect ([tok] -> Reply tok st [tok]) -> [tok] -> Reply tok st [tok]
forall a b. (a -> b) -> a -> b
$ tok
c tok -> [tok] -> [tok]
forall a. a -> [a] -> [a]
: [tok]
r

  walk1 :: [tok] -> [tok] -> Consumed (Reply tok st [tok])
walk1 [tok]
xs [tok]
cs = case [tok]
xs of
    [] -> Reply tok st [tok] -> Consumed (Reply tok st [tok])
forall a. a -> Consumed a
Empty (Reply tok st [tok] -> Consumed (Reply tok st [tok]))
-> Reply tok st [tok] -> Consumed (Reply tok st [tok])
forall a b. (a -> b) -> a -> b
$ [tok] -> Reply tok st [tok]
forall tok. [tok] -> Reply tok st [tok]
ok [tok]
cs
    tok
x : [tok]
rs -> case [tok]
cs of
      [] -> Reply tok st [tok] -> Consumed (Reply tok st [tok])
forall a. a -> Consumed a
Empty Reply tok st [tok]
forall tok st a. Reply tok st a
errEof
      tok
c : [tok]
ss ->
        if tok
x tok -> tok -> Bool
forall a. Eq a => a -> a -> Bool
== tok
c then Reply tok st [tok] -> Consumed (Reply tok st [tok])
forall a. a -> Consumed a
Consumed (Reply tok st [tok] -> Consumed (Reply tok st [tok]))
-> Reply tok st [tok] -> Consumed (Reply tok st [tok])
forall a b. (a -> b) -> a -> b
$ [tok] -> [tok] -> [tok] -> Reply tok st [tok]
walk [tok
x] [tok]
rs [tok]
ss else Reply tok st [tok] -> Consumed (Reply tok st [tok])
forall a. a -> Consumed a
Empty (Reply tok st [tok] -> Consumed (Reply tok st [tok]))
-> Reply tok st [tok] -> Consumed (Reply tok st [tok])
forall a b. (a -> b) -> a -> b
$ [tok] -> Reply tok st [tok]
forall tok st a. [tok] -> Reply tok st a
errExpect [tok
c]
  in [tok] -> [tok] -> Consumed (Reply tok st [tok])
walk1 [tok]
s [tok]
input