1) replaced ACE_HAS_LONGLONG_T with ACE_LACKS_LONGLONG_T. 2) fixed operator/, and added operator% and operator-- to ACE_U_LongLong

2 files changed, 101 insertions, 80 deletions

diff --git a/ace/Basic_Types.h b/ace/Basic_Types.h
index 747200b6e95..de62f8c73ad 100644
--- a/ace/Basic_Types.h
+++ b/ace/Basic_Types.h
@@ -113,7 +113,8 @@
 #if defined (ACE_WIN32)
 #   define ACE_SIZEOF_LONG_LONG 8
     typedef unsigned __int64 ACE_UINT64;
-#elif defined (ULLONG_MAX) && ! defined (__GNUG__)
+#elif defined (ULLONG_MAX) && !defined (__GNUG__) && \
+      !defined (ACE_LACKS_LONGLONG_T)
 # if (ULLONG_MAX) == 18446744073709551615ULL
 #   define ACE_SIZEOF_LONG_LONG 8
 #   if ACE_SIZEOF_INT != 8 && ACE_SIZEOF_LONG != 8
@@ -130,7 +131,7 @@
 # else
 #   error: unsupported long long size, must be updated for this platform!
 # endif /* ULLONG_MAX */
-#elif defined (ULONGLONG_MAX)
+#elif defined (ULONGLONG_MAX) && !defined (ACE_LACKS_LONGLONG_T)
   // Irix 6.x, for example.
 # if (ULONGLONG_MAX) == 18446744073709551615ULL
 #   define ACE_SIZEOF_LONG_LONG 8
@@ -140,25 +141,9 @@
 # else
 #   error: unsupported long long size, must be updated for this platform!
 # endif /* ULLONG_MAX */
-#else /* ! ACE_WIN32 && ! ULLONG_MAX && ! ULONGLONG_MAX */
-# if defined (ACE_HAS_LONGLONG_T)
-  // Assume 8-byte long longs.  It would be better to #define
-  // ACE_HAS_LONGLONG_T to the number of bytes in a long,
-  // but we'd have to do that consistently in all config files.
-#   define ACE_SIZEOF_LONG_LONG 8
-#   if ACE_SIZEOF_INT != 8 && ACE_SIZEOF_LONG != 8
-#     if defined (sun)
-        // sun #defines u_longlong_t, maybe other platforms do also.
-        // Use it, at least with g++, so that its -pedantic doesn't
-        // complain about no ANSI C++ long long.
-        typedef u_longlong_t ACE_UINT64;
-#     else
-        // LynxOS 2.5.0 and Linux don't have u_longlong_t.
-        typedef unsigned long long ACE_UINT64;
-#     endif /* __GNUG__ && sun */
-#   endif /* ACE_SIZEOF_INT != 8 && ACE_SIZEOF_LONG != 8 */
-# else /* ! ACE_HAS_LONGLONG_T */
-
+#else /* ! ACE_WIN32 || (! ULLONG_MAX || __GNUG__) || ! ULONGLONG_MAX ||
+         ACE_LACKS_LONGLONG_T */
+# if defined (ACE_LACKS_LONGLONG_T)
     class ACE_Export ACE_U_LongLong
       // = TITLE
       //     Unsigned long long for platforms that don't have one.
@@ -192,14 +177,16 @@
       ACE_U_LongLong operator- (const ACE_U_LongLong &) const;
 
       // Note that the following take ACE_UINT32 arguments.  These are
-      // typical use cases, and easy to implement.  But, they're very
-      // limited in the ranges of values that they can handle.
+      // typical use cases, and easy to implement.  But, they limit
+      // the return values to 32 bits as well.  There are no checks
+      // for overflow.
       ACE_UINT32 operator/ (const ACE_UINT32) const;
-      // ACE_UINT32 operator% (const ACE_UINT32) const;
+      ACE_UINT32 operator% (const ACE_UINT32) const;
 
       ACE_U_LongLong &operator+= (const ACE_U_LongLong &);
-      ACE_U_LongLong &operator++ ();
       ACE_U_LongLong &operator-= (const ACE_U_LongLong &);
+      ACE_U_LongLong &operator++ ();
+      ACE_U_LongLong &operator-- ();
 
       // = Helper methods.
       void output (FILE * = stdout) const;
@@ -223,8 +210,23 @@
 #   if ACE_SIZEOF_INT != 8 && ACE_SIZEOF_LONG != 8
       typedef ACE_U_LongLong ACE_UINT64;
 #   endif /* ACE_SIZEOF_INT != 8 && ACE_SIZEOF_LONG != 8 */
