Thu Jun 11 20:02:58 UTC 2009 John S. Kinnebrew <john.s.kinnebrew@vanderbilt.edu>

33 files changed, 1333 insertions, 229 deletions

diff --git a/ChangeLog b/ChangeLog
index 511ab2f38f6..a44fcdc00f5 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,65 @@
+Thu Jun 11 20:02:58 UTC 2009  John S. Kinnebrew  <john.s.kinnebrew@vanderbilt.edu>
+
+        * common/RACE_common.mpc:
+        * MPC/config/race_common.mpb:
+
+          RACE libraries output to $(ACE_ROOT)/lib
+
+
+        * RACE.mwc:
+        * RACE_SAPOP.mwc:
+
+          Updated with revised filenames
+
+
+        * SA_POP/SAPOP_C2W.mwc:
+        * SA_POP/SAPOP_Standalone.mwc:
+        * SA_POP/SAPOP_for_RACE.mpc:
+        * SA_POP/SAPOP_w_ACE.mpc:
+        * SA_POP/SA_POP_XML_Typedefs.cpp:
+
+          Updated for latest version of CIAO XML Utilities
+
+
+        * SA_POP/Standalone/XML_Utils/XML:
+
+        * SA_POP/Standalone/XML_Utils/XML/CIAO_XML_Utils_Export.h:
+        * SA_POP/Standalone/XML_Utils/XML/XML.mpc:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Error_Handler.h:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Error_Handler.cpp:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Helper.h:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Helper.tpp:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.h:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.tpp:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.cpp:
+        * SA_POP/Standalone/XML_Utils/XML/XercesString.h:
+        * SA_POP/Standalone/XML_Utils/XML/XercesString.cpp:
+
+        * SA_POP/Standalone/XML_Utils/XMLSchema/TypeInfo.tpp:
+        * SA_POP/Standalone/XML_Utils/XMLSchema/Types.hpp:
+
+        * SA_POP/Standalone/XML_Utils/XSCRT/Elements.hpp:
+        * SA_POP/Standalone/XML_Utils/XSCRT/Traversal.hpp:
+        * SA_POP/Standalone/XML_Utils/XSCRT/Traversal.tpp:
+        * SA_POP/Standalone/XML_Utils/XSCRT/XML.hpp:
+        * SA_POP/Standalone/XML_Utils/XSCRT/XMLSchema.hpp:
+
+          Updated to latest version of CIAO XML Utilities
+
+
+        * SA_POP/Tester/Tester_Component.mpc:
+
+          Updated for changes to CIAO and DAnCE
+
+
+        * SA_POP/SA_POP_for_RACE.mpc:
+        * SA_POP/Standalone/XML_Utils/Common.h:
+        * SA_POP/Standalone/XML_Utils/SAPOP_XSC.mpc:
+        * SA_POP/Standalone/XML_Utils/XSC_XML_Handlers_Export.h:
+
+          Removed these files for CIAO XML Utilities update.
+
+
 Wed May 27 23:44:58 UTC 2009  William R. Otte  <wotte@dre.vanderbilt.edu>
 
         * Allocator/Base/Allocator_Base.mpc:
@@ -140,8 +202,8 @@ Wed May 27 23:44:58 UTC 2009  William R. Otte  <wotte@dre.vanderbilt.edu>
         * lib:
         * utils/RACE_utils.cpp:
 
-          Updates for new CIAO. 
-        
+          Updates for new CIAO.
+
 Mon Feb  2 03:05:39 UTC 2009  William R. Otte  <wotte@dre.vanderbilt.edu>
 
         * Input_Adapters/Interactive_Input_Adapter/Admin_exec.cpp:
diff --git a/MPC/config/race_common.mpb b/MPC/config/race_common.mpb
index 7f7cb515f4a..52841173353 100644
--- a/MPC/config/race_common.mpb
+++ b/MPC/config/race_common.mpb
@@ -1,4 +1,5 @@
 project {
-  includes += $(RACE_ROOT)
+  libout     =  $(ACE_ROOT)/lib	
+  includes  +=  $(RACE_ROOT)
 }
 
diff --git a/RACE.mwc b/RACE.mwc
index f84f78c0424..ef0dc62f16d 100644
--- a/RACE.mwc
+++ b/RACE.mwc
@@ -1,14 +1,14 @@
 workspace {
   cmdline += -include $RACE_ROOT/MPC/config
   common
-  Output_Adapters/DAnCE_Output_Adapter
-  Input_Adapters
-  Data_Base
   utils
-  Conductor
   Controller/Base
-  Tester
   TM_Daemon
   TM_Proxy
   Effectors
+  Conductor
+  Output_Adapters/DAnCE_Output_Adapter
+  Input_Adapters
+  Data_Base
+  Tester
 }
diff --git a/RACE_SAPOP.mwc b/RACE_SAPOP.mwc
index 6f7f4e36008..f8971516674 100644
--- a/RACE_SAPOP.mwc
+++ b/RACE_SAPOP.mwc
@@ -11,7 +11,7 @@ workspace {
   Input_Adapters/SA_POP_Input_Adapter
   Input_Adapters/Base
   Data_Base
-  SA_POP/SA_POP_for_RACE.mpc
+  SA_POP/SAPOP_for_RACE.mpc
   SA_POP/Component/SA_POP_Component.mpc
   SA_POP/Tester/Tester_Component.mpc
 }
