ChangeLogTag:Fri Dec 03 02:32:03 1999 Nanbor Wang <nanbor@cs.wustl.edu>

25 files changed, 788 insertions, 763 deletions

diff --git a/TAO/ChangeLog-99c b/TAO/ChangeLog-99c
index 6c5d0b16825..306992b14f5 100644
--- a/TAO/ChangeLog-99c
+++ b/TAO/ChangeLog-99c
@@ -1,3 +1,31 @@
+Fri Dec 03 02:32:03 1999  Nanbor Wang  <nanbor@cs.wustl.edu>
+
+	* tao/Any.h:
+	* tao/CDR.h:
+	* tao/CONV_FRAMEC.h:
+	* tao/DomainC.h:
+	* tao/Exception.h:
+	* tao/GIOP.h:
+	* tao/IOPC.h:
+	* tao/IORC.h:
+	* tao/InterceptorC.h:
+	* tao/InterfaceC.h:
+	* tao/MessagingC.h:
+	* tao/ORB.h:
+	* tao/ORB_Core.h:
+	* tao/Object.h:
+	* tao/ObjectIDList.h:
+	* tao/POAC.h:
+	* tao/PolicyC.h:
+	* tao/PollableC.h:
+	* tao/Principal.h:
+	* tao/Sequence.h:
+	* tao/TAOC.h:
+	* tao/TimeBaseC.h:
+	* tao/corbafwd.h:
+	* tao/orbconf.h: Made sure all the top level functions are
+	  exported correctly.
+
 Thu Dec  2 22:01:25 1999  Marina Spivak  <marina@cs.wustl.edu>
 
 	* performance-tests/RTCorba/Multiple_Endpoints/Endpoint_Per_Priority/Client.dsp
diff --git a/TAO/tao/Any.h b/TAO/tao/Any.h
index 1b42aeafc69..9c010470e85 100644
--- a/TAO/tao/Any.h
+++ b/TAO/tao/Any.h
@@ -483,77 +483,77 @@ private:
 // Copying versions of insertion
 // operators which are defined as members of the Any class
 // must also be defined for Any_var.
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::Short);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::UShort);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::Long);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::ULong);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::LongLong);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::ULongLong);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::Float);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::Double);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    const CORBA_Any&);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    const char*);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::TypeCode_ptr);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    const CORBA::Object_ptr);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::Any::from_boolean);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::Any::from_char);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::Any::from_wchar);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::Any::from_octet);
-extern TAO_Export void operator<<= (CORBA_Any_var,
-                                    CORBA::Any::from_string);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::Short);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::UShort);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::Long);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::ULong);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::LongLong);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::ULongLong);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::Float);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::Double);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             const CORBA_Any&);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             const char*);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::TypeCode_ptr);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             const CORBA::Object_ptr);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::Any::from_boolean);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::Any::from_char);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::Any::from_wchar);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::Any::from_octet);
+TAO_Export void operator<<= (CORBA_Any_var,
+                             CORBA::Any::from_string);
 
 // These are not required by the spec, but will make users
 // of other ORBs that are used to them more comfortable.
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::Short&);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::UShort&);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::Long&);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::ULong&);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::LongLong&);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::ULongLong&);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::Float&);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::Double&);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA_Any&);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::TypeCode_ptr&);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              char*&);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::Any::to_boolean);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::Any::to_octet);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::Any::to_char);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::Any::to_wchar);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::Any::to_string);
-extern TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
-                                              CORBA::Any::to_object);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::Short&);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::UShort&);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::Long&);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::ULong&);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::LongLong&);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::ULongLong&);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::Float&);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::Double&);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA_Any&);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::TypeCode_ptr&);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       char*&);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::Any::to_boolean);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::Any::to_octet);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::Any::to_char);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::Any::to_wchar);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::Any::to_string);
+TAO_Export CORBA::Boolean operator>>= (CORBA_Any_var,
+                                       CORBA::Any::to_object);
 
 #endif /* __ACE_INLINE__ */
 
diff --git a/TAO/tao/CDR.h b/TAO/tao/CDR.h
index 67f26c6d4ac..689e7022454 100644
--- a/TAO/tao/CDR.h
+++ b/TAO/tao/CDR.h
@@ -251,15 +251,15 @@ private:
 };
 
 // This operators are too complex to be inline....
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR& cdr,
-                                             const CORBA::Any &x);
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR& cdr,
-                                             const CORBA::TypeCode *x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR& cdr,
+                                      const CORBA::Any &x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR& cdr,
+                                      const CORBA::TypeCode *x);
 
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR& cdr,
-                                             CORBA::Any &x);
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR& cdr,
-                                             CORBA::TypeCode *&x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR& cdr,
+                                      CORBA::Any &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR& cdr,
+                                      CORBA::TypeCode *&x);
 
 #if defined(__ACE_INLINE__)
 # include "tao/CDR.i"
@@ -267,53 +267,53 @@ extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR& cdr,
 
 // CDR output operators for CORBA types
 
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
-                                             CORBA::Short x);
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
-                                             CORBA::UShort x);
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
-                                             CORBA::Long x);
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
-                                             CORBA::ULong x);
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
-                                             CORBA::LongLong x);
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
-                                             CORBA::ULongLong x);
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR& os,
-                                             CORBA::LongDouble x);
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
-                                             CORBA::Float x);
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
-                                             CORBA::Double x);
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
-                                             const CORBA::Char* x);
-extern TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
-                                             const CORBA::WChar* x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
+                                      CORBA::Short x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
+                                      CORBA::UShort x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
+                                      CORBA::Long x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
+                                      CORBA::ULong x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
+                                      CORBA::LongLong x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
+                                      CORBA::ULongLong x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR& os,
+                                      CORBA::LongDouble x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
+                                      CORBA::Float x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
+                                      CORBA::Double x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
+                                      const CORBA::Char* x);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &os,
+                                      const CORBA::WChar* x);
 
 // CDR input operators for CORBA types
 
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
-                                             CORBA::Short &x);
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
-                                             CORBA::UShort &x);
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
-                                             CORBA::Long &x);
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
-                                             CORBA::ULong &x);
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
-                                             CORBA::LongLong &x);
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
-                                             CORBA::ULongLong &x);
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
-                                             CORBA::LongDouble &x);
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
-                                             CORBA::Float &x);
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
-                                             CORBA::Double &x);
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
-                                             CORBA::Char* &x);
-extern TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
-                                             CORBA::WChar* &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
+                                      CORBA::Short &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
+                                      CORBA::UShort &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
+                                      CORBA::Long &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
+                                      CORBA::ULong &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
+                                      CORBA::LongLong &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
+                                      CORBA::ULongLong &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
+                                      CORBA::LongDouble &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
+                                      CORBA::Float &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
+                                      CORBA::Double &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
+                                      CORBA::Char* &x);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &is,
+                                      CORBA::WChar* &x);
 
 #endif /* __ACE_INLINE */
 
diff --git a/TAO/tao/CONV_FRAMEC.h b/TAO/tao/CONV_FRAMEC.h
index bfed6da475c..0eb9c96c85f 100644
--- a/TAO/tao/CONV_FRAMEC.h
+++ b/TAO/tao/CONV_FRAMEC.h
@@ -329,33 +329,31 @@ TAO_NAMESPACE  CONV_FRAME
 }
 TAO_NAMESPACE_CLOSE // module CONV_FRAME
 
-void TAO_Export operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetComponent &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, CONV_FRAME::CodeSetComponent*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetComponent *&);
-void TAO_Export operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetComponentInfo &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, CONV_FRAME::CodeSetComponentInfo*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetComponentInfo *&);
-void TAO_Export operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetContext &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, CONV_FRAME::CodeSetContext*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetContext *&);
+TAO_Export void operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetComponent &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CONV_FRAME::CodeSetComponent*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetComponent *&);
+TAO_Export void operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetComponentInfo &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CONV_FRAME::CodeSetComponentInfo*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetComponentInfo *&);
+TAO_Export void operator<<= (CORBA::Any &, const CONV_FRAME::CodeSetContext &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CONV_FRAME::CodeSetContext*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CONV_FRAME::CodeSetContext *&);
 
 #ifndef __ACE_INLINE__
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const CONV_FRAME::CodeSetComponent &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, CONV_FRAME::CodeSetComponent &);
-CORBA::Boolean TAO_Export operator<< (
-    TAO_OutputCDR &,
-    const CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId &
-  );
-CORBA::Boolean TAO_Export operator>> (
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CONV_FRAME::CodeSetComponent &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CONV_FRAME::CodeSetComponent &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &,
+                                      const CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId &);
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
     CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId &
   );
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const CONV_FRAME::CodeSetComponentInfo &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, CONV_FRAME::CodeSetComponentInfo &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const CONV_FRAME::CodeSetContext &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, CONV_FRAME::CodeSetContext &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CONV_FRAME::CodeSetComponentInfo &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CONV_FRAME::CodeSetComponentInfo &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CONV_FRAME::CodeSetContext &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CONV_FRAME::CodeSetContext &);
 
 #endif /* __ACE_INLINE__ */
 
