Sun Aug 8 21:10:30 UTC 2010 William R. Otte <wotte@dre.vanderbilt.edu>

        * TAO_IDL/be/be_codegen.cpp:
        * TAO_IDL/be/be_visitor_enum.cpp:
        * TAO_IDL/be/be_visitor_enum/any_op_ch.cpp:
        * TAO_IDL/be/be_visitor_enum/any_op_cs.cpp:
        * TAO_IDL/be/be_visitor_exception.cpp:
        * TAO_IDL/be/be_visitor_exception/any_op_ch.cpp:
        * TAO_IDL/be/be_visitor_exception/any_op_cs.cpp:
        * TAO_IDL/be/be_visitor_interface/any_op_ch.cpp:
        * TAO_IDL/be/be_visitor_interface/any_op_cs.cpp:
        * TAO_IDL/be/be_visitor_sequence.cpp:
        * TAO_IDL/be/be_visitor_sequence/any_op_ch.cpp:
        * TAO_IDL/be/be_visitor_sequence/any_op_cs.cpp:
        * TAO_IDL/be/be_visitor_structure.cpp:
        * TAO_IDL/be/be_visitor_structure/any_op_ch.cpp:
        * TAO_IDL/be/be_visitor_structure/any_op_cs.cpp:
        * TAO_IDL/be/be_visitor_union.cpp:
        * TAO_IDL/be/be_visitor_union/any_op_ch.cpp:
        * TAO_IDL/be/be_visitor_union/any_op_cs.cpp:
        * tao/AnyTypeCode/Any.h:
        * tao/AnyTypeCode/Any.inl:
        * tao/AnyTypeCode/Any.cpp:
        * tao/AnyTypeCode/ExceptionA.h:
        * tao/AnyTypeCode/ExceptionA.cpp:
        * tao/AnyTypeCode/PolicyA.h:
        * tao/AnyTypeCode/PolicyA.cpp:
        * tao/AnyTypeCode/WrongTransactionA.h:
        * tao/AnyTypeCode/WrongTransactionA.cpp:

          Expanded use of the ACE_ANY_OPS_USE_NAMESPACE macro for compilers that
          implement strict argument dependent lookup, especially for overloaded
          operators. 

        * tao/DynamicAny/DynCommon.cpp:
        * tao/Messaging/Buffering_Constraint_Policy.cpp:
        * tao/RTCORBA/RT_ProtocolPropertiesA.cpp:
        * tao/orbconf.h:

          Various compile fixes for the Clang LLVM compiler.

32 files changed, 1141 insertions, 145 deletions

diff --git a/TAO/ChangeLog b/TAO/ChangeLog
index 843bda9f4e3..6b7eb555c88 100644
--- a/TAO/ChangeLog
+++ b/TAO/ChangeLog
@@ -1,9 +1,50 @@
+Sun Aug  8 21:10:30 UTC 2010  William R. Otte  <wotte@dre.vanderbilt.edu>
+
+        * TAO_IDL/be/be_codegen.cpp:
+        * TAO_IDL/be/be_visitor_enum.cpp:
+        * TAO_IDL/be/be_visitor_enum/any_op_ch.cpp:
+        * TAO_IDL/be/be_visitor_enum/any_op_cs.cpp:
+        * TAO_IDL/be/be_visitor_exception.cpp:
+        * TAO_IDL/be/be_visitor_exception/any_op_ch.cpp:
+        * TAO_IDL/be/be_visitor_exception/any_op_cs.cpp:
+        * TAO_IDL/be/be_visitor_interface/any_op_ch.cpp:
+        * TAO_IDL/be/be_visitor_interface/any_op_cs.cpp:
+        * TAO_IDL/be/be_visitor_sequence.cpp:
+        * TAO_IDL/be/be_visitor_sequence/any_op_ch.cpp:
+        * TAO_IDL/be/be_visitor_sequence/any_op_cs.cpp:
+        * TAO_IDL/be/be_visitor_structure.cpp:
+        * TAO_IDL/be/be_visitor_structure/any_op_ch.cpp:
+        * TAO_IDL/be/be_visitor_structure/any_op_cs.cpp:
+        * TAO_IDL/be/be_visitor_union.cpp:
+        * TAO_IDL/be/be_visitor_union/any_op_ch.cpp:
+        * TAO_IDL/be/be_visitor_union/any_op_cs.cpp:
+        * tao/AnyTypeCode/Any.h:
+        * tao/AnyTypeCode/Any.inl:
+        * tao/AnyTypeCode/Any.cpp:
+        * tao/AnyTypeCode/ExceptionA.h:
+        * tao/AnyTypeCode/ExceptionA.cpp:
+        * tao/AnyTypeCode/PolicyA.h:
+        * tao/AnyTypeCode/PolicyA.cpp:
+        * tao/AnyTypeCode/WrongTransactionA.h:
+        * tao/AnyTypeCode/WrongTransactionA.cpp:
+
+          Expanded use of the ACE_ANY_OPS_USE_NAMESPACE macro for compilers that
+          implement strict argument dependent lookup, especially for overloaded
+          operators. 
+
+        * tao/DynamicAny/DynCommon.cpp:
+        * tao/Messaging/Buffering_Constraint_Policy.cpp:
+        * tao/RTCORBA/RT_ProtocolPropertiesA.cpp:
+        * tao/orbconf.h:
+
+          Various compile fixes for the Clang LLVM compiler.
+
 Fri Aug  6 20:24:47 UTC 2010  Jeff Parsons <j.parsons@vanderbilt.edu>
 
         * TAO_IDL/be/be_visitor_component.cpp:
         * TAO_IDL/be/be_visitor_home.cpp:
         * TAO_IDL/be_include/be_visitor_home.h:
-        
+
           Removed unnecessary includes.
 
 Fri Aug  6 20:18:12 UTC 2010  Jeff Parsons <j.parsons@vanderbilt.edu>
@@ -64,20 +105,20 @@ Fri Aug  6 18:57:50 UTC 2010  Jeff Parsons <j.parsons@vanderbilt.edu>
 Fri Aug  6 14:43:26 UTC 2010  Jeff Parsons <j.parsons@vanderbilt.edu>
 
         * bin/tao_other_tests.lst:
