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(NO_THREADS)

     9

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

    10

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

    11

void OTTDExitThread(void) { 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;

    35

	MallocT(&t, 1);

    36

    37

	if (t == NULL) return NULL;

    38

    39

	t->func = function;

    40

	t->arg  = arg;

    41

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

    42

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

    43

		return t;

    44

	} else {

    45

		free(t);

    46

		return NULL;

    47

	}

    48

}

    49

    50

void* OTTDJoinThread(OTTDThread* t)

    51

{

    52

	void* ret;

    53

    54

	if (t == NULL) return NULL;

    55

    56

	DosWaitThread(&t->thread, DCWW_WAIT);

    57

	ret = t->ret;

    58

	free(t);

    59

	return ret;

    60

}

    61

    62

void OTTDExitThread(void)

    63

{

    64

	_endthread();

    65

}

    66

    67

#elif defined(UNIX)

    68

    69

#include <pthread.h>

    70

    71

struct OTTDThread {

    72

	pthread_t thread;

    73

};

    74

    75

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

    76

{

    77

	OTTDThread* t;

    78

	MallocT(&t, 1);

    79

    80

	if (t == NULL) return NULL;

    81

    82

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

    83

		return t;

    84

	} else {

    85

		free(t);

    86

		return NULL;

    87

	}

    88

}

    89

    90

void* OTTDJoinThread(OTTDThread* t)

    91

{

    92

	void* ret;

    93

    94

	if (t == NULL) return NULL;

    95

    96

	pthread_join(t->thread, &ret);

    97

	free(t);

    98

	return ret;

    99

}

   100

   101

void OTTDExitThread(void)

   102

{

   103

	pthread_exit(NULL);

   104

}

   105

   106

#elif defined(WIN32)

   107

   108

#include <windows.h>

   109

   110

struct OTTDThread {

   111

	HANDLE thread;

   112

	OTTDThreadFunc func;

   113

	void* arg;

   114

	void* ret;

   115

};

   116

   117

static DWORD WINAPI Proxy(LPVOID arg)

   118

{

   119

	OTTDThread* t = (OTTDThread*)arg;

   120

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

   121

	return 0;

   122

}

   123

   124

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

   125

{

   126

	OTTDThread* t;

   127

	MallocT(&t, 1);

   128

	DWORD dwThreadId;

   129

   130

	if (t == NULL) return NULL;

   131

   132

	t->func = function;

   133

	t->arg  = arg;

   134

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

   135

   136

	if (t->thread != NULL) {

   137

		return t;

   138

	} else {

   139

		free(t);

   140

		return NULL;

   141

	}

   142

}

   143

   144

void* OTTDJoinThread(OTTDThread* t)

   145

{

   146

	void* ret;

   147

   148

	if (t == NULL) return NULL;

   149

   150

	WaitForSingleObject(t->thread, INFINITE);

   151

	CloseHandle(t->thread);

   152

	ret = t->ret;

   153

	free(t);

   154

	return ret;

   155

}

   156

   157

void OTTDExitThread(void)

   158

{

   159

	ExitThread(0);

   160

}

   161

#endif