-many :: Parser a -> Parser [a]
-many !p = Parser $! many' p []
-
--- This implementation is rather ugly but we need to make it
--- tail-recursive to avoid stack overflow.
-many' :: Parser a -> [a] -> State ParserState (ParserResult [a])
-many' !p !soFar
- = do saved <- get
- result <- runParser p
- case result of
- Success a -> many' p (a:soFar)
- IllegalInput -> do put saved
- return $! Success $ reverse soFar
- ReachedEOF -> if pstIsEOFFatal saved then
- do put saved
- return ReachedEOF
- else
- do put saved
- return $! Success $ reverse soFar
+many :: forall a. Parser a -> Parser [a]
+many !p = Parser $!
+ do state <- get
+ let (# result, state' #) = many' state Seq.empty
+ put state'
+ return result
+ where
+ many' :: ParserState -> Seq a -> (# ParserResult [a], ParserState #)
+ many' !st !soFar
+ = case runState (runParser p) st of
+ (Success a, st') -> many' st' (soFar |> a)
+ (IllegalInput, _) -> (# Success (Fold.toList soFar), st #)
+ (ReachedEOF , _) -> if pstIsEOFFatal st then
+ (# ReachedEOF, st #)
+ else
+ (# Success (Fold.toList soFar), st #)
+
+manyChar :: Parser Char -> Parser Lazy.ByteString
+manyChar !p = Parser $!
+ do state <- get
+ case scan' state 0 of
+ Success len
+ -> do let (bs, rest) = B.splitAt len (pstInput state)
+ state' = state { pstInput = rest }
+ put state'
+ return $ Success bs
+ ReachedEOF
+ -> if pstIsEOFFatal state then
+ return ReachedEOF
+ else
+ error "internal error"
+ _ -> error "internal error"
+ where
+ scan' :: ParserState -> Int64 -> ParserResult Int64
+ scan' !st !soFar
+ = case runState (runParser p) st of
+ (Success _ , st') -> scan' st' (soFar + 1)
+ (IllegalInput, _ ) -> Success soFar
+ (ReachedEOF , _ ) -> if pstIsEOFFatal st then
+ ReachedEOF
+ else
+ Success soFar