-# endif /* ! ACE_HAS_LONGLONG_T */
-#endif /* ! ACE_WIN32 && ! ULLONG_MAX && ! ULONGLONG_MAX */
+# else /* ! ACE_LACKS_LONGLONG_T */
+    // Assume that the platform has 8-byte long longs.
+#   define ACE_SIZEOF_LONG_LONG 8
+#   if ACE_SIZEOF_INT != 8 && ACE_SIZEOF_LONG != 8
+#     if defined (sun)
+        // sun #defines u_longlong_t, maybe other platforms do also.
+        // Use it, at least with g++, so that its -pedantic doesn't
+        // complain about no ANSI C++ long long.
+        typedef u_longlong_t ACE_UINT64;
+#     else
+        // LynxOS 2.5.0 and Linux don't have u_longlong_t.
+        typedef unsigned long long ACE_UINT64;
+#     endif /* sun */
+#   endif /* ACE_SIZEOF_INT != 8 && ACE_SIZEOF_LONG != 8 */
+# endif /* ! ACE_LACKS_LONGLONG_T */
+#endif /* ! ACE_WIN32 || (! ULLONG_MAX || __GNUG__) || ! ULONGLONG_MAX ||
+          ACE_LACKS_LONGLONG_T */
 
 // The number of bytes in a void *.
 #define ACE_SIZEOF_VOID_P ACE_SIZEOF_LONG
diff --git a/ace/Basic_Types.i b/ace/Basic_Types.i
index 37f1b0c0730..e2d938e1af6 100644
--- a/ace/Basic_Types.i
+++ b/ace/Basic_Types.i
@@ -39,104 +39,124 @@ ACE_U_LongLong::~ACE_U_LongLong (void)
 }
 
 ACE_INLINE int
-ACE_U_LongLong::operator== (const ACE_U_LongLong &ll) const
+ACE_U_LongLong::operator== (const ACE_U_LongLong &n) const
 {
-  return hi_ == ll.hi_  &&  lo_ == ll.lo_;
+  return hi_ == n.hi_  &&  lo_ == n.lo_;
 }
 
 ACE_INLINE int
-ACE_U_LongLong::operator!= (const ACE_U_LongLong &ll) const
+ACE_U_LongLong::operator!= (const ACE_U_LongLong &n) const
 {
-  return ! (*this == ll);
+  return ! (*this == n);
 }
 
 ACE_INLINE int
-ACE_U_LongLong::operator< (const ACE_U_LongLong &ll) const
+ACE_U_LongLong::operator< (const ACE_U_LongLong &n) const
 {
-  return hi_ < ll.hi_ ? 1
-                      : hi_ > ll.hi_ ? 0
-                                     : lo_ < ll.lo_;
+  return hi_ < n.hi_ ? 1
+                     : hi_ > n.hi_ ? 0
+                                   : lo_ < n.lo_;
 }
 
 ACE_INLINE int
-ACE_U_LongLong::operator<= (const ACE_U_LongLong &ll) const
+ACE_U_LongLong::operator<= (const ACE_U_LongLong &n) const
 {
-  return hi_ < ll.hi_ ? 1
-                      : hi_ > ll.hi_ ? 0
-                                     : lo_ <= ll.lo_;
+  return hi_ < n.hi_ ? 1
+                     : hi_ > n.hi_ ? 0
+                                   : lo_ <= n.lo_;
 }
 
 ACE_INLINE int
-ACE_U_LongLong::operator> (const ACE_U_LongLong &ll) const
+ACE_U_LongLong::operator> (const ACE_U_LongLong &n) const
 {
-  return hi_ > ll.hi_ ? 1
-                      : hi_ < ll.hi_ ? 0
-                                     : lo_ > ll.lo_;
+  return hi_ > n.hi_ ? 1
+                     : hi_ < n.hi_ ? 0
+                                   : lo_ > n.lo_;
 }
 
 ACE_INLINE int
-ACE_U_LongLong::operator>= (const ACE_U_LongLong &ll) const
+ACE_U_LongLong::operator>= (const ACE_U_LongLong &n) const
 {
-  return hi_ > ll.hi_ ? 1
-                      : hi_ < ll.hi_ ? 0
-                                     : lo_ >= ll.lo_;
+  return hi_ > n.hi_ ? 1
+                     : hi_ < n.hi_ ? 0
+                                   : lo_ >= n.lo_;
 }
 
 ACE_INLINE
-ACE_U_LongLong::ACE_U_LongLong (const ACE_U_LongLong &ll)
-  : hi_ (ll.hi_),
-    lo_ (ll.lo_)
+ACE_U_LongLong::ACE_U_LongLong (const ACE_U_LongLong &n)
+  : hi_ (n.hi_),
+    lo_ (n.lo_)
 {
 }
 
 ACE_INLINE ACE_U_LongLong &
-ACE_U_LongLong::operator= (const ACE_U_LongLong &ll)
+ACE_U_LongLong::operator= (const ACE_U_LongLong &n)
 {
-  hi_ = ll.hi_;
-  lo_ = ll.lo_;
+  hi_ = n.hi_;
+  lo_ = n.lo_;
   return *this;
 }
 
 ACE_INLINE ACE_U_LongLong
