ChangeLogTag:Thu Feb 20 09:01:55 2003 Ossama Othman <ossama@uci.edu>

1 files changed, 208 insertions, 108 deletions

diff --git a/ace/CDR_Base.cpp b/ace/CDR_Base.cpp
index c01c3e40039..64f1e3472f4 100644
--- a/ace/CDR_Base.cpp
+++ b/ace/CDR_Base.cpp
@@ -1,7 +1,3 @@
-// -*- C++ -*-
-//
-// $Id$
-
 #include "ace/CDR_Base.h"
 #include "ace/Message_Block.h"
 
@@ -9,11 +5,12 @@
 # include "ace/CDR_Base.inl"
 #endif /* ! __ACE_INLINE__ */
 
-ACE_RCSID(ace, CDR_Base, "$Id$")
-
+ACE_RCSID (ace,
+           CDR_Base,
+           "$Id$")
 
 //
-// See comments in CDR_Base.i about optimization cases for swap_XX_array.
+// See comments in CDR_Base.inl about optimization cases for swap_XX_array.
 //
 
 void
@@ -24,7 +21,7 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
   // Later, we try to read in 32 or 64 bit chunks,
   // so make sure we don't do that for unaligned addresses.
 #if ACE_SIZEOF_LONG == 8
-  const char* const o8 = ACE_ptr_align_binary(orig, 8);
+  const char* const o8 = ACE_ptr_align_binary (orig, 8);
   while (orig < o8 && n > 0)
     {
       ACE_CDR::swap_2 (orig, target);
@@ -33,7 +30,7 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
       --n;
     }
 #else
