.

19 files changed, 227 insertions, 362 deletions

diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.cpp b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.cpp
index 75de50ad531..e2f1c570a46 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.cpp
@@ -1,55 +1,38 @@
-// ========================================================================
 // $Id$
-//
-// = LIBRARY
-//    orbsvcs
-//
-// = FILENAME
-//    Constraint_Interpreter.cpp
-//
-// = AUTHOR
-//    Seth Widoff <sbw1@cs.wustl.edu>
-//
-// ========================================================================
 
 #include "ace/OS.h"
 #include "Constraint_Interpreter.h"
 
 ACE_RCSID(Trader, Constraint_Interpreter, "$Id$")
 
-  // *************************************************************
-  // TAO_Interpreter
-  // *************************************************************
-
 TAO_Interpreter::~TAO_Interpreter (void)
 {
   delete root_;
 }
 
 int
-TAO_Interpreter::build_tree(const char* constraints)
+TAO_Interpreter::build_tree (const char* constraints)
 {
-  TAO_Lex_String_Input::reset((char*)constraints);
+  TAO_Lex_String_Input::reset ((char*)constraints);
   int return_value = 0;
 
   yyval.constraint_ = 0;
-  return_value = ::yyparse();
+  return_value = ::yyparse ();
 
   if (return_value == 0 && yyval.constraint_ != 0)
     this->root_ = yyval.constraint_;
   else
     {
-      while (yylex() > 0)
-        ;
+      while (yylex () > 0)
+        continue;
       this->root_ = 0;
     }
 
   return return_value;
 }
 
-
 int
-TAO_Interpreter::is_empty_string(const char* str)
+TAO_Interpreter::is_empty_string (const char* str)
 {
   int return_value = 0;
 
@@ -71,46 +54,44 @@ TAO_Interpreter::is_empty_string(const char* str)
   return return_value;
 }
 
-  // *************************************************************
-  // TAO_Constraint_Interpreter
-  // *************************************************************
-
 TAO_Constraint_Interpreter::
 TAO_Constraint_Interpreter (const CosTradingRepos::ServiceTypeRepository::TypeStruct& ts,
                             const char* constraints,
-                            CORBA::Environment& TAO_IN_ENV)
+                            CORBA::Environment& ACE_TRY_ENV)
   ACE_THROW_SPEC ((CosTrading::IllegalConstraint))
   : TAO_Interpreter ()
 {
   TAO_Constraint_Validator type_checker (ts);
 
   if (TAO_Interpreter::is_empty_string (constraints))
-    this->root_ = new TAO_Literal_Constraint ((CORBA::Boolean) 1);
+    ACE_NEW (this->root_,
+             TAO_Literal_Constraint ((CORBA::Boolean) 1));
   else
     {
       if (this->build_tree (constraints) != 0)
-        TAO_THROW (CosTrading::IllegalConstraint (constraints));
+        ACE_THROW (CosTrading::IllegalConstraint (constraints));
 
       if (type_checker.validate (this->root_) == -1)
-        TAO_THROW (CosTrading::IllegalConstraint (constraints));
+        ACE_THROW (CosTrading::IllegalConstraint (constraints));
     }
 }
 
 TAO_Constraint_Interpreter::
-TAO_Constraint_Interpreter(TAO_Constraint_Validator& validator,
+TAO_Constraint_Interpreter (TAO_Constraint_Validator& validator,
                            const char* constraints,
-                           CORBA::Environment& TAO_IN_ENV)
+                           CORBA::Environment& ACE_TRY_ENV)
   ACE_THROW_SPEC ((CosTrading::IllegalConstraint))
 {
   if (TAO_Interpreter::is_empty_string (constraints))
-    this->root_ = new TAO_Literal_Constraint ((CORBA::Boolean) 1);
+    ACE_NEW (this->root_,
+             TAO_Literal_Constraint ((CORBA::Boolean) 1));
   else
     {
       if (this->build_tree (constraints) != 0)
-        TAO_THROW (CosTrading::IllegalConstraint (constraints));
+        ACE_THROW (CosTrading::IllegalConstraint (constraints));
 
       if (validator.validate (this->root_) == -1)
-        TAO_THROW (CosTrading::IllegalConstraint (constraints));
+        ACE_THROW (CosTrading::IllegalConstraint (constraints));
     }
 }
 
@@ -126,56 +107,54 @@ TAO_Constraint_Interpreter::evaluate (CosTrading::Offer* offer)
 }
 
 CORBA::Boolean
-TAO_Constraint_Interpreter::evaluate(TAO_Constraint_Evaluator& evaluator)
+TAO_Constraint_Interpreter::evaluate (TAO_Constraint_Evaluator& evaluator)
 {
   return evaluator.evaluate_constraint (this->root_);
 }
 
-  // *************************************************************
-  // TAO_Preference_Interpreter
-  // *************************************************************
-
 TAO_Preference_Interpreter::
-TAO_Preference_Interpreter(const CosTradingRepos::ServiceTypeRepository::TypeStruct& ts,
+TAO_Preference_Interpreter (const CosTradingRepos::ServiceTypeRepository::TypeStruct& ts,
                            const char* preference,
-                           CORBA::Environment& TAO_IN_ENV)
+                           CORBA::Environment& ACE_TRY_ENV)
   ACE_THROW_SPEC ((CosTrading::Lookup::IllegalPreference))
-  : TAO_Interpreter ()
+    : TAO_Interpreter ()
 {
   TAO_Constraint_Validator type_checker (ts);
 
   if (TAO_Interpreter::is_empty_string (preference))
-    this->root_ = new TAO_Noop_Constraint (TAO_FIRST);
+    ACE_NEW (this->root_,
+             TAO_Noop_Constraint (TAO_FIRST));
   else
     {
       if (this->build_tree (preference) != 0)
-        TAO_THROW (CosTrading::Lookup::IllegalPreference (preference));
+        ACE_THROW (CosTrading::Lookup::IllegalPreference (preference));
 
       if (type_checker.validate (this->root_) == -1)
-        TAO_THROW (CosTrading::Lookup::IllegalPreference (preference));
+        ACE_THROW (CosTrading::Lookup::IllegalPreference (preference));
     }
 }
 
 TAO_Preference_Interpreter::
