Mon Mar 11 01:50:33 UTC 2013 Phil Mesnier <mesnier_p@socket.net>

9 files changed, 402 insertions, 15 deletions

diff --git a/TAO/ChangeLog_Asynch_ImR b/TAO/ChangeLog_Asynch_ImR
new file mode 100644
index 00000000000..80899d2aada
--- /dev/null
+++ b/TAO/ChangeLog_Asynch_ImR
@@ -0,0 +1,30 @@
+Mon Mar 11 01:50:33 UTC 2013  Phil Mesnier  <mesnier_p@socket.net>
+
+        * orbsvcs/ImplRepo_Service/Adapter_Activator.h:
+        * orbsvcs/ImplRepo_Service/Adapter_Activator.cpp:
+
+          In order to support asynchronous interfaces, the adapter has to use the
+          default servant rather than the servant locator. The servant locator does
+          not give an opportunity for asynch processing.
+
+        * orbsvcs/ImplRepo_Service/Forwarder.h:
+        * orbsvcs/ImplRepo_Service/Forwarder.cpp:
+
+          The initial cut at implementing AMH.
+
+        * orbsvcs/ImplRepo_Service/ImplRepo_Service.mpc:
+        * orbsvcs/ImplRepo_Service/Locator_Options.h:
+        * orbsvcs/ImplRepo_Service/Locator_Options.cpp:
+
+          The feature is optional for now at least.
+
+        * tao/ImR_Client/ImR_Client.mpc:
+
+          Add support for generating asyncronous stubs and skeletons for working
+          with the ImR.
+
+Local Variables:
+mode: change-log
+add-log-time-format: (lambda () (progn (setq tz (getenv "TZ")) (set-time-zone-rule "UTC") (setq time (format-time-string "%a %b %e %H:%M:%S %Z %Y" (current-time))) (set-time-zone-rule tz) time))
+indent-tabs-mode: nil
+End:
diff --git a/TAO/orbsvcs/ImplRepo_Service/Adapter_Activator.cpp b/TAO/orbsvcs/ImplRepo_Service/Adapter_Activator.cpp
index f893b947636..96b973f6459 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Adapter_Activator.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/Adapter_Activator.cpp
@@ -12,21 +12,29 @@
 #include "Adapter_Activator.h"
 
 #include "ace/Log_Msg.h"
+#include "tao/PortableServer/Servant_Base.h"
 
 ImR_Adapter::ImR_Adapter (void)
-: servant_locator_ (0)
+  : servant_locator_ (0),
+    default_servant_ (0)
 {
 }
 
 void
