diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown --- a/CHANGELOG.markdown +++ b/CHANGELOG.markdown @@ -1,3 +1,7 @@ +0.1.5.0 +------- +* support megaparsec-5.* + 0.1.4.0 ------- * add Megaparsec-based parsers diff --git a/pseudo-boolean.cabal b/pseudo-boolean.cabal --- a/pseudo-boolean.cabal +++ b/pseudo-boolean.cabal @@ -2,7 +2,7 @@ -- documentation, see http://haskell.org/cabal/users-guide/ name: pseudo-boolean -version: 0.1.4.0 +version: 0.1.5.0 synopsis: Reading/Writing OPB/WBO files used in pseudo boolean competition description: Reading\/Writing OPB\/WBO files used in pseudo boolean competition homepage: https://github.com/msakai/pseudo-boolean @@ -39,16 +39,17 @@ Data.PseudoBoolean.Types other-extensions: BangPatterns + ConstraintKinds CPP DeriveDataTypeable DeriveGeneric FlexibleContexts OverloadedStrings build-depends: - base >=4.6.0.1 && <4.9, + base >=4.6.0.1 && <4.10, containers >=0.4.2.1, parsec >=3.1.2 && <4, - megaparsec >=4 && <5, + megaparsec >=4 && <6, bytestring >=0.9.2.1 && <0.11, bytestring-builder, dlist >=0.7.0 && <0.8.0, diff --git a/src/Data/PseudoBoolean/Megaparsec.hs b/src/Data/PseudoBoolean/Megaparsec.hs --- a/src/Data/PseudoBoolean/Megaparsec.hs +++ b/src/Data/PseudoBoolean/Megaparsec.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE BangPatterns, FlexibleContexts #-} +{-# LANGUAGE BangPatterns, FlexibleContexts, TypeFamilies, CPP, ConstraintKinds #-} {-# OPTIONS_GHC -Wall #-} ----------------------------------------------------------------------------- -- | @@ -7,7 +7,7 @@ -- License : BSD-style -- -- Maintainer : masahiro.sakai@gmail.com --- Portability : non-portable (BangPatterns, FlexibleContexts) +-- Portability : non-portable (BangPatterns, FlexibleContexts, TypeFamilies, CPP, ConstraintKinds) -- -- A parser library for OPB file and WBO files used in pseudo boolean competition. -- @@ -38,21 +38,37 @@ import Control.Applicative ((<*)) import Control.Monad import Data.ByteString.Lazy (ByteString) +import qualified Data.ByteString.Lazy as BL import Data.Maybe import Text.Megaparsec +import Text.Megaparsec.Prim (MonadParsec ()) import Data.PseudoBoolean.Types import Data.PseudoBoolean.Internal.TextUtil +#if MIN_VERSION_megaparsec(5,0,0) +type C e s m = (MonadParsec e s m, Token s ~ Char) +#else +type C e s m = (MonadParsec s m Char) +#endif + -- | Parser for OPB files -opbParser :: Stream s Char => ParsecT s m Formula +#if MIN_VERSION_megaparsec(5,0,0) +opbParser :: (MonadParsec e s m, Token s ~ Char) => m Formula +#else +opbParser :: (MonadParsec s m Char) => m Formula +#endif opbParser = formula -- | Parser for WBO files -wboParser :: Stream s Char => ParsecT s m SoftFormula +#if MIN_VERSION_megaparsec(5,0,0) +wboParser :: (MonadParsec e s m, Token s ~ Char) => m SoftFormula +#else +wboParser :: (MonadParsec s m Char) => m SoftFormula +#endif wboParser = softformula -- ::= [] -formula :: Stream s Char => ParsecT s m Formula +formula :: C e s m => m Formula formula = do h <- optional hint sequence_of_comments @@ -66,7 +82,7 @@ , pbNumConstraints = fromMaybe (length cs) (fmap snd h) } -hint :: Stream s Char => ParsecT s m (Int,Int) +hint :: C e s m => m (Int,Int) hint = try $ do _ <- char '*' zeroOrMoreSpace @@ -81,11 +97,11 @@ return (fromIntegral nv, fromIntegral nc) -- ::= [] -sequence_of_comments :: Stream s Char => ParsecT s m () +sequence_of_comments :: C e s m => m () sequence_of_comments = skipMany comment -- XXX: we allow empty sequence -- ::= "*" -comment :: Stream s Char => ParsecT s m () +comment :: C e s m => m () comment = do _ <- char '*' _ <- manyTill anyChar eol @@ -93,18 +109,18 @@ return () -- ::= [] -sequence_of_comments_or_constraints :: Stream s Char => ParsecT s m [Constraint] +sequence_of_comments_or_constraints :: C e s m => m [Constraint] sequence_of_comments_or_constraints = do xs <- many comment_or_constraint -- We relax the grammer and allow spaces in the beginning of next component. return $ catMaybes xs -- ::= | -comment_or_constraint :: Stream s Char => ParsecT s m (Maybe Constraint) +comment_or_constraint :: C e s m => m (Maybe Constraint) comment_or_constraint = (comment >> return Nothing) <|> (liftM Just constraint) -- ::= "min:" ";" -objective :: Stream s Char => ParsecT s m Sum +objective :: C e s m => m Sum objective = do _ <- string "min:" zeroOrMoreSpace @@ -113,7 +129,7 @@ return obj -- ::= ";" -constraint :: Stream s Char => ParsecT s m Constraint +constraint :: C e s m => m Constraint constraint = do lhs <- sum op <- relational_operator @@ -124,11 +140,11 @@ return (lhs, op, rhs) -- ::= | -sum :: Stream s Char => ParsecT s m Sum +sum :: C e s m => m Sum sum = some weightedterm -- ::= -weightedterm :: Stream s Char => ParsecT s m WeightedTerm +weightedterm :: C e s m => m WeightedTerm weightedterm = do w <- integer oneOrMoreSpace @@ -137,7 +153,7 @@ return (w,t) -- ::= | "+" | "-" -integer :: Stream s Char => ParsecT s m Integer +integer :: C e s m => m Integer integer = msum [ unsigned_integer , char '+' >> unsigned_integer @@ -145,33 +161,33 @@ ] -- ::= | -unsigned_integer :: Stream s Char => ParsecT s m Integer +unsigned_integer :: C e s m => m Integer unsigned_integer = do ds <- some digitChar return $! readUnsignedInteger ds -- ::= ">=" | "=" -relational_operator :: Stream s Char => ParsecT s m Op +relational_operator :: C e s m => m Op relational_operator = (string ">=" >> return Ge) <|> (string "=" >> return Eq) -- ::= "x" -variablename :: Stream s Char => ParsecT s m Var +variablename :: C e s m => m Var variablename = do _ <- char 'x' i <- unsigned_integer return $! fromIntegral i -- ::= " " [] -oneOrMoreSpace :: Stream s Char => ParsecT s m () +oneOrMoreSpace :: C e s m => m () oneOrMoreSpace = skipSome (char ' ') -- ::= [" " ] -zeroOrMoreSpace :: Stream s Char => ParsecT s m () +zeroOrMoreSpace :: C e s m => m () -- zeroOrMoreSpace = skipMany (char ' ') zeroOrMoreSpace = space -- We relax the grammer and allow more type of spacing -semi :: Stream s Char => ParsecT s m () +semi :: C e s m => m () semi = char ';' >> space -- We relax the grammer and allow spaces in the beginning of next component. @@ -182,11 +198,11 @@ For non-linear instances, is defined as ::= -} -term :: Stream s Char => ParsecT s m Term +term :: C e s m => m Term term = oneOrMoreLiterals -- ::= | -oneOrMoreLiterals :: Stream s Char => ParsecT s m [Lit] +oneOrMoreLiterals :: C e s m => m [Lit] oneOrMoreLiterals = do l <- literal mplus (try $ oneOrMoreSpace >> liftM (l:) (oneOrMoreLiterals)) (return [l]) @@ -195,24 +211,37 @@ -- But it's not the case here. -- ::= | "~" -literal :: Stream s Char => ParsecT s m Lit +literal :: C e s m => m Lit literal = variablename <|> (char '~' >> liftM negate variablename) -- | Parse a OPB format string containing pseudo boolean problem. +#if MIN_VERSION_megaparsec(5,0,0) +parseOPBString :: String -> String -> Either (ParseError Char Dec) Formula +#else parseOPBString :: String -> String -> Either ParseError Formula +#endif parseOPBString = parse (formula <* eof) -- | Parse a OPB format lazy bytestring containing pseudo boolean problem. +#if MIN_VERSION_megaparsec(5,0,0) +parseOPBByteString :: String -> ByteString -> Either (ParseError Char Dec) Formula +#else parseOPBByteString :: String -> ByteString -> Either ParseError Formula +#endif parseOPBByteString = parse (formula <* eof) -- | Parse a OPB file containing pseudo boolean problem. +#if MIN_VERSION_megaparsec(5,0,0) +parseOPBFile :: FilePath -> IO (Either (ParseError Char Dec) Formula) +#else parseOPBFile :: FilePath -> IO (Either ParseError Formula) -parseOPBFile = parseFromFile ((formula <* eof) :: Parsec ByteString Formula) - +#endif +parseOPBFile filepath = do + s <- BL.readFile filepath + return $! parse (formula <* eof) filepath s -- ::= -softformula :: Stream s Char => ParsecT s m SoftFormula +softformula :: C e s m => m SoftFormula softformula = do h <- optional hint sequence_of_comments @@ -227,7 +256,7 @@ } -- ::= "soft:" [] ";" -softheader :: Stream s Char => ParsecT s m (Maybe Integer) +softheader :: C e s m => m (Maybe Integer) softheader = do _ <- string "soft:" zeroOrMoreSpace -- XXX @@ -237,19 +266,19 @@ return top -- ::= [] -wbo_sequence_of_comments_or_constraints :: Stream s Char => ParsecT s m [SoftConstraint] +wbo_sequence_of_comments_or_constraints :: C e s m => m [SoftConstraint] wbo_sequence_of_comments_or_constraints = do xs <- many wbo_comment_or_constraint -- XXX: we relax the grammer to allow empty sequence return $ catMaybes xs -- ::= || -wbo_comment_or_constraint :: Stream s Char => ParsecT s m (Maybe SoftConstraint) +wbo_comment_or_constraint :: C e s m => m (Maybe SoftConstraint) wbo_comment_or_constraint = (comment >> return Nothing) <|> m where m = liftM Just $ (constraint >>= \c -> return (Nothing, c)) <|> softconstraint -- ::= "[" "]" -softconstraint :: Stream s Char => ParsecT s m SoftConstraint +softconstraint :: C e s m => m SoftConstraint softconstraint = do _ <- char '[' zeroOrMoreSpace @@ -261,13 +290,27 @@ return (Just cost, c) -- | Parse a WBO format string containing weighted boolean optimization problem. +#if MIN_VERSION_megaparsec(5,0,0) +parseWBOString :: String -> String -> Either (ParseError Char Dec) SoftFormula +#else parseWBOString :: String -> String -> Either ParseError SoftFormula +#endif parseWBOString = parse (softformula <* eof) -- | Parse a WBO format lazy bytestring containing pseudo boolean problem. +#if MIN_VERSION_megaparsec(5,0,0) +parseWBOByteString :: String -> ByteString -> Either (ParseError Char Dec) SoftFormula +#else parseWBOByteString :: String -> ByteString -> Either ParseError SoftFormula +#endif parseWBOByteString = parse (softformula <* eof) -- | Parse a WBO file containing weighted boolean optimization problem. +#if MIN_VERSION_megaparsec(5,0,0) +parseWBOFile :: FilePath -> IO (Either (ParseError Char Dec) SoftFormula) +#else parseWBOFile :: FilePath -> IO (Either ParseError SoftFormula) -parseWBOFile = parseFromFile ((softformula <* eof) :: Parsec ByteString SoftFormula) +#endif +parseWBOFile filepath = do + s <- BL.readFile filepath + return $! parse (softformula <* eof) filepath s