Thu May 31 09:13:26 UTC 2012 Johnny Willemsen <jwillemsen@remedy.nl>

        * MPC/config/dance_config_handlers.mpb:
        * MPC/config/dance_config_handlers_base.mpb:
        * dance/RepositoryManager/RepositoryManager_Impl.cpp:
        * dance/TargetManager/DomainDataManager.cpp:
        * tools/Config_Handlers/Any_Handler.h:
        * tools/Config_Handlers/Config_Handlers.mpc:
        * tools/Config_Handlers/DD_Handler.cpp:
        * tools/Config_Handlers/Package_Handlers/CAD_Handler.h:
        * tools/Config_Handlers/Package_Handlers/CID_Handler.cpp:
        * tools/Config_Handlers/Package_Handlers/CPD_Handler.h:
        * tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.h:
        * tools/Config_Handlers/Package_Handlers/Comp_Intf_Descr_Handler.cpp:
        * tools/Config_Handlers/Package_Handlers/IAD_Handler.cpp:
        * tools/Config_Handlers/Package_Handlers/PCD_Handler.cpp:
        * tools/Config_Handlers/Package_Handlers/Package_Handlers.mpc:
        * tools/Config_Handlers/Package_Handlers/SID_Handler.h:
        * tools/Config_Handlers/XML_File_Intf.cpp:
          Updated because DAnCE XML_Utils has been moved to ACE as ACE_XML_Utils

        * MPC/config/xml_utils.mpb:
        * tools/XML:
        * tools/XML/XML.mpc:
        * tools/XML/XML_Error_Handler.h:
        * tools/XML/XML_Error_Handler.cpp:
        * tools/XML/XML_Helper.h:
        * tools/XML/XML_Helper.tpp:
        * tools/XML/XML_Schema_Resolver.h:
        * tools/XML/XML_Schema_Resolver.tpp:
        * tools/XML/XML_Schema_Resolver.cpp:
        * tools/XML/XML_Typedefs.h:
        * tools/XML/XML_Typedefs.cpp:
        * tools/XML/XML_Utils_Export.h:
        * tools/XML/XercesString.h:
        * tools/XML/XercesString.cpp:
          Removed these files.

13 files changed, 1182 insertions, 0 deletions

