win32/thread.c

   1 /*
   2  * Win32 kernel functions
   3  *
   4  * Copyright 1995 Martin von Loewis
   5  */
   6
   7 #include <stdio.h>
   8 #include <unistd.h>
   9 #include <string.h>
  10 #include "windows.h"
  11 #include "winbase.h"
  12 #include "winerror.h"
  13 #include "stddebug.h"
  14 #include "debug.h"
  15 #include "xmalloc.h"
  16
  17 /***********************************************************************
  18  *           GetCurrentThreadId   (KERNEL32.200)
  19  */
  20
  21 int GetCurrentThreadId(void)
  22 {
  23         return getpid();
  24 }
  25
  26 /***********************************************************************
  27  *           GetThreadContext         (KERNEL32.294)
  28  */
  29 BOOL GetThreadContext(HANDLE hThread, void *lpContext)
  30 {
  31         return FALSE;
  32 }
  33 /***********************************************************************
  34  *           GetCurrentThread    (KERNEL32.200)
  35  */
  36 HANDLE GetCurrentThread(void)
  37 {
  38         return 0;
  39 }
  40
  41 /**********************************************************************
  42  *          Critical Sections are currently ignored
  43  */
  44 void InitializeCriticalSection(CRITICAL_SECTION *lpCrit)
  45 {
  46         memset(lpCrit,0,sizeof(CRITICAL_SECTION));
  47 }
  48
  49 void EnterCriticalSection(CRITICAL_SECTION* lpCrit)
  50 {
  51     if (lpCrit->LockCount)
  52         fprintf( stderr, "Error: re-entering critical section %08lx\n",
  53                  (DWORD)lpCrit );
  54     lpCrit->LockCount++;
  55 }
  56
  57 void LeaveCriticalSection(CRITICAL_SECTION* lpCrit)
  58 {
  59     if (!lpCrit->LockCount)
  60         fprintf( stderr, "Error: leaving critical section %08lx again\n",
  61                  (DWORD)lpCrit );
  62     lpCrit->LockCount--;
  63 }
  64
  65 void DeleteCriticalSection(CRITICAL_SECTION* lpCrit)
  66 {
  67         return;
  68 }
  69
  70 void
  71 ReinitializeCriticalSection(CRITICAL_SECTION *lpCrit) {
  72         /* hmm */
  73 }
  74
  75 /***********************************************************************
  76  *           Tls is available only for the single thread
  77  * (BTW: TLS means Thread Local Storage)
  78  */
  79 static LPVOID* Tls=0;
  80 static int TlsCount=0;
  81
  82 DWORD TlsAlloc()
  83 {
  84         if(!Tls){
  85                 TlsCount++;
  86                 Tls=xmalloc(sizeof(LPVOID));
  87                 /* Tls needs to be zero initialized */
  88                 Tls[0]=0;
  89                 return 0;
  90         }
  91         Tls=xrealloc(Tls,sizeof(LPVOID)*(++TlsCount));
  92         Tls[TlsCount-1]=0;
  93         return TlsCount-1;
  94 }
  95
  96 void TlsFree(DWORD index)
  97 {
  98         /*FIXME: should remember that it has been freed */
  99         return;
 100 }
 101
 102 LPVOID TlsGetValue(DWORD index)
 103 {
 104         if(index>=TlsCount)
 105         {
 106                 /* FIXME: Set last error*/
 107                 return 0;
 108         }
 109         return Tls[index];
 110 }
 111
 112 BOOL32 TlsSetValue(DWORD index,LPVOID value)
 113 {
 114         if(index>=TlsCount)
 115         {
 116                 /* FIXME: Set last error*/
 117                 return FALSE;
 118         }
 119         Tls[index]=value;
 120         return TRUE;
 121 }
 122
 123 /* FIXME: This is required to work cross-addres space as well */
 124 static CRITICAL_SECTION interlocked;
 125 static int interlocked_init;
 126
 127 static void get_interlocked()
 128 {
 129         if(!interlocked_init)
 130                 InitializeCriticalSection(&interlocked);
 131         interlocked_init=1;
 132         EnterCriticalSection(&interlocked);
 133 }
 134
 135 static void release_interlocked()
 136 {
 137         LeaveCriticalSection(&interlocked);
 138 }
 139
 140 /***********************************************************************
 141  *           InterlockedIncrement
 142  */
 143 LONG InterlockedIncrement(LPLONG lpAddend)
 144 {
 145         int ret;
 146         get_interlocked();
 147         (*lpAddend)++;
 148         ret=*lpAddend;
 149         release_interlocked();
 150         return ret;
 151 }
 152
 153 /***********************************************************************
 154  *           InterlockedDecrement
 155  */
 156 LONG InterlockedDecrement(LPLONG lpAddend)
 157 {
 158         int ret;
 159         get_interlocked();
 160         (*lpAddend)--;
 161         ret=*lpAddend;
 162         release_interlocked();
 163         return ret;
 164 }
 165
 166 /***********************************************************************
 167  *           InterlockedExchange
 168  */
 169 LONG InterlockedExchange(LPLONG target, LONG value)
 170 {
 171         int ret;
 172         get_interlocked();
 173         ret=*target;
 174         *target=value;
 175         release_interlocked();
 176         return ret;
 177 }