diff --git a/TAO/tao/DomainC.h b/TAO/tao/DomainC.h
index 7d981b5cd01..9d96865b014 100644
--- a/TAO/tao/DomainC.h
+++ b/TAO/tao/DomainC.h
@@ -284,16 +284,16 @@ private:
 };
 
 // Any operators for interface CORBA_ConstructionPolicy
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              CORBA_ConstructionPolicy_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &,
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
                                        CORBA_ConstructionPolicy *&);
 
 #ifndef __ACE_INLINE__
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &,
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &,
                                       const CORBA_ConstructionPolicy_ptr );
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &,
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &,
                                       CORBA_ConstructionPolicy_ptr &);
 
 #endif /* __ACE_INLINE__ */
@@ -304,28 +304,28 @@ CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &,
 
 
 // Any operators for interface CORBA_DomainManager
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              CORBA_DomainManager_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &,
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
                                        CORBA_DomainManager *&);
 
 // Any operators for interface CORBA_DomainManagerList
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              const CORBA_DomainManagerList &); // copying version
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              CORBA_DomainManagerList*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &,
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
                                        CORBA_DomainManagerList *&);
 
 #ifndef __ACE_INLINE__
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &,
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &,
                                       const CORBA_DomainManager_ptr );
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &,
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &,
                                       CORBA_DomainManager_ptr &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &,
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &,
                                       const CORBA_DomainManagerList &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &,
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &,
                                       CORBA_DomainManagerList &);
 #endif /* __ACE_INLINE__ */
 
diff --git a/TAO/tao/Exception.h b/TAO/tao/Exception.h
index 008b98e7cf3..1363580887c 100644
--- a/TAO/tao/Exception.h
+++ b/TAO/tao/Exception.h
@@ -111,9 +111,8 @@ private:
 #if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
 
 // Convenient ostream operator.
-extern TAO_Export
-ostream& operator<< (ostream &os,
-                     const CORBA_Exception &e);
+TAO_Export ostream& operator<< (ostream &os,
+                                const CORBA_Exception &e);
 
 #endif // (ACE_LACKS_IOSTREAM_TOTALLY)
 
diff --git a/TAO/tao/GIOP.h b/TAO/tao/GIOP.h
index a1c0340909f..cfaf8031a6e 100644
--- a/TAO/tao/GIOP.h
+++ b/TAO/tao/GIOP.h
@@ -299,16 +299,16 @@ typedef TAO_Unbounded_Sequence<TAO_GIOP_ServiceContext>
 
 extern CORBA::TypeCode_ptr TC_ServiceContextList;
 
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR&, const TAO_GIOP_ServiceContext&);
 
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR&, TAO_GIOP_ServiceContext&);
 
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR&, const TAO_GIOP_ServiceContextList&);
 
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR&, TAO_GIOP_ServiceContextList&);
 #endif /* 0 */
 
diff --git a/TAO/tao/IOPC.h b/TAO/tao/IOPC.h
index e4aef994194..a5512933cac 100644
--- a/TAO/tao/IOPC.h
+++ b/TAO/tao/IOPC.h
@@ -574,85 +574,85 @@ TAO_NAMESPACE  IOP
 }
 TAO_NAMESPACE_CLOSE // module IOP
 
-void TAO_Export operator<<= (CORBA::Any &, const IOP::TaggedProfile &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, IOP::TaggedProfile*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, IOP::TaggedProfile *&);
-void TAO_Export operator<<= (CORBA::Any &, const IOP::IOR &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, IOP::IOR*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, IOP::IOR *&);
-void TAO_Export operator<<= (CORBA::Any &, const IOP::TaggedComponent &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, IOP::TaggedComponent*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, IOP::TaggedComponent *&);
-void TAO_Export operator<<= (CORBA::Any &, const IOP::MultipleComponentProfile &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, IOP::MultipleComponentProfile*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, IOP::MultipleComponentProfile *&);
-void TAO_Export operator<<= (CORBA::Any &, const IOP::ServiceContext &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, IOP::ServiceContext*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, IOP::ServiceContext *&);
-void TAO_Export operator<<= (CORBA::Any &, const IOP::ServiceContextList &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, IOP::ServiceContextList*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, IOP::ServiceContextList *&);
+TAO_Export void operator<<= (CORBA::Any &, const IOP::TaggedProfile &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IOP::TaggedProfile*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::TaggedProfile *&);
+TAO_Export void operator<<= (CORBA::Any &, const IOP::IOR &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IOP::IOR*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::IOR *&);
+TAO_Export void operator<<= (CORBA::Any &, const IOP::TaggedComponent &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IOP::TaggedComponent*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::TaggedComponent *&);
+TAO_Export void operator<<= (CORBA::Any &, const IOP::MultipleComponentProfile &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IOP::MultipleComponentProfile*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::MultipleComponentProfile *&);
+TAO_Export void operator<<= (CORBA::Any &, const IOP::ServiceContext &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IOP::ServiceContext*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::ServiceContext *&);
+TAO_Export void operator<<= (CORBA::Any &, const IOP::ServiceContextList &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IOP::ServiceContextList*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IOP::ServiceContextList *&);
 
 #ifndef __ACE_INLINE__
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const IOP::TaggedProfile &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, IOP::TaggedProfile &);
-CORBA::Boolean TAO_Export operator<< (
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IOP::TaggedProfile &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IOP::TaggedProfile &);
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
     const IOP::TaggedProfile::_tao_seq_Octet &
   );
-CORBA::Boolean TAO_Export operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
     IOP::TaggedProfile::_tao_seq_Octet &
   );
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const IOP::IOR &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, IOP::IOR &);
-CORBA::Boolean TAO_Export operator<< (
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IOP::IOR &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IOP::IOR &);
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
     const IOP::IOR::_tao_seq_TaggedProfile &
   );
-CORBA::Boolean TAO_Export operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
     IOP::IOR::_tao_seq_TaggedProfile &
   );
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const IOP::TaggedComponent &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, IOP::TaggedComponent &);
-CORBA::Boolean TAO_Export operator<< (
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IOP::TaggedComponent &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IOP::TaggedComponent &);
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
     const IOP::TaggedComponent::_tao_seq_Octet &
   );
-CORBA::Boolean TAO_Export operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
     IOP::TaggedComponent::_tao_seq_Octet &
   );
 
-CORBA::Boolean TAO_Export operator<< (
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
     const IOP::MultipleComponentProfile &
   );
-CORBA::Boolean TAO_Export operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
     IOP::MultipleComponentProfile &
   );
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const IOP::ServiceContext &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, IOP::ServiceContext &);
-CORBA::Boolean TAO_Export operator<< (
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IOP::ServiceContext &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IOP::ServiceContext &);
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
     const IOP::ServiceContext::_tao_seq_Octet &
   );
-CORBA::Boolean TAO_Export operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
     IOP::ServiceContext::_tao_seq_Octet &
   );
 
-CORBA::Boolean TAO_Export operator<< (
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
     const IOP::ServiceContextList &
   );
-CORBA::Boolean TAO_Export operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
     IOP::ServiceContextList &
   );
diff --git a/TAO/tao/IORC.h b/TAO/tao/IORC.h
index 3e975c5ffec..8867ae07ca4 100644
--- a/TAO/tao/IORC.h
+++ b/TAO/tao/IORC.h
@@ -458,52 +458,52 @@ TAO_NAMESPACE  TAO_IOP
 TAO_NAMESPACE_CLOSE // module TAO_IOP
 
 // Any operators for interface TAO_IOP::TAO_IOR_Manipulation
-void TAO_Export operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation_ptr);
+TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation_ptr);
 CORBA::Boolean  operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation *&);
-void TAO_Export operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&);
-void TAO_Export operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::NotFound &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::NotFound*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::NotFound *&);
-void TAO_Export operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::Duplicate &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Duplicate*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Duplicate *&);
-void TAO_Export operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&);
-void TAO_Export operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::IORList &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::IORList*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::IORList *&);
+TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList *&);
+TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::NotFound &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::NotFound*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::NotFound *&);
+TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::Duplicate &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Duplicate*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Duplicate *&);
+TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR *&);
+TAO_Export void operator<<= (CORBA::Any &, const TAO_IOP::TAO_IOR_Manipulation::IORList &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::IORList*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO_IOP::TAO_IOR_Manipulation::IORList *&);
 
 #ifndef __ACE_INLINE__
 
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const TAO_IOP::TAO_IOR_Manipulation_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, TAO_IOP::TAO_IOR_Manipulation_ptr &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const TAO_IOP::TAO_IOR_Manipulation::NotFound &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, TAO_IOP::TAO_IOR_Manipulation::NotFound &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const TAO_IOP::TAO_IOR_Manipulation::Duplicate &); //
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, TAO_IOP::TAO_IOR_Manipulation::Duplicate &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &); //
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
     const TAO_IOP::TAO_IOR_Manipulation::IORList &
   );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
     TAO_IOP::TAO_IOR_Manipulation::IORList &