diff --git a/ACE/ace/XML_Utils/XML.mpc b/ACE/ace/XML_Utils/XML.mpc
new file mode 100644
index 00000000000..3bd84708aec
--- /dev/null
+++ b/ACE/ace/XML_Utils/XML.mpc
@@ -0,0 +1,21 @@
+// $Id$
+
+project (ACE_XML_Utils) : install, acelib, xerces, ace_output {
+  sharedname   += ACE_XML_Utils
+  dynamicflags += XML_UTILS_BUILD_DLL
+
+  specific {
+    install_dir = ace/XML_Utils
+  }
+
+  Header_Files {
+    XML_Utils_Export.h
+  }
+
+  Source_Files {
+    XML_Error_Handler.cpp
+    XercesString.cpp
+    XML_Schema_Resolver.cpp
+    XML_Typedefs.cpp
+  }
+}
diff --git a/ACE/ace/XML_Utils/XML_Error_Handler.cpp b/ACE/ace/XML_Utils/XML_Error_Handler.cpp
new file mode 100644
index 00000000000..bc459bb4eae
--- /dev/null
+++ b/ACE/ace/XML_Utils/XML_Error_Handler.cpp
@@ -0,0 +1,67 @@
+// $Id$
+
+#include "XML_Error_Handler.h"
+#include "ace/Log_Msg.h"
+#include "ace/Auto_Ptr.h"
+#include <xercesc/util/XMLString.hpp>
+#include <xercesc/dom/DOMLocator.hpp>
+#include <xercesc/sax/SAXParseException.hpp>
+#include "XercesString.h"
+#include <iostream>
+
+using xercesc::SAXParseException;
+
+namespace XML
+{
+  XML_Error_Handler::XML_Error_Handler (void)
+    : errors_ (false)
+  {
+  }
+
+  XML_Error_Handler::~XML_Error_Handler()
+  {
+  }
+
+  void XML_Error_Handler::warning(const SAXParseException& toCatch)
+  {
+    XStr file (toCatch.getSystemId ());
+    XStr msg (toCatch.getMessage ());
+
+    std::cerr << "Warning: " << file << ':' << toCatch.getLineNumber ()
+              << ':' << toCatch.getColumnNumber () << " - "
+              << msg << std::endl;
+  }
+
+  void XML_Error_Handler::error(const SAXParseException& toCatch)
+  {
+    XStr file (toCatch.getSystemId ());
+    XStr msg (toCatch.getMessage ());
+
+    std::cerr << "Error: " << file << ':' << toCatch.getLineNumber ()
+              << ':' << toCatch.getColumnNumber () << " - "
+              << msg << std::endl;
+    this->errors_ = true;
+  }
+
+  void XML_Error_Handler::fatalError(const SAXParseException& toCatch)
+  {
+    XStr file (toCatch.getSystemId ());
+    XStr msg (toCatch.getMessage ());
+
+    std::cerr << "Fatal Error: " << file << ':' << toCatch.getLineNumber ()
+              << ':' << toCatch.getColumnNumber () << " - "
+              << msg << std::endl;
+    this->errors_ = true;
+  }
+
+  void XML_Error_Handler::resetErrors()
+  {
+    this->errors_ = false;
+  }
+
+  bool
+  XML_Error_Handler::getErrors (void) const
+  {
+    return this->errors_;
+  }
+}
diff --git a/ACE/ace/XML_Utils/XML_Error_Handler.h b/ACE/ace/XML_Utils/XML_Error_Handler.h
new file mode 100644
index 00000000000..ccc40fd308e
--- /dev/null
+++ b/ACE/ace/XML_Utils/XML_Error_Handler.h
@@ -0,0 +1,60 @@
+//==============================================================
+/**
+ *  @file  XML_Error_Handler.h
+ *
+ *  $Id$
+ *
+ *  @brief Error handler for Xerces
+ *
+ *  @author Bala Natarajan <bala@dre.vanderbilt.edu>
+ */
+//================================================================
+#ifndef ACE_XML_ERROR_HANDLER_H
+#define ACE_XML_ERROR_HANDLER_H
+
+#include /**/ "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "XML_Utils_Export.h"
+
+#include <xercesc/sax/ErrorHandler.hpp>
+
+using xercesc::SAXParseException;
+
+namespace XML
+{
+  /**
+    * @class XML_Error_Hander
+    *
+    * @brief Error handler for XERCES
+    *
+    */
+  class XML_Utils_Export XML_Error_Handler
+    : public xercesc::ErrorHandler
+  {
+  public:
+
+    XML_Error_Handler (void);
+
+    ~XML_Error_Handler (void);
+
+    void warning(const SAXParseException& toCatch);
+    void error(const SAXParseException& toCatch);
+    void fatalError(const SAXParseException& toCatch);
+    void resetErrors();
+    bool getErrors (void) const;
+  private :
+    // Disallow copying
+    XML_Error_Handler (const XML_Error_Handler&);
+    XML_Error_Handler& operator= (const XML_Error_Handler&);
+
+    bool errors_;
+  };
+}
+
+#include /**/ "ace/post.h"
+
+#endif /* ACE_XML_ERROR_HANDLER_H */
diff --git a/ACE/ace/XML_Utils/XML_Helper.h b/ACE/ace/XML_Utils/XML_Helper.h
new file mode 100644
index 00000000000..3108cce1f6a
--- /dev/null
+++ b/ACE/ace/XML_Utils/XML_Helper.h
@@ -0,0 +1,99 @@
+// $Id$
+//============================================================
+/**
+ * @file XML_Helper.h
+ *
+ * @brief Some helper functions for XML
+ *
+ * @author Bala Natarajan <bala@dre.vanderbilt.edu>
+ * @author William R. Otte <wotte@dre.vanderbilt.edu>
+ */
+//============================================================
+#ifndef ACE_XML_HELPER_H
+#define ACE_XML_HELPER_H
+#include /**/ "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "XML_Error_Handler.h"
+#include "XML_Schema_Resolver.h"
+
+#include "xercesc/util/XercesDefs.hpp"
+#include "xercesc/parsers/XercesDOMParser.hpp"
+
+#include <memory>
+
+namespace XERCES_CPP_NAMESPACE
+{
+  class DOMDocument;
+  class DOMWriter;
+  class DOMImplementation;
+  class DOMDocumentType;
+}
+
+namespace XML
+{
+  /**
+    * @class XML_Helper
+    *
+    * @brief Helper class for some routine XML stuff.
+    */
+  template <typename Resolver = XML_Schema_Resolver <>,
+            typename Error_Handler = XML_Error_Handler>
+  class XML_Helper
+  {
+  public:
+    //      XML_Helper (void);
+    XML_Helper (Resolver *resolver = 0, Error_Handler *eh = 0);
+
+    ~XML_Helper (void);
+
+    /// Create a DOM tree
+    XERCES_CPP_NAMESPACE::DOMDocument *
+    create_dom (const ACE_TCHAR *uri) const;
+
+    XERCES_CPP_NAMESPACE::DOMDocument *
+    create_dom (const ACE_TCHAR *root,
+                const ACE_TCHAR *ns,
+                XERCES_CPP_NAMESPACE::DOMDocumentType * doctype = 0) const;
+
+    XERCES_CPP_NAMESPACE::DOMDocumentType *
+    create_doctype (const ACE_TCHAR *qn,
+                    const ACE_TCHAR *pid,
+                    const ACE_TCHAR *sid) const;
+
+    /// Writes out a DOMDocument to an XML file
+    bool write_DOM (XERCES_CPP_NAMESPACE::DOMDocument *doc,
+                    const ACE_TCHAR *file) const;
+
+    bool is_initialized (void) const;
+
+    /// Terminate the parser
+    void terminate_parser (void);
+
+    Resolver &get_resolver (void);
+
+    Error_Handler &get_error_handler (void);
+
+  protected:
+    /// Intialize the parser
+    void init_parser (void);
+
+  private:
+    bool initialized_;
+    XERCES_CPP_NAMESPACE::DOMImplementation *impl_;
+    mutable std::auto_ptr<XERCES_CPP_NAMESPACE::XercesDOMParser> parser_;
+
+    Resolver *resolver_;
+    bool release_resolver_;
+    Error_Handler *e_handler_;
+    bool release_e_handler_;
+  };
+}
+
+#include "XML_Helper.tpp"
+
+#include /**/ "ace/post.h"
+#endif/*ACE_XML_HELPER_H*/
diff --git a/ACE/ace/XML_Utils/XML_Helper.tpp b/ACE/ace/XML_Utils/XML_Helper.tpp
new file mode 100644
index 00000000000..b1177ddcb56
--- /dev/null
+++ b/ACE/ace/XML_Utils/XML_Helper.tpp
@@ -0,0 +1,349 @@
+//$Id$
+#include "XML_Helper.h"
+#include "ace/Auto_Ptr.h"
+#include "ace/Log_Msg.h"
+#include "xercesc/util/XMLUniDefs.hpp"
+#include "xercesc/dom/DOM.hpp"
+#include "XML_Error_Handler.h"
+#include "XML_Schema_Resolver.h"
+#include "xercesc/framework/LocalFileFormatTarget.hpp"
+#include "xercesc/dom/DOM.hpp"
+#include "XercesString.h"
+
+#if XERCES_VERSION_MAJOR == 3
+#include "xercesc/dom/DOMLSSerializer.hpp"
+#endif
+
+namespace XML
+{
+  using xercesc::XMLException;
+  using xercesc::XMLString;
+  using xercesc::DOMImplementation;
+  using xercesc::DOMImplementationRegistry;
+//    using xercesc::DOMBuilder;
+  using xercesc::DOMImplementationLS;
+  using xercesc::XMLUni;
+  using xercesc::DOMDocument;
+  using xercesc::DOMException;
+  using xercesc::DOMDocumentType;
+  using xercesc::XercesDOMParser;
+/*
+  template <typename Resolver, typename Error>
+  XML_Helper<Resolver, Error>::XML_Helper (void)
+    : initialized_ (false)
+  {
+    this->init_parser ();
+  }
+*/
+  // TODO this is stub implementation
+  template <typename Resolver, typename Error>
+  XML_Helper<Resolver, Error>::XML_Helper (Resolver *resolver, Error *eh)
+    : initialized_ (false),
+      resolver_ (resolver),
+      release_resolver_(false),
+      e_handler_ (eh),
+      release_e_handler_ (false)
+  {
+    this->init_parser ();
+  }
+
+  template <typename Resolver, typename Error>
+  XML_Helper<Resolver, Error>::~XML_Helper (void)
+  {
+    this->terminate_parser ();
+  }
+
+  template <typename Resolver, typename Error>
+  bool
+  XML_Helper<Resolver, Error>::is_initialized (void) const
+  {
+    return this->initialized_ == true;
+  }
+
+  template <typename Resolver, typename Error>
+  void
+  XML_Helper<Resolver, Error>::init_parser (void)
+  {
+    if (this->initialized_)
+      return;
+
+    //      CIAO_DEBUG ((LM_TRACE, CLINFO
+    //"XML_Helper<>::is_initialized - Initializing the Xerces runtime \n"));
+    // Initialize the Xerces run-time
+    try
+      {
+        if (!resolver_)
+          {
+            resolver_ = new Resolver ();
+            release_resolver_ = true;
+          }
+
+        if (!e_handler_)
+          {
+            e_handler_ = new Error ();
+            release_e_handler_ = true;
+          }
+
+        xercesc::XMLPlatformUtils::Initialize();
+      }
+    catch (const XMLException& e)
+      {
+        char* message =
+          XMLString::transcode (e.getMessage());
+        ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message);
+
+        throw;
+      }
+    catch (...)
+      {
+        ACE_DEBUG ((LM_DEBUG,
+                    "(%P|%t) Some other exception,"
+                    " returning\n"));
+
+        return;
+      }
+
+    // Instantiate the DOM parser.
+    static const XMLCh gLS[] = { xercesc::chLatin_L,
+                                  xercesc::chLatin_S,
+                                  xercesc::chNull };
+
+    // Get an implementation of the Load-Store (LS) interface
+    // and cache it for later use
+    impl_ =
+      DOMImplementationRegistry::getDOMImplementation(gLS);
+
+    this->initialized_ = true;
+    return;
+  }
+
+  template <typename Resolver, typename Error>
+  XERCES_CPP_NAMESPACE::DOMDocument *
+  XML_Helper<Resolver, Error>::create_dom (const ACE_TCHAR *root,
+                                            const ACE_TCHAR *ns,
+                                            DOMDocumentType *doctype) const
+  {
+    if (root == 0 || ns == 0)
+      return 0;
+
+    return this->impl_->createDocument (XStr (ns),
+                                        XStr (root),
+                                        doctype);
+  }
+
+  template <typename Resolver, typename Error>
+  XERCES_CPP_NAMESPACE::DOMDocumentType *
+  XML_Helper<Resolver, Error>::create_doctype (const ACE_TCHAR *qn,
+                                                const ACE_TCHAR *pid,
+                                                const ACE_TCHAR *sid) const
+  {
+    return this->impl_->createDocumentType (XStr (qn),
+                                            XStr (pid),
+                                            XStr (sid));
+  }
+  template <typename Resolver, typename Error>
+  XERCES_CPP_NAMESPACE::DOMDocument *
+  XML_Helper<Resolver, Error>::create_dom (const ACE_TCHAR *url) const
+  {
+
+    if (url == 0)
+      return 0;
+
+    try
+      {
+        if (this->parser_.get () == 0)
+          this->parser_.reset ((new xercesc::XercesDOMParser ()));
+
+        // Perform Namespace processing.
+        this->parser_->setDoNamespaces (true);
+
+        // Discard comment nodes in the document
+        this->parser_->setCreateCommentNodes (false);
+
+        // Disable datatype normalization. The XML 1.0 attribute value
+        // normalization always occurs though.
+        // this->parser_->setFeature (XMLUni::fgDOMDatatypeNormalization, true);
+
+        // Do not create EntityReference nodes in the DOM tree. No
+        // EntityReference nodes will be created, only the nodes
+        // corresponding to their fully expanded sustitution text will be
+        // created.
+        this->parser_->setCreateEntityReferenceNodes (false);
+
+        // Perform Validation
+        this->parser_->setValidationScheme (xercesc::AbstractDOMParser::Val_Always);
+
+        // Do not include ignorable whitespace in the DOM tree.
+        this->parser_->setIncludeIgnorableWhitespace (false);
+
+        // Enable the parser's schema support.
+        this->parser_->setDoSchema (true);
+
+        // Enable full schema constraint checking, including checking which
+        // may be time-consuming or memory intensive. Currently, particle
+        // unique attribution constraint checking and particle derivation
+        // restriction checking are controlled by this option.
+        this->parser_->setValidationSchemaFullChecking (true);
+
+        // The parser will treat validation error as fatal and will exit.
+        this->parser_->setValidationConstraintFatal (true);
+
+        this->parser_->setErrorHandler (e_handler_);
+
+        this->parser_->setEntityResolver (resolver_);
+
+        this->parser_->parse (ACE_TEXT_ALWAYS_CHAR (url));
+
+        if (e_handler_ && e_handler_->getErrors ())
+          return 0;
+
+        return this->parser_->getDocument ();
+      }
+    catch (const DOMException& e)
+      {
+        const unsigned int maxChars = 2047;
+        XMLCh errText[maxChars + 1];
+
+        if (DOMImplementation::loadDOMExceptionMsg (e.code,
+                                                    errText,
+                                                    maxChars))
+          {
+            char* message =
+              XMLString::transcode (errText);
+            ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message);
+          }
+        return 0;
+
+      }
+    catch (const XMLException& e)
+      {
+        char* message = XMLString::transcode (e.getMessage());
+        ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message);
+        throw 0;
+      }
+    catch (...)
+      {
+        ACE_DEBUG ((LM_DEBUG,
+                    "(%P|%t) Caught an unknown exception \n"));
+        throw;
+      }
+
+    return 0;
+  }
+
+  template <typename Resolver, typename Error>
+  void
+  XML_Helper<Resolver, Error>::terminate_parser (void)
+  {
+    if (!this->initialized_)
+      return;
+
+    try
+      {
+        if (release_resolver_ && resolver_)
+          {
+            delete resolver_;
+            resolver_ = 0;
+          }
+
+        if (release_e_handler_ && e_handler_)
+          {
+            delete e_handler_;
+            e_handler_ = 0;
+          }
+
+        this->parser_.reset (0);
+        this->impl_ = 0;
+        xercesc::XMLPlatformUtils::Terminate();
+      }
+    catch (const XMLException& e)
+      {
+        char* message =
+          XMLString::transcode (e.getMessage());
+        ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message);
+        throw;
+      }
+
+    this->initialized_ = false;
+    return;
+  }
+
+  template <typename Resolver, typename Error>
+  Resolver &
+  XML_Helper<Resolver, Error>::get_resolver (void)
+  {
+    if (!this->resolver_)
+      throw std::exception ();
+
+    return *this->resolver_;
+  }
+
+  template <typename Resolver, typename Error>
+  Error &
+  XML_Helper<Resolver, Error>::get_error_handler (void)
+  {
+    if (!this->e_handler_)
+      throw std::exception ();
+
+    return *this->e_handler_;
+  }
+
+  template <typename Resolver, typename Error>
+  bool
+  XML_Helper<Resolver, Error>::write_DOM (XERCES_CPP_NAMESPACE::DOMDocument *doc,
+                                          const ACE_TCHAR *file) const
+  {
+    try
+      {
+        bool retn;
+#if XERCES_VERSION_MAJOR == 3
+        XERCES_CPP_NAMESPACE::DOMLSSerializer *serializer (impl_->createLSSerializer ());
+        XERCES_CPP_NAMESPACE::DOMConfiguration *ser_config (serializer->getDomConfig ());
+        XERCES_CPP_NAMESPACE::DOMLSOutput *output (impl_->createLSOutput ());
+
+        if (ser_config->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true))
+          ser_config->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true);
+
+        XMLFormatTarget *format_target = new XERCES_CPP_NAMESPACE::LocalFileFormatTarget (ACE_TEXT_ALWAYS_CHAR (file));
+
+        output->setByteStream (format_target);
+
+        retn = serializer->write (doc, output);
+
+        output->release ();
+        serializer->release ();
+        return retn;
+#else
+        std::auto_ptr <XERCES_CPP_NAMESPACE::DOMWriter> writer (impl_->createDOMWriter());
+
+        if (writer->canSetFeature (XMLUni::fgDOMWRTFormatPrettyPrint,
+                                    true))
+          writer->setFeature (XMLUni::fgDOMWRTFormatPrettyPrint, true);
+
+        std::auto_ptr <xercesc::XMLFormatTarget> ft (new xercesc::LocalFileFormatTarget(ACE_TEXT_ALWAYS_CHAR (file)));
+        retn = writer->writeNode(ft.get (), *doc);
+
+        return retn;
+#endif
+      }
+    catch (const xercesc::XMLException &e)
+      {
+        char* message = XMLString::transcode (e.getMessage());
+        ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message);
+
+        char* name = XMLString::transcode (e.getType());
+        ACE_Auto_Basic_Array_Ptr<char> cleanup_name (name);
+
+        ACE_ERROR ((LM_ERROR, "Caught exception while serializing DOM to file.\n"
+                    "Name: %C\n"
+                    "Message: %C\n"
+                    "SrcFile: %C\n"
+                    "SrcLine: %C\n",
+                    name,
+                    message,
+                    e.getSrcFile (),
+                    e.getSrcLine ()));
+        return false;
+      }
+  }
+}
diff --git a/ACE/ace/XML_Utils/XML_Schema_Resolver.cpp b/ACE/ace/XML_Utils/XML_Schema_Resolver.cpp
new file mode 100644
index 00000000000..a491e2d442e
--- /dev/null
+++ b/ACE/ace/XML_Utils/XML_Schema_Resolver.cpp
@@ -0,0 +1,77 @@
+// $Id$
+#include "XML_Schema_Resolver.h"
+
+#include <xercesc/util/PlatformUtils.hpp>
+#include <xercesc/util/XercesDefs.hpp>
+
+#include "XercesString.h"
+
+#include "ace/Env_Value_T.h"
+
+#include <iostream>
+
+namespace XML
+{
+  Basic_Resolver::Basic_Resolver (const ACE_TCHAR *path)
+    : path_ (path)
+  {
+  }
+
+  XMLCh *
+  Basic_Resolver::operator() (const XMLCh *const,
+                              const XMLCh *const systemId) const
+  {
+    XStr path (path_);
+    path.append (systemId);
+    return path.release ();
+  }
+
+  Environment_Resolver::Environment_Resolver (void)
+  {
+  }
+
+  Environment_Resolver::Environment_Resolver (const ACE_TCHAR *variable,
+                                              const ACE_TCHAR *relpath)
+  {
+    this->add_path (variable, relpath);
+  }
+
+  using xercesc::XMLPlatformUtils;
+
+  void
+  Environment_Resolver::add_path (const ACE_TCHAR *variable,
+                                  const ACE_TCHAR *relpath)
+  {
+    ACE_Env_Value <const ACE_TCHAR *> path_env (variable,
+                                                ACE_TEXT(""));
+
+    XStr xpath (path_env);
+    XStr xrelpath (relpath);
+
+    xpath.append (xrelpath);
+
+    paths_.push_back (xpath);
+  }
+
+  XMLCh *
+  Environment_Resolver::operator() (const XMLCh *const,
+                                    const XMLCh *const systemId) const
+  {
+    for (std::vector<XStr>::const_iterator i = this->paths_.begin ();
+          i != this->paths_.end ();
+          ++i)
+      {
+        XStr path (*i);
+        path.append(systemId);
+
+        FileHandle file (XMLPlatformUtils::openFile (path));
+
+        if (file != 0)
+          {
+            XMLPlatformUtils::closeFile (file);
+            return path.release ();
+          }
+      }
+    return 0;
+  }
+}
diff --git a/ACE/ace/XML_Utils/XML_Schema_Resolver.h b/ACE/ace/XML_Utils/XML_Schema_Resolver.h
new file mode 100644
index 00000000000..b849520d319
--- /dev/null
+++ b/ACE/ace/XML_Utils/XML_Schema_Resolver.h
@@ -0,0 +1,110 @@
+/**
+ * @file XML_Schema_Resolver.h
+ * @author Will Otte <wotte@dre.vanderbilt.edu>
+ *
+ * $Id$
+ *
+ * Resolves schema locations.
+ */
+
+#ifndef ACE_XML_SCHEMA_RESOLVER_H
+#define ACE_XML_SCHEMA_RESOLVER_H
+#include /**/ "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "XML_Utils_Export.h"
+#include "XercesString.h"
+
+#include <xercesc/sax/EntityResolver.hpp>
+#include <vector>
+#include <string>
+
+using namespace xercesc;
+
+namespace XML
+{
+  // forward decl.
+  struct NoOp_Resolver;
+
+  /**
+    * @class XML_Schema_Resolver
+    * @brief Resolves schema locations
+    *
+    * Template argument Resolver should be a functor with an operation
+    * const ACE_TCHAR * operator () (...arguments from resolveEntity...)
+    */
+  template <typename Resolver = NoOp_Resolver>
+  class XML_Schema_Resolver
+    : public virtual EntityResolver
+  {
+  public:
+    XML_Schema_Resolver (void);
+
+    XML_Schema_Resolver (Resolver &resolver);
+
+    /// This function is called by the Xerces infrastructure to
+    /// actually resolve the location of a schema.
+    virtual InputSource * resolveEntity (const XMLCh *const publicId,
+                                          const XMLCh *const systemId);
+
+    Resolver &get_resolver (void);
+
+  private:
+    XML_Schema_Resolver (XML_Schema_Resolver<Resolver> &);
+
+    Resolver resolver_;
+  };
+
+  /**
+    * @class NoOp_Resolver
+    * @brief Resolver that does nothing.
+    */
+  struct NoOp_Resolver
+  {
+    const XMLCh* operator() (const XMLCh *const,
+                              const XMLCh *const systemId) const
+    { return systemId; };
+  };
+
+  /**
+    * @class Basic_Resolver
+    * @brief Resolves a schema location from a fixed path.
+    */
+  struct Basic_Resolver
+  {
+    Basic_Resolver (const ACE_TCHAR *path);
+
+    XMLCh* operator() (const XMLCh *const publicId,
+                        const XMLCh *const systemId) const;
+    XStr path_;
+  };
+
+  /**
+    * @class Environment_Resolver
+    * @brief Resolves a schema location from a path from an environment variable.
+    */
+  struct XML_Utils_Export Environment_Resolver
+  {
+    Environment_Resolver (void);
+
+    Environment_Resolver (const ACE_TCHAR *variable,
+                          const ACE_TCHAR *path);
+
+    void add_path (const ACE_TCHAR *variable,
+                    const ACE_TCHAR *path);
+
+    XMLCh* operator() (const XMLCh *const publicId,
+                        const XMLCh *const systemId) const;
+
+    std::vector<XStr> paths_;
+  };
+}
+
+#include "XML_Schema_Resolver.tpp"
+
+#include /**/ "ace/post.h"
+
+#endif /*  ACE_XML_SCHEMA_RESOLVER_H */
diff --git a/ACE/ace/XML_Utils/XML_Schema_Resolver.tpp b/ACE/ace/XML_Utils/XML_Schema_Resolver.tpp
new file mode 100644
index 00000000000..dba9261e1af
--- /dev/null
+++ b/ACE/ace/XML_Utils/XML_Schema_Resolver.tpp
@@ -0,0 +1,52 @@
+// $Id$
+#ifndef XML_SCHEMA_RESOLVER_TPP
+#define XML_SCHEMA_RESOLVER_TPP
+
+#include "XML_Schema_Resolver.h"
+#include "XercesString.h"
+
+#include <xercesc/framework/LocalFileInputSource.hpp>
+#include <xercesc/framework/Wrapper4InputSource.hpp>
+
+using xercesc::Wrapper4InputSource;
+using xercesc::LocalFileInputSource;
+
+
+namespace XML
+{
+  template<typename Resolver>
+  XML_Schema_Resolver<Resolver>::XML_Schema_Resolver (void)
+    : resolver_ ()
+  {
+  }
+
+  template<typename Resolver>
+  XML_Schema_Resolver<Resolver>::XML_Schema_Resolver (Resolver &res)
+    : resolver_ (res)
+  {
+  }
+
+  template<typename Resolver>
+  Resolver &
+  XML_Schema_Resolver<Resolver>::get_resolver (void)
+  {
+    return resolver_;
+  }
+
+  /// This function is called by the Xerces infrastructure to
+  /// actually resolve the location of a schema.
+  template<typename Resolver>
+  InputSource *
+  XML_Schema_Resolver<Resolver>::resolveEntity (const XMLCh *const publicId,
+                                                  const XMLCh *const systemId)
+  {
+    XStr path = resolver_ (publicId, systemId);
+    if (path.begin () == 0)
+      return 0;
+
+    // Ownership of these objects is given to other people.
+    return /*new Wrapper4InputSource*/ (new LocalFileInputSource (path.begin ()));
+  }
+}
+
+#endif /*XML_SCHEMA_RESOLVER_TPP*/
diff --git a/ACE/ace/XML_Utils/XML_Typedefs.cpp b/ACE/ace/XML_Utils/XML_Typedefs.cpp
new file mode 100644
index 00000000000..bac591edc9a
--- /dev/null
+++ b/ACE/ace/XML_Utils/XML_Typedefs.cpp
@@ -0,0 +1,8 @@
+// $Id$
+
+#include "XML_Typedefs.h"
+
+namespace XML
+{
+  XML_Typedef::HELPER XML_Typedef::XML_HELPER;
+}
diff --git a/ACE/ace/XML_Utils/XML_Typedefs.h b/ACE/ace/XML_Utils/XML_Typedefs.h
new file mode 100644
index 00000000000..35a4b7d0cea
--- /dev/null
+++ b/ACE/ace/XML_Utils/XML_Typedefs.h
@@ -0,0 +1,32 @@
+/**
+ * @file XML_Typedefs.h
+ * @author William R. Otte <wotte@dre.vanderbilt.edu>
+ * $Id$
+ * Typedefs from the XML Utilities.
+ */
+#ifndef XML_TYPEDEFS_H
+#define XML_TYPEDEFS_H
+
+#include "XML_Utils_Export.h"
+#include "XML_Helper.h"
+#include "XML_Schema_Resolver.h"
+#include "XML_Error_Handler.h"
+
+namespace XML
+{
+  class XML_Utils_Export XML_Typedef
+  {
+  public:
+    typedef ::XML::Environment_Resolver PATH_RESOLVER;
+    typedef ::XML::XML_Schema_Resolver< ::XML::Environment_Resolver > XML_RESOLVER;
+    typedef ::XML::XML_Error_Handler ERROR_HANDLER;
+    typedef ::XML::XML_Helper< XML_RESOLVER, ERROR_HANDLER > HELPER;
+
+    static ERROR_HANDLER _xml_error_handler;
+
+  public:
+    static HELPER XML_HELPER;
+  };
+}
+
+#endif /* XML_TYPEDEFS_H */
diff --git a/ACE/ace/XML_Utils/XML_Utils_Export.h b/ACE/ace/XML_Utils/XML_Utils_Export.h
new file mode 100644
index 00000000000..bd8709e2b22
--- /dev/null
+++ b/ACE/ace/XML_Utils/XML_Utils_Export.h
@@ -0,0 +1,58 @@
+
+// -*- C++ -*-
+// $Id$
+// Definition for Win32 Export directives.
+// This file is generated automatically by generate_export_file.pl XML_Utils
+// ------------------------------
+#ifndef XML_UTILS_EXPORT_H
+#define XML_UTILS_EXPORT_H
+
+#include "ace/config-all.h"
+
+#if defined (ACE_AS_STATIC_LIBS) && !defined (XML_UTILS_HAS_DLL)
+#  define XML_UTILS_HAS_DLL 0
+#endif /* ACE_AS_STATIC_LIBS && XML_UTILS_HAS_DLL */
+
+#if !defined (XML_UTILS_HAS_DLL)
+#  define XML_UTILS_HAS_DLL 1
+#endif /* ! XML_UTILS_HAS_DLL */
+
+#if defined (XML_UTILS_HAS_DLL) && (XML_UTILS_HAS_DLL == 1)
+#  if defined (XML_UTILS_BUILD_DLL)
+#    define XML_Utils_Export ACE_Proper_Export_Flag
+#    define XML_UTILS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T)
+#    define XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#  else /* XML_UTILS_BUILD_DLL */
+#    define XML_Utils_Export ACE_Proper_Import_Flag
+#    define XML_UTILS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T)
+#    define XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#  endif /* XML_UTILS_BUILD_DLL */
+#else /* XML_UTILS_HAS_DLL == 1 */
+#  define XML_Utils_Export
+#  define XML_UTILS_SINGLETON_DECLARATION(T)
+#  define XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#endif /* XML_UTILS_HAS_DLL == 1 */
+
+// Set XML_UTILS_NTRACE = 0 to turn on library specific tracing even if
+// tracing is turned off for ACE.
+#if !defined (XML_UTILS_NTRACE)
+#  if (ACE_NTRACE == 1)
+#    define XML_UTILS_NTRACE 1
+#  else /* (ACE_NTRACE == 1) */
+#    define XML_UTILS_NTRACE 0
+#  endif /* (ACE_NTRACE == 1) */
+#endif /* !XML_UTILS_NTRACE */
+
+#if (XML_UTILS_NTRACE == 1)
+#  define XML_UTILS_TRACE(X)
+#else /* (XML_UTILS_NTRACE == 1) */
+#  if !defined (ACE_HAS_TRACE)
+#    define ACE_HAS_TRACE
+#  endif /* ACE_HAS_TRACE */
+#  define XML_UTILS_TRACE(X) ACE_TRACE_IMPL(X)
+#  include "ace/Trace.h"
+#endif /* (XML_UTILS_NTRACE == 1) */
+
+#endif /* XML_UTILS_EXPORT_H */
+
+// End of auto generated file.
diff --git a/ACE/ace/XML_Utils/XercesString.cpp b/ACE/ace/XML_Utils/XercesString.cpp
new file mode 100644
index 00000000000..9daf5934ce4
--- /dev/null
+++ b/ACE/ace/XML_Utils/XercesString.cpp
@@ -0,0 +1,167 @@
+// $Id$
+
+#include <ostream>
+#include <algorithm>
+
+#include "XercesString.h"
+#include "xercesc/util/PlatformUtils.hpp"
+
+using xercesc::XMLString;
+using xercesc::XMLPlatformUtils;
+
+namespace XML
+{
+// On unicode windows, ACE_TCHAR == XMLCh
+#if !defined (_MSC_VER) || !defined (ACE_USES_WCHAR)
+  XStr::XStr (const ACE_TCHAR* str)
+    : _wstr(0)
+  {
+    _wstr = XMLString::transcode(ACE_TEXT_ALWAYS_CHAR (str));
+  }
+#endif
+
+  XStr::XStr (XMLCh *wstr)
+    : _wstr(wstr)
+  {
+
+  }
+
+  XStr::XStr (const XMLCh* wstr)
+    : _wstr(0)
+  {
+    _wstr = XMLString::replicate(wstr);
+  }
+
+  XStr::XStr (const XStr &right)
+    : _wstr(0)
+  {
+    _wstr = XMLString::replicate(right._wstr);
+  }
+
+  XStr& XStr::operator= (const XStr& rhs)
+  {
+    if (&rhs == this)
+      return *this;
+    XStr temp (rhs);
+    std::swap (this->_wstr, temp._wstr);
+    return *this;
+  }
+
+  XStr::~XStr ()
+  {
+    this->reset ();
+  }
+
+  const XMLCh* XStr::begin () const
+  {
+    return _wstr;
+  }
+
+  const XMLCh* XStr::end () const
+  {
+    return _wstr + size();
+  }
+
+  bool XStr::append(const XMLCh *tail)
+  {
+    int iTailLen = XMLString::stringLen(tail);
+    int iWorkLen = XMLString::stringLen(_wstr);
+
+    XMLSize_t bytes = (iWorkLen + iTailLen + 1) * sizeof (XMLCh);
+    void *tmp = XMLPlatformUtils::fgMemoryManager->allocate (bytes);
+    XMLCh *result = reinterpret_cast<XMLCh *> (tmp);
+
+    bool bOK = result != 0;
+    if (bOK)
+      {
+        XMLCh *target = result;
+        XMLString::moveChars(target, _wstr, iWorkLen);
+        target += iWorkLen;
+        XMLString::moveChars(target, tail, iTailLen);
+        target += iTailLen;
+        *target++ = 0;
+        XMLString::release(&_wstr);
+        _wstr = result;
+      }
+    return bOK;
+  }
+
+  bool XStr::erase(const XMLCh *head, const XMLCh *tail)
+  {
+    bool bOK = head <= tail && head >= begin() && tail <= end();
+    if (bOK)
+      {
+        XMLSize_t bytes = (size() - (tail - head) + 1 ) * sizeof (XMLCh);
+        void *tmp = XMLPlatformUtils::fgMemoryManager->allocate (bytes);
+        XMLCh *result = reinterpret_cast<XMLCh *> (tmp);
+
+        XMLCh *target = result;
+        bOK = target != 0;
+        if (bOK)
+          {
+            const XMLCh *cursor = begin();
+
+            while (cursor != head) *target++ = *cursor++;
+            cursor = tail;
+            while ( cursor != end() ) *target++ = *cursor++;
+            *target ++ = 0;
+            XMLString::release(&_wstr);
+            _wstr = result;
+          }
+      }
+    return bOK;
+  }
+
+  int XStr::size () const
+  {
+    return XMLString::stringLen(_wstr);
+  }
+
+  XMLCh XStr::operator [] (const int i)
+  {
+    return _wstr[i];
+  }
+
+  XMLCh XStr::operator [] (const int i) const
+  {
+    return _wstr[i];
+  }
+
+  XMLCh * XStr::release (void)
+  {
+    XMLCh* tmp = _wstr;
+    this->_wstr = 0;
+    return tmp;
+  }
+
+  void
+  XStr::reset (void)
+  {
+    if (_wstr)
+      XMLString::release(&_wstr);
+    _wstr = 0;
+  }
+
+  bool operator== (const XStr& lhs, const XStr& rhs)
+  {
+    return XMLString::compareIString (lhs,rhs) == 0;
+  }
+
+  bool operator!= (const XStr& lhs, const XStr& rhs)
+  {
+    return !operator==(lhs, rhs);
+  }
+
+
+  std::ostream&
+  operator<< (std::ostream& o, XStr const& str)
+  {
+    char* s = XMLString::transcode (str);
+
+    o << s;
+
+    XMLString::release (&s); // idiots?
+    return o;
+  }
+
+}
diff --git a/ACE/ace/XML_Utils/XercesString.h b/ACE/ace/XML_Utils/XercesString.h
new file mode 100644
index 00000000000..81c55f74957
--- /dev/null
+++ b/ACE/ace/XML_Utils/XercesString.h
@@ -0,0 +1,82 @@
+// $Id$
+
+#ifndef _XERCESSTRING_H
+#define _XERCESSTRING_H
+
+#include /**/ "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include <iosfwd>
+
+#ifdef __BORLANDC__
+using std::memcpy;
+#endif
+
+#include <xercesc/util/XMLString.hpp>
+
+// Utility class that provides a std::string like facade to XMLString.
+// Doesn't implement all of the methods of std::string.
+#include "XML_Utils_Export.h"
+
+namespace XML
+{
+  class XML_Utils_Export XStr
+  {
+  public:
+    XStr() : _wstr(0L) { };
+
+// On unicode windows, ACE_TCHAR == XMLCh
+#if !defined (_MSC_VER) || !defined (ACE_USES_WCHAR)
+    XStr (const ACE_TCHAR* str);
+#endif
+
+    XStr (XMLCh* wstr);
+
+    XStr (const XMLCh* wstr);
+
+    XStr (const XStr& copy);
+
+    XStr& operator= (const XStr& rhs);
+
+    ~XStr();
+
+    const XMLCh* begin() const;
+
+    const XMLCh* end() const;
+
+    bool append(const XMLCh* tail);
+
+    bool erase (const XMLCh* head, const XMLCh* tail);
+
+    int size() const;
+
+    XMLCh operator [] (const int i);
+
+    XMLCh operator [] (const int i) const;
+
+    operator const XMLCh* () const { return _wstr; };
+
+    XMLCh * release (void);
+
+    /// Release the held string and free its memory.
+    void reset (void);
+  private:
+
+    XMLCh* _wstr; // Internal representation
+
+  };
+
+  XML_Utils_Export bool operator== (const XStr& lhs, const XStr& rhs);
+  XML_Utils_Export bool operator!= (const XStr& lhs, const XStr& rhs);
+
+  XML_Utils_Export std::ostream&
+  operator<< (std::ostream& o, XStr const& str);
+
+}
+
+#include /**/ "ace/post.h"
+
+#endif /* _XERCESSTRING_H */