Remove catch(...) handler occurrences.

diff --git a/xmltooling/AbstractDOMCachingXMLObject.cpp b/xmltooling/AbstractDOMCachingXMLObject.cpp
index 53564ff..77d508b 100644 (file)
--- a/xmltooling/AbstractDOMCachingXMLObject.cpp
+++ b/xmltooling/AbstractDOMCachingXMLObject.cpp
@@ -123,13 +123,10 @@ XMLObject* AbstractDOMCachingXMLObject::clone() const
             domCopy->getOwnerDocument()->release();\r
             throw UnmarshallingException("Unable to locate builder for cloned element.");\r
         }\r
-        try {\r
-            return b->buildFromElement(domCopy,true); // bind document\r
-        }\r
-        catch (...) {\r
-            domCopy->getOwnerDocument()->release();\r
-            throw;\r
-        }\r
+        XercesJanitor<DOMDocument> janitor(domCopy->getOwnerDocument());\r
+        XMLObject* ret = b->buildFromElement(domCopy,true); // bind document\r
+        janitor.release(); // safely transferred\r
+        return ret;\r
     }\r
     return NULL;\r
 }\r

diff --git a/xmltooling/encryption/impl/Encrypter.cpp b/xmltooling/encryption/impl/Encrypter.cpp
index 1ede2a2..bf08c2a 100644 (file)
--- a/xmltooling/encryption/impl/Encrypter.cpp
+++ b/xmltooling/encryption/impl/Encrypter.cpp
@@ -140,28 +140,22 @@ EncryptedData* Encrypter::encryptStream(istream& input, EncryptionParams& encPar
     DOMDocument* doc=NULL;
     try {
         doc=XMLToolingConfig::getConfig().getParser().newDocument();
+        XercesJanitor<DOMDocument> janitor(doc);
         m_cipher=XMLToolingInternalConfig::getInternalConfig().m_xsecProvider->newCipher(doc);
         
         checkParams(encParams,kencParams);
         StreamInputSource::StreamBinInputStream xstream(input);
         m_cipher->encryptBinInputStream(&xstream, ENCRYPT_NONE, encParams.m_algorithm);
         EncryptedData* xmlEncData = decorateAndUnmarshall(encParams, kencParams);
-        doc->release();
         return xmlEncData;
     }
     catch(XSECException& e) {
-        doc->release();
         auto_ptr_char temp(e.getMsg());
         throw EncryptionException(string("XMLSecurity exception while encrypting: ") + temp.get());
     }
     catch(XSECCryptoException& e) {
-        doc->release();
         throw EncryptionException(string("XMLSecurity exception while encrypting: ") + e.getMsg());
     }
-    catch (...) {
-        doc->release();
-        throw;
-    }
 }
 
 EncryptedData* Encrypter::decorateAndUnmarshall(EncryptionParams& encParams, KeyEncryptionParams* kencParams)
@@ -232,6 +226,7 @@ EncryptedKey* Encrypter::encryptKey(const unsigned char* keyBuffer, unsigned int
     DOMDocument* doc=NULL;
     try {
         doc=XMLToolingConfig::getConfig().getParser().newDocument();
+        XercesJanitor<DOMDocument> janitor(doc);
         m_cipher=XMLToolingInternalConfig::getInternalConfig().m_xsecProvider->newCipher(doc);
         m_cipher->setKEK(kencParams.m_key->clone());
         auto_ptr<XENCEncryptedKey> encKey(m_cipher->encryptKey(keyBuffer, keyBufferSize, ENCRYPT_NONE, kencParams.m_algorithm));
@@ -253,21 +248,14 @@ EncryptedKey* Encrypter::encryptKey(const unsigned char* keyBuffer, unsigned int
             kencParams.m_keyInfo=NULL;   // transfer ownership
         }
 
-        doc->release();
         xmlObjectKey.release();
         return xmlEncKey;
     }
     catch(XSECException& e) {
-        doc->release();
         auto_ptr_char temp(e.getMsg());
         throw EncryptionException(string("XMLSecurity exception while encrypting: ") + temp.get());
     }
     catch(XSECCryptoException& e) {
-        doc->release();
         throw EncryptionException(string("XMLSecurity exception while encrypting: ") + e.getMsg());
     }
-    catch (...) {
-        doc->release();
-        throw;
-    }
 }

