1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "thread.h"

     5

#include <stdlib.h>

     6

     7

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

     8

Thread* OTTDCreateThread(ThreadFunc function, void* arg) { return NULL; }

     9

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

    10

    11

    12

#elif defined(__OS2__)

    13

    14

#define INCL_DOS

    15

#include <os2.h>

    16

#include <process.h>

    17

    18

struct Thread {

    19

	TID thread;

    20

	ThreadFunc func;

    21

	void* arg;

    22

	void* ret;

    23

};

    24

    25

static void Proxy(void* arg)

    26

{

    27

	Thread* t = arg;

    28

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

    29

}

    30

    31

Thread* OTTDCreateThread(ThreadFunc function, void* arg)

    32

{

    33

	Thread* 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(Thread* 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

    61

#elif defined(UNIX)

    62

    63

#include <pthread.h>

    64

    65

struct Thread {

    66

	pthread_t thread;

    67

};

    68

    69

Thread* OTTDCreateThread(ThreadFunc function, void* arg)

    70

{

    71

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

    72

    73

	if (t == NULL) return NULL;

    74

    75

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

    76

		return t;

    77

	} else {

    78

		free(t);

    79

		return NULL;

    80

	}

    81

}

    82

    83

void* OTTDJoinThread(Thread* t)

    84

{

    85

	void* ret;

    86

    87

	if (t == NULL) return NULL;

    88

    89

	pthread_join(t->thread, &ret);

    90

	free(t);

    91

	return ret;

    92

}

    93

    94

    95

#elif defined(WIN32)

    96

    97

#include <windows.h>

    98

    99

struct Thread {

   100

	HANDLE thread;

   101

	ThreadFunc func;

   102

	void* arg;

   103

	void* ret;

   104

};

   105

   106

static DWORD WINAPI Proxy(LPVOID arg)

   107

{

   108

	Thread* t = arg;

   109

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

   110

	return 0;

   111

}

   112

   113

Thread* OTTDCreateThread(ThreadFunc function, void* arg)

   114

{

   115

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

   116

	DWORD dwThreadId;

   117

   118

	if (t == NULL) return NULL;

   119

   120

	t->func = function;

   121

	t->arg  = arg;

   122

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

   123

   124

	if (t->thread != NULL) {

   125

		return t;

   126

	} else {

   127

		free(t);

   128

		return NULL;

   129

	}

   130

}

   131

   132

void* OTTDJoinThread(Thread* t)

   133

{

   134

	void* ret;

   135

   136

	if (t == NULL) return NULL;

   137

   138

	WaitForSingleObject(t->thread, INFINITE);

   139

	CloseHandle(t->thread);

   140

	ret = t->ret;

   141

	free(t);

   142

	return ret;

   143

}

   144

#endif