Mon Mar 21 11:07:19 UTC 2011 James Edmondson <james.r.edmondson@vanderbilt.edu>

        - Applied formatting for 80 columns where possible
        - Added DANCE_TRACE to all functions so we have the option
          to turn them off and on.
        - Applied macros from dance\Logger\Log_Macros.h to replace
          numbers with appropriate log levels

        * tools/Artifact_Installation/Artifact_Installation_exec.cpp
        * tools/Artifact_Installation/Artifact_Installation_Impl.cpp
        * tools/Artifact_Installation/Installation_Repository_Manager.cpp
        * tools/Config_Handlers/ADD_Handler.cpp
        * tools/Config_Handlers/Any_Handler.cpp
        * tools/Config_Handlers/CPD_Handler.cpp
        * tools/Config_Handlers/DataType_Handler.cpp
        * tools/Config_Handlers/DnC_Dump.cpp
        * tools/Config_Handlers/DnC_Dump_T.cpp
        * tools/Config_Handlers/DP_Handler.cpp
        * tools/Config_Handlers/Dump_Obj.cpp
        * tools/Config_Handlers/DynAny_Handler/DataType_Handler.cpp
        * tools/Config_Handlers/DynAny_Handler/DynAlias_Handler.cpp
        * tools/Config_Handlers/DynAny_Handler/DynAny_Handler.cpp
        * tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.cpp
        * tools/Config_Handlers/DynAny_Handler/DynSequence_Handler.cpp
        * tools/Config_Handlers/DynAny_Handler/DynStruct_Handler.cpp
        * tools/Config_Handlers/IDD_Handler.cpp
        * tools/Config_Handlers/MDD_Handler.cpp
        * tools/Config_Handlers/Package_Handlers/CAD_Handler.cpp
        * tools/Config_Handlers/Package_Handlers/CID_Handler.cpp
        * tools/Config_Handlers/Package_Handlers/CPD_Handler.cpp
        * tools/Config_Handlers/Package_Handlers/SID_Handler.cpp
        * tools/Config_Handlers/PSPE_Handler.cpp
        * tools/Config_Handlers/SatisfierProperty_Handler.cpp
        * tools/Config_Handlers/XML_File_Intf.cpp
        * tools/Convert_Plan/Convert_Plan.cpp
        * tools/Convert_Plan/Convert_Plan_Impl.cpp
        * tools/Split_Plan/Locality_Splitter.cpp
        * tools/Split_Plan/Split_Plan.cpp
        * tools/Split_Plan/Split_Plan_exec.cpp
        * tools/System_Health/Daemon/SHS_Daemon.cpp
        * tools/System_Health/Daemon/SHS_Daemon_Impl.cpp
        * tools/System_Health/Interceptors/SHS_CORBA_Transport.cpp

1 files changed, 362 insertions, 136 deletions

diff --git a/DAnCE/tools/Config_Handlers/DnC_Dump.cpp b/DAnCE/tools/Config_Handlers/DnC_Dump.cpp
index add026aeedd..9735583e2c7 100644
--- a/DAnCE/tools/Config_Handlers/DnC_Dump.cpp
+++ b/DAnCE/tools/Config_Handlers/DnC_Dump.cpp
@@ -7,12 +7,22 @@
 #include "DnC_Dump_T.h"
 #include <iostream>
 
+// James Edmondson <james.r.edmondson@vanderbilt.edu> note:
+// All of the dumps in this file had log levels of 1, which in our Log_Macros
+// indicates a terminal error. Ideally, I would think these should take
+// a parameter to indicate the log level to assume, rather than assuming
+// the worst. Although dumps tend to happen when a fatal error has
+// occurred, it can also be a debugging tool. Not sure if I agree with
+// them being terminal error prints, but perhaps this is something
+// we can discuss
+
 using namespace ::Deployment::DnC_Dump_T;
 namespace Deployment
 {
   void
   DnC_Dump::dump (const char* caption, const ::CORBA::StringSeq &str_seq)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     CORBA::ULong size = str_seq.length ();
 
     if (size != 0)
@@ -21,9 +31,9 @@ namespace Deployment
 
         for (CORBA::ULong i = 0; i < size; ++i)
           {
-            DANCE_DEBUG (1, (LM_DEBUG, "%s%s %d:\n",
+            DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "%s%s %d:\n",
                         Dump_Obj::indent(), caption, i));
-            DANCE_DEBUG (1, (LM_DEBUG, "%s  %s:\n",
+            DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "%s  %s:\n",
                         Dump_Obj::indent(), str_seq[i].in ()));
           }
       }