-ImR_Adapter::init (PortableServer::ServantLocator_ptr servant)
+ImR_Adapter::init (PortableServer::ServantLocator_ptr locator)
 {
-  servant_locator_ = servant;
+  servant_locator_ = locator;
+}
+
+void
+ImR_Adapter::init (TAO_ServantBase * servant)
+{
+  default_servant_ = servant;
 }
 
 CORBA::Boolean
 ImR_Adapter::unknown_adapter (PortableServer::POA_ptr parent,
-                                        const char *name)
+                              const char *name)
 {
   ACE_ASSERT (! CORBA::is_nil(parent));
   ACE_ASSERT (name != 0);
@@ -34,7 +42,7 @@ ImR_Adapter::unknown_adapter (PortableServer::POA_ptr parent,
   policies.length (2);
 
   const char *exception_message = "Null Message";
-
+  bool use_loc = this->servant_locator_ != 0;
   try
     {
       // Servant Retention Policy
@@ -44,8 +52,11 @@ ImR_Adapter::unknown_adapter (PortableServer::POA_ptr parent,
 
       // Request Processing Policy
       exception_message = "While PortableServer::POA::create_request_processing_policy";
+
       policies[1] =
-        parent->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER);
+        parent->create_request_processing_policy (use_loc ?
+                                                  PortableServer::USE_SERVANT_MANAGER :
+                                                  PortableServer::USE_DEFAULT_SERVANT);
 
       PortableServer::POAManager_var poa_manager =
         parent->the_POAManager ();
@@ -66,8 +77,17 @@ ImR_Adapter::unknown_adapter (PortableServer::POA_ptr parent,
       exception_message = "While child->the_activator";
       child->the_activator (this);
 
-      exception_message = "While unknown_adapter, set_servant_manager";
-      child->set_servant_manager (this->servant_locator_);
+      if (use_loc)
+        {
+          exception_message = "While unknown_adapter, set_servant_manager";
+          child->set_servant_manager (this->servant_locator_);
+        }
+      else
+        {
+          exception_message = "While unknown_adapter, set_servant";
+          child->set_servant (this->default_servant_);
+        }
+
     }
   catch (const CORBA::Exception& ex)
     {
diff --git a/TAO/orbsvcs/ImplRepo_Service/Adapter_Activator.h b/TAO/orbsvcs/ImplRepo_Service/Adapter_Activator.h
index e1396f9c7d4..3ff4da1e789 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Adapter_Activator.h
+++ b/TAO/orbsvcs/ImplRepo_Service/Adapter_Activator.h
@@ -24,6 +24,8 @@
 
 #include "tao/LocalObject.h"
 
+class TAO_ServantBase;
+
 
 /**
  * @class ImR_Adapter_Activator
@@ -48,10 +50,13 @@ public:
     const char *name
   );
 
-  void init(PortableServer::ServantLocator_ptr servant);
+  void init(PortableServer::ServantLocator_ptr locator);
+  void init(TAO_ServantBase * servant);
 private:
   /// The ServantLocator registered in each new POA.
   PortableServer::ServantLocator_ptr servant_locator_;
+  /// Alternatively, the default servant used.
+  TAO_ServantBase *default_servant_;
 };
 
 #endif /* IMR_ADAPTER_ACTIVATOR_H */
diff --git a/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp b/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp
index 4ca91d7002f..8819ca4bfd3 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp
@@ -22,6 +22,12 @@
 #include "tao/PortableServer/POA_Current_Impl.h"
 #include "tao/PortableServer/POA_Current.h"
 
+#include <tao/TAO_Server_Request.h>
+#include <tao/DynamicInterface/Request.h>
+#include <tao/DynamicInterface/Server_Request.h>
+#include <tao/DynamicInterface/AMH_DSI_Response_Handler.h>
+#include <tao/Messaging/AMH_Response_Handler.h>
+
 /**
 * This constructor takes in orb and ImR_Locator_i pointers to store for later
 * use.  It also grabs a reference to the POACurrent object for use in
@@ -29,6 +35,7 @@
 */
 ImR_Forwarder::ImR_Forwarder (ImR_Locator_i& imr_impl)
   : locator_ (imr_impl)
+  , orb_ (0)
 {
 }
 
@@ -158,3 +165,230 @@ ImR_Forwarder::postinvoke (const PortableServer::ObjectId &,
 {
 }
 
+//-------------------------------------------------------------------------------------
+
+ImR_DSI_Forwarder::ImR_DSI_Forwarder (ImR_Locator_i& imr_impl)
+  : locator_ (imr_impl)
+  , orb_ (0)
+{
+}
+
+ImR_DSI_Forwarder::~ImR_DSI_Forwarder (void)
+{
+}
+
+void
+ImR_DSI_Forwarder::init (CORBA::ORB_ptr orb)
+{
+  ACE_ASSERT (! CORBA::is_nil(orb));
+  this->orb_ = orb;
+  try
+    {
+      CORBA::Object_var tmp =
+        orb->resolve_initial_references ("POACurrent");
+
+      this->poa_current_var_ =
+        PortableServer::Current::_narrow (tmp.in ());
+    }
+  catch (const CORBA::Exception&)
+    {
+      ACE_DEBUG ((LM_DEBUG, "ImR_Forwarder::init() Exception ignored.\n"));
+    }
+  ACE_ASSERT (!CORBA::is_nil (this->poa_current_var_.in ()));
+}
+
+void
+ImR_DSI_Forwarder::_dispatch (TAO_ServerRequest &request,
+                              TAO::Portable_Server::Servant_Upcall * /*context */ )
+{
+  // No need to do any of this if the client isn't waiting.
+  if (request.response_expected ())
+    {
+      if (!CORBA::is_nil (request.forward_location ()))
+        {
+          request.init_reply ();
+          request.tao_send_reply ();
+
+          // No need to invoke in this case.
+          return;
+        }
+      else if (request.sync_with_server ())
+        {
+          // The last line before the call to this function
+          // was an ACE_CHECK_RETURN, so if we're here, we
+          // know there is no exception so far, and that's all
+          // a SYNC_WITH_SERVER client request cares about.
+          request.send_no_exception_reply ();
+        }
+    }
+
+  // Create DSI request object.
+  CORBA::ServerRequest *dsi_request = 0;
+  ACE_NEW (dsi_request,
+           CORBA::ServerRequest (request));
+  try
+    {
+      TAO_AMH_DSI_Response_Handler_var rh;
+      ACE_NEW (rh, TAO_AMH_DSI_Response_Handler(request));
+
+      rh->init (request, 0);
+      // Delegate to user.
+      this->invoke (dsi_request, rh.in());
+    }
+  catch (CORBA::Exception& ex)
+    {
+      // Only if the client is waiting.
+      if (request.response_expected () && !request.sync_with_server ())
+        {
+          request.tao_send_reply_exception (ex);
+        }
+    }
+  CORBA::release (dsi_request);
+}
+
+void
+ImR_DSI_Forwarder::invoke (CORBA::ServerRequest_ptr )
+{
+  // unused method, only asynch invocations are used
+}
+
+char *
+ImR_DSI_Forwarder::_primary_interface (const PortableServer::ObjectId&,
+                                       PortableServer::POA_ptr)
+{
+  return CORBA::string_dup ("IDL:Object:1.0");
+}
+
+void
+ImR_DSI_Forwarder::invoke (CORBA::ServerRequest_ptr request,
+                           TAO_AMH_DSI_Response_Handler_ptr resp)
+{
+  bool is_oneway = !request->_tao_server_request().response_expected()
+    || request->_tao_server_request().sync_with_server();
+
+  if (is_oneway)
+    {
+      CORBA::release (resp);
+      return; // nothing else to do?
+    }
+
+  PortableServer::POA_var poa = this->poa_current_var_->get_POA();
+  PortableServer::ObjectId_var oid = this->poa_current_var_->get_object_id ();
+
+  CORBA::String_var server_name = poa->the_name();
+
+  CORBA::String_var key_str;
+  // Unlike POA Current, this implementation cannot be cached.
+  TAO::Portable_Server::POA_Current* tao_current =
+    dynamic_cast <TAO::Portable_Server::POA_Current*> (this->poa_current_var_.in ());
+
+  ACE_ASSERT(tao_current != 0);
+  TAO::Portable_Server::POA_Current_Impl* impl = tao_current->implementation ();
+  TAO::ObjectKey::encode_sequence_to_string (key_str.out (), impl->object_key ());
+
+  ImR_ReplyHandler * rh = new ImR_ReplyHandler(key_str.in(),
+                                               this->locator_.debug() > 0 ?
+                                               server_name.in() : "",
+                                               this->orb_, resp);
+  CORBA::String_var pior = this->locator_.activate_server_by_name (server_name.in(), false);
+
+  rh->send_ior (pior.in());
+}
+
+void
+ImR_DSI_Forwarder::invoke_get_interface(CORBA::ServerRequest_ptr )
+{
+  // no impl
+}
+
+void
+ImR_DSI_Forwarder::invoke_primary_interface(CORBA::ServerRequest_ptr )
+{
+  // no impl
+}
+
+
+//--------------------------------------------------------------------
+
+
+ImR_ReplyHandler::ImR_ReplyHandler (const char *key,
+                                    const char *server_name,
+                                    CORBA::ORB_ptr orb,
+                                    TAO_AMH_DSI_Response_Handler_ptr resp)
+  :key_str_ (key),
+   server_name_ (server_name),
+   orb_(CORBA::ORB::_duplicate (orb)),
+   resp_ (resp)
+{
+}
+
+ImR_ReplyHandler::~ImR_ReplyHandler (void)
+{
+}
+
+void
+ImR_ReplyHandler::send_ior (const char *pior)
+{
+  ACE_CString ior = pior;
+
+  // Check that the returned ior is the expected partial ior with
+  // missing ObjectKey.
+  if (ior.find ("corbaloc:") != 0 || ior[ior.length () - 1] != '/')
+    {
+      ACE_ERROR ((LM_ERROR,
+                  ACE_TEXT ("ImR_ReplyHandler::send_ior (): Invalid corbaloc ior.\n")
+                  ACE_TEXT ("\t<%s>\n"),
+                  ior.c_str()));
+
+      CORBA::OBJECT_NOT_EXIST ex (CORBA::SystemException::_tao_minor_code
+                                  ( TAO_IMPLREPO_MINOR_CODE, 0),
+                                  CORBA::COMPLETED_NO);
+      TAO_AMH_DSI_Exception_Holder h(&ex);
+      this->resp_->invoke_excep(&h);
+      delete this;
+      return;
+    }
+
+  ior += this->key_str_.in();
+
+  if (this->server_name_[0] != 0)
+    ACE_DEBUG ((LM_DEBUG,
+                ACE_TEXT ("ImR_ReplyHandler::send_ior(): Forwarding invocation on <%s> ")
+                ACE_TEXT ("to <%s>\n"),
+                this->server_name_.in(), ior.c_str()));
+
+  CORBA::Object_var forward_obj;
+    this->orb_->string_to_object (ior.c_str ());
+
+  if (!CORBA::is_nil (forward_obj.in ()))
+    {
+      PortableServer::ForwardRequest fwd (forward_obj.in ());
+      TAO_AMH_DSI_Exception_Holder h(&fwd);
+      this->resp_->invoke_excep(&h);
+      delete this;
+    }
+  else
+    {
+      ACE_ERROR ((LM_ERROR,
+                  ACE_TEXT ("ImR_ReplyHandler::send_ior (): Forward_to ")
+                  ACE_TEXT ("reference is nil.\n")));
+
+      CORBA::OBJECT_NOT_EXIST ex (CORBA::SystemException::_tao_minor_code
+                                  ( TAO_IMPLREPO_MINOR_CODE, 0),
+                                  CORBA::COMPLETED_NO);
+      TAO_AMH_DSI_Exception_Holder h(&ex);
+      this->resp_->invoke_excep(&h);
+      delete this;
+    }
+}
+
+void
+ImR_ReplyHandler::send_exception (void)
+{
+  CORBA::TRANSIENT ex (CORBA::SystemException::_tao_minor_code
+                       ( TAO_IMPLREPO_MINOR_CODE, 0),
+                       CORBA::COMPLETED_NO);
+  TAO_AMH_DSI_Exception_Holder h(&ex);
+  resp_->invoke_excep(&h);
+  delete this;
+}
diff --git a/TAO/orbsvcs/ImplRepo_Service/Forwarder.h b/TAO/orbsvcs/ImplRepo_Service/Forwarder.h
index 776735491bd..631330f6c55 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Forwarder.h
+++ b/TAO/orbsvcs/ImplRepo_Service/Forwarder.h
@@ -17,6 +17,9 @@
 
 #include "tao/PortableServer/PortableServer.h"
 #include "tao/PortableServer/ServantLocatorC.h"
+#include "tao/DynamicInterface/Dynamic_Implementation.h"
+#include "tao/DynamicInterface/AMH_DSI_Response_Handler.h"
+#include "tao/Messaging/Messaging.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
@@ -70,4 +73,65 @@ private:
   CORBA::ORB_ptr orb_;
 };
 
+// forward declare the types used to manage AMH/DSI coupling
+class TAO_AMH_DSI_Response_Handler;
+typedef TAO_AMH_DSI_Response_Handler * TAO_AMH_DSI_Response_Handler_ptr;
+class TAO_AMH_DSI_Response_Handler_var;
+
+class ImR_ReplyHandler
+{
+public:
+  ImR_ReplyHandler (const char *key,
+                    const char *server_name,
+                    CORBA::ORB_ptr orb,
+                    TAO_AMH_DSI_Response_Handler_ptr resp);
+
+  ~ImR_ReplyHandler (void);
+
+  void send_ior (const char *pior);
+  void send_exception (void);
+
+private:
+  CORBA::String_var key_str_;
+  CORBA::String_var server_name_;
+  CORBA::ORB_var orb_;
+  TAO_AMH_DSI_Response_Handler_var resp_;
+};
+
+class ImR_DSI_Forwarder : public virtual TAO_DynamicImplementation
+{
+public:
+  ImR_DSI_Forwarder (ImR_Locator_i& imr_impl);
+  virtual ~ImR_DSI_Forwarder (void);
+
+  virtual void _dispatch (TAO_ServerRequest& request,
+                          TAO::Portable_Server::Servant_Upcall *context);
+
+  void invoke (CORBA::ServerRequest_ptr request);
+
+  char * _primary_interface(const PortableServer::ObjectId&,
+                            PortableServer::POA_ptr);
+
+  void invoke (CORBA::ServerRequest_ptr request,
+               TAO_AMH_DSI_Response_Handler_ptr rh);
+
+  void invoke_get_interface(CORBA::ServerRequest_ptr request);
+
+  void invoke_primary_interface(CORBA::ServerRequest_ptr request);
+
+
+  void init(CORBA::ORB_ptr orb);
+
+private:
+  /// Where we find out where to forward to.
+  ImR_Locator_i& locator_;
+
+  /// POA reference.
+  PortableServer::Current_var poa_current_var_;
+
+  /// Variable to save the ORB reference passed to the constr.
+  CORBA::ORB_ptr orb_;
+};
+
+
 #endif /* IMR_FORWARDER_H */
diff --git a/TAO/orbsvcs/ImplRepo_Service/ImplRepo_Service.mpc b/TAO/orbsvcs/ImplRepo_Service/ImplRepo_Service.mpc
index 881141bd54b..1c44cbf19df 100644
--- a/TAO/orbsvcs/ImplRepo_Service/ImplRepo_Service.mpc
+++ b/TAO/orbsvcs/ImplRepo_Service/ImplRepo_Service.mpc
@@ -5,6 +5,7 @@ project(ImR_Activator_IDL) : orbsvcslib, orbsvcs_output, conv_lib, portableserve
   dynamicflags += ACTIVATOR_IDL_BUILD_DLL
   idlflags += -Wb,export_macro=ActivatorIDL_Export -Wb,export_include=activator_idl_export.h
   idl_files {
+    idlflags    += -GH -GC
     ImR_Activator.idl
   }
   source_files {
@@ -25,11 +26,12 @@ project(ImR_Locator_IDL) : orbsvcslib, orbsvcs_output, conv_lib, valuetype, port
   dynamicflags += LOCATOR_IDL_BUILD_DLL
   idlflags    += -Wb,export_macro=LocatorIDL_Export -Wb,export_include=locator_idl_export.h
   idl_files {
+    idlflags += -GH
     ImR_Locator.idl
   }
 
   idl_files {
-    idlflags    += -GH
+    idlflags    += -GH -GC
     AsyncStartupWaiter.idl
   }
 
@@ -63,7 +65,7 @@ project(ImR_Activator) : orbsvcslib, orbsvcs_output, conv_lib, acexml, avoids_mi
   }
 }
 
-project(ImR_Locator) : orbsvcslib, orbsvcs_output, conv_lib, avoids_minimum_corba, avoids_corba_e_compact, avoids_corba_e_micro, iortable, portableserver, messaging, svc_utils, acexml, imr_client, iormanip {
+project(ImR_Locator) : orbsvcslib, orbsvcs_output, conv_lib, avoids_minimum_corba, avoids_corba_e_compact, avoids_corba_e_micro, iortable, portableserver, messaging, svc_utils, acexml, imr_client, iormanip, dynamicinterface {
   sharedname   = TAO_ImR_Locator
   dynamicflags += LOCATOR_BUILD_DLL
   after       += ImR_Locator_IDL ImR_Activator_IDL
diff --git a/TAO/orbsvcs/ImplRepo_Service/Locator_Options.cpp b/TAO/orbsvcs/ImplRepo_Service/Locator_Options.cpp
index 265e6bd69ed..76b10bcc4ef 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Locator_Options.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/Locator_Options.cpp
@@ -35,6 +35,7 @@ Options::Options ()
 , service_command_ (SC_NONE)
 , unregister_if_address_reused_ (false)
 , imr_type_ (STANDALONE_IMR)
+, use_dsi_ (false)
 {
 }
 
@@ -235,6 +236,11 @@ Options::parse_args (int &argc, ACE_TCHAR *argv[])
           this->ping_interval_ =
             ACE_Time_Value (0, 1000 * ACE_OS::atoi (shifter.get_current ()));
         }
+      else if (ACE_OS::strcasecmp (shifter.get_current (),
+                                   ACE_TEXT ("--use_dsi")) == 0)
+        {
+          this->use_dsi_ = true;
+        }
       else
         {
           shifter.ignore_arg ();
@@ -298,6 +304,7 @@ Options::print_usage (void) const
     ACE_TEXT ("  -s              Run as a service\n")
     ACE_TEXT ("  -t secs         Server startup timeout.(Default=60s)\n")
     ACE_TEXT ("  -v msecs        Server verification interval.(Default=10s)\n")
+    ACE_TEXT ("  --use_dsi       Servant dispatching using \n")
               ));
 }
 
@@ -366,6 +373,10 @@ Options::save_registry_options ()
     (LPBYTE) &this->imr_type_ , sizeof (this->imr_type_));
   ACE_ASSERT (err == ERROR_SUCCESS);
 
+  err = ACE_TEXT_RegSetValueEx (key, ACE_TEXT ("UseDSI"), 0, REG_DWORD,
+    (LPBYTE) &this->use_dsi_ , sizeof (this->use_dsi_));
+  ACE_ASSERT (err == ERROR_SUCCESS);
+
   err = ::RegCloseKey (key);
   ACE_ASSERT (err == ERROR_SUCCESS);
 #endif
@@ -485,6 +496,14 @@ Options::load_registry_options ()
       ACE_ASSERT (type == REG_DWORD);
     }
 
