The new, cleaner, version of the atomic operations. The dummy code is…

… what you should start working with to port atomic ops.

The linux code appears to be complete and *should* be the base of all Unix and GCC based versions. The macosx and win32 versions
are currently just copies of the dummy code. I will begin working on the windows version as soon as this check in is done. I
need someone to work on the Mac OS X version.

I'm afraid that this check in will break QNX (Sorry!)

include/SDL_atomic.h

@@ -18,6 +18,8 @@
 
     Sam Lantinga
     slouken@libsdl.org
+
+    Contributed by Bob Pendleton, bob@pendleton.com
  */
 
 /**
@@ -46,48 +48,50 @@ extern "C" {
  * processor specific atomic operations. When possible they are
  * implemented as true processor specific atomic operations. When that
  * is not possible the are implemented using locks that *do* use the
- * available atomic operations. In rare cases they may be implemented
- * using SDL's mutex fuctions.
+ * available atomic operations.
+ *
+ * At the very minimum spin locks must be implemented. Without spin
+ * locks it is not possible (AFAICT) to emulate the rest of the atomic
+ * operations.
  */
 
 /* Function prototypes */
 
-/* 32 bit atomic operations */
+/**
+ * SDL AtomicLock.
+ * 
+ * The spin lock functions and type are required and can not be
+ * emulated because they are used in the emulation code.
+ */
+
+typedef volatile Uint32 SDL_SpinLock;
 
 /**
- * \fn int SDL_AtomicExchange32(volatile Uint32 * ptr, Uint32 value)
+ * \fn  void SDL_AtomicLock(SDL_SpinLock *lock);
  *
- * \brief Atomically exchange two 32 bit values.
+ * \brief Lock a spin lock by setting it to a none zero value.
  *
- * \return the value point to by ptr.
- *
- * \param ptr points to the value to be fetched from *ptr.  
- * \param value is value to be stored at *ptr.
- *
- * The current value stored at *ptr is returned and it is replaced
- * with value. This function can be used to implement SDL_TestThenSet.
+ * \param lock points to the lock.
  *
  */
-extern DECLSPEC Uint32 SDLCALL SDL_AtomicExchange32(volatile Uint32 * ptr, Uint32 value);
+extern DECLSPEC void SDLCALL SDL_AtomicLock(SDL_SpinLock *lock);
 
 /**
- * \fn int SDL_AtomicCompareThenSet32(volatile Uint32 * ptr, Uint32 oldvalue, Uint32 newvalue)
- *
- * \brief If *ptr == oldvalue then replace the contents of *ptr by new value. 
+ * \fn  void SDL_AtomicUnlock(SDL_SpinLock *lock);
  *
- * \return true if the newvalue was stored.
+ * \brief Unlock a spin lock by setting it to 0. Always returns immediately
  *
- * \param *ptr is the value to be compared and replaced.
- * \param oldvalue is value to be compared to *ptr.
- * \param newvalue is value to be stored at *ptr.
+ * \param lock points to the lock.
  *
  */
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCompareThenSet32(volatile Uint32 * ptr,
-                                                            Uint32 oldvalue, Uint32 newvalue);
+extern DECLSPEC void SDLCALL SDL_AtomicUnlock(SDL_SpinLock *lock);
+
+/* 32 bit atomic operations */
+
 /**
  * \fn  SDL_bool SDL_AtomicTestThenSet32(volatile Uint32 * ptr);
  *
- * \brief Check to see if *ptr == 0 and set it to non-zero.
+ * \brief Check to see if *ptr == 0 and set it to 1.
  *
  * \return SDL_True if the value pointed to by ptr was zero and
  * SDL_False if it was not zero
@@ -211,9 +215,6 @@ extern DECLSPEC Uint32 SDLCALL SDL_AtomicSubtractThenFetch32(volatile Uint32 * p
 /* 64 bit atomic operations */
 #ifdef SDL_HAS_64BIT_TYPE
 
-extern DECLSPEC Uint64 SDLCALL SDL_AtomicExchange64(volatile Uint64 * ptr, Uint64 value);
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCompareThenSet64(volatile Uint64 * ptr,
-                                                            Uint64 oldvalue, Uint64 newvalue);
 extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTestThenSet64(volatile Uint64 * ptr);
 extern DECLSPEC void SDLCALL SDL_AtomicClear64(volatile Uint64 * ptr);
 extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr);