ChangeLogTag:Fri Mar 2 21:42:54 UTC 2007 Ossama Othman <ossama_othman at symantec dot com>

10 files changed, 151 insertions, 58 deletions

diff --git a/ACE/ChangeLog b/ACE/ChangeLog
index b6d1f9e9383..dfd25230a4a 100644
--- a/ACE/ChangeLog
+++ b/ACE/ChangeLog
@@ -1,3 +1,50 @@
+Fri Mar  2 21:42:54 UTC 2007  Ossama Othman  <ossama_othman at symantec dot com>
+
+        * ace/Basic_Types.h (ACE_UINT64_MAX):
+
+          Corrected value for the ACE_LACKS_{UNSIGNED}LONG_LONG_T case.
+
+          (ACE_U64_TO_U32, ACE_CU64_TO_CU32):
+
+          Converted these macros to inlined functions.
+
+          (ACE_LONGLONG_TO_PTR):
+
+          Cast pointer to intptr_t instead of ptrdiff_t before casting
+          to the pointer type.  The ptrdiff_t type  is meant for pointer
+          differences.
+
+        * ace/High_Res_Timer.cpp (dump):
+
+          Drop ACE_CU64_TO_CU32 macro in favor of standard static_cast<>.
+          There was no real use for that macro in this case.
+
+        * ace/Numeric_Limits.h (ACE_Numeric_Limits):
+
+          Added a specialization for ACE_U_LongLong.
+
+        * ace/Sample_History.cpp (dump_samples):
+
+          Removed unnecessary cast to 32 bit value.
+
+          Corrected Log_Msg format specifier for unsigned type.
+
+        * ace/Time_Value.cpp (operator*=):
+        * tests/Time_Value_Test.cpp (run_main):
+
+          Removed ACE_LACKS_NUMERIC_LIMITS preprocessor conditional.  Use
+          ACE_Numeric_Limits<> instead.  It is always available.
+
+        * ace/Time_Value.h (to_usec):
+        * ace/Time_Value.inl (to_usec):
+
+          Enabled support for this method when ACE_LACKS_LONGLONG_T is
+          defined.
+
+        * ace/UUID.cpp (get_systemtime):
+
+          Fixed support for ACE_U_LongLong type.
+
 Fri Mar  2 20:48:45 UTC 2007  Steve Huston  <shuston@riverace.com>
 
         * ACE-INSTALL.html: Improved the description of using Pharlap ETS and
diff --git a/ACE/ace/Basic_Types.h b/ACE/ace/Basic_Types.h
index ec2ca3cc2ad..aeb749b1886 100644
--- a/ACE/ace/Basic_Types.h
+++ b/ACE/ace/Basic_Types.h
@@ -440,7 +440,7 @@ ACE_END_VERSIONED_NAMESPACE_DECL
   reinterpret_cast<PTR_TYPE> (L.lo ())
 #else  /* ! ACE_LACKS_LONGLONG_T */
 # define ACE_LONGLONG_TO_PTR(PTR_TYPE, L) \
-  reinterpret_cast<PTR_TYPE> (static_cast<ptrdiff_t> (L))
+  reinterpret_cast<PTR_TYPE> (static_cast<intptr_t> (L))
 #endif /* ! ACE_LACKS_LONGLONG_T */
 
 // If the platform lacks an unsigned long long, define one.
@@ -613,7 +613,7 @@ ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 
     // @note  the above four accessors are inlined here in
     // order to minimize the extent of the data_ struct.  It's
