diff --git a/parsers.cabal b/parsers.cabal --- a/parsers.cabal +++ b/parsers.cabal @@ -1,6 +1,6 @@ name: parsers category: Text, Parsing -version: 0.12.2.1 +version: 0.12.3 license: BSD3 cabal-version: >= 1.10 license-file: LICENSE @@ -11,7 +11,12 @@ bug-reports: http://github.com/ekmett/parsers/issues copyright: Copyright (C) 2010-2013 Edward A. Kmett synopsis: Parsing combinators -description: Parsing combinators +description: + This library provides convenient combinators for working with and building parsing combinator libraries. + . + Given a few simple instances, e.g. for the class 'Text.Parser.Combinators.Parsing' in "Text.Parser.Combinators.Parsing" you + get access to a large number of canned definitions. Instances exist for the parsers provided by @parsec@, + @attoparsec@ and base’s "Text.Read". build-type: Custom extra-source-files: .travis.yml @@ -20,11 +25,6 @@ type: git location: git://github.com/ekmett/parsers.git -flag lib-Werror - description: Treat warnings as errors when building. - manual: True - default: False - library default-language: Haskell2010 exposed-modules: @@ -39,23 +39,19 @@ hs-source-dirs: src - if flag(lib-Werror) - ghc-options: -Wall - else - ghc-options: -Wall - - ghc-options: -O2 + ghc-options: -Wall -fno-warn-wrong-do-bind -fwarn-monomorphism-restriction -fwarn-identities -fwarn-incomplete-record-updates -fwarn-incomplete-uni-patterns build-depends: - base >= 4 && < 5, - charset >= 0.3 && < 1, - containers >= 0.4 && < 0.6, - parsec >= 3.1 && < 3.2, - attoparsec >= 0.12.1 && < 0.14, - text >= 0.10 && < 1.3, - transformers >= 0.2 && < 0.5, - scientific >= 0.3 && < 0.4, - unordered-containers >= 0.2 && < 0.3 + base >= 4 && < 5, + base-orphans >= 0.3 && < 1, + charset >= 0.3 && < 1, + containers >= 0.4 && < 0.6, + parsec >= 3.1 && < 3.2, + attoparsec >= 0.12.1.4 && < 0.14, + text >= 0.10 && < 1.3, + transformers >= 0.2 && < 0.5, + scientific >= 0.3 && < 0.4, + unordered-containers >= 0.2 && < 0.3 -- Verify the results of the examples test-suite doctests @@ -72,8 +68,6 @@ QuickCheck, quickcheck-instances ghc-options: -Wall -threaded - if impl(ghc<7.6.1) - ghc-options: -Werror hs-source-dirs: tests test-suite quickcheck @@ -89,6 +83,4 @@ QuickCheck, quickcheck-instances ghc-options: -Wall -threaded - if impl(ghc<7.6.1) - ghc-options: -Werror hs-source-dirs: tests diff --git a/src/Text/Parser/Char.hs b/src/Text/Parser/Char.hs --- a/src/Text/Parser/Char.hs +++ b/src/Text/Parser/Char.hs @@ -46,7 +46,9 @@ , CharParsing(..) ) where +#if __GLASGOW_HASKELL__ < 710 import Control.Applicative +#endif import Control.Monad.Trans.Class import Control.Monad.Trans.State.Lazy as Lazy import Control.Monad.Trans.State.Strict as Strict @@ -62,7 +64,9 @@ import qualified Data.CharSet as CharSet import Data.Foldable import qualified Data.IntSet as IntSet +#if __GLASGOW_HASKELL__ < 710 import Data.Monoid +#endif import Data.Text import qualified Text.ParserCombinators.ReadP as ReadP import qualified Text.Parsec as Parsec @@ -81,7 +85,7 @@ {-# ANN oneOf "HLint: ignore Use String" #-} -- | As the dual of 'oneOf', @noneOf cs@ succeeds if the current --- character /not/ in the supplied list of characters @cs@. Returns the +-- character is /not/ in the supplied list of characters @cs@. Returns the -- parsed character. -- -- > consonant = noneOf "aeiou" @@ -101,7 +105,7 @@ {-# INLINE oneOfSet #-} -- | As the dual of 'oneOf', @noneOf cs@ succeeds if the current --- character /not/ in the supplied list of characters @cs@. Returns the +-- character is /not/ in the supplied list of characters @cs@. Returns the -- parsed character. -- -- > consonant = noneOf "aeiou" diff --git a/src/Text/Parser/Combinators.hs b/src/Text/Parser/Combinators.hs --- a/src/Text/Parser/Combinators.hs +++ b/src/Text/Parser/Combinators.hs @@ -57,11 +57,7 @@ ) where import Control.Applicative -#ifdef ORPHAN_ALTERNATIVE_READP -import Control.Monad (MonadPlus(..), ap) -#else import Control.Monad (MonadPlus(..)) -#endif import Control.Monad.Trans.Class import Control.Monad.Trans.State.Lazy as Lazy import Control.Monad.Trans.State.Strict as Strict @@ -72,8 +68,13 @@ import Control.Monad.Trans.Reader import Control.Monad.Trans.Identity import Data.Foldable (asum) +#if __GLASGOW_HASKELL__ < 710 import Data.Monoid +#ifdef ORPHAN_ALTERNATIVE_READP +import Data.Orphans () +#endif import Data.Traversable (sequenceA) +#endif import qualified Text.Parsec as Parsec import qualified Data.Attoparsec.Types as Att import qualified Data.Attoparsec.Combinator as Att @@ -139,13 +140,13 @@ sepEndBy p sep = sepEndBy1 p sep <|> pure [] {-# INLINE sepEndBy #-} --- | @endBy1 p sep@ parses /one/ or more occurrences of @p@, seperated +-- | @endBy1 p sep@ parses /one/ or more occurrences of @p@, separated -- and ended by @sep@. Returns a list of values returned by @p@. endBy1 :: Alternative m => m a -> m sep -> m [a] endBy1 p sep = some (p <* sep) {-# INLINE endBy1 #-} --- | @endBy p sep@ parses /zero/ or more occurrences of @p@, seperated +-- | @endBy p sep@ parses /zero/ or more occurrences of @p@, separated -- and ended by @sep@. Returns a list of values returned by @p@. -- -- > cStatements = cStatement `endBy` semi @@ -411,14 +412,3 @@ eof = ReadP.eof notFollowedBy p = ((Just <$> p) ReadP.<++ pure Nothing) >>= maybe (pure ()) (unexpected . show) - -#ifdef ORPHAN_ALTERNATIVE_READP -instance Applicative ReadP.ReadP where - pure = return - (<*>) = ap - -instance Alternative ReadP.ReadP where - empty = mzero - (<|>) = mplus -#endif - diff --git a/src/Text/Parser/Expression.hs b/src/Text/Parser/Expression.hs --- a/src/Text/Parser/Expression.hs +++ b/src/Text/Parser/Expression.hs @@ -74,22 +74,33 @@ -- expression parser that handles prefix signs, postfix increment and -- basic arithmetic. -- +-- > import Control.Applicative ((<|>)) +-- > import Text.Parser.Combinators (()) +-- > import Text.Parser.Expression +-- > import Text.Parser.Token (TokenParsing, natural, parens, reserve) +-- > import Text.Parser.Token.Style (emptyOps) +-- > +-- > expr :: (Monad m, TokenParsing m) => m Integer -- > expr = buildExpressionParser table term -- > "expression" -- > +-- > term :: (Monad m, TokenParsing m) => m Integer -- > term = parens expr -- > <|> natural -- > "simple expression" -- > +-- > table :: (Monad m, TokenParsing m) => [[Operator m Integer]] -- > table = [ [prefix "-" negate, prefix "+" id ] -- > , [postfix "++" (+1)] -- > , [binary "*" (*) AssocLeft, binary "/" (div) AssocLeft ] -- > , [binary "+" (+) AssocLeft, binary "-" (-) AssocLeft ] -- > ] -- > --- > binary name fun assoc = Infix (fun <* reservedOp name) assoc --- > prefix name fun = Prefix (fun <* reservedOp name) --- > postfix name fun = Postfix (fun <* reservedOp name) +-- > binary name fun assoc = Infix (fun <$ reservedOp name) assoc +-- > prefix name fun = Prefix (fun <$ reservedOp name) +-- > postfix name fun = Postfix (fun <$ reservedOp name) +-- > +-- > reservedOp name = reserve emptyOps name buildExpressionParser :: forall m a. (Parsing m, Applicative m) => OperatorTable m a diff --git a/src/Text/Parser/LookAhead.hs b/src/Text/Parser/LookAhead.hs --- a/src/Text/Parser/LookAhead.hs +++ b/src/Text/Parser/LookAhead.hs @@ -36,7 +36,11 @@ import Control.Monad.Trans.RWS.Strict as Strict import Control.Monad.Trans.Reader import Control.Monad.Trans.Identity +import qualified Data.Attoparsec.Types as Att +import qualified Data.Attoparsec.Combinator as Att +#if __GLASGOW_HASKELL__ < 710 import Data.Monoid +#endif import qualified Text.ParserCombinators.ReadP as ReadP import qualified Text.Parsec as Parsec import Text.Parser.Combinators @@ -80,6 +84,9 @@ instance (Parsec.Stream s m t, Show t) => LookAheadParsing (Parsec.ParsecT s u m) where lookAhead = Parsec.lookAhead + +instance Att.Chunk i => LookAheadParsing (Att.Parser i) where + lookAhead = Att.lookAhead instance LookAheadParsing ReadP.ReadP where lookAhead p = ReadP.look >>= \s -> diff --git a/src/Text/Parser/Permutation.hs b/src/Text/Parser/Permutation.hs --- a/src/Text/Parser/Permutation.hs +++ b/src/Text/Parser/Permutation.hs @@ -45,7 +45,7 @@ {-# INLINE (<||>) #-} -- | The expression @f \<$$> p@ creates a fresh permutation parser --- consisting of parser @p@. The the final result of the permutation +-- consisting of parser @p@. The final result of the permutation -- parser is the function @f@ applied to the return value of @p@. The -- parser @p@ is not allowed to accept empty input - use the optional -- combinator ('<$?>') instead. @@ -72,7 +72,7 @@ {-# INLINE (<|?>) #-} -- | The expression @f \<$?> (x,p)@ creates a fresh permutation parser --- consisting of parser @p@. The the final result of the permutation +-- consisting of parser @p@. The final result of the permutation -- parser is the function @f@ applied to the return value of @p@. The -- parser @p@ is optional - if it can not be applied, the default value -- @x@ will be used instead. diff --git a/src/Text/Parser/Token.hs b/src/Text/Parser/Token.hs --- a/src/Text/Parser/Token.hs +++ b/src/Text/Parser/Token.hs @@ -1,11 +1,11 @@ +{-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# OPTIONS_GHC -fspec-constr -fspec-constr-count=8 #-} -{-# LANGUAGE CPP #-} #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif +{-# OPTIONS_GHC -fspec-constr -fspec-constr-count=8 #-} ----------------------------------------------------------------------------- -- | -- Module : Text.Parser.Token @@ -97,12 +97,15 @@ import Data.Functor.Identity import qualified Data.HashSet as HashSet import Data.HashSet (HashSet) -import Data.List (foldl') +import Data.List (foldl', transpose) +#if __GLASGOW_HASKELL__ < 710 import Data.Monoid +#endif import Data.Scientific ( Scientific ) import qualified Data.Scientific as Sci import Data.String -import Data.Text hiding (empty,zip,foldl,foldl') +import Data.Text hiding (empty,zip,foldl,foldl',take,map,length,splitAt,null,transpose) +import Numeric (showIntAtBase) import qualified Text.ParserCombinators.ReadP as ReadP import qualified Text.Parsec as Parsec import qualified Data.Attoparsec.Types as Att @@ -579,10 +582,32 @@ escapeCode = (charEsc <|> charNum <|> charAscii <|> charControl) "escape code" where charControl = (\c -> toEnum (fromEnum c - fromEnum '@')) <$> (char '^' *> (upper <|> char '@')) - charNum = toEnum . fromInteger <$> num where - num = decimal - <|> (char 'o' *> number 8 octDigit) - <|> (char 'x' *> number 16 hexDigit) + charNum = toEnum <$> num + where + num = bounded 10 maxchar + <|> (char 'o' *> bounded 8 maxchar) + <|> (char 'x' *> bounded 16 maxchar) + maxchar = fromEnum (maxBound :: Char) + + bounded base bnd = foldl' (\x d -> base * x + digitToInt d) 0 + <$> bounded' (take base thedigits) (map digitToInt $ showIntAtBase base intToDigit bnd "") + where + thedigits = map char ['0'..'9'] ++ map oneOf (transpose [['A'..'F'],['a'..'f']]) + toomuch = unexpected "out-of-range numeric escape sequence" + bounded' dps@(zero:_) bds = skipSome zero *> ([] <$ notFollowedBy (choice dps) <|> bounded'' dps bds) + <|> bounded'' dps bds + bounded' [] _ = error "bounded called with base 0" + bounded'' dps [] = [] <$ notFollowedBy (choice dps) <|> toomuch + bounded'' dps (bd : bds) = let anyd = choice dps + nomore = notFollowedBy anyd <|> toomuch + (low, ex : high) = splitAt bd dps + in ((:) <$> choice low <*> atMost (length bds) anyd) <* nomore + <|> ((:) <$> ex <*> ([] <$ nomore <|> bounded'' dps bds)) + <|> if not (null bds) + then (:) <$> choice high <*> atMost (length bds - 1) anyd <* nomore + else empty + atMost n p | n <= 0 = pure [] + | otherwise = ((:) <$> p <*> atMost (n - 1) p) <|> pure [] charEsc = choice $ parseEsc <$> escMap parseEsc (c,code) = code <$ char c escMap = zip "abfnrtv\\\"\'" "\a\b\f\n\r\t\v\\\"\'" diff --git a/src/Text/Parser/Token/Style.hs b/src/Text/Parser/Token/Style.hs --- a/src/Text/Parser/Token/Style.hs +++ b/src/Text/Parser/Token/Style.hs @@ -1,5 +1,5 @@ -{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE CPP #-} +{-# LANGUAGE DeriveDataTypeable #-} #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702 {-# LANGUAGE Trustworthy #-} #endif @@ -42,7 +42,9 @@ import Control.Applicative import qualified Data.HashSet as HashSet import Data.HashSet (HashSet) +#if __GLASGOW_HASKELL__ < 710 import Data.Monoid +#endif import Data.Data import Text.Parser.Combinators import Text.Parser.Char diff --git a/tests/QuickCheck.hs b/tests/QuickCheck.hs --- a/tests/QuickCheck.hs +++ b/tests/QuickCheck.hs @@ -32,7 +32,7 @@ -- Instead of letting quick check pick the parser framework as a test parameter -- it may be better to just run all tests for each parser framework. -data P a = P ((Monad m, CharParsing m) => m a) +data P a = P (forall m. (Monad m, CharParsing m) => m a) data TestParser a = TestParser String (P a -> String -> Either String a)