1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "thread.h"

     5

#include <stdlib.h>

     6

#include "helpers.hpp"

     7

     8

#if defined(__AMIGA__) || defined(__MORPHOS__) || defined(PSP) || defined(NO_THREADS)

     9

OTTDThread *OTTDCreateThread(OTTDThreadFunc function, void *arg) { return NULL; }

    10

void *OTTDJoinThread(OTTDThread *t) { return NULL; }

    11

void OTTDExitThread() { NOT_REACHED(); };

    12

    13

#elif defined(__OS2__)

    14

    15

#define INCL_DOS

    16

#include <os2.h>

    17

#include <process.h>

    18

    19

struct OTTDThread {

    20

	TID thread;

    21

	OTTDThreadFunc func;

    22

	void* arg;

    23

	void* ret;

    24

};

    25

    26

static void Proxy(void* arg)

    27

{

    28

	OTTDThread* t = (OTTDThread*)arg;

    29

	t->ret = t->func(t->arg);

    30

}

    31

    32

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

    33

{

    34

	OTTDThread* t = MallocT<OTTDThread>(1);

    35

    36

	if (t == NULL) return NULL;

    37

    38

	t->func = function;

    39

	t->arg  = arg;

    40

	t->thread = _beginthread(Proxy, NULL, 32768, t);

    41

	if (t->thread != (TID)-1) {

    42

		return t;

    43

	} else {

    44

		free(t);

    45

		return NULL;

    46

	}

    47

}

    48

    49

void* OTTDJoinThread(OTTDThread* t)

    50

{

    51

	void* ret;

    52

    53

	if (t == NULL) return NULL;

    54

    55

	DosWaitThread(&t->thread, DCWW_WAIT);

    56

	ret = t->ret;

    57

	free(t);

    58

	return ret;

    59

}

    60

    61

void OTTDExitThread()

    62

{

    63

	_endthread();

    64

}

    65

    66

#elif defined(UNIX)

    67

    68

#include <pthread.h>

    69

    70

struct OTTDThread {

    71

	pthread_t thread;

    72

};

    73

    74

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

    75

{

    76

	OTTDThread* t = MallocT<OTTDThread>(1);

    77

    78

	if (t == NULL) return NULL;

    79

    80

	if (pthread_create(&t->thread, NULL, function, arg) == 0) {

    81

		return t;

    82

	} else {

    83

		free(t);

    84

		return NULL;

    85

	}

    86

}

    87

    88

void* OTTDJoinThread(OTTDThread* t)

    89

{

    90

	void* ret;

    91

    92

	if (t == NULL) return NULL;

    93

    94

	pthread_join(t->thread, &ret);

    95

	free(t);

    96

	return ret;

    97

}

    98

    99

void OTTDExitThread()

   100

{

   101

	pthread_exit(NULL);

   102

}

   103

   104

#elif defined(WIN32)

   105

   106

#include <windows.h>

   107

   108

struct OTTDThread {

   109

	HANDLE thread;

   110

	OTTDThreadFunc func;

   111

	void* arg;

   112

	void* ret;

   113

};

   114

   115

static DWORD WINAPI Proxy(LPVOID arg)

   116

{

   117

	OTTDThread* t = (OTTDThread*)arg;

   118

	t->ret = t->func(t->arg);

   119

	return 0;

   120

}

   121

   122

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

   123

{

   124

	OTTDThread* t = MallocT<OTTDThread>(1);

   125

	DWORD dwThreadId;

   126

   127

	if (t == NULL) return NULL;

   128

   129

	t->func = function;

   130

	t->arg  = arg;

   131

	t->thread = CreateThread(NULL, 0, Proxy, t, 0, &dwThreadId);

   132

   133

	if (t->thread != NULL) {

   134

		return t;

   135

	} else {

   136

		free(t);

   137

		return NULL;

   138

	}

   139

}

   140

   141

void* OTTDJoinThread(OTTDThread* t)

   142

{

   143

	void* ret;

   144

   145

	if (t == NULL) return NULL;

   146

   147

	WaitForSingleObject(t->thread, INFINITE);

   148

	CloseHandle(t->thread);

   149

	ret = t->ret;

   150

	free(t);

   151

	return ret;

   152

}

   153

   154

void OTTDExitThread()

   155

{

   156

	ExitThread(0);

   157

}

   158

#endif