home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 22 / AACD 22.iso / AACD / Programming / AmigaSDL / amisrc / SDL_syssem.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-04-29  |  3.5 KB  |  178 lines
  1. /* WARNING:  This file was automatically generated!
  2.  * Original: ./src/thread/generic/SDL_syssem.c
  3.  */
  4. /*
  5.     SDL - Simple DirectMedia Layer
  6.     Copyright (C) 1997, 1998, 1999, 2000  Sam Lantinga
  7.  
  8.     This library is free software; you can redistribute it and/or
  9.     modify it under the terms of the GNU Library General Public
  10.     License as published by the Free Software Foundation; either
  11.     version 2 of the License, or (at your option) any later version.
  12.  
  13.     This library is distributed in the hope that it will be useful,
  14.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.     Library General Public License for more details.
  17.  
  18.     You should have received a copy of the GNU Library General Public
  19.     License along with this library; if not, write to the Free
  20.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21.  
  22.     Sam Lantinga
  23.     slouken@devolution.com
  24. */
  25.  
  26. #ifdef SAVE_RCSID
  27. static char rcsid =
  28.  "@(#) $Id: SDL_syssem.c,v 1.1.2.4 2000/05/30 15:59:57 hercules Exp $";
  29. #endif
  30.  
  31. /* An implementation of semaphores using mutexes and condition variables */
  32.  
  33. #include "SDL_error.h"
  34. #include "SDL_thread.h"
  35. #include "SDL_systhread_c.h"
  36.  
  37.  
  38. struct SDL_semaphore
  39. {
  40.     struct SignalSemaphore Sem;
  41.     Uint32 count;
  42.     Uint32 waiters_count;
  43.     SDL_mutex *count_lock;
  44.     SDL_cond *count_nonzero;
  45. };
  46.  
  47. #undef D
  48.  
  49. #define D(x)
  50.  
  51. SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
  52. {
  53.     SDL_sem *sem;
  54.  
  55.     sem = (SDL_sem *)malloc(sizeof(*sem));
  56.  
  57.     if ( ! sem ) {
  58.         SDL_OutOfMemory();
  59.         return(0);
  60.     }
  61.  
  62.     D(bug("Creating semaphore %lx...\n",sem));
  63.  
  64.     memset(sem,0,sizeof(*sem));
  65.  
  66.     InitSemaphore(&sem->Sem);
  67.     
  68.     return(sem);
  69. }
  70.  
  71. void SDL_DestroySemaphore(SDL_sem *sem)
  72. {
  73.     D(bug("Destroying semaphore %lx...\n",sem));
  74.  
  75.     if ( sem ) {
  76. // Condizioni per liberare i task in attesa?
  77.         free(sem);
  78.     }
  79. }
  80.  
  81. int SDL_SemTryWait(SDL_sem *sem)
  82. {
  83.     if ( ! sem ) {
  84.         SDL_SetError("Passed a NULL semaphore");
  85.         return -1;
  86.     }
  87.  
  88.     D(bug("TryWait semaphore...%lx\n",sem));
  89.  
  90.     ObtainSemaphore(&sem->Sem);
  91. //    ReleaseSemaphore(&sem->Sem);
  92.  
  93.     return 1;
  94. }
  95.  
  96. int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)
  97. {
  98.     int retval;
  99.  
  100.  
  101.     if ( ! sem ) {
  102.         SDL_SetError("Passed a NULL semaphore");
  103.         return -1;
  104.     }
  105.  
  106.     D(bug("WaitTimeout (%ld) semaphore...%lx\n",timeout,sem));
  107.  
  108.     /* A timeout of 0 is an easy case */
  109.     if ( timeout == 0 ) {
  110.         return SDL_SemTryWait(sem);
  111.     }
  112. /*
  113.     SDL_LockMutex(sem->count_lock);
  114.     ++sem->waiters_count;
  115.     retval = 0;
  116.     while ( (sem->count == 0) && (retval != SDL_MUTEX_TIMEDOUT) ) {
  117.         retval = SDL_CondWaitTimeout(sem->count_nonzero,
  118.                                      sem->count_lock, timeout);
  119.     }
  120.     --sem->waiters_count;
  121.     --sem->count;
  122.     SDL_UnlockMutex(sem->count_lock);
  123. */
  124.     if(!(retval=AttemptSemaphore(&sem->Sem)))
  125.     {
  126.         SDL_Delay(timeout);
  127.         retval=AttemptSemaphore(&sem->Sem);
  128.     }
  129.  
  130.     if(retval==TRUE)
  131.     {
  132. //        ReleaseSemaphore(&sem->Sem);
  133.         retval=1;
  134.     }
  135.  
  136.     return retval;
  137. }
  138.  
  139. int SDL_SemWait(SDL_sem *sem)
  140. {
  141.     ObtainSemaphore(&sem->Sem);
  142.     return 0;
  143. //    return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT);
  144. }
  145.  
  146. Uint32 SDL_SemValue(SDL_sem *sem)
  147. {
  148.     Uint32 value;
  149.     
  150.     value = 0;
  151.     if ( sem ) {
  152.         value = sem->Sem.ss_NestCount;
  153. //        SDL_UnlockMutex(sem->count_lock);
  154.     }
  155.     return value;
  156. }
  157.  
  158. int SDL_SemPost(SDL_sem *sem)
  159. {
  160.     if ( ! sem ) {
  161.         SDL_SetError("Passed a NULL semaphore");
  162.         return -1;
  163.     }
  164.     D(bug("SemPost semaphore...%lx\n",sem));
  165.  
  166.     ReleaseSemaphore(&sem->Sem);
  167. #if 0
  168.     SDL_LockMutex(sem->count_lock);
  169.     if ( sem->waiters_count > 0 ) {
  170.         SDL_CondSignal(sem->count_nonzero);
  171.     }
  172.     ++sem->count;
  173.     SDL_UnlockMutex(sem->count_lock);
  174. #endif
  175.     return 0;
  176. }
  177.  
  178.