ChangeLogTag:Wed Feb 26 18:42:33 2003 Christopher Kohlhoff <chris@kohlhoff.com>

8 files changed, 131 insertions, 7 deletions

diff --git a/ChangeLog b/ChangeLog
index fa416c61ab2..d8c69b3fea1 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,27 @@
+Wed Feb 26 18:42:33 2003  Christopher Kohlhoff  <chris@kohlhoff.com>
+
+        * ace/Makefile.bor:
+
+          Removed ACE_LD_DECORATOR_STR definition from CFLAGS, as this
+          macro is now defined by the common included makefiles.
+
+        * ace/Synch.h:
+
+          Added missing constructor overload and disown member function
+          to the ACE_Guard<ACE_Null_Mutex> template specialization.
+
+        * ace/Atomic_Op.cpp:
+        * ace/Atomic_Op.h:
+        * ace/Atomic_Op.i:
+        * tests/Atomic_Op_Test.cpp:
+
+          Use InterlockedExchange (or the XCHG instruction) to provide
+          strong memory-ordering when assigning to an atomic integer.
+
+        * bin/MakeProjectCreator/Creator.pm:
+
+          Added support for line continuation using backslash in .mpc files.
+
 Wed Feb 26 11:55:20 2003  Chad Elliott  <elliott_c@ociweb.com>
 
         * ace/ace.mpc:
diff --git a/ace/Atomic_Op.cpp b/ace/Atomic_Op.cpp
index b35d1d7424c..11c075d473d 100644
--- a/ace/Atomic_Op.cpp
+++ b/ace/Atomic_Op.cpp
@@ -13,6 +13,7 @@ ACE_RCSID(ace, Atomic_Op, "$Id$")
 
 long (*ACE_Atomic_Op<ACE_Thread_Mutex, long>::increment_fn_) (volatile long *) = 0;
 long (*ACE_Atomic_Op<ACE_Thread_Mutex, long>::decrement_fn_) (volatile long *) = 0;
+long (*ACE_Atomic_Op<ACE_Thread_Mutex, long>::exchange_fn_) (volatile long *, long) = 0;
 long (*ACE_Atomic_Op<ACE_Thread_Mutex, long>::exchange_add_fn_) (volatile long *, long) = 0;
 
 void
@@ -22,12 +23,14 @@ ACE_Atomic_Op<ACE_Thread_Mutex, long>::init_functions (void)
     {
       increment_fn_ = single_cpu_increment;
       decrement_fn_ = single_cpu_decrement;
+      exchange_fn_ = single_cpu_exchange;
       exchange_add_fn_ = single_cpu_exchange_add;
     }
   else
     {
       increment_fn_ = multi_cpu_increment;
       decrement_fn_ = multi_cpu_decrement;
+      exchange_fn_ = multi_cpu_exchange;
       exchange_add_fn_ = multi_cpu_exchange_add;
     }
 }
@@ -75,6 +78,20 @@ ACE_Atomic_Op<ACE_Thread_Mutex, long>::single_cpu_decrement (volatile long *valu
 }
 
 long