-        
+
           Added new test below.
 
 Fri Aug  6 14:35:45 UTC 2010  Jeff Parsons <j.parsons@vanderbilt.edu>
 
         * orbsvcs/tests/InterfaceRepo/Bug_3881_Regression/*.*:
-        
-          New test, consisiting of IDL file and perl script, to 
+
+          New test, consisiting of IDL file and perl script, to
           check for reintroduction of [BUGID:3881].
 
 Fri Aug  6 13:42:39 UTC 2010  Jeff Parsons <j.parsons@vanderbilt.edu>
 
         * orbsvcs/orbsvcs/IFRService/IFR_Service_Utils.cpp(valid_creation):
-        
+
           Skipped call to pre_exist() check if the new entry represents
           an IDL module, since modules may be reopened. This bug (reported
           by Bogdan Jeram <bjeram at eso dot org>) was somehow
@@ -96,14 +137,14 @@ Wed Aug  4 20:52:39 UTC 2010  Jeff Parsons <j.parsons@vanderbilt.edu>
         * TAO_IDL/be/be_util.cpp:
         * TAO_IDL/be/be_global.cpp:
         * TAO_IDL/be_include/be_global.h:
-        
+
           New IDL compiler option -Sg, which disables the generation of
           unique extensions on header file preprocessor guards. These
           changes are from a patch supplied by Bogdan Jeram
           <bjeram at eso dot org>, and close [BUGID:3867].
-          
+
         * docs/compiler.html:
-        
+
           Updated IDL compiler options table.
 
 Wed Aug  4 19:24:15 UTC 2010  Johnny Willemsen  <jwillemsen@remedy.nl>
diff --git a/TAO/TAO_IDL/be/be_codegen.cpp b/TAO/TAO_IDL/be/be_codegen.cpp
index bd40860d358..de5745f5a91 100644
--- a/TAO/TAO_IDL/be/be_codegen.cpp
+++ b/TAO/TAO_IDL/be/be_codegen.cpp
@@ -950,6 +950,9 @@ TAO_CodeGen::start_anyop_header (const char *fname)
                            << "\"";
     }
 
+  // Generate the include statement for AnyTypeCode
+  *this->anyop_header_ << "\n#include \"tao/AnyTypeCode/Any.h\"\n";
+
   const char *tao_prefix = "";
   ACE_CString pidl_checker (idl_global->filename ()->get_string ());
   bool const got_tao_pidl =
@@ -961,7 +964,7 @@ TAO_CodeGen::start_anyop_header (const char *fname)
     {
       tao_prefix = "tao/";
     }
-
+  
   // Generate the include statement for the client header. We just
   // need to put only the base names. Path info is not required.
   if (be_global->safe_include ())
@@ -2495,6 +2498,13 @@ TAO_CodeGen::gen_stub_hdr_includes (void)
                                "tao/AnyTypeCode/AnyTypeCode_methods.h",
                                this->client_header_);
 
+  this->gen_cond_file_include (be_global->tc_support ()
+                               && !be_global->gen_anyop_files (),
+                               "tao/AnyTypeCode/Any.h",
+                               this->client_header_);
+
+
+
   if (idl_global->abstract_iface_seen_ || idl_global->abstractbase_seen_)
     {
       // Include the AbstractBase file from the Valuetype library.
diff --git a/TAO/TAO_IDL/be/be_visitor_enum.cpp b/TAO/TAO_IDL/be/be_visitor_enum.cpp
index 69faa92d2ac..83f5e627b43 100644
--- a/TAO/TAO_IDL/be/be_visitor_enum.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_enum.cpp
@@ -17,6 +17,10 @@
 #include "be_enum_val.h"
 #include "be_helper.h"
 #include "be_extern.h"
+#include "be_module.h"
+#include "be_interface.h"
+#include "be_structure.h"
+#include "be_util.h"
 
 #include "be_visitor_enum.h"
 #include "be_visitor_context.h"
diff --git a/TAO/TAO_IDL/be/be_visitor_enum/any_op_ch.cpp b/TAO/TAO_IDL/be/be_visitor_enum/any_op_ch.cpp
index 79ddce9f48f..2761135062a 100644
--- a/TAO/TAO_IDL/be/be_visitor_enum/any_op_ch.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_enum/any_op_ch.cpp
@@ -42,6 +42,50 @@ be_visitor_enum_any_op_ch::visit_enum (be_enum *node)
   *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
       << "// " << __FILE__ << ":" << __LINE__;
 
+  be_module *module = 0;
+  
+  if (node->is_nested ())
+    {
+      AST_Decl *d = node;
+      AST_Decl::NodeType nt = d->node_type ();
+
+      while (nt != AST_Decl::NT_root)
+        {
+          if (nt == AST_Decl::NT_module)
+            {
+              module = be_module::narrow_from_decl (d);
+              break;
+            }
+          else
+            {
+              d = ScopeAsDecl (d->defined_in ());
+              nt = d->node_type ();
+            }
+        }
+
+      if (module != 0)
+        {
+          // Some compilers handle "any" operators in a namespace
+          // corresponding to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+      
+          be_util::gen_nested_namespace_begin (os, module);
+      
+          // Generate the Any <<= and >>= operators.
+          *os << be_nl << be_nl
+              << macro << " void operator<<= (::CORBA::Any &, ::" << node->name ()
+              << ");" << be_nl;
+          *os << macro << " ::CORBA::Boolean operator>>= (const ::CORBA::Any &, ::"
+              << node->name () << " &);";
+      
+          be_util::gen_nested_namespace_end (os, module);
+      
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n\n";
+        }
+    }
+
   *os << be_global->core_versioning_begin () << be_nl;
 
   // Generate the Any <<= and >>= operators.
@@ -53,6 +97,11 @@ be_visitor_enum_any_op_ch::visit_enum (be_enum *node)
 
   *os << be_global->core_versioning_end () << be_nl;
 
+  if (module != 0)
+    {
+      *os << "\n\n#endif";
+    }
+
   node->cli_hdr_any_op_gen (1);
   return 0;
 }
diff --git a/TAO/TAO_IDL/be/be_visitor_enum/any_op_cs.cpp b/TAO/TAO_IDL/be/be_visitor_enum/any_op_cs.cpp
index dcef9a62cae..26686877228 100644
--- a/TAO/TAO_IDL/be/be_visitor_enum/any_op_cs.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_enum/any_op_cs.cpp
@@ -72,6 +72,77 @@ be_visitor_enum_any_op_cs::visit_enum (be_enum *node)
           << "}" << be_uidt_nl
           << "}" << be_nl << be_nl;
     }
+  
+
+  *os << be_global->core_versioning_end () << be_nl;
+
+  be_module *module = 0;
+  if (node->is_nested ())
+    {
+      AST_Decl *d = node;
+      AST_Decl::NodeType nt = d->node_type ();
+
+      while (nt != AST_Decl::NT_root)
+        {
+          if (nt == AST_Decl::NT_module)
+            {
+              module = be_module::narrow_from_decl (d);
+              break;
+            }
+          else
+            {
+              d = ScopeAsDecl (d->defined_in ());
+              nt = d->node_type ();
+            }
+        }
+
+      if (module != 0)
+        {
+          // Some compilers handle "any" operators in a namespace corresponding
+          // to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+      
+          be_util::gen_nested_namespace_begin (os, module);
+      
+      
+          // Generate the Any <<= and >>= operator declarations
+          // Any <<= and >>= operators.
+          *os << "void operator<<= (" << be_idt << be_idt_nl
+              << "::CORBA::Any &_tao_any," << be_nl
+              << "::" << node->name () << " _tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "TAO::Any_Basic_Impl_T< ::" << node->name () << ">::insert ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->tc_name () << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+      
+          *os << "::CORBA::Boolean operator>>= (" << be_idt << be_idt_nl
+              << "const ::CORBA::Any &_tao_any," << be_nl
+              << "::" << node->name () << " &_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "return" << be_idt_nl
+              << "TAO::Any_Basic_Impl_T< ::" << node->name () << ">::extract ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->tc_name () << "," << be_nl
+              << "_tao_elem " << be_uidt_nl
+              << ");" << be_uidt << be_uidt << be_uidt_nl
+              << "}";
+      
+          be_util::gen_nested_namespace_end (os, module);
+      
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n";
+        }
+    }
+
+  *os << be_global->core_versioning_begin () << be_nl;
 
   // Generate the Any <<= and >>= operator declarations
   // Any <<= and >>= operators.
@@ -104,6 +175,11 @@ be_visitor_enum_any_op_cs::visit_enum (be_enum *node)
 
   *os << be_global->core_versioning_end () << be_nl;
 
+  if (module != 0)
+    {
+      *os << "\n\n#endif";
+    }
+
   node->cli_stub_any_op_gen (1);
   return 0;
 }
diff --git a/TAO/TAO_IDL/be/be_visitor_exception.cpp b/TAO/TAO_IDL/be/be_visitor_exception.cpp
index 2a405ca9a96..2586b7f1654 100644
--- a/TAO/TAO_IDL/be/be_visitor_exception.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_exception.cpp
@@ -16,6 +16,8 @@
 #include "be_exception.h"
 #include "be_typedef.h"
 #include "be_enum.h"
+#include "be_module.h"
+#include "be_util.h"
 #include "be_interface.h"
 #include "be_interface_fwd.h"
 #include "be_valuebox.h"
diff --git a/TAO/TAO_IDL/be/be_visitor_exception/any_op_ch.cpp b/TAO/TAO_IDL/be/be_visitor_exception/any_op_ch.cpp
index 2656807808e..cf5f5d9ed18 100644
--- a/TAO/TAO_IDL/be/be_visitor_exception/any_op_ch.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_exception/any_op_ch.cpp
@@ -43,6 +43,52 @@ be_visitor_exception_any_op_ch::visit_exception (be_exception *node)
   *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
       << "// " << __FILE__ << ":" << __LINE__;
 
+  be_module *module = 0;
+  if (node->is_nested ())
+    {
+      AST_Decl *d = node;
+      AST_Decl::NodeType nt = d->node_type ();
+
+      while (nt != AST_Decl::NT_root)
+        {
+          if (nt == AST_Decl::NT_module)
+            {
+              module = be_module::narrow_from_decl (d);
+              break;
+            }
+          else
+            {
+              d = ScopeAsDecl (d->defined_in ());
+              nt = d->node_type ();
+            }
+        }
+
+      if (module != 0)
+        {
+          // Some compilers handle "any" operators in a namespace
+          // corresponding to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+      
+          be_util::gen_nested_namespace_begin (os, module);
+      
+          *os << be_nl << be_nl
+              << macro << " void operator<<= (::CORBA::Any &, const ::" << node->name ()
+              << " &); // copying version" << be_nl;
+          *os << macro << " void operator<<= (::CORBA::Any &, ::" << node->name ()
+              << "*); // noncopying version" << be_nl;
+          *os << macro << " ::CORBA::Boolean operator>>= (const ::CORBA::Any &, ::"
+              << node->name () << " *&); // deprecated\n";
+          *os << macro << " ::CORBA::Boolean operator>>= (const ::CORBA::Any &, const ::"
+              << node->name () << " *&);";
+      
+          be_util::gen_nested_namespace_end (os, module);
+      
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n\n";
+        }
+    }
+      
   *os << be_global->core_versioning_begin () << be_nl;
   
   *os << be_nl << be_nl
@@ -56,6 +102,11 @@ be_visitor_exception_any_op_ch::visit_exception (be_exception *node)
       << node->name () << " *&);";
 
   *os << be_global->core_versioning_end () << be_nl;
+
+  if (module != 0)
+    {
+      *os << "\n\n#endif";
+    }
   
   // All we have to do is to visit the scope and generate code.
   if (this->visit_scope (node) == -1)
diff --git a/TAO/TAO_IDL/be/be_visitor_exception/any_op_cs.cpp b/TAO/TAO_IDL/be/be_visitor_exception/any_op_cs.cpp
index 3b38b21e2ce..7295a43fa2a 100644
--- a/TAO/TAO_IDL/be/be_visitor_exception/any_op_cs.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_exception/any_op_cs.cpp
@@ -110,6 +110,111 @@ be_visitor_exception_any_op_cs::visit_exception (be_exception *node)
           << "}" << be_uidt_nl
           << "}";
     }
+  
+  *os << be_global->core_versioning_end () << be_nl;
+
+  be_module *module = 0;
+  if (node->is_nested ())
+    {
+      AST_Decl *d = node;
+      AST_Decl::NodeType nt = d->node_type ();
+
+      while (nt != AST_Decl::NT_root)
+        {
+          if (nt == AST_Decl::NT_module)
+            {
+              module = be_module::narrow_from_decl (d);
+              break;
+            }
+          else
+            {
+              d = ScopeAsDecl (d->defined_in ());
+              nt = d->node_type ();
+            }
+        }
+
+      if (module != 0)
+        {
+          // Some compilers handle "any" operators in a namespace corresponding
+          // to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+
+          be_util::gen_nested_namespace_begin (os, module);
+
+          // Copying insertion operator.
+
+          *os << be_nl << be_nl
+              << "// Copying insertion." << be_nl
+              << "void operator<<= (" << be_idt << be_idt_nl
+              << "::CORBA::Any &_tao_any," << be_nl
+              << "const ::" << node->name () << " &_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::insert_copy ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << node->tc_name () << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Non-copying insertion operator."
+          *os << "// Non-copying insertion." << be_nl
+              << "void operator<<= (" << be_idt << be_idt_nl
+              << "::CORBA::Any &_tao_any," << be_nl
+              << "::" << node->name () << " *_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::insert ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << node->tc_name () << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Extraction to non-const pointer operator.
+          *os << "// Extraction to non-const pointer (deprecated)." << be_nl
+              << "::CORBA::Boolean operator>>= (" << be_idt << be_idt_nl
+              << "const ::CORBA::Any &_tao_any," << be_nl
+              << "::" << node->name () << " *&_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "return _tao_any >>= const_cast<" << be_idt << be_idt_nl
+              << "const ::" << node->name () << " *&> (" << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Extraction to const pointer operator.
+          *os << "// Extraction to const pointer." << be_nl
+              << "::CORBA::Boolean operator>>= (" << be_idt << be_idt_nl
+              << "const ::CORBA::Any &_tao_any," << be_nl
+              << "const ::" << node->name () << " *&_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "return" << be_idt_nl
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::extract ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << node->tc_name () << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt << be_uidt_nl
+              << "}";
+          
+          be_util::gen_nested_namespace_end (os, module);
+          
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n";
+        }
+    }
+  
+  
+  *os << be_global->core_versioning_begin () << be_nl;
 
   // Copying insertion operator.
 
@@ -176,7 +281,12 @@ be_visitor_exception_any_op_cs::visit_exception (be_exception *node)
       << "}";
 
   *os << be_global->core_versioning_end () << be_nl;
-
+  
+  if (module != 0)
+    {
+      *os << "\n\n#endif";
+    }
+  
   // all we have to do is to visit the scope and generate code
   if (this->visit_scope (node) == -1)
     {
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/any_op_ch.cpp b/TAO/TAO_IDL/be/be_visitor_interface/any_op_ch.cpp
index fb650d90879..6e4f9c76cf5 100644
--- a/TAO/TAO_IDL/be/be_visitor_interface/any_op_ch.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_interface/any_op_ch.cpp
@@ -49,42 +49,50 @@ be_visitor_interface_any_op_ch::visit_interface (be_interface *node)
 
   be_module *module = 0;
 
-  if (node->is_nested () &&
-      node->defined_in ()->scope_node_type () == AST_Decl::NT_module)
+  if (node->is_nested ())
     {
-      module = be_module::narrow_from_scope (node->defined_in ());
+      AST_Decl *d = node;
+      AST_Decl::NodeType nt = d->node_type ();
 
-      if (!module)
+      while (nt != AST_Decl::NT_root)
         {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "be_visitor_valuebox_any_op_ch::"
-                             "visit_valuebox - "
-                             "Error parsing nested name\n"),
-                            -1);
+          if (nt == AST_Decl::NT_module)
+            {
+              module = be_module::narrow_from_decl (d);
+              break;
+            }
+          else
+            {
+              d = ScopeAsDecl (d->defined_in ());
+              nt = d->node_type ();
+            }
         }
 
-      // Some compilers handle "any" operators in a namespace
-      // corresponding to their module, others do not.
-      *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
-
-      be_util::gen_nested_namespace_begin (os, module);
-
-      // emit  nested variation of any operators
-      *os << macro << " void"
-          << " operator<<= ( ::CORBA::Any &, " << node->local_name ()
-          << "_ptr); // copying" << be_nl;
-      *os << macro << " void"
-          << " operator<<= ( ::CORBA::Any &, " << node->local_name ()
-          << "_ptr *); // non-copying" << be_nl;
-      *os << macro << " ::CORBA::Boolean"
-          << " operator>>= (const ::CORBA::Any &, "
-          << node->local_name () << "_ptr &);";
-
-      be_util::gen_nested_namespace_end (os, module);
-
-      // Emit #else.
-      *os << be_nl << be_nl
-          << "#else\n\n";
+      if (module != 0)
+        {
+          // Some compilers handle "any" operators in a namespace
+          // corresponding to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+
+          be_util::gen_nested_namespace_begin (os, module);
+
+          // emit  nested variation of any operators
+          *os << macro << " void"
+              << " operator<<= ( ::CORBA::Any &, " << node->local_name ()
+              << "_ptr); // copying" << be_nl;
+          *os << macro << " void"
+              << " operator<<= ( ::CORBA::Any &, " << node->local_name ()
+              << "_ptr *); // non-copying" << be_nl;
+          *os << macro << " ::CORBA::Boolean"
+              << " operator>>= (const ::CORBA::Any &, "
+              << node->local_name () << "_ptr &);";
+
+          be_util::gen_nested_namespace_end (os, module);
+
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n\n";
+        }
     }
 
   *os << be_global->core_versioning_begin () << be_nl;
diff --git a/TAO/TAO_IDL/be/be_visitor_interface/any_op_cs.cpp b/TAO/TAO_IDL/be/be_visitor_interface/any_op_cs.cpp
index da138ec967c..7a77fa81e82 100644
--- a/TAO/TAO_IDL/be/be_visitor_interface/any_op_cs.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_interface/any_op_cs.cpp
@@ -125,74 +125,82 @@ be_visitor_interface_any_op_cs::visit_interface (be_interface *node)
 
   be_module *module = 0;
 
-  if (node->is_nested () &&
-      node->defined_in ()->scope_node_type () == AST_Decl::NT_module)
+  if (node->is_nested ())
     {
-      module = be_module::narrow_from_scope (node->defined_in ());
+      AST_Decl *d = node;
+      AST_Decl::NodeType nt = d->node_type ();
 
-      if (!module)
+      while (nt != AST_Decl::NT_root)
         {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "be_visitor_valuebox_any_op_cs::"
-                             "visit_valuebox - "
-                             "Error parsing nested name\n"),
-                            -1);
+          if (nt == AST_Decl::NT_module)
+            {
+              module = be_module::narrow_from_decl (d);
+              break;
+            }
+          else
+            {
+              d = ScopeAsDecl (d->defined_in ());
+              nt = d->node_type ();
+            }
         }
 
-      // Some compilers handle "any" operators in a namespace corresponding
-      // to their module, others do not.
-      *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
-
-      be_util::gen_nested_namespace_begin (os, module);
-
-      // emit  nested variation of any operators
-      *os << be_nl << be_nl
-          << "/// Copying insertion." << be_nl
-          << "void" << be_nl
-          << "operator<<= (" << be_idt << be_idt_nl
-          << "::CORBA::Any &_tao_any," << be_nl
-          << node->local_name () << "_ptr _tao_elem)" << be_uidt << be_uidt_nl
-          << "{" << be_idt_nl
-          << node->local_name () << "_ptr _tao_objptr =" << be_idt_nl
-          << node->local_name () << "::_duplicate (_tao_elem);" << be_uidt_nl
-          << "_tao_any <<= &_tao_objptr;" << be_uidt_nl
-          << "}" << be_nl << be_nl;
-
-      *os << "/// Non-copying insertion." << be_nl
-          << "void" << be_nl
-          << "operator<<= (" << be_idt << be_idt_nl
-          << "::CORBA::Any &_tao_any," << be_nl
-          << node->local_name () << "_ptr *_tao_elem)" << be_uidt << be_uidt_nl
-          << "{" << be_idt_nl
-          << "TAO::Any_Impl_T<" << node->local_name () << ">::insert ("
-          << be_idt << be_idt_nl
-          << "_tao_any," << be_nl
-          << node->local_name () << "::_tao_any_destructor," << be_nl
-          << node->tc_name ()->last_component () << "," << be_nl
-          << "*_tao_elem)" << be_uidt
-          << be_uidt << be_uidt_nl
-          << "}" << be_nl << be_nl;
-
-      *os << "::CORBA::Boolean" << be_nl
-          << "operator>>= (" << be_idt << be_idt_nl
-          << "const ::CORBA::Any &_tao_any," << be_nl
-          << node->local_name () << "_ptr &_tao_elem)" << be_uidt << be_uidt_nl
-          << "{" << be_idt_nl
-          << "return" << be_idt_nl
-          << "TAO::Any_Impl_T<" << node->local_name () << ">::extract ("
-          << be_idt << be_idt_nl
-          << "_tao_any," << be_nl
-          << node->local_name () << "::_tao_any_destructor," << be_nl
-          << node->tc_name ()->last_component () << "," << be_nl
-          << "_tao_elem)" << be_uidt << be_uidt
-          << be_uidt << be_uidt_nl
-          << "}";
-
-      be_util::gen_nested_namespace_end (os, module);
-
-      // Emit #else.
-      *os << be_nl << be_nl
-          << "#else\n";
+      if (module != 0)
+        {
+          // Some compilers handle "any" operators in a namespace corresponding
+          // to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+
+          be_util::gen_nested_namespace_begin (os, module);
+
+          // emit  nested variation of any operators
+          *os << be_nl << be_nl
+              << "/// Copying insertion." << be_nl
+              << "void" << be_nl
+              << "operator<<= (" << be_idt << be_idt_nl
+              << "::CORBA::Any &_tao_any," << be_nl
+              << node->local_name () << "_ptr _tao_elem)" << be_uidt << be_uidt_nl
+              << "{" << be_idt_nl
+              << node->local_name () << "_ptr _tao_objptr =" << be_idt_nl
+              << node->local_name () << "::_duplicate (_tao_elem);" << be_uidt_nl
+              << "_tao_any <<= &_tao_objptr;" << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          *os << "/// Non-copying insertion." << be_nl
+              << "void" << be_nl
+              << "operator<<= (" << be_idt << be_idt_nl
+              << "::CORBA::Any &_tao_any," << be_nl
+              << node->local_name () << "_ptr *_tao_elem)" << be_uidt << be_uidt_nl
+              << "{" << be_idt_nl
+              << "TAO::Any_Impl_T<" << node->local_name () << ">::insert ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << node->local_name () << "::_tao_any_destructor," << be_nl
+              << node->tc_name ()->last_component () << "," << be_nl
+              << "*_tao_elem);" << be_uidt
+              << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          *os << "::CORBA::Boolean" << be_nl
+              << "operator>>= (" << be_idt << be_idt_nl
+              << "const ::CORBA::Any &_tao_any," << be_nl
+              << node->local_name () << "_ptr &_tao_elem)" << be_uidt << be_uidt_nl
+              << "{" << be_idt_nl
+              << "return" << be_idt_nl
+              << "TAO::Any_Impl_T<" << node->local_name () << ">::extract ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << node->local_name () << "::_tao_any_destructor," << be_nl
+              << node->tc_name ()->last_component () << "," << be_nl
+              << "_tao_elem);" << be_uidt << be_uidt
+              << be_uidt << be_uidt_nl
+              << "}";
+
+          be_util::gen_nested_namespace_end (os, module);
+
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n";
+        }
     }
 
   *os << be_global->core_versioning_begin () << be_nl;
diff --git a/TAO/TAO_IDL/be/be_visitor_sequence.cpp b/TAO/TAO_IDL/be/be_visitor_sequence.cpp
index cb7e544587c..d39552b6bae 100644
--- a/TAO/TAO_IDL/be/be_visitor_sequence.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_sequence.cpp
@@ -15,6 +15,8 @@
 #include "be_array.h"
 #include "be_enum.h"
 #include "be_exception.h"
+#include "be_module.h"
+#include "be_util.h"
 #include "be_interface.h"
 #include "be_interface_fwd.h"
 #include "be_component.h"
diff --git a/TAO/TAO_IDL/be/be_visitor_sequence/any_op_ch.cpp b/TAO/TAO_IDL/be/be_visitor_sequence/any_op_ch.cpp
index 08fb6b10dca..4efb8c70596 100644
--- a/TAO/TAO_IDL/be/be_visitor_sequence/any_op_ch.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_sequence/any_op_ch.cpp
@@ -17,8 +17,8 @@
 // ***************************************************************************
 
 be_visitor_sequence_any_op_ch::be_visitor_sequence_any_op_ch (
-    be_visitor_context *ctx
-  )
+                                                              be_visitor_context *ctx
+                                                              )
   : be_visitor_decl (ctx)
 {
 }
@@ -66,6 +66,70 @@ be_visitor_sequence_any_op_ch::visit_sequence (be_sequence *node)
       name = node->full_name ();
     }
 
+  be_module *module = 0;  
+  if (node->is_nested ())
+    {
+      AST_Decl *d = node;
+      AST_Decl::NodeType nt = d->node_type ();
+
+      while (nt != AST_Decl::NT_root)
+        {
+          if (nt == AST_Decl::NT_module)
+            {
+              module = be_module::narrow_from_decl (d);
+              break;
+            }
+          else
+            {
+              d = ScopeAsDecl (d->defined_in ());
+              nt = d->node_type ();
+            }
+        }
+
+      if (module != 0)
+        {
+          // Some compilers handle "any" operators in a namespace
+          // corresponding to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+          
+          be_util::gen_nested_namespace_begin (os, module);
+
+          // Generate the Any <<= and >>= operators.
+          *os << macro
+              << " void"
+              << " operator<<= ( ::CORBA::Any &, const ::"
+              << name.c_str ()
+              << " &); // copying version" << be_nl;
+      
+          if (!alt)
+            {    
+              *os << macro
+                  << " void"
+                  << " operator<<= ( ::CORBA::Any &, ::"
+                  << name.c_str ()
+                  << "*); // noncopying version" << be_nl;
+      
+              *os << macro
+                  << " ::CORBA::Boolean"
+                  << " operator>>= (const ::CORBA::Any &, ::"
+                  << name.c_str ()
+                  << " *&); // deprecated" << be_nl;
+            }
+      
+          *os << macro
+              << " ::CORBA::Boolean"
+              << " operator>>= (const ::CORBA::Any &, const ::"
+              << name.c_str ()
+              << " *&);";
+
+          be_util::gen_nested_namespace_end (os, module);
+          
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n\n";
+        }
+    }
+
   *os << be_global->core_versioning_begin () << be_nl;
   
   // Generate the Any <<= and >>= operators.
@@ -88,7 +152,7 @@ be_visitor_sequence_any_op_ch::visit_sequence (be_sequence *node)
           << " operator>>= (const ::CORBA::Any &, "
           << name.c_str ()
           << " *&); // deprecated" << be_nl;
-        }
+    }
       
   *os << macro
       << " ::CORBA::Boolean"
@@ -97,6 +161,12 @@ be_visitor_sequence_any_op_ch::visit_sequence (be_sequence *node)
       << " *&);";
 
   *os << be_global->core_versioning_end () << be_nl;
+
+  if (module != 0)
+    {
+      *os << "\n\n#endif";
+    }
+
   
   node->cli_hdr_any_op_gen (true);
   return 0;
diff --git a/TAO/TAO_IDL/be/be_visitor_sequence/any_op_cs.cpp b/TAO/TAO_IDL/be/be_visitor_sequence/any_op_cs.cpp
index fe8df12a2da..ead93407e9b 100644
--- a/TAO/TAO_IDL/be/be_visitor_sequence/any_op_cs.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_sequence/any_op_cs.cpp
@@ -18,8 +18,8 @@
 // ***************************************************************************
 
 be_visitor_sequence_any_op_cs::be_visitor_sequence_any_op_cs (
-    be_visitor_context *ctx
-  )
+                                                              be_visitor_context *ctx
+                                                              )
   : be_visitor_decl (ctx)
 {
 }
@@ -88,21 +88,21 @@ be_visitor_sequence_any_op_cs::visit_sequence (be_sequence *node)
           
       switch (tc)
         {
-          case ANY_OBJREF:
-            *os << "insert_objref_vector<"
-                << bt->full_name () << "_ptr> (";
+        case ANY_OBJREF:
+          *os << "insert_objref_vector<"
+              << bt->full_name () << "_ptr> (";
                 
-            break;
-          case ANY_ARRAY:
-            *os << "insert_array_vector<"
-                << bt->full_name () << "_forany> (";
+          break;
+        case ANY_ARRAY:
+          *os << "insert_array_vector<"
+              << bt->full_name () << "_forany> (";
                 
-            break;
-          default:
-            *os << "insert_value_vector<"
-                << bt->full_name () << "> (";
+          break;
+        default:
+          *os << "insert_value_vector<"
+              << bt->full_name () << "> (";
                 
-            break;
+          break;
         }
           
       *os << be_idt_nl
@@ -121,21 +121,21 @@ be_visitor_sequence_any_op_cs::visit_sequence (be_sequence *node)
           
       switch (tc)
         {
-          case ANY_OBJREF:
-            *os << "extract_objref_vector<"
-                << bt->full_name () << "_ptr> (";
+        case ANY_OBJREF:
+          *os << "extract_objref_vector<"
+              << bt->full_name () << "_ptr> (";
                 
-            break;
-          case ANY_ARRAY:
-            *os << "extract_array_vector<"
-                << bt->full_name () << "_forany> (";
+          break;
+        case ANY_ARRAY:
+          *os << "extract_array_vector<"
+              << bt->full_name () << "_forany> (";
                 
-            break;
-          default:
-            *os << "extract_value_vector<"
-                << bt->full_name () << "> (";
+          break;
+        default:
+          *os << "extract_value_vector<"
+              << bt->full_name () << "> (";
                 
-            break;
+          break;
         }
           
       *os << be_idt_nl
@@ -178,11 +178,121 @@ be_visitor_sequence_any_op_cs::visit_sequence (be_sequence *node)
           << "}" << be_uidt_nl
           << "}" << be_nl;
     }
-    
+  
+  *os << be_global->core_versioning_end () << be_nl;
+
   // If this is non-zero, we want to call its tc_name()
   // for the TypeCode to pass to the Any operator impls.  
   be_typedef *td = this->ctx_->tdef ();
 
+  be_module *module = 0;  
+  if (node->is_nested ())
+    {
+      AST_Decl *d = node;
+      AST_Decl::NodeType nt = d->node_type ();
+
+      while (nt != AST_Decl::NT_root)
+        {
+          if (nt == AST_Decl::NT_module)
+            {
+              module = be_module::narrow_from_decl (d);
+              break;
+            }
+          else
+            {
+              d = ScopeAsDecl (d->defined_in ());
+              nt = d->node_type ();
+            }
+        }
+
+      if (module != 0)
+        {
+          // Some compilers handle "any" operators in a namespace
+          // corresponding to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+          
+          be_util::gen_nested_namespace_begin (os, module);
+  
+          // Copying insertion.
+          *os << be_nl
+              << "// Copying insertion." << be_nl
+              << "void operator<<= (" << be_idt << be_idt_nl
+              << "::CORBA::Any &_tao_any," << be_nl
+              << "const ::" << node->name () << " &_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+
+              << "if (0 == &_tao_elem) // Trying to de-reference NULL object"
+              << be_idt_nl
+              << "_tao_any <<= static_cast< ::" << node->name ()
+              << " *>( 0 ); // Use non-copying insertion of a NULL" << be_uidt_nl
+              << "else" << be_idt_nl
+
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::insert_copy ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << (td != 0 ? td->tc_name () : node->tc_name ()) << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Non-copying insertion.
+          *os << "// Non-copying insertion." << be_nl
+              << "void operator<<= (" << be_idt << be_idt_nl
+              << "::CORBA::Any &_tao_any," << be_nl
+              << "::" << node->name () << " *_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::insert ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << (td != 0 ? td->tc_name () : node->tc_name ()) << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Extraction to non-const pointer (deprecated, just calls the other).
+          *os << "// Extraction to non-const pointer (deprecated)." << be_nl
+              << "::CORBA::Boolean operator>>= (" << be_idt << be_idt_nl
+              << "const ::CORBA::Any &_tao_any," << be_nl
+              << "::" << node->name () << " *&_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "return _tao_any >>= const_cast<" << be_idt << be_idt_nl
+              << "const ::" << node->name () << " *&> (" << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Extraction to const pointer.
+          *os << "// Extraction to const pointer." << be_nl
+              << "::CORBA::Boolean operator>>= (" << be_idt << be_idt_nl
+              << "const ::CORBA::Any &_tao_any," << be_nl
+              << "const ::" << node->name () << " *&_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "return" << be_idt_nl
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::extract ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::"  <<  node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << (td != 0 ? td->tc_name () : node->tc_name ()) << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt << be_uidt_nl
+              << "}";
+
+          be_util::gen_nested_namespace_end (os, module);
+  
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n\n";
+        }
+    }
+
+  *os << be_global->core_versioning_begin () << be_nl;
+  
   // Copying insertion.
   *os << be_nl
       << "// Copying insertion." << be_nl
@@ -254,6 +364,11 @@ be_visitor_sequence_any_op_cs::visit_sequence (be_sequence *node)
       << "}";
 
   *os << be_global->core_versioning_end () << be_nl;
+
+  if (module != 0)
+    {
+      *os << "\n\n#endif";
+    }
   
   node->cli_stub_any_op_gen (true);
   return 0;
diff --git a/TAO/TAO_IDL/be/be_visitor_structure.cpp b/TAO/TAO_IDL/be/be_visitor_structure.cpp
index 6fc8d989d3b..f2eac91d559 100644
--- a/TAO/TAO_IDL/be/be_visitor_structure.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_structure.cpp
@@ -16,6 +16,9 @@
 #include "be_structure.h"
 #include "be_helper.h"
 #include "be_extern.h"
+#include "be_module.h"
+#include "be_interface.h"
+#include "be_util.h"
 
 #include "be_visitor_structure.h"
 #include "be_visitor_field.h"
diff --git a/TAO/TAO_IDL/be/be_visitor_structure/any_op_ch.cpp b/TAO/TAO_IDL/be/be_visitor_structure/any_op_ch.cpp
index 3f359421a8c..cfffd42a31e 100644
--- a/TAO/TAO_IDL/be/be_visitor_structure/any_op_ch.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_structure/any_op_ch.cpp
@@ -18,8 +18,8 @@
 // ***************************************************************************
 
 be_visitor_structure_any_op_ch::be_visitor_structure_any_op_ch (
-    be_visitor_context *ctx
-  )
+                                                                be_visitor_context *ctx
+                                                                )
   : be_visitor_structure (ctx)
 {
 }
@@ -42,7 +42,52 @@ be_visitor_structure_any_op_ch::visit_structure (be_structure *node)
 
   *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
       << "// " << __FILE__ << ":" << __LINE__ << be_nl << be_nl;
-
+  
+  be_module *module = 0;
+  if (node->is_nested ())
+    {
+      AST_Decl *d = node;
+      AST_Decl::NodeType nt = d->node_type ();
+
+      while (nt != AST_Decl::NT_root)
+        {
+          if (nt == AST_Decl::NT_module)
+            {
+              module = be_module::narrow_from_decl (d);
+              break;
+            }
+          else
+            {
+              d = ScopeAsDecl (d->defined_in ());
+              nt = d->node_type ();
+            }
+        }
+
+      if (module != 0)
+        {
+          // Some compilers handle "any" operators in a namespace
+          // corresponding to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+          
+          be_util::gen_nested_namespace_begin (os, module);
+          
+          *os << macro << " void operator<<= (::CORBA::Any &, const ::" << node->name ()
+              << " &); // copying version" << be_nl;
+          *os << macro << " void operator<<= (::CORBA::Any &, ::" << node->name ()
+              << "*); // noncopying version" << be_nl;
+          *os << macro << " ::CORBA::Boolean operator>>= (const ::CORBA::Any &, ::"
+              << node->name () << " *&); // deprecated\n";
+          *os << macro << " ::CORBA::Boolean operator>>= (const ::CORBA::Any &, const ::"
+              << node->name () << " *&);";
+          
+          be_util::gen_nested_namespace_end (os, module);
+          
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n\n";
+        }
+    }
+      
   *os << be_global->core_versioning_begin () << be_nl;
 
   *os << macro << " void operator<<= (::CORBA::Any &, const " << node->name ()
@@ -56,6 +101,12 @@ be_visitor_structure_any_op_ch::visit_structure (be_structure *node)
 
   *os << be_global->core_versioning_end () << be_nl;
 
+  if (module != 0)
+    {
+      *os << "\n\n#endif";
+    }
+
+
   // All we have to do is to visit the scope and generate code.
   if (this->visit_scope (node) == -1)
     {
diff --git a/TAO/TAO_IDL/be/be_visitor_structure/any_op_cs.cpp b/TAO/TAO_IDL/be/be_visitor_structure/any_op_cs.cpp
index a4f6b4be42a..42fb3f3c335 100644
--- a/TAO/TAO_IDL/be/be_visitor_structure/any_op_cs.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_structure/any_op_cs.cpp
@@ -19,8 +19,8 @@
 // ***************************************************************************
 
 be_visitor_structure_any_op_cs::be_visitor_structure_any_op_cs (
-    be_visitor_context *ctx
-  )
+                                                                be_visitor_context *ctx
+                                                                )
   : be_visitor_structure (ctx)
 {
 }
@@ -44,8 +44,6 @@ be_visitor_structure_any_op_cs::visit_structure (be_structure *node)
       << "// TAO_IDL - Generated from " << be_nl
       << "// " << __FILE__ << ":" << __LINE__ << be_nl << be_nl;
 
-  *os << be_global->core_versioning_begin () << be_nl;
-  
   // Since we don't generate CDR stream operators for types that
   // explicitly contain a local interface (at some level), we
   // must override these Any template class methods to avoid
@@ -54,6 +52,8 @@ be_visitor_structure_any_op_cs::visit_structure (be_structure *node)
   // type is inserted into an Any and then marshaled.
   if (node->is_local ())
     {
+      *os << be_global->core_versioning_begin () << be_nl;
+
       *os << be_nl << be_nl
           << "namespace TAO" << be_nl
           << "{" << be_idt_nl
@@ -74,7 +74,116 @@ be_visitor_structure_any_op_cs::visit_structure (be_structure *node)
           << "return false;" << be_uidt_nl
           << "}" << be_uidt_nl
           << "}";
+
+      *os << be_global->core_versioning_end () << be_nl;
+    }
+  
+
+  be_module *module = 0;
+  if (node->is_nested ())
+    {
+      AST_Decl *d = node;
+      AST_Decl::NodeType nt = d->node_type ();
+
+      while (nt != AST_Decl::NT_root)
+        {
+          if (nt == AST_Decl::NT_module)
+            {
+              module = be_module::narrow_from_decl (d);
+              break;
+            }
+          else
+            {
+              d = ScopeAsDecl (d->defined_in ());
+              nt = d->node_type ();
+            }
+        }
+
+      if (module != 0)
+        {
+          // Some compilers handle "any" operators in a namespace corresponding
+          // to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+
+          be_util::gen_nested_namespace_begin (os, module);
+
+          // Copying insertion.
+          *os << "// Copying insertion." << be_nl
+              << "void operator<<= (" << be_idt << be_idt_nl
+              << "::CORBA::Any &_tao_any," << be_nl
+              << "const ::" << node->name () << " &_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+
+              << "if (0 == &_tao_elem) // Trying to de-reference NULL object" << be_idt_nl
+              << "_tao_any <<= static_cast< ::" << node->name () << " *>( 0 ); "
+              << "// Use non-copying insertion of a NULL" << be_uidt_nl
+              << "else" << be_idt_nl
+
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::insert_copy ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << node->tc_name () << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Non-copying insertion.
+          *os << "// Non-copying insertion." << be_nl
+              << "void operator<<= (" << be_idt << be_idt_nl
+              << "::CORBA::Any &_tao_any, ::" << be_nl
+              << node->name () << " *_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::insert ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << node->tc_name () << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Extraction to non-const pointer (deprecated, just calls the other).
+          *os << "// Extraction to non-const pointer (deprecated)." << be_nl
+              << "::CORBA::Boolean operator>>= (" << be_idt << be_idt_nl
+              << "const ::CORBA::Any &_tao_any," << be_nl
+              << "::" << node->name () << " *&_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "return _tao_any >>= const_cast<" << be_idt << be_idt_nl
+              << "const ::" << node->name () << " *&> (" << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Extraction to const pointer.
+          *os << "// Extraction to const pointer." << be_nl
+              << "::CORBA::Boolean operator>>= (" << be_idt << be_idt_nl
+              << "const ::CORBA::Any &_tao_any," << be_nl
+              << "const ::" << node->name () << " *&_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "return" << be_idt_nl
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::extract ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << node->tc_name () << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt << be_uidt_nl
+              << "}";
+      
+          be_util::gen_nested_namespace_end (os, module);
+      
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n";
+        }
     }
+  
+  *os << be_global->core_versioning_begin () << be_nl;
 
   // Copying insertion.
   *os << "// Copying insertion." << be_nl
@@ -145,6 +254,11 @@ be_visitor_structure_any_op_cs::visit_structure (be_structure *node)
 
   *os << be_global->core_versioning_end () << be_nl;
 
+  if (module != 0)
+    {
+      *os << "\n\n#endif";
+    }
+
   // all we have to do is to visit the scope and generate code
   if (this->visit_scope (node) == -1)
     {
diff --git a/TAO/TAO_IDL/be/be_visitor_union.cpp b/TAO/TAO_IDL/be/be_visitor_union.cpp
index 8db265851c4..5304f511c3f 100644
--- a/TAO/TAO_IDL/be/be_visitor_union.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_union.cpp
@@ -16,6 +16,9 @@
 #include "be_enum.h"
 #include "be_typedef.h"
 #include "be_predefined_type.h"
+#include "be_module.h"
+#include "be_util.h"
+#include "be_interface.h"
 #include "be_union.h"
 #include "be_union_branch.h"
 #include "be_helper.h"
diff --git a/TAO/TAO_IDL/be/be_visitor_union/any_op_ch.cpp b/TAO/TAO_IDL/be/be_visitor_union/any_op_ch.cpp
index 6b659bb6d10..1de1131be30 100644
--- a/TAO/TAO_IDL/be/be_visitor_union/any_op_ch.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_union/any_op_ch.cpp
@@ -43,6 +43,55 @@ be_visitor_union_any_op_ch::visit_union (be_union *node)
   *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
       << "// " << __FILE__ << ":" << __LINE__ << be_nl << be_nl;
 
+  be_module *module = 0;
+  
+  AST_Decl *decl = node;
+  if (decl->is_nested ())
+    {
+      if (node->defined_in ()->scope_node_type () == AST_Decl::NT_interface)
+        {
+          be_interface *intf = 0;
+          intf = be_interface::narrow_from_scope (node->defined_in ());
+          decl = intf;
+        }
+
+      if (decl->defined_in ()->scope_node_type () == AST_Decl::NT_module)
+        {
+          module = be_module::narrow_from_scope (decl->defined_in ());
+
+          if (!module)
+            {
+              ACE_ERROR_RETURN ((LM_ERROR,
+                                 "be_visitor_union_any_op_ch::"
+                                 "visit_union - "
+                                 "Error parsing nested name\n"),
+                                -1);
+            }
+          
+          // Some compilers handle "any" operators in a namespace
+          // corresponding to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+          
+          be_util::gen_nested_namespace_begin (os, module);
+          
+  
+          *os << macro << " void operator<<= (::CORBA::Any &, const ::" << node->name ()
+              << " &); // copying version" << be_nl;
+          *os << macro << " void operator<<= (::CORBA::Any &, ::" << node->name ()
+              << "*); // noncopying version" << be_nl;
+          *os << macro << " ::CORBA::Boolean operator>>= (const ::CORBA::Any &, ::"
+              << node->name () << " *&); // deprecated\n";
+          *os << macro << " ::CORBA::Boolean operator>>= (const ::CORBA::Any &, const ::"
+              << node->name () << " *&);";
+          
+          be_util::gen_nested_namespace_end (os, module);
+          
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n\n";
+        }
+    }
+
   *os << be_global->core_versioning_begin () << be_nl;
   
   *os << macro << " void operator<<= (::CORBA::Any &, const " << node->name ()
@@ -56,6 +105,11 @@ be_visitor_union_any_op_ch::visit_union (be_union *node)
 
   *os << be_global->core_versioning_end () << be_nl;
 
+  if (module != 0)
+    {
+      *os << "\n\n#endif";
+    }
+
   if (this->visit_scope (node) == -1)
     {
       ACE_ERROR_RETURN ((LM_ERROR,
diff --git a/TAO/TAO_IDL/be/be_visitor_union/any_op_cs.cpp b/TAO/TAO_IDL/be/be_visitor_union/any_op_cs.cpp
index e2e2fd57012..e70f3b780a7 100644
--- a/TAO/TAO_IDL/be/be_visitor_union/any_op_cs.cpp
+++ b/TAO/TAO_IDL/be/be_visitor_union/any_op_cs.cpp
@@ -76,6 +76,116 @@ be_visitor_union_any_op_cs::visit_union (be_union *node)
           << "}";
     }
 
+  *os << be_global->core_versioning_end () << be_nl;
+
+  be_module *module = 0;
+
+  AST_Decl *decl = node;
+  if (decl->is_nested ())
+    {
+      if (node->defined_in ()->scope_node_type () == AST_Decl::NT_interface)
+        {
+          be_interface *intf = 0;
+          intf = be_interface::narrow_from_scope (node->defined_in ());
+          decl = intf;
+        }
+
+      if (decl->defined_in ()->scope_node_type () == AST_Decl::NT_module)
+        {
+          module = be_module::narrow_from_scope (decl->defined_in ());
+          
+          if (!module)
+            {
+              ACE_ERROR_RETURN ((LM_ERROR,
+                                 "be_visitor_valuebox_any_op_cs::"
+                                 "visit_valuebox - "
+                                 "Error parsing nested name\n"),
+                                -1);
+            }
+
+          // Some compilers handle "any" operators in a namespace corresponding
+          // to their module, others do not.
+          *os << "\n\n#if defined (ACE_ANY_OPS_USE_NAMESPACE)\n";
+
+          be_util::gen_nested_namespace_begin (os, module);
+
+          // Copying insertion.
+          *os << "// Copying insertion." << be_nl
+              << "void operator<<= (" << be_idt << be_idt_nl
+              << "::CORBA::Any &_tao_any," << be_nl
+              << "const ::" << node->name () << " &_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+
+              << "if (0 == &_tao_elem) // Trying to de-reference NULL object" << be_idt_nl
+              << "_tao_any <<= static_cast< ::" << node->name () << " *>( 0 ); // Use non-copying insertion of a NULL" << be_uidt_nl
+              << "else" << be_idt_nl
+
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::insert_copy ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << node->tc_name () << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Non-copying insertion.
+          *os << "// Non-copying insertion." << be_nl
+              << "void operator<<= (" << be_idt << be_idt_nl
+              << "::CORBA::Any &_tao_any," << be_nl
+              << "::" << node->name () << " *_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::insert ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << node->tc_name () << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Extraction to non-const pointer (deprecated, just calls the other).
+          *os << "// Extraction to non-const pointer (deprecated)." << be_nl
+              << "::CORBA::Boolean operator>>= (" << be_idt << be_idt_nl
+              << "const ::CORBA::Any &_tao_any," << be_nl
+              << "::" << node->name () << " *&_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "return _tao_any >>= const_cast<" << be_idt << be_idt_nl
+              << "const ::" << node->name () << " *&> (" << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt_nl
+              << "}" << be_nl << be_nl;
+
+          // Extraction to const pointer.
+          *os << "// Extraction to const pointer." << be_nl
+              << "::CORBA::Boolean operator>>= (" << be_idt << be_idt_nl
+              << "const ::CORBA::Any &_tao_any," << be_nl
+              << "const ::" << node->name () << " *&_tao_elem" << be_uidt_nl
+              << ")" << be_uidt_nl
+              << "{" << be_idt_nl
+              << "return" << be_idt_nl
+              << "TAO::Any_Dual_Impl_T< ::" << node->name () << ">::extract ("
+              << be_idt << be_idt_nl
+              << "_tao_any," << be_nl
+              << "::" << node->name () << "::_tao_any_destructor," << be_nl
+              << "::" << node->tc_name () << "," << be_nl
+              << "_tao_elem" << be_uidt_nl
+              << ");" << be_uidt << be_uidt << be_uidt_nl
+              << "}";
+
+          be_util::gen_nested_namespace_end (os, module);
+      
+          // Emit #else.
+          *os << be_nl << be_nl
+              << "#else\n";          
+        }
+    }
+
+  *os << be_global->core_versioning_begin () << be_nl;
+
   // Copying insertion.
   *os << "// Copying insertion." << be_nl
       << "void operator<<= (" << be_idt << be_idt_nl
@@ -145,6 +255,11 @@ be_visitor_union_any_op_cs::visit_union (be_union *node)
 
   *os << be_global->core_versioning_end () << be_nl;
 
+  if (module != 0)
+    {
+      *os << "\n\n#endif";
+    }
+
   // All we have to do is to visit the scope and generate code.
   if (this->visit_scope (node) == -1)
     {
diff --git a/TAO/tao/AnyTypeCode/Any.cpp b/TAO/tao/AnyTypeCode/Any.cpp
index 05669e3bdee..8cd963b628e 100644
--- a/TAO/tao/AnyTypeCode/Any.cpp
+++ b/TAO/tao/AnyTypeCode/Any.cpp
@@ -368,6 +368,11 @@ CORBA::Any::operator<<= (CORBA::Any::from_wstring ws)
 
 // Insertion of the other basic types.
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
+
 void
 operator<<= (CORBA::Any &any, CORBA::Short s)
 {
@@ -743,6 +748,10 @@ operator >>= (const CORBA::Any &any, std::string &str)
   return flag;
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
+
 // ================================================================
 // Any_Impl_T template specializations.
 
diff --git a/TAO/tao/AnyTypeCode/Any.h b/TAO/tao/AnyTypeCode/Any.h
index 6f6dfe69e7e..9ff3890fc22 100644
--- a/TAO/tao/AnyTypeCode/Any.h
+++ b/TAO/tao/AnyTypeCode/Any.h
@@ -282,6 +282,11 @@ operator<< (std::ostream &, const CORBA::Any &);
 
 #endif /* GEN_OSTREAM_OPS */
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
+
 /// Typesafe insertion.
 
 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::Short);
