attoparsec-text-0.8.5.1/0000755000000000000000000000000011572217467013214 5ustar0000000000000000attoparsec-text-0.8.5.1/Setup.lhs0000644000000000000000000000011411572217467015020 0ustar0000000000000000#!/usr/bin/env runhaskell > import Distribution.Simple > main = defaultMain attoparsec-text-0.8.5.1/attoparsec-text.cabal0000644000000000000000000000437711572217467017342 0ustar0000000000000000name: attoparsec-text version: 0.8.5.1 license: BSD3 license-file: LICENSE category: Text, Parsing author: Felipe Lessa , Bryan O'Sullivan maintainer: Felipe Lessa stability: experimental tested-with: GHC == 6.12.1, GHC == 7.0.1 synopsis: Fast combinator parsing for texts cabal-version: >= 1.6 homepage: http://patch-tag.com/r/felipe/attoparsec-text/home build-type: Simple description: A fast parser combinator library, aimed particularly at dealing efficiently with network protocols and complicated text/binary file formats. . This library is basically a translation of the original attoparsec library to use text instead of bytestrings. . Changes in version 0.8.5.0: . * Ported changes from attoparsec 0.8.5.0. . Changes in version 0.8.2.1: . * Permit newer version of containers for GHC 7.0. . Changes in version 0.8.2.0: . * Add @IsString@ instance to @Parser@. . * Add specializations of @\<*@ and @*\>@, see the docs for more information. . * Add @digit@, @letter@, @space@, @decimal@, @hexadecimal@, @signed@, @double@ and @rational@. extra-source-files: README.markdown benchmarks/Makefile benchmarks/Double.hs benchmarks/Tiny.hs benchmarks/med.txt.bz2 benchmarks/double_test.txt.bz2 tests/Makefile tests/QC.hs tests/QCSupport.hs tests/TestFastSet.hs -- examples/Makefile -- examples/Parsec_RFC2616.hs -- examples/RFC2616.hs -- examples/TestRFC2616.hs -- examples/rfc2616.c source-repository head type: darcs location: http://patch-tag.com/r/felipe/attoparsec-text library build-depends: base >= 3 && < 5, attoparsec >= 0.7 && < 0.10, text >= 0.10 && < 0.12, containers >= 0.1.0.1 && < 0.5, array >= 0.1 && < 0.4 extensions: CPP exposed-modules: Data.Attoparsec.Text Data.Attoparsec.Text.FastSet Data.Attoparsec.Text.Lazy other-modules: Data.Attoparsec.Text.Internal ghc-options: -Wall -- ghc-prof-options: -auto-all attoparsec-text-0.8.5.1/README.markdown0000644000000000000000000000101711572217467015714 0ustar0000000000000000# Welcome to attoparsec-text attoparsec-text is a fast Haskell parser combinator library. It is designed after attoparsec library but working with Text instead of ByteStrings. # Join in! I'm happy to receive bug reports, fixes, documentation enhancements, and other improvements. Master [darcs repository](http://patch-tag.com/r/felipe/attoparsec-text/home): * `darcs get http://patch-tag.com/r/felipe/attoparsec-text` Authors ------- This library is written by Felipe Lessa as a port of Bryan O'Sullivan's attoparsec. attoparsec-text-0.8.5.1/LICENSE0000644000000000000000000000270111572217467014221 0ustar0000000000000000Copyright (c) Felipe Lessa, Lennart Kolmodin All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the author nor the names of his contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. attoparsec-text-0.8.5.1/tests/0000755000000000000000000000000011572217467014356 5ustar0000000000000000attoparsec-text-0.8.5.1/tests/TestFastSet.hs0000644000000000000000000000033211572217467017121 0ustar0000000000000000module Main (main) where import qualified Data.Attoparsec.Text.FastSet as F import Test.QuickCheck prop_AllMembers s = let set = F.fromList s in all (`F.member` set) s main = do quickCheck prop_AllMembers attoparsec-text-0.8.5.1/tests/Makefile0000644000000000000000000000034011572217467016013 0ustar0000000000000000all: TestFastSet.out qc.out %.out: %.exe ./$< | tee $<.tmp mv $<.tmp $@ qc.exe: QC.hs ghc -O -fno-warn-orphans --make -o $@ $< %.exe: %.hs ghc -O -fno-warn-orphans --make -o $@ $< clean: -rm -f *.hi *.o *.exe *.out attoparsec-text-0.8.5.1/tests/QC.hs0000644000000000000000000000646511572217467015230 0ustar0000000000000000{-# LANGUAGE OverloadedStrings #-} module Main (main) where import Control.Monad (forM_) import Data.Maybe (isJust) import Prelude hiding (takeWhile) import QCSupport import Test.Framework (defaultMain, testGroup) import Test.Framework.Providers.QuickCheck2 (testProperty) import Test.QuickCheck hiding (NonEmpty) import qualified Data.Attoparsec.Text as P import qualified Data.Text as T -- Make sure that structures whose types claim they are non-empty -- really are. nonEmptyList l = length (nonEmpty l) > 0 where types = l :: NonEmpty [Int] nonEmptyBS l = T.length (nonEmpty l) > 0 -- Naming. {- label (NonEmpty s) = case parse (anyChar s) T.empty of (_, Left err) -> s `isInfixOf` err _ -> False -} -- Basic byte-level combinators. maybeP p s = case P.parse p s `P.feed` T.empty of P.Done _ i -> Just i _ -> Nothing defP p s = P.parse p s `P.feed` T.empty satisfy w s = maybeP (P.satisfy (<=w)) (T.cons w s) == Just w char w s = maybeP (P.char w) (T.cons w s) == Just w anyChar s = maybeP P.anyChar s == if T.null s then Nothing else Just (T.head s) notChar w (NonEmpty s) = maybeP (P.notChar w) s == if v == w then Nothing else Just v where v = T.head s string s = maybeP (P.string s) s == Just s skipWhile w s = let t = T.dropWhile (<=w) s in case defP (P.skipWhile (<=w)) s of P.Done t' () -> t == t' _ -> False takeCount (Positive k) s = case maybeP (P.take k) s of Nothing -> k > T.length s Just s' -> k <= T.length s takeWhile w s = let (h,t) = T.spanBy (==w) s in case defP (P.takeWhile (==w)) s of P.Done t' h' -> t == t' && h == h' _ -> False takeWhile1 w s = let s' = T.cons w s (h,t) = T.spanBy (<=w) s' in case defP (P.takeWhile1 (<=w)) s' of P.Done t' h' -> t == t' && h == h' _ -> False takeTill w s = let (h,t) = T.breakBy (==w) s in case defP (P.takeTill (==w)) s of P.Done t' h' -> t == t' && h == h' _ -> False ensure n s = case defP (P.ensure m) s of P.Done _ () -> T.length s >= m _ -> T.length s < m where m = (n `mod` 220) - 20 takeWhile1_empty = maybeP (P.takeWhile1 undefined) T.empty == Nothing endOfInput s = maybeP P.endOfInput s == if T.null s then Just () else Nothing main = defaultMain tests tests = [ testGroup "fnord" [ testProperty "nonEmptyList" nonEmptyList, testProperty "nonEmptyBS" nonEmptyBS, testProperty "satisfy" satisfy, testProperty "char" char, testProperty "notChar" notChar, testProperty "anyChar" anyChar, testProperty "string" string, testProperty "skipWhile" skipWhile, testProperty "takeCount" takeCount, testProperty "takeWhile" takeWhile, testProperty "takeWhile1" takeWhile1, testProperty "takeWhile1_empty" takeWhile1_empty, testProperty "takeTill" takeTill, testProperty "endOfInput" endOfInput, testProperty "ensure" ensure ] ] attoparsec-text-0.8.5.1/tests/QCSupport.hs0000644000000000000000000000324711572217467016620 0ustar0000000000000000{-# LANGUAGE FlexibleContexts, FlexibleInstances #-} module QCSupport ( NonEmpty(..) ) where import Control.Applicative import Data.Attoparsec.Text import System.Random (RandomGen, Random(..)) import Test.QuickCheck hiding (NonEmpty) import qualified Data.Text as T import qualified Data.Text.Lazy as L integralRandomR :: (Integral a, RandomGen g) => (a,a) -> g -> (a,g) integralRandomR (a,b) g = case randomR (fromIntegral a :: Integer, fromIntegral b :: Integer) g of (x,g') -> (fromIntegral x, g') newtype NonEmpty a = NonEmpty { nonEmpty :: a } deriving (Eq, Ord, Read, Show) instance Functor NonEmpty where fmap f (NonEmpty a) = NonEmpty (f a) instance Applicative NonEmpty where NonEmpty f <*> NonEmpty a = NonEmpty (f a) pure a = NonEmpty a instance Arbitrary a => Arbitrary (NonEmpty [a]) where arbitrary = NonEmpty <$> sized (\n -> choose (1,n+1) >>= vector) instance Arbitrary T.Text where arbitrary = T.pack <$> arbitrary instance Arbitrary (NonEmpty T.Text) where arbitrary = fmap T.pack <$> arbitrary instance Arbitrary L.Text where arbitrary = sized $ \n -> resize (round (sqrt (toEnum n :: Double))) ((L.fromChunks . map nonEmpty) <$> arbitrary) instance Arbitrary (NonEmpty L.Text) where arbitrary = sized $ \n -> resize (round (sqrt (toEnum n :: Double))) (fmap (L.fromChunks . map nonEmpty) <$> arbitrary) {- instance Random Word8 where randomR = integralRandomR random = randomR (minBound,maxBound) instance Arbitrary Word8 where arbitrary = choose (minBound, maxBound) -}attoparsec-text-0.8.5.1/Data/0000755000000000000000000000000011572217467014065 5ustar0000000000000000attoparsec-text-0.8.5.1/Data/Attoparsec/0000755000000000000000000000000011572217467016172 5ustar0000000000000000attoparsec-text-0.8.5.1/Data/Attoparsec/Text.hs0000644000000000000000000002011211572217467017446 0ustar0000000000000000-- | -- Module : Data.Attoparsec.Text -- Copyright : Felipe Lessa 2010-2011, Bryan O'Sullivan 2007-2010 -- License : BSD3 -- -- Maintainer : felipe.lessa@gmail.com -- Stability : experimental -- Portability : unknown -- -- Simple, efficient combinator parsing for 'T.Text' strings, -- loosely based on the Parsec library. module Data.Attoparsec.Text ( -- * Differences from Parsec -- $parsec -- * Incremental input -- $incremental -- * Performance considerations -- $performance -- * Parser types I.Parser , Result(..) -- ** Typeclass instances -- $instances -- * Running parsers , parse , feed , I.parseOnly , parseWith , parseTest -- ** Result conversion , maybeResult , eitherResult -- * Combinators , (I.) , I.try , module Data.Attoparsec.Combinator -- * Parsing individual characters , I.char , I.anyChar , I.notChar , I.satisfy , I.satisfyWith , I.skip -- ** Special character parsers -- $specialcharparsers , I.digit , I.letter , I.space -- ** Character classes , I.inClass , I.notInClass -- * Efficient string handling , I.string , I.skipSpace , I.skipWhile , I.take , I.scan , I.takeWhile , I.takeWhile1 , I.takeTill -- ** Consume all remaining input , I.takeText , I.takeLazyText -- * Text parsing , I.endOfLine -- * Numeric parsers , I.decimal , I.hexadecimal , I.signed , I.double , I.rational -- * State observation and manipulation functions , I.endOfInput , I.atEnd -- * Applicative specializations -- $applicative , (<*.) , (.*>) ) where import Control.Applicative (Applicative, (<*), (*>)) import Data.Attoparsec.Combinator import qualified Data.Attoparsec.Text.Internal as I import qualified Data.Text as T import Data.Attoparsec.Text.Internal (Result(..), parse) -- $parsec -- -- Compared to Parsec 3, @attoparsec-text@ makes several -- tradeoffs. It is not intended for, or ideal for, all possible -- uses. -- -- * While @attoparsec-text@ can consume input incrementally, -- Parsec cannot. Incremental input is a huge deal for -- efficient and secure network and system programming, since -- it gives much more control to users of the library over -- matters such as resource usage and the I/O model to use. -- -- * Much of the performance advantage of @attoparsec-text@ is -- gained via high-performance parsers such as 'I.takeWhile' -- and 'I.string'. If you use complicated combinators that -- return lists of characters, there is less performance -- difference between the two libraries. -- -- * Unlike Parsec 3, @attoparsec-text@ does not support being -- used as a monad transformer. -- -- * @attoparsec-text@ is specialised to deal only with strict -- 'T.Text' input. Efficiency concernts rule out both lists -- and lazy texts. The usual use for lazy texts would be to -- allow consumption of very large input without a large -- footprint. For this need, @attoparsec-text@'s incremental -- input provides an excellent substitute, with much more -- control over when input takes place. If you must use lazy -- texts, see the 'Lazy' module, which feeds lazy chunks to a -- regular parser. -- -- * Parsec parsers can produce more helpful error messages than -- @attoparsec-text@ parsers. This is a matter of focus: -- @attoparsec-text@ avoids the extra book-keeping in favour of -- higher performance. -- $incremental -- -- @attoparsec-text@ supports incremental input, meaning that you -- can feed it a text that represents only part of the -- expected total amount of data to parse. If your parser reaches -- the end of a fragment of input and could consume more input, -- it will suspend parsing and return a 'Partial' continuation. -- -- Supplying the 'Partial' continuation with another text will -- resume parsing at the point where it was suspended. You must be -- prepared for the result of the resumed parse to be another -- 'Partial' continuation. -- -- To indicate that you have no more input, supply the 'Partial' -- continuation with an empty text. -- -- Remember that some parsing combinators will not return a result -- until they reach the end of input. They may thus cause 'Partial' -- results to be returned. -- -- If you do not need support for incremental input, consider using -- the 'I.parseOnly' function to run your parser. It will never -- prompt for more input. -- $performance -- -- To actually achieve high performance, there are a few guidelines -- that it is useful to follow. -- -- Use the 'T.Text'-oriented parsers whenever possible, -- e.g. 'I.takeWhile1' instead of 'many1' 'I.anyChar'. There is -- about a factor of 100 difference in performance between the -- two kinds of parser. -- -- For very simple character-testing predicates, write them by -- hand instead of using 'I.inClass' or 'I.notInClass'. For -- instance, both of these predicates test for an end-of-line -- character, but the first is much faster than the second: -- -- >endOfLine_fast c = w == '\r' || c == '\n' -- >endOfLine_slow = inClass "\r\n" -- -- Make active use of benchmarking and profiling tools to measure, -- find the problems with, and improve the performance of your parser. -- $instances -- -- The 'I.Parser' type is an instance of the following classes: -- -- * 'Monad', where 'fail' throws an exception (i.e. fails) with an -- error message. -- -- * 'Functor' and 'Applicative', which follow the usual definitions. -- -- * 'MonadPlus', where 'mzero' fails (with no error message) and -- 'mplus' executes the right-hand parser if the left-hand one -- fails. -- -- * 'Alternative', which follows 'MonadPlus'. -- -- The 'Result' type is an instance of 'Functor', where 'fmap' -- transforms the value in a 'Done' result. -- | If a parser has returned a 'Partial' result, supply it with more -- input. feed :: Result r -> T.Text -> Result r feed f@(Fail _ _ _) _ = f feed (Partial k) d = k d feed (Done bs r) d = Done (T.append bs d) r {-# INLINE feed #-} -- | Run a parser and print its result to standard output. parseTest :: (Show a) => I.Parser a -> T.Text -> IO () parseTest p s = print (parse p s) -- | Run a parser with an initial input string, and a monadic action -- that can supply more input if needed. parseWith :: Monad m => (m T.Text) -- ^ An action that will be executed to provide the parser -- with more input, if necessary. The action must return an -- 'T.empty' string when there is no more input available. -> I.Parser a -> T.Text -- ^ Initial input for the parser. -> m (Result a) parseWith refill p s = step $ parse p s where step (Partial k) = (step . k) =<< refill step r = return r -- | Convert a 'Result' value to a 'Maybe' value. A 'Partial' result -- is treated as failure. maybeResult :: Result r -> Maybe r maybeResult (Done _ r) = Just r maybeResult _ = Nothing -- | Convert a 'Result' value to an 'Either' value. A 'Partial' result -- is treated as failure. eitherResult :: Result r -> Either String r eitherResult (Done _ r) = Right r eitherResult (Fail _ _ msg) = Left msg eitherResult _ = Left "Result: incomplete input" -- $specialcharparsers -- -- Special parser for characters. Unlike the original -- @attoparsec@ package, these parsers do work correctly for all -- encodings. Internally "Data.Char" module is used. -- $applicative -- -- We provide specializations of @\<*@ and @*\>@ as @\<*.@ and -- @.*\>@, respectively. Together with @IsString@ instance of -- 'I.Parser', you may write parsers applicatively more easily. -- For example: -- -- > paren p = "(" .*> p <*. ")" -- -- instead of the more verbose -- -- > paren p = string "(" *> p <* string ")" -- | Same as @Applicative@'s @\<*@ but specialized to 'T.Text' -- on the second argument. (<*.) :: Applicative f => f a -> f T.Text -> f a (<*.) = (<*) -- | Same as @Applicative@'s @*\>@ but specialized to 'T.Text' -- on the first argument. (.*>) :: Applicative f => f T.Text -> f a -> f a (.*>) = (*>) attoparsec-text-0.8.5.1/Data/Attoparsec/Text/0000755000000000000000000000000011572217467017116 5ustar0000000000000000attoparsec-text-0.8.5.1/Data/Attoparsec/Text/Internal.hs0000644000000000000000000005505311572217467021236 0ustar0000000000000000{-# LANGUAGE BangPatterns, Rank2Types, RecordWildCards, FlexibleInstances #-} -- | -- Module : Data.Attoparsec.Text.Internal -- Copyright : Felipe Lessa 2010-2011, Bryan O'Sullivan 2007-2010 -- License : BSD3 -- -- Maintainer : felipe.lessa@gmail.com -- Stability : experimental -- Portability : unknown -- -- Simple, efficient parser combinators for 'T.Text' strings, -- loosely based on the Parsec library, heavily based on attoparsec. module Data.Attoparsec.Text.Internal ( -- * Parser types Parser , Result(..) -- * Running parsers , parse , parseOnly -- * Combinators , () , try , module Data.Attoparsec.Combinator -- * Parsing individual characters , satisfy , satisfyWith , anyChar , skip , char , notChar -- ** Character classes , inClass , notInClass -- ** Special character parsers , digit , letter , space -- * Efficient string handling , skipWhile , skipSpace , string , stringTransform , take , scan , takeWhile , takeWhile1 , takeTill -- ** Consume all remaining input , takeText , takeLazyText -- * Numeric parsers , decimal , hexadecimal , signed , double , rational -- * State observation and manipulation functions , endOfInput , atEnd , ensure -- * Utilities , endOfLine ) where import Control.Applicative (Alternative(..), Applicative(..), (<$>)) import Control.Monad (MonadPlus(..), when) import Data.Attoparsec.Combinator import Data.Attoparsec.Text.FastSet (charClass, member) import Data.Char import Data.Monoid (Monoid(..)) import Data.Ratio ((%)) import Data.String (IsString(..)) import Prelude hiding (getChar, take, takeWhile) import qualified Data.Text as T import qualified Data.Text.Lazy as TL -- | The result of a parse. data Result r = Fail T.Text [String] String -- ^ The parse failed. The 'T.Text' is the input -- that had not yet been consumed when the failure -- occurred. The @[@'String'@]@ is a list of contexts -- in which the error occurred. The 'String' is the -- message describing the error, if any. | Partial (T.Text -> Result r) -- ^ Supply this continuation with more input so that -- the parser can resume. To indicate that no more -- input is available, use an 'T.empty' string. | Done T.Text r -- ^ The parse succeeded. The 'T.Text' is the -- input that had not yet been consumed (if any) when -- the parse succeeded. instance Show r => Show (Result r) where show (Fail bs stk msg) = "Fail " ++ show bs ++ " " ++ show stk ++ " " ++ show msg show (Partial _) = "Partial _" show (Done bs r) = "Done " ++ show bs ++ " " ++ show r fmapR :: (a -> b) -> Result a -> Result b fmapR _ (Fail st stk msg) = Fail st stk msg fmapR f (Partial k) = Partial (fmapR f . k) fmapR f (Done bs r) = Done bs (f r) instance Functor Result where fmap = fmapR newtype Input = I {unI :: T.Text} newtype Added = A {unA :: T.Text} -- | The 'Parser' type is a monad. newtype Parser a = Parser { runParser :: forall r. Input -> Added -> More -> Failure r -> Success a r -> Result r } type Failure r = Input -> Added -> More -> [String] -> String -> Result r type Success a r = Input -> Added -> More -> a -> Result r instance IsString (Parser T.Text) where fromString = string . T.pack -- | Have we read all available input? data More = Complete | Incomplete deriving (Eq, Show) addS :: Input -> Added -> More -> Input -> Added -> More -> (Input -> Added -> More -> r) -> r addS i0 a0 m0 _i1 a1 m1 f = let !i = I (unI i0 +++ unA a1) a = A (unA a0 +++ unA a1) !m = m0 <> m1 in f i a m where Complete <> _ = Complete _ <> Complete = Complete _ <> _ = Incomplete {-# INLINE addS #-} bindP :: Parser a -> (a -> Parser b) -> Parser b bindP m g = Parser $ \i0 a0 m0 kf ks -> runParser m i0 a0 m0 kf $ \i1 a1 m1 a -> runParser (g a) i1 a1 m1 kf ks {-# INLINE bindP #-} returnP :: a -> Parser a returnP a = Parser (\i0 a0 m0 _kf ks -> ks i0 a0 m0 a) {-# INLINE returnP #-} instance Monad Parser where return = returnP (>>=) = bindP fail = failDesc noAdds :: Input -> Added -> More -> (Input -> Added -> More -> r) -> r noAdds i0 _a0 m0 f = f i0 (A T.empty) m0 {-# INLINE noAdds #-} plus :: Parser a -> Parser a -> Parser a plus a b = Parser $ \i0 a0 m0 kf ks -> let kf' i1 a1 m1 _ _ = addS i0 a0 m0 i1 a1 m1 $ \ i2 a2 m2 -> runParser b i2 a2 m2 kf ks in noAdds i0 a0 m0 $ \i2 a2 m2 -> runParser a i2 a2 m2 kf' ks {-# INLINE plus #-} instance MonadPlus Parser where mzero = failDesc "mzero" {-# INLINE mzero #-} mplus = plus fmapP :: (a -> b) -> Parser a -> Parser b fmapP p m = Parser $ \i0 a0 m0 f k -> runParser m i0 a0 m0 f $ \i1 a1 s1 a -> k i1 a1 s1 (p a) {-# INLINE fmapP #-} instance Functor Parser where fmap = fmapP apP :: Parser (a -> b) -> Parser a -> Parser b apP d e = do b <- d a <- e return (b a) {-# INLINE apP #-} instance Applicative Parser where pure = returnP (<*>) = apP -- These definitions are equal to the defaults, but this -- way the optimizer doesn't have to work so hard to figure -- that out. (*>) = (>>) x <* y = x >>= \a -> y >> return a instance Monoid (Parser a) where mempty = failDesc "mempty" {-# INLINE mempty #-} mappend = plus instance Alternative Parser where empty = failDesc "empty" {-# INLINE empty #-} (<|>) = plus failDesc :: String -> Parser a failDesc err = Parser (\i0 a0 m0 kf _ks -> kf i0 a0 m0 [] msg) where msg = "Failed reading: " ++ err {-# INLINE failDesc #-} -- | If at least @n@ bytes of input are available, return the current -- input, otherwise fail. ensure :: Int -> Parser T.Text ensure !n = Parser $ \i0 a0 m0 kf ks -> if T.length (unI i0) >= n then ks i0 a0 m0 (unI i0) else runParser (demandInput >> ensure n) i0 a0 m0 kf ks -- | Ask for input. If we receive any, pass it to a success -- continuation, otherwise to a failure continuation. prompt :: Input -> Added -> More -> (Input -> Added -> More -> Result r) -> (Input -> Added -> More -> Result r) -> Result r prompt i0 a0 _m0 kf ks = Partial $ \s -> if T.null s then kf i0 a0 Complete else ks (I (unI i0 +++ s)) (A (unA a0 +++ s)) Incomplete -- | Immediately demand more input via a 'Partial' continuation -- result. demandInput :: Parser () demandInput = Parser $ \i0 a0 m0 kf ks -> if m0 == Complete then kf i0 a0 m0 ["demandInput"] "not enough characters" else let kf' i a m = kf i a m ["demandInput"] "not enough characters" ks' i a m = ks i a m () in prompt i0 a0 m0 kf' ks' -- | This parser always succeeds. It returns 'True' if any input is -- available either immediately or on demand, and 'False' if the end -- of all input has been reached. wantInput :: Parser Bool wantInput = Parser $ \i0 a0 m0 _kf ks -> case () of _ | not (T.null (unI i0)) -> ks i0 a0 m0 True | m0 == Complete -> ks i0 a0 m0 False | otherwise -> let kf' i a m = ks i a m False ks' i a m = ks i a m True in prompt i0 a0 m0 kf' ks' get :: Parser T.Text get = Parser $ \i0 a0 m0 _kf ks -> ks i0 a0 m0 (unI i0) put :: T.Text -> Parser () put s = Parser $ \_i0 a0 m0 _kf ks -> ks (I s) a0 m0 () (+++) :: T.Text -> T.Text -> T.Text (+++) = T.append {-# INLINE (+++) #-} -- | Attempt a parse, and if it fails, rewind the input so that no -- input appears to have been consumed. -- -- This combinator is useful in cases where a parser might consume -- some input before failing, i.e. the parser needs arbitrary -- lookahead. The downside to using this combinator is that it can -- retain input for longer than is desirable. try :: Parser a -> Parser a try p = Parser $ \i0 a0 m0 kf ks -> noAdds i0 a0 m0 $ \i1 a1 m1 -> let kf' i2 a2 m2 = addS i0 a0 m0 i2 a2 m2 kf in runParser p i1 a1 m1 kf' ks -- | The parser @satisfy p@ succeeds for any character for which -- the predicate @p@ returns 'True'. Returns the character that -- is actually parsed. -- -- >import Data.Char (isDigit) -- >digit = satisfy isDigit satisfy :: (Char -> Bool) -> Parser Char satisfy p = do s <- ensure 1 case T.uncons s of Just (h,t) | p h -> put t >> return h | otherwise -> fail "satisfy" Nothing -> error "Data.Attoparsec.Text.Internal.satisfy: never here" -- | The parser @skip p@ succeeds for any character for which the -- predicate @p@ returns 'True'. -- -- >import Data.Char (isDigit) -- >digit = satisfy isDigit skip :: (Char -> Bool) -> Parser () skip p = do s <- ensure 1 case T.uncons s of Just (h,t) | p h -> put t | otherwise -> fail "skip" Nothing -> error "Data.Attoparsec.Text.Internal.skip: never here" -- | The parser @satisfyWith f p@ transforms a character, and -- succeeds if the predicate @p@ returns 'True' on the -- transformed value. The parser returns the transformed -- character that was parsed. satisfyWith :: (Char -> a) -> (a -> Bool) -> Parser a satisfyWith f p = do s <- ensure 1 let Just (h,t) = T.uncons s c = f h if p c then put t >> return c else fail "satisfyWith" -- | Parse a single digit. digit :: Parser Char digit = satisfy isDigit "digit" {-# INLINE digit #-} -- | Parse a single letter. letter :: Parser Char letter = satisfy isLetter "letter" {-# INLINE letter #-} -- | Parse a space character. space :: Parser Char space = satisfy isSpace "space" {-# INLINE space #-} -- | Consume @n@ characters of input, but succeed only if the -- predicate returns 'True'. takeWith :: Int -> (T.Text -> Bool) -> Parser T.Text takeWith n p = do s <- ensure n let (h,t) = T.splitAt n s if p h then put t >> return h else failDesc "takeWith" -- | Consume exactly @n@ characters of input. take :: Int -> Parser T.Text take n = takeWith n (const True) {-# INLINE take #-} -- | @string s@ parses a sequence of characters that identically -- match @s@. Returns the parsed string (i.e. @s@). This parser -- consumes no input if it fails (even if a partial match). -- -- /Note/: The behaviour of this parser is different to that of the -- similarly-named parser in Parsec, as this one is all-or-nothing. -- To illustrate the difference, the following parser will fail under -- Parsec given an input of @"for"@: -- -- >string "foo" <|> string "for" -- -- The reason for its failure is that that the first branch is a -- partial match, and will consume the letters @\'f\'@ and -- @\'o\'@ before failing. In Attoparsec, both the original on -- bytestrings and this one on texts, the above parser will -- /succeed/ on that input, because the failed first branch will -- consume nothing. string :: T.Text -> Parser T.Text string s = takeWith (T.length s) (==s) {-# INLINE string #-} stringTransform :: (T.Text -> T.Text) -> T.Text -> Parser T.Text stringTransform f s = takeWith (T.length s) ((==f s) . f) {-# INLINE stringTransform #-} -- | Skip past input for as long as the predicate returns 'True'. skipWhile :: (Char -> Bool) -> Parser () skipWhile p = go where go = do t <- T.dropWhile p <$> get put t when (T.null t) $ do input <- wantInput when input go {-# INLINE skipWhile #-} -- | Skip over white space. skipSpace :: Parser () skipSpace = skipWhile isSpace >> return () {-# INLINE skipSpace #-} -- | Consume input as long as the predicate returns 'False' -- (i.e. until it returns 'True'), and return the consumed input. -- -- This parser does not fail. It will return an empty string if the -- predicate returns 'True' on the first character of input. -- -- /Note/: Because this parser does not fail, do not use it with -- combinators such as 'many', because such parsers loop until a -- failure occurs. Careless use will thus result in an infinite loop. takeTill :: (Char -> Bool) -> Parser T.Text takeTill p = takeWhile (not . p) {-# INLINE takeTill #-} -- | Consume input as long as the predicate returns 'True', and return -- the consumed input. -- -- This parser does not fail. It will return an empty string if the -- predicate returns 'False' on the first character of input. -- -- /Note/: Because this parser does not fail, do not use it with -- combinators such as 'many', because such parsers loop until a -- failure occurs. Careless use will thus result in an infinite loop. takeWhile :: (Char -> Bool) -> Parser T.Text takeWhile p = (T.concat . reverse) `fmap` go [] where go acc = do #if MIN_VERSION_text(0,11,0) (h,t) <- T.span p <$> get #else (h,t) <- T.spanBy p <$> get #endif put t if T.null t then do input <- wantInput if input then go (h:acc) else return (h:acc) else return (h:acc) takeRest :: Parser [T.Text] takeRest = go [] where go acc = do input <- wantInput if input then do s <- get put T.empty go (s:acc) else return (reverse acc) -- | Consume all remaining input and return it as a single string. takeText :: Parser T.Text takeText = T.concat `fmap` takeRest -- | Consume all remaining input and return it as a single string. takeLazyText :: Parser TL.Text takeLazyText = TL.fromChunks `fmap` takeRest -- | A stateful scanner. The predicate consumes and transforms a -- state argument, and each transformed state is passed to successive -- invocations of the predicate on each character of the input until one -- returns 'Nothing' or the input ends. -- -- This parser does not fail. It will return an empty string if the -- predicate returns 'Nothing' on the first character of input. -- -- /Note/: Because this parser does not fail, do not use it with -- combinators such as 'many', because such parsers loop until a -- failure occurs. Careless use will thus result in an infinite loop. scan :: s -> (s -> Char -> Maybe s) -> Parser T.Text scan s0 p = do chunks <- go [] s0 case chunks of [x] -> return x xs -> return . T.concat . reverse $ xs where scanner s !n t = case T.uncons t of Nothing -> Continue s Just (c,t') -> case p s c of Just s' -> scanner s' (n+1) t' Nothing -> Finished n t go acc s = do input <- get case scanner s 0 input of Continue s' -> do put T.empty more <- wantInput if more then go (input : acc) s' else return (input : acc) Finished n t -> put t >> return (T.take n input : acc) {-# INLINE scan #-} data ScannnerResult s = Continue s | Finished !Int !T.Text -- | Consume input as long as the predicate returns 'True', and return -- the consumed input. -- -- This parser requires the predicate to succeed on at least one -- character of input: it will fail if the predicate never -- returns 'True' or if there is no input left. takeWhile1 :: (Char -> Bool) -> Parser T.Text takeWhile1 p = do (`when` demandInput) =<< T.null <$> get #if MIN_VERSION_text(0,11,0) (h,t) <- T.span p <$> get #else (h,t) <- T.spanBy p <$> get #endif when (T.null h) $ failDesc "takeWhile1" put t if T.null t then (h+++) `fmapP` takeWhile p else return h -- | Match any character in a set. -- -- >vowel = inClass "aeiou" -- -- Range notation is supported. -- -- >halfAlphabet = inClass "a-nA-N" -- -- To add a literal @\'-\'@ to a set, place it at the beginning or end -- of the string. inClass :: String -> Char -> Bool inClass s = (`member` mySet) where mySet = charClass s {-# INLINE inClass #-} -- | Match any character not in a set. notInClass :: String -> Char -> Bool notInClass s = not . inClass s {-# INLINE notInClass #-} -- | Match any character. anyChar :: Parser Char anyChar = satisfy $ const True {-# INLINE anyChar #-} -- | Match a specific character. char :: Char -> Parser Char char c = satisfy (== c) show c {-# INLINE char #-} -- | Match any character except the given one. notChar :: Char -> Parser Char notChar c = satisfy (/= c) "not " ++ show c {-# INLINE notChar #-} -- | Parse and decode an unsigned decimal number. decimal :: Integral a => Parser a {-# SPECIALISE decimal :: Parser Int #-} {-# SPECIALISE decimal :: Parser Integer #-} decimal = T.foldl' step 0 `fmap` takeWhile1 asciiIsDigit where step a w = a * 10 + fromIntegral (fromEnum w - 48) asciiIsDigit :: Char -> Bool asciiIsDigit c = c >= '0' && c <= '9' {-# INLINE asciiIsDigit #-} -- | Parse and decode an unsigned hexadecimal number. The hex digits -- @\'a\'@ through @\'f\'@ may be upper or lower case. -- -- This parser does not accept a leading @\"0x\"@ string. hexadecimal :: Integral a => Parser a {-# SPECIALISE hexadecimal :: Parser Int #-} hexadecimal = T.foldl' step 0 `fmap` takeWhile1 asciiIsHexDigit where step a c | c >= '0' && c <= '9' = a * 16 + fromIntegral (fromEnum c - 48) | otherwise = a * 16 + fromIntegral (asciiToLower c - 87) asciiIsHexDigit :: Char -> Bool asciiIsHexDigit c = asciiIsDigit c || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') {-# INLINE asciiIsHexDigit #-} asciiToLower :: Char -> Int asciiToLower c | c >= 'A' && c <= 'Z' = fromEnum c + 32 | otherwise = fromEnum c -- | Parse a number with an optional leading @\'+\'@ or @\'-\'@ sign -- character. signed :: Num a => Parser a -> Parser a {-# SPECIALISE signed :: Parser Int -> Parser Int #-} signed p = (negate <$> (char '-' *> p)) <|> (char '+' *> p) <|> p -- | Parse a rational number. -- -- This parser accepts an optional leading sign character, followed by -- at least one decimal digit. The syntax similar to that accepted by -- the 'read' function, with the exception that a trailing @\'.\'@ or -- @\'e\'@ /not/ followed by a number is not consumed. -- -- Examples with behaviour identical to 'read', if you feed an empty -- continuation to the first result: -- -- >rational "3" == Done 3.0 "" -- >rational "3.1" == Done 3.1 "" -- >rational "3e4" == Done 30000.0 "" -- >rational "3.1e4" == Done 31000.0 "" -- -- Examples with behaviour identical to 'read': -- -- >rational ".3" == Fail "input does not start with a digit" -- >rational "e3" == Fail "input does not start with a digit" -- -- Examples of differences from 'read': -- -- >rational "3.foo" == Done 3.0 ".foo" -- >rational "3e" == Done 3.0 "e" rational :: RealFloat a => Parser a {-# SPECIALIZE rational :: Parser Double #-} rational = floaty $ \real frac fracDenom -> fromRational $ real % 1 + frac % fracDenom -- | Parse a rational number. -- -- The syntax accepted by this parser is the same as for 'rational'. -- -- /Note/: This function is almost ten times faster than 'rational', -- but is slightly less accurate. -- -- The 'Double' type supports about 16 decimal places of accuracy. -- For 94.2% of numbers, this function and 'rational' give identical -- results, but for the remaining 5.8%, this function loses precision -- around the 15th decimal place. For 0.001% of numbers, this -- function will lose precision at the 13th or 14th decimal place. double :: Parser Double double = floaty $ \real frac fracDenom -> fromIntegral real + fromIntegral frac / fromIntegral fracDenom data T = T !Integer !Int floaty :: RealFloat a => (Integer -> Integer -> Integer -> a) -> Parser a {-# INLINE floaty #-} floaty f = do sign <- satisfy (\c -> c == '-' || c == '+') <|> return '+' real <- decimal let tryFraction = do _ <- satisfy (== '.') ds <- takeWhile asciiIsDigit case (case parse decimal ds of Partial k -> k T.empty r -> r) of Done _ n -> return $ T n (T.length ds) _ -> fail "no digits after decimal" T fraction fracDigits <- tryFraction <|> return (T 0 0) let e c = c == 'e' || c == 'E' power <- (satisfy e *> signed decimal) <|> return (0 :: Int) let n = if fracDigits == 0 then if power == 0 then fromIntegral real else fromIntegral real * (10 ^^ power) else if power == 0 then f real fraction (10 ^ fracDigits) else f real fraction (10 ^ fracDigits) * (10 ^^ power) return $! if sign == '+' then n else -n -- | Match only if all input has been consumed. endOfInput :: Parser () endOfInput = Parser $ \i0 a0 m0 kf ks -> if T.null (unI i0) then if m0 == Complete then ks i0 a0 m0 () else let kf' i1 a1 m1 _ _ = addS i0 a0 m0 i1 a1 m1 $ \ i2 a2 m2 -> ks i2 a2 m2 () ks' i1 a1 m1 _ = addS i0 a0 m0 i1 a1 m1 $ \ i2 a2 m2 -> kf i2 a2 m2 [] "endOfInput" in runParser demandInput i0 a0 m0 kf' ks' else kf i0 a0 m0 [] "endOfInput" -- | Return an indication of whether the end of input has been -- reached. atEnd :: Parser Bool atEnd = not <$> wantInput {-# INLINE atEnd #-} -- | Match either a single newline character @\'\\n\'@, or a carriage -- return followed by a newline character @\"\\r\\n\"@. endOfLine :: Parser () endOfLine = (char '\n' >> return ()) <|> (string (T.pack "\r\n") >> return ()) --- | Name the parser, in case failure occurs. () :: Parser a -> String -- ^ the name to use if parsing fails -> Parser a p msg0 = Parser $ \i0 a0 m0 kf ks -> let kf' i a m strs msg = kf i a m (msg0:strs) msg in runParser p i0 a0 m0 kf' ks {-# INLINE () #-} infix 0 -- | Terminal failure continuation. failK :: Failure a failK i0 _a0 _m0 stack msg = Fail (unI i0) stack msg {-# INLINE failK #-} -- | Terminal success continuation. successK :: Success a a successK i0 _a0 _m0 a = Done (unI i0) a {-# INLINE successK #-} -- | Run a parser. parse :: Parser a -> T.Text -> Result a parse m s = runParser m (I s) (A T.empty) Incomplete failK successK {-# INLINE parse #-} -- | Run a parser that cannot be resupplied via a 'Partial' result. parseOnly :: Parser a -> T.Text -> Either String a parseOnly m s = case runParser m (I s) (A T.empty) Complete failK successK of Fail _ _ err -> Left err Done _ a -> Right a _ -> error "parseOnly: impossible error!" {-# INLINE parseOnly #-} attoparsec-text-0.8.5.1/Data/Attoparsec/Text/FastSet.hs0000644000000000000000000000340311572217467021023 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.Attoparsec.FastSet -- Copyright : Felipe Lessa 2010, Bryan O'Sullivan 2008 -- License : BSD3 -- -- Maintainer : felipe.lessa@gmail.com -- Stability : experimental -- Portability : unknown -- -- Fast set membership tests for 'Char' values. The set -- representation is unboxed for efficiency. We test for -- membership using a binary search. -- ----------------------------------------------------------------------------- module Data.Attoparsec.Text.FastSet ( -- * Data type FastSet -- * Construction , fromList , set -- * Lookup , member -- * Handy interface , charClass ) where import Data.List (sort) import qualified Data.Array.Base as AB import qualified Data.Array.Unboxed as A import qualified Data.Text as T newtype FastSet = FastSet (A.UArray Int Char) deriving (Eq, Ord, Show) -- | Create a set. set :: T.Text -> FastSet set t = mkSet (T.length t) (sort $ T.unpack t) fromList :: [Char] -> FastSet fromList cs = mkSet (length cs) (sort cs) mkSet :: Int -> [Char] -> FastSet mkSet l = FastSet . A.listArray (0,l-1) -- | Check the set for membership. member :: Char -> FastSet -> Bool member c (FastSet a) = uncurry search (A.bounds a) where search lo hi | hi < lo = False | otherwise = let mid = (lo + hi) `div` 2 in case compare c (AB.unsafeAt a mid) of GT -> search (mid + 1) hi LT -> search lo (mid - 1) _ -> True charClass :: String -> FastSet charClass = fromList . go where go (a:'-':b:xs) = [a..b] ++ go xs go (x:xs) = x : go xs go _ = "" attoparsec-text-0.8.5.1/Data/Attoparsec/Text/Lazy.hs0000644000000000000000000000624311572217467020376 0ustar0000000000000000-- | -- Module : Data.Attoparsec.Text.Lazy -- Copyright : Felipe Lessa 2010, Bryan O'Sullivan 2010 -- License : BSD3 -- -- Maintainer : felipe.lessa@gmail.com -- Stability : experimental -- Portability : unknown -- -- Simple, efficient combinator parsing for lazy 'Text' -- strings, loosely based on the Parsec library. -- -- This is essentially the same code as in the 'Data.Attoparsec' -- module, only with a 'parse' function that can consume a lazy -- 'Text' incrementally, and a 'Result' type that does not allow -- more input to be fed in. Think of this as suitable for use with a -- lazily read file, e.g. via 'L.readFile' or 'L.hGetContents'. -- -- Behind the scenes, strict 'T.Text' values are still used -- internally to store parser input and manipulate it efficiently. -- High-performance parsers such as 'string' still expect strict -- 'T.Text' parameters. module Data.Attoparsec.Text.Lazy ( Result(..) , module Data.Attoparsec.Text -- * Running parsers , parse , parseTest -- ** Result conversion , maybeResult , eitherResult ) where import Data.Text.Lazy (Text, fromChunks, toChunks) import qualified Data.Text as T import qualified Data.Attoparsec.Text as A import Data.Attoparsec.Text hiding (Result(..), eitherResult, maybeResult, parse, parseWith, parseTest) -- | The result of a parse. data Result r = Fail Text [String] String -- ^ The parse failed. The 'Text' is the input -- that had not yet been consumed when the failure -- occurred. The @[@'String'@]@ is a list of contexts -- in which the error occurred. The 'String' is the -- message describing the error, if any. | Done Text r -- ^ The parse succeeded. The 'Text' is the -- input that had not yet been consumed (if any) when -- the parse succeeded. instance Show r => Show (Result r) where show (Fail bs stk msg) = "Fail " ++ show bs ++ " " ++ show stk ++ " " ++ show msg show (Done bs r) = "Done " ++ show bs ++ " " ++ show r fmapR :: (a -> b) -> Result a -> Result b fmapR _ (Fail st stk msg) = Fail st stk msg fmapR f (Done bs r) = Done bs (f r) instance Functor Result where fmap = fmapR -- | Run a parser and return its result. parse :: A.Parser a -> Text -> Result a parse p s = case toChunks s of x:xs -> go (A.parse p x) xs [] -> go (A.parse p T.empty) [] where go (A.Fail x stk msg) ys = Fail (fromChunks $ x:ys) stk msg go (A.Done x r) ys = Done (fromChunks $ x:ys) r go (A.Partial k) (y:ys) = go (k y) ys go (A.Partial k) [] = go (k T.empty) [] -- | Run a parser and print its result to standard output. parseTest :: (Show a) => A.Parser a -> Text -> IO () parseTest p s = print (parse p s) -- | Convert a 'Result' value to a 'Maybe' value. maybeResult :: Result r -> Maybe r maybeResult (Done _ r) = Just r maybeResult _ = Nothing -- | Convert a 'Result' value to an 'Either' value. eitherResult :: Result r -> Either String r eitherResult (Done _ r) = Right r eitherResult (Fail _ _ msg) = Left msg attoparsec-text-0.8.5.1/benchmarks/0000755000000000000000000000000011572217467015331 5ustar0000000000000000attoparsec-text-0.8.5.1/benchmarks/Makefile0000644000000000000000000000026211572217467016771 0ustar0000000000000000all: med.txt double_test.txt tiny double tiny: Tiny.hs ghc -O --make -o $@ $< double: Double.hs ghc -O --make -o $@ $< %: %.bz2 bunzip2 -k $< clean: -rm -f *.o *.hi tiny attoparsec-text-0.8.5.1/benchmarks/med.txt.bz20000644000000000000000000000100611572217467017330 0ustar0000000000000000BZh91AY&SYOÿ`1Ì! €`2Ž@¼@@@J‰¤ôG©¤¡UD ¸” u„ „ IB„iB’„ ¥Ò„d¡êPêPæ©BIBIBÒ„Ô¡iB„ R„ %J6” rJ9%J0” yJ1J=J;J:J2” |’„„„R„ Ò„‰B„æ(+$Êk:ñÔ e¸á0Œ@1À;€@4@4@4¨šM¤zšJ5TJ ‰BQ(@Ñ(@Ñ(@å(@õ(@ÒP”¡´¡ÒPö” z” t” e(@ÚPû¡t¡)B”¡ B„ %R„„)B B„ R„ ¥J=¥Ò„©BR„’P´¡iB„ ¥)B„æ(+$Êk#õŠÀ)§0Œ@1À3jD@j”#Ôõ R©¦†™UP€Rnª©%åUQ/$¸KeT“ )0“Šª’v%ô–êª%Ø .ªª%Ÿ Z%ø–€IeUD²ª¢Zè–’ÕUD¸%À ,%€$·UQ,ª¨–ÀIz%Ø L¤æª©&€RhK€$ºª¨—°YPR~.äŠp¡!Öã attoparsec-text-0.8.5.1/benchmarks/Tiny.hs0000644000000000000000000000312511572217467016611 0ustar0000000000000000import Control.Applicative ((<|>)) import Control.Monad (forM_) import Data.Char (isDigit, isLetter) import System.Environment (getArgs) import qualified Data.Attoparsec.Char8 as AB import qualified Data.ByteString.Char8 as B import qualified Data.Attoparsec.Text as A import qualified Data.Text as T import qualified Data.Text.IO as T import qualified Text.Parsec as P import qualified Text.Parsec.ByteString as P attoparsec_bytestring args = do forM_ args $ \arg -> do input <- B.readFile arg case AB.parse p input `AB.feed` B.empty of AB.Done _ xs -> print (length xs) what -> print what where slow = AB.many (AB.many1 AB.letter_ascii <|> AB.many1 AB.digit) fast = AB.many (AB.takeWhile1 isLetter <|> AB.takeWhile1 isDigit) isDigit c = c >= '0' && c <= '9' isLetter c = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') p = fast attoparsec_text args = do forM_ args $ \arg -> do input <- T.readFile arg case A.parse p input `A.feed` T.empty of A.Done _ xs -> print (length xs) what -> print what where p = A.many (A.takeWhile1 isLetter <|> A.takeWhile1 isDigit) parsec args = forM_ args $ \arg -> do input <- readFile arg case P.parse (P.many (P.many1 P.letter P.<|> P.many1 P.digit)) "" input of Left err -> print err Right xs -> print (length xs) main = do args <- getArgs case args of ("attoparsec_bytestring":xs) -> attoparsec_bytestring xs ("attoparsec_text":xs) -> attoparsec_text xs ("parsec":xs) -> parsec xs [] -> putStrLn "Usage: ... [parsec|attoparsec_text|attoparsec_bytestring] inputs" attoparsec-text-0.8.5.1/benchmarks/double_test.txt.bz20000644000000000000000000000047111572217467021101 0ustar0000000000000000BZh91AY&SY«Â^û<À0°À5PšzÀШƒ¨ƒ¨TAºj…D¡QÈTA¤* Êe ˆ9B¢èTAÚbxÅd™MgÓ³Ùì”p` óÀÀCÕBf¡ Úe ˆ;B¢ ШƒHTAÄ* ú…D¡Q!QP¨ƒ”* ï¨TAêe ˆ?1AY&SYÒ4"jö8˜<À0°À5PšzÀŒå ˆ5B¢Шƒt* æèTAª}B¢ P¨ƒ(TAˆTAÄ* þ…DB¢ ¡QŒPVI”ÖTÖ™Àm†O0$`@šªié=NÙ N’á O zH g$4&’Â@˜H¤4'âîH§ Rqµattoparsec-text-0.8.5.1/benchmarks/Double.hs0000644000000000000000000000715311572217467017105 0ustar0000000000000000import Control.Applicative ((<|>)) import Control.Monad (forM_, MonadPlus(mzero)) import Data.Char (isDigit, isLetter) import Data.List (foldl') import System.Environment (getArgs) import qualified Data.Attoparsec.Char8 as AB import qualified Data.Attoparsec.Text as A import qualified Data.ByteString.Char8 as B import qualified Data.Text as T import qualified Data.Text.IO as T import qualified Data.Text.Read as TR import qualified Text.ParserCombinators.Parsec as P attoparsec_builtin args = do forM_ args $ \arg -> do input <- B.readFile arg case AB.parse (AB.many1 (AB.char '#' >> p)) input `AB.feed` B.empty of AB.Done _ xs -> print (sum xs :: Double) what -> print what where p = AB.double ---------------------------------------------------------------------- attoparsec_text_builtin args = do forM_ args $ \arg -> do input <- T.readFile arg case A.parse (A.many1 (A.char '#' >> p)) input `A.feed` T.empty of A.Done _ xs -> print (sum xs :: Double) what -> print what where p = A.double ---------------------------------------------------------------------- attoparsec_text_laforge args = do forM_ args $ \arg -> do input <- T.readFile arg case A.parse (A.many1 (A.char '#' >> p)) input `A.feed` T.empty of A.Done _ xs -> print (sum xs :: Double) what -> print what where p = do i <- A.takeWhile isDigit f <- A.option T.empty (A.char '.' >> A.takeWhile1 isDigit) if (T.null i && T.null f) then mzero else return $ fromIntegral (dec i) + fromIntegral (dec f) / fromIntegral (10 ^ (T.length f)) where dec = T.foldl' (\acc c -> acc * 10 + fromEnum c - 48) 0 attoparsec_text_laforge_discarding args = do forM_ args $ \arg -> do input <- T.readFile arg case A.parse (A.many1 (A.char '#' >> p)) input `A.feed` T.empty of A.Done _ xs -> print (length xs) what -> print what where p = do i <- A.takeWhile isDigit f <- A.option T.empty (A.char '.' >> A.takeWhile1 isDigit) return () ---------------------------------------------------------------------- parsec_laforge args = forM_ args $ \arg -> do input <- readFile arg case P.parse (P.many1 (P.char '#' >> p)) "" input of Left err -> print err Right xs -> print (sum xs :: Double) where p = do i <- P.many P.digit f <- P.option "" (P.char '.' >> P.many1 P.digit) if (null i && null f) then mzero else return $ fromIntegral (dec i) + fromIntegral (dec f) / fromIntegral (10 ^ (length f)) where dec = foldl' (\acc c -> acc * 10 + fromEnum c - 48) 0 parsec_laforge_discarding args = forM_ args $ \arg -> do input <- readFile arg case P.parse (P.many1 (P.char '#' >> p)) "" input of Left err -> print err Right xs -> print (length xs :: Int) where p = do i <- P.many P.digit f <- P.option "" (P.char '.' >> P.many1 P.digit) return () ---------------------------------------------------------------------- main = do args <- getArgs case args of ("attoparsec_builtin":xs) -> attoparsec_builtin xs ("attoparsec_text_builtin":xs) -> attoparsec_text_builtin xs ("attoparsec_text_laforge":xs) -> attoparsec_text_laforge xs ("attoparsec_text_laforge_discarding":xs) -> attoparsec_text_laforge_discarding xs ("parsec_laforge":xs) -> parsec_laforge xs ("parsec_laforge_discarding":xs) -> parsec_laforge_discarding xs [] -> do putStrLn "Usage: ... [attoparsec_text_builtin|attoparsec_text_laforge|parsec_laforge] inputs" putStrLn "Usage: ... [attoparsec_text_laforge_discarding|parsec_laforge_discarding] inputs"