changed include protection from #if !defined to ifndef, and added #pragma once, if possible

4 files changed, 159 insertions, 155 deletions

diff --git a/TAO/Benchmark/Marshal_Test/Orbix/marshal.h b/TAO/Benchmark/Marshal_Test/Orbix/marshal.h
index 4e07d507a8b..497c872001f 100644
--- a/TAO/Benchmark/Marshal_Test/Orbix/marshal.h
+++ b/TAO/Benchmark/Marshal_Test/Orbix/marshal.h
@@ -134,7 +134,7 @@ class _IDL_SEQUENCE_any_var : public CORBA::_var
 class Marshal_dispatch : public virtual CORBA::PPTR {
 public:
 
-      Marshal_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, 
+      Marshal_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m,
         CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im)
        : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {}
 
@@ -149,12 +149,12 @@ public:
        : PPTR (IT_OR,IT_p,IT_o) {}
 
 
-   Marshal_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, 
+   Marshal_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m,
         char *IT_i, CORBA::Object* IT_ob, void* IT_im)
        : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {}
 
 
-   virtual unsigned char dispatch (CORBA::Request &IT_r, 
+   virtual unsigned char dispatch (CORBA::Request &IT_r,
         unsigned char IT_isTarget, void* IT_pp=NULL);
 
 
@@ -213,12 +213,12 @@ protected:
     }
 public:
     static Marshal_ptr _duplicate(
-            Marshal_ptr, 
+            Marshal_ptr,
             CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ());
 public:
    static Marshal* _bind (const char* IT_markerServer, const char* host,
-		const CORBA::Context &IT_c, 
-		CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+                const CORBA::Context &IT_c,
+                CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
    static Marshal* _bind (CORBA::Environment &IT_env);
    static Marshal* _bind (const char* IT_markerServer=NULL, const char* host=NULL,
                  CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
@@ -245,7 +245,7 @@ struct Marshal_Struct {
     void decodeOp (CORBA::Request &IT_r);
     void decodeInOutOp (CORBA::Request &IT_r);
     static void* IT_anySupport (CORBA::Request &IT_r,
-    			void *&, void*, const CORBA::Flags&);
+                        void *&, void*, const CORBA::Flags&);
     static const void *IT_fn;
     Marshal_Struct(const Marshal_Struct &);
     Marshal_Struct();
@@ -361,7 +361,7 @@ struct Marshal_Union {
     void decodeOp (CORBA::Request &IT_r);
     void decodeInOutOp (CORBA::Request &IT_r);
     static void* IT_anySupport (CORBA::Request &IT_r,
-    			void *&, void*, const CORBA::Flags&);
+                        void *&, void*, const CORBA::Flags&);
     static const void *IT_fn;
 
     private:
@@ -704,7 +704,7 @@ struct Marshal_Recursive {
     void decodeOp (CORBA::Request &IT_r);
     void decodeInOutOp (CORBA::Request &IT_r);
     static void* IT_anySupport (CORBA::Request &IT_r,
-    			void *&, void*, const CORBA::Flags&);
+                        void *&, void*, const CORBA::Flags&);
     static const void *IT_fn;
     Marshal_Recursive(const Marshal_Recursive &);
     Marshal_Recursive();
@@ -993,7 +993,7 @@ class Marshal_SeqElem : public CORBA::_SeqElem
     }
 
     operator Marshal_ptr () const {
-        return _ptr ? (Marshal_ptr) (*_ptr) : Marshal_nil(); 
+        return _ptr ? (Marshal_ptr) (*_ptr) : Marshal_nil();
     }
 
     Marshal_ptr operator->() const { return *_ptr;}
@@ -1009,108 +1009,108 @@ class Marshal_SeqElem : public CORBA::_SeqElem
 #define TIE_Marshal(X) Marshal##X
 
 #define DEF_TIE_Marshal(X) \
-	class Marshal##X : public virtual Marshal {		\
-	  X* m_obj;						\
-	public:							\
-								\
-								\
-	   Marshal##X  (X *objp, const char* m="", CORBA::LoaderClass *l=0)\
-		: Marshal(), m_obj(objp) {	\
-		m_pptr = new Marshal_dispatch		\
-			(( Marshal*)this,(CORBA::Object*)this,m,l,Marshal_IR,m_obj);	\
-	   }								\
-	   Marshal##X  (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\
-		: Marshal() {	\
-		m_pptr = new Marshal_dispatch		\
-			(( Marshal*)this,(CORBA::Object*)this,IT_m,Marshal_IR,IT_p,IT_q);	\
-		m_obj = (X*)(m_pptr->getImplObj ());			\
-	   }								\
-								\
-	   virtual ~Marshal##X  () {				\
-		if (_okToDeleteImpl ()) delete m_obj; }					\
-	   virtual void* _deref () {					\
-		return m_obj; }					\
-								\
+        class Marshal##X : public virtual Marshal {             \
+          X* m_obj;                                             \
+        public:                                                 \
+                                                                \
+                                                                \
+           Marshal##X  (X *objp, const char* m="", CORBA::LoaderClass *l=0)\
+                : Marshal(), m_obj(objp) {      \
+                m_pptr = new Marshal_dispatch           \
+                        (( Marshal*)this,(CORBA::Object*)this,m,l,Marshal_IR,m_obj);    \
+           }                                                            \
+           Marshal##X  (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\
+                : Marshal() {   \
+                m_pptr = new Marshal_dispatch           \
+                        (( Marshal*)this,(CORBA::Object*)this,IT_m,Marshal_IR,IT_p,IT_q);       \
+                m_obj = (X*)(m_pptr->getImplObj ());                    \
+           }                                                            \
+                                                                \
+           virtual ~Marshal##X  () {                            \
+                if (_okToDeleteImpl ()) delete m_obj; }                                 \
+           virtual void* _deref () {                                    \
+                return m_obj; }                                 \
+                                                                \
 virtual void test_short (CORBA::Short s1, CORBA::Short& s2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_short (  s1, s2,IT_env);\
 }\