@@ -32,15 +42,19 @@ namespace Deployment
   // Dumps a string
   void DnC_Dump::dump (const char* caption, const TAO::String_Manager& str)
   {
-    DANCE_DEBUG (1, (LM_DEBUG, "%s%s: %s\n", Dump_Obj::indent(),
-                caption, str.in()));
+    DANCE_TRACE("DnC_Dump::dump");
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%s%s: %s\n", Dump_Obj::indent(),
+      caption, str.in()));
   }
 
   // Dumps a boolean
   void DnC_Dump::dump (const char* caption, const CORBA::Boolean& val)
   {
-    DANCE_DEBUG (1, (LM_DEBUG, "%s%s: %s\n", Dump_Obj::indent(),
-                caption, val ? "true" : "false"));
+    DANCE_TRACE("DnC_Dump::dump");
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%s%s: %s\n", Dump_Obj::indent(),
+      caption, val ? "true" : "false"));
   }
 
   /*
@@ -50,26 +64,43 @@ namespace Deployment
   // SatisfierProperty
   void DnC_Dump::dump (const Deployment::SatisfierProperty& sp)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("SatisfierProperty");
     dump ("name", sp.name);
 
-    DANCE_DEBUG (1, (LM_DEBUG, "%skind: ", Dump_Obj::indent()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%skind: ", Dump_Obj::indent()));
+
     switch (sp.kind) {
-    case Quantity: DANCE_DEBUG (1, (LM_DEBUG, "Quantity\n")); break;
-    case Capacity: DANCE_DEBUG (1, (LM_DEBUG, "Capacity\n")); break;
-    case Minimum: DANCE_DEBUG (1, (LM_DEBUG, "Minimum\n")); break;
-    case Maximum: DANCE_DEBUG (1, (LM_DEBUG, "Maximum\n")); break;
-    case Attribute: DANCE_DEBUG (1, (LM_DEBUG, "Attribute\n")); break;
-    case Selection: DANCE_DEBUG (1, (LM_DEBUG, "Selection\n")); break;
+    case Quantity:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Quantity\n"));
+      break;
+    case Capacity:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Capacity\n"));
+      break;
+    case Minimum:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Minimum\n"));
+      break;
+    case Maximum:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Maximum\n"));
+      break;
+    case Attribute:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Attribute\n"));
+      break;
+    case Selection:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Selection\n"));
+      break;
     }
 
-    DANCE_DEBUG (1, (LM_DEBUG, "%svalue:\n", Dump_Obj::indent()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%svalue:\n", Dump_Obj::indent()));
     dump (sp.value);
   }
 
   // SharedResource
   void DnC_Dump::dump (const Deployment::SharedResource& sr)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("SharedResource");
     dump ("name", sr.name);
     dump ("resourceType", sr.resourceType);
@@ -86,6 +117,7 @@ namespace Deployment
   // Resource
   void DnC_Dump::dump (const Deployment::Resource& resource)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("Resource");
     dump ("name", resource.name);
     dump ("resourceType", resource.resourceType);
@@ -96,6 +128,7 @@ namespace Deployment
   // Node
   void DnC_Dump::dump (const Deployment::Node& node)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("Node");
     dump ("name", node.name);
     dump ("label", node.label);
@@ -124,6 +157,7 @@ namespace Deployment
   // Interconnect
   void DnC_Dump::dump (const Deployment::Interconnect& conn)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("Interconnect");
     dump ("name", conn.name);
     dump ("label", conn.label);
@@ -150,6 +184,7 @@ namespace Deployment
   void
   DnC_Dump::dump (const Deployment::Bridge& bridge)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("Bridge");
     dump ("name", bridge.name);
     dump ("label", bridge.label);
@@ -167,6 +202,7 @@ namespace Deployment
 
   void DnC_Dump::dump (const ::Deployment::Domain &domain)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     CORBA::Any val;
     val <<= domain;
 
@@ -196,6 +232,7 @@ namespace Deployment
   void DnC_Dump::dump (const ::Deployment::ComponentPortDescription
                        &compportdesc)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("ComponentPortDescription");
 
     dump ("name", compportdesc.name);
@@ -206,15 +243,37 @@ namespace Deployment
     dump ("exclusiveUser", compportdesc.exclusiveUser);
     dump ("optional", compportdesc.optional);
 
-    DANCE_DEBUG (1, (LM_DEBUG, "%skind: ", Dump_Obj::indent()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%skind: ", Dump_Obj::indent()));
     switch (compportdesc.kind) {
-    case Facet: DANCE_DEBUG (1, (LM_DEBUG, "Facet\n")); break;
-    case SimplexReceptacle: DANCE_DEBUG (1, (LM_DEBUG, "SimplexReceptacle\n")); break;
-    case MultiplexReceptacle: DANCE_DEBUG (1, (LM_DEBUG, "MultiplexReceptacle\n")); break;
-    case EventEmitter: DANCE_DEBUG (1, (LM_DEBUG, "EventEmitter\n")); break;
-    case EventPublisher: DANCE_DEBUG (1, (LM_DEBUG, "EventPublisher\n")); break;
-    case EventConsumer: DANCE_DEBUG (1, (LM_DEBUG, "EventConsumer\n")); break;
-    default: DANCE_DEBUG (1, (LM_DEBUG, "Unknown port kind\n")); break;
+    case Facet:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "Facet\n"));
+      break;
+    case SimplexReceptacle:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "SimplexReceptacle\n"));
+      break;
+    case MultiplexReceptacle:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "MultiplexReceptacle\n"));
+      break;
+    case EventEmitter:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "EventEmitter\n"));
+      break;
+    case EventPublisher:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "EventPublisher\n"));
+      break;
+    case EventConsumer:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "EventConsumer\n"));
+      break;
+    default:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "Unknown port kind\n"));
+      break;
     }
   }
 
@@ -222,49 +281,125 @@ namespace Deployment
 
   void DnC_Dump::dump (const ::Deployment::ComponentPropertyDescription &comppropdesc)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("ComponentPropertyDescription");
 
     dump ("name", comppropdesc.name);
 
-    DANCE_DEBUG (1, (LM_DEBUG, "%stype: ", Dump_Obj::indent()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%stype: ", Dump_Obj::indent()));
     switch (comppropdesc.type.in()->kind()) {
-    case ::CORBA::tk_null: DANCE_DEBUG (1, (LM_DEBUG, "tk_null\n")); break;
-    case ::CORBA::tk_void: DANCE_DEBUG (1, (LM_DEBUG, "tk_void\n")); break;
-    case ::CORBA::tk_short: DANCE_DEBUG (1, (LM_DEBUG, "tk_short\n")); break;
-    case ::CORBA::tk_long: DANCE_DEBUG (1, (LM_DEBUG, "tk_long\n")); break;
-    case ::CORBA::tk_ushort: DANCE_DEBUG (1, (LM_DEBUG, "tk_ushort\n")); break;
-    case ::CORBA::tk_ulong: DANCE_DEBUG (1, (LM_DEBUG, "tk_ulong\n")); break;
-    case ::CORBA::tk_float: DANCE_DEBUG (1, (LM_DEBUG, "tk_float\n")); break;
-    case ::CORBA::tk_double: DANCE_DEBUG (1, (LM_DEBUG, "tk_double\n")); break;
-    case ::CORBA::tk_boolean: DANCE_DEBUG (1, (LM_DEBUG, "tk_boolean\n")); break;
-    case ::CORBA::tk_char: DANCE_DEBUG (1, (LM_DEBUG, "tk_char\n")); break;
-    case ::CORBA::tk_octet: DANCE_DEBUG (1, (LM_DEBUG, "tk_octet\n")); break;
-    case ::CORBA::tk_any: DANCE_DEBUG (1, (LM_DEBUG, "tk_any\n")); break;
-    case ::CORBA::tk_TypeCode: DANCE_DEBUG (1, (LM_DEBUG, "tk_TypeCode\n")); break;
-    case ::CORBA::tk_Principal: DANCE_DEBUG (1, (LM_DEBUG, "tk_Principal\n")); break;
-    case ::CORBA::tk_objref: DANCE_DEBUG (1, (LM_DEBUG, "tk_objref\n")); break;
-    case ::CORBA::tk_struct: DANCE_DEBUG (1, (LM_DEBUG, "tk_struct\n")); break;
-    case ::CORBA::tk_union: DANCE_DEBUG (1, (LM_DEBUG, "tk_union\n")); break;
-    case ::CORBA::tk_enum: DANCE_DEBUG (1, (LM_DEBUG, "tk_enum\n")); break;
-    case ::CORBA::tk_string: DANCE_DEBUG (1, (LM_DEBUG, "tk_string\n")); break;
-    case ::CORBA::tk_sequence: DANCE_DEBUG (1, (LM_DEBUG, "tk_sequence\n")); break;
-    case ::CORBA::tk_array: DANCE_DEBUG (1, (LM_DEBUG, "tk_array\n")); break;
-    case ::CORBA::tk_alias: DANCE_DEBUG (1, (LM_DEBUG, "tk_alias\n")); break;
-    case ::CORBA::tk_except: DANCE_DEBUG (1, (LM_DEBUG, "tk_except\n")); break;
-    case ::CORBA::tk_longlong: DANCE_DEBUG (1, (LM_DEBUG, "tk_longlong\n")); break;
-    case ::CORBA::tk_ulonglong: DANCE_DEBUG (1, (LM_DEBUG, "tk_ulonglong\n")); break;
-    case ::CORBA::tk_longdouble: DANCE_DEBUG (1, (LM_DEBUG, "tk_longdouble\n")); break;
-    case ::CORBA::tk_wchar: DANCE_DEBUG (1, (LM_DEBUG, "tk_wchar\n")); break;
-    case ::CORBA::tk_wstring: DANCE_DEBUG (1, (LM_DEBUG, "tk_wstring\n")); break;
-    case ::CORBA::tk_fixed: DANCE_DEBUG (1, (LM_DEBUG, "tk_fixed\n")); break;
-    case ::CORBA::tk_value: DANCE_DEBUG (1, (LM_DEBUG, "tk_value\n")); break;
-    case ::CORBA::tk_value_box: DANCE_DEBUG (1, (LM_DEBUG, "tk_value_box\n")); break;
-    case ::CORBA::tk_native: DANCE_DEBUG (1, (LM_DEBUG, "tk_native\n")); break;
-    case ::CORBA::tk_abstract_interface: DANCE_DEBUG (1, (LM_DEBUG, "tk_abstract_interface\n")); break;
-    case ::CORBA::tk_local_interface: DANCE_DEBUG (1, (LM_DEBUG, "tk_local_interface\n")); break;
-    case ::CORBA::tk_component: DANCE_DEBUG (1, (LM_DEBUG, "tk_component\n")); break;
-    case ::CORBA::tk_home: DANCE_DEBUG (1, (LM_DEBUG, "tk_home\n")); break;
-    case ::CORBA::tk_event: DANCE_DEBUG (1, (LM_DEBUG, "tk_event\n")); break;
+    case ::CORBA::tk_null:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_null\n"));
+      break;
+    case ::CORBA::tk_void:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_void\n"));
+      break;
+    case ::CORBA::tk_short:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_short\n"));
+      break;
+    case ::CORBA::tk_long:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_long\n"));
+      break;
+    case ::CORBA::tk_ushort:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_ushort\n"));
+      break;
+    case ::CORBA::tk_ulong:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_ulong\n"));
+      break;
+    case ::CORBA::tk_float:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_float\n"));
+      break;
+    case ::CORBA::tk_double:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_double\n"));
+      break;
+    case ::CORBA::tk_boolean:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_boolean\n"));
+      break;
+    case ::CORBA::tk_char:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_char\n"));
+      break;
+    case ::CORBA::tk_octet:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_octet\n"));
+      break;
+    case ::CORBA::tk_any:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_any\n"));
+      break;
+    case ::CORBA::tk_TypeCode:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_TypeCode\n"));
+      break;
+    case ::CORBA::tk_Principal:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_Principal\n"));
+      break;
+    case ::CORBA::tk_objref:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_objref\n"));
+      break;
+    case ::CORBA::tk_struct:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_struct\n"));
+      break;
+    case ::CORBA::tk_union:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_union\n"));
+      break;
+    case ::CORBA::tk_enum:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_enum\n"));
+      break;
+    case ::CORBA::tk_string:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_string\n"));
+      break;
+    case ::CORBA::tk_sequence:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_sequence\n"));
+      break;
+    case ::CORBA::tk_array:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_array\n"));
+      break;
+    case ::CORBA::tk_alias:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_alias\n"));
+      break;
+    case ::CORBA::tk_except:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_except\n"));
+      break;
+    case ::CORBA::tk_longlong:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_longlong\n"));
+      break;
+    case ::CORBA::tk_ulonglong:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_ulonglong\n"));
+      break;
+    case ::CORBA::tk_longdouble:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_longdouble\n"));
+      break;
+    case ::CORBA::tk_wchar:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_wchar\n"));
+      break;
+    case ::CORBA::tk_wstring:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_wstring\n"));
+      break;
+    case ::CORBA::tk_fixed:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_fixed\n"));
+      break;
+    case ::CORBA::tk_value:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_value\n"));
+      break;
+    case ::CORBA::tk_value_box:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_value_box\n"));
+      break;
+    case ::CORBA::tk_native:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_native\n"));
+      break;
+    case ::CORBA::tk_abstract_interface:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_abstract_interface\n"));
+      break;
+    case ::CORBA::tk_local_interface:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_local_interface\n"));
+      break;
+    case ::CORBA::tk_component:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_component\n"));
+      break;
+    case ::CORBA::tk_home:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_home\n"));
+      break;
+    case ::CORBA::tk_event:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_event\n"));
+      break;
     default:
       break;
     };
@@ -274,6 +409,7 @@ namespace Deployment
 
   void DnC_Dump::dump (const ::Deployment::ComponentInterfaceDescription &cid)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("ComponentInterfaceDescription");
     dump ("label", cid.label);
     dump ("UUID", cid.UUID);
@@ -290,6 +426,7 @@ namespace Deployment
 
   void DnC_Dump::dump (const ::Deployment::Requirement &req)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("Requirement");
 
     dump ("resourceType", req.resourceType);
@@ -301,6 +438,7 @@ namespace Deployment
 
   void DnC_Dump::dump(const Deployment::MonolithicDeploymentDescription &mdd)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("MonolithicDeploymentDescription");
 
     dump ("name", mdd.name);
@@ -319,26 +457,46 @@ namespace Deployment
 
   void DnC_Dump::dump(const Deployment::ResourceUsageKind &ruk)
   {
-    DANCE_DEBUG (1, (LM_DEBUG, "%sresourceUsage: ", Dump_Obj::indent()));
+    DANCE_TRACE("DnC_Dump::dump");
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%sresourceUsage: ", Dump_Obj::indent()));
     switch (ruk) {
-    case None: DANCE_DEBUG (1, (LM_DEBUG, "None\n")); break;
-    case InstanceUsesResource: DANCE_DEBUG (1, (LM_DEBUG, "InstanceUsesResource\n")); break;
-    case ResourceUsesInstance: DANCE_DEBUG (1, (LM_DEBUG, "ResourceUsesInstance\n")); break;
-    case PortUsesResource: DANCE_DEBUG (1, (LM_DEBUG, "PortUsesResource\n")); break;
-    case ResourceUsesPort: DANCE_DEBUG (1, (LM_DEBUG, "ResourceUsesPort\n")); break;
+    case None:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "None\n"));
+      break;
+    case InstanceUsesResource:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "InstanceUsesResource\n"));
+      break;
+    case ResourceUsesInstance:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "ResourceUsesInstance\n"));
+      break;
+    case PortUsesResource:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "PortUsesResource\n"));
+      break;
+    case ResourceUsesPort:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "ResourceUsesPort\n"));
+      break;
     }
   }
 
   // InstanceResourceDeploymentDescription
 
-  void DnC_Dump::dump(const Deployment::InstanceResourceDeploymentDescription &irdd)
+  void DnC_Dump::dump(
+    const Deployment::InstanceResourceDeploymentDescription &irdd)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("InstanceResourceDeploymentDescription");
 
     dump (irdd.resourceUsage);
     dump ("requirementName", irdd.requirementName);
     dump ("resourceName", irdd.resourceName);
-    DANCE_DEBUG (1, (LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG,
+      "%sresourceValue:\n", Dump_Obj::indent()));
     dump_sequence ("property",  irdd.property);
   }
 
@@ -346,6 +504,7 @@ namespace Deployment
 
   void DnC_Dump::dump(const Deployment::InstanceDeploymentDescription &idd)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("InstanceDeploymentDescription");
 
     dump ("name", idd.name);
@@ -367,6 +526,7 @@ namespace Deployment
 
   void DnC_Dump::dump (const ::Deployment::ComponentExternalPortEndpoint &cepe)
   {
+    DANCE_TRACE("DnC_Dump::dump");
     Dump_Obj dump_obj("ComponentExternalPortEndpoint");
 
     dump ("portName", cepe.portName);
@@ -380,15 +540,37 @@ namespace Deployment
 
     dump ("portName", pspe.portName);
     dump ("provider", pspe.provider);
-    DANCE_DEBUG (1, (LM_DEBUG, "%skind: ", Dump_Obj::indent()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%skind: ", Dump_Obj::indent()));
     switch (pspe.kind) {
-    case Facet: DANCE_DEBUG (1, (LM_DEBUG, "Facet\n")); break;
-    case SimplexReceptacle: DANCE_DEBUG (1, (LM_DEBUG, "SimplexReceptacle\n")); break;
-    case MultiplexReceptacle: DANCE_DEBUG (1, (LM_DEBUG, "MultiplexReceptacle\n")); break;
-    case EventEmitter: DANCE_DEBUG (1, (LM_DEBUG, "EventEmitter\n")); break;
-    case EventPublisher: DANCE_DEBUG (1, (LM_DEBUG, "EventPublisher\n")); break;
-    case EventConsumer: DANCE_DEBUG (1, (LM_DEBUG, "EventConsumer\n")); break;
-    default: DANCE_DEBUG (1, (LM_DEBUG, "Unknown port kind\n")); break;
+    case Facet:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "Facet\n"));
+      break;
+    case SimplexReceptacle:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "SimplexReceptacle\n"));
+      break;
+    case MultiplexReceptacle:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "MultiplexReceptacle\n"));
+      break;
+    case EventEmitter:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "EventEmitter\n"));
+      break;
+    case EventPublisher:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "EventPublisher\n"));
+      break;
+    case EventConsumer:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "EventConsumer\n"));
+      break;
+    default:
+      DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+        (LM_DEBUG, "Unknown port kind\n"));
+      break;
     }
 #if (_MSC_VER)
     dump_ref<Deployment::DeploymentPlan> ("instanceRef", pspe.instanceRef,
@@ -415,7 +597,8 @@ namespace Deployment
     dump ("targetName", crdd.targetName);
     dump ("requirementName", crdd.requirementName);
     dump ("resourceName", crdd.resourceName);
-    DANCE_DEBUG (1, (LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent()));
     dump_sequence ("properties", crdd.property);
   }
 
@@ -478,7 +661,8 @@ namespace Deployment
 
     dump ("requirementName", rdd.requirementName);
     dump ("resourceName", rdd.resourceName);
-    DANCE_DEBUG (1, (LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent()));
     dump_sequence ("properties", rdd.property);
   }
 
@@ -530,7 +714,8 @@ namespace Deployment
 
   // SubcomponentInstantiationDescription
 
-  void DnC_Dump::dump (const ::Deployment::SubcomponentInstantiationDescription &sid)
+  void DnC_Dump::dump (
+    const ::Deployment::SubcomponentInstantiationDescription &sid)
   {
     Dump_Obj dump_obj("SubcomponentInstantiationDescription");
 
@@ -555,8 +740,9 @@ namespace Deployment
 
     a >>= v;
 
-    DANCE_DEBUG (1, (LM_DEBUG, "%sinstance: %s\n", Dump_Obj::indent (),
-                v->instance[value].name.in ()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%sinstance: %s\n", Dump_Obj::indent (),
+      v->instance[value].name.in ()));
   }
 
   // AssemblyConnectionDescription
@@ -588,8 +774,9 @@ namespace Deployment
 
     a >>= v;
 
-    DANCE_DEBUG (1, (LM_DEBUG, "%sinstance: %s\n", Dump_Obj::indent (),
-                v->instance[value].name.in ()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%sinstance: %s\n", Dump_Obj::indent (),
+      v->instance[value].name.in ()));
   }
 
   void
@@ -619,7 +806,8 @@ namespace Deployment
 
   // ImplementationArtifactDescription
 
-  void DnC_Dump::dump (const ::Deployment::ImplementationArtifactDescription &iad)
+  void DnC_Dump::dump (
+    const ::Deployment::ImplementationArtifactDescription &iad)
   {
     Dump_Obj dump_obj("ImplementationArtifactDescription");
 
@@ -682,13 +870,14 @@ namespace Deployment
   // ComponentImplementationDescription
 
   void DnC_Dump::dump (
-                       const ::Deployment::ComponentImplementationDescription &cid)
+       const ::Deployment::ComponentImplementationDescription &cid)
   {
     Dump_Obj dump_obj("ComponentImplementationDescription");
 
     dump ("label", cid.label);
     dump ("UUID", cid.UUID);
-    DANCE_DEBUG (1, (LM_DEBUG, "%sImplements:\n", Dump_Obj::indent()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%sImplements:\n", Dump_Obj::indent()));
     dump (cid.implements);
     dump_sequence ("assemblyImpl", cid.assemblyImpl);
     dump_sequence ("monolithicImpl", cid.monolithicImpl);
@@ -700,12 +889,13 @@ namespace Deployment
 
   // PackagedComponentImplementation
 
-  void DnC_Dump::dump (const ::Deployment::PackagedComponentImplementation &pci)
+  void DnC_Dump::dump (
+    const ::Deployment::PackagedComponentImplementation &pci)
   {
     Dump_Obj dump_obj("PackagedComponentImplementation");
 
     dump ("Name", pci.name);
-    DANCE_DEBUG (1, (LM_DEBUG,
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG,
                 "%sreferencedImplementation:\n", Dump_Obj::indent()));
     DnC_Dump::dump (pci.referencedImplementation);
   }
@@ -719,7 +909,8 @@ namespace Deployment
 
     dump ("label", comppkgdesc.label);
     dump ("UUID", comppkgdesc.UUID);
-    DANCE_DEBUG (1, (LM_DEBUG, "%srealizes:\n", Dump_Obj::indent ()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%srealizes:\n", Dump_Obj::indent ()));
     DnC_Dump::dump (comppkgdesc.realizes); // ComponentInterfaceDescription
     dump_sequence ("configProperty", comppkgdesc.configProperty);
     dump_sequence ("implementation", comppkgdesc.implementation);
@@ -746,7 +937,8 @@ namespace Deployment
   {
     Dump_Obj dump_obj("Property");
     dump ("name", property.name);
-    DANCE_DEBUG (1, (LM_DEBUG, "%svalue:\n", Dump_Obj::indent()));
+    DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+      (LM_DEBUG, "%svalue:\n", Dump_Obj::indent()));
     dump (property.value);
   }
 
@@ -762,33 +954,39 @@ namespace Deployment
           CORBA::Short temp;
           if (! (any >>= temp))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC_Dump::dump (CORBA::Any), expected short\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC_Dump::dump (CORBA::Any), expected short\
 encoded different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (),
-                      temp));
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (),
+            temp));
         }
         break;
 
       case CORBA::tk_null:
-        DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: null value encoded\n",
-                    Dump_Obj::indent ()));
+        DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+          (LM_DEBUG, "%sAny value: null value encoded\n",
+          Dump_Obj::indent ()));
         break;
 
       case CORBA::tk_void:
-        DANCE_DEBUG (1, (LM_DEBUG, "Any value: void type encoded\n"));
+        DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+          (LM_DEBUG, "Any value: void type encoded\n"));
         break;
       case CORBA::tk_long:
         {
           CORBA::Long temp;
           if (! (any >>= temp))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected long\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected long\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (),
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (),
                       temp));
         }
         break;
@@ -798,12 +996,14 @@ encoded with different type"));
           CORBA::UShort temp;
           if (! (any >>= temp))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected u short\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected u short\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %u\n", Dump_Obj::indent (),
-                      temp));
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "%sAny value: %u\n", Dump_Obj::indent (),
+            temp));
         }
         break;
 
@@ -812,11 +1012,13 @@ encoded with different type"));
           CORBA::ULong temp;
           if (! (any >>= temp))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected ulong\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected ulong\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %u\n", Dump_Obj::indent (),
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "%sAny value: %u\n", Dump_Obj::indent (),
                       temp));
         }
         break;
@@ -826,12 +1028,14 @@ encoded with different type"));
           CORBA::Float temp;
           if (! (any >>= temp))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected float\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected float\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %f\n", Dump_Obj::indent (),
-                      temp));
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "%sAny value: %f\n", Dump_Obj::indent (),
+            temp));
         }
         break;
       case CORBA::tk_double:
@@ -839,12 +1043,14 @@ encoded with different type"));
           CORBA::Double temp;
           if (! (any >>= temp))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected double\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected double\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %f\n", Dump_Obj::indent (),
-                      temp));
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "%sAny value: %f\n", Dump_Obj::indent (),
+            temp));
         }
         break;
       case CORBA::tk_boolean:
@@ -852,15 +1058,18 @@ encoded with different type"));
           CORBA::Boolean temp;
           if (! (any >>= CORBA::Any::to_boolean (temp)))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected bool\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected bool\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
 
           if (temp)
-            DANCE_DEBUG (1, (LM_DEBUG, "Any value: True\n"));
+            DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "Any value: True\n"));
           else
-            DANCE_DEBUG (1, (LM_DEBUG, "Any value: False\n"));
+            DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "Any value: False\n"));
         }
         break;
 
@@ -869,12 +1078,14 @@ encoded with different type"));
           CORBA::Char temp;
           if (! (any >>= CORBA::Any::to_char (temp)))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected char\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected char\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %c\n", Dump_Obj::indent (),
-                      temp));
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "%sAny value: %c\n", Dump_Obj::indent (),
+             temp));
         }
         break;
 
@@ -883,12 +1094,14 @@ encoded with different type"));
           CORBA::Octet temp;
           if (! (any >>= CORBA::Any::to_octet (temp)))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected octet\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected octet\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (),
-                      temp));
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG,
+            "%sAny value: %d\n", Dump_Obj::indent (),
+            temp));
         }
         break;
 
@@ -897,12 +1110,14 @@ encoded with different type"));
           const char * temp = 0;
           if (! (any >>= temp))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected string\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected string\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %s\n", Dump_Obj::indent (),
-                      temp));
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "%sAny value: %s\n", Dump_Obj::indent (),
+            temp));
         }
         break;
       case CORBA::tk_longlong:
@@ -910,12 +1125,14 @@ encoded with different type"));
           CORBA::LongLong temp;
           if (! (any >>= temp))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected longlong\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected longlong\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %l\n", Dump_Obj::indent (),
-                      temp));
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "%sAny value: %l\n", Dump_Obj::indent (),
+            temp));
         }
         break;
 
@@ -924,12 +1141,14 @@ encoded with different type"));
           CORBA::LongDouble temp;
           if (! (any >>= temp))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected longdouble\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected longdouble\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (),
-                      temp));
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (),
+            temp));
         }
 
         break;
@@ -938,12 +1157,14 @@ encoded with different type"));
           CORBA::WChar temp;
           if (! (any >>= CORBA::Any::to_wchar (temp)))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected wchar\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected wchar\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %c\n", Dump_Obj::indent (),
-                      temp));
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+            (LM_DEBUG, "%sAny value: %c\n", Dump_Obj::indent (),
+            temp));
         }
         break;
 
@@ -952,12 +1173,14 @@ encoded with different type"));
           const CORBA::WChar * temp;
           if (! (any >>= temp))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected wstring\
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+                (LM_DEBUG, "DnC::dump (CORBA::Any) expected wstring\
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %s\n", Dump_Obj::indent (),
-                      temp));
+          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG,
+            "%sAny value: %s\n", Dump_Obj::indent (),
+            temp));
         }
         break;
 
@@ -966,16 +1189,19 @@ encoded with different type"));
 /*          CORBA::Enum temp;
           if (! (any >>= temp))
             {
-              DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected enum \
+              DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG,
+              "DnC::dump (CORBA::Any) expected enum \
 encoded with different type"));
               throw CORBA::INTERNAL ();
             }
-*/          DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: some enum\n", Dump_Obj::indent ()));
+*/          DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+              (LM_DEBUG, "%sAny value: some enum\n", Dump_Obj::indent ()));
         }
         break;
 
       default:
-        DANCE_DEBUG (1, (LM_DEBUG, "Unknown type encoded in Any\n"));
+        DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR,
+          (LM_DEBUG, "Unknown type encoded in Any\n"));
         throw CORBA::INTERNAL ();
       }
   }