1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "thread.h"

     5

#include <stdlib.h>

     6

     7

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

     8

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

     9

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

    10

void OTTDExitThread(void) { NOT_REACHED(); };

    11

    12

#elif defined(__OS2__)

    13

    14

#define INCL_DOS

    15

#include <os2.h>

    16

#include <process.h>

    17

    18

struct OTTDThread {

    19

	TID thread;

    20

	OTTDThreadFunc func;

    21

	void* arg;

    22

	void* ret;

    23

};

    24

    25

static void Proxy(void* arg)

    26

{

    27

	OTTDThread* t = arg;

    28

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

    29

}

    30

    31

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

    32

{

    33

	OTTDThread* t = malloc(sizeof(*t));

    34

    35

	if (t == NULL) return NULL;

    36

    37

	t->func = function;

    38

	t->arg  = arg;

    39

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

    40

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

    41

		return t;

    42

	} else {

    43

		free(t);

    44

		return NULL;

    45

	}

    46

}

    47

    48

void* OTTDJoinThread(OTTDThread* t)

    49

{

    50

	void* ret;

    51

    52

	if (t == NULL) return NULL;

    53

    54

	DosWaitThread(&t->thread, DCWW_WAIT);

    55

	ret = t->ret;

    56

	free(t);

    57

	return ret;

    58

}

    59

    60

void OTTDExitThread(void)

    61

{

    62

	_endthread();

    63

}

    64

    65

#elif defined(UNIX)

    66

    67

#include <pthread.h>

    68

    69

struct OTTDThread {

    70

	pthread_t thread;

    71

};

    72

    73

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

    74

{

    75

	OTTDThread* t = malloc(sizeof(*t));

    76

    77

	if (t == NULL) return NULL;

    78

    79

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

    80

		return t;

    81

	} else {

    82

		free(t);

    83

		return NULL;

    84

	}

    85

}

    86

    87

void* OTTDJoinThread(OTTDThread* t)

    88

{

    89

	void* ret;

    90

    91

	if (t == NULL) return NULL;

    92

    93

	pthread_join(t->thread, &ret);

    94

	free(t);

    95

	return ret;

    96

}

    97

    98

void OTTDExitThread(void)

    99

{

   100

	pthread_exit(NULL);

   101

}

   102

   103

#elif defined(WIN32)

   104

   105

#include <windows.h>

   106

   107

struct OTTDThread {

   108

	HANDLE thread;

   109

	OTTDThreadFunc func;

   110

	void* arg;

   111

	void* ret;

   112

};

   113

   114

static DWORD WINAPI Proxy(LPVOID arg)

   115

{

   116

	OTTDThread* t = arg;

   117

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

   118

	return 0;

   119

}

   120

   121

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

   122

{

   123

	OTTDThread* t = malloc(sizeof(*t));

   124

	DWORD dwThreadId;

   125

   126

	if (t == NULL) return NULL;

   127

   128

	t->func = function;

   129

	t->arg  = arg;

   130

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

   131

   132

	if (t->thread != NULL) {

   133

		return t;

   134

	} else {

   135

		free(t);

   136

		return NULL;

   137

	}

   138

}

   139

   140

void* OTTDJoinThread(OTTDThread* t)

   141

{

   142

	void* ret;

   143

   144

	if (t == NULL) return NULL;

   145

   146

	WaitForSingleObject(t->thread, INFINITE);

   147

	CloseHandle(t->thread);

   148

	ret = t->ret;

   149

	free(t);

   150

	return ret;

   151

}

   152

   153

void OTTDExitThread(void)

   154

{

   155

	ExitThread(0);

   156

}

   157

#endif