-  const char* const o4 = ACE_ptr_align_binary(orig, 4);
+  const char* const o4 = ACE_ptr_align_binary (orig, 4);
   // this is an _if_, not a _while_. The mistmatch can only be by 2.
   if (orig != o4)
     {
@@ -54,28 +51,28 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
   // In the while loop ahead, orig will move over the array by 8 byte
   // increments (4 elements of 2 bytes).
   // end marks our barrier for not falling outside.
-  const char* const end = orig + 2*(n & (~3));
+  const char* const end = orig + 2 * (n & (~3));
 
   // See if we're aligned for writting in 64 or 32 bit chunks...
 #if ACE_SIZEOF_LONG == 8
-  if (target == ACE_ptr_align_binary(target, 8))
+  if (target == ACE_ptr_align_binary (target, 8))
 #else
-  if (target == ACE_ptr_align_binary(target, 4))
+  if (target == ACE_ptr_align_binary (target, 4))
 #endif
     {
       while (orig < end)
         {
-#if defined(ACE_HAS_PENTIUM) && defined(__GNUG__)
+#if defined (ACE_HAS_PENTIUM) && defined (__GNUG__)
           unsigned int a =
-            * ACE_reinterpret_cast(const unsigned int*, orig);
+            * ACE_reinterpret_cast (const unsigned int*, orig);
           unsigned int b =
-            * ACE_reinterpret_cast(const unsigned int*, orig + 4);
-          asm( "bswap %1"      : "=r" (a) : "0" (a) );
-          asm( "bswap %1"      : "=r" (b) : "0" (b) );
-          asm( "rol $16, %1"   : "=r" (a) : "0" (a) );
-          asm( "rol $16, %1"   : "=r" (b) : "0" (b) );
-          * ACE_reinterpret_cast(unsigned int*, target) = a;
-          * ACE_reinterpret_cast(unsigned int*, target + 4) = b;
+            * ACE_reinterpret_cast (const unsigned int*, orig + 4);
+          asm ( "bswap %1"      : "=r" (a) : "0" (a) );
+          asm ( "bswap %1"      : "=r" (b) : "0" (b) );
+          asm ( "rol $16, %1"   : "=r" (a) : "0" (a) );
+          asm ( "rol $16, %1"   : "=r" (b) : "0" (b) );
+          * ACE_reinterpret_cast (unsigned int*, target) = a;
+          * ACE_reinterpret_cast (unsigned int*, target + 4) = b;
 #elif defined(ACE_HAS_PENTIUM) \
       && (defined(_MSC_VER) || defined(__BORLANDC__)) \
       && !defined(ACE_LACKS_INLINE_ASSEMBLY)
@@ -92,19 +89,19 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
 #elif ACE_SIZEOF_LONG == 8
           // 64 bit architecture.
           register unsigned long a =
-            * ACE_reinterpret_cast(const unsigned long*, orig);
+            * ACE_reinterpret_cast (const unsigned long*, orig);
 
           register unsigned long a1 = (a & 0x00ff00ff00ff00ffUL) << 8;
           register unsigned long a2 = (a & 0xff00ff00ff00ff00UL) >> 8;
 
           a = (a1 | a2);
 
-          * ACE_reinterpret_cast(unsigned long*, target) = a;
+          * ACE_reinterpret_cast (unsigned long*, target) = a;
 #else
           register ACE_UINT32 a =
-            * ACE_reinterpret_cast(const ACE_UINT32*, orig);
+            * ACE_reinterpret_cast (const ACE_UINT32*, orig);
           register ACE_UINT32 b =
-            * ACE_reinterpret_cast(const ACE_UINT32*, orig + 4);
+            * ACE_reinterpret_cast (const ACE_UINT32*, orig + 4);
 
           register ACE_UINT32 a1 = (a & 0x00ff00ffU) << 8;
           register ACE_UINT32 b1 = (b & 0x00ff00ffU) << 8;
@@ -114,8 +111,8 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
           a = (a1 | a2);
           b = (b1 | b2);
 
-          * ACE_reinterpret_cast(ACE_UINT32*, target) = a;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = b;
+          * ACE_reinterpret_cast (ACE_UINT32*, target) = a;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 4) = b;
 #endif
           orig += 8;
           target += 8;
@@ -126,27 +123,27 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
       // We're out of luck. We have to write in 2 byte chunks.
       while (orig < end)
         {
-#if defined(ACE_HAS_PENTIUM) && defined(__GNUG__)
+#if defined (ACE_HAS_PENTIUM) && defined (__GNUG__)
           unsigned int a =
-            * ACE_reinterpret_cast(const unsigned int*, orig);
+            * ACE_reinterpret_cast (const unsigned int*, orig);
           unsigned int b =
-            * ACE_reinterpret_cast(const unsigned int*, orig + 4);
-          asm( "bswap %1" : "=r" (a) : "0" (a) );
-          asm( "bswap %1" : "=r" (b) : "0" (b) );
+            * ACE_reinterpret_cast (const unsigned int*, orig + 4);
+          asm ( "bswap %1" : "=r" (a) : "0" (a) );
+          asm ( "bswap %1" : "=r" (b) : "0" (b) );
           // We're little endian.
-          * ACE_reinterpret_cast(unsigned short*, target + 2)
+          * ACE_reinterpret_cast (unsigned short*, target + 2)
               = (unsigned short) (a & 0xffff);
-          * ACE_reinterpret_cast(unsigned short*, target + 6)
+          * ACE_reinterpret_cast (unsigned short*, target + 6)
               = (unsigned short) (b & 0xffff);
-          asm( "shrl $16, %1" : "=r" (a) : "0" (a) );
-          asm( "shrl $16, %1" : "=r" (b) : "0" (b) );
-          * ACE_reinterpret_cast(unsigned short*, target + 0)
+          asm ( "shrl $16, %1" : "=r" (a) : "0" (a) );
+          asm ( "shrl $16, %1" : "=r" (b) : "0" (b) );
+          * ACE_reinterpret_cast (unsigned short*, target + 0)
               = (unsigned short) (a & 0xffff);
-          * ACE_reinterpret_cast(unsigned short*, target + 4)
+          * ACE_reinterpret_cast (unsigned short*, target + 4)
               = (unsigned short) (b & 0xffff);
-#elif defined(ACE_HAS_PENTIUM) \
-      && (defined(_MSC_VER) || defined(__BORLANDC__)) \
-      && !defined(ACE_LACKS_INLINE_ASSEMBLY)
+#elif defined (ACE_HAS_PENTIUM) \
+      && (defined (_MSC_VER) || defined (__BORLANDC__)) \
+      && !defined (ACE_LACKS_INLINE_ASSEMBLY)
           __asm mov ecx, orig;
           __asm mov edx, target;
           __asm mov eax, [ecx];
@@ -163,34 +160,34 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
 #elif ACE_SIZEOF_LONG == 8
           // 64 bit architecture.
           register unsigned long a =
-            * ACE_reinterpret_cast(const unsigned long*, orig);
+            * ACE_reinterpret_cast (const unsigned long*, orig);
 
           register unsigned long a1 = (a & 0x00ff00ff00ff00ffUL) << 8;
           register unsigned long a2 = (a & 0xff00ff00ff00ff00UL) >> 8;
 
           a = (a1 | a2);
 
-          ACE_UINT16 b1 = ACE_static_cast(ACE_UINT16, (a >> 48));
-          ACE_UINT16 b2 = ACE_static_cast(ACE_UINT16, ((a >> 32) & 0xffff));
-          ACE_UINT16 b3 = ACE_static_cast(ACE_UINT16, ((a >> 16) & 0xffff));
-          ACE_UINT16 b4 = ACE_static_cast(ACE_UINT16, (a & 0xffff));
+          ACE_UINT16 b1 = ACE_static_cast (ACE_UINT16, (a >> 48));
+          ACE_UINT16 b2 = ACE_static_cast (ACE_UINT16, ((a >> 32) & 0xffff));
+          ACE_UINT16 b3 = ACE_static_cast (ACE_UINT16, ((a >> 16) & 0xffff));
+          ACE_UINT16 b4 = ACE_static_cast (ACE_UINT16, (a & 0xffff));
 
 #if defined(ACE_LITTLE_ENDIAN)
-          * ACE_reinterpret_cast(ACE_UINT16*, target) = b4;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = b3;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = b2;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = b1;
+          * ACE_reinterpret_cast (ACE_UINT16*, target) = b4;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 2) = b3;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 4) = b2;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 6) = b1;
 #else