diff --git a/TAO/tao/InterceptorC.h b/TAO/tao/InterceptorC.h
index 0668d4dbb16..3bdf806c9fe 100644
--- a/TAO/tao/InterceptorC.h
+++ b/TAO/tao/InterceptorC.h
@@ -714,20 +714,20 @@ class TAO_Export ClientRequestInterceptor: public virtual Interceptor
 TAO_NAMESPACE_CLOSE // module PortableInterceptor
 
 // Any operators for interface PortableInterceptor::Cookie
-void TAO_Export operator<<= (CORBA::Any &, PortableInterceptor::Cookie_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableInterceptor::Cookie *&);
-void TAO_Export operator<<= (CORBA::Any &, const PortableInterceptor::Cookies &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableInterceptor::Cookies*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableInterceptor::Cookies *&);
+TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::Cookie_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::Cookie *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableInterceptor::Cookies &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::Cookies*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::Cookies *&);
 // Any operators for interface PortableInterceptor::Interceptor
-void TAO_Export operator<<= (CORBA::Any &, PortableInterceptor::Interceptor_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableInterceptor::Interceptor *&);
+TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::Interceptor_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::Interceptor *&);
 // Any operators for interface PortableInterceptor::ServerRequestInterceptor
-void TAO_Export operator<<= (CORBA::Any &, PortableInterceptor::ServerRequestInterceptor_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableInterceptor::ServerRequestInterceptor *&);
+TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::ServerRequestInterceptor_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::ServerRequestInterceptor *&);
 // Any operators for interface PortableInterceptor::ClientRequestInterceptor
-void TAO_Export operator<<= (CORBA::Any &, PortableInterceptor::ClientRequestInterceptor_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableInterceptor::ClientRequestInterceptor *&);
+TAO_Export void operator<<= (CORBA::Any &, PortableInterceptor::ClientRequestInterceptor_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableInterceptor::ClientRequestInterceptor *&);
 
 #endif /* TAO_HAS_INTERCEPTORS */
 
diff --git a/TAO/tao/InterfaceC.h b/TAO/tao/InterfaceC.h
index 6fb95074004..1f755760bc4 100644
--- a/TAO/tao/InterfaceC.h
+++ b/TAO/tao/InterfaceC.h
@@ -7981,555 +7981,555 @@ class TAO_Export CORBA_ValueBoxDef: public virtual CORBA_IDLType
 
 #endif /* end #if !defined */
 
-void  operator<<= (CORBA::Any &, CORBA::DefinitionKind);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::DefinitionKind &);
-extern CORBA::IRObject_ptr (*_TAO_collocation_CORBA_IRObject_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::DefinitionKind);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::DefinitionKind &);
+TAO_Export CORBA::IRObject_ptr (*_TAO_collocation_CORBA_IRObject_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::IRObject
-void  operator<<= (CORBA::Any &, CORBA::IRObject_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::IRObject *&);
-extern CORBA::Contained_ptr (*_TAO_collocation_CORBA_Contained_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::IRObject_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::IRObject *&);
+TAO_Export CORBA::Contained_ptr (*_TAO_collocation_CORBA_Contained_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::Contained
-void  operator<<= (CORBA::Any &, CORBA::Contained_ptr);
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::Contained_ptr);
 CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Contained *&);
-void  operator<<= (CORBA::Any &, const CORBA::Contained::Description &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::Contained::Description*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Contained::Description *&);
-void  operator<<= (CORBA::Any &, const CORBA::InterfaceDefSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::InterfaceDefSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::InterfaceDefSeq *&);
-void  operator<<= (CORBA::Any &, const CORBA::ValueDefSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ValueDefSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueDefSeq *&);
-void  operator<<= (CORBA::Any &, const CORBA::ContainedSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ContainedSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ContainedSeq *&);
-void  operator<<= (CORBA::Any &, const CORBA::StructMember &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::StructMember*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::StructMember *&);
-void  operator<<= (CORBA::Any &, const CORBA::StructMemberSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::StructMemberSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::StructMemberSeq *&);
-void  operator<<= (CORBA::Any &, const CORBA::Initializer &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::Initializer*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Initializer *&);
-void  operator<<= (CORBA::Any &, const CORBA::InitializerSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::InitializerSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::InitializerSeq *&);
-void  operator<<= (CORBA::Any &, const CORBA::UnionMember &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::UnionMember*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::UnionMember *&);
-void  operator<<= (CORBA::Any &, const CORBA::UnionMemberSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::UnionMemberSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::UnionMemberSeq *&);
-void  operator<<= (CORBA::Any &, const CORBA::EnumMemberSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::EnumMemberSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::EnumMemberSeq *&);
-extern CORBA::Container_ptr (*_TAO_collocation_CORBA_Container_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::Contained::Description &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::Contained::Description*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Contained::Description *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::InterfaceDefSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::InterfaceDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::InterfaceDefSeq *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ValueDefSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ValueDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueDefSeq *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ContainedSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ContainedSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ContainedSeq *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::StructMember &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::StructMember*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::StructMember *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::StructMemberSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::StructMemberSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::StructMemberSeq *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::Initializer &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::Initializer*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Initializer *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::InitializerSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::InitializerSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::InitializerSeq *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::UnionMember &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::UnionMember*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::UnionMember *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::UnionMemberSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::UnionMemberSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::UnionMemberSeq *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::EnumMemberSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::EnumMemberSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::EnumMemberSeq *&);
+TAO_Export CORBA::Container_ptr (*_TAO_collocation_CORBA_Container_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::Container
-void  operator<<= (CORBA::Any &, CORBA::Container_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Container *&);
-void  operator<<= (CORBA::Any &, const CORBA::Container::Description &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::Container::Description*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Container::Description *&);
-void  operator<<= (CORBA::Any &, const CORBA::Container::DescriptionSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::Container::DescriptionSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Container::DescriptionSeq *&);
-extern CORBA::IDLType_ptr (*_TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::Container_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Container *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::Container::Description &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::Container::Description*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Container::Description *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::Container::DescriptionSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::Container::DescriptionSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Container::DescriptionSeq *&);
+TAO_Export CORBA::IDLType_ptr (*_TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::IDLType
-void  operator<<= (CORBA::Any &, CORBA::IDLType_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::IDLType *&);
-void  operator<<= (CORBA::Any &, CORBA::PrimitiveKind);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::PrimitiveKind &);
-extern CORBA::Repository_ptr (*_TAO_collocation_CORBA_Repository_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::IDLType_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::IDLType *&);
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::PrimitiveKind);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::PrimitiveKind &);
+TAO_Export CORBA::Repository_ptr (*_TAO_collocation_CORBA_Repository_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::Repository
-void  operator<<= (CORBA::Any &, CORBA::Repository_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Repository *&);
-extern CORBA::ModuleDef_ptr (*_TAO_collocation_CORBA_ModuleDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::Repository_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::Repository *&);
+TAO_Export CORBA::ModuleDef_ptr (*_TAO_collocation_CORBA_ModuleDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::ModuleDef
-void  operator<<= (CORBA::Any &, CORBA::ModuleDef_ptr);
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ModuleDef_ptr);
 CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ModuleDef *&);