@@ -335,6 +340,10 @@ TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &,
                                        std::string &);
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
 #if defined (__ACE_INLINE__)
@@ -343,6 +352,11 @@ TAO_END_VERSIONED_NAMESPACE_DECL
 
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
+
 /// Copying versions of insertion operators for basic types
 /// must also be defined for CORBA::Any_var.
 
@@ -407,6 +421,10 @@ TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any_var &,
                                        CORBA::Any::to_object);
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
 #endif /* __ACE_INLINE__ */
diff --git a/TAO/tao/AnyTypeCode/Any.inl b/TAO/tao/AnyTypeCode/Any.inl
index 761f4d13175..a293f5e0036 100644
--- a/TAO/tao/AnyTypeCode/Any.inl
+++ b/TAO/tao/AnyTypeCode/Any.inl
@@ -88,6 +88,11 @@ CORBA::Any_var::ptr (void) const
 // CORBA::Any_var insertion operators
 // *************************************************************
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
+
 ACE_INLINE void
 operator <<= (CORBA::Any_var &lhs, CORBA::Short rhs)
 {
@@ -314,6 +319,10 @@ operator >>= (const CORBA::Any_var &lhs, CORBA::Any::to_object rhs)
   return lhs.in () >>= rhs;
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
+
 // *************************************************************
 // Inline operations for class CORBA::Any_out
 // *************************************************************
diff --git a/TAO/tao/AnyTypeCode/ExceptionA.cpp b/TAO/tao/AnyTypeCode/ExceptionA.cpp
index 55f7ff6ef58..4d0d6668a94 100644
--- a/TAO/tao/AnyTypeCode/ExceptionA.cpp
+++ b/TAO/tao/AnyTypeCode/ExceptionA.cpp
@@ -83,6 +83,11 @@ namespace TAO
 
 // =======================================================================
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
+
 
 // Insertion of CORBA::Exception - copying.
 void
@@ -106,5 +111,9 @@ operator<<= (CORBA::Any &any, CORBA::Exception *exception)
       exception);
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
+
 
 TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/AnyTypeCode/ExceptionA.h b/TAO/tao/AnyTypeCode/ExceptionA.h
