307 #define BAIL_MACRO_MUTEX(e, m, r) { __PHYSFS_setError(e); __PHYSFS_platformReleaseMutex(m); return r; }

   308 #define BAIL_IF_MACRO_MUTEX(c, e, m, r) if (c) { __PHYSFS_setError(e); __PHYSFS_platformReleaseMutex(m); return r; }

   638 /*

   639  * Create a platform-specific mutex. This can be whatever datatype your

   640  *  platform uses for mutexes, but it is cast to a (void *) for abstractness.

   641  *

   642  * Return (NULL) if you couldn't create one. Systems without threads can

   643  *  return any arbitrary non-NULL value.

   644  */

   645 void *__PHYSFS_platformCreateMutex(void);

   646 

   647 /*

   648  * Destroy a platform-specific mutex, and clean up any resources associated

   649  *  with it. (mutex) is a value previously returned by

   650  *  __PHYSFS_platformCreateMutex(). This can be a no-op on single-threaded

   651  *  platforms.

   652  */

   653 void __PHYSFS_platformDestroyMutex(void *mutex);

   654 

   655 /*

   656  * Grab possession of a platform-specific mutex. Mutexes should be recursive;

   657  *  that is, the same thread should be able to call this function multiple

   658  *  times in a row without causing a deadlock. This function should block 

   659  *  until a thread can gain possession of the mutex.

   660  *

   661  * Return non-zero if the mutex was grabbed, zero if there was an 

   662  *  unrecoverable problem grabbing it (this should not be a matter of 

   663  *  timing out! We're talking major system errors; block until the mutex 

   664  *  is available otherwise.)

   665  */

   666 int __PHYSFS_platformGrabMutex(void *mutex);

   667 

   668 /*

   669  * Relinquish possession of the mutex when this method has been called 

   670  *  once for each time that platformGrabMutex was called. Once possession has

   671  *  been released, the next thread in line to grab the mutex (if any) may

   672  *  proceed.

   673  */

   674 void __PHYSFS_platformReleaseMutex(void *mutex);

   675