-	\
+        \
 virtual void test_long (CORBA::Long l1, CORBA::Long& l2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_long (  l1, l2,IT_env);\
 }\
-	\
+        \
 virtual void test_octet (CORBA::Octet o1, CORBA::Octet& o2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_octet (  o1, o2,IT_env);\
 }\
-	\
+        \
 virtual void test_char (CORBA::Char c1, CORBA::Char& c2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_char (  c1, c2,IT_env);\
 }\
-	\
+        \
 virtual void test_double (CORBA::Double d1, CORBA::Double& d2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_double (  d1, d2,IT_env);\
 }\
-	\
+        \
 virtual void test_struct (const Marshal::Marshal_Struct& ms1, Marshal::Marshal_Struct& ms2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_struct (  ms1, ms2,IT_env);\
 }\
-	\
+        \
 virtual void test_union (const Marshal::Marshal_Union& u1, Marshal::Marshal_Union& u2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_union (  u1, u2,IT_env);\
 }\
-	\
+        \
 virtual void test_any (const CORBA::any& a1, CORBA::any*& a2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_any (  a1, a2,IT_env);\
 }\
-	\
+        \
 virtual void test_sequence (const Marshal::AnySeq& as1, Marshal::AnySeq*& as2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_sequence (  as1, as2,IT_env);\
 }\
-	\
+        \
 virtual void test_recursive (const Marshal::Marshal_Recursive& mr1, Marshal::Marshal_Recursive*& mr2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_recursive (  mr1, mr2,IT_env);\
 }\
-								\
-	};						\
+                                                                \
+        };                                              \
 
 
-#define QUALS_Marshal	\
+#define QUALS_Marshal   \
 virtual void test_short (CORBA::Short s1, CORBA::Short& s2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_short (  s1, s2,IT_env);\
 }\
-	\
+        \
 virtual void test_long (CORBA::Long l1, CORBA::Long& l2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_long (  l1, l2,IT_env);\
 }\
-	\
+        \
 virtual void test_octet (CORBA::Octet o1, CORBA::Octet& o2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_octet (  o1, o2,IT_env);\
 }\