index 61156287d71..06dbfb9c982 100644
--- a/TAO/tao/AnyTypeCode/ExceptionA.h
+++ b/TAO/tao/AnyTypeCode/ExceptionA.h
@@ -36,9 +36,18 @@ namespace CORBA
   typedef Any *Any_ptr;
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
+
 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, const CORBA::Exception &);
 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::Exception *);
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
+
 TAO_END_VERSIONED_NAMESPACE_DECL
 
 #include /**/"ace/post.h"
diff --git a/TAO/tao/AnyTypeCode/PolicyA.cpp b/TAO/tao/AnyTypeCode/PolicyA.cpp
index 415b13e6224..0ec8e48a7b4 100644
--- a/TAO/tao/AnyTypeCode/PolicyA.cpp
+++ b/TAO/tao/AnyTypeCode/PolicyA.cpp
@@ -169,6 +169,11 @@ namespace TAO
   }
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
+
 // Copying insertion.
 void operator<<= (
     CORBA::Any &_tao_any,
@@ -224,6 +229,10 @@ CORBA::Boolean operator>>= (
       );
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
+
 // TAO_IDL - Generated from
 // be\be_visitor_exception/any_op_cs.cpp:50
 
@@ -255,6 +264,11 @@ namespace TAO
   }
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
+
 // Copying insertion.
 void operator<<= (
     CORBA::Any &_tao_any,
@@ -310,6 +324,10 @@ CORBA::Boolean operator>>= (
       );
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
+
 // TAO_IDL - Generated from
 // be\be_visitor_interface/any_op_cs.cpp:50
 
@@ -326,6 +344,11 @@ namespace TAO
   }
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
+
 // Copying insertion.
 void
 operator<<= (
@@ -368,6 +391,10 @@ operator>>= (
       );
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
+
 // TAO_IDL - Generated from
 // be\be_visitor_interface/any_op_cs.cpp:50
 
diff --git a/TAO/tao/AnyTypeCode/PolicyA.h b/TAO/tao/AnyTypeCode/PolicyA.h
index 34f9bb4101e..1abfdbcdd0a 100644
--- a/TAO/tao/AnyTypeCode/PolicyA.h
+++ b/TAO/tao/AnyTypeCode/PolicyA.h
@@ -87,7 +87,10 @@ namespace CORBA
 
 } // module CORBA
 
