1

/* $Id$ */

     2

     3

/** @file fiber_win32.cpp Win32 implementation of Fiber. */

     4

     5

#include "stdafx.h"

     6

#include "fiber.hpp"

     7

#include <stdlib.h>

     8

#include <windows.h>

     9

#include <process.h>

    10

    11

class Fiber_Win32 : public Fiber {

    12

private:

    13

	LPVOID m_fiber;

    14

	FiberFunc m_proc;

    15

	void *m_param;

    16

	bool m_attached;

    17

    18

	static Fiber_Win32 *s_main;

    19

    20

public:

    21

	/**

    22

	 * Create a win32 fiber and start it, calling proc(param).

    23

	 */

    24

	Fiber_Win32(FiberFunc proc, void *param) :

    25

		m_fiber(NULL),

    26

		m_proc(proc),

    27

		m_param(param),

    28

		m_attached(false)

    29

	{

    30

		CreateFiber();

    31

	}

    32

    33

	/**

    34

	 * Create a win32 fiber and attach current thread to it.

    35

	 */

    36

	Fiber_Win32(void *param) :

    37

		m_fiber(NULL),

    38

		m_proc(NULL),

    39

		m_param(param),

    40

		m_attached(true)

    41

	{

    42

		ConvertThreadToFiber();

    43

		if (s_main == NULL) s_main = this;

    44

	}

    45

    46

	/* virtual */ ~Fiber_Win32()

    47

	{

    48

		if (this->m_fiber != NULL) {

    49

			if (this->m_attached) {

    50

				this->ConvertFiberToThread();

    51

			} else {

    52

				this->DeleteFiber();

    53

			}

    54

		}

    55

	}

    56

    57

	/* virtual */ void SwitchToFiber()

    58

	{

    59

		typedef VOID (WINAPI *FnSwitchToFiber)(LPVOID fiber);

    60

    61

		static FnSwitchToFiber fnSwitchToFiber = (FnSwitchToFiber)stGetProcAddr("SwitchToFiber");

    62

		assert(fnSwitchToFiber != NULL);

    63

    64

		fnSwitchToFiber(this->m_fiber);

    65

	}

    66

    67

	/* virtual */ void Exit()

    68

	{

    69

		/* Simply switch back to the main fiber, we kill the fiber sooner or later */

    70

		s_main->SwitchToFiber();

    71

	}

    72

    73

	/* virtual */ bool IsRunning()

    74

	{

    75

		return this->m_fiber != NULL;

    76

	}

    77

    78

	/* virtual */ void *GetFiberData()

    79

	{

    80

		return this->m_param;

    81

	}

    82

    83

	/**

    84

	 * Win95 doesn't have Fiber support. So check if we have Fiber support,

    85

	 *  and else fall back on Fiber_Thread.

    86

	 */

    87

	static bool IsSupported()

    88

	{

    89

		static bool first_run = true;

    90

		static bool is_supported = false;

    91

    92

		if (first_run) {

    93

			first_run = false;

    94

			static const char *names[] = {

    95

				"ConvertThreadToFiber",

    96

				"CreateFiber",

    97

				"DeleteFiber",

    98

				"ConvertFiberToThread",

    99

				"SwitchToFiber"};

   100

			for (size_t i = 0; i < lengthof(names); i++) {

   101

				if (stGetProcAddr(names[i]) == NULL) return false;

   102

			}

   103

			is_supported = true;

   104

		}

   105

		return is_supported;

   106

	}

   107

   108

private:

   109

	/**

   110

	 * Get a function from kernel32.dll.

   111

	 * @param name Function to get.

   112

	 * @return Proc to the function, or NULL when not found.

   113

	 */

   114

	static FARPROC stGetProcAddr(const char *name)

   115

	{

   116

		static HMODULE hKernel = LoadLibraryA("kernel32.dll");

   117

		return GetProcAddress(hKernel, name);

   118

	}

   119

   120

	/**

   121

	 * First function which is called within the fiber.

   122

	 */

   123

	static VOID CALLBACK stFiberProc(LPVOID fiber)

   124

	{

   125

		Fiber_Win32 *cur = (Fiber_Win32 *)fiber;

   126

		cur->m_proc(cur->m_param);

   127

	}

   128

   129

	/**

   130

	 * Delete a fiber.

   131

	 */

   132

	void DeleteFiber()

   133

	{

   134

		typedef VOID (WINAPI *FnDeleteFiber)(LPVOID lpFiber);

   135

   136

		static FnDeleteFiber fnDeleteFiber = (FnDeleteFiber)stGetProcAddr("DeleteFiber");

   137

		assert(fnDeleteFiber != NULL);

   138

   139

		fnDeleteFiber(this->m_fiber);

   140

		this->m_fiber = NULL;

   141

	}

   142

   143

	/**

   144

	 * Convert a current thread to a fiber.

   145

	 */

   146

	void ConvertThreadToFiber()

   147

	{

   148

		typedef LPVOID (WINAPI *FnConvertThreadToFiber)(LPVOID lpParameter);

   149

   150

		static FnConvertThreadToFiber fnConvertThreadToFiber = (FnConvertThreadToFiber)stGetProcAddr("ConvertThreadToFiber");

   151

		assert(fnConvertThreadToFiber != NULL);

   152

   153

		this->m_fiber = fnConvertThreadToFiber(this);

   154

	}

   155

   156

	/**

   157

	 * Create a new fiber.

   158

	 */

   159

	void CreateFiber()

   160

	{

   161

		typedef LPVOID (WINAPI *FnCreateFiber)(SIZE_T dwStackSize, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter);

   162

   163

		static FnCreateFiber fnCreateFiber = (FnCreateFiber)stGetProcAddr("CreateFiber");

   164

		assert(fnCreateFiber != NULL);

   165

   166

		this->m_fiber = fnCreateFiber(0, &stFiberProc, this);

   167

	}

   168

   169

	/**

   170

	 * Convert a fiber back to a thread.

   171

	 */

   172

	void ConvertFiberToThread()

   173

	{

   174

		typedef BOOL (WINAPI *FnConvertFiberToThread)();

   175

   176

		static FnConvertFiberToThread fnConvertFiberToThread = (FnConvertFiberToThread)stGetProcAddr("ConvertFiberToThread");

   177

		assert(fnConvertFiberToThread != NULL);

   178

   179

		fnConvertFiberToThread();

   180

		this->m_fiber = NULL;

   181

	}

   182

};

   183

   184

/* Initialize the static member of Fiber_Win32 */

   185

/* static */ Fiber_Win32 *Fiber_Win32::s_main = NULL;

   186

   187

/* Include Fiber_Thread, as Win95 needs it */

   188

#include "fiber_thread.cpp"

   189

   190

/* static */ Fiber *Fiber::New(FiberFunc proc, void *param)

   191

{

   192

	if (Fiber_Win32::IsSupported()) return new Fiber_Win32(proc, param);

   193

	return new Fiber_Thread(proc, param);

   194

}

   195

   196

/* static */ Fiber *Fiber::AttachCurrent(void *param)

   197

{

   198

	if (Fiber_Win32::IsSupported()) return new Fiber_Win32(param);

   199

	return new Fiber_Thread(param);

   200

}

   201

   202

/* static */ void *Fiber::GetCurrentFiberData()

   203

{

   204

	if (Fiber_Win32::IsSupported()) return ((Fiber *)::GetFiberData())->GetFiberData();

   205

	return Fiber_Thread::GetCurrentFiber()->GetFiberData();

   206

}