Split thread.c into a number of system-specific files. · python/cpython@2c8cb9f (original) (raw)
``
1
`+
/***********************************************************
`
``
2
`+
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
`
``
3
`+
Amsterdam, The Netherlands.
`
``
4
+
``
5
`+
All Rights Reserved
`
``
6
+
``
7
`+
Permission to use, copy, modify, and distribute this software and its
`
``
8
`+
documentation for any purpose and without fee is hereby granted,
`
``
9
`+
provided that the above copyright notice appear in all copies and that
`
``
10
`+
both that copyright notice and this permission notice appear in
`
``
11
`+
supporting documentation, and that the names of Stichting Mathematisch
`
``
12
`+
Centrum or CWI not be used in advertising or publicity pertaining to
`
``
13
`+
distribution of the software without specific, written prior permission.
`
``
14
+
``
15
`+
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
`
``
16
`+
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
`
``
17
`+
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
`
``
18
`+
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
`
``
19
`+
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
`
``
20
`+
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
`
``
21
`+
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
`
``
22
+
``
23
`+
******************************************************************/
`
``
24
+
``
25
`+
#include <cthreads.h>
`
``
26
+
``
27
+
``
28
`+
/*
`
``
29
`+
- Initialization.
`
``
30
`+
*/
`
``
31
`+
static void _init_thread _P0()
`
``
32
`+
{
`
``
33
`+
cthread_init();
`
``
34
`+
}
`
``
35
+
``
36
`+
/*
`
``
37
`+
- Thread support.
`
``
38
`+
*/
`
``
39
`+
int start_new_thread _P2(func, void (*func) _P((void *)), arg, void *arg)
`
``
40
`+
{
`
``
41
`+
#if defined(SGI_THREADS) && defined(USE_DL)
`
``
42
`+
long addr, size;
`
``
43
`+
static int local_initialized = 0;
`
``
44
`+
#endif /* SGI_THREADS and USE_DL */
`
``
45
`+
int success = 0; /* init not needed when SOLARIS_THREADS and */
`
``
46
`+
/* C_THREADS implemented properly */
`
``
47
+
``
48
`+
dprintf(("start_new_thread called\n"));
`
``
49
`+
if (!initialized)
`
``
50
`+
init_thread();
`
``
51
`+
(void) cthread_fork(func, arg);
`
``
52
`+
return success < 0 ? 0 : 1;
`
``
53
`+
}
`
``
54
+
``
55
`+
static void do_exit_thread _P1(no_cleanup, int no_cleanup)
`
``
56
`+
{
`
``
57
`+
dprintf(("exit_thread called\n"));
`
``
58
`+
if (!initialized)
`
``
59
`+
if (no_cleanup)
`
``
60
`+
_exit(0);
`
``
61
`+
else
`
``
62
`+
exit(0);
`
``
63
`+
cthread_exit(0);
`
``
64
`+
}
`
``
65
+
``
66
`+
void exit_thread _P0()
`
``
67
`+
{
`
``
68
`+
do_exit_thread(0);
`
``
69
`+
}
`
``
70
+
``
71
`+
void _exit_thread _P0()
`
``
72
`+
{
`
``
73
`+
do_exit_thread(1);
`
``
74
`+
}
`
``
75
+
``
76
`+
#ifndef NO_EXIT_PROG
`
``
77
`+
static void do_exit_prog _P2(status, int status, no_cleanup, int no_cleanup)
`
``
78
`+
{
`
``
79
`+
dprintf(("exit_prog(%d) called\n", status));
`
``
80
`+
if (!initialized)
`
``
81
`+
if (no_cleanup)
`
``
82
`+
_exit(status);
`
``
83
`+
else
`
``
84
`+
exit(status);
`
``
85
`+
}
`
``
86
+
``
87
`+
void exit_prog _P1(status, int status)
`
``
88
`+
{
`
``
89
`+
do_exit_prog(status, 0);
`
``
90
`+
}
`
``
91
+
``
92
`+
void _exit_prog _P1(status, int status)
`
``
93
`+
{
`
``
94
`+
do_exit_prog(status, 1);
`
``
95
`+
}
`
``
96
`+
#endif /* NO_EXIT_PROG */
`
``
97
+
``
98
`+
/*
`
``
99
`+
- Lock support.
`
``
100
`+
*/
`
``
101
`+
type_lock allocate_lock _P0()
`
``
102
`+
{
`
``
103
+
``
104
`+
dprintf(("allocate_lock called\n"));
`
``
105
`+
if (!initialized)
`
``
106
`+
init_thread();
`
``
107
+
``
108
`+
dprintf(("allocate_lock() -> %lx\n", (long)lock));
`
``
109
`+
return (type_lock) lock;
`
``
110
`+
}
`
``
111
+
``
112
`+
void free_lock _P1(lock, type_lock lock)
`
``
113
`+
{
`
``
114
`+
dprintf(("free_lock(%lx) called\n", (long)lock));
`
``
115
`+
}
`
``
116
+
``
117
`+
int acquire_lock _P2(lock, type_lock lock, waitflag, int waitflag)
`
``
118
`+
{
`
``
119
`+
int success;
`
``
120
+
``
121
`+
dprintf(("acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
`
``
122
`+
dprintf(("acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
`
``
123
`+
return success;
`
``
124
`+
}
`
``
125
+
``
126
`+
void release_lock _P1(lock, type_lock lock)
`
``
127
`+
{
`
``
128
`+
dprintf(("release_lock(%lx) called\n", (long)lock));
`
``
129
`+
}
`
``
130
+
``
131
`+
/*
`
``
132
`+
- Semaphore support.
`
``
133
`+
*/
`
``
134
`+
type_sema allocate_sema _P1(value, int value)
`
``
135
`+
{
`
``
136
`+
dprintf(("allocate_sema called\n"));
`
``
137
`+
if (!initialized)
`
``
138
`+
init_thread();
`
``
139
+
``
140
`+
dprintf(("allocate_sema() -> %lx\n", (long) sema));
`
``
141
`+
return (type_sema) sema;
`
``
142
`+
}
`
``
143
+
``
144
`+
void free_sema _P1(sema, type_sema sema)
`
``
145
`+
{
`
``
146
`+
dprintf(("free_sema(%lx) called\n", (long) sema));
`
``
147
`+
}
`
``
148
+
``
149
`+
void down_sema _P1(sema, type_sema sema)
`
``
150
`+
{
`
``
151
`+
dprintf(("down_sema(%lx) called\n", (long) sema));
`
``
152
`+
dprintf(("down_sema(%lx) return\n", (long) sema));
`
``
153
`+
}
`
``
154
+
``
155
`+
void up_sema _P1(sema, type_sema sema)
`
``
156
`+
{
`
``
157
`+
dprintf(("up_sema(%lx)\n", (long) sema));
`
``
158
`+
}
`