1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "thread.h"

     5

#include <stdlib.h>

     6

     7

#if defined(__AMIGA__) || 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) && !defined(__MORPHOS__)

    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

   158

#elif defined(MORPHOS)

   159

   160

#include <exec/types.h>

   161

#include <exec/rawfmt.h>

   162

#include <dos/dostags.h>

   163

   164

#include <proto/dos.h>

   165

#include <proto/exec.h>

   166

   167

#include <setjmp.h>

   168

   169

/* NOTE: this code heavily depends on latest libnix updates. So make

   170

 *        sure you link with new stuff which supports semaphore locking of

   171

 *        the IO resources, else it will just go foobar. */

   172

   173

struct OTTDThreadStartupMessage {

   174

	struct Message msg;  ///< standard exec.library message (MUST be the first thing in the message struct!)

   175

	OTTDThreadFunc func; ///< function the thread will execute

   176

	void *arg;           ///< functions arguments for the thread function

   177

	void *ret;           ///< return value of the thread function

   178

	jmp_buf jumpstore;   ///< storage for the setjump state

   179

};

   180

   181

struct OTTDThread {

   182

	struct MsgPort *replyport;

   183

	struct OTTDThreadStartupMessage msg;

   184

};

   185

   186

   187

/**

   188

 *  Default OpenTTD STDIO/ERR debug output is not very useful for this, so we

   189

 *  utilize serial/ramdebug instead.

   190

 */

   191

#ifndef NO_DEBUG_MESSAGES

   192

void KPutStr(CONST_STRPTR format)

   193

{

   194

	RawDoFmt(format, NULL, (void (*)())RAWFMTFUNC_SERIAL, NULL);

   195

}

   196

#else

   197

#define KPutStr(x)

   198

#endif

   199

   200

static void Proxy(void)

   201

{

   202

	struct Task *child = FindTask(NULL);

   203

	struct OTTDThreadStartupMessage *msg;

   204

   205

	/* Make sure, we don't block the parent. */

   206

	SetTaskPri(child, -5);

   207

   208

	KPutStr("[Child] Progressing...\n");

   209

   210

	if (NewGetTaskAttrs(NULL, &msg, sizeof(struct OTTDThreadStartupMessage *), TASKINFOTYPE_STARTUPMSG, TAG_DONE) && msg != NULL) {

   211

		/* Make use of setjmp() here, so this point can be reached again from inside

   212

		 *  OTTDExitThread() which can be called from anythere inside msg->func.

   213

		 *  It's a bit ugly and in worst case it leaks some memory. */

   214

		if (setjmp(msg->jumpstore) == 0) {

   215

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

   216

		} else {

   217

			KPutStr("[Child] Returned to main()\n");

   218

		}

   219

	}

   220

   221

	/*  Quit the child, exec.library will reply the startup msg internally. */

   222

	KPutStr("[Child] Done.\n");

   223

}

   224

   225

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void *arg)

   226

{

   227

	OTTDThread *t;

   228

	struct Task *parent;

   229

   230

	KPutStr("[OpenTTD] Create thread...\n");

   231

   232

	t = (struct OTTDThread *)AllocVecTaskPooled(sizeof(struct OTTDThread));

   233

	if (t == NULL) return NULL;

   234

   235

	parent = FindTask(NULL);

   236

   237

	/* Make sure main thread runs with sane priority */

   238

	SetTaskPri(parent, 0);

   239

   240

	/* Things we'll pass down to the child by utilizing NP_StartupMsg */

   241

	t->msg.func = function;

   242

	t->msg.arg  = arg;

   243

	t->msg.ret  = NULL;

   244

   245

	t->replyport = CreateMsgPort();

   246

   247

	if (t->replyport != NULL) {

   248

		struct Process *child;

   249

   250

		t->msg.msg.mn_Node.ln_Type = NT_MESSAGE;

   251

		t->msg.msg.mn_ReplyPort    = t->replyport;

   252

		t->msg.msg.mn_Length       = sizeof(struct OTTDThreadStartupMessage);

   253

   254

		child = CreateNewProcTags(

   255

			NP_CodeType,     CODETYPE_PPC,

   256

			NP_Entry,        Proxy,

   257

			NP_StartupMsg,   (ULONG)&t->msg,

   258

			NP_Priority,     5UL,

   259

			NP_Name,         (ULONG)"OpenTTD Thread",

   260

			NP_PPCStackSize, 131072UL,

   261

			TAG_DONE);

   262

   263

		if (child != NULL) {

   264

			KPutStr("[OpenTTD] Child process launched.\n");

   265

			return t;

   266

		}

   267

		DeleteMsgPort(t->replyport);

   268

	}

   269

	FreeVecTaskPooled(t);

   270

   271

	return NULL;

   272

}

   273

   274

void* OTTDJoinThread(OTTDThread *t)

   275

{

   276

	struct OTTDThreadStartupMessage *reply;

   277

	void *ret;

   278

   279

	KPutStr("[OpenTTD] Join threads...\n");

   280

   281

	if (t == NULL) return NULL;

   282

   283

	KPutStr("[OpenTTD] Wait for child to quit...\n");

   284

	WaitPort(t->replyport);

   285

   286

	reply = (struct OTTDThreadStartupMessage *)GetMsg(t->replyport);

   287

	ret   = reply->ret;

   288

   289

	DeleteMsgPort(t->replyport);

   290

	FreeVecTaskPooled(t);

   291

   292

	return ret;

   293

}

   294

   295

void OTTDExitThread()

   296

{

   297

	struct OTTDThreadStartupMessage *msg;

   298

   299

	KPutStr("[Child] Aborting...\n");

   300

   301

	if (NewGetTaskAttrs(NULL, &msg, sizeof(struct OTTDThreadStartupMessage *), TASKINFOTYPE_STARTUPMSG, TAG_DONE) && msg != NULL) {

   302

		KPutStr("[Child] Jumping back...\n");

   303

		longjmp(msg->jumpstore, 0xBEAFCAFE);

   304

	}

   305

   306

	NOT_REACHED();

   307

}

   308

   309

#endif