packages feed

BerkeleyDBXML 0.7.1 → 0.7.2

raw patch · 6 files changed

+212/−35 lines, 6 filesdep ~BerkeleyDB

Dependency ranges changed: BerkeleyDB

Files

BerkeleyDBXML.cabal view
@@ -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:     <http://www.oracle.com/database/berkeley-db/xml/index.html>     .@@ -20,7 +34,7 @@     <http://www.haskell.org/haskellwiki/BerkeleyDBXML>     .     DARCS repository:-    <http://blacksapphire.com/BerkeleyDBXML/>+    <http://code.haskell.org/BerkeleyDBXML/>     .     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++
Database/Berkeley/DbXml.hs view
@@ -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
Database/Berkeley/dbxml_helper.cpp view
@@ -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)
Database/Berkeley/dbxml_helper.h view
@@ -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,
README view
@@ -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/
examples/adventure.hs view
@@ -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)