-	\
+        \
 virtual void test_char (CORBA::Char c1, CORBA::Char& c2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_char (  c1, c2,IT_env);\
 }\
-	\
+        \
 virtual void test_double (CORBA::Double d1, CORBA::Double& d2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_double (  d1, d2,IT_env);\
 }\
-	\
+        \
 virtual void test_struct (const Marshal_Struct& ms1, Marshal_Struct& ms2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_struct (  ms1, ms2,IT_env);\
 }\
-	\
+        \
 virtual void test_union (const Marshal_Union& u1, Marshal_Union& u2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_union (  u1, u2,IT_env);\
 }\
-	\
+        \
 virtual void test_any (const CORBA::any& a1, CORBA::any*& a2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_any (  a1, a2,IT_env);\
 }\
-	\
+        \
 virtual void test_sequence (const AnySeq& as1, AnySeq*& as2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_sequence (  as1, as2,IT_env);\
 }\
-	\
+        \
 virtual void test_recursive (const Marshal_Recursive& mr1, Marshal_Recursive*& mr2, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
 m_obj->test_recursive (  mr1, mr2,IT_env);\
 }\
@@ -1121,19 +1121,19 @@ m_obj->test_recursive (  mr1, mr2,IT_env);\
 class MarshalProxyFactoryClass : public virtual CORBA::ObjectFactoryClass {
 public:
    MarshalProxyFactoryClass (unsigned char IT_p=0)
-		: CORBA::ProxyFactory (Marshal_IR, IT_p) {}
+                : CORBA::ProxyFactory (Marshal_IR, IT_p) {}
 
     virtual void* New (char *IT_OR, CORBA::Environment&);
 
     virtual void* New (ObjectReference *IT_OR, CORBA::Environment&);
 
-    virtual void* New2 (); 
+    virtual void* New2 ();
 
     virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&);
 
     virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&);
 
-    virtual CORBA::Object* New2Object (); 
+    virtual CORBA::Object* New2Object ();
 
     virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
 