+  sz = sizeof(use_dsi_);
+  err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT ("UseDSI"), 0, &type,
+    (LPBYTE) &this->use_dsi_ , &sz);
+  if (err == ERROR_SUCCESS)
+    {
+      ACE_ASSERT (type == REG_DWORD);
+    }
+
   err = ::RegCloseKey (key);
   ACE_ASSERT (err == ERROR_SUCCESS);
 #endif
@@ -568,6 +587,13 @@ Options::unregister_if_address_reused (void) const
 }
 
 Options::ImrType
-Options::imr_type(void) const {
+Options::imr_type (void) const
+{
   return this->imr_type_;
 }
+
+bool
+Options::use_dsi (void) const
+{
+  return this->use_dsi_;
+}
diff --git a/TAO/orbsvcs/ImplRepo_Service/Locator_Options.h b/TAO/orbsvcs/ImplRepo_Service/Locator_Options.h
index 8c62959de12..bf35b8cb140 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Locator_Options.h
+++ b/TAO/orbsvcs/ImplRepo_Service/Locator_Options.h
@@ -101,6 +101,8 @@ public:
   enum ImrType { BACKUP_IMR, PRIMARY_IMR, STANDALONE_IMR };
   ImrType imr_type(void) const;
 
+  bool use_dsi (void) const;
+
 private:
   /// Parses and pulls out arguments for the ImR
   int parse_args (int &argc, ACE_TCHAR *argv[]);
@@ -156,6 +158,10 @@ private:
 
   /// The type of ImR Locator this is.
   ImrType imr_type_;
+
+  /// Is the dispatching handled by a ServantLocator or a default servant?
+  bool use_dsi_;
+
 };
 
 #endif
