diff --git a/Data/Attoparsec/Enumerator.hs b/Data/Attoparsec/Enumerator.hs deleted file mode 100644 --- a/Data/Attoparsec/Enumerator.hs +++ /dev/null @@ -1,52 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module: Data.Attoparsec.Enumerator --- Copyright: 2010 John Millikin --- License: MIT --- --- Maintainer: jmillikin@gmail.com --- Portability: portable --- ------------------------------------------------------------------------------ -{-# LANGUAGE DeriveDataTypeable #-} -module Data.Attoparsec.Enumerator - ( ParseError (..) - , iterParser - ) where -import Control.Exception (Exception) -import Data.Typeable (Typeable) -import qualified Data.Attoparsec as A -import qualified Data.ByteString as B -import qualified Data.Enumerator as E - --- | The context and message from a 'A.Fail' value. -data ParseError = ParseError - { errorContexts :: [String] - , errorMessage :: String - } - deriving (Show, Typeable) - -instance Exception ParseError - --- | Convert an Attoparsec 'A.Parser' into an 'E.Iteratee'. The parser will --- be streamed bytes until it returns 'A.Done' or 'A.Fail'. --- --- If parsing fails, the iteratee's error value will contain a 'ParseError'. -iterParser :: Monad m => A.Parser a -> E.Iteratee B.ByteString m a -iterParser p = E.continue (step (A.parse p)) where - step parse (E.Chunks xs) = parseLoop parse (notEmpty xs) - step parse E.EOF = case A.feed (parse B.empty) B.empty of - A.Done _ a -> E.yield a E.EOF - A.Partial _ -> err [] "iterParser: divergent parser" - A.Fail _ ctx msg -> err ctx msg - - parseLoop parse [] = E.continue (step parse) - parseLoop parse (x:xs) = case parse x of - A.Done extra a -> E.yield a $ if B.null extra - then E.Chunks xs - else E.Chunks (extra:xs) - A.Partial parse' -> parseLoop parse' xs - A.Fail _ ctx msg -> err ctx msg - - err ctx msg = E.throwError (ParseError ctx msg) - notEmpty = filter (not . B.null) diff --git a/attoparsec-enumerator.cabal b/attoparsec-enumerator.cabal --- a/attoparsec-enumerator.cabal +++ b/attoparsec-enumerator.cabal @@ -1,33 +1,58 @@ name: attoparsec-enumerator -version: 0.2.0.4 -synopsis: Convert an Attoparsec parser into an iteratee +version: 0.2.0.5 license: MIT license-file: license.txt author: John Millikin -maintainer: jmillikin@gmail.com -copyright: Copyright (c) John Millikin 2010 +maintainer: John Millikin build-type: Simple -cabal-version: >=1.6 +cabal-version: >= 1.6 category: Text, Parsing, Enumerator stability: experimental +homepage: https://john-millikin.com/software/attoparsec-enumerator/ bug-reports: mailto:jmillikin@gmail.com -homepage: http://john-millikin.com/software/attoparsec-enumerator/ -tested-with: GHC==6.12.1 +synopsis: Pass input from an enumerator to an Attoparsec parser. +description: + This library allows an Attoparsec parser to receive input incrementally + from an enumerator. This could be used for parsing large files, or + implementing binary network protocols. + . + > (-# LANGUAGE OverloadedStrings #-) + > + > import Control.Applicative + > import Data.Attoparsec + > import Data.Attoparsec.Enumerator + > import Data.Enumerator + > import Data.Enumerator.Binary (enumHandle) + > import Data.Enumerator.List + > import System.IO + > + > parser = string "foo" <|> string "bar" + > + > main = do + > xy <- run_ (enumHandle 1 stdin $$ do + > x <- iterParser parser + > y <- iterParser parser + > return (x, y)) + > print xy + + source-repository head type: bazaar - location: http://john-millikin.com/software/attoparsec-enumerator/ + location: https://john-millikin.com/branches/attoparsec-enumerator/0.2/ -library - if true - ghc-options: -Wall +source-repository this + type: bazaar + location: https://john-millikin.com/branches/attoparsec-enumerator/0.2/ + tag: attoparsec-enumerator_0.2.0.5 - if impl(ghc >= 6.11) - ghc-options: -fno-warn-unused-do-bind +library + hs-source-dirs: lib + ghc-options: -Wall -O2 build-depends: - base >= 3 && < 5 - , attoparsec >= 0.8 && < 0.10 + base >= 4.0 && < 5.0 + , attoparsec >= 0.8 && < 0.11 , bytestring >= 0.9 && < 0.10 , enumerator >= 0.4 && < 0.5 diff --git a/lib/Data/Attoparsec/Enumerator.hs b/lib/Data/Attoparsec/Enumerator.hs new file mode 100644 --- /dev/null +++ b/lib/Data/Attoparsec/Enumerator.hs @@ -0,0 +1,53 @@ +{-# LANGUAGE DeriveDataTypeable #-} + +-- | +-- Module: Data.Attoparsec.Enumerator +-- Copyright: 2010 John Millikin +-- License: MIT +-- +-- Maintainer: jmillikin@gmail.com +-- Portability: portable +module Data.Attoparsec.Enumerator + ( ParseError (..) + , iterParser + ) where + +import Control.Exception (Exception) +import Data.Typeable (Typeable) +import qualified Data.ByteString as B + +import qualified Data.Attoparsec as A +import qualified Data.Enumerator as E + +-- | The context and message from a 'A.Fail' value. +data ParseError = ParseError + { errorContexts :: [String] + , errorMessage :: String + } + deriving (Show, Typeable) + +instance Exception ParseError + +-- | Convert an Attoparsec 'A.Parser' into an 'E.Iteratee'. The parser will +-- be streamed bytes until it returns 'A.Done' or 'A.Fail'. +-- +-- If parsing fails, a 'ParseError' will be thrown with 'E.throwError'. Use +-- 'E.catchError' to catch it. +iterParser :: Monad m => A.Parser a -> E.Iteratee B.ByteString m a +iterParser p = E.continue (step (A.parse p)) where + step parse (E.Chunks xs) = parseLoop parse (notEmpty xs) + step parse E.EOF = case A.feed (parse B.empty) B.empty of + A.Done _ a -> E.yield a E.EOF + A.Partial _ -> err [] "iterParser: divergent parser" + A.Fail _ ctx msg -> err ctx msg + + parseLoop parse [] = E.continue (step parse) + parseLoop parse (x:xs) = case parse x of + A.Done extra a -> E.yield a $ if B.null extra + then E.Chunks xs + else E.Chunks (extra:xs) + A.Partial parse' -> parseLoop parse' xs + A.Fail _ ctx msg -> err ctx msg + + err ctx msg = E.throwError (ParseError ctx msg) + notEmpty = filter (not . B.null)