-
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
 // TAO_IDL - Generated from
 // be\be_visitor_exception/any_op_ch.cpp:52
 
@@ -111,6 +114,10 @@ TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::Policy_ptr); // co
 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::Policy_ptr *); // non-copying
 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Policy_ptr &);
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
+
 // TAO_IDL - Generated from
 // be\be_codegen.cpp:955
 
diff --git a/TAO/tao/AnyTypeCode/WrongTransactionA.cpp b/TAO/tao/AnyTypeCode/WrongTransactionA.cpp
index 1eb4a217261..40d37559b4e 100644
--- a/TAO/tao/AnyTypeCode/WrongTransactionA.cpp
+++ b/TAO/tao/AnyTypeCode/WrongTransactionA.cpp
@@ -91,6 +91,11 @@ namespace TAO
   }
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
+
 // Copying insertion.
 void operator<<= (
     CORBA::Any &_tao_any,
@@ -146,4 +151,8 @@ CORBA::Boolean operator>>= (
       );
 }
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
+
 TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/AnyTypeCode/WrongTransactionA.h b/TAO/tao/AnyTypeCode/WrongTransactionA.h
index fa1b876847b..b5a4f5abbc8 100644
--- a/TAO/tao/AnyTypeCode/WrongTransactionA.h
+++ b/TAO/tao/AnyTypeCode/WrongTransactionA.h
@@ -83,11 +83,19 @@ namespace TAO
 // TAO_IDL - Generated from
 // be\be_visitor_exception/any_op_ch.cpp:52
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+namespace CORBA
+{
+#endif
+
 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, const CORBA::WrongTransaction &); // copying version
 TAO_AnyTypeCode_Export void operator<<= (CORBA::Any &, CORBA::WrongTransaction*); // noncopying version
 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::WrongTransaction *&); // deprecated
 TAO_AnyTypeCode_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::WrongTransaction *&);
 