diff --git a/SA_POP/ChangeLog b/SA_POP/ChangeLog
index 979242ba90e..5e0bfff2443 100644
--- a/SA_POP/ChangeLog
+++ b/SA_POP/ChangeLog
@@ -1,3 +1,65 @@
+Thu Jun 11 20:02:58 UTC 2009  John S. Kinnebrew  <john.s.kinnebrew@vanderbilt.edu>
+
+        * common/RACE_common.mpc:
+        * MPC/config/race_common.mpb:
+
+          RACE libraries output to $(ACE_ROOT)/lib
+
+
+        * RACE.mwc:
+        * RACE_SAPOP.mwc:
+
+          Updated with revised filenames
+
+
+        * SA_POP/SAPOP_C2W.mwc:
+        * SA_POP/SAPOP_Standalone.mwc:
+        * SA_POP/SAPOP_for_RACE.mpc:
+        * SA_POP/SAPOP_w_ACE.mpc:
+        * SA_POP/SA_POP_XML_Typedefs.cpp:
+
+          Updated for latest version of CIAO XML Utilities
+
+
+        * SA_POP/Standalone/XML_Utils/XML:
+
+        * SA_POP/Standalone/XML_Utils/XML/CIAO_XML_Utils_Export.h:
+        * SA_POP/Standalone/XML_Utils/XML/XML.mpc:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Error_Handler.h:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Error_Handler.cpp:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Helper.h:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Helper.tpp:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.h:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.tpp:
+        * SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.cpp:
+        * SA_POP/Standalone/XML_Utils/XML/XercesString.h:
+        * SA_POP/Standalone/XML_Utils/XML/XercesString.cpp:
+
+        * SA_POP/Standalone/XML_Utils/XMLSchema/TypeInfo.tpp:
+        * SA_POP/Standalone/XML_Utils/XMLSchema/Types.hpp:
+
+        * SA_POP/Standalone/XML_Utils/XSCRT/Elements.hpp:
+        * SA_POP/Standalone/XML_Utils/XSCRT/Traversal.hpp:
+        * SA_POP/Standalone/XML_Utils/XSCRT/Traversal.tpp:
+        * SA_POP/Standalone/XML_Utils/XSCRT/XML.hpp:
+        * SA_POP/Standalone/XML_Utils/XSCRT/XMLSchema.hpp:
+
+          Updated to latest version of CIAO XML Utilities
+
+
+        * SA_POP/Tester/Tester_Component.mpc:
+
+          Updated for changes to CIAO and DAnCE
+
+
+        * SA_POP/SA_POP_for_RACE.mpc:
+        * SA_POP/Standalone/XML_Utils/Common.h:
+        * SA_POP/Standalone/XML_Utils/SAPOP_XSC.mpc:
+        * SA_POP/Standalone/XML_Utils/XSC_XML_Handlers_Export.h:
+
+          Removed these files for CIAO XML Utilities update.
+
+
 Wed May 27 23:44:58 UTC 2009  William R. Otte  <wotte@dre.vanderbilt.edu>
 
         * Component/SA_POP_Component.mpc:
diff --git a/SA_POP/SAPOP_C2W.mwc b/SA_POP/SAPOP_C2W.mwc
index fc40bd46799..4363d239248 100644
--- a/SA_POP/SAPOP_C2W.mwc
+++ b/SA_POP/SAPOP_C2W.mwc
@@ -1,5 +1,5 @@
 workspace {
-  Standalone/XML_Utils/Utils/Utils.mpc
+  Standalone/XML_Utils/XML/XML.mpc
   SAPOP_w_ACE.mpc
   C2W/C2W_Demo.mpc
 }
diff --git a/SA_POP/SAPOP_Standalone.mwc b/SA_POP/SAPOP_Standalone.mwc
index 5f44fda18f7..c963b6531e8 100644
--- a/SA_POP/SAPOP_Standalone.mwc
+++ b/SA_POP/SAPOP_Standalone.mwc
@@ -1,5 +1,5 @@
 workspace {
-  Standalone/XML_Utils/Utils/Utils.mpc
+  Standalone/XML_Utils/XML/XML.mpc
   SAPOP_w_ACE.mpc
   Standalone/SAPOP_Demo.mpc
 }
diff --git a/SA_POP/SA_POP_for_RACE.mpc b/SA_POP/SAPOP_for_RACE.mpc
index 3045b240014..6cc375d0850 100644
--- a/SA_POP/SA_POP_for_RACE.mpc
+++ b/SA_POP/SAPOP_for_RACE.mpc
@@ -3,7 +3,8 @@ project(SA_POP) : ciao_config_handlers, dance_deployment_stub, xerces, race_comm
    after += XSC_Config_Handlers
    sharedname   = SA_POP
 
-   includes += $(CIAO_ROOT)/tools/Config_Handlers \
+   includes += $(CIAO_ROOT)/tools \
+               $(CIAO_ROOT)/tools/Config_Handlers \
                $(SAPOP_ROOT)
 
    macros = SA_POP_HAS_ACE SA_POP_HAS_CIAO
@@ -13,6 +14,8 @@ project(SA_POP) : ciao_config_handlers, dance_deployment_stub, xerces, race_comm
                     SA_BUILDER_BUILD_DLL \
                     LOGSCREENOUT_BUILD_DLL
 
+   libs += CIAO_XML_Utils
+
 
    IDL_Files {
    }
@@ -49,6 +52,7 @@ project(SA_POP) : ciao_config_handlers, dance_deployment_stub, xerces, race_comm
       LogScreenOut.h
       LogFileOut.h
 
+      SA_POP_XML_Typedefs.h
       SANet/SANetFileIn.h
       TaskMapFileIn.h
    }
@@ -76,6 +80,7 @@ project(SA_POP) : ciao_config_handlers, dance_deployment_stub, xerces, race_comm
       LogScreenOut.cpp
       LogFileOut.cpp
 
+      SA_POP_XML_Typedefs.cpp
       SANet/SANetFileIn.cpp
       SANet/XML_SANet.cpp
       TaskMapFileIn.cpp