-void  operator<<= (CORBA::Any &, const CORBA::ModuleDescription &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ModuleDescription*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ModuleDescription *&);
-extern CORBA::ConstantDef_ptr (*_TAO_collocation_CORBA_ConstantDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ModuleDescription &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ModuleDescription*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ModuleDescription *&);
+TAO_Export CORBA::ConstantDef_ptr (*_TAO_collocation_CORBA_ConstantDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::ConstantDef
-void  operator<<= (CORBA::Any &, CORBA::ConstantDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ConstantDef *&);
-void  operator<<= (CORBA::Any &, const CORBA::ConstantDescription &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ConstantDescription*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ConstantDescription *&);
-extern CORBA::TypedefDef_ptr (*_TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ConstantDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ConstantDef *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ConstantDescription &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ConstantDescription*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ConstantDescription *&);
+TAO_Export CORBA::TypedefDef_ptr (*_TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::TypedefDef
-void  operator<<= (CORBA::Any &, CORBA::TypedefDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::TypedefDef *&);
-void  operator<<= (CORBA::Any &, const CORBA::TypeDescription &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::TypeDescription*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::TypeDescription *&);
-extern CORBA::StructDef_ptr (*_TAO_collocation_CORBA_StructDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::TypedefDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::TypedefDef *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::TypeDescription &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::TypeDescription*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::TypeDescription *&);
+TAO_Export CORBA::StructDef_ptr (*_TAO_collocation_CORBA_StructDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::StructDef
-void  operator<<= (CORBA::Any &, CORBA::StructDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::StructDef *&);
-extern CORBA::UnionDef_ptr (*_TAO_collocation_CORBA_UnionDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::StructDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::StructDef *&);
+TAO_Export CORBA::UnionDef_ptr (*_TAO_collocation_CORBA_UnionDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::UnionDef
-void  operator<<= (CORBA::Any &, CORBA::UnionDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::UnionDef *&);
-extern CORBA::EnumDef_ptr (*_TAO_collocation_CORBA_EnumDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::UnionDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::UnionDef *&);
+TAO_Export CORBA::EnumDef_ptr (*_TAO_collocation_CORBA_EnumDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::EnumDef
-void  operator<<= (CORBA::Any &, CORBA::EnumDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::EnumDef *&);
-extern CORBA::AliasDef_ptr (*_TAO_collocation_CORBA_AliasDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::EnumDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::EnumDef *&);
+TAO_Export CORBA::AliasDef_ptr (*_TAO_collocation_CORBA_AliasDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::AliasDef
-void  operator<<= (CORBA::Any &, CORBA::AliasDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::AliasDef *&);
-extern CORBA::PrimitiveDef_ptr (*_TAO_collocation_CORBA_PrimitiveDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::AliasDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::AliasDef *&);
+TAO_Export CORBA::PrimitiveDef_ptr (*_TAO_collocation_CORBA_PrimitiveDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::PrimitiveDef
-void  operator<<= (CORBA::Any &, CORBA::PrimitiveDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::PrimitiveDef *&);
-extern CORBA::StringDef_ptr (*_TAO_collocation_CORBA_StringDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::PrimitiveDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::PrimitiveDef *&);
+TAO_Export CORBA::StringDef_ptr (*_TAO_collocation_CORBA_StringDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::StringDef
-void  operator<<= (CORBA::Any &, CORBA::StringDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::StringDef *&);
-extern CORBA::WstringDef_ptr (*_TAO_collocation_CORBA_WstringDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::StringDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::StringDef *&);
+TAO_Export CORBA::WstringDef_ptr (*_TAO_collocation_CORBA_WstringDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::WstringDef
-void  operator<<= (CORBA::Any &, CORBA::WstringDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::WstringDef *&);
-extern CORBA::FixedDef_ptr (*_TAO_collocation_CORBA_FixedDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::WstringDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::WstringDef *&);
+TAO_Export CORBA::FixedDef_ptr (*_TAO_collocation_CORBA_FixedDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::FixedDef
-void  operator<<= (CORBA::Any &, CORBA::FixedDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::FixedDef *&);
-extern CORBA::SequenceDef_ptr (*_TAO_collocation_CORBA_SequenceDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::FixedDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::FixedDef *&);
+TAO_Export CORBA::SequenceDef_ptr (*_TAO_collocation_CORBA_SequenceDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::SequenceDef
-void  operator<<= (CORBA::Any &, CORBA::SequenceDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::SequenceDef *&);
-extern CORBA::ArrayDef_ptr (*_TAO_collocation_CORBA_ArrayDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::SequenceDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::SequenceDef *&);
+TAO_Export CORBA::ArrayDef_ptr (*_TAO_collocation_CORBA_ArrayDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::ArrayDef
-void  operator<<= (CORBA::Any &, CORBA::ArrayDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ArrayDef *&);
-extern CORBA::ExceptionDef_ptr (*_TAO_collocation_CORBA_ExceptionDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ArrayDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ArrayDef *&);
+TAO_Export CORBA::ExceptionDef_ptr (*_TAO_collocation_CORBA_ExceptionDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::ExceptionDef
-void  operator<<= (CORBA::Any &, CORBA::ExceptionDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ExceptionDef *&);
-void  operator<<= (CORBA::Any &, const CORBA::ExceptionDescription &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ExceptionDescription*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ExceptionDescription *&);
-void  operator<<= (CORBA::Any &, CORBA::AttributeMode);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::AttributeMode &);
-extern CORBA::AttributeDef_ptr (*_TAO_collocation_CORBA_AttributeDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ExceptionDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ExceptionDef *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ExceptionDescription &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ExceptionDescription*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ExceptionDescription *&);
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::AttributeMode);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::AttributeMode &);
+TAO_Export CORBA::AttributeDef_ptr (*_TAO_collocation_CORBA_AttributeDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::AttributeDef
-void  operator<<= (CORBA::Any &, CORBA::AttributeDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::AttributeDef *&);
-void  operator<<= (CORBA::Any &, const CORBA::AttributeDescription &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::AttributeDescription*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::AttributeDescription *&);
-void  operator<<= (CORBA::Any &, CORBA::OperationMode);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::OperationMode &);
-void  operator<<= (CORBA::Any &, CORBA::ParameterMode);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ParameterMode &);
-void  operator<<= (CORBA::Any &, const CORBA::ParameterDescription &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ParameterDescription*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ParameterDescription *&);
-void  operator<<= (CORBA::Any &, const CORBA::ParDescriptionSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ParDescriptionSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ParDescriptionSeq *&);
-void  operator<<= (CORBA::Any &, const CORBA::ContextIdSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ContextIdSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ContextIdSeq *&);
-void  operator<<= (CORBA::Any &, const CORBA::ExceptionDefSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ExceptionDefSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ExceptionDefSeq *&);
-void  operator<<= (CORBA::Any &, const CORBA::ExcDescriptionSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ExcDescriptionSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ExcDescriptionSeq *&);
-extern CORBA::OperationDef_ptr (*_TAO_collocation_CORBA_OperationDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::AttributeDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::AttributeDef *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::AttributeDescription &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::AttributeDescription*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::AttributeDescription *&);
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::OperationMode);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::OperationMode &);
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ParameterMode);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ParameterMode &);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ParameterDescription &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ParameterDescription*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ParameterDescription *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ParDescriptionSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ParDescriptionSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ParDescriptionSeq *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ContextIdSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ContextIdSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ContextIdSeq *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ExceptionDefSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ExceptionDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ExceptionDefSeq *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ExcDescriptionSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ExcDescriptionSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ExcDescriptionSeq *&);
+TAO_Export CORBA::OperationDef_ptr (*_TAO_collocation_CORBA_OperationDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::OperationDef
-void  operator<<= (CORBA::Any &, CORBA::OperationDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::OperationDef *&);
-void  operator<<= (CORBA::Any &, const CORBA::OperationDescription &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::OperationDescription*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::OperationDescription *&);
-void  operator<<= (CORBA::Any &, const CORBA::RepositoryIdSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::RepositoryIdSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::RepositoryIdSeq *&);
-void  operator<<= (CORBA::Any &, const CORBA::OpDescriptionSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::OpDescriptionSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::OpDescriptionSeq *&);
-void  operator<<= (CORBA::Any &, const CORBA::AttrDescriptionSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::AttrDescriptionSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::AttrDescriptionSeq *&);
-extern CORBA::InterfaceDef_ptr (*_TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::OperationDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::OperationDef *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::OperationDescription &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::OperationDescription*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::OperationDescription *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::RepositoryIdSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::RepositoryIdSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::RepositoryIdSeq *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::OpDescriptionSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::OpDescriptionSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::OpDescriptionSeq *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::AttrDescriptionSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::AttrDescriptionSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::AttrDescriptionSeq *&);
+TAO_Export CORBA::InterfaceDef_ptr (*_TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::InterfaceDef
-void  operator<<= (CORBA::Any &, CORBA::InterfaceDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::InterfaceDef *&);
-void  operator<<= (CORBA::Any &, const CORBA::InterfaceDef::FullInterfaceDescription &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::InterfaceDef::FullInterfaceDescription*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::InterfaceDef::FullInterfaceDescription *&);
-void  operator<<= (CORBA::Any &, const CORBA::InterfaceDescription &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::InterfaceDescription*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::InterfaceDescription *&);
-void  operator<<= (CORBA::Any &, const CORBA::ValueMember &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ValueMember*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueMember *&);
-void  operator<<= (CORBA::Any &, const CORBA::ValueMemberSeq &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ValueMemberSeq*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueMemberSeq *&);
-extern CORBA::ValueMemberDef_ptr (*_TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::InterfaceDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::InterfaceDef *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::InterfaceDef::FullInterfaceDescription &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::InterfaceDef::FullInterfaceDescription*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::InterfaceDef::FullInterfaceDescription *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::InterfaceDescription &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::InterfaceDescription*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::InterfaceDescription *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ValueMember &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ValueMember*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueMember *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ValueMemberSeq &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ValueMemberSeq*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueMemberSeq *&);
+TAO_Export CORBA::ValueMemberDef_ptr (*_TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::ValueMemberDef
-void  operator<<= (CORBA::Any &, CORBA::ValueMemberDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueMemberDef *&);
-extern CORBA::ValueDef_ptr (*_TAO_collocation_CORBA_ValueDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ValueMemberDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueMemberDef *&);
+TAO_Export CORBA::ValueDef_ptr (*_TAO_collocation_CORBA_ValueDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::ValueDef
-void  operator<<= (CORBA::Any &, CORBA::ValueDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueDef *&);
-void  operator<<= (CORBA::Any &, const CORBA::ValueDef::FullValueDescription &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ValueDef::FullValueDescription*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueDef::FullValueDescription *&);
-void  operator<<= (CORBA::Any &, const CORBA::ValueDescription &); // copying version
-void  operator<<= (CORBA::Any &, CORBA::ValueDescription*); // noncopying version
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueDescription *&);
-extern CORBA::ValueBoxDef_ptr (*_TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer) (
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ValueDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueDef *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ValueDef::FullValueDescription &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ValueDef::FullValueDescription*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueDef::FullValueDescription *&);
+TAO_Export void  operator<<= (CORBA::Any &, const CORBA::ValueDescription &); // copying version
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ValueDescription*); // noncopying version
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueDescription *&);
+TAO_Export CORBA::ValueBoxDef_ptr (*_TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 // Any operators for interface CORBA::ValueBoxDef
-void  operator<<= (CORBA::Any &, CORBA::ValueBoxDef_ptr);
-CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueBoxDef *&);
+TAO_Export void  operator<<= (CORBA::Any &, CORBA::ValueBoxDef_ptr);
+TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::ValueBoxDef *&);
 
 #ifndef __ACE_INLINE__
 
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::DefinitionKind &); //
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::DefinitionKind &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::DefinitionKind &); //
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::DefinitionKind &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::IRObject_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::IRObject_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::Contained_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::Contained_ptr &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::Contained::Description &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::Contained::Description &);
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::Contained::Description &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::Contained::Description &);
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::InterfaceDefSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::InterfaceDefSeq &
   );
 
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::ValueDefSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::ValueDefSeq &
   );
 
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::ContainedSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::ContainedSeq &
   );
 
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::StructMember &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::StructMember &);
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::StructMember &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::StructMember &);
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::StructMemberSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::StructMemberSeq &
   );
 
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::Initializer &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::Initializer &);
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::Initializer &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::Initializer &);
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::InitializerSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::InitializerSeq &
   );
 
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::UnionMember &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::UnionMember &);
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::UnionMember &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::UnionMember &);
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::UnionMemberSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::UnionMemberSeq &
   );
 
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::EnumMemberSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::EnumMemberSeq &
   );
 
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::Container_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::Container_ptr &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::Container::Description &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::Container::Description &);
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::Container::Description &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::Container::Description &);
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::Container::DescriptionSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::Container::DescriptionSeq &
   );
 
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::IDLType_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::IDLType_ptr &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::PrimitiveKind &); //
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::PrimitiveKind &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::PrimitiveKind &); //
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::PrimitiveKind &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::Repository_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::Repository_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::ModuleDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::ModuleDef_ptr &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ModuleDescription &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ModuleDescription &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ModuleDescription &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ModuleDescription &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::ConstantDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::ConstantDef_ptr &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ConstantDescription &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ConstantDescription &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ConstantDescription &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ConstantDescription &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::TypedefDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::TypedefDef_ptr &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::TypeDescription &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::TypeDescription &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::TypeDescription &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::TypeDescription &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::StructDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::StructDef_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::UnionDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::UnionDef_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::EnumDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::EnumDef_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::AliasDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::AliasDef_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::PrimitiveDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::PrimitiveDef_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::StringDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::StringDef_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::WstringDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::WstringDef_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::FixedDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::FixedDef_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::SequenceDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::SequenceDef_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::ArrayDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::ArrayDef_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::ExceptionDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::ExceptionDef_ptr &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ExceptionDescription &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ExceptionDescription &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::AttributeMode &); //
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::AttributeMode &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ExceptionDescription &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ExceptionDescription &);
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::AttributeMode &); //
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::AttributeMode &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::AttributeDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::AttributeDef_ptr &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::AttributeDescription &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::AttributeDescription &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::OperationMode &); //
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::OperationMode &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ParameterMode &); //
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ParameterMode &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ParameterDescription &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ParameterDescription &);
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::AttributeDescription &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::AttributeDescription &);
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::OperationMode &); //
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::OperationMode &);
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ParameterMode &); //
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ParameterMode &);
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ParameterDescription &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ParameterDescription &);
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::ParDescriptionSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::ParDescriptionSeq &
   );
 
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::ContextIdSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::ContextIdSeq &
   );
 
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::ExceptionDefSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::ExceptionDefSeq &
   );
 
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::ExcDescriptionSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::ExcDescriptionSeq &
   );
 
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::OperationDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::OperationDef_ptr &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::OperationDescription &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::OperationDescription &);
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::OperationDescription &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::OperationDescription &);
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::RepositoryIdSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::RepositoryIdSeq &
   );
 
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::OpDescriptionSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::OpDescriptionSeq &
   );
 
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::AttrDescriptionSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::AttrDescriptionSeq &
   );
 
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::InterfaceDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::InterfaceDef_ptr &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::InterfaceDef::FullInterfaceDescription &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::InterfaceDef::FullInterfaceDescription &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::InterfaceDescription &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::InterfaceDescription &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ValueMember &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ValueMember &);
-CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::InterfaceDef::FullInterfaceDescription &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::InterfaceDef::FullInterfaceDescription &);
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::InterfaceDescription &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::InterfaceDescription &);
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ValueMember &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ValueMember &);
+TAO_Export CORBA::Boolean  operator<< (
     TAO_OutputCDR &,
     const CORBA::ValueMemberSeq &
   );
-CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean  operator>> (
     TAO_InputCDR &,
     CORBA::ValueMemberSeq &
   );
 
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::ValueMemberDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::ValueMemberDef_ptr &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::ValueDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::ValueDef_ptr &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ValueDef::FullValueDescription &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ValueDef::FullValueDescription &);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ValueDescription &);
-CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ValueDescription &);
-CORBA::Boolean
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ValueDef::FullValueDescription &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ValueDef::FullValueDescription &);
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ValueDescription &);
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ValueDescription &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::ValueBoxDef_ptr );
-CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::ValueBoxDef_ptr &);
 
 #endif /* __ACE_INLINE__ */
diff --git a/TAO/tao/MessagingC.h b/TAO/tao/MessagingC.h
index 5b0167d3df9..97eecab3ce9 100644
--- a/TAO/tao/MessagingC.h
+++ b/TAO/tao/MessagingC.h
@@ -2097,62 +2097,62 @@ typedef void (*TAO_Reply_Handler_Skeleton)(
     );
 #endif /* TAO_HAS_AMI_CALLBACK */
 
-void TAO_Export operator<<= (CORBA::Any &, Messaging::PriorityRange*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, Messaging::PriorityRange *&);
+TAO_Export void operator<<= (CORBA::Any &, Messaging::PriorityRange*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::PriorityRange *&);
 
-void TAO_Export operator<<= (CORBA::Any &, const Messaging::RoutingTypeRange &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, Messaging::RoutingTypeRange*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, Messaging::RoutingTypeRange *&);
+TAO_Export void operator<<= (CORBA::Any &, const Messaging::RoutingTypeRange &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, Messaging::RoutingTypeRange*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::RoutingTypeRange *&);
 
-void TAO_Export operator<<= (CORBA::Any &, const Messaging::PolicyValue &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, Messaging::PolicyValue*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, Messaging::PolicyValue *&);
-void TAO_Export operator<<= (CORBA::Any &, const Messaging::PolicyValueSeq &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, Messaging::PolicyValueSeq*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, Messaging::PolicyValueSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const Messaging::PolicyValue &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, Messaging::PolicyValue*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::PolicyValue *&);
+TAO_Export void operator<<= (CORBA::Any &, const Messaging::PolicyValueSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, Messaging::PolicyValueSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::PolicyValueSeq *&);
 
 #if defined (TAO_HAS_AMI_CALLBACK)
-extern  Messaging::ReplyHandler_ptr (*_TAO_collocation_Messaging_ReplyHandler_Stub_Factory_function_pointer) (
+TAO_Export  Messaging::ReplyHandler_ptr (*_TAO_collocation_Messaging_ReplyHandler_Stub_Factory_function_pointer) (
                                      CORBA::Object_ptr obj);
 
 // Any operators for interface Messaging::ReplyHandler
-void TAO_Export operator<<= (CORBA::Any &, Messaging::ReplyHandler_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, Messaging::ReplyHandler *&);
-CORBA::Boolean  operator<< (TAO_OutputCDR &, const Messaging::ExceptionHolder *); //
-CORBA::Boolean  operator>> (TAO_InputCDR &, Messaging::ExceptionHolder *&);
+TAO_Export void operator<<= (CORBA::Any &, Messaging::ReplyHandler_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::ReplyHandler *&);
+TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const Messaging::ExceptionHolder *); //
+TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, Messaging::ExceptionHolder *&);
 #endif /* TAO_HAS_AMI_CALLBACK */
 
 #if defined (TAO_HAS_AMI_POLLER)
 // Any operators for interface Messaging::Poller