-          * ACE_reinterpret_cast(ACE_UINT16*, target) = b1;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = b2;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = b3;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = b4;
+          * ACE_reinterpret_cast (ACE_UINT16*, target) = b1;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 2) = b2;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 4) = b3;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 6) = b4;
 #endif
 #else
           register ACE_UINT32 a =
-            * ACE_reinterpret_cast(const ACE_UINT32*, orig);
+            * ACE_reinterpret_cast (const ACE_UINT32*, orig);
           register ACE_UINT32 b =
-            * ACE_reinterpret_cast(const ACE_UINT32*, orig + 4);
+            * ACE_reinterpret_cast (const ACE_UINT32*, orig + 4);
 
           register ACE_UINT32 a1 = (a & 0x00ff00ff) << 8;
           register ACE_UINT32 b1 = (b & 0x00ff00ff) << 8;
@@ -200,21 +197,21 @@ ACE_CDR::swap_2_array (const char* orig, char* target, size_t n)
           a = (a1 | a2);
           b = (b1 | b2);
 
-          ACE_UINT32 c1 = ACE_static_cast(ACE_UINT16, (a >> 16));
-          ACE_UINT32 c2 = ACE_static_cast(ACE_UINT16, (a & 0xffff));
-          ACE_UINT32 c3 = ACE_static_cast(ACE_UINT16, (b >> 16));
-          ACE_UINT32 c4 = ACE_static_cast(ACE_UINT16, (b & 0xffff));
+          ACE_UINT32 c1 = ACE_static_cast (ACE_UINT16, (a >> 16));
+          ACE_UINT32 c2 = ACE_static_cast (ACE_UINT16, (a & 0xffff));
+          ACE_UINT32 c3 = ACE_static_cast (ACE_UINT16, (b >> 16));
+          ACE_UINT32 c4 = ACE_static_cast (ACE_UINT16, (b & 0xffff));
 
 #if defined(ACE_LITTLE_ENDIAN)
-          * ACE_reinterpret_cast(ACE_UINT16*, target) = c2;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = c1;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = c4;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = c3;
+          * ACE_reinterpret_cast (ACE_UINT16*, target) = c2;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 2) = c1;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 4) = c4;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 6) = c3;
 #else