-    // only used here; the .i and .cpp files use the accessors.
+    // only used here; the .inl and .cpp files use the accessors.
 
     /// These functions are used to implement multiplication.
     ACE_UINT32 ul_shift (ACE_UINT32 a,
@@ -641,17 +641,43 @@ ACE_END_VERSIONED_NAMESPACE_DECL
 
 # endif /* ACE_LACKS_LONGLONG_T */
 
+ACE_BEGIN_VERSIONED_NAMESPACE_DECL
+
 // Conversions from ACE_UINT64 to ACE_UINT32.  ACE_CU64_TO_CU32 should
 // be used on const ACE_UINT64's.
 # if defined (ACE_LACKS_LONGLONG_T) || defined (ACE_LACKS_UNSIGNEDLONGLONG_T)
-#   define ACE_U64_TO_U32(n) ((n).lo ())
-#   define ACE_CU64_TO_CU32(n) ((n).lo ())
+inline ACE_UINT32
+ACE_U64_TO_U32 (ACE_U_LongLong const & n)
+{
+  /**
+   * @note We could add a cast operator to ACE_U_LongLong but that may
+   *       cause more problems than it solves.  Force users to perform
+   *       an explicit cast via ACE_{C}U64_TO_{C}U32.
+   */
+  return n.lo ();
+}
+
+inline ACE_UINT32
+ACE_CU64_TO_CU32 (ACE_U_LongLong const & n)
+{
+  return ACE_U64_TO_U32 (n);
+}
 # else  /* ! ACE_LACKS_LONGLONG_T */
-#   define ACE_U64_TO_U32(n) (static_cast<ACE_UINT32> (n))
-#   define ACE_CU64_TO_CU32(n) \
-     (static_cast<ACE_CAST_CONST ACE_UINT32> (n))
+inline ACE_UINT32
+ACE_U64_TO_U32 (ACE_UINT64 n)
+{
+  return static_cast<ACE_UINT32> (n);
+}
+
+inline ACE_UINT32
+ACE_CU64_TO_CU32 (ACE_UINT64 n)
+{
+  return static_cast<ACE_UINT32> (n);
+}
 # endif /* ! ACE_LACKS_LONGLONG_T */
 
+ACE_END_VERSIONED_NAMESPACE_DECL
+
 // 64-bit literals require special marking on some platforms.
 # if defined (ACE_LACKS_LONGLONG_T)
     // Can only specify 32-bit arguments.
@@ -836,7 +862,19 @@ ACE_END_VERSIONED_NAMESPACE_DECL
 #define ACE_UINT32_MAX 0xFFFFFFFF
 #define ACE_INT64_MAX ACE_INT64_LITERAL(0x7FFFFFFFFFFFFFFF)
 #define ACE_INT64_MIN -(ACE_INT64_MAX)-1
-#define ACE_UINT64_MAX ACE_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)
+
+#if defined (ACE_LACKS_LONGLONG_T) || defined (ACE_LACKS_UNSIGNEDLONGLONG_T)
+# if defined (ACE_LACKS_UNSIGNEDLONGLONG_T)
+// ACE_U_LongLong's constructor accepts a "long long" in this
+// case.
+#  define ACE_UINT64_MAX ACE_U_LongLong (0xFFFFFFFFFFFFFFFF);
+# else
+// ACE_U_LongLong's constructor accepts an ACE_UINT32 low and high
+// pair of parameters.
+#  define ACE_UINT64_MAX ACE_U_LongLong (0xFFFFFFFFu, 0xFFFFFFFFu);
+# endif  /* ACE_LACKS_UNSIGNEDLONGLONG_T */
+#endif  /* ACE_LACKS_LONGLONG_T || defined ACE_LACKS_UNSIGNEDLONGLONG_T */
+
 // These use ANSI/IEEE format.
 #define ACE_FLT_MAX 3.402823466e+38F
 #define ACE_FLT_MIN 1.175494351e-38F
diff --git a/ACE/ace/High_Res_Timer.cpp b/ACE/ace/High_Res_Timer.cpp
index 12714786bed..832da28c8ca 100644
--- a/ACE/ace/High_Res_Timer.cpp
+++ b/ACE/ace/High_Res_Timer.cpp
@@ -328,18 +328,18 @@ ACE_High_Res_Timer::dump (void) const
              start_incr_.hi (), start_incr_.lo ()));
 #else  /* ! ACE_LACKS_LONGLONG_T */
   ACE_DEBUG ((LM_DEBUG,
-             ACE_LIB_TEXT (":\nstart_.hi ():     %8x; start_.lo ():      %8x;\n")
-             ACE_LIB_TEXT ("end_.hi ():       %8x; end_.lo ():        %8x;\n")
-             ACE_LIB_TEXT ("total_.hi ():     %8x; total_.lo ():      %8x;\n")
-             ACE_LIB_TEXT ("start_incr_.hi () %8x; start_incr_.lo (): %8x;\n"),
-             ACE_CU64_TO_CU32 (start_ >> 32),
-             ACE_CU64_TO_CU32 (start_ & 0xfffffffful),
-             ACE_CU64_TO_CU32 (end_ >> 32),
-             ACE_CU64_TO_CU32 (end_ & 0xfffffffful),
-             ACE_CU64_TO_CU32 (total_ >> 32),
-             ACE_CU64_TO_CU32 (total_ & 0xfffffffful),
-             ACE_CU64_TO_CU32 (start_incr_ >> 32),
-             ACE_CU64_TO_CU32 (start_incr_ & 0xfffffffful)));
+              ACE_LIB_TEXT (":\nstart_.hi ():     %8x; start_.lo ():      %8x;\n")
+              ACE_LIB_TEXT ("end_.hi ():       %8x; end_.lo ():        %8x;\n")
+              ACE_LIB_TEXT ("total_.hi ():     %8x; total_.lo ():      %8x;\n")
+              ACE_LIB_TEXT ("start_incr_.hi () %8x; start_incr_.lo (): %8x;\n"),
+              static_cast<ACE_UINT32> (start_ >> 32),
+              static_cast<ACE_UINT32> (start_ & 0xfffffffful),
+              static_cast<ACE_UINT32> (end_ >> 32),
+              static_cast<ACE_UINT32> (end_ & 0xfffffffful),
+              static_cast<ACE_UINT32> (total_ >> 32),
+              static_cast<ACE_UINT32> (total_ & 0xfffffffful),
+              static_cast<ACE_UINT32> (start_incr_ >> 32),
+              static_cast<ACE_UINT32> (start_incr_ & 0xfffffffful)));
 #endif /* ! ACE_LACKS_LONGLONG_T */
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 #endif /* ACE_HAS_DUMP */
diff --git a/ACE/ace/Numeric_Limits.h b/ACE/ace/Numeric_Limits.h
index 863c576059e..4fbac9d2768 100644
--- a/ACE/ace/Numeric_Limits.h
+++ b/ACE/ace/Numeric_Limits.h
@@ -52,6 +52,11 @@
 #  undef max
 # endif  /* __MINGW32__ */
 
