FilesExpand file tree

 master

/

thread_foobar.h

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

132 lines (107 loc) · 2.2 KB

 master

/

thread_foobar.h

Copy path

Top

File metadata and controls

• Code
• Blame

132 lines (107 loc) · 2.2 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

/*

* Initialization.

*/

static void

PyThread__init_thread(void)

{

}

/*

* Thread support.

*/

long

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

{

int success = 0; /* init not needed when SOLARIS_THREADS and */

/* C_THREADS implemented properly */

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

if (!initialized)

PyThread_init_thread();

return success < 0 ? -1 : 0;

}

long

PyThread_get_thread_ident(void)

{

if (!initialized)

PyThread_init_thread();

}

void

PyThread_exit_thread(void)

{

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

if (!initialized)

exit(0);

}

/*

* Lock support.

*/

PyThread_type_lock

PyThread_allocate_lock(void)

{

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

if (!initialized)

PyThread_init_thread();

dprintf(("PyThread_allocate_lock() -> %p\n", lock));

return (PyThread_type_lock) lock;

}

void

PyThread_free_lock(PyThread_type_lock lock)

{

dprintf(("PyThread_free_lock(%p) called\n", lock));

}

int

PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)

{

return PyThread_acquire_lock_timed(lock, waitflag ? -1 : 0, 0);

}

PyLockStatus

PyThread_acquire_lock_timed(PyThread_type_lock lock, PY_TIMEOUT_T microseconds,

int intr_flag)

{

int success;

dprintf(("PyThread_acquire_lock_timed(%p, %lld, %d) called\n", lock, microseconds, intr_flag));

dprintf(("PyThread_acquire_lock_timed(%p, %lld, %d) -> %d\n",

lock, microseconds, intr_flag, success));

return success;

}

void

PyThread_release_lock(PyThread_type_lock lock)

{

dprintf(("PyThread_release_lock(%p) called\n", lock));

}

/* The following are only needed if native TLS support exists */

#define Py_HAVE_NATIVE_TLS

#ifdef Py_HAVE_NATIVE_TLS

int

PyThread_create_key(void)

{

int result;

return result;

}

void

PyThread_delete_key(int key)

{

}

int

PyThread_set_key_value(int key, void *value)

{

int ok;

/* A failure in this case returns -1 */

if (!ok)

return -1;

return 0;

}

void *

PyThread_get_key_value(int key)

{

void *result;

return result;

}

void

PyThread_delete_key_value(int key)

{

}

void

PyThread_ReInitTLS(void)

{

}

#endif