diff --git a/SA_POP/SAPOP_w_ACE.mpc b/SA_POP/SAPOP_w_ACE.mpc
index 5ef1788611c..2e9463346b2 100644
--- a/SA_POP/SAPOP_w_ACE.mpc
+++ b/SA_POP/SAPOP_w_ACE.mpc
@@ -12,15 +12,11 @@ project(SA_POP) : xerces, acelib {
    includes += $(SAPOP_ROOT) \
                $(SAPOP_ROOT)/Standalone/XML_Utils
 
-//****TEMP****TEMP****TEMP****TEMP****TEMP****TEMP****TEMP****TEMP
-// SA_POP_HAS_CIAO macro needed even for standalone due to changes
-// in CIAO XML utilities (now used in the same manner as in CIAO,
-// even when built separately for standalone version).
-   macros = SA_POP_HAS_ACE SA_POP_HAS_CIAO
-//****TEMP****TEMP****TEMP****TEMP****TEMP****TEMP****TEMP****TEMP
-
-   dynamicflags   = CIAO_XML_UTILS_BUILD_DLL \
-                    SANETFILEIN_BUILD_DLL \
+   macros = SA_POP_HAS_ACE
+
+
+
+   dynamicflags   = SANETFILEIN_BUILD_DLL \
                     TASKMAPFILEIN_BUILD_DLL \
                     SA_BUILDER_BUILD_DLL \
                     LOGSCREENOUT_BUILD_DLL \
@@ -62,13 +58,14 @@ project(SA_POP) : xerces, acelib {
       LogFileOut.h
       LogGraphOut.h
 
+      SA_POP_XML_Typedefs.h
       SANet/SANetFileIn.h
       TaskMapFileIn.h
    }
 
    Source_Files {
       SA_POP_Exceptions.cpp
-      SA_POP_XML_Typedefs.cpp
+
       SA_Builder.cpp
 
       Planner.cpp
@@ -90,6 +87,7 @@ project(SA_POP) : xerces, acelib {
       LogFileOut.cpp
       LogGraphOut.cpp
 
+      SA_POP_XML_Typedefs.cpp
       SANet/SANetFileIn.cpp
       SANet/XML_SANet.cpp
       TaskMapFileIn.cpp
diff --git a/SA_POP/SA_POP_XML_Typedefs.cpp b/SA_POP/SA_POP_XML_Typedefs.cpp
index 4030d3c0bd9..f2453a593d4 100644
--- a/SA_POP/SA_POP_XML_Typedefs.cpp
+++ b/SA_POP/SA_POP_XML_Typedefs.cpp
@@ -1,6 +1,6 @@
 // $Id$
 
-#include "XML_Typedefs.h"
+#include "SA_POP_XML_Typedefs.h"
 
 namespace SA_POP
 {
diff --git a/SA_POP/Standalone/XML_Utils/Common.h b/SA_POP/Standalone/XML_Utils/Common.h
deleted file mode 100644
index 6057cbb74be..00000000000
--- a/SA_POP/Standalone/XML_Utils/Common.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// $Id$
-/**
-* @file Common.h
-* @author Will Otte <wotte@dre.vanderbilt.edu>
-*
-* Some common definitions for all config_handlers.
-*/
-#ifndef CONFIG_HANDLERS_COMMON_H
-#define CONFIG_HANDLERS_COMMON_H
-#include <string>
-
-namespace CIAO
-{
-namespace Config_Handlers
-{
-/**
-* @class Config_Error
-* @brief Exception to communicate a config_handlers error
-*/
-class Config_Error
-{
-public:
-Config_Error (const std::string &name,
-const std::string &error) :
-name_ (name),
-error_ (error)
-{};
-
-/// Some identifying information about the element that
-/// caused the error
-std::string name_;
-
-/// A human readable error message
-std::string error_;
-
-};
-}
-}
-#endif /* CONFIG_HANDLERS_COMMON_H */
-
-
diff --git a/SA_POP/Standalone/XML_Utils/SAPOP_XSC.mpc b/SA_POP/Standalone/XML_Utils/SAPOP_XSC.mpc
deleted file mode 100644
index 23723c684a3..00000000000
--- a/SA_POP/Standalone/XML_Utils/SAPOP_XSC.mpc
+++ /dev/null
@@ -1,30 +0,0 @@
-project(SAPOP_XSC) : xscdefaults {
-  requires += xsc
- 
-//  xscflags -= --cxx-char-type ACE_TCHAR
-   xscflags += --cxx-export-symbol XSC_XML_Handlers_Export
-   xscflags += --cxx-export-header XSC_XML_Handlers_Export.h
-  xscflags += --cxx-banner-file $(SAPOP_ROOT)/docs/schema/xsc-banner.cpp
-  xscflags += --cxx-header-banner-file $(SAPOP_ROOT)/docs/schema/xsc-banner.h
-  xscflags += --cxx-enable-random-access-sequences
-
-  xscflags += --search-path "$(SAPOP_ROOT)/docs/schema"
-
-  custom_only = 1
-
-  XSC_Files {
-     xscflags += --cxx-header-regex "%Task_Map.xsd%XML_TaskMap%"
-     xscflags += --cxx-inline-regex "%Task_Map.xsd%XML_TaskMap%"
-     xscflags += --cxx-source-regex "%Task_Map.xsd%XML_TaskMap%"
-     xscflags += --cxx-namespace-regex "%.*vanderbilt.*%SA_POP/XML%"
-     Task_Map.xsd
-  }
-
-  XSC_Files {
-     xscflags += --cxx-header-regex "%SANet_Network.xsd%XML_SANet"
-     xscflags += --cxx-inline-regex "%SANet_Network.xsd%XML_SANet"
-     xscflags += --cxx-source-regex "%SANet_Network.xsd%XML_SANet"
-     xscflags += --cxx-namespace-regex "%.*vanderbilt.*%SANet/XML%"
-     SANet_Network.xsd
-  }
-}
diff --git a/SA_POP/Standalone/XML_Utils/XML/CIAO_XML_Utils_Export.h b/SA_POP/Standalone/XML_Utils/XML/CIAO_XML_Utils_Export.h
new file mode 100644
index 00000000000..f4f3ec3a1cd
--- /dev/null
+++ b/SA_POP/Standalone/XML_Utils/XML/CIAO_XML_Utils_Export.h
@@ -0,0 +1,54 @@
+
+// -*- C++ -*-
+// $Id$
+// Definition for Win32 Export directives.
+// This file is generated automatically by generate_export_file.pl CIAO_XML_Utils
+// ------------------------------
+#ifndef CIAO_XML_UTILS_EXPORT_H
+#define CIAO_XML_UTILS_EXPORT_H
+
+#include "ace/config-all.h"
+
+#if !defined (CIAO_XML_UTILS_HAS_DLL)
+#  define CIAO_XML_UTILS_HAS_DLL 1
+#endif /* ! CIAO_XML_UTILS_HAS_DLL */
+
+#if defined (CIAO_XML_UTILS_HAS_DLL) && (CIAO_XML_UTILS_HAS_DLL == 1)
+#  if defined (CIAO_XML_UTILS_BUILD_DLL)
+#    define CIAO_XML_Utils_Export ACE_Proper_Export_Flag
+#    define CIAO_XML_UTILS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T)
+#    define CIAO_XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#  else /* CIAO_XML_UTILS_BUILD_DLL */
+#    define CIAO_XML_Utils_Export ACE_Proper_Import_Flag
+#    define CIAO_XML_UTILS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T)
+#    define CIAO_XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#  endif /* CIAO_XML_UTILS_BUILD_DLL */
+#else /* CIAO_XML_UTILS_HAS_DLL == 1 */
+#  define CIAO_XML_Utils_Export
+#  define CIAO_XML_UTILS_SINGLETON_DECLARATION(T)
+#  define CIAO_XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#endif /* CIAO_XML_UTILS_HAS_DLL == 1 */
+
+// Set CIAO_XML_UTILS_NTRACE = 0 to turn on library specific tracing even if
+// tracing is turned off for ACE.
+#if !defined (CIAO_XML_UTILS_NTRACE)
+#  if (ACE_NTRACE == 1)
+#    define CIAO_XML_UTILS_NTRACE 1
+#  else /* (ACE_NTRACE == 1) */
+#    define CIAO_XML_UTILS_NTRACE 0
+#  endif /* (ACE_NTRACE == 1) */
+#endif /* !CIAO_XML_UTILS_NTRACE */
+
+#if (CIAO_XML_UTILS_NTRACE == 1)
+#  define CIAO_XML_UTILS_TRACE(X)
+#else /* (CIAO_XML_UTILS_NTRACE == 1) */
+#  if !defined (ACE_HAS_TRACE)
+#    define ACE_HAS_TRACE
+#  endif /* ACE_HAS_TRACE */
+#  define CIAO_XML_UTILS_TRACE(X) ACE_TRACE_IMPL(X)
+#  include "ace/Trace.h"
+#endif /* (CIAO_XML_UTILS_NTRACE == 1) */
+
+#endif /* CIAO_XML_UTILS_EXPORT_H */
+
+// End of auto generated file.
diff --git a/SA_POP/Standalone/XML_Utils/XML/XML.mpc b/SA_POP/Standalone/XML_Utils/XML/XML.mpc
new file mode 100644
index 00000000000..458f256e4c4
--- /dev/null
+++ b/SA_POP/Standalone/XML_Utils/XML/XML.mpc
@@ -0,0 +1,19 @@
+// $Id$
+
+project (SAPOP_XML_Utils) : acelib, xerces {
+  sharedname   += SAPOP_XML_Utils
+
+  libout = $(SAPOP_ROOT)/lib
+
+  includes += ..
+
+  dynamicflags  = CIAO_XML_UTILS_BUILD_DLL
+
+//  macros       += XML_USE_PTHREADS
+
+  Source_Files {
+    XML_Error_Handler.cpp
+    XercesString.cpp
+    XML_Schema_Resolver.cpp
+  }
+}
diff --git a/SA_POP/Standalone/XML_Utils/XML/XML_Error_Handler.cpp b/SA_POP/Standalone/XML_Utils/XML/XML_Error_Handler.cpp
new file mode 100644
index 00000000000..ba24b817649
--- /dev/null
+++ b/SA_POP/Standalone/XML_Utils/XML/XML_Error_Handler.cpp
@@ -0,0 +1,70 @@
+// $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 CIAO
+{
+  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/SA_POP/Standalone/XML_Utils/XML/XML_Error_Handler.h b/SA_POP/Standalone/XML_Utils/XML/XML_Error_Handler.h
new file mode 100644
index 00000000000..7cc65bf86a1
--- /dev/null
+++ b/SA_POP/Standalone/XML_Utils/XML/XML_Error_Handler.h
@@ -0,0 +1,63 @@
+//==============================================================
+/**
+ *  @file  XML_Error_Handler.h
+ *
+ *  $Id$
+ *
+ *  @brief Error handler for Xerces
+ *
+ *  @author Bala Natarajan <bala@dre.vanderbilt.edu>
+ */
+//================================================================
+#ifndef CIAO_XML_ERROR_HANDLER_H
+#define CIAO_XML_ERROR_HANDLER_H
+
+#include /**/ "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "XML/CIAO_XML_Utils_Export.h"
+
+#include <xercesc/sax/ErrorHandler.hpp>
+
+using xercesc::SAXParseException;
+
+namespace CIAO
+{
+  namespace XML
+  {
+    /**
+     * @class XML_Error_Hander
+     *
+     * @brief Error handler for XERCES
+     *
+     */
+    class CIAO_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 /* CIAO_XML_ERROR_HANDLER_H*/
diff --git a/SA_POP/Standalone/XML_Utils/XML/XML_Helper.h b/SA_POP/Standalone/XML_Utils/XML/XML_Helper.h
new file mode 100644
index 00000000000..69f887cbe40
--- /dev/null
+++ b/SA_POP/Standalone/XML_Utils/XML/XML_Helper.h
@@ -0,0 +1,100 @@
+// $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 CIAO_XML_HELPER_H
+#define CIAO_XML_HELPER_H
+#include /**/ "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+#include "XML/CIAO_XML_Utils_Export.h"
+#include "XML/XML_Error_Handler.h"
+#include "XML/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 CIAO
+{
+  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);
+      
+      // Initialize the resolver we should use.
+      XML_Helper (Resolver &resolver, Error_Handler &eh);
+
+      ~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;
+
+    protected:
+      /// Intialize the parser
+      void init_parser (void);
+
+      /// Terminate the parser
+      void terminate_parser (void);
+
+    private:
+      bool initialized_;
+      XERCES_CPP_NAMESPACE::DOMImplementation *impl_;
+      mutable std::auto_ptr<XERCES_CPP_NAMESPACE::XercesDOMParser> parser_;
+      
+      Resolver &resolver_;
+      Error_Handler &e_handler_;
+    };
+    
+   
+  }
+}
+
+#include "XML_Helper.tpp"
+
+#include /**/ "ace/post.h"
+#endif/*CIAO_CONFIG_HANDLERS_XML_HELPER_H*/
diff --git a/SA_POP/Standalone/XML_Utils/XML/XML_Helper.tpp b/SA_POP/Standalone/XML_Utils/XML/XML_Helper.tpp
new file mode 100644
index 00000000000..f95674dee8e
--- /dev/null
+++ b/SA_POP/Standalone/XML_Utils/XML/XML_Helper.tpp
@@ -0,0 +1,313 @@
+//$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
+
+#ifdef SA_POP_HAS_CIAO
+#include "ciao/Logger/Log_Macros.h"
+#endif
+
+namespace CIAO
+{
+  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),
+        e_handler_ (eh)
+    {
+      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;
+
+#ifdef SA_POP_HAS_CIAO
+      CIAO_DEBUG ((LM_TRACE, CLINFO
+                  "XML_Helper<>::is_initialized - Initializing the Xerces runtime \n"));
+#else
+      ACE_DEBUG ((LM_TRACE,
+                  "(%P|%t) [%M] - %T - "
+                  "XML_Helper<>::is_initialized - Initializing the Xerces runtime \n"));
+#endif
+      // Initialize the Xerces run-time
+      try
+        {
+          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 (url);
+          
+          if (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)
+    {
+      try
+        {
+          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>
+    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 (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(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: %s\n"
+                      "Message: %s\n"
+                      "SrcFile: %s\n"
+                      "SrcLine: %d\n",
+                      name,
+                      message,
+                      e.getSrcFile (),
+                      e.getSrcLine ()));
+          return false;
+        }
+    }
+  }
+}
diff --git a/SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.cpp b/SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.cpp
new file mode 100644
index 00000000000..cc78dca37cd
--- /dev/null
+++ b/SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.cpp
@@ -0,0 +1,77 @@
+// $Id$
+#include <xercesc/util/PlatformUtils.hpp>
+#include <xercesc/util/XercesDefs.hpp>
+
+#include "XML/XML_Schema_Resolver.h"
+#include "XML/XercesString.h"
+
+#include "ace/Env_Value_T.h"
+
+
+#include <iostream>
+
+namespace CIAO
+{
+  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 (const ACE_TCHAR *variable,
+                                                const ACE_TCHAR *relpath)
+    {
+      xercesc::XMLPlatformUtils::Initialize();
+      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/SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.h b/SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.h
new file mode 100644
index 00000000000..1826c8c1af6
--- /dev/null
+++ b/SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.h
@@ -0,0 +1,109 @@
+/**
+ * @file XML_Schema_Resolver.h
+ * @author Will Otte <wotte@dre.vanderbilt.edu>
+ *
+ * $Id$
+ *
+ * Resolves schema locations.
+ */
+
+#ifndef CIAO_XML_SCHEMA_RESOLVER_H
+#define CIAO_XML_SCHEMA_RESOLVER_H
+#include /**/ "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "XML/CIAO_XML_Utils_Export.h"
+#include "XML/XercesString.h"
+
+#include <xercesc/sax/EntityResolver.hpp>
+#include <vector>
+#include <string>
+
+using namespace xercesc;
+
+namespace CIAO
+{
+  namespace XML
+  {
+    // forward decl.
+    struct NoOp_Resolver;
+
+    /**
+     * @class CIAO_Schema_Resolver
+     * @brief Resolves schema locations for CIAO.
+     *
+     * 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);
+
+    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 CIAO_XML_Utils_Export Environment_Resolver
+    {
+      Environment_Resolver (const ACE_TCHAR *variable = ACE_TEXT(""),
+                            const ACE_TCHAR *path = ACE_TEXT("./"));
+
+      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/XML_Schema_Resolver.tpp"
+
+#include /**/ "ace/post.h"
+
+#endif /*  CIAO_XML_SCHEMA_RESOLVER_H */
diff --git a/SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.tpp b/SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.tpp
new file mode 100644
index 00000000000..22039e01f14
--- /dev/null
+++ b/SA_POP/Standalone/XML_Utils/XML/XML_Schema_Resolver.tpp
@@ -0,0 +1,48 @@
+// $Id$
+#ifndef XML_SCHEMA_RESOLVER_TPP
+#define XML_SCHEMA_RESOLVER_TPP
+
+#include "XML/XML_Schema_Resolver.h"
+#include "XML/XercesString.h"
+
+#include <xercesc/framework/LocalFileInputSource.hpp>
+#include <xercesc/framework/Wrapper4InputSource.hpp>
+
+using xercesc::Wrapper4InputSource;
+using xercesc::LocalFileInputSource;
+
+
+namespace CIAO
+{
+  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)
+    {
+    }
+
+    /// 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/SA_POP/Standalone/XML_Utils/XML/XercesString.cpp b/SA_POP/Standalone/XML_Utils/XML/XercesString.cpp
new file mode 100644
index 00000000000..e66d4b891ad
--- /dev/null
+++ b/SA_POP/Standalone/XML_Utils/XML/XercesString.cpp
@@ -0,0 +1,151 @@
+// $Id$
+
+#include <ostream>
+#include <algorithm>
+
+#include "XercesString.h"
+using xercesc::XMLString;
+
+namespace CIAO
+{
+  namespace XML
+  {
+
+    XStr::XStr (const char* str)
+      : _wstr(0)
+    {
+      _wstr = XMLString::transcode(str);
+    }
+
+    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 ()
+    {
+      if (_wstr)
+        XMLString::release(&_wstr);
+    }
+
+    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);
+      XMLCh *result = new XMLCh[ iWorkLen + iTailLen + 1 ];
+      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)
+        {
+          XMLCh *result = new XMLCh[ size() - (tail - head) + 1 ];
+          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;
+    }
+
+    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/SA_POP/Standalone/XML_Utils/XML/XercesString.h b/SA_POP/Standalone/XML_Utils/XML/XercesString.h
new file mode 100644
index 00000000000..c07c62ec9b0
--- /dev/null
+++ b/SA_POP/Standalone/XML_Utils/XML/XercesString.h
@@ -0,0 +1,78 @@
+// $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/CIAO_XML_Utils_Export.h"
+
+namespace CIAO
+{
+  namespace XML
+  {
+    class CIAO_XML_Utils_Export XStr
+    {
+    public:
+      XStr() : _wstr(0L) { };
+
+      XStr (const char* str);
+
+      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);
+    private:
+
+      XMLCh* _wstr; // Internal representation
+
+    };
+
+    CIAO_XML_Utils_Export bool operator== (const XStr& lhs, const XStr& rhs);
+    CIAO_XML_Utils_Export bool operator!= (const XStr& lhs, const XStr& rhs);
+
+    CIAO_XML_Utils_Export std::ostream&
+    operator<< (std::ostream& o, XStr const& str);
+
+  }
+}
+#include /**/ "ace/post.h"
+
+#endif /* _XERCESSTRING_H */
diff --git a/SA_POP/Standalone/XML_Utils/XMLSchema/TypeInfo.tpp b/SA_POP/Standalone/XML_Utils/XMLSchema/TypeInfo.tpp
index 6ead5b8f7b2..918197937b7 100644
--- a/SA_POP/Standalone/XML_Utils/XMLSchema/TypeInfo.tpp
+++ b/SA_POP/Standalone/XML_Utils/XMLSchema/TypeInfo.tpp
@@ -65,7 +65,8 @@ namespace XMLSchema
     add_info<NMTOKEN<C> > (map, 0);
     add_info<Name<C> > (map, 0);
     add_info<NCName<C> > (map, 0);
-
+    add_info<QName<C> > (map, 0);
+    
     add_info<ID<C> > (map, 0);
 
     // IDREF_Base
diff --git a/SA_POP/Standalone/XML_Utils/XMLSchema/Types.hpp b/SA_POP/Standalone/XML_Utils/XMLSchema/Types.hpp
index a23d7f2cdd9..c27c20731d2 100644
--- a/SA_POP/Standalone/XML_Utils/XMLSchema/Types.hpp
+++ b/SA_POP/Standalone/XML_Utils/XMLSchema/Types.hpp
@@ -57,9 +57,10 @@ namespace XMLSchema
   {
   protected:
     typedef basic_string<C> Base__ ;
-
+    
   public:
-
+    //    typedef ACE_Refcounted_Auto_Ptr < string, ACE_Null_Mutex > _ptr;
+    
     //@@ VC6 does not inject XSCRT::Type into the scope so I have
     //   to qualify it all the time.
     //
@@ -296,6 +297,45 @@ namespace XMLSchema
   };
 
   template <typename C>
+  class QName: public Name<C>
+  {
+  protected:
+    typedef typename Name<C>::Base__ Base__;
+
+  public:
+    QName()
+    {
+    }
+
+    QName(XSCRT::XML::Element<C> const& e)
+        : Name<C> (e)
+    {
+    }
+
+    QName(XSCRT::XML::Attribute<C> const& a)
+        : Name<C> (a)
+    {
+    }
+
+    QName(Base__ const& x)
+        : Name<C> (x)
+    {
+    }
+
+    QName (C const* x)
+        : Name<C> (x)
+    {
+    }
+
+    QName&
+    operator= (Base__ const& x)
+    {
+      static_cast<Base__&> (*this) = x;
+      return *this;
+    }
+  };
+
+  template <typename C>
   struct IdentityProvider : XSCRT::IdentityProvider
   {
     IdentityProvider (NCName<C> const& id)
diff --git a/SA_POP/Standalone/XML_Utils/XSCRT/Elements.hpp b/SA_POP/Standalone/XML_Utils/XSCRT/Elements.hpp
index 7c2b1c58d34..92f707e937f 100644
--- a/SA_POP/Standalone/XML_Utils/XSCRT/Elements.hpp
+++ b/SA_POP/Standalone/XML_Utils/XSCRT/Elements.hpp
@@ -8,9 +8,11 @@
 #include <map>
 #include <string>
 #include <sstream>
+#include <memory>
 // #include <iostream> //@@ tmp
 
 #include "XSCRT/Parser.hpp"
+#include "ace/Refcounted_Auto_Ptr.h"
 
 namespace XSCRT
 {
@@ -219,6 +221,8 @@ namespace XSCRT
   class FundamentalType : public Type
   {
   public:
+    //    typedef ACE_Refcounted_Auto_Ptr < FundamentalType, ACE_Null_Mutex > _ptr;
+    
     FundamentalType ()
     {
     }
@@ -268,7 +272,7 @@ namespace XSCRT
   };
 
 #if ((defined (__GNUC__) && (__GNUC__ == 3 && (__GNUC_MINOR__ < 3))) || \
-    (defined (__BORLANDC__) && (__BORLANDC__ == 0x564)) || \
+    (defined (__BORLANDC__) && (__BORLANDC__ == 0x610)) || \
     (defined (__SUNPRO_CC) && (__SUNPRO_CC <= 0x570)))
 
   // Stuff for broken gcc < 3.3. Don't like what you see - use better
@@ -475,8 +479,6 @@ namespace XSCRT
   //
   //
 
-#if !defined (_MSC_VER) || (_MSC_VER >= 1300)
-
   template<>
   template<>
   inline
@@ -512,58 +514,6 @@ namespace XSCRT
   {
     x_ = (a.value () == L"true") || (a.value () == L"1");
   }
-
-#else
-
-  template <>
-  class FundamentalType<bool> : public Type
-  {
-  public:
-    FundamentalType ()
-    {
-    }
-
-    template<typename C>
-    FundamentalType (XML::Element<C> const& e)
-    {
-      x_ = (e.value ()[0] == 't') || (e.value ()[0] == '1');
-    }
-
-    template<typename C>
-    FundamentalType (XML::Attribute<C> const& a)
-    {
-      x_ = (a.value ()[0] == 't') || (a.value ()[0] == '1');
-    }
-
-    FundamentalType (bool const& x)
-        : x_ (x)
-    {
-    }
-
-    FundamentalType&
-    operator= (bool const& x)
-    {
-      x_ = x;
-      return *this;
-    }
-
-  public:
-    operator bool const& () const
-    {
-      return x_;
-    }
-
-    operator bool& ()
-    {
-      return x_;
-    }
-
-  protected:
-    bool x_;
-  };
-
-#endif
-
 }
 
 #include "XSCRT/Elements.ipp"
diff --git a/SA_POP/Standalone/XML_Utils/XSCRT/Traversal.hpp b/SA_POP/Standalone/XML_Utils/XSCRT/Traversal.hpp
index 2dc957a9e79..482d5fc77e1 100644
--- a/SA_POP/Standalone/XML_Utils/XSCRT/Traversal.hpp
+++ b/SA_POP/Standalone/XML_Utils/XSCRT/Traversal.hpp
@@ -9,10 +9,6 @@
 #include <set>
 #include <vector>
 
-// #include <iostream>
-// using std::wcerr;
-// using std::endl;
-
 #include "XSCRT/ExtendedTypeInfo.hpp"
 
 namespace XSCRT
@@ -36,11 +32,6 @@ namespace XSCRT
 
       virtual void
       trampoline (B const& n) = 0;
-
-      /*@@ VC6
-      template <typename X>
-      friend class DispatcherBase;
-      */
     };
 
 
@@ -64,7 +55,7 @@ namespace XSCRT
       map (TypeId id, TraverserBase<B>& t)
       {
         //wcerr << "map for " << id.name () << " to " << &t
-        //      << " in " << &traversal_map_ << endl;
+    //      << " in " << &traversal_map_ << endl;
 
         //@@ VC6
         Traversers& traversers = traversal_map_[id];
diff --git a/SA_POP/Standalone/XML_Utils/XSCRT/Traversal.tpp b/SA_POP/Standalone/XML_Utils/XSCRT/Traversal.tpp
index b798178621b..51889c0fb9b 100644
--- a/SA_POP/Standalone/XML_Utils/XSCRT/Traversal.tpp
+++ b/SA_POP/Standalone/XML_Utils/XSCRT/Traversal.tpp
@@ -80,7 +80,7 @@ namespace XSCRT
 
         // Remove traversed types from the level map.
         //
-	//@@ VC6
+    //@@ VC6
         {
           for (typename TypeInfoSet::const_iterator i = dispatched.begin ();
                i != dispatched.end ();
@@ -88,7 +88,7 @@ namespace XSCRT
           {
             levels.erase (*i);
           }
-	}
+    }
       }
     }
 
@@ -145,7 +145,7 @@ namespace XSCRT
 
         // Remove traversed types from the level map.
         //
-	//@@ VC6
+    //@@ VC6
         {
           for (typename TypeInfoSet::const_iterator i = dispatched.begin ();
                i != dispatched.end ();
@@ -153,7 +153,7 @@ namespace XSCRT
           {
             levels.erase (*i);
           }
-	}
+    }
       }
     }
 
diff --git a/SA_POP/Standalone/XML_Utils/XSCRT/XML.hpp b/SA_POP/Standalone/XML_Utils/XSCRT/XML.hpp
index 1f11533e2bb..8f21ea8263d 100644
--- a/SA_POP/Standalone/XML_Utils/XSCRT/XML.hpp
+++ b/SA_POP/Standalone/XML_Utils/XSCRT/XML.hpp
@@ -462,8 +462,11 @@ namespace XSCRT
     {
       string xns (ns);
 
-      XMLCh const* p (
-        e.dom_element ()->lookupNamespacePrefix (xns.c_str (), false));
+#if defined(XERCES_VERSION_MAJOR) && XERCES_VERSION_MAJOR > 2
+      XMLCh const* p (e.dom_element ()->lookupPrefix (xns.c_str ()));
+#else
+      XMLCh const* p (e.dom_element ()->lookupNamespacePrefix (xns.c_str (), false));
+#endif
 
       if (p == 0)
       {
diff --git a/SA_POP/Standalone/XML_Utils/XSCRT/XMLSchema.hpp b/SA_POP/Standalone/XML_Utils/XSCRT/XMLSchema.hpp
index 6f810782953..95575267eee 100644
--- a/SA_POP/Standalone/XML_Utils/XSCRT/XMLSchema.hpp
+++ b/SA_POP/Standalone/XML_Utils/XSCRT/XMLSchema.hpp
@@ -258,6 +258,40 @@ namespace XMLSchema
   };
 
   template <typename C>
+  class QName: public Name<C>
+  {
+  protected:
+    typedef typename Name<C>::Base__ Base__;
+
+  public:
+    QName()
+    {
+    }
+
+    QName(XSCRT::XML::Element<C> const& e)
+        : Name<C> (e)
+    {
+    }
+
+    QName(XSCRT::XML::Attribute<C> const& a)
+        : Name<C> (a)
+    {
+    }
+
+    QName(Base__ const& x)
+        : Name<C> (x)
+    {
+    }
+
+    QName&
+    operator= (Base__ const& x)
+    {
+      static_cast<Base__&> (*this) = x;
+      return *this;
+    }
+  };
+
+  template <typename C>
   struct IdentityProvider : XSCRT::IdentityProvider
   {
     IdentityProvider (NCName<C> const& id)
diff --git a/SA_POP/Standalone/XML_Utils/XSC_XML_Handlers_Export.h b/SA_POP/Standalone/XML_Utils/XSC_XML_Handlers_Export.h
deleted file mode 100644
index 7d18280aa34..00000000000
--- a/SA_POP/Standalone/XML_Utils/XSC_XML_Handlers_Export.h
+++ /dev/null
@@ -1,58 +0,0 @@
-
-// -*- C++ -*-
-// $Id$
-// Definition for Win32 Export directives.
-// This file is generated automatically by generate_export_file.pl XSC_XML_Handlers
-// ------------------------------
-#ifndef XSC_XML_HANDLERS_EXPORT_H
-#define XSC_XML_HANDLERS_EXPORT_H
-
-#include "ace/config-all.h"
-
-#if defined (ACE_AS_STATIC_LIBS) && !defined (XSC_XML_HANDLERS_HAS_DLL)
-#  define XSC_XML_HANDLERS_HAS_DLL 0
-#endif /* ACE_AS_STATIC_LIBS && XSC_XML_HANDLERS_HAS_DLL */
-
-#if !defined (XSC_XML_HANDLERS_HAS_DLL)
-#  define XSC_XML_HANDLERS_HAS_DLL 1
-#endif /* ! XSC_XML_HANDLERS_HAS_DLL */
-
-#if defined (XSC_XML_HANDLERS_HAS_DLL) && (XSC_XML_HANDLERS_HAS_DLL == 1)
-#  if defined (XSC_XML_HANDLERS_BUILD_DLL)
-#    define XSC_XML_Handlers_Export ACE_Proper_Export_Flag
-#    define XSC_XML_HANDLERS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T)
-#    define XSC_XML_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
-#  else /* XSC_XML_HANDLERS_BUILD_DLL */
-#    define XSC_XML_Handlers_Export ACE_Proper_Import_Flag
-#    define XSC_XML_HANDLERS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T)
-#    define XSC_XML_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
-#  endif /* XSC_XML_HANDLERS_BUILD_DLL */
-#else /* XSC_XML_HANDLERS_HAS_DLL == 1 */
-#  define XSC_XML_Handlers_Export
-#  define XSC_XML_HANDLERS_SINGLETON_DECLARATION(T)
-#  define XSC_XML_HANDLERS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
-#endif /* XSC_XML_HANDLERS_HAS_DLL == 1 */
-
-// Set XSC_XML_HANDLERS_NTRACE = 0 to turn on library specific tracing even if
-// tracing is turned off for ACE.
-#if !defined (XSC_XML_HANDLERS_NTRACE)
-#  if (ACE_NTRACE == 1)
-#    define XSC_XML_HANDLERS_NTRACE 1
-#  else /* (ACE_NTRACE == 1) */
-#    define XSC_XML_HANDLERS_NTRACE 0
-#  endif /* (ACE_NTRACE == 1) */
-#endif /* !XSC_XML_HANDLERS_NTRACE */
-
-#if (XSC_XML_HANDLERS_NTRACE == 1)
-#  define XSC_XML_HANDLERS_TRACE(X)
-#else /* (XSC_XML_HANDLERS_NTRACE == 1) */
-#  if !defined (ACE_HAS_TRACE)
-#    define ACE_HAS_TRACE
-#  endif /* ACE_HAS_TRACE */
-#  define XSC_XML_HANDLERS_TRACE(X) ACE_TRACE_IMPL(X)
-#  include "ace/Trace.h"
-#endif /* (XSC_XML_HANDLERS_NTRACE == 1) */
-
-#endif /* XSC_XML_HANDLERS_EXPORT_H */
-
-// End of auto generated file.
diff --git a/SA_POP/Tester/Tester_Component.mpc b/SA_POP/Tester/Tester_Component.mpc
index b075cb1fcde..a93c236dfcf 100644
--- a/SA_POP/Tester/Tester_Component.mpc
+++ b/SA_POP/Tester/Tester_Component.mpc
@@ -77,7 +77,10 @@ project(Tester_Component_exec) : ciao_executor, race_common {
                 OpString_stub \
                 SA_POP_Component_stub
 
-  libs += OpString_stub Data_Base_Component_stub DAnCE_OA_Component_stub RACE_common_stub CIAO_Deployment_stub TAO_Messaging CIAO_Events_Base CIAO_Container TAO_PortableServer   
+  libs += OpString_stub Data_Base_Component_stub DAnCE_OA_Component_stub RACE_common_stub   
+// TAO_Messaging CIAO_Container_Base TAO_PortableServer
+// CIAO_Events_Base 
+
   libpaths += $(ACE_ROOT)/lib
 
   dynamicflags   = TESTER_COMPONENT_EXEC_BUILD_DLL
diff --git a/common/RACE_common.mpc b/common/RACE_common.mpc
index b39d3338cee..bafb19241be 100644
--- a/common/RACE_common.mpc
+++ b/common/RACE_common.mpc
@@ -1,6 +1,6 @@
 project(RACE_common_stub): anytypecode, race_idl {
 
-   libout       = $(ACE_ROOT)/lib	
+//   libout       = $(ACE_ROOT)/lib	
    sharedname = RACE_common_stub
    idlflags += -Wb,stub_export_macro=RACE_COMMON_STUB_Export \
                -Wb,stub_export_include=RACE_common_stub_export.h
@@ -26,6 +26,7 @@ project(RACE_common_stub): anytypecode, race_idl {
 
 project(OpString_stub): dance_deployment_stub, race_idl {
 
+//  libout       = $(ACE_ROOT)/lib	
   after += RACE_common_stub
   sharedname = OpString_stub
   idlflags += -Wb,stub_export_macro=OPSTRING_STUB_Export \
@@ -36,7 +37,7 @@ project(OpString_stub): dance_deployment_stub, race_idl {
 
   libs += RACE_common_stub
 
-IDL_Files {
+  IDL_Files {
     OpString.idl
     Goal.idl
     QoS.idl