-          * ACE_reinterpret_cast(ACE_UINT16*, target) = c1;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = c2;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = c3;
-          * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = c4;
+          * ACE_reinterpret_cast (ACE_UINT16*, target) = c1;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 2) = c2;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 4) = c3;
+          * ACE_reinterpret_cast (ACE_UINT16*, target + 6) = c4;
 #endif
 #endif
 
@@ -277,9 +274,9 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
       while (orig < end)
         {
           register unsigned long a =
-            * ACE_reinterpret_cast(const long*, orig);
+            * ACE_reinterpret_cast (const long*, orig);
           register unsigned long b =
-            * ACE_reinterpret_cast(const long*, orig + 8);
+            * ACE_reinterpret_cast (const long*, orig + 8);
 
           register unsigned long a84 = (a & 0x000000ff000000ffL) << 24;
           register unsigned long b84 = (b & 0x000000ff000000ffL) << 24;
@@ -293,8 +290,8 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
           a = (a84 | a73 | a62 | a51);
           b = (b84 | b73 | b62 | b51);
 
-          * ACE_reinterpret_cast(long*, target) = a;
-          * ACE_reinterpret_cast(long*, target + 8) = b;
+          * ACE_reinterpret_cast (long*, target) = a;
+          * ACE_reinterpret_cast (long*, target + 8) = b;
 
           orig += 16;
           target += 16;
@@ -306,9 +303,9 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
       while (orig < end)
         {
           register unsigned long a =
-            * ACE_reinterpret_cast(const long*, orig);
+            * ACE_reinterpret_cast (const long*, orig);
           register unsigned long b =
-            * ACE_reinterpret_cast(const long*, orig + 8);
+            * ACE_reinterpret_cast (const long*, orig + 8);
 
           register unsigned long a84 = (a & 0x000000ff000000ffL) << 24;
           register unsigned long b84 = (b & 0x000000ff000000ffL) << 24;
@@ -322,21 +319,21 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
           a = (a84 | a73 | a62 | a51);
           b = (b84 | b73 | b62 | b51);
 
-          ACE_UINT32 c1 = ACE_static_cast(ACE_UINT32, (a >> 32));
-          ACE_UINT32 c2 = ACE_static_cast(ACE_UINT32, (a & 0xffffffff));
-          ACE_UINT32 c3 = ACE_static_cast(ACE_UINT32, (b >> 32));
-          ACE_UINT32 c4 = ACE_static_cast(ACE_UINT32, (b & 0xffffffff));
+          ACE_UINT32 c1 = ACE_static_cast (ACE_UINT32, (a >> 32));
+          ACE_UINT32 c2 = ACE_static_cast (ACE_UINT32, (a & 0xffffffff));
+          ACE_UINT32 c3 = ACE_static_cast (ACE_UINT32, (b >> 32));
+          ACE_UINT32 c4 = ACE_static_cast (ACE_UINT32, (b & 0xffffffff));
 
 #if defined(ACE_LITTLE_ENDIAN)
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 0) = c2;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = c1;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 8) = c4;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 12) = c3;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 0) = c2;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 4) = c1;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 8) = c4;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 12) = c3;
 #else
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 0) = c1;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = c2;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 8) = c3;
-          * ACE_reinterpret_cast(ACE_UINT32*, target + 12) = c4;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 0) = c1;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 4) = c2;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 8) = c3;
+          * ACE_reinterpret_cast (ACE_UINT32*, target + 12) = c4;
 #endif
           orig += 16;
           target += 16;