-void TAO_Export operator<<= (CORBA::Any &, Messaging::Poller_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, Messaging::Poller *&);
+TAO_Export void operator<<= (CORBA::Any &, Messaging::Poller_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::Poller *&);
 #endif /* TAO_HAS_AMI_POLLER */
 
 #ifndef __ACE_INLINE__
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const Messaging::PriorityRange &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, Messaging::PriorityRange &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const Messaging::RoutingTypeRange &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, Messaging::RoutingTypeRange &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const Messaging::PolicyValue &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, Messaging::PolicyValue &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const Messaging::PolicyValue::_tao_seq_Octet &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, Messaging::PolicyValue::_tao_seq_Octet &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const Messaging::PolicyValueSeq &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, Messaging::PolicyValueSeq &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::PriorityRange &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::PriorityRange &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::RoutingTypeRange &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::RoutingTypeRange &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::PolicyValue &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::PolicyValue &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::PolicyValue::_tao_seq_Octet &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::PolicyValue::_tao_seq_Octet &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::PolicyValueSeq &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::PolicyValueSeq &);
 
 #if defined (TAO_HAS_AMI_CALLBACK)
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const Messaging::ReplyHandler_ptr );
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, Messaging::ReplyHandler_ptr &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const Messaging::ExceptionHolder &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, Messaging::ExceptionHolder &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const Messaging::ExceptionHolder::_tao_seq_Octet &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, Messaging::ExceptionHolder::_tao_seq_Octet &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ReplyHandler_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ReplyHandler_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ExceptionHolder &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ExceptionHolder &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ExceptionHolder::_tao_seq_Octet &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ExceptionHolder::_tao_seq_Octet &);
 #endif /* TAO_HAS_AMI_CALLBACK */
 
 #if defined (TAO_HAS_AMI_POLLER)
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const Messaging::Poller_ptr );
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, Messaging::Poller_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::Poller_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::Poller_ptr &);
 #endif
 
 #endif /* __ACE_INLINE__ */
diff --git a/TAO/tao/ORB.h b/TAO/tao/ORB.h
index a0e9c09eda9..c2646226f72 100644
--- a/TAO/tao/ORB.h
+++ b/TAO/tao/ORB.h
@@ -747,7 +747,7 @@ private:
                                     ACE_Time_Value *timeout,
                                     CORBA::Environment& ACE_TRY_ENV);
   // Resolve the given service based on the service ID.
-  
+
   int multicast_query (char* &buf,
                        const char *service_name,
                        u_short port,
@@ -862,34 +862,34 @@ private:
   CORBA::ORB_ptr &ptr_;
 };
 
-extern TAO_Export void
+TAO_Export void
 operator<<= (CORBA::Any &, const CORBA::ORB::InvalidName &);
-extern TAO_Export void
+TAO_Export void
 operator<<= (CORBA::Any &, CORBA::ORB::InvalidName*);
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>>= (const CORBA::Any &, CORBA::ORB::InvalidName *&);
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::ORB::InvalidName &);
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::ORB::InvalidName &);
 
 # if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
 
-extern TAO_Export ostream &
+TAO_Export ostream &
 operator<< (ostream &, const CORBA::String_var &);
-extern TAO_Export istream &
+TAO_Export istream &
 operator>> (istream &, CORBA::String_var &);
-extern TAO_Export ostream &
+TAO_Export ostream &
 operator<< (ostream &, CORBA::String_out &);
-extern TAO_Export istream &
+TAO_Export istream &
 operator>> (istream &, CORBA::String_out &);
-extern TAO_Export ostream &
+TAO_Export ostream &
 operator<< (ostream &, const CORBA::WString_var &);
-extern TAO_Export istream &
+TAO_Export istream &
 operator>> (istream &, CORBA::WString_var &);
-extern TAO_Export ostream &
+TAO_Export ostream &
 operator<< (ostream &, CORBA::WString_out &);
-extern TAO_Export istream &
+TAO_Export istream &
 operator>> (istream &, CORBA::WString_out &);
 
 # endif /* ACE_LACKS_IOSTREAM_TOTALLY */
diff --git a/TAO/tao/ORB_Core.h b/TAO/tao/ORB_Core.h
index 2df65cf237c..13001460d4a 100644
--- a/TAO/tao/ORB_Core.h
+++ b/TAO/tao/ORB_Core.h
@@ -733,7 +733,7 @@ private:
 
 // ****************************************************************
 
-extern TAO_Export TAO_ORB_Core *TAO_ORB_Core_instance (void);
+TAO_Export TAO_ORB_Core *TAO_ORB_Core_instance (void);
 
 #if defined (__ACE_INLINE__)
 # include "tao/ORB_Core.i"
diff --git a/TAO/tao/Object.h b/TAO/tao/Object.h
index c4cf48a3299..2eb119c84b0 100644
--- a/TAO/tao/Object.h
+++ b/TAO/tao/Object.h
@@ -308,10 +308,10 @@ public:
   virtual void _release (void) = 0;
 };
 
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR&, const CORBA_Object*);
 
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR&, CORBA_Object*&);
 
 #if defined (__ACE_INLINE__)
diff --git a/TAO/tao/ObjectIDList.h b/TAO/tao/ObjectIDList.h
index 2f28681036f..514fdcba836 100644
--- a/TAO/tao/ObjectIDList.h
+++ b/TAO/tao/ObjectIDList.h
@@ -128,8 +128,8 @@ private:
 
 #ifndef __ACE_INLINE__
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const CORBA_ORB_ObjectIdList &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, CORBA_ORB_ObjectIdList &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_ORB_ObjectIdList &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_ORB_ObjectIdList &);
 
 #endif /* __ACE_INLINE__ */
 
diff --git a/TAO/tao/POAC.h b/TAO/tao/POAC.h
index 9f2daca4fa0..7e95c76b591 100644
--- a/TAO/tao/POAC.h
+++ b/TAO/tao/POAC.h
@@ -2284,10 +2284,10 @@ TAO_NAMESPACE PortableServer{
 
   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Current;
 
-  TAO_NAMESPACE_STORAGE_CLASS char *ObjectId_to_string (const PortableServer::ObjectId &id);
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::WChar *ObjectId_to_wstring (const PortableServer::ObjectId &id);
-  TAO_NAMESPACE_STORAGE_CLASS PortableServer::ObjectId *string_to_ObjectId (const char *id);
-  TAO_NAMESPACE_STORAGE_CLASS PortableServer::ObjectId *wstring_to_ObjectId (const CORBA::WChar *id);
+  TAO_Export char *ObjectId_to_string (const PortableServer::ObjectId &id);
+  TAO_Export CORBA::WChar *ObjectId_to_wstring (const PortableServer::ObjectId &id);
+  TAO_Export PortableServer::ObjectId *string_to_ObjectId (const char *id);
+  TAO_Export PortableServer::ObjectId *wstring_to_ObjectId (const CORBA::WChar *id);
 
 }
 TAO_NAMESPACE_CLOSE
@@ -2300,111 +2300,111 @@ TAO_NAMESPACE_CLOSE
 
 #if !defined (TAO_HAS_MINIMUM_CORBA)
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicyValue &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, PortableServer::ThreadPolicyValue &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicyValue &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ThreadPolicyValue &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const PortableServer::ThreadPolicy_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, PortableServer::ThreadPolicy_ptr &);
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicyValue &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, PortableServer::LifespanPolicyValue &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicyValue &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::LifespanPolicyValue &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const PortableServer::LifespanPolicy_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, PortableServer::LifespanPolicy_ptr &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicyValue &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, PortableServer::IdUniquenessPolicyValue &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicyValue &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdUniquenessPolicyValue &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const PortableServer::IdUniquenessPolicy_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, PortableServer::IdUniquenessPolicy_ptr &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicyValue &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, PortableServer::IdAssignmentPolicyValue &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicyValue &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::IdAssignmentPolicyValue &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const PortableServer::IdAssignmentPolicy_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, PortableServer::IdAssignmentPolicy_ptr &);
 
 #if !defined (TAO_HAS_MINIMUM_CORBA)
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicyValue &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, PortableServer::ImplicitActivationPolicyValue &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicyValue &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ImplicitActivationPolicyValue &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const PortableServer::ImplicitActivationPolicy_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, PortableServer::ImplicitActivationPolicy_ptr &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicyValue &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, PortableServer::ServantRetentionPolicyValue &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicyValue &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::ServantRetentionPolicyValue &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const PortableServer::ServantRetentionPolicy_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, PortableServer::ServantRetentionPolicy_ptr &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicyValue &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, PortableServer::RequestProcessingPolicyValue &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicyValue &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::RequestProcessingPolicyValue &);
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const PortableServer::RequestProcessingPolicy_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, PortableServer::RequestProcessingPolicy_ptr &);
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
 // POA's exceptions.
-void TAO_Export operator<<= (CORBA::Any &, const PortableServer::POA::AdapterAlreadyExists &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableServer::POA::AdapterAlreadyExists*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableServer::POA::AdapterAlreadyExists *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::AdapterAlreadyExists &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::AdapterAlreadyExists*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::AdapterAlreadyExists *&);
 
 #if !defined (TAO_HAS_MINIMUM_CORBA)
 