@@ -1151,7 +1151,7 @@ public:
     MarshalBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) {
   if (CORBA::PPTR::isOK (m_pptr, Marshal_IR))
     m_pptr = new Marshal_dispatch ( (Marshal*)this,
-   	 (CORBA::Object*)this, m, l, Marshal_IR, this);
+         (CORBA::Object*)this, m, l, Marshal_IR, this);
 }
 
         virtual void test_short (CORBA::Short s1, CORBA::Short& s2, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
diff --git a/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_client.h b/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_client.h
index 9fce90ef265..c22f71f0d16 100644
--- a/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_client.h
+++ b/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_client.h
@@ -4,16 +4,16 @@
 //
 // = LIBRARY
 //    CORBA Marshal Orbix Benchmark
-// 
+//
 // = FILENAME
 //    orbix_marshal_client.h
 //
 // = AUTHOR
 //    Aniruddha Gokhale
-// 
+//
 // ============================================================================
 
-#if !defined(_ORBIX_MARSHAL_CLIENT_H_)
+#ifndef _ORBIX_MARSHAL_CLIENT_H_
 #define _ORBIX_MARSHAL_CLIENT_H_
 
 // benchmark library includes
@@ -38,78 +38,78 @@ public:
   // destructor
 
   virtual int run (CORBA_Marshal_Proxy::OPTIONS &options,
-		   CORBA_Marshal_Proxy::RESULTS &results);
+                   CORBA_Marshal_Proxy::RESULTS &results);
   // do the actual work
 
   virtual int use_sii (CORBA_Marshal_Proxy::OPTIONS &options,
-		       CORBA_Marshal_Proxy::RESULTS &results);
+                       CORBA_Marshal_Proxy::RESULTS &results);
   // use the static invocation interface
 
   virtual int use_dii (CORBA_Marshal_Proxy::OPTIONS &options,
-		       CORBA_Marshal_Proxy::RESULTS &results);
+                       CORBA_Marshal_Proxy::RESULTS &results);
   // use the dynamic invocation interface
 private:
   // =helper functions
   int sii_test_short (CORBA_Marshal_Proxy::OPTIONS &options,
-		      CORBA_Marshal_Proxy::RESULTS &results);
+                      CORBA_Marshal_Proxy::RESULTS &results);
 
   int sii_test_long (CORBA_Marshal_Proxy::OPTIONS &options,
-		     CORBA_Marshal_Proxy::RESULTS &results);
+                     CORBA_Marshal_Proxy::RESULTS &results);
 
   int sii_test_octet (CORBA_Marshal_Proxy::OPTIONS &options,
-		      CORBA_Marshal_Proxy::RESULTS &results);
+                      CORBA_Marshal_Proxy::RESULTS &results);
 
   int sii_test_char (CORBA_Marshal_Proxy::OPTIONS &options,
-		     CORBA_Marshal_Proxy::RESULTS &results);
+                     CORBA_Marshal_Proxy::RESULTS &results);
 
   int sii_test_double (CORBA_Marshal_Proxy::OPTIONS &options,
-		       CORBA_Marshal_Proxy::RESULTS &results);
+                       CORBA_Marshal_Proxy::RESULTS &results);
 
   int sii_test_struct (CORBA_Marshal_Proxy::OPTIONS &options,
-		       CORBA_Marshal_Proxy::RESULTS &results);
+                       CORBA_Marshal_Proxy::RESULTS &results);
 
   int sii_test_union (CORBA_Marshal_Proxy::OPTIONS &options,
-		      CORBA_Marshal_Proxy::RESULTS &results);
+                      CORBA_Marshal_Proxy::RESULTS &results);
 
   int sii_test_any (CORBA_Marshal_Proxy::OPTIONS &options,
-		    CORBA_Marshal_Proxy::RESULTS &results);
+                    CORBA_Marshal_Proxy::RESULTS &results);
 
   int sii_test_sequence (CORBA_Marshal_Proxy::OPTIONS &options,
-			 CORBA_Marshal_Proxy::RESULTS &results);
+                         CORBA_Marshal_Proxy::RESULTS &results);
 
   int sii_test_recursive (CORBA_Marshal_Proxy::OPTIONS &options,
-			  CORBA_Marshal_Proxy::RESULTS &results);
+                          CORBA_Marshal_Proxy::RESULTS &results);
 
   // all the DII helpers
   int dii_test_short (CORBA_Marshal_Proxy::OPTIONS &options,
-		      CORBA_Marshal_Proxy::RESULTS &results);
+                      CORBA_Marshal_Proxy::RESULTS &results);
 
   int dii_test_long (CORBA_Marshal_Proxy::OPTIONS &options,
-		     CORBA_Marshal_Proxy::RESULTS &results);
+                     CORBA_Marshal_Proxy::RESULTS &results);
 
   int dii_test_octet (CORBA_Marshal_Proxy::OPTIONS &options,
-		      CORBA_Marshal_Proxy::RESULTS &results);
+                      CORBA_Marshal_Proxy::RESULTS &results);
 
   int dii_test_char (CORBA_Marshal_Proxy::OPTIONS &options,
-		     CORBA_Marshal_Proxy::RESULTS &results);
+                     CORBA_Marshal_Proxy::RESULTS &results);
 
   int dii_test_double (CORBA_Marshal_Proxy::OPTIONS &options,
-		       CORBA_Marshal_Proxy::RESULTS &results);
+                       CORBA_Marshal_Proxy::RESULTS &results);
 
   int dii_test_struct (CORBA_Marshal_Proxy::OPTIONS &options,
-		       CORBA_Marshal_Proxy::RESULTS &results);
+                       CORBA_Marshal_Proxy::RESULTS &results);
 
   int dii_test_union (CORBA_Marshal_Proxy::OPTIONS &options,
-		      CORBA_Marshal_Proxy::RESULTS &results);
+                      CORBA_Marshal_Proxy::RESULTS &results);
 
   int dii_test_any (CORBA_Marshal_Proxy::OPTIONS &options,
-		    CORBA_Marshal_Proxy::RESULTS &results);
+                    CORBA_Marshal_Proxy::RESULTS &results);
 
   int dii_test_sequence (CORBA_Marshal_Proxy::OPTIONS &options,
-			 CORBA_Marshal_Proxy::RESULTS &results);
+                         CORBA_Marshal_Proxy::RESULTS &results);
 
   int dii_test_recursive (CORBA_Marshal_Proxy::OPTIONS &options,
-			  CORBA_Marshal_Proxy::RESULTS &results);
+                          CORBA_Marshal_Proxy::RESULTS &results);
 
   CORBA::ORB_ptr orb_;
   // handle to the underlying orb
diff --git a/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_impl.h b/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_impl.h
index a74866173d8..2b62f4bb81b 100644
--- a/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_impl.h
+++ b/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_impl.h
@@ -1,16 +1,20 @@
 // $Id$
 
-#if !defined (ORBIX_MARSHAL_IMPL_H)
+#ifndef ORBIX_MARSHAL_IMPL_H
 #define ORBIX_MARSHAL_IMPL_H
 
 // to include DSI related files
 
 #include "ace/OS.h"
 
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
 #include "marshal.h"
 
 
-class Marshal_SSI_Impl 
+class Marshal_SSI_Impl
   : public virtual MarshalBOAImpl
 {
   // =TITLE
@@ -25,73 +29,73 @@ public:
   // destructor
 
   virtual void test_short (CORBA::Short s1,
-			   CORBA::Short& s2,
-			   CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+                           CORBA::Short& s2,
+                           CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   // test short
-	
+
   virtual void test_long (CORBA::Long l1,
-			  CORBA::Long& l2,
-			  CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+                          CORBA::Long& l2,
+                          CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   // test long
-	
+
   virtual void test_octet (CORBA::Octet o1,
-			   CORBA::Octet& o2,
-			   CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+                           CORBA::Octet& o2,
+                           CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   // test octet
-	
+
   virtual void test_char (CORBA::Char c1,
-			  CORBA::Char& c2,
-			  CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+                          CORBA::Char& c2,
+                          CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   // test char
-	
+
   virtual void test_double (CORBA::Double d1,
-			    CORBA::Double& d2,
-			    CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+                            CORBA::Double& d2,
+                            CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   // test double
-	
+
   virtual void test_struct (const Marshal::Marshal_Struct& ms1,
-			    Marshal::Marshal_Struct& ms2,
-			    CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+                            Marshal::Marshal_Struct& ms2,
+                            CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   // test struct
-	
+
   virtual void test_union (const Marshal::Marshal_Union& u1,
-			   Marshal::Marshal_Union& u2,
-			   CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+                           Marshal::Marshal_Union& u2,
+                           CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   // test union
-	
+
   virtual void test_any (const CORBA::Any& a1,
-			 CORBA::Any *& a2,
-			 CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+                         CORBA::Any *& a2,
+                         CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   // test any
-	
+
   /*
   virtual void test_sequence (const Marshal::ShortSeq& s1,
-			     const Marshal::LongSeq& l1,
-			     const Marshal::OctetSeq& o1,
-			     const Marshal::CharSeq& c1,
-			     const Marshal::DoubleSeq& d1,
-			     const Marshal::StructSeq& S1,
-			     const Marshal::UnionSeq& U1,
-			     const Marshal::AnySeq& a1,
-			     Marshal::ShortSeq *& s2,
-			     Marshal::LongSeq *& l2,
-			     Marshal::OctetSeq *& o2,
-			     Marshal::CharSeq *& c2,
-			     Marshal::DoubleSeq *& d2,
-			     Marshal::StructSeq *& S2,
-			     Marshal::UnionSeq *& U2,
-			     Marshal::AnySeq *& a2);
-			     */
+                             const Marshal::LongSeq& l1,
+                             const Marshal::OctetSeq& o1,
+                             const Marshal::CharSeq& c1,
+                             const Marshal::DoubleSeq& d1,
+                             const Marshal::StructSeq& S1,
+                             const Marshal::UnionSeq& U1,
+                             const Marshal::AnySeq& a1,
+                             Marshal::ShortSeq *& s2,
+                             Marshal::LongSeq *& l2,
+                             Marshal::OctetSeq *& o2,
+                             Marshal::CharSeq *& c2,
+                             Marshal::DoubleSeq *& d2,
+                             Marshal::StructSeq *& S2,
+                             Marshal::UnionSeq *& U2,
+                             Marshal::AnySeq *& a2);
+                             */
   virtual void test_sequence (const Marshal::AnySeq& a1,
-			      Marshal::AnySeq *& a2,
-			      CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+                              Marshal::AnySeq *& a2,
+                              CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   // test sequence
 
   virtual void test_recursive (const Marshal::Marshal_Recursive& mr1,
-			       Marshal::Marshal_Recursive *& mr2,
-			       CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+                               Marshal::Marshal_Recursive *& mr2,
+                               CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   // test struct
-	
+
 };
 
 class Marshal_DSI_Impl : public CORBA::DynamicImplementation
@@ -109,50 +113,50 @@ public:
 
 private:
   virtual void invoke (CORBA::ServerRequest& req, CORBA::Environment_ptr,
-		       CORBA::Environment&IT_env =
-		       CORBA::IT_chooseDefaultEnv()); 
+                       CORBA::Environment&IT_env =
+                       CORBA::IT_chooseDefaultEnv());
   // This method is a must
 
   void test_short (CORBA::Short s1,
-		   CORBA::Short& s2);
+                   CORBA::Short& s2);
   // test short
-	
+
   void test_long (CORBA::Long l1,
-		  CORBA::Long& l2);
+                  CORBA::Long& l2);
   // test long
-	
+
   void test_octet (CORBA::Octet o1,
-		   CORBA::Octet& o2);
+                   CORBA::Octet& o2);
   // test octet
-	
+
   void test_char (CORBA::Char c1,
-		  CORBA::Char& c2);
+                  CORBA::Char& c2);
   // test char
-	
+
   void test_double (CORBA::Double d1,
-		    CORBA::Double& d2);
+                    CORBA::Double& d2);
   // test double
-	
+
   void test_struct (const Marshal::Marshal_Struct& ms1,
-		    Marshal::Marshal_Struct& ms2);
+                    Marshal::Marshal_Struct& ms2);
   // test struct
-	
+
   void test_union (const Marshal::Marshal_Union& u1,
-		   Marshal::Marshal_Union& u2);
+                   Marshal::Marshal_Union& u2);
   // test union
-	
+
   void test_any (const CORBA::Any& a1,
-		 CORBA::Any *& a2);
+                 CORBA::Any *& a2);
   // test any