@@ -349,23 +346,23 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
     {
 #if defined(ACE_HAS_PENTIUM) && defined(__GNUG__)
       register unsigned int a =
-        *ACE_reinterpret_cast(const unsigned int*, orig);
+        *ACE_reinterpret_cast (const unsigned int*, orig);
       register unsigned int b =
-        *ACE_reinterpret_cast(const unsigned int*, orig + 4);
+        *ACE_reinterpret_cast (const unsigned int*, orig + 4);
       register unsigned int c =
-        *ACE_reinterpret_cast(const unsigned int*, orig + 8);
+        *ACE_reinterpret_cast (const unsigned int*, orig + 8);
       register unsigned int d =
-        *ACE_reinterpret_cast(const unsigned int*, orig + 12);
+        *ACE_reinterpret_cast (const unsigned int*, orig + 12);
 
       asm ("bswap %1" : "=r" (a) : "0" (a));
       asm ("bswap %1" : "=r" (b) : "0" (b));
       asm ("bswap %1" : "=r" (c) : "0" (c));
       asm ("bswap %1" : "=r" (d) : "0" (d));
 
-      *ACE_reinterpret_cast(unsigned int*, target) = a;
-      *ACE_reinterpret_cast(unsigned int*, target + 4) = b;
-      *ACE_reinterpret_cast(unsigned int*, target + 8) = c;
-      *ACE_reinterpret_cast(unsigned int*, target + 12) = d;
+      *ACE_reinterpret_cast (unsigned int*, target) = a;
+      *ACE_reinterpret_cast (unsigned int*, target + 4) = b;
+      *ACE_reinterpret_cast (unsigned int*, target + 8) = c;
+      *ACE_reinterpret_cast (unsigned int*, target + 12) = d;
 #elif defined(ACE_HAS_PENTIUM) \
       && (defined(_MSC_VER) || defined(__BORLANDC__)) \
       && !defined(ACE_LACKS_INLINE_ASSEMBLY)
@@ -385,13 +382,13 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
       __asm mov 12[esi], eax
 #else
       register ACE_UINT32 a =
-        * ACE_reinterpret_cast(const ACE_UINT32*, orig);
+        * ACE_reinterpret_cast (const ACE_UINT32*, orig);
       register ACE_UINT32 b =
-        * ACE_reinterpret_cast(const ACE_UINT32*, orig + 4);
+        * ACE_reinterpret_cast (const ACE_UINT32*, orig + 4);
       register ACE_UINT32 c =
-        * ACE_reinterpret_cast(const ACE_UINT32*, orig + 8);
+        * ACE_reinterpret_cast (const ACE_UINT32*, orig + 8);
       register ACE_UINT32 d =
-        * ACE_reinterpret_cast(const ACE_UINT32*, orig + 12);
+        * ACE_reinterpret_cast (const ACE_UINT32*, orig + 12);
 
       // Expect the optimizer reordering this A LOT.
       // We leave it this way for clarity.
@@ -400,10 +397,10 @@ ACE_CDR::swap_4_array (const char* orig, char* target, size_t n)
       c = (c << 24) | ((c & 0xff00) << 8) | ((c & 0xff0000) >> 8) | (c >> 24);
       d = (d << 24) | ((d & 0xff00) << 8) | ((d & 0xff0000) >> 8) | (d >> 24);
 
-      * ACE_reinterpret_cast(ACE_UINT32*, target) = a;
-      * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = b;
-      * ACE_reinterpret_cast(ACE_UINT32*, target + 8) = c;
-      * ACE_reinterpret_cast(ACE_UINT32*, target + 12) = d;
+      * ACE_reinterpret_cast (ACE_UINT32*, target) = a;
+      * ACE_reinterpret_cast (ACE_UINT32*, target + 4) = b;
+      * ACE_reinterpret_cast (ACE_UINT32*, target + 8) = c;
+      * ACE_reinterpret_cast (ACE_UINT32*, target + 12) = d;
 #endif
 
       orig += 16;
@@ -439,7 +436,7 @@ ACE_CDR::swap_8_array (const char* orig, char* target, size_t n)
   const char* const end = orig + 8*n;
   while (orig < end)
     {
-      swap_8(orig, target);
+      swap_8 (orig, target);
       orig += 8;
       target += 8;
     }
@@ -453,12 +450,21 @@ ACE_CDR::swap_16_array (const char* orig, char* target, size_t n)
   const char* const end = orig + 16*n;
   while (orig < end)
     {
-      swap_16(orig, target);
+      swap_16 (orig, target);
       orig += 16;
       target += 16;
     }
 }
 