+#ifdef ACE_ANY_OPS_USE_NAMESPACE
+}
+#endif
 // TAO_IDL - Generated from
 // be\be_codegen.cpp:955
 
diff --git a/TAO/tao/DynamicAny/DynCommon.cpp b/TAO/tao/DynamicAny/DynCommon.cpp
index 7a785ef6ea1..4256113aa32 100644
--- a/TAO/tao/DynamicAny/DynCommon.cpp
+++ b/TAO/tao/DynamicAny/DynCommon.cpp
@@ -1,5 +1,8 @@
 // $Id$
 
+#include "tao/AnyTypeCode/AnyTypeCode_methods.h"
+#include "tao/Valuetype/AbstractBase.h"
+
 #include "tao/DynamicAny/DynCommon.h"
 
 #include "tao/DynamicAny/DynAnyFactory.h"
@@ -19,6 +22,7 @@
 #include "ace/OS_NS_wchar.h"
 #include "ace/OS_NS_string.h"
 
+
 ACE_RCSID (DynamicAny,
            DynCommon,
            "$Id$")
diff --git a/TAO/tao/Messaging/Buffering_Constraint_Policy.cpp b/TAO/tao/Messaging/Buffering_Constraint_Policy.cpp
index cfa1ba26341..e01d7c229c2 100644
--- a/TAO/tao/Messaging/Buffering_Constraint_Policy.cpp
+++ b/TAO/tao/Messaging/Buffering_Constraint_Policy.cpp
@@ -45,7 +45,7 @@ TAO_Buffering_Constraint_Policy::policy_type (void)
 CORBA::Policy_ptr
 TAO_Buffering_Constraint_Policy::create (const CORBA::Any& val)
 {
-  TAO::BufferingConstraint *buffering_constraint = 0;
+  const TAO::BufferingConstraint *buffering_constraint = 0;
   if ((val >>= buffering_constraint) == 0)
     throw ::CORBA::PolicyError (CORBA::BAD_POLICY_VALUE);
 
diff --git a/TAO/tao/RTCORBA/RT_ProtocolPropertiesA.cpp b/TAO/tao/RTCORBA/RT_ProtocolPropertiesA.cpp
index 7fd4f6bb209..4411903d74b 100644
--- a/TAO/tao/RTCORBA/RT_ProtocolPropertiesA.cpp
+++ b/TAO/tao/RTCORBA/RT_ProtocolPropertiesA.cpp
@@ -130,7 +130,7 @@ namespace RTCORBA
         _tao_any,
         ProtocolProperties::_tao_any_destructor,
         _tc_ProtocolProperties,
-        *_tao_elem)
+        *_tao_elem);
   }
   
   ::CORBA::Boolean
@@ -143,7 +143,7 @@ namespace RTCORBA
           _tao_any,
           ProtocolProperties::_tao_any_destructor,
           _tc_ProtocolProperties,
-          _tao_elem)
+          _tao_elem);
   }
 }
 
diff --git a/TAO/tao/orbconf.h b/TAO/tao/orbconf.h
index b980e3b1e5c..fdea9c361e8 100644
--- a/TAO/tao/orbconf.h
+++ b/TAO/tao/orbconf.h
@@ -21,6 +21,7 @@
 
 #include "ace/Basic_Types.h"
 #include "ace/Global_Macros.h"
+#include "ace/Condition_Thread_Mutex.h"
 #include "ace/Synch_Traits.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)