+# if defined (ACE_LACKS_LONGLONG_T) || defined (ACE_LACKS_UNSIGNEDLONGLONG_T)
+// For ACE_U_LongLong.
+#  include "ace/Basic_Types.h"
+# endif  /* ACE_LACKS_LONGLONG_T || ACE_LACKS_UNSIGNEDLONGLONG_T */
+
 # include <limits>
 #endif /* ACE_LACKS_NUMERIC_LIMITS */
 
@@ -234,20 +239,29 @@ struct ACE_Numeric_Limits
 template<>
 struct ACE_Numeric_Limits<LONGLONG>
 {
-   static LONGLONG min (void) { return _I64_MIN; }
-   static LONGLONG max (void) { return _I64_MAX; }
+  static LONGLONG min (void) { return _I64_MIN; }
+  static LONGLONG max (void) { return _I64_MAX; }
 };
 
 template<>
 struct ACE_Numeric_Limits<ULONGLONG>
 {
-   static ULONGLONG min (void) { return 0; }
-   static ULONGLONG max (void) { return _UI64_MAX; }
+  static ULONGLONG min (void) { return 0; }
+  static ULONGLONG max (void) { return _UI64_MAX; }
 };
 # endif  /* ACE_WIN64 && _MSC_VER <= 1310 */
 
 #endif /* ACE_LACKS_NUMERIC_LIMITS */
 
