1

/* $Id$ */

     2

     3

/** @file thread.cpp */

     4

     5

#include "stdafx.h"

     6

#include "thread.h"

     7

#include <stdlib.h>

     8

#include "helpers.hpp"

     9

    10

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

    11

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

    12

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

    13

void OTTDExitThread() { NOT_REACHED(); };

    14

    15

#elif defined(__OS2__)

    16

    17

#define INCL_DOS

    18

#include <os2.h>

    19

#include <process.h>

    20

    21

struct OTTDThread {

    22

	TID thread;

    23

	OTTDThreadFunc func;

    24

	void* arg;

    25

	void* ret;

    26

};

    27

    28

static void Proxy(void* arg)

    29

{

    30

	OTTDThread* t = (OTTDThread*)arg;

    31

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

    32

}

    33

    34

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

    35

{

    36

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

    37

    38

	if (t == NULL) return NULL;

    39

    40

	t->func = function;

    41

	t->arg  = arg;

    42

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

    43

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

    44

		return t;

    45

	} else {

    46

		free(t);

    47

		return NULL;

    48

	}

    49

}

    50

    51

void* OTTDJoinThread(OTTDThread* t)

    52

{

    53

	void* ret;

    54

    55

	if (t == NULL) return NULL;

    56

    57

	DosWaitThread(&t->thread, DCWW_WAIT);

    58

	ret = t->ret;

    59

	free(t);

    60

	return ret;

    61

}

    62

    63

void OTTDExitThread()

    64

{

    65

	_endthread();

    66

}

    67

    68

#elif defined(UNIX)

    69

    70

#include <pthread.h>

    71

    72

struct OTTDThread {

    73

	pthread_t thread;

    74

};

    75

    76

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

    77

{

    78

	OTTDThread* t = MallocT<OTTDThread>(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()

   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 = MallocT<OTTDThread>(1);

   127

	DWORD dwThreadId;

   128

   129

	if (t == NULL) return NULL;

   130

   131

	t->func = function;

   132

	t->arg  = arg;

   133

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

   134

   135

	if (t->thread != NULL) {

   136

		return t;

   137

	} else {

   138

		free(t);

   139

		return NULL;

   140

	}

   141

}

   142

   143

void* OTTDJoinThread(OTTDThread* t)

   144

{

   145

	void* ret;

   146

   147

	if (t == NULL) return NULL;

   148

   149

	WaitForSingleObject(t->thread, INFINITE);

   150

	CloseHandle(t->thread);

   151

	ret = t->ret;

   152

	free(t);

   153

	return ret;

   154

}

   155

   156

void OTTDExitThread()

   157

{

   158

	ExitThread(0);

   159

}

   160

#endif