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 /***********************************************************************
  71  *           Tls is available only for the single thread
  72  * (BTW: TLS means Thread Local Storage)
  73  */
  74 static LPVOID* Tls=0;
  75 static int TlsCount=0;
  76
  77 DWORD TlsAlloc()
  78 {
  79         if(!Tls){
  80                 TlsCount++;
  81                 Tls=xmalloc(sizeof(LPVOID));
  82                 /* Tls needs to be zero initialized */
  83                 Tls[0]=0;
  84                 return 0;
  85         }
  86         Tls=xrealloc(Tls,sizeof(LPVOID)*(++TlsCount));
  87         Tls[TlsCount-1]=0;
  88         return TlsCount-1;
  89 }
  90
  91 void TlsFree(DWORD index)
  92 {
  93         /*FIXME: should remember that it has been freed */
  94         return;
  95 }
  96
  97 LPVOID TlsGetValue(DWORD index)
  98 {
  99         if(index>=TlsCount)
 100         {
 101                 /* FIXME: Set last error*/
 102                 return 0;
 103         }
 104         return Tls[index];
 105 }
 106
 107 BOOL32 TlsSetValue(DWORD index,LPVOID value)
 108 {
 109         if(index>=TlsCount)
 110         {
 111                 /* FIXME: Set last error*/
 112                 return FALSE;
 113         }
 114         Tls[index]=value;
 115         return TRUE;
 116 }
 117
 118 /* FIXME: This is required to work cross-addres space as well */
 119 static CRITICAL_SECTION interlocked;
 120 static int interlocked_init;
 121
 122 static void get_interlocked()
 123 {
 124         if(!interlocked_init)
 125                 InitializeCriticalSection(&interlocked);
 126         interlocked_init=1;
 127         EnterCriticalSection(&interlocked);
 128 }
 129
 130 static void release_interlocked()
 131 {
 132         LeaveCriticalSection(&interlocked);
 133 }
 134
 135 /***********************************************************************
 136  *           InterlockedIncrement
 137  */
 138 LONG InterlockedIncrement(LPLONG lpAddend)
 139 {
 140         int ret;
 141         get_interlocked();
 142         (*lpAddend)++;
 143         ret=*lpAddend;
 144         release_interlocked();
 145         return ret;
 146 }
 147
 148 /***********************************************************************
 149  *           InterlockedDecrement
 150  */
 151 LONG InterlockedDecrement(LPLONG lpAddend)
 152 {
 153         int ret;
 154         get_interlocked();
 155         (*lpAddend)--;
 156         ret=*lpAddend;
 157         release_interlocked();
 158         return ret;
 159 }
 160
 161 /***********************************************************************
 162  *           InterlockedExchange
 163  */
 164 LONG InterlockedExchange(LPLONG target, LONG value)
 165 {
 166         int ret;
 167         get_interlocked();
 168         ret=*target;
 169         *target=value;
 170         release_interlocked();
 171         return ret;
 172 }