+#if defined (ACE_LACKS_LONGLONG_T) || defined (ACE_LACKS_UNSIGNEDLONGLONG_T)
+template<>
+struct ACE_Numeric_Limits<ACE_U_LongLong>
+{
+  static ACE_U_LongLong min (void) { return ACE_U_LongLong (); /* 0 */ }
+  static ACE_U_LongLong max (void) { return ACE_UINT64_MAX; }
+};
+#endif  /* ACE_LACKS_LONGLONG_T || defined ACE_LACKS_UNSIGNEDLONGLONG_T */
+
 ACE_END_VERSIONED_NAMESPACE_DECL
 
 #include /**/ "ace/post.h"
diff --git a/ACE/ace/Sample_History.cpp b/ACE/ace/Sample_History.cpp
index 832029e4dde..08639223cb8 100644
--- a/ACE/ace/Sample_History.cpp
+++ b/ACE/ace/Sample_History.cpp
@@ -46,9 +46,14 @@ ACE_Sample_History::dump_samples (const ACE_TCHAR *msg,
 #ifndef ACE_NLOGGING
   for (size_t i = 0; i != this->sample_count_; ++i)
     {
-      const ACE_UINT64 x = this->samples_[i] / scale_factor;
-      const ACE_UINT32 val = ACE_CU64_TO_CU32 (x);
-      ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("%s: %d %u\n"), msg, i, val));
+      const ACE_UINT64 val = this->samples_[i] / scale_factor;
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_LIB_TEXT ("%s: ")
+                  ACE_SIZE_T_FORMAT_SPECIFIER
+                  ACE_LIB_TEXT ("%Q\n"),
+                  msg,
+                  i,
+                  val));
     }
 #else
   ACE_UNUSED_ARG (msg);
diff --git a/ACE/ace/Time_Value.cpp b/ACE/ace/Time_Value.cpp
index 61b64c3b5b4..bc8f6218159 100644
--- a/ACE/ace/Time_Value.cpp
+++ b/ACE/ace/Time_Value.cpp
@@ -219,13 +219,8 @@ ACE_Time_Value::operator *= (double d)
      + static_cast<double> (this->usec ()) / ACE_ONE_SECOND_IN_USECS) * d;
 
   // shall we saturate the result?
-#if !defined(ACE_LACKS_NUMERIC_LIMITS)
-  static const double max_int = std::numeric_limits<time_t>::max () + 0.999999;
-  static const double min_int = std::numeric_limits<time_t>::min () - 0.999999;
-#else
-  static const double max_int = LONG_MAX + 0.999999;
-  static const double min_int = LONG_MIN - 0.999999;
-#endif
+  static const double max_int = ACE_Numeric_Limits<time_t>::max () + 0.999999;
+  static const double min_int = ACE_Numeric_Limits<time_t>::min () - 0.999999;
 
   if (time_total > max_int)
     time_total = max_int;
diff --git a/ACE/ace/Time_Value.h b/ACE/ace/Time_Value.h
index 1c1af92b4ff..eb67dba429c 100644
--- a/ACE/ace/Time_Value.h
+++ b/ACE/ace/Time_Value.h
@@ -193,15 +193,12 @@ public:
   /// Set microseconds.
   void usec (suseconds_t usec);
 
-#if !defined (ACE_LACKS_LONGLONG_T)
   /**
    * @return Sum of second field (in microseconds) and microsecond field
    *         and return them via the @param usec parameter.
    */
   void to_usec (ACE_UINT64 &usec) const;
 
-#endif /*ACE_LACKS_LONGLONG_T */
-
   // = The following arithmetic methods operate on ACE_Time_Value's.
 
   /// Add @a tv to this.
diff --git a/ACE/ace/Time_Value.inl b/ACE/ace/Time_Value.inl
index 28ac34fa9f1..c42ec35a9ce 100644
--- a/ACE/ace/Time_Value.inl
+++ b/ACE/ace/Time_Value.inl
@@ -193,16 +193,20 @@ ACE_Time_Value::usec (suseconds_t usec)
   this->tv_.tv_usec = usec;
 }
 