+void
+ACE_CDR::mb_align (ACE_Message_Block *mb)
+{
+  char *start = ACE_ptr_align_binary (mb->base (),
+                                      ACE_CDR::MAX_ALIGNMENT);
+  mb->rd_ptr (start);
+  mb->wr_ptr (start);
+}
+
 int
 ACE_CDR::grow (ACE_Message_Block *mb, size_t minsize)
 {
@@ -545,6 +551,100 @@ ACE_CDR::LongLong::operator!= (const ACE_CDR::LongLong &rhs) const
 {
   return this->l != rhs.l || this->h != rhs.h;
 }
+
+int
+ACE_CDR::LongLong::operator< (const ACE_CDR::LongLong &rhs) const
+{
+  return this->h < rhs.h && this->l < rhs.l;
+}
+
+int
+ACE_CDR::LongLong::operator<= (const ACE_CDR::LongLong &rhs) const
+{
+  return this->h <= rhs.h && this->l <= rhs.l;
+}
+
+int
+ACE_CDR::LongLong::operator> (const ACE_CDR::LongLong &rhs) const
+{
+  return this->h > rhs.h && this->l > rhs.l;
+}
+
+int
+ACE_CDR::LongLong::operator>= (const ACE_CDR::LongLong &rhs) const
+{
+  return this->h >= rhs.h && this->l >= rhs.l;
+}
+
+int
+ACE_CDR::LongLong::operator== (ACE_INT32 rhs) const
+{
+  // Do the right comparison based on the higher order bits.  Those
+  // bits indicate whether or not this LongLong is positive or
+  // negative.
+  if ((this->h == 0 && rhs >= 0) || (this->h == 0xFFFFFFFF && rhs < 0))
+    return this->l == rhs;
+  else
+    return 0;  // *this and rhs have different signs, or *this
+               // contains value that cannot be represented with 32
+               // bits alone.
+}
+
+int
+ACE_CDR::LongLong::operator!= (ACE_INT32 rhs) const
+{
+  // Do the right comparison based on the higher order bits.  Those
+  // bits indicate whether or not this LongLong is positive or
+  // negative.
+  if ((this->h == 0 && rhs >= 0) || (this->h == 0xFFFFFFFF && rhs < 0))
+    return this->l != rhs;
+  else
+    return 1;  // *this and rhs have different signs, or *this
+               // contains a value that cannot be represented with 32
+               // bits alone.
+}
+
+int
+ACE_CDR::LongLong::operator< (ACE_UINT32 rhs) const
+{
+  if (this->h > 0)
+    return 0;  // 64 bit positive number
+
+  else if (this->h < 0)
+    return 1;  // 64 bit negative number
+
+  else  // this->h == 0
+    return ACE_static_cast (ACE_UINT32, this->l) < rhs;  // 32 bit
+                                                         // positive
+                                                         // number
+}
+
+int
+ACE_CDR::LongLong::operator<= (ACE_UINT32 rhs) const
+{
+
+}
+
+int
+ACE_CDR::LongLong::operator> (ACE_UINT32 rhs) const
+{
+  if (this->h > 0)
+    return 1;  // A positive number with greater than
+
+  else if (this->h < 0)
+    return 0;  // 64 bit negative number
+
+  else  // this->h == 0
+    return ACE_static_cast (ACE_UINT32, this->l) > rhs;  // 32 bit
+                                                         // positive
+                                                         // number
+}
+
+int
+ACE_CDR::LongLong::operator>= (ACE_UINT32 rhs) const
+{
+  return this->l >= rhs;
+}
 #endif /* NONNATIVE_LONGLONG */
 
 #if defined (NONNATIVE_LONGDOUBLE)
@@ -563,22 +663,22 @@ ACE_CDR::LongDouble::operator!= (const ACE_CDR::LongDouble &rhs) const
 
 #if defined(_UNICOS) && !defined(_CRAYMPP)
 // placeholders to get things compiling
-ACE_CDR::Float::Float()
+ACE_CDR::Float::Float (void)
 {
 }
 
-ACE_CDR::Float::Float(const float & init)
+ACE_CDR::Float::Float (const float & /* init */)
 {
 }
 
 ACE_CDR::Float &
-ACE_CDR::Float::operator= (const float &rhs)
+ACE_CDR::Float::operator= (const float & /* rhs */)
 {
   return *this;
 }
 
 int
-ACE_CDR::Float::operator!= (const ACE_CDR::Float &rhs) const
+ACE_CDR::Float::operator!= (const ACE_CDR::Float & /* rhs */) const
 {
   return 0;
 }