-TAO_Preference_Interpreter(TAO_Constraint_Validator& validator,
+TAO_Preference_Interpreter (TAO_Constraint_Validator& validator,
                            const char* preference,
-                           CORBA::Environment& TAO_IN_ENV)
+                           CORBA::Environment& ACE_TRY_ENV)
   ACE_THROW_SPEC ((CosTrading::Lookup::IllegalPreference))
     : TAO_Interpreter ()
 {
   if (TAO_Interpreter::is_empty_string (preference))
-    this->root_ = new TAO_Noop_Constraint (TAO_FIRST);
+    ACE_NEW (this->root_,
+             TAO_Noop_Constraint (TAO_FIRST));
   else
     {
       if (this->build_tree (preference) != 0)
-        TAO_THROW (CosTrading::Lookup::IllegalPreference (preference));
+        ACE_THROW (CosTrading::Lookup::IllegalPreference (preference));
 
       if (validator.validate (this->root_) == -1)
-        TAO_THROW (CosTrading::Lookup::IllegalPreference (preference));
+        ACE_THROW (CosTrading::Lookup::IllegalPreference (preference));
     }
 }
 
-TAO_Preference_Interpreter::~TAO_Preference_Interpreter()
+TAO_Preference_Interpreter::~TAO_Preference_Interpreter ()
 {
 }
 