-ACE_U_LongLong::operator+ (const ACE_U_LongLong &ll) const
+ACE_U_LongLong::operator+ (const ACE_U_LongLong &n) const
 {
-  ACE_U_LongLong ret (lo_ + ll.lo_, hi_ + ll.hi_);
-  if (ret.lo_ < ll.lo_) /* carry */ ++ret.hi_;
+  ACE_U_LongLong ret (lo_ + n.lo_, hi_ + n.hi_);
+  if (ret.lo_ < n.lo_) /* carry */ ++ret.hi_;
   return ret;
 }
 
 ACE_INLINE ACE_U_LongLong
-ACE_U_LongLong::operator- (const ACE_U_LongLong &ll) const
+ACE_U_LongLong::operator- (const ACE_U_LongLong &n) const
 {
-  ACE_U_LongLong ret (lo_ - ll.lo_, hi_ - ll.hi_);
-  if (lo_ < ll.lo_) /* borrow */ --ret.hi_;
+  ACE_U_LongLong ret (lo_ - n.lo_, hi_ - n.hi_);
+  if (lo_ < n.lo_) /* borrow */ --ret.hi_;
   return ret;
 }
 
 ACE_INLINE ACE_UINT32
-ACE_U_LongLong::operator/ (const ACE_UINT32 ul) const
+ACE_U_LongLong::operator/ (const ACE_UINT32 n) const
 {
-  // This assumes integer division, so it's not always very accurate:
-  // Quotient = (hi_ * (ULONG_MAX + 1) + lo_) / ul
-  //          = (hi_ * ULONG_MAX + hi_ + lo_) / ul
-  //          = hi_ * (ULONG_MAX / ul)  +  (hi_ + lo_) / ul
-  return hi_ * (ULONG_MAX / ul)  +  (hi_ + lo_) / ul;
+  // This takes advantage of the fact that the return type has only 32
+  // bits.  Replace 0x100000000 with 0xffffffff + 1 because the latter
+  // has 33 bits.
+  // Quotient = (0x100000000u * hi_ + lo_) / n
+  //          = ((0x100000000u - n + n) * hi_ + lo_) / n
+  //          = ((0x100000000u - n) / n * hi_  +  hi_ * n / n  +  lo_ / n
+  //          = (0x100000000u - n) / n * hi_ +  hi_  +  lo_ / n
+  //          = (0xffffffffu - n + 1) / n * hi_ +  hi_  +  lo_ / n
+
+  return (0xffffffffu - n + 1) / n * hi_  +  hi_  +  lo_ / n;
+}
+
+ACE_INLINE ACE_UINT32
+ACE_U_LongLong::operator% (const ACE_UINT32 n) const
+{
+  // Because the argument is an ACE_UINT32, the result can never be
+  // bigger than 32 bits.  Replace 0x100000000 with 0xffffffff + 1
+  // because the latter has 33 bits.
+  // Mod = (0x100000000u * hi_ + lo_) % n
+  //     = (0x100000000u % n * hi_  +  lo_ % n) % n
+  //     = ((0x100000000u - n) % n * hi_  +  lo_ % n) % n
+  //     = ((0xffffffffu - n + 1) % n * hi_  +  lo_ % n) % n
+
+  return ((0xffffffff - n + 1)  % n * hi_  +  lo_ % n) % n;
 }
 
-// ACE_INLINE ACE_UINT32
-// ACE_U_LongLong::operator% (const ACE_UINT32 ul) const
-// {
-//   // Just return lo_ portion.  Because the argument is an ACE_UINT32,
-//   // the result can never be bigger than 32 bits.
-//   return (*this  -  (ACE_U_LongLong) (*this / ul * ul)).lo_;
-// }
+ACE_INLINE ACE_U_LongLong &
+ACE_U_LongLong::operator+= (const ACE_U_LongLong &n)
+{
+  hi_ += n.hi_;
+  lo_ += n.lo_;
+  if (lo_ < n.lo_) /* carry */ ++hi_;
+  return *this;
+}
 
 ACE_INLINE ACE_U_LongLong &
-ACE_U_LongLong::operator+= (const ACE_U_LongLong &ll)
+ACE_U_LongLong::operator-= (const ACE_U_LongLong &n)
 {
-  hi_ += ll.hi_;
-  lo_ += ll.lo_;
-  if (lo_ < ll.lo_) /* carry */ ++hi_;
+  hi_ -= n.hi_;
+  if (lo_ < n.lo_) /* borrow */ --hi_;
+  lo_ -= n.lo_;
   return *this;
 }
 
@@ -149,11 +169,10 @@ ACE_U_LongLong::operator++ ()
 }
 
 ACE_INLINE ACE_U_LongLong &
-ACE_U_LongLong::operator-= (const ACE_U_LongLong &ll)
+ACE_U_LongLong::operator-- ()
 {
-  hi_ -= ll.hi_;
-  if (lo_ < ll.lo_) /* borrow */ --hi_;
-  lo_ -= ll.lo_;
+  if (lo_ == 0) /* borrow */ --hi_;
+  --lo_;
   return *this;
 }