diff --git a/TAO/tao/ImR_Client/ImR_Client.mpc b/TAO/tao/ImR_Client/ImR_Client.mpc
index 4350825cc33..95b22fe231e 100644
--- a/TAO/tao/ImR_Client/ImR_Client.mpc
+++ b/TAO/tao/ImR_Client/ImR_Client.mpc
@@ -2,7 +2,7 @@
 project(*idl) : tao_versioning_idl_defaults, install {
   custom_only = 1
   IDL_Files {
-    idlflags += -Gp -Gd -Sorb -GA \
+    idlflags += -Gp -Gd -Sorb -GA -GC\
                 -Wb,export_macro=TAO_IMR_Client_Export \
                 -Wb,export_include=tao/ImR_Client/imr_client_export.h \
                 -iC tao/ImR_Client
@@ -11,7 +11,7 @@ project(*idl) : tao_versioning_idl_defaults, install {
   }
 
   IDL_Files {
-    idlflags += -Gp -Gd -Sorb -GX \
+    idlflags += -Gp -Gd -Sorb -GX -GH \
                 -Wb,export_macro=TAO_IMR_Client_Export \
                 -Wb,export_include=tao/ImR_Client/imr_client_export.h \
                 -iC tao/ImR_Client
@@ -24,7 +24,7 @@ project(*idl) : tao_versioning_idl_defaults, install {
   }
 }
 
-project(ImR_Client) : taolib, tao_output, install, portableserver, taoidldefaults, iormanip {
+project(ImR_Client) : taolib, tao_output, install, portableserver, taoidldefaults, iormanip, valuetype, messaging {
   after       += *idl
   sharedname   = TAO_ImR_Client
   dynamicflags += TAO_IMR_CLIENT_BUILD_DLL