-void TAO_Export operator<<= (CORBA::Any &, const PortableServer::POA::AdapterInactive &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableServer::POA::AdapterInactive*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableServer::POA::AdapterInactive *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::AdapterInactive &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::AdapterInactive*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::AdapterInactive *&);
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
-void TAO_Export operator<<= (CORBA::Any &, const PortableServer::POA::AdapterNonExistent &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableServer::POA::AdapterNonExistent*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableServer::POA::AdapterNonExistent *&);
-void TAO_Export operator<<= (CORBA::Any &, const PortableServer::POA::InvalidPolicy &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableServer::POA::InvalidPolicy*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableServer::POA::InvalidPolicy *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::AdapterNonExistent &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::AdapterNonExistent*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::AdapterNonExistent *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::InvalidPolicy &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::InvalidPolicy*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::InvalidPolicy *&);
 
 #if !defined (TAO_HAS_MINIMUM_CORBA)
 
-void TAO_Export operator<<= (CORBA::Any &, const PortableServer::POA::NoServant &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableServer::POA::NoServant*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableServer::POA::NoServant *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::NoServant &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::NoServant*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::NoServant *&);
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
-void TAO_Export operator<<= (CORBA::Any &, const PortableServer::POA::ObjectAlreadyActive &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableServer::POA::ObjectAlreadyActive*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableServer::POA::ObjectAlreadyActive *&);
-void TAO_Export operator<<= (CORBA::Any &, const PortableServer::POA::ObjectNotActive &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableServer::POA::ObjectNotActive*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableServer::POA::ObjectNotActive *&);
-void TAO_Export operator<<= (CORBA::Any &, const PortableServer::POA::ServantAlreadyActive &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableServer::POA::ServantAlreadyActive*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableServer::POA::ServantAlreadyActive *&);
-void TAO_Export operator<<= (CORBA::Any &, const PortableServer::POA::ServantNotActive &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableServer::POA::ServantNotActive*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableServer::POA::ServantNotActive *&);
-void TAO_Export operator<<= (CORBA::Any &, const PortableServer::POA::WrongAdapter &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableServer::POA::WrongAdapter*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableServer::POA::WrongAdapter *&);
-void TAO_Export operator<<= (CORBA::Any &, const PortableServer::POA::WrongPolicy &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, PortableServer::POA::WrongPolicy*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, PortableServer::POA::WrongPolicy *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ObjectAlreadyActive &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ObjectAlreadyActive*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ObjectAlreadyActive *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ObjectNotActive &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ObjectNotActive*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ObjectNotActive *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ServantAlreadyActive &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ServantAlreadyActive*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ServantAlreadyActive *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::ServantNotActive &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::ServantNotActive*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::ServantNotActive *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::WrongAdapter &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::WrongAdapter*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::WrongAdapter *&);
+TAO_Export void operator<<= (CORBA::Any &, const PortableServer::POA::WrongPolicy &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, PortableServer::POA::WrongPolicy*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, PortableServer::POA::WrongPolicy *&);
 
 // POA::Current && its exception.
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const PortableServer::Current_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, PortableServer::Current_ptr &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const PortableServer::Current::NoContext &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, PortableServer::Current::NoContext &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const PortableServer::Current::NoContext &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, PortableServer::Current::NoContext &);
 #endif /* defined INLINE */
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
diff --git a/TAO/tao/PolicyC.h b/TAO/tao/PolicyC.h
index 7defcb1231a..f8a322082d8 100644
--- a/TAO/tao/PolicyC.h
+++ b/TAO/tao/PolicyC.h
@@ -510,38 +510,38 @@ private:
 
 // ****************************************************************
 
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              const CORBA::PolicyError &);
-void TAO_Export operator<<= (CORBA::Any &, CORBA::PolicyError*);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyError*);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
                                        CORBA::PolicyError *&);
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              const CORBA::InvalidPolicies &);
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              CORBA::InvalidPolicies*);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &,
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
                                        CORBA::InvalidPolicies *&);
 
 // Any operators for interface CORBA::Policy
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              CORBA::Policy_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &,
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
                                        CORBA::Policy *&);
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              const CORBA::PolicyList &);
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              CORBA::PolicyList*);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &,
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
                                        CORBA::PolicyList *&);
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              const CORBA::PolicyTypeSeq &);
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              CORBA::PolicyTypeSeq*);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &,
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
                                        CORBA::PolicyTypeSeq *&);
-void TAO_Export operator<<= (CORBA::Any &,
+TAO_Export void operator<<= (CORBA::Any &,
                              CORBA::SetOverrideType);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &,
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
                                        CORBA::SetOverrideType &);
 
 // ****************************************************************
@@ -550,33 +550,33 @@ CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &,
 #include "tao/PolicyC.i"
 #else
 
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::PolicyError &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::PolicyError &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::InvalidPolicies &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::InvalidPolicies &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::InvalidPolicies::_tao_seq_UShort &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::InvalidPolicies::_tao_seq_UShort &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::Policy_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::Policy_ptr &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::PolicyList &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::PolicyList &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::PolicyTypeSeq &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::PolicyTypeSeq &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::SetOverrideType &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::SetOverrideType &);
 
 #endif /* defined INLINE */
diff --git a/TAO/tao/PollableC.h b/TAO/tao/PollableC.h
index 79f339246ab..56c273f8cd1 100644
--- a/TAO/tao/PollableC.h
+++ b/TAO/tao/PollableC.h
@@ -395,39 +395,39 @@ private:
 };
 
 // Any operators for interface CORBA_Pollable
-void TAO_Export operator<<= (CORBA::Any &, CORBA_Pollable_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, CORBA_Pollable *&);
+TAO_Export void operator<<= (CORBA::Any &, CORBA_Pollable_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_Pollable *&);
 // Any operators for interface CORBA::DIIPollable
-void TAO_Export operator<<= (CORBA::Any &, CORBA::DIIPollable_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, CORBA::DIIPollable *&);
+TAO_Export void operator<<= (CORBA::Any &, CORBA::DIIPollable_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::DIIPollable *&);
 // Any operators for interface CORBA_PollableSet
-void TAO_Export operator<<= (CORBA::Any &, CORBA_PollableSet_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, CORBA_PollableSet *&);
-void TAO_Export operator<<= (CORBA::Any &, const CORBA_PollableSet::NoPossiblePollable &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, CORBA_PollableSet::NoPossiblePollable*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, CORBA_PollableSet::NoPossiblePollable *&);
-void TAO_Export operator<<= (CORBA::Any &, const CORBA_PollableSet::UnknownPollable &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, CORBA_PollableSet::UnknownPollable*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, CORBA_PollableSet::UnknownPollable *&);
+TAO_Export void operator<<= (CORBA::Any &, CORBA_PollableSet_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PollableSet *&);
+TAO_Export void operator<<= (CORBA::Any &, const CORBA_PollableSet::NoPossiblePollable &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CORBA_PollableSet::NoPossiblePollable*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PollableSet::NoPossiblePollable *&);
+TAO_Export void operator<<= (CORBA::Any &, const CORBA_PollableSet::UnknownPollable &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CORBA_PollableSet::UnknownPollable*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PollableSet::UnknownPollable *&);
 
 #ifndef __ACE_INLINE__
 
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA_Pollable_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA_Pollable_ptr &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA::DIIPollable_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA::DIIPollable_ptr &);
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR &, const CORBA_PollableSet_ptr );
-CORBA::Boolean TAO_Export
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR &, CORBA_PollableSet_ptr &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const CORBA_PollableSet::NoPossiblePollable &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, CORBA_PollableSet::NoPossiblePollable &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const CORBA_PollableSet::UnknownPollable &); //
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, CORBA_PollableSet::UnknownPollable &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_PollableSet::NoPossiblePollable &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_PollableSet::NoPossiblePollable &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_PollableSet::UnknownPollable &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_PollableSet::UnknownPollable &);
 
 #endif /* __ACE_INLINE__ */
 
diff --git a/TAO/tao/Principal.h b/TAO/tao/Principal.h
index af0cfb5c066..a861fa4fbb3 100644
--- a/TAO/tao/Principal.h
+++ b/TAO/tao/Principal.h
@@ -147,10 +147,10 @@ private:
   CORBA_Principal_ptr &ptr_;
 };
 
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR&, CORBA_Principal*);
 
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR&, CORBA_Principal*&);
 
 #if defined (__ACE_INLINE__)
diff --git a/TAO/tao/Sequence.h b/TAO/tao/Sequence.h
index c5ab9fdf50b..33edc95bd0e 100644
--- a/TAO/tao/Sequence.h
+++ b/TAO/tao/Sequence.h
@@ -562,11 +562,11 @@ private:
 // ****************************************************************
 
 // Comparison of octet sequence.