diff --git a/xmltooling/io/AbstractXMLObjectMarshaller.cpp b/xmltooling/io/AbstractXMLObjectMarshaller.cpp
index f228875..e6a10f4 100644 (file)
--- a/xmltooling/io/AbstractXMLObjectMarshaller.cpp
+++ b/xmltooling/io/AbstractXMLObjectMarshaller.cpp
@@ -85,32 +85,26 @@ DOMElement* AbstractXMLObjectMarshaller::marshall(
         document=DOMImplementationRegistry::getDOMImplementation(NULL)->createDocument();\r
         bindDocument=true;\r
     }\r
+    \r
+    XercesJanitor<DOMDocument> janitor(bindDocument ? document : NULL);\r
 \r
-    try {\r
-        XT_log.debug("creating root element to marshall");\r
-        DOMElement* domElement = document->createElementNS(\r
-            getElementQName().getNamespaceURI(), getElementQName().getLocalPart()\r
-            );\r
-        setDocumentElement(document, domElement);\r
+    XT_log.debug("creating root element to marshall");\r
+    DOMElement* domElement = document->createElementNS(\r
+        getElementQName().getNamespaceURI(), getElementQName().getLocalPart()\r
+        );\r
+    setDocumentElement(document, domElement);\r
 #ifndef XMLTOOLING_NO_XMLSEC\r
-        marshallInto(domElement, sigs);\r
+    marshallInto(domElement, sigs);\r
 #else\r
-        marshallInto(domElement);\r
+    marshallInto(domElement);\r
 #endif\r
-        //Recache the DOM.\r
-        XT_log.debug("caching DOM for XMLObject (document is %sbound)", bindDocument ? "" : "not ");\r
-        setDOM(domElement, bindDocument);\r
-        releaseParentDOM(true);\r
+    //Recache the DOM.\r
+    XT_log.debug("caching DOM for XMLObject (document is %sbound)", bindDocument ? "" : "not ");\r
+    setDOM(domElement, bindDocument);\r
+    janitor.release();  // safely transferred\r
+    releaseParentDOM(true);\r
 \r
-        return domElement;\r
-    }\r
-    catch (...) {\r
-        // Delete the document if need be, and rethrow.\r
-        if (bindDocument) {\r
-            document->release();\r
-        }\r
-        throw;\r
-    }\r
+    return domElement;\r
 }\r
 \r
 DOMElement* AbstractXMLObjectMarshaller::marshall(\r

diff --git a/xmltooling/util/ParserPool.cpp b/xmltooling/util/ParserPool.cpp
index 4897338..8a22b6e 100644 (file)
--- a/xmltooling/util/ParserPool.cpp
+++ b/xmltooling/util/ParserPool.cpp
@@ -43,7 +43,7 @@ using namespace std;
 using namespace log4cpp;
 
 ParserPool::ParserPool(bool namespaceAware, bool schemaAware)
-    : m_namespaceAware(namespaceAware), m_schemaAware(schemaAware), m_lock(XMLPlatformUtils::makeMutex()) {}
+    : m_namespaceAware(namespaceAware), m_schemaAware(schemaAware), m_lock(Mutex::create()) {}
 
 ParserPool::~ParserPool()
 {
@@ -51,7 +51,7 @@ ParserPool::~ParserPool()
         m_pool.top()->release();
         m_pool.pop();
     }
-    XMLPlatformUtils::closeMutex(m_lock);
+    delete m_lock;
 }
 
 DOMDocument* ParserPool::newDocument()
@@ -62,14 +62,19 @@ DOMDocument* ParserPool::newDocument()
 DOMDocument* ParserPool::parse(DOMInputSource& domsrc)
 {
     DOMBuilder* parser=checkoutBuilder();
+    XercesJanitor<DOMBuilder> janitor(parser);
     try {
         DOMDocument* doc=parser->parse(domsrc);
         parser->setFeature(XMLUni::fgXercesUserAdoptsDOMDocument,true);
-        checkinBuilder(parser);
+        checkinBuilder(janitor.release());
         return doc;
     }
-    catch (...) {
-        checkinBuilder(parser);
+    catch (XMLException&) {
+        checkinBuilder(janitor.release());
+        throw;
+    }
+    catch (XMLToolingException&) {
+        checkinBuilder(janitor.release());
         throw;
     }
 }
@@ -113,7 +118,7 @@ bool ParserPool::loadSchema(const XMLCh* nsURI, const XMLCh* pathname)
         return false;
     }
 
-    XMLPlatformUtils::lockMutex(m_lock);
+    Lock lock(m_lock);
 #ifdef HAVE_GOOD_STL
     m_schemaLocMap[nsURI]=pathname;
     m_schemaLocations.erase();
@@ -124,7 +129,6 @@ bool ParserPool::loadSchema(const XMLCh* nsURI, const XMLCh* pathname)
     m_schemaLocations.erase();
     for_each(m_schemaLocMap.begin(),m_schemaLocMap.end(),doubleit<string>(m_schemaLocations,' '));
 #endif