+ACE_Atomic_Op<ACE_Thread_Mutex, long>::single_cpu_exchange (volatile long *value,
+                                                            long rhs)
+{
+#if defined (__GNUC__) && defined (ACE_HAS_PENTIUM)
+  unsigned long addr = ACE_reinterpret_cast (unsigned long, value);
+  asm( "xchg %0, (%1)" : "+r"(rhs) : "r"(addr) );
+  return rhs;
+#else /* __GNUC__ && ACE_HAS_PENTIUM */
+  ACE_UNUSED_ARG (value);
+  ACE_NOTSUP_RETURN (-1);
+#endif /* __GNUC__ && ACE_HAS_PENTIUM */
+}
+
+long
 ACE_Atomic_Op<ACE_Thread_Mutex, long>::single_cpu_exchange_add (volatile long *value,
                                                                 long rhs)
 {
@@ -137,6 +154,21 @@ ACE_Atomic_Op<ACE_Thread_Mutex, long>::multi_cpu_decrement (volatile long *value
 }
 
 long
+ACE_Atomic_Op<ACE_Thread_Mutex, long>::multi_cpu_exchange (volatile long *value,
+                                                           long rhs)
+{
+#if defined (__GNUC__) && defined (ACE_HAS_PENTIUM)
+  unsigned long addr = ACE_reinterpret_cast (unsigned long, value);
+  // The XCHG instruction automatically follows LOCK semantics
+  asm( "xchg %0, (%1)" : "+r"(rhs) : "r"(addr) );
+  return rhs;
+#else /* __GNUC__ && ACE_HAS_PENTIUM */
+  ACE_UNUSED_ARG (value);
+  ACE_NOTSUP_RETURN (-1);
+#endif /* __GNUC__ && ACE_HAS_PENTIUM */
+}
+
+long
 ACE_Atomic_Op<ACE_Thread_Mutex, long>::multi_cpu_exchange_add (volatile long *value,
                                                                long rhs)
 {
diff --git a/ace/Atomic_Op.h b/ace/Atomic_Op.h
index 086fc7da3bd..c84697b6e12 100644
--- a/ace/Atomic_Op.h
+++ b/ace/Atomic_Op.h
@@ -137,16 +137,19 @@ private:
   // Single-cpu atomic op implementations.
   static long single_cpu_increment (volatile long *value);
   static long single_cpu_decrement (volatile long *value);
+  static long single_cpu_exchange (volatile long *value, long rhs);
   static long single_cpu_exchange_add (volatile long *value, long rhs);
 
   // Multi-cpu atomic op implementations.
   static long multi_cpu_increment (volatile long *value);
   static long multi_cpu_decrement (volatile long *value);
+  static long multi_cpu_exchange (volatile long *value, long rhs);
   static long multi_cpu_exchange_add (volatile long *value, long rhs);
 
   // Pointers to selected atomic op implementations.
   static long (*increment_fn_) (volatile long *);
   static long (*decrement_fn_) (volatile long *);
+  static long (*exchange_fn_) (volatile long *, long);
   static long (*exchange_add_fn_) (volatile long *, long);
 };
 #endif /* ACE_HAS_BUILTIN_ATOMIC_OP */
diff --git a/ace/Atomic_Op.i b/ace/Atomic_Op.i
index 39d09ba0d17..dfae7e33526 100644
--- a/ace/Atomic_Op.i
+++ b/ace/Atomic_Op.i
@@ -117,14 +117,22 @@ ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator< (long rhs) const
 ACE_INLINE void
 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (long rhs)
 {
-  this->value_ = rhs;
+#if defined (WIN32)
+  ::InterlockedExchange (ACE_const_cast (long *, &this->value_), rhs);
+#else /* WIN32 */
+  (*exchange_fn_) (&this->value_, rhs);
+#endif /* WIN32 */
 }
 
 ACE_INLINE void
 ACE_Atomic_Op<ACE_Thread_Mutex, long>::operator= (
    const ACE_Atomic_Op<ACE_Thread_Mutex, long> &rhs)
 {
-  this->value_ = rhs.value_;
+#if defined (WIN32)
+  ::InterlockedExchange (ACE_const_cast (long *, &this->value_), rhs.value_);
+#else /* WIN32 */
+  (*exchange_fn_) (&this->value_, rhs.value_);
+#endif /* WIN32 */
 }
 
 ACE_INLINE long
diff --git a/ace/Makefile.bor b/ace/Makefile.bor
index 8008811bca8..2e2bf8de58d 100644
--- a/ace/Makefile.bor
+++ b/ace/Makefile.bor
@@ -245,8 +245,7 @@ OBJFILES = \
 
 RESOURCE = $(OBJDIR)\ace.res
 
-CFLAGS = $(ACE_CFLAGS) -DACE_BUILD_DLL -DACE_OS_BUILD_DLL \
-         -DACE_LD_DECORATOR_STR=ACE_LIB_TEXT(\"$(LIB_DECORATOR)\")
+CFLAGS = $(ACE_CFLAGS) -DACE_BUILD_DLL -DACE_OS_BUILD_DLL
 CPPDIR = .
 
 INCDIR_NAME = ace
diff --git a/ace/Synch.h b/ace/Synch.h
index f1a680e7e63..a8798689064 100644
--- a/ace/Synch.h
+++ b/ace/Synch.h
@@ -1701,6 +1701,7 @@ public:
   // = Initialization and termination methods.
   ACE_Guard (ACE_Null_Mutex &) {}
   ACE_Guard (ACE_Null_Mutex &, int) {}
+  ACE_Guard (ACE_Null_Mutex &, int, int) {}
 #if defined (ACE_WIN32)
   ~ACE_Guard (void) {}
 #endif /* ACE_WIN32 */
@@ -1708,6 +1709,7 @@ public:
   int acquire (void) { return 0; }
   int tryacquire (void) { return 0; }
   int release (void) { return 0; }
+  void disown (void) {}
   int locked (void) { return 1; }
   int remove (void) { return 0; }
   void dump (void) const {}
diff --git a/bin/MakeProjectCreator/modules/Creator.pm b/bin/MakeProjectCreator/modules/Creator.pm
index 13e796e69ed..e87a597fb8a 100644
--- a/bin/MakeProjectCreator/modules/Creator.pm
+++ b/bin/MakeProjectCreator/modules/Creator.pm
@@ -393,4 +393,40 @@ sub read_global_configuration {
 }
 
 
+sub read_file {
+  my($self)        = shift;
+  my($input)       = shift;
+  my($ih)          = new FileHandle();
+  my($status)      = 1;
+  my($errorString) = '';
+
+  $self->{'line_number'} = 0;
+  my($line) = "";
+  if (open($ih, $input)) {
+    while(<$ih>) {
+      $line .= $self->strip_line($_);
+
+      if ($line =~ /\\$/) {
+        $line =~ s/\\$/ /;
+      }
+      else {
+        ($status, $errorString) = $self->parse_line($ih, $line);
+        $line = "";
+
+        if (!$status) {
+          last;
+        }
+      }
+    }
+    close($ih);
+  }
+  else {
+    $errorString = 'ERROR: Unable to open for reading';
+    $status = 0;
+  }
+
+  return $status, $errorString;
+}
+
+
 1;
diff --git a/tests/Atomic_Op_Test.cpp b/tests/Atomic_Op_Test.cpp
index c00c3eb94d3..61c8c3bb27a 100644
--- a/tests/Atomic_Op_Test.cpp
+++ b/tests/Atomic_Op_Test.cpp
@@ -61,13 +61,23 @@ ACE_TMAIN (int, ACE_TCHAR *[])
   ACE_ASSERT (foo == 5);
   ACE_ASSERT (result == 5);
 
-  foo = 5L;
-  ACE_ASSERT (foo == 5);
+  foo = 7;
+  ACE_ASSERT (foo == 7);
 
-  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <long> increment %D\n")));
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <long> assignment %D\n")));
   int i;
   for (i = 0; i < TEST_ITERATIONS; ++i)
     {
+      foo = 1;
+      foo = 2;
+      foo = 3;
+      foo = 4;
+    }
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ending <long> assignment %D\n")));
+
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <long> increment %D\n")));
+  for (i = 0; i < TEST_ITERATIONS; ++i)
+    {
       ++foo;
       ++foo;
       ++foo;
@@ -136,6 +146,16 @@ ACE_TMAIN (int, ACE_TCHAR *[])
   bar = 5L;
   ACE_ASSERT (bar == 5);
 
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <int> assignment %D\n")));
+  for (i = 0; i < TEST_ITERATIONS; ++i)
+    {
+      bar = 1;
+      bar = 2;
+      bar = 3;
+      bar = 4;
+    }
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ending <int> assignment %D\n")));
+
   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <int> increment %D\n")));
   for (i = 0; i < TEST_ITERATIONS; ++i)
     {