-#if !defined (ACE_LACKS_LONGLONG_T)
 ACE_INLINE void
-ACE_Time_Value::to_usec (ACE_UINT64 &usec) const
+ACE_Time_Value::to_usec (ACE_UINT64 & usec) const
 {
   // ACE_OS_TRACE ("ACE_Time_Value::to_usec");
+
+#ifdef ACE_LACKS_LONGLONG_T
+  // No native 64-bit type, meaning time_t is most likely 32 bits.
+  usec = ACE_U_LongLong (this->tv_.tv_sec);
+#else
   usec = static_cast<ACE_UINT64> (this->tv_.tv_sec);
+#endif  /* ACE_LACKS_LONG_LONG_T */
   usec *= 1000000;
   usec += this->tv_.tv_usec;
 }
-#endif /*ACE_LACKS_LONGLONG_T*/
 
 ACE_INLINE ACE_Time_Value
 operator * (double d, const ACE_Time_Value &tv)
diff --git a/ACE/ace/UUID.cpp b/ACE/ace/UUID.cpp
index b6454dd9db8..62fbed45e4e 100644
--- a/ACE/ace/UUID.cpp
+++ b/ACE/ace/UUID.cpp
@@ -469,7 +469,14 @@ namespace ACE_Utils
   void
   UUID_Generator::get_systemtime (UUID_time & timestamp)
   {
-    const UUID_time timeOffset = ACE_UINT64_LITERAL (0x1B21DD213814000);
+    const UUID_time timeOffset =
+#if defined (ACE_LACKS_UNSIGNEDLONGLONG_T)
+      ACE_U_LongLong (0x1B21DD213814000);
+#elif defined (ACE_LACKS_LONGLONG_T)
+      ACE_U_LongLong (0x13814000u, 0x1B21DD2u);
+#else
+      ACE_UINT64_LITERAL (0x1B21DD213814000);
+#endif  /* ACE_LACKS_LONG_LONG_T */
 
     /// Get the time of day, convert to 100ns ticks then add the offset.
     ACE_Time_Value now = ACE_OS::gettimeofday();
diff --git a/ACE/tests/Time_Value_Test.cpp b/ACE/tests/Time_Value_Test.cpp
index 865bbb7d265..91c62c35f19 100644
--- a/ACE/tests/Time_Value_Test.cpp
+++ b/ACE/tests/Time_Value_Test.cpp
@@ -49,16 +49,7 @@ ACE_RCSID(tests, Time_Value_Test, "$Id$")
 #include "ace/ACE.h"
 #include "ace/Time_Value.h"
 
-#if !defined(ACE_LACKS_NUMERIC_LIMITS)
-// some platforms pollute the namespace by defining max() and min() macros
-#ifdef max
-#undef max
-#endif
-#ifdef min
-#undef min
-#endif
-#include <limits>
-#endif /* ACE_LACKS_NUMERIC_LIMITS */
+#include "ace/Numeric_Limits.h"
 
 #if defined (sun) && !defined (ACE_LACKS_LONGLONG_T)
 static
@@ -252,13 +243,8 @@ run_main (int, ACE_TCHAR *[])
   tv1 *= -10.0;
   ACE_ASSERT (tv1.sec () == tv2.sec () && tv1.usec () == tv2.usec ());
 
-#if !defined(ACE_LACKS_NUMERIC_LIMITS)
-  const time_t max_time_t = std::numeric_limits<time_t>::max ();
-  const time_t min_time_t = std::numeric_limits<time_t>::min ();
-#else
-  const time_t max_time_t = LONG_MAX;
-  const time_t min_time_t = LONG_MIN;
-#endif
+  const time_t max_time_t = ACE_Numeric_Limits<time_t>::max ();
+  const time_t min_time_t = ACE_Numeric_Limits<time_t>::min ();
 
   // test results near limits
   tv1.set ((max_time_t >> 1), 499999);