--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/touchTest/Iphone Test/touchTestIPhone2/touchTestIPhone/include/SDL_atomic.h	Sat Jul 31 01:24:50 2010 +0400
@@ -0,0 +1,216 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+
+    Contributed by Bob Pendleton, bob@pendleton.com
+ */
+
+/**
+ *  \file SDL_atomic.h
+ *  
+ *  Atomic operations.
+ *  
+ *  These operations may, or may not, actually be implemented using
+ *  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.
+ *  
+ *  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.
+ */
+
+#ifndef _SDL_atomic_h_
+#define _SDL_atomic_h_
+
+#include "SDL_stdinc.h"
+#include "SDL_platform.h"
+
+#include "begin_code.h"
+
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/* Function prototypes */
+
+/**
+ *  \name 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;
+
+/**
+ *  \brief Lock a spin lock by setting it to a none zero value.
+ *  
+ *  \param lock Points to the lock.
+ */
+extern DECLSPEC void SDLCALL SDL_AtomicLock(SDL_SpinLock *lock);
+
+/**
+ *  \brief Unlock a spin lock by setting it to 0. Always returns immediately
+ *
+ *  \param lock Points to the lock.
+ */
+extern DECLSPEC void SDLCALL SDL_AtomicUnlock(SDL_SpinLock *lock);
+
+/*@}*//*SDL AtomicLock*/
+
+/**
+ *  \name 32 bit atomic operations
+ */
+/*@{*/
+
+/**
+ *  \brief Check to see if \c *ptr == 0 and set it to 1.
+ *  
+ *  \return SDL_True if the value pointed to by \c ptr was zero and
+ *          SDL_False if it was not zero
+ *  
+ *  \param ptr Points to the value to be tested and set.
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTestThenSet32(volatile Uint32 * ptr);
+
+/**
+ *  \brief Set the value pointed to by \c ptr to be zero.
+ *  
+ *  \param ptr Address of the value to be set to zero
+ */
+extern DECLSPEC void SDLCALL SDL_AtomicClear32(volatile Uint32 * ptr);
+
+/**
+ *  \brief Fetch the current value of \c *ptr and then increment that
+ *         value in place.
+ *  
+ *  \return The value before it was incremented.
+ *  
+ *  \param ptr Address of the value to fetch and increment
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr);
+
+/**
+ *  \brief Fetch \c *ptr and then decrement the value in place.
+ *  
+ *  \return The value before it was decremented.
+ *  
+ *  \param ptr Address of the value to fetch and decrement
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr);
+
+/**
+ *  \brief Fetch the current value at \c ptr and then add \c value to \c *ptr.
+ *  
+ *  \return \c *ptr before the addition took place.
+ *  
+ *  \param ptr The address of data we are changing.
+ *  \param value The value to add to \c *ptr. 
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value);
+
+/**
+ *  \brief Fetch \c *ptr and then subtract \c value from it.
+ *  
+ *  \return \c *ptr before the subtraction took place.
+ *  
+ *  \param ptr The address of the data being changed.
+ *  \param value The value to subtract from \c *ptr.
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value);
+
+/**
+ *  \brief Add one to the data pointed to by \c ptr and return that value.
+ *  
+ *  \return The incremented value.
+ *  
+ *  \param ptr The address of the data to increment.
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr);
+
+/**
+ *  \brief Subtract one from data pointed to by \c ptr and return the new value.
+ *  
+ *  \return The decremented value.
+ *  
+ *  \param ptr The address of the data to decrement.
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr);
+
+/**
+ *  \brief Add \c value to the data pointed to by \c ptr and return result.
+ *  
+ *  \return The sum of \c *ptr and \c value.
+ *  
+ *  \param ptr The address of the data to be modified.
+ *  \param value The value to be added.
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value);
+
+/**
+ *  \brief Subtract \c value from the data pointed to by \c ptr and return the result.
+ *  
+ *  \return The difference between \c *ptr and \c value.
+ *  
+ *  \param ptr The address of the data to be modified.
+ *  \param value The value to be subtracted.
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value);
+
+/*@}*//*32 bit atomic operations*/
+
+/**
+ *  \name 64 bit atomic operations
+ */
+/*@{*/
+#ifdef SDL_HAS_64BIT_TYPE
+
+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);
+extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr);
+extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value);
+extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value);
+extern DECLSPEC Uint64 SDLCALL SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr);
+extern DECLSPEC Uint64 SDLCALL SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr);
+extern DECLSPEC Uint64 SDLCALL SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value);
+extern DECLSPEC Uint64 SDLCALL SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value);
+#endif /*  SDL_HAS_64BIT_TYPE */
+
+/*@}*//*64 bit atomic operations*/
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+
+#include "close_code.h"
+
+#endif /* _SDL_atomic_h_ */
+
+/* vi: set ts=4 sw=4 expandtab: */