@@ -208,9 +187,9 @@ order_offer (TAO_Constraint_Evaluator& evaluator,
           // correct place in the queue.
           TAO_Expression_Type expr_type = this->root_->expr_type ();
 
-          if (expr_type == TAO_FIRST ||
-              (expr_type == TAO_WITH &&
-               ! ACE_static_cast (CORBA::Boolean, pref_info.value_)))
+          if (expr_type == TAO_FIRST 
+              || (expr_type == TAO_WITH 
+                  && ! ACE_static_cast (CORBA::Boolean, pref_info.value_)))
             this->offers_.enqueue_tail (pref_info);
           else
             this->offers_.enqueue_head (pref_info);
@@ -220,25 +199,27 @@ order_offer (TAO_Constraint_Evaluator& evaluator,
               Ordered_Offers::ITERATOR offer_iter (this->offers_);
 
               // Push the new item down the list until the min/max
-              // criterion is satisfied. Observe the evaluation
-              // failed / evaluation suceeded partion in the list.
+              // criterion is satisfied. Observe the evaluation failed
+              // / evaluation suceeded partion in the list.
               offer_iter.advance ();
+
               for (int i = 1;
-                   ! offer_iter.done ();
+                   offer_iter.done () == 0;
                    offer_iter.advance (), i++)
                 {
                   Preference_Info* current_offer;
                   offer_iter.next (current_offer);
 
                   // Maintain the sorted order in the first partition.
-                  if (current_offer->evaluated_ == 1 &&
-                      ((expr_type == TAO_MIN &&
-                       pref_info.value_ > current_offer->value_) ||
-                      (expr_type == TAO_MAX &&
-                       pref_info.value_ < current_offer->value_)))
+                  if (current_offer->evaluated_ == 1 
+                      && ((expr_type == TAO_MIN 
+                        && pref_info.value_ > current_offer->value_) 
+                       || (expr_type == TAO_MAX 
+                           && pref_info.value_ < current_offer->value_)))
                     {
                       // Swap the out of order pair
-                      this->offers_.set (*current_offer, i - 1);
+                      this->offers_.set (*current_offer,
+                                         i - 1);
                       this->offers_.set (pref_info, i);
                     }
                   else
@@ -287,13 +268,9 @@ remove_offer (CosTrading::Offer*& offer)
 int
 TAO_Preference_Interpreter::num_offers (void)
 {
-  return this->offers_.size();
+  return this->offers_.size ();
 }
 
-  // *************************************************************
-  // Ugly Lex/Yacc Stuff
-  // *************************************************************
-
 char* TAO_Lex_String_Input::string_ = 0;
 char* TAO_Lex_String_Input::current_ = 0;
 char* TAO_Lex_String_Input::end_ = 0;
@@ -301,14 +278,16 @@ char* TAO_Lex_String_Input::end_ = 0;
 // Routine to have Lex read its input from the constraint string.
 
 int
-TAO_Lex_String_Input::copy_into(char* buf, int max_size)
+TAO_Lex_String_Input::copy_into (char* buf, int max_size)
 {
   int chars_left =  TAO_Lex_String_Input::end_ - TAO_Lex_String_Input::current_;
-  int n = (max_size > chars_left) ? chars_left : max_size;
+  int n = max_size > chars_left ? chars_left : max_size;
 
   if (n > 0)
     {
-      memcpy(buf, TAO_Lex_String_Input::current_, n);
+      ACE_OS:: memcpy (buf,
+                       TAO_Lex_String_Input::current_,
+                       n);
       TAO_Lex_String_Input::current_ += n;
     }
 
@@ -316,12 +295,12 @@ TAO_Lex_String_Input::copy_into(char* buf, int max_size)
 }
 
 void
-TAO_Lex_String_Input::reset(char* input_string)
+TAO_Lex_String_Input::reset (char* input_string)
 {
   TAO_Lex_String_Input::string_ = input_string;
   TAO_Lex_String_Input::current_ = input_string;
   TAO_Lex_String_Input::end_ = input_string +
-    ACE_OS::strlen(TAO_Lex_String_Input::string_);
+    ACE_OS::strlen (TAO_Lex_String_Input::string_);
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.h b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.h
index 462e91ae51b..4493da8a76c 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Interpreter.h
@@ -1,7 +1,7 @@
 /* -*- C++ -*- */
+// $Id$
 
 // ========================================================================
-// $Id$
 //
 // = LIBRARY
 //    orbsvcs
@@ -72,7 +72,7 @@ class TAO_Constraint_Interpreter : public TAO_Interpreter
 //   whether the offer meets the constraints.
 {
 public:
-
+  // = Initialization and termination methods.
   TAO_Constraint_Interpreter (const CosTradingRepos::ServiceTypeRepository::TypeStruct& ts,
                               const char* constraints,
                               CORBA::Environment& env)
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.cpp b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.cpp
index ea7b8775e3b..ff502e23059 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Nodes.cpp
@@ -1,26 +1,13 @@
-// =====================================================================
 // $Id$
-//
-// = LIBRARY
-//    Lookup
-//
-// = FILENAME
-//    Constraint_Nodes.cpp
-//
-// = AUTHOR
-//    Seth Widoff <sbw1@cs.wustl.edu>
-//
-// =====================================================================
-
 
 #include "Constraint_Nodes.h"
 #include "Constraint_Visitors.h"
 
-ACE_RCSID(Trader, Constraint_Nodes, "$Id$")
+ACE_RCSID (Trader, Constraint_Nodes, "$Id$")
 
-const CORBA::Long MAX_SIGNED_INTEGER = (~(CORBA::Long)0) >> 1;
-const CORBA::Long MIN_SIGNED_INTEGER = ~(MAX_SIGNED_INTEGER);
-const CORBA::ULong MAX_UNSIGNED_INTEGER = (~(CORBA::ULong)0);
+const CORBA::Long MAX_SIGNED_INTEGER = (~ (CORBA::Long)0) >> 1;
+const CORBA::Long MIN_SIGNED_INTEGER = ~ (MAX_SIGNED_INTEGER);
+const CORBA::ULong MAX_UNSIGNED_INTEGER = (~ (CORBA::ULong)0);
 
 int
 TAO_Noop_Constraint::accept (TAO_Constraint_Visitor* visitor)
@@ -40,15 +27,15 @@ TAO_Noop_Constraint::accept (TAO_Constraint_Visitor* visitor)
 
 TAO_Binary_Constraint::
 TAO_Binary_Constraint (TAO_Expression_Type op_type,
-				TAO_Constraint* left,
-				TAO_Constraint* right)
-  : op_  (op_type),
+                       TAO_Constraint* left,
+                       TAO_Constraint* right)
+  : op_ (op_type),
     left_ (left),
     right_ (right)
 {
 }
 
-TAO_Binary_Constraint::~TAO_Binary_Constraint ()
+TAO_Binary_Constraint::~TAO_Binary_Constraint (void)
 {
   delete left_;
   delete right_;
@@ -78,6 +65,7 @@ static int (*dispatch_table[]) (TAO_Constraint_Visitor*,
 };
 
 // Simulate the fun of actual double dispatching.
+
 int
 TAO_Binary_Constraint::accept (TAO_Constraint_Visitor* visitor)
 {
@@ -85,7 +73,7 @@ TAO_Binary_Constraint::accept (TAO_Constraint_Visitor* visitor)
     return_value = -1;
 
   if (dispatch_table[offset] != 0)
-    return_value = dispatch_table[offset](visitor, this);
+    return_value = dispatch_table[offset] (visitor, this);
 
   return return_value;
 }
@@ -95,15 +83,15 @@ TAO_Binary_Constraint::
 visit_or (TAO_Constraint_Visitor* visitor,
 		  TAO_Binary_Constraint* expr)
 {
-  return visitor->visit_or(expr);
+  return visitor->visit_or (expr);
 }
 
 int
 TAO_Binary_Constraint::
 visit_and (TAO_Constraint_Visitor* visitor,
-	  TAO_Binary_Constraint* expr)
+           TAO_Binary_Constraint* expr)
 {
-  return visitor->visit_and(expr);
+  return visitor->visit_and (expr);
 }
 
 int
@@ -281,7 +269,7 @@ TAO_Property_Constraint::~TAO_Property_Constraint (void)
 }
 
 int
-TAO_Property_Constraint::accept(TAO_Constraint_Visitor* visitor)
+TAO_Property_Constraint::accept (TAO_Constraint_Visitor* visitor)
 {
   return visitor->visit_property (this);
 }
@@ -310,7 +298,7 @@ TAO_Literal_Constraint (CORBA::Any* any)
   TAO_CHECK_ENV_RETURN_VOID (env);
 
   this->type_ = TAO_Literal_Constraint::comparable_type (type.in ());
-  switch(this->type_)
+  switch (this->type_)
     {
     case TAO_SIGNED:
       this->op_.integer_ = 0;
@@ -318,7 +306,7 @@ TAO_Literal_Constraint (CORBA::Any* any)
 	{
 	  CORBA::Short sh;
 	  any_ref >>= sh;
-	  this->op_.integer_ = (CORBA::Long)sh;
+	  this->op_.integer_ = (CORBA::Long) sh;
 	}
       else
 	any_ref >>= this->op_.integer_;
@@ -329,7 +317,7 @@ TAO_Literal_Constraint (CORBA::Any* any)
 	{
 	  CORBA::UShort sh;
 	  any_ref >>= sh;
-	  this->op_.uinteger_ = (CORBA::ULong)sh;
+	  this->op_.uinteger_ = (CORBA::ULong) sh;
 	}
       else
 	any_ref >>= this->op_.uinteger_;
@@ -338,25 +326,25 @@ TAO_Literal_Constraint (CORBA::Any* any)
       if (corba_type == CORBA::tk_float)
 	{
 	  CORBA::Float fl;
-	  (*any) >>= fl;
-	  this->op_.double_ = (CORBA::Double)fl;
+          (*any) >>= fl;
+	  this->op_.double_ = (CORBA::Double) fl;
 	}
       else
-	(*any) >>= this->op_.double_;
+        (*any) >>= this->op_.double_;
       break;
     case TAO_BOOLEAN:
       {
-	CORBA_Any::to_boolean tmp(this->op_.bool_);
-	(*any) >>= tmp;
+	CORBA_Any::to_boolean tmp (this->op_.bool_);
+        (*any) >>= tmp;
       }
-      break;
+    break;
     case TAO_STRING:
       {
 	char* s;
 	any_ref >>= s;
 	this->op_.str_ = CORBA::string_dup (s);
       }
-      break;
+    break;
     case TAO_SEQUENCE:
       this->op_.any_ = any;
     }
@@ -401,7 +389,7 @@ TAO_Literal_Constraint::~TAO_Literal_Constraint (void)
 int
 TAO_Literal_Constraint::accept (TAO_Constraint_Visitor* visitor)
 {
-  return visitor->visit_literal(this);
+  return visitor->visit_literal (this);
 }
 
 void
@@ -423,13 +411,13 @@ TAO_Literal_Constraint::operator CORBA::ULong (void) const
     return_value = this->op_.uinteger_;
   else if (this->type_ == TAO_SIGNED)
     return_value =
-      (this->op_.integer_ > 0) ? (CORBA::ULong)this->op_.integer_ : 0;
+      (this->op_.integer_ > 0) ? (CORBA::ULong) this->op_.integer_ : 0;
   else if (this->type_ == TAO_DOUBLE)
     return_value =
       (this->op_.double_ > 0) ?
       ((this->op_.double_ > MAX_UNSIGNED_INTEGER) ?
        MAX_UNSIGNED_INTEGER :
-       (CORBA::ULong)this->op_.double_)
+       (CORBA::ULong) this->op_.double_)
       : 0;
 
   return return_value;
@@ -450,10 +438,10 @@ TAO_Literal_Constraint::operator CORBA::Long (void) const
       (this->op_.double_ > 0) ?
       ((this->op_.double_ > MAX_SIGNED_INTEGER) ?
        MAX_SIGNED_INTEGER :
-       (CORBA::Long)this->op_.double_) :
+       (CORBA::Long) this->op_.double_) :
     ((this->op_.double_ < MIN_SIGNED_INTEGER) ?
      MIN_SIGNED_INTEGER :
-     (CORBA::Long)this->op_.double_);
+     (CORBA::Long) this->op_.double_);
 
   return return_value;
 }