-    XMLPlatformUtils::unlockMutex(m_lock);
 
     return true;
 }
@@ -162,19 +166,19 @@ bool ParserPool::loadCatalog(const XMLCh* pathname)
     Wrapper4InputSource domsrc(&fsrc,false);
     try {
         DOMDocument* doc=XMLToolingConfig::getConfig().getParser().parse(domsrc);
+        XercesJanitor<DOMDocument> janitor(doc);
         
         // Check root element.
         const DOMElement* root=doc->getDocumentElement();
         if (!XMLHelper::isNodeNamed(root,CATALOG_NS,catalog)) {
             auto_ptr_char temp(pathname);
             log.error("unknown root element, failed to load XML catalog from %s", temp.get());
-            doc->release();
             return false;
         }
         
         // Fetch all the <uri> elements.
         DOMNodeList* mappings=root->getElementsByTagNameNS(CATALOG_NS,uri);
-        XMLPlatformUtils::lockMutex(m_lock);
+        Lock lock(m_lock);
         for (XMLSize_t i=0; i<mappings->getLength(); i++) {
             root=static_cast<DOMElement*>(mappings->item(i));
             const XMLCh* from=root->getAttributeNS(NULL,name);
@@ -193,8 +197,6 @@ bool ParserPool::loadCatalog(const XMLCh* pathname)
 #else
         for_each(m_schemaLocMap.begin(),m_schemaLocMap.end(),doubleit<string>(m_schemaLocations,' '));
 #endif
-        XMLPlatformUtils::unlockMutex(m_lock);
-        doc->release();
     }
     catch (XMLParserException& e) {
         log.error("catalog loader caught XMLParserException: %s", e.what());
@@ -300,38 +302,29 @@ DOMBuilder* ParserPool::createBuilder()
 
 DOMBuilder* ParserPool::checkoutBuilder()
 {
-    XMLPlatformUtils::lockMutex(m_lock);
-    try {
-        if (m_pool.empty()) {
-            DOMBuilder* builder=createBuilder();
-            XMLPlatformUtils::unlockMutex(m_lock);
-            return builder;
-        }
-        DOMBuilder* p=m_pool.top();
-        m_pool.pop();
-        if (m_schemaAware) {
+    Lock lock(m_lock);
+    if (m_pool.empty()) {
+        DOMBuilder* builder=createBuilder();
+        return builder;
+    }
+    DOMBuilder* p=m_pool.top();
+    m_pool.pop();
+    if (m_schemaAware) {
 #ifdef HAVE_GOOD_STL
-            p->setProperty(XMLUni::fgXercesSchemaExternalSchemaLocation,const_cast<XMLCh*>(m_schemaLocations.c_str()));
+        p->setProperty(XMLUni::fgXercesSchemaExternalSchemaLocation,const_cast<XMLCh*>(m_schemaLocations.c_str()));
 #else
-            auto_ptr_XMLCh temp2(m_schemaLocations.c_str());
-            p->setProperty(XMLUni::fgXercesSchemaExternalSchemaLocation,const_cast<XMLCh*>(temp2.get()));
+        auto_ptr_XMLCh temp2(m_schemaLocations.c_str());
+        p->setProperty(XMLUni::fgXercesSchemaExternalSchemaLocation,const_cast<XMLCh*>(temp2.get()));
 #endif
-        }
-        XMLPlatformUtils::unlockMutex(m_lock);
-        return p;
-    }
-    catch(...) {
-        XMLPlatformUtils::unlockMutex(m_lock);
-        throw;
     }
+    return p;
 }
 
 void ParserPool::checkinBuilder(DOMBuilder* builder)
 {
     if (builder) {
-        XMLPlatformUtils::lockMutex(m_lock);
+        Lock lock(m_lock);
         m_pool.push(builder);
-        XMLPlatformUtils::unlockMutex(m_lock);
     }
 }
 
@@ -341,15 +334,16 @@ unsigned int StreamInputSource::StreamBinInputStream::readBytes(XMLByte* const t
     unsigned int bytes_read=0,request=maxToRead;
 
     // Fulfill the rest by reading from the stream.
-    if (request && !m_is.eof()) {
+    if (request && !m_is.eof() && !m_is.fail()) {
         try {
             m_is.read(reinterpret_cast<char* const>(target),request);
             m_pos+=m_is.gcount();
             bytes_read+=m_is.gcount();
         }
-        catch(...) {
-            Category::getInstance(XMLTOOLING_LOGCAT".StreamInputSource").critStream() <<
-                "XML::StreamInputSource::StreamBinInputStream::readBytes caught an exception" << CategoryStream::ENDLINE;
+        catch(ios_base::failure& e) {
+            Category::getInstance(XMLTOOLING_LOGCAT".StreamInputSource").critStream()
+                << "XML::StreamInputSource::StreamBinInputStream::readBytes caught an exception: " << e.what()
+                << CategoryStream::ENDLINE;
             *toFill=0;
             return 0;
         }

diff --git a/xmltooling/util/ParserPool.h b/xmltooling/util/ParserPool.h
index 1966656..64910df 100644 (file)
--- a/xmltooling/util/ParserPool.h
+++ b/xmltooling/util/ParserPool.h
@@ -24,6 +24,7 @@
 #define __xmltooling_pool_h__\r
 \r
 #include <xmltooling/unicode.h>\r
+#include <xmltooling/util/Threads.h>\r
 \r
 #include <map>\r
 #include <stack>\r
@@ -130,7 +131,7 @@ namespace xmltooling {
 #endif\r
         bool m_namespaceAware,m_schemaAware;\r
         std::stack<DOMBuilder*> m_pool;\r
-        void* m_lock;\r
+        Mutex* m_lock;\r
     };\r
 \r
     /**\r

diff --git a/xmltooling/util/XMLHelper.cpp b/xmltooling/util/XMLHelper.cpp
index 091fd95..7d61fdc 100644 (file)
--- a/xmltooling/util/XMLHelper.cpp
+++ b/xmltooling/util/XMLHelper.cpp
@@ -211,17 +211,11 @@ void XMLHelper::serialize(const DOMElement* e, std::string& buf)
     static const XMLCh UTF8[]={ chLatin_U, chLatin_T, chLatin_F, chDigit_8, chNull };\r
     DOMImplementation* impl=DOMImplementationRegistry::getDOMImplementation(impltype);\r
     DOMWriter* serializer=(static_cast<DOMImplementationLS*>(impl))->createDOMWriter();\r
+    XercesJanitor<DOMWriter> janitor(serializer);\r
     serializer->setEncoding(UTF8);\r
-    try {\r
-        MemBufFormatTarget target;\r
-        if (!serializer->writeNode(&target,*e))\r
-            throw XMLParserException("unable to serialize XML");\r
-        buf.erase();\r
-        buf.append(reinterpret_cast<const char*>(target.getRawBuffer()),target.getLen());\r
-        serializer->release();\r
-    }\r
-    catch (...) {\r
-        serializer->release();\r
-        throw;\r
-    }\r
+    MemBufFormatTarget target;\r
+    if (!serializer->writeNode(&target,*e))\r
+        throw XMLParserException("unable to serialize XML");\r
+    buf.erase();\r
+    buf.append(reinterpret_cast<const char*>(target.getRawBuffer()),target.getLen());\r
 }\r

diff --git a/xmltooling/util/XMLHelper.h b/xmltooling/util/XMLHelper.h
index 9f2f6fe..912c208 100644 (file)
--- a/xmltooling/util/XMLHelper.h
+++ b/xmltooling/util/XMLHelper.h
@@ -31,28 +31,28 @@ using namespace xercesc;
 namespace xmltooling {\r
     \r
     /**\r
-     * RAII wrapper for DOM Documents.\r
+     * RAII wrapper for Xerces resources.\r
      */\r
-    class XMLTOOL_API DocumentJanitor\r
+    template<class T> class XercesJanitor\r
     {\r
-        MAKE_NONCOPYABLE(DocumentJanitor);\r
-        DOMDocument* m_doc;\r
+        MAKE_NONCOPYABLE(XercesJanitor);\r
+        T* m_held;\r
     public:\r
-        DocumentJanitor(DOMDocument* doc) : m_doc(doc) {}\r
+        XercesJanitor(T* resource) : m_held(resource) {}\r
         \r
-        ~DocumentJanitor() {\r
-            if (m_doc)\r
-                m_doc->release();\r
+        ~XercesJanitor() {\r
+            if (m_held)\r
+                m_held->release();\r
         }\r
         \r
         /**\r
-         * Returns any document held by this object and releases it to the caller.\r
+         * Returns resource held by this object and releases it to the caller.\r
          * \r
-         * @return  the document held or NULL\r
+         * @return  the resource held or NULL\r
          */\r
-        DOMDocument* release() {\r
-            DOMDocument* ret=m_doc;\r
-            m_doc=NULL;\r
+        T* release() {\r
+            T* ret=m_held;\r
+            m_held=NULL;\r
             return ret;\r
         }\r
     };\r