FilesExpand file tree

 master

/

thread_wince.h

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

171 lines (136 loc) · 3.97 KB

 master

/

thread_wince.h

Copy path

Top

File metadata and controls

• Code
• Blame

171 lines (136 loc) · 3.97 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

/* This code implemented by Mark Hammond (MHammond@skippinet.com.au) */

#include <windows.h>

#include <limits.h>

#include <pydebug.h>

long PyThread_get_thread_ident(void);

/*

* Change all headers to pure ANSI as no one will use K&R style on an

* NT

*/

/*

* Initialization of the C package, should not be needed.

*/

static void PyThread__init_thread(void)

{

}

/*

* Thread support.

*/

long PyThread_start_new_thread(void (*func)(void *), void *arg)

{

long rv;

int success = -1;

dprintf(("%ld: PyThread_start_new_thread called\n", PyThread_get_thread_ident()));

if (!initialized)

PyThread_init_thread();

rv = _beginthread(func, 0, arg); /* use default stack size */

if (rv != -1) {

success = 0;

dprintf(("%ld: PyThread_start_new_thread succeeded:\n", PyThread_get_thread_ident()));

}

return success;

}

/*

* Return the thread Id instead of an handle. The Id is said to uniquely identify the

* thread in the system

*/

long PyThread_get_thread_ident(void)

{

if (!initialized)

PyThread_init_thread();

return GetCurrentThreadId();

}

static void do_PyThread_exit_thread(int no_cleanup)

{

dprintf(("%ld: do_PyThread_exit_thread called\n", PyThread_get_thread_ident()));

if (!initialized)

if (no_cleanup)

exit(0); /* XXX - was _exit()!! */

else

exit(0);

_endthread();

}

void PyThread_exit_thread(void)

{

do_PyThread_exit_thread(0);

}

void PyThread__exit_thread(void)

{

do_PyThread_exit_thread(1);

}

#ifndef NO_EXIT_PROG

static void do_PyThread_exit_prog(int status, int no_cleanup)

{

dprintf(("PyThread_exit_prog(%d) called\n", status));

if (!initialized)

if (no_cleanup)

_exit(status);

else

exit(status);

}

void PyThread_exit_prog(int status)

{

do_PyThread_exit_prog(status, 0);

}

void PyThread__exit_prog(int status)

{

do_PyThread_exit_prog(status, 1);

}

#endif /* NO_EXIT_PROG */

/*

* Lock support. It has to be implemented using Mutexes, as

* CE doesnt support semaphores. Therefore we use some hacks to

* simulate the non reentrant requirements of Python locks

*/

PyThread_type_lock PyThread_allocate_lock(void)

{

HANDLE aLock;

dprintf(("PyThread_allocate_lock called\n"));

if (!initialized)

PyThread_init_thread();

aLock = CreateEvent(NULL, /* Security attributes */

0, /* Manual-Reset */

1, /* Is initially signalled */

NULL); /* Name of event */

dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));

return (PyThread_type_lock) aLock;

}

void PyThread_free_lock(PyThread_type_lock aLock)

{

dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));

CloseHandle(aLock);

}

/*

* Return 1 on success if the lock was acquired

*

* and 0 if the lock was not acquired. This means a 0 is returned

* if the lock has already been acquired by this thread!

*/

int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)

{

int success = 1;

DWORD waitResult;

dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));

#ifndef DEBUG

waitResult = WaitForSingleObject(aLock, (waitflag ? INFINITE : 0));

#else

/* To aid in debugging, we regularly wake up. This allows us to

break into the debugger */

while (TRUE) {

waitResult = WaitForSingleObject(aLock, waitflag ? 3000 : 0);

if (waitflag==0 || (waitflag && waitResult == WAIT_OBJECT_0))

break;

}

#endif

if (waitResult != WAIT_OBJECT_0) {

success = 0; /* We failed */

}

dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));

return success;

}

void PyThread_release_lock(PyThread_type_lock aLock)

{

dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));

if (!SetEvent(aLock))

dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));

}