diff --git a/BerkeleyDBXML.cabal b/BerkeleyDBXML.cabal --- a/BerkeleyDBXML.cabal +++ b/BerkeleyDBXML.cabal @@ -1,5 +1,5 @@ name: BerkeleyDBXML -version: 0.7.1 +version: 0.7.2 license: BSD3 license-file: LICENSE cabal-version: >= 1.6 @@ -9,10 +9,24 @@ stability: beta synopsis: Berkeley DB XML binding description: - Berkeley DB XML is a powerful, fully transactional, XML-based database that uses - XQuery as its query language. Berkeley DB XML is built on top of Berkeley DB. - It is NOT an SQL database. + This package is a Haskell binding for Berkeley DB XML, which is a powerful, + fully transactional, XML-based database written in C++ that uses XQuery as its + query language. It is NOT an SQL database. It is not free for commercial use. . + The binding is only about 70% complete, but it should allow you to write a fairly + serious application. If you would like a particular part of the API added, + please contact me. + . + If Berkeley DB or DB XML is not installed in the default location of /usr or + /usr/local, you will need to specify the paths in this way: + . + > cabal install BerkeleyDBXML \ + > --extra-include-dirs=/usr/local/dbxml-2.5.16/include/ \ + > --extra-include-dirs=/usr/local/dbxml-2.5.16/include/dbxml/ \ + > --extra-lib-dirs=/usr/local/dbxml-2.5.16/lib/ + . + See the examples/ directory for examples. + . Berkeley DB XML home page: . @@ -20,7 +34,7 @@ . DARCS repository: - + . Changes: 0.7: Compatible (only) with dbxml 2.5. @@ -37,7 +51,7 @@ exposed-modules: Database.Berkeley.DbXml c-sources: Database/Berkeley/dbxml_helper.cpp - build-depends: base == 4.*, bytestring >= 0.9, BerkeleyDB >= 0.8.1 + build-depends: base == 4.*, bytestring >= 0.9, BerkeleyDB >= 0.8.4 include-dirs: Database/Berkeley/ - extra-libraries: db, dbxml, xqilla, xerces-c, xml2, stdc++ + extra-libraries: db, dbxml, xqilla, xerces-c, stdc++ diff --git a/Database/Berkeley/DbXml.hs b/Database/Berkeley/DbXml.hs --- a/Database/Berkeley/DbXml.hs +++ b/Database/Berkeley/DbXml.hs @@ -1,4 +1,5 @@ -{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls, TypeSynonymInstances, DeriveDataTypeable #-} +{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls, TypeSynonymInstances, + DeriveDataTypeable, FlexibleInstances #-} {-# CFILES Database/Berkeley/dbxml_helper.cpp #-} -- | Berkeley DB binding. All IO monad functions can throw DbXmlException or DbException. @@ -47,6 +48,8 @@ XmlQueryContext, xmlQueryContext_setDefaultCollection, xmlQueryContext_setVariableValue, + -- * XmlUpdateContext + XmlUpdateContext, -- * XmlQueryExpression XmlQueryExpression, xmlQueryExpression_execute, @@ -65,6 +68,18 @@ xmlString, xmlXmlDocument, xmlValue_asString, + -- * C++ integration + XmlManager_native, + xmlManager_toNative, + XmlContainer_native, + xmlContainer_toNative, + xmlContainer_fromNative, + XmlTransaction_native, + xmlTransaction_fromNative, + XmlQueryContext_native, + xmlQueryContext_fromNative, + XmlUpdateContext_native, + xmlUpdateContext_fromNative ) where import Foreign.C @@ -73,7 +88,7 @@ import Foreign.Ptr import Foreign.ForeignPtr import Foreign.Marshal.Utils -import Data.Bits +import Data.Bits import Database.Berkeley.Db import Data.Maybe import System.IO.Error @@ -95,7 +110,7 @@ charToUtf8 :: Char -> String charToUtf8 ch = let - c = ord(ch)::Int + c = ord(ch):: Int f0 = c .&. 0x3f f1 = (c `shiftR` 6) .&. 0x3f f2 = (c `shiftR` 12) .&. 0x3f @@ -111,7 +126,7 @@ charFromUtf8 :: String -> (Char, String) charFromUtf8 (ch:chs) = let - c = ord(ch)::Int + c = ord(ch):: Int in case c of _ | (c .&. 0x80) == 0 -> (c, cs) @@ -143,7 +158,7 @@ OPERATION_INTERRUPTED | -- ^ An operation was explicitly interrupted UNKNOWN_ERROR -- ^ An unexpected error code was received from Berkeley DbXML deriving (Show,Eq) - + dbxmlErrFromNum :: Int -> ExceptionCode dbxmlErrFromNum 0 = INTERNAL_ERROR dbxmlErrFromNum 1 = CONTAINER_OPEN @@ -217,6 +232,7 @@ DBXML_GEN_NAME | -- ^ generate name in putDoc DB_FLAG DbFlag -- ^ For wrapping a Berkeley DB flag +dbxmlToNum :: DbXmlFlag -> Word32 dbxmlToNum DBXML_ADOPT_DBENV = 0x00000001 dbxmlToNum DBXML_ALLOW_EXTERNAL_ACCESS = 0x00000002 dbxmlToNum DBXML_ALLOW_AUTO_OPEN = 0x00000004 @@ -238,13 +254,14 @@ dbxmlToNum DBXML_GEN_NAME = 0x02000000 dbxmlToNum (DB_FLAG f) = dbToNum f -dbxmlOrFlags flags = foldr (.|.) 0 $ map dbxmlToNum flags +dbxmlOrFlags :: [DbXmlFlag] -> Word32 +dbxmlOrFlags = foldr (.|.) 0 . map dbxmlToNum data XmlManager_struct type XmlManager = Ptr XmlManager_struct foreign import ccall safe "dbxml_helper.h _xmlManager" _xmlManager - :: Ptr DbEnv_struct -> CUInt -> Ptr XmlManager -> IO CInt + :: Ptr DbEnv_struct -> Word32 -> Ptr XmlManager -> IO CInt xmlManager_create :: DbEnv -> [DbXmlFlag] -> IO XmlManager xmlManager_create dbenv flags = @@ -255,17 +272,38 @@ then throwDBXML "xmlManager_create" ret "" else peek ptr +data XmlManager_native +foreign import ccall "dbxml_helper.h _xmlManager_toNative" _xmlManager_toNative + :: XmlManager -> Ptr (Ptr XmlManager_native) -> IO CInt + +-- | Extract a C++ pointer of type XmlManager* from the Haskell handle, which can be +-- passed to C++. +xmlManager_toNative :: XmlManager -> (Ptr XmlManager_native -> IO a) -> IO a +xmlManager_toNative mgr code = + alloca $ \pManager -> do + ret <- _xmlManager_toNative mgr pManager + if ret /= 0 + then throwDBXML "xmlManager_toNative" ret "" + else code =<< peek pManager + data XmlContainer_struct type XmlContainer = ForeignPtr XmlContainer_struct foreign import ccall "dbxml_helper.h &_xmlContainer_delete" _xmlContainer_delete :: FunPtr (Ptr XmlContainer_struct -> IO ()) +foreign import ccall "dbxml_helper.h &_xmlContainer_nullDelete" _xmlContainer_nullDelete + :: FunPtr (Ptr XmlContainer_struct -> IO ()) data ContainerType = NodeContainer | WholedocContainer foreign import ccall safe "dbxml_helper.h _xmlManager_openContainer" _xmlManager_openContainer - :: XmlManager -> CString -> CUInt -> CInt -> CInt -> Ptr (Ptr XmlContainer_struct) -> IO CInt + :: XmlManager -> CString -> Word32 -> CInt -> CInt -> Ptr (Ptr XmlContainer_struct) -> IO CInt -xmlManager_openContainer :: XmlManager -> String -> [DbXmlFlag] -> ContainerType -> Int -> IO XmlContainer +xmlManager_openContainer :: XmlManager + -> String -- ^ Container filename + -> [DbXmlFlag] + -> ContainerType -- ^ Default in C++ interface is NodeContainer + -> Int -- ^ Unix file mode + -> IO XmlContainer xmlManager_openContainer mgr filename flags cType mode = alloca $ \ptr -> withCAString filename $ \c_filename -> do @@ -294,7 +332,7 @@ :: FunPtr (Ptr XmlTransaction_struct -> IO ()) foreign import ccall safe "dbxml_helper.h _xmlManager_createTransaction" _xmlManager_createTransaction - :: XmlManager -> CUInt -> Ptr (Ptr XmlTransaction_struct) -> IO CInt + :: XmlManager -> Word32 -> Ptr (Ptr XmlTransaction_struct) -> IO CInt xmlManager_createTransaction :: XmlManager -> [DbFlag] -> IO XmlTransaction xmlManager_createTransaction mgr flags = @@ -320,6 +358,19 @@ p <- peek ptr newForeignPtr _xmlTransaction_delete p +data XmlTransaction_native +foreign import ccall "dbxml_helper.h &_xmlTransaction_nullDestructor" _xmlTransaction_nullDestructor + :: FunPtr (Ptr XmlTransaction_struct -> IO ()) +foreign import ccall unsafe "dbxml_helper.h _xmlTransaction_fromNative" _xmlTransaction_fromNative + :: Ptr XmlTransaction_native -> IO (Ptr XmlTransaction_struct) + +-- | Create a Haskell handle for a C++ transaction of type XmlTransaction*. The +-- C++ code has the responsibility of cleaning it up. +xmlTransaction_fromNative :: Ptr XmlTransaction_native -> IO XmlTransaction +xmlTransaction_fromNative nat = do + s <- _xmlTransaction_fromNative nat + newForeignPtr _xmlTransaction_nullDestructor s -- Do not clean it up when we release it + foreign import ccall safe "dbxml_helper.h _xmlTransaction_commit" _xmlTransaction_commit :: Ptr XmlTransaction_struct -> IO CInt @@ -345,8 +396,38 @@ foreign import ccall safe "dbxml_helper.h &_xmlDocument_delete" _xmlDocument_delete :: FunPtr (Ptr XmlDocument_struct -> IO ()) +data XmlContainer_native +foreign import ccall "dbxml_helper.h _xmlContainer_toNative" _xmlContainer_toNative + :: Ptr XmlContainer_struct -> Ptr (Ptr XmlContainer_native) -> IO CInt + +-- | Extract a C++ pointer of type XmlContainer* from the Haskell handle, which can be +-- passed to C++. +xmlContainer_toNative :: XmlContainer -> (Ptr XmlContainer_native -> IO a) -> IO a +xmlContainer_toNative cont code = + alloca $ \pCont -> + withForeignPtr cont $ \c_cont -> do + ret <- _xmlContainer_toNative c_cont pCont + if ret /= 0 + then throwDBXML "xmlContainer_toNative" ret "" + else code =<< peek pCont + +foreign import ccall safe "dbxml_helper.h _xmlContainer_fromNative" _xmlContainer_fromNative + :: Ptr XmlContainer_native -> Ptr (Ptr XmlContainer_struct) -> IO CInt + +-- | Make a Haskell handle from a native XmlContainer*, where the XmlContainer* is +-- managed by someone else. +xmlContainer_fromNative :: Ptr XmlContainer_native -> IO XmlContainer +xmlContainer_fromNative c_cont = + alloca $ \ptr -> do + ret <- _xmlContainer_fromNative c_cont ptr + if ret /= 0 + then throwDBXML "xmlManager_openContainer" ret "" + else do + p <- peek ptr + newForeignPtr _xmlContainer_nullDelete p + foreign import ccall safe "dbxml_helper.h _xmlContainer_getDocument" _xmlContainer_getDocument - :: Ptr XmlContainer_struct -> Ptr XmlTransaction_struct -> CString -> CUInt -> Ptr (Ptr XmlDocument_struct) -> IO CInt + :: Ptr XmlContainer_struct -> Ptr XmlTransaction_struct -> CString -> Word32 -> Ptr (Ptr XmlDocument_struct) -> IO CInt xmlContainer_getDocument :: XmlContainer -> Maybe XmlTransaction -> String -> [DbFlag] -> IO XmlDocument xmlContainer_getDocument cont mTrans key flags = @@ -488,7 +569,7 @@ -- Safe so it doesn't block other Haskell threads, since this one can take a while to execute foreign import ccall safe "dbxml_helper.h _xmlManager_query" _xmlManager_query :: Ptr XmlManager_struct -> Ptr XmlTransaction_struct -> CString -> - Ptr XmlQueryContext_struct -> CUInt -> Ptr (Ptr XmlResults_struct) -> IO CInt + Ptr XmlQueryContext_struct -> Word32 -> Ptr (Ptr XmlResults_struct) -> IO CInt xmlManager_query :: XmlManager -> Maybe XmlTransaction @@ -626,10 +707,21 @@ then throwDBXML "xmlQueryContext_setVariableValue" ret (" name="++name++" value="++(show value)) else return () +data XmlQueryContext_native +foreign import ccall "dbxml_helper.h &_xmlQueryContext_nullDestructor" _xmlQueryContext_nullDestructor + :: FunPtr (Ptr XmlQueryContext_struct -> IO ()) +foreign import ccall unsafe "dbxml_helper.h _xmlQueryContext_fromNative" _xmlQueryContext_fromNative + :: Ptr XmlQueryContext_native -> IO (Ptr XmlQueryContext_struct) + +xmlQueryContext_fromNative :: Ptr XmlQueryContext_native -> IO XmlQueryContext +xmlQueryContext_fromNative uc_c = do + uc <- _xmlQueryContext_fromNative uc_c + newForeignPtr _xmlQueryContext_nullDestructor uc + -- Safe so it doesn't block other Haskell threads, since this one can take a while to execute foreign import ccall safe "dbxml_helper.h _xmlQueryExpression_execute" _xmlQueryExpression_execute :: Ptr XmlQueryExpression_struct -> Ptr XmlTransaction_struct -> Ptr XmlValue_struct - -> Ptr XmlQueryContext_struct -> CUInt -> Ptr (Ptr XmlResults_struct) -> IO CInt + -> Ptr XmlQueryContext_struct -> Word32 -> Ptr (Ptr XmlResults_struct) -> IO CInt xmlQueryExpression_execute :: XmlQueryExpression -> Maybe XmlTransaction @@ -730,6 +822,17 @@ p <- peek ptr newForeignPtr _xmlUpdateContext_delete p +data XmlUpdateContext_native +foreign import ccall "dbxml_helper.h &_xmlUpdateContext_nullDestructor" _xmlUpdateContext_nullDestructor + :: FunPtr (Ptr XmlUpdateContext_struct -> IO ()) +foreign import ccall unsafe "dbxml_helper.h _xmlUpdateContext_fromNative" _xmlUpdateContext_fromNative + :: Ptr XmlUpdateContext_native -> IO (Ptr XmlUpdateContext_struct) + +xmlUpdateContext_fromNative :: Ptr XmlUpdateContext_native -> IO XmlUpdateContext +xmlUpdateContext_fromNative uc_c = do + uc <- _xmlUpdateContext_fromNative uc_c + newForeignPtr _xmlUpdateContext_nullDestructor uc + foreign import ccall safe "dbxml_helper.h _xmlDocument_setContent" _xmlDocument_setContent :: Ptr XmlDocument_struct -> Ptr Word8 -> CUInt -> IO CInt @@ -747,7 +850,7 @@ let (fp, fp_offset, length) = BSI.toForeignPtr bs withForeignPtr fp $ \c_fp -> code (c_fp `plusPtr` fp_offset) length - + foreign import ccall safe "dbxml_helper.h _xmlContainer_updateDocument" _xmlContainer_updateDocument :: Ptr XmlContainer_struct -> Ptr XmlTransaction_struct -> Ptr XmlDocument_struct -> Ptr XmlUpdateContext_struct -> IO CInt @@ -770,7 +873,7 @@ foreign import ccall safe "dbxml_helper.h _xmlContainer_putDocument" _xmlContainer_putDocument :: Ptr XmlContainer_struct -> Ptr XmlTransaction_struct - -> Ptr XmlDocument_struct -> Ptr XmlUpdateContext_struct -> CUInt -> IO CInt + -> Ptr XmlDocument_struct -> Ptr XmlUpdateContext_struct -> Word32 -> IO CInt xmlContainer_putDocument :: XmlContainer -> Maybe XmlTransaction -> XmlDocument -> XmlUpdateContext -> [DbXmlFlag] -> IO () @@ -812,12 +915,12 @@ foreign import ccall safe "dbxml_helper.h _xmlContainer_close" _xmlContainer_close :: Ptr XmlContainer_struct -> IO () --- | Closes a container. Equivalent to destructing the XmlContainer object in C++. +-- | Closes a container. Equivalent to destructing the XmlContainer object in C++. xmlContainer_close :: XmlContainer -> IO () xmlContainer_close cont = withForeignPtr cont $ \cont_ -> _xmlContainer_close cont_ - + foreign import ccall safe "dbxml_helper.h _xmlContainer_addIndex" _xmlContainer_addIndex :: Ptr XmlContainer_struct -> Ptr XmlTransaction_struct -> CString -> CString -> CString -> Ptr XmlUpdateContext_struct -> IO CInt @@ -886,7 +989,7 @@ foreign import ccall safe "dbxml_helper.h _xmlManager_close" _xmlManager_close :: Ptr XmlManager_struct -> IO () --- | Closes an XmlManager. Equivalent to destructing the XmlManager object in C++. +-- | Closes an XmlManager. Equivalent to destructing the XmlManager object in C++. xmlManager_close :: XmlManager -> IO () xmlManager_close mgr = _xmlManager_close mgr diff --git a/Database/Berkeley/dbxml_helper.cpp b/Database/Berkeley/dbxml_helper.cpp --- a/Database/Berkeley/dbxml_helper.cpp +++ b/Database/Berkeley/dbxml_helper.cpp @@ -93,6 +93,12 @@ } } +int _xmlManager_toNative(XmlManagerInfo* mgr, DbXml::XmlManager** pMgr) +{ + *pMgr = &mgr->mgr; + return 0; +} + void _xmlManager_close(XmlManagerInfo* mgr) { delete mgr; @@ -126,6 +132,13 @@ delete cont; } +// Delete the container reference but not the container itself, because someone +// else is managing it. +void _xmlContainer_nullDelete(DbXml::XmlContainer** cont) +{ + delete cont; +} + void _xmlContainer_close(DbXml::XmlContainer** cont) { delete *cont; @@ -166,6 +179,15 @@ delete trans; } +void _xmlTransaction_nullDestructor(DbXml::XmlTransaction* trans) +{ +} + +DbXml::XmlTransaction* _xmlTransaction_fromNative(DbXml::XmlTransaction* trans) +{ + return trans; +} + int _xmlTransaction_commit(DbXml::XmlTransaction* trans) { try { @@ -188,6 +210,19 @@ } } +int _xmlContainer_toNative(DbXml::XmlContainer** cont, DbXml::XmlContainer** pCont) +{ + *pCont = *cont; + return 0; +} + +int _xmlContainer_fromNative(DbXml::XmlContainer* cont, DbXml::XmlContainer*** container) +{ + *container = new DbXml::XmlContainer*; + **container = cont; + return 0; +} + int _xmlContainer_getDocument(DbXml::XmlContainer** cont, DbXml::XmlTransaction* trans, const char* key, u_int32_t flags, DbXml::XmlDocument** doc) { @@ -260,6 +295,15 @@ delete ctx; } +void _xmlQueryContext_nullDestructor(DbXml::XmlQueryContext*) +{ +} + +DbXml::XmlQueryContext* _xmlQueryContext_fromNative(DbXml::XmlQueryContext* qc) +{ + return qc; +} + void _xmlResults_delete(DbXml::XmlResults* res) { delete res; @@ -485,6 +529,15 @@ void _xmlUpdateContext_delete(DbXml::XmlUpdateContext* ctx) { delete ctx; +} + +void _xmlUpdateContext_nullDestructor(DbXml::XmlUpdateContext*) +{ +} + +DbXml::XmlUpdateContext* _xmlUpdateContext_fromNative(DbXml::XmlUpdateContext* uc) +{ + return uc; } int _xmlManager_createUpdateContext(XmlManagerInfo* mgr, DbXml::XmlUpdateContext** ctx) diff --git a/Database/Berkeley/dbxml_helper.h b/Database/Berkeley/dbxml_helper.h --- a/Database/Berkeley/dbxml_helper.h +++ b/Database/Berkeley/dbxml_helper.h @@ -28,17 +28,25 @@ }; int _xmlManager(DB_ENV** dbenv, u_int32_t flags, XmlManagerInfo** mgr); + int _xmlManager_toNative(XmlManagerInfo* mgr, DbXml::XmlManager** pMgr); void _xmlManager_close(XmlManagerInfo* mgr); int _xmlManager_openContainer(XmlManagerInfo* mgr, const char* name, u_int32_t flags, int cType, int mode, DbXml::XmlContainer*** container); int _xmlManager_existsContainer(XmlManagerInfo* mgr, const char* name); void _xmlContainer_delete(DbXml::XmlContainer** cont); + // Delete the container reference but not the container itself, because someone + // else is managing it. + void _xmlContainer_nullDelete(DbXml::XmlContainer** cont); void _xmlContainer_close(DbXml::XmlContainer** cont); int _xmlManager_createTransaction(XmlManagerInfo* mgr, u_int32_t flags, DbXml::XmlTransaction** trans); int _xmlManager_createTransaction_DbTxn(XmlManagerInfo* mgr, DB_TXN ** dbtxnp, DbXml::XmlTransaction** trans); void _xmlTransaction_delete(DbXml::XmlTransaction* trans); + void _xmlTransaction_nullDestructor(DbXml::XmlTransaction* trans); int _xmlTransaction_commit(DbXml::XmlTransaction* trans); int _xmlTransaction_abort(DbXml::XmlTransaction* trans); + DbXml::XmlTransaction* _xmlTransaction_fromNative(DbXml::XmlTransaction* trans); + int _xmlContainer_toNative(DbXml::XmlContainer** cont, DbXml::XmlContainer** pCont); + int _xmlContainer_fromNative(DbXml::XmlContainer* cont, DbXml::XmlContainer*** container); int _xmlContainer_getDocument(DbXml::XmlContainer** cont, DbXml::XmlTransaction* trans, const char* key, u_int32_t flags, DbXml::XmlDocument** doc); char* _xmlContainer_getName(DbXml::XmlContainer** cont); @@ -47,6 +55,8 @@ int _xmlDocument_getContent(DbXml::XmlDocument* doc, char** str, int* length); int _xmlManager_createQueryContext(XmlManagerInfo* mgr, int rt, int ev, DbXml::XmlQueryContext** ctx); void _xmlQueryContext_delete(DbXml::XmlQueryContext* ctx); + void _xmlQueryContext_nullDestructor(DbXml::XmlQueryContext*); + DbXml::XmlQueryContext* _xmlQueryContext_fromNative(DbXml::XmlQueryContext* qc); void _xmlResults_delete(DbXml::XmlResults* res); int _xmlResults_hasNext(DbXml::XmlResults* res, int* answer); int _xmlResults_nextDocument(DbXml::XmlResults* res, DbXml::XmlDocument** doc); @@ -71,6 +81,8 @@ int _xmlDocument_getName(DbXml::XmlDocument* doc, char** name); int _xmlDocument_setName(DbXml::XmlDocument* doc, const char* name); void _xmlUpdateContext_delete(DbXml::XmlUpdateContext* ctx); + void _xmlUpdateContext_nullDestructor(DbXml::XmlUpdateContext*); + DbXml::XmlUpdateContext* _xmlUpdateContext_fromNative(DbXml::XmlUpdateContext* uc); int _xmlManager_createUpdateContext(XmlManagerInfo* mgr, DbXml::XmlUpdateContext** ctx); int _xmlDocument_setContent(DbXml::XmlDocument* doc, const char* text, unsigned int length); int _xmlContainer_updateDocument(DbXml::XmlContainer** cont, DbXml::XmlTransaction* trans, diff --git a/README b/README --- a/README +++ b/README @@ -1,5 +1,5 @@ Berkeley DB / Berkeley DB XML binding for Haskell -28 Jan 2010 +6 May 2011 by Stephen Blackheath email me: http://blacksapphire.com/antispam/ @@ -8,7 +8,8 @@ Berkeley DB XML is a powerful, fully transactional, XML-based database that uses -XQuery as its query language. It is NOT an SQL database. You can download it here: +XQuery as its query language. It is NOT an SQL database. It is not free for +commercial use. You can download it here: http://www.oracle.com/database/berkeley-db/xml/index.html @@ -25,16 +26,10 @@ To install, use the standard Cabal install procedure: -cabal install - -or - -runhaskell Setup.hs install - If Berkeley DB or DB XML is not installed in the default location of /usr or /usr/local, you will need to specify the paths in this way: -cabal install \ +cabal install BerkeleyDBXML \ --extra-include-dirs=/usr/local/dbxml-2.5.16/include/ \ --extra-include-dirs=/usr/local/dbxml-2.5.16/include/dbxml/ \ --extra-lib-dirs=/usr/local/dbxml-2.5.16/lib/ diff --git a/examples/adventure.hs b/examples/adventure.hs --- a/examples/adventure.hs +++ b/examples/adventure.hs @@ -193,7 +193,7 @@ docs <- collectM (xmlResults_next res) records <- forM docs $ \doc -> do text <- xmlDocument_getContent doc - value <- case unpickleXML' defaultParserOptions (xpRoot pickler) text of + value <- case unpickleXML' defaultParseOptions (xpRoot pickler) text of Left err -> fail $ "unpickle failed: "++err Right value -> return value return (doc, value)