-	
+
   void test_sequence (const Marshal::AnySeq& a1,
-		      Marshal::AnySeq *& a2);
+                      Marshal::AnySeq *& a2);
   // test sequence
 
   void test_recursive (const Marshal::Marshal_Recursive& mr1,
-		       Marshal::Marshal_Recursive *& mr2);
+                       Marshal::Marshal_Recursive *& mr2);
   // test struct
-	
+
 private:
   //= helper functions - they behave as if they were skeletons
   void test_short_skel (CORBA::ServerRequest& req);
diff --git a/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_server.h b/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_server.h
index 09a64b4bbc8..3fb2fa83396 100644
--- a/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_server.h
+++ b/TAO/Benchmark/Marshal_Test/Orbix/orbix_marshal_server.h
@@ -4,16 +4,16 @@
 //
 // = LIBRARY
 //    CORBA Marshal Orbix Benchmark
-// 
+//
 // = FILENAME
 //    orbix_marshal_server.h
 //
 // = AUTHOR
 //    Aniruddha Gokhale
-// 
+//
 // ============================================================================
 
-#if !defined(_ORBIX_MARSHAL_SERVER_H_)
+#ifndef _ORBIX_MARSHAL_SERVER_H_
 #define _ORBIX_MARSHAL_SERVER_H_
 
 // benchmark library includes
@@ -37,7 +37,7 @@ public:
   // destructor
 
   virtual int run (CORBA_Marshal_Proxy::OPTIONS &options,
-		   CORBA_Marshal_Proxy::RESULTS &results);
+                   CORBA_Marshal_Proxy::RESULTS &results);
   // do the actual work
 private:
   CORBA::ORB_ptr orb_;