@@ -465,9 +453,9 @@ TAO_Literal_Constraint::operator CORBA::Double (void) const
   if (this->type_ == TAO_DOUBLE)
     return_value = this->op_.double_;
   else if (this->type_ == TAO_SIGNED)
-    return_value = (CORBA::Double)this->op_.integer_;
+    return_value = (CORBA::Double) this->op_.integer_;
   else if (this->type_ == TAO_UNSIGNED)
-    return_value = (CORBA::Double)this->op_.uinteger_;
+    return_value = (CORBA::Double) this->op_.uinteger_;
 
   return return_value;
 }
@@ -524,7 +512,7 @@ TAO_Literal_Constraint::comparable_type (CORBA::TypeCode_ptr type)
 	if (kind == CORBA::tk_sequence)
 	  return_value = TAO_SEQUENCE;
       }
-      break;
+    break;
     default:
       return_value = TAO_UNKNOWN;
     }
@@ -538,24 +526,24 @@ operator== (const TAO_Literal_Constraint& left,
 {
   int return_value = 0;
   TAO_Expression_Type widest_type =
-    TAO_Literal_Constraint::widest_type(left, right);
+    TAO_Literal_Constraint::widest_type (left, right);
 
   switch (widest_type)
     {
     case TAO_STRING:
-      return_value = (ACE_OS::strcmp((const char*)left, (const char*)right) == 0);
+      return_value = (ACE_OS::strcmp ((const char*) left, (const char*) right) == 0);
       break;
     case TAO_DOUBLE:
-      return_value = (CORBA::Double)left == (CORBA::Double)right;
+      return_value = (CORBA::Double) left == (CORBA::Double) right;
       break;
     case TAO_SIGNED:
-      return_value = (CORBA::Long)left == (CORBA::Long)right;
+      return_value = (CORBA::Long) left == (CORBA::Long) right;
       break;
     case TAO_UNSIGNED:
-      return_value = (CORBA::ULong)left == (CORBA::ULong)right;
+      return_value = (CORBA::ULong) left == (CORBA::ULong) right;
       break;
     case TAO_BOOLEAN:
-      return_value = (CORBA::Boolean)left == (CORBA::Boolean)right;
+      return_value = (CORBA::Boolean) left == (CORBA::Boolean) right;
       break;
     }
 
@@ -569,24 +557,24 @@ operator!= (const TAO_Literal_Constraint& left,
 {
   int return_value = 0;
   TAO_Expression_Type widest_type =
-    TAO_Literal_Constraint::widest_type(left, right);
+    TAO_Literal_Constraint::widest_type (left, right);
 
   switch (widest_type)
     {
     case TAO_STRING:
-      return_value = (ACE_OS::strcmp((const char*)left, (const char*)right) != 0);
+      return_value = (ACE_OS::strcmp ((const char*) left, (const char*) right) != 0);
       break;
     case TAO_DOUBLE:
-      return_value = (CORBA::Double)left != (CORBA::Double)right;
+      return_value = (CORBA::Double) left != (CORBA::Double) right;
       break;
     case TAO_SIGNED:
-      return_value = (CORBA::Long)left != (CORBA::Long)right;
+      return_value = (CORBA::Long) left != (CORBA::Long) right;
       break;
     case TAO_UNSIGNED:
-      return_value = (CORBA::ULong)left != (CORBA::ULong)right;
+      return_value = (CORBA::ULong) left != (CORBA::ULong) right;
       break;
     case TAO_BOOLEAN:
-      return_value = (CORBA::Boolean)left != (CORBA::Boolean)right;
+      return_value = (CORBA::Boolean) left != (CORBA::Boolean) right;
       break;
     }
 
@@ -599,21 +587,21 @@ operator< (const TAO_Literal_Constraint& left,
 {
   int return_value = 0;
   TAO_Expression_Type widest_type =
-    TAO_Literal_Constraint::widest_type(left, right);
+    TAO_Literal_Constraint::widest_type (left, right);
 
   switch (widest_type)
     {
     case TAO_STRING:
-      return_value = (ACE_OS::strcmp((const char*)left, (const char*)right) < 0);
+      return_value = (ACE_OS::strcmp ((const char*) left, (const char*) right) < 0);
       break;
     case TAO_DOUBLE:
-      return_value = (CORBA::Double)left < (CORBA::Double)right;
+      return_value = (CORBA::Double) left < (CORBA::Double) right;
       break;
     case TAO_SIGNED:
-      return_value = (CORBA::Long)left < (CORBA::Long)right;
+      return_value = (CORBA::Long) left < (CORBA::Long) right;
       break;
     case TAO_UNSIGNED:
-      return_value = (CORBA::ULong)left < (CORBA::ULong)right;
+      return_value = (CORBA::ULong) left < (CORBA::ULong) right;
       break;
     case TAO_BOOLEAN:
       return_value = (CORBA::Boolean) left < (CORBA::Boolean) right;
@@ -629,21 +617,21 @@ operator<= (const TAO_Literal_Constraint& left,
 {
   int return_value = 0;
   TAO_Expression_Type widest_type =
-    TAO_Literal_Constraint::widest_type(left, right);
+    TAO_Literal_Constraint::widest_type (left, right);
 
   switch (widest_type)
     {
     case TAO_STRING:
-      return_value = (ACE_OS::strcmp((const char*)left, (const char*)right) <= 0);
+      return_value = (ACE_OS::strcmp ((const char*) left, (const char*) right) <= 0);
       break;
     case TAO_DOUBLE:
-      return_value = (CORBA::Double)left <= (CORBA::Double)right;
+      return_value = (CORBA::Double) left <= (CORBA::Double) right;
       break;
     case TAO_SIGNED:
-      return_value = (CORBA::Long)left <= (CORBA::Long)right;
+      return_value = (CORBA::Long) left <= (CORBA::Long) right;
       break;
     case TAO_UNSIGNED:
-      return_value = (CORBA::ULong)left <= (CORBA::ULong)right;
+      return_value = (CORBA::ULong) left <= (CORBA::ULong) right;
       break;
     }
 
@@ -656,21 +644,21 @@ operator> (const TAO_Literal_Constraint& left,
 {
   int return_value = 0;
   TAO_Expression_Type widest_type =
-    TAO_Literal_Constraint::widest_type(left, right);
+    TAO_Literal_Constraint::widest_type (left, right);
 
   switch (widest_type)
     {
     case TAO_STRING:
-      return_value = (ACE_OS::strcmp((const char*)left, (const char*)right) > 0);
+      return_value = (ACE_OS::strcmp ((const char*) left, (const char*) right) > 0);
       break;
     case TAO_DOUBLE:
-      return_value = (CORBA::Double)left > (CORBA::Double)right;
+      return_value = (CORBA::Double) left > (CORBA::Double) right;
       break;
     case TAO_SIGNED:
-      return_value = (CORBA::Long)left > (CORBA::Long)right;
+      return_value = (CORBA::Long) left > (CORBA::Long) right;
       break;
     case TAO_UNSIGNED:
-      return_value = (CORBA::ULong)left > (CORBA::ULong)right;
+      return_value = (CORBA::ULong) left > (CORBA::ULong) right;
       break;
     }
 
@@ -683,21 +671,21 @@ operator>= (const TAO_Literal_Constraint& left,
 {
   int return_value = 0;
   TAO_Expression_Type widest_type =
-    TAO_Literal_Constraint::widest_type(left, right);
+    TAO_Literal_Constraint::widest_type (left, right);
 
   switch (widest_type)
     {
     case TAO_STRING:
-      return_value = (ACE_OS::strcmp((const char*)left, (const char*)right) >= 0);
+      return_value = (ACE_OS::strcmp ((const char*) left, (const char*) right) >= 0);
       break;
     case TAO_DOUBLE:
-      return_value = (CORBA::Double)left >= (CORBA::Double)right;
+      return_value = (CORBA::Double) left >= (CORBA::Double) right;
       break;
     case TAO_SIGNED:
-      return_value = (CORBA::Long)left >= (CORBA::Long)right;
+      return_value = (CORBA::Long) left >= (CORBA::Long) right;
       break;
     case TAO_UNSIGNED:
-      return_value = (CORBA::ULong)left >= (CORBA::ULong)right;
+      return_value = (CORBA::ULong) left >= (CORBA::ULong) right;
       break;
     }
 
@@ -717,9 +705,9 @@ operator== (const TAO_String_Manager& left,
 {
   int result =  0;
 
-  if ((const char*)right != 0)
+  if ((const char*) right != 0)
     result = ACE_OS::strcmp ((const char*) left,
-			     (const char*) right) == 0;
+ (const char*) right) == 0;
   return result;
 }
 
@@ -729,27 +717,27 @@ operator+ (const TAO_Literal_Constraint& left,
 	   const TAO_Literal_Constraint& right)
 {
   TAO_Expression_Type widest_type =
-    TAO_Literal_Constraint::widest_type(left, right);
+    TAO_Literal_Constraint::widest_type (left, right);
 
   switch (widest_type)
     {
     case TAO_DOUBLE:
       {
-	CORBA::Double result = (CORBA::Double)left + (CORBA::Double)right;
-	return TAO_Literal_Constraint((CORBA::Double)result);
+	CORBA::Double result = (CORBA::Double) left + (CORBA::Double) right;
+	return TAO_Literal_Constraint ((CORBA::Double) result);
       }
     case TAO_SIGNED:
       {
-	CORBA::Long result = (CORBA::Long)left + (CORBA::Long)right;
-	return TAO_Literal_Constraint((CORBA::Long)result);
+	CORBA::Long result = (CORBA::Long) left + (CORBA::Long) right;
+	return TAO_Literal_Constraint ((CORBA::Long) result);
       }
     case TAO_UNSIGNED:
       {
-	CORBA::ULong result = (CORBA::ULong)left + (CORBA::ULong)right;
-	return TAO_Literal_Constraint((CORBA::ULong)result);
+	CORBA::ULong result = (CORBA::ULong) left + (CORBA::ULong) right;
+	return TAO_Literal_Constraint ((CORBA::ULong) result);
       }
     default:
-      return TAO_Literal_Constraint((CORBA::Long)0);
+      return TAO_Literal_Constraint ((CORBA::Long)0);
     }
 }
 
@@ -758,27 +746,27 @@ operator- (const TAO_Literal_Constraint& left,
 	   const TAO_Literal_Constraint& right)
 {
   TAO_Expression_Type widest_type =
-    TAO_Literal_Constraint::widest_type(left, right);
+    TAO_Literal_Constraint::widest_type (left, right);
 
   switch (widest_type)
     {
     case TAO_DOUBLE:
       {
-	CORBA::Double result = (CORBA::Double)left - (CORBA::Double)right;
-	return TAO_Literal_Constraint((CORBA::Double)result);
+	CORBA::Double result = (CORBA::Double) left - (CORBA::Double) right;
+	return TAO_Literal_Constraint ((CORBA::Double) result);
       }
     case TAO_SIGNED:
       {
-	CORBA::Long result = (CORBA::Long)left - (CORBA::Long)right;
-	return TAO_Literal_Constraint((CORBA::Long)result);
+	CORBA::Long result = (CORBA::Long) left - (CORBA::Long) right;
+	return TAO_Literal_Constraint ((CORBA::Long) result);
       }
     case TAO_UNSIGNED:
       {
-	CORBA::ULong result = (CORBA::ULong)left - (CORBA::ULong)right;
-	return TAO_Literal_Constraint((CORBA::ULong)result);
+	CORBA::ULong result = (CORBA::ULong) left - (CORBA::ULong) right;
+	return TAO_Literal_Constraint ((CORBA::ULong) result);
       }
     default:
-      return TAO_Literal_Constraint((CORBA::Long)0);
+      return TAO_Literal_Constraint ((CORBA::Long)0);
     }
 }
 
@@ -787,27 +775,27 @@ operator* (const TAO_Literal_Constraint& left,
 	   const TAO_Literal_Constraint& right)
 {
   TAO_Expression_Type widest_type =
-    TAO_Literal_Constraint::widest_type(left, right);
+    TAO_Literal_Constraint::widest_type (left, right);
 
   switch (widest_type)
     {
     case TAO_DOUBLE:
       {
-	CORBA::Double result = (CORBA::Double)left * (CORBA::Double)right;
-	return TAO_Literal_Constraint((CORBA::Double)result);
+	CORBA::Double result = (CORBA::Double) left * (CORBA::Double) right;
+	return TAO_Literal_Constraint ((CORBA::Double) result);
       }
     case TAO_SIGNED:
       {
-	CORBA::Long result = (CORBA::Long)left * (CORBA::Long)right;
-	return TAO_Literal_Constraint((CORBA::Long)result);
+	CORBA::Long result = (CORBA::Long) left * (CORBA::Long) right;
+	return TAO_Literal_Constraint ((CORBA::Long) result);
       }
     case TAO_UNSIGNED:
       {
-	CORBA::ULong result = (CORBA::ULong)left * (CORBA::ULong)right;
-	return TAO_Literal_Constraint((CORBA::ULong)result);
+	CORBA::ULong result = (CORBA::ULong) left * (CORBA::ULong) right;
+	return TAO_Literal_Constraint ((CORBA::ULong) result);
       }
     default:
-      return TAO_Literal_Constraint((CORBA::Long)0);
+      return TAO_Literal_Constraint ((CORBA::Long)0);
     }
 }
 
@@ -816,27 +804,27 @@ operator/ (const TAO_Literal_Constraint& left,
 	   const TAO_Literal_Constraint& right)
 {
   TAO_Expression_Type widest_type =
-    TAO_Literal_Constraint::widest_type(left, right);
+    TAO_Literal_Constraint::widest_type (left, right);
 
   switch (widest_type)
     {
     case TAO_DOUBLE:
       {
-	CORBA::Double result = (CORBA::Double)left / (CORBA::Double)right;
-	return TAO_Literal_Constraint((CORBA::Double)result);
+	CORBA::Double result = (CORBA::Double) left / (CORBA::Double) right;
+	return TAO_Literal_Constraint ((CORBA::Double) result);
       }
     case TAO_SIGNED:
       {
-	CORBA::Long result = (CORBA::Long)left / (CORBA::Long)right;
-	return TAO_Literal_Constraint((CORBA::Long)result);
+	CORBA::Long result = (CORBA::Long) left / (CORBA::Long) right;
+	return TAO_Literal_Constraint ((CORBA::Long) result);
       }
     case TAO_UNSIGNED:
       {
-	CORBA::ULong result = (CORBA::ULong)left / (CORBA::ULong)right;
-	return TAO_Literal_Constraint((CORBA::ULong)result);
+	CORBA::ULong result = (CORBA::ULong) left / (CORBA::ULong) right;
+	return TAO_Literal_Constraint ((CORBA::ULong) result);
       }
     default:
-      return TAO_Literal_Constraint((CORBA::Long)0);
+      return TAO_Literal_Constraint ((CORBA::Long)0);
     }
 }
 
@@ -847,21 +835,21 @@ operator- (const TAO_Literal_Constraint& operand)
     {
     case TAO_DOUBLE:
       {
-	CORBA::Double result = - (CORBA::Double)operand;
-	return TAO_Literal_Constraint((CORBA::Double)result);
+	CORBA::Double result = - (CORBA::Double) operand;
+	return TAO_Literal_Constraint ((CORBA::Double) result);
       }
     case TAO_SIGNED:
       {
-	CORBA::Long result = - (CORBA::Long)operand;
-	return TAO_Literal_Constraint((CORBA::Long)result);
+	CORBA::Long result = - (CORBA::Long) operand;
+	return TAO_Literal_Constraint ((CORBA::Long) result);
       }
     case TAO_UNSIGNED:
       {
-	CORBA::Long result = - (CORBA::Long)((CORBA::ULong)operand);
-	return TAO_Literal_Constraint((CORBA::ULong)result);
+	CORBA::Long result = - (CORBA::Long) ((CORBA::ULong) operand);
+	return TAO_Literal_Constraint ((CORBA::ULong) result);
       }
     default:
-      return TAO_Literal_Constraint((CORBA::Long)0);
+      return TAO_Literal_Constraint ((CORBA::Long)0);
     }
 }
 
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.cpp b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.cpp
index d2b6009b262..7da2f2ffab9 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.cpp
@@ -1,28 +1,11 @@
 // $Id$
 
-// ========================================================================
-//
-// = LIBRARY
-//    orbsvcs
-//
-// = FILENAME
-//    Constraint_Visitors.cpp
-//
-// = AUTHOR
-//    Seth Widoff <sbw1@cs.wustl.edu>
-//
-// ========================================================================
-
 #include "Constraint_Visitors.h"
 #include "Constraint_Nodes.h"
 #include "Trader_T.h"
 
 ACE_RCSID(Trader, Constraint_Visitors, "$Id$")
 
-  // *************************************************************
-  // TAO_Constraint_Evaluator
-  // *************************************************************
-
 TAO_Constraint_Evaluator::Operand_Queue::Operand_Queue (void)
 {
 }
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.h b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.h
index bf74dfdcb14..82bede14505 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Constraint_Visitors.h
@@ -1,7 +1,7 @@
 /* -*- C++ -*- */
+// $Id$
 
 // ========================================================================
-// $Id$
 //
 // = LIBRARY
 //    orbsvcs
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Offer_Database.h b/TAO/orbsvcs/orbsvcs/Trader/Offer_Database.h
index 7edebd44946..cd4d00e03bd 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Offer_Database.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Offer_Database.h
@@ -1,7 +1,7 @@
 /* -*- C++ -*- */
+// $Id$
 
 // ========================================================================
-// $Id$
 //
 // = LIBRARY
 //    orbsvcs
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators.cpp b/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators.cpp
index 670a6d28e1b..bfdbb5ac779 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators.cpp
@@ -1,17 +1,4 @@
-// ========================================================================
 // $Id$
-//
-// = LIBRARY
-//    orbsvcs
-//
-// = FILENAME
-//   Offer_Iterators.cpp
-//
-// = AUTHOR
-//    Marina Spivak <marina@cs.wustl.edu>
-//    Seth Widoff <sbw1@cs.wustl.edu>
-//
-// ========================================================================
 
 #include "Offer_Iterators.h"
 
@@ -31,7 +18,7 @@ TAO_Offer_Iterator::~TAO_Offer_Iterator (void)
 }
 
 void
-TAO_Offer_Iterator::destroy (CORBA::Environment &)
+TAO_Offer_Iterator::destroy (CORBA::Environment &ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // Remove self from POA
@@ -40,27 +27,23 @@ TAO_Offer_Iterator::destroy (CORBA::Environment &)
   // much about errors here anyway
   //
 
-  TAO_TRY
+  ACE_TRY
     {
-      PortableServer::POA_var poa = this->_default_POA (TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+      PortableServer::POA_var poa = this->_default_POA (ACE_TRY_ENV);
+      ACE_CHECK_ENV;
 
-      PortableServer::ObjectId_var id = poa->servant_to_id (this, TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+      PortableServer::ObjectId_var id = poa->servant_to_id (this, ACE_TRY_ENV);
+      ACE_CHECK_ENV;
 
-      poa->deactivate_object (id.in (), TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+      poa->deactivate_object (id.in (), ACE_TRY_ENV);
+      ACE_CHECK_ENV;
     }
-  TAO_CATCHANY
+  ACE_CATCHANY
     {
     }
-  TAO_ENDTRY;
+  ACE_ENDTRY;
 }
 
-  // *************************************************************
-  // TAO_Query_Only_Offer_Iterator
-  // *************************************************************
-
 TAO_Query_Only_Offer_Iterator::
 TAO_Query_Only_Offer_Iterator(const TAO_Property_Filter& pfilter)
   : TAO_Offer_Iterator (pfilter)
@@ -111,10 +94,6 @@ TAO_Query_Only_Offer_Iterator::next_n (CORBA::ULong n,
   return offers_in_sequence != 0;
 }
 
-  // *************************************************************
-  // TAO_Offer_Iterator_Collection
-  // *************************************************************
-
 TAO_Offer_Iterator_Collection::TAO_Offer_Iterator_Collection (void)
 {
 }
@@ -126,15 +105,17 @@ TAO_Offer_Iterator_Collection::~TAO_Offer_Iterator_Collection (void)
       CosTrading::OfferIterator* offer_iter;
       this->iters_.dequeue_head (offer_iter);
 
-      TAO_TRY
+      ACE_TRY
         {
-          offer_iter->destroy (TAO_TRY_ENV);
-          TAO_CHECK_ENV;
+          offer_iter->destroy (ACE_TRY_ENV);
+          ACE_CHECK_ENV;
 
           CORBA::release (offer_iter);
         }
-      TAO_CATCHANY {}
-      TAO_ENDTRY;
+      ACE_CATCHANY 
+        {
+        }
+      ACE_ENDTRY;
     }
 }
 
@@ -149,14 +130,17 @@ add_offer_iterator (CosTrading::OfferIterator_ptr offer_iter)
 CORBA::Boolean
 TAO_Offer_Iterator_Collection::next_n (CORBA::ULong n,
                                        CosTrading::OfferSeq_out offers,
-                                       CORBA::Environment &env)
+                                       CORBA::Environment &ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   CORBA::ULong offers_left = n;
   CORBA::Boolean return_value = 1;
   CosTrading::OfferSeq_var out_offers;
 
-  ACE_NEW_RETURN (offers, CosTrading::OfferSeq, return_value);
+  ACE_NEW_RETURN (offers,
+                  CosTrading::OfferSeq,
+                  return_value);
+
   while (offers_left > 0 && ! this->iters_.is_empty ())
     {
       CORBA::ULong offset = 0;
@@ -167,14 +151,14 @@ TAO_Offer_Iterator_Collection::next_n (CORBA::ULong n,
       // Determine how many offers we should retrieve from this
       // iterator.
 
-      TAO_TRY
+      ACE_TRY
         {
           // Retrieve the set of offers.
           any_left =
             iter->next_n (offers_left,
                           CosTrading::OfferSeq_out (out_offers.out ()),
-                          TAO_TRY_ENV);
-          TAO_CHECK_ENV;
+                          ACE_TRY_ENV);
+          ACE_CHECK_ENV;
 
           // If we've exhausted this iterator, destroy it.
           if (any_left == 0)
@@ -193,10 +177,10 @@ TAO_Offer_Iterator_Collection::next_n (CORBA::ULong n,
 
           offers_left -= out_offers->length ();
         }
-      TAO_CATCHANY
+      ACE_CATCHANY
         {
         }
-      TAO_ENDTRY;
+      ACE_ENDTRY;
     }
 
   // Determine if we have anything left to offer.
@@ -207,7 +191,7 @@ TAO_Offer_Iterator_Collection::next_n (CORBA::ULong n,
 }
 
 void
-TAO_Offer_Iterator_Collection::destroy (CORBA::Environment& TAO_IN_ENV)
+TAO_Offer_Iterator_Collection::destroy (CORBA::Environment& ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // Destroy all iterators in the collection.
@@ -218,44 +202,39 @@ TAO_Offer_Iterator_Collection::destroy (CORBA::Environment& TAO_IN_ENV)
       CosTrading::OfferIterator** iter = 0;
 
       iters_iter.next (iter);
-      (*iter)->destroy (TAO_IN_ENV);
+      (*iter)->destroy (ACE_TRY_ENV);
     }
 
   // Remove self from POA
   //
   // Note that there is no real error checking here as we can't do
   // much about errors here anyway
-  //
 
-  TAO_TRY
+  ACE_TRY
     {
-      PortableServer::POA_var poa = this->_default_POA (TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+      PortableServer::POA_var poa = this->_default_POA (ACE_TRY_ENV);
+      ACE_CHECK_ENV;
       PortableServer::ObjectId_var id =
-        poa->servant_to_id (this, TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+        poa->servant_to_id (this, ACE_TRY_ENV);
+      ACE_CHECK_ENV;
 
-      poa->deactivate_object (id.in (), TAO_TRY_ENV);
+      poa->deactivate_object (id.in (), ACE_TRY_ENV);
     }
-  TAO_CATCHANY
+  ACE_CATCHANY
     {
     }
-  TAO_ENDTRY;
+  ACE_ENDTRY;
 }
 
 CORBA::ULong
-TAO_Offer_Iterator_Collection::max_left (CORBA::Environment &TAO_IN_ENV)
+TAO_Offer_Iterator_Collection::max_left (CORBA::Environment &ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException,
                    CosTrading::UnknownMaxLeft))
 {
-  TAO_THROW_RETURN (CosTrading::UnknownMaxLeft(), 0);
+  ACE_THROW_RETURN (CosTrading::UnknownMaxLeft(),
+                    0);
 }
 
-  // *************************************************************
-  // TAO_Offer_Id_Iterator
-  // *************************************************************
-
-
 TAO_Offer_Id_Iterator::TAO_Offer_Id_Iterator (void)
 {
 }
@@ -284,7 +263,7 @@ TAO_Offer_Id_Iterator::max_left (CORBA::Environment &)
 }
 
 void
-TAO_Offer_Id_Iterator::destroy (CORBA::Environment &)
+TAO_Offer_Id_Iterator::destroy (CORBA::Environment &ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // Remove self from POA
@@ -293,21 +272,21 @@ TAO_Offer_Id_Iterator::destroy (CORBA::Environment &)
   // much about errors here anyway
   //
 
-  TAO_TRY
+  ACE_TRY
     {
-      PortableServer::POA_var poa = this->_default_POA (TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+      PortableServer::POA_var poa = this->_default_POA (ACE_TRY_ENV);
+      ACE_CHECK_ENV;
 
-      PortableServer::ObjectId_var id = poa->servant_to_id (this, TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+      PortableServer::ObjectId_var id = poa->servant_to_id (this, ACE_TRY_ENV);
+      ACE_CHECK_ENV;
 
-      poa->deactivate_object (id.in (), TAO_TRY_ENV);
-      TAO_CHECK_ENV;
+      poa->deactivate_object (id.in (), ACE_TRY_ENV);
+      ACE_CHECK_ENV;
     }
-  TAO_CATCHANY
+  ACE_CATCHANY
     {
     }
-  TAO_ENDTRY;
+  ACE_ENDTRY;
 }
 
 CORBA::Boolean
@@ -323,9 +302,9 @@ TAO_Offer_Id_Iterator::next_n (CORBA::ULong n,
   CORBA::Boolean return_value = (CORBA::Boolean) (difference > 0);
 
   if (returnable_items == 0)
-    {
-      ACE_NEW_RETURN (_ids, CosTrading::OfferIdSeq, return_value);
-    }
+    ACE_NEW_RETURN (_ids,
+                    CosTrading::OfferIdSeq,
+                    return_value);
   else
     {
       // Allocate space for the returned OfferIds.
@@ -352,7 +331,9 @@ TAO_Offer_Id_Iterator::next_n (CORBA::ULong n,
 			  return_value);
 	}
       else
-	ACE_NEW_RETURN (_ids, CosTrading::OfferIdSeq, return_value);
+	ACE_NEW_RETURN (_ids,
+                        CosTrading::OfferIdSeq,
+                        return_value);
     }
 
   // Return true only if there are items left to be returned in
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators.h b/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators.h
index c5cd1c2448d..544058cc546 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators.h
@@ -1,7 +1,7 @@
 /* -*- C++ -*- */
+// $Id$
 
 // ============================================================================
-// $Id$
 //
 // = LIBRARY
 //    orbsvcs
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators_T.cpp b/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators_T.cpp
index 4c56d53b3e9..48d099c9170 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators_T.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators_T.cpp
@@ -1,17 +1,4 @@
-// ============================================================================
 // $Id$
-//
-// = LIBRARY
-//    orbsvcs
-//
-// = FILENAME
-//    Offer_Iterators_T.cpp
-//
-// = AUTHOR
-//    Marina Spivak <marina@cs.wustl.edu>
-//    Seth Widoff <sbw1@cs.wustl.edu>
-//    Irfan Pyarali <irfan@cs.wustl.edu>
-// ============================================================================
 
 #ifndef TAO_OFFER_ITERATORS_T_C
 #define  TAO_OFFER_ITERATORS_T_C
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators_T.h b/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators_T.h
index 1af30631650..e2f21ef876f 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators_T.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Offer_Iterators_T.h
@@ -1,7 +1,7 @@
 /* -*- C++ -*- */
+// $Id$
 
 // ========================================================================
-// $Id$
 //
 // = LIBRARY
 //    orbsvcs
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.cpp b/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.cpp
index a9386747480..f0f9a6353db 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.cpp
@@ -1,18 +1,4 @@
-// ========================================================================
-//
 // $Id$
-//
-// = LIBRARY
-//    orbsvcs
-//
-// = FILENAME
-//   Service_Type_Repository.cpp
-//
-// = AUTHOR
-//    Marina Spivak <marina@cs.wustl.edu>
-//    Seth Widoff <sbw1@cs.wustl.edu>
-//
-// ========================================================================
 
 #include "Locking.h"
 #include "Service_Type_Repository.h"
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.h b/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.h
index ebb9b61f7f4..396a0881bc4 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Service_Type_Repository.h
@@ -1,6 +1,7 @@
 /* -*- C++ -*- */
-// ========================================================================
 // $Id$
+
+// ========================================================================
 //
 // = LIBRARY
 //    orbsvcs
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader.cpp b/TAO/orbsvcs/orbsvcs/Trader/Trader.cpp
index 5c857ff1a1e..9d581a91432 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader.cpp
@@ -1,17 +1,4 @@
-// ============================================================================
 // $Id$
-//
-// = LIBRARY
-//    orbsvcs
-//
-// = FILENAME
-//    Trader_Base.cpp
-//
-// = AUTHOR
-//    Irfan Pyarali <irfan@cs.wustl.edu>
-//    Seth Widoff <sbw1@cs.wustl.edu>
-//
-// ============================================================================
 
 #include "Trader.h"
 #include "Offer_Iterators_T.h"
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader.h b/TAO/orbsvcs/orbsvcs/Trader/Trader.h
index 48ee2779794..99acbc7f2ea 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader.h
@@ -1,7 +1,7 @@
 /* -*- C++ -*- */
+// $Id$
 
 // ============================================================================
-// $Id$
 //
 // = LIBRARY
 //    orbsvcs
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.cpp b/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.cpp
index 204fa50d5a9..053fd42c3a4 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.cpp
@@ -1,17 +1,4 @@
-// ========================================================================
 // $Id$
-//
-// = LIBRARY
-//    orbsvcs
-//
-// = FILENAME
-//    Trader_Interfaces.cpp
-//
-// = AUTHOR
-//    Marina Spivak <marina@cs.wustl.edu>
-//    Seth Widoff <sbw1@cs.wustl.edu>
-//
-// ========================================================================
 
 #if !defined (TAO_TRADER_INTERFACES_C)
 #define TAO_TRADER_INTERFACES_C
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.h b/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.h
index 00561a27cf0..5c375a4c06e 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader_Interfaces.h
@@ -1,7 +1,7 @@
 /* -*- C++ -*- */
+// $Id$
 
 // ========================================================================
-// $Id$
 //
 // = LIBRARY
 //    orbsvcs
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader_T.cpp b/TAO/orbsvcs/orbsvcs/Trader/Trader_T.cpp
index 7c7f450d024..8369be5c652 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader_T.cpp
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader_T.cpp
@@ -1,18 +1,4 @@
-// ============================================================================
 // $Id$
-//
-// = LIBRARY
-//    orbsvcs
-//
-// = FILENAME
-//    Trader.cpp
-//
-// = AUTHOR
-//    Marina Spivak <marina@cs.wustl.edu>
-//    Seth Widoff <sbw1@cs.wustl.edu>
-//    Irfan Pyarali <irfan@cs.wustl.edu>
-//
-// ============================================================================
 
 #ifndef TAO_TRADER_C
 #define TAO_TRADER_C
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader_T.h b/TAO/orbsvcs/orbsvcs/Trader/Trader_T.h
index ca513621416..fac6e20a948 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader_T.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader_T.h
@@ -1,7 +1,7 @@
 /* -*- C++ -*- */
+// $Id$
 
 // ========================================================================
-// $Id$
 //
 // = LIBRARY
 //    orbsvcs
diff --git a/TAO/orbsvcs/orbsvcs/Trader/Trader_Utils.h b/TAO/orbsvcs/orbsvcs/Trader/Trader_Utils.h
index 962eea88816..2b768f69707 100644
--- a/TAO/orbsvcs/orbsvcs/Trader/Trader_Utils.h
+++ b/TAO/orbsvcs/orbsvcs/Trader/Trader_Utils.h
@@ -1,7 +1,7 @@
 /* -*- C++ -*- */
+// $Id$
 
 // ========================================================================
-// $Id$
 //
 // = LIBRARY
 //    orbsvcs