-extern TAO_Export int operator== (const TAO_Unbounded_Sequence<CORBA::Octet> &l,
-                                  const TAO_Unbounded_Sequence<CORBA::Octet> &r);
+TAO_Export int operator== (const TAO_Unbounded_Sequence<CORBA::Octet> &l,
+                           const TAO_Unbounded_Sequence<CORBA::Octet> &r);
 
-extern TAO_Export int operator!= (const TAO_Unbounded_Sequence<CORBA::Octet> &l,
-                                  const TAO_Unbounded_Sequence<CORBA::Octet> &r);
+TAO_Export int operator!= (const TAO_Unbounded_Sequence<CORBA::Octet> &l,
+                           const TAO_Unbounded_Sequence<CORBA::Octet> &r);
 
 // ****************************************************************
 
diff --git a/TAO/tao/TAOC.h b/TAO/tao/TAOC.h
index 655738d2543..8684609d3e5 100644
--- a/TAO/tao/TAOC.h
+++ b/TAO/tao/TAOC.h
@@ -417,15 +417,15 @@ TAO_NAMESPACE_CLOSE // module TAO
 
 #if defined (TAO_HAS_CORBA_MESSAGING)
 
-void TAO_Export operator<<= (CORBA::Any &, const TAO::PrioritySpecification &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, TAO::PrioritySpecification*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, TAO::PrioritySpecification *&);
+TAO_Export void operator<<= (CORBA::Any &, const TAO::PrioritySpecification &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, TAO::PrioritySpecification*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO::PrioritySpecification *&);
 // Any operators for interface TAO::ClientPriorityPolicy
-void TAO_Export operator<<= (CORBA::Any &, TAO::ClientPriorityPolicy_ptr);
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, TAO::ClientPriorityPolicy *&);
-void TAO_Export operator<<= (CORBA::Any &, const TAO::BufferingConstraint &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, TAO::BufferingConstraint*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, TAO::BufferingConstraint *&);
+TAO_Export void operator<<= (CORBA::Any &, TAO::ClientPriorityPolicy_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO::ClientPriorityPolicy *&);
+TAO_Export void operator<<= (CORBA::Any &, const TAO::BufferingConstraint &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, TAO::BufferingConstraint*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TAO::BufferingConstraint *&);
 // Any operators for interface TAO::BufferingConstraintPolicy
 void  operator<<= (CORBA::Any &, TAO::BufferingConstraintPolicy_ptr);
 CORBA::Boolean  operator>>= (const CORBA::Any &, TAO::BufferingConstraintPolicy *&);
@@ -436,10 +436,10 @@ CORBA::Boolean  operator>>= (const CORBA::Any &, TAO::BufferingConstraintPolicy
 
 #if defined (TAO_HAS_CORBA_MESSAGING)
 
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const TAO::PrioritySpecification &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, TAO::PrioritySpecification &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const TAO::BufferingConstraint &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, TAO::BufferingConstraint &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const TAO::PrioritySpecification &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, TAO::PrioritySpecification &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const TAO::BufferingConstraint &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, TAO::BufferingConstraint &);
 
 #endif /* TAO_HAS_CORBA_MESSAGING */
 
diff --git a/TAO/tao/TimeBaseC.h b/TAO/tao/TimeBaseC.h
index 463447ff065..843f1a17bb9 100644
--- a/TAO/tao/TimeBaseC.h
+++ b/TAO/tao/TimeBaseC.h
@@ -134,20 +134,20 @@ TAO_NAMESPACE  TimeBase
 }
 TAO_NAMESPACE_CLOSE // module TimeBase
 
-void TAO_Export operator<<= (CORBA::Any &, const TimeBase::UtcT &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, TimeBase::UtcT*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, TimeBase::UtcT *&);
-void TAO_Export operator<<= (CORBA::Any &, const TimeBase::IntervalT &); // copying version
-void TAO_Export operator<<= (CORBA::Any &, TimeBase::IntervalT*); // noncopying version
-CORBA::Boolean TAO_Export operator>>= (const CORBA::Any &, TimeBase::IntervalT *&);
+TAO_Export void operator<<= (CORBA::Any &, const TimeBase::UtcT &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, TimeBase::UtcT*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TimeBase::UtcT *&);
+TAO_Export void operator<<= (CORBA::Any &, const TimeBase::IntervalT &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, TimeBase::IntervalT*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, TimeBase::IntervalT *&);
 
 #if defined (__ACE_INLINE__)
 #include "tao/TimeBaseC.i"
 #else
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const TimeBase::UtcT &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, TimeBase::UtcT &);
-CORBA::Boolean TAO_Export operator<< (TAO_OutputCDR &, const TimeBase::IntervalT &);
-CORBA::Boolean TAO_Export operator>> (TAO_InputCDR &, TimeBase::IntervalT &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const TimeBase::UtcT &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, TimeBase::UtcT &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const TimeBase::IntervalT &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, TimeBase::IntervalT &);
 #endif /* defined INLINE */
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
diff --git a/TAO/tao/corbafwd.h b/TAO/tao/corbafwd.h
index 89e1a8a52e1..7b518b03811 100644
--- a/TAO/tao/corbafwd.h
+++ b/TAO/tao/corbafwd.h
@@ -644,7 +644,7 @@ template <class T,class T_var> class TAO_Unbounded_Object_Sequence;
 // Provide a simple function to access the TSS default environment.
 // We tried with CORBA_Environment::default_environment (),
 // CORBA::default_environment() and others.
-extern TAO_Export CORBA_Environment& TAO_default_environment (void);
+TAO_Export CORBA_Environment& TAO_default_environment (void);
 
 enum TAO_SERVANT_LOCATION
 {
@@ -703,11 +703,11 @@ TAO_NAMESPACE CORBA
 
   // = String memory management.
   TAO_NAMESPACE_INLINE_FUNCTION Char* string_alloc (ULong len);
-  TAO_NAMESPACE_STORAGE_CLASS Char* string_dup (const Char *);
+  TAO_Export  Char* string_dup (const Char *);
   TAO_NAMESPACE_INLINE_FUNCTION void string_free (Char *);
 
   // This is a TAO extension and must go away....
-  TAO_NAMESPACE_STORAGE_CLASS Char* string_copy (const Char *);
+  TAO_Export Char* string_copy (const Char *);
 
   typedef CORBA_String_var String_var;
   typedef CORBA_String_out String_out;
@@ -719,7 +719,7 @@ TAO_NAMESPACE CORBA
 
   // = String memory management routines.
   TAO_NAMESPACE_INLINE_FUNCTION WChar* wstring_alloc (ULong len);
-  TAO_NAMESPACE_STORAGE_CLASS WChar* wstring_dup (const WChar *const);
+  TAO_Export  WChar* wstring_dup (const WChar *const);
   TAO_NAMESPACE_INLINE_FUNCTION void wstring_free (WChar *const);
 
   typedef CORBA_WString_var WString_var;
@@ -1657,13 +1657,13 @@ TAO_NAMESPACE CORBA
   // There could be a single version of these methods, but g++ 2.7.2
   // gets horribly confused if we used CORBA::default_environment() at
   // this point.
-  TAO_NAMESPACE_STORAGE_CLASS ORB_ptr ORB_init (int &argc,
-                                                char *argv[],
-                                                const char *orb_name = 0);
-  TAO_NAMESPACE_STORAGE_CLASS ORB_ptr ORB_init (int &argc,
-                                                char *argv[],
-                                                const char *orb_name,
-                                                CORBA_Environment &ACE_TRY_ENV);
+  TAO_Export ORB_ptr ORB_init (int &argc,
+                               char *argv[],
+                               const char *orb_name = 0);
+  TAO_Export ORB_ptr ORB_init (int &argc,
+                               char *argv[],
+                               const char *orb_name,
+                               CORBA_Environment &ACE_TRY_ENV);
   // ORB initialisation
 
   // = TAO extensions...
@@ -1806,10 +1806,10 @@ TAO_NAMESPACE_CLOSE  // end of class (namespace) CORBA
 typedef TAO_Unbounded_Sequence<CORBA::Octet> TAO_opaque;
 extern TAO_Export CORBA::TypeCode_ptr TC_opaque;
 
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator<< (TAO_OutputCDR&, const TAO_opaque&);
 
-extern TAO_Export CORBA::Boolean
+TAO_Export CORBA::Boolean
 operator>> (TAO_InputCDR&, TAO_opaque&);
 
 class TAO_ObjectKey;
diff --git a/TAO/tao/orbconf.h b/TAO/tao/orbconf.h
index 5ad2e5147be..fe9eb18fa50 100644
--- a/TAO/tao/orbconf.h
+++ b/TAO/tao/orbconf.h
@@ -191,7 +191,7 @@
 # if defined (_MSC_VER) && defined (__ACE_INLINE__)
 #   define TAO_NAMESPACE_INLINE_FUNCTION inline
 # else
-#   define TAO_NAMESPACE_INLINE_FUNCTION TAO_NAMESPACE_STORAGE_CLASS
+#   define TAO_NAMESPACE_INLINE_FUNCTION TAO_Export
 # endif
 
 // Instead of replacing this with the ACE macro