Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
6 : : # include "pycore_gc.h" // PyGC_Head
7 : : # include "pycore_runtime.h" // _Py_ID()
8 : : #endif
9 : :
10 : :
11 : : #if defined(HAVE_MP_SEMAPHORE) && defined(MS_WINDOWS)
12 : :
13 : : PyDoc_STRVAR(_multiprocessing_SemLock_acquire__doc__,
14 : : "acquire($self, /, block=True, timeout=None)\n"
15 : : "--\n"
16 : : "\n"
17 : : "Acquire the semaphore/lock.");
18 : :
19 : : #define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF \
20 : : {"acquire", _PyCFunction_CAST(_multiprocessing_SemLock_acquire), METH_FASTCALL|METH_KEYWORDS, _multiprocessing_SemLock_acquire__doc__},
21 : :
22 : : static PyObject *
23 : : _multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
24 : : PyObject *timeout_obj);
25 : :
26 : : static PyObject *
27 : : _multiprocessing_SemLock_acquire(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
28 : : {
29 : : PyObject *return_value = NULL;
30 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
31 : :
32 : : #define NUM_KEYWORDS 2
33 : : static struct {
34 : : PyGC_Head _this_is_not_used;
35 : : PyObject_VAR_HEAD
36 : : PyObject *ob_item[NUM_KEYWORDS];
37 : : } _kwtuple = {
38 : : .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
39 : : .ob_item = { &_Py_ID(block), &_Py_ID(timeout), },
40 : : };
41 : : #undef NUM_KEYWORDS
42 : : #define KWTUPLE (&_kwtuple.ob_base.ob_base)
43 : :
44 : : #else // !Py_BUILD_CORE
45 : : # define KWTUPLE NULL
46 : : #endif // !Py_BUILD_CORE
47 : :
48 : : static const char * const _keywords[] = {"block", "timeout", NULL};
49 : : static _PyArg_Parser _parser = {
50 : : .keywords = _keywords,
51 : : .fname = "acquire",
52 : : .kwtuple = KWTUPLE,
53 : : };
54 : : #undef KWTUPLE
55 : : PyObject *argsbuf[2];
56 : : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
57 : : int blocking = 1;
58 : : PyObject *timeout_obj = Py_None;
59 : :
60 : : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
61 : : if (!args) {
62 : : goto exit;
63 : : }
64 : : if (!noptargs) {
65 : : goto skip_optional_pos;
66 : : }
67 : : if (args[0]) {
68 : : blocking = PyObject_IsTrue(args[0]);
69 : : if (blocking < 0) {
70 : : goto exit;
71 : : }
72 : : if (!--noptargs) {
73 : : goto skip_optional_pos;
74 : : }
75 : : }
76 : : timeout_obj = args[1];
77 : : skip_optional_pos:
78 : : return_value = _multiprocessing_SemLock_acquire_impl(self, blocking, timeout_obj);
79 : :
80 : : exit:
81 : : return return_value;
82 : : }
83 : :
84 : : #endif /* defined(HAVE_MP_SEMAPHORE) && defined(MS_WINDOWS) */
85 : :
86 : : #if defined(HAVE_MP_SEMAPHORE) && defined(MS_WINDOWS)
87 : :
88 : : PyDoc_STRVAR(_multiprocessing_SemLock_release__doc__,
89 : : "release($self, /)\n"
90 : : "--\n"
91 : : "\n"
92 : : "Release the semaphore/lock.");
93 : :
94 : : #define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF \
95 : : {"release", (PyCFunction)_multiprocessing_SemLock_release, METH_NOARGS, _multiprocessing_SemLock_release__doc__},
96 : :
97 : : static PyObject *
98 : : _multiprocessing_SemLock_release_impl(SemLockObject *self);
99 : :
100 : : static PyObject *
101 : : _multiprocessing_SemLock_release(SemLockObject *self, PyObject *Py_UNUSED(ignored))
102 : : {
103 : : return _multiprocessing_SemLock_release_impl(self);
104 : : }
105 : :
106 : : #endif /* defined(HAVE_MP_SEMAPHORE) && defined(MS_WINDOWS) */
107 : :
108 : : #if defined(HAVE_MP_SEMAPHORE) && !defined(MS_WINDOWS)
109 : :
110 : : PyDoc_STRVAR(_multiprocessing_SemLock_acquire__doc__,
111 : : "acquire($self, /, block=True, timeout=None)\n"
112 : : "--\n"
113 : : "\n"
114 : : "Acquire the semaphore/lock.");
115 : :
116 : : #define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF \
117 : : {"acquire", _PyCFunction_CAST(_multiprocessing_SemLock_acquire), METH_FASTCALL|METH_KEYWORDS, _multiprocessing_SemLock_acquire__doc__},
118 : :
119 : : static PyObject *
120 : : _multiprocessing_SemLock_acquire_impl(SemLockObject *self, int blocking,
121 : : PyObject *timeout_obj);
122 : :
123 : : static PyObject *
124 : 0 : _multiprocessing_SemLock_acquire(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
125 : : {
126 : 0 : PyObject *return_value = NULL;
127 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
128 : :
129 : : #define NUM_KEYWORDS 2
130 : : static struct {
131 : : PyGC_Head _this_is_not_used;
132 : : PyObject_VAR_HEAD
133 : : PyObject *ob_item[NUM_KEYWORDS];
134 : : } _kwtuple = {
135 : : .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
136 : : .ob_item = { &_Py_ID(block), &_Py_ID(timeout), },
137 : : };
138 : : #undef NUM_KEYWORDS
139 : : #define KWTUPLE (&_kwtuple.ob_base.ob_base)
140 : :
141 : : #else // !Py_BUILD_CORE
142 : : # define KWTUPLE NULL
143 : : #endif // !Py_BUILD_CORE
144 : :
145 : : static const char * const _keywords[] = {"block", "timeout", NULL};
146 : : static _PyArg_Parser _parser = {
147 : : .keywords = _keywords,
148 : : .fname = "acquire",
149 : : .kwtuple = KWTUPLE,
150 : : };
151 : : #undef KWTUPLE
152 : : PyObject *argsbuf[2];
153 [ # # ]: 0 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
154 : 0 : int blocking = 1;
155 : 0 : PyObject *timeout_obj = Py_None;
156 : :
157 [ # # # # : 0 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
# # # # ]
158 [ # # ]: 0 : if (!args) {
159 : 0 : goto exit;
160 : : }
161 [ # # ]: 0 : if (!noptargs) {
162 : 0 : goto skip_optional_pos;
163 : : }
164 [ # # ]: 0 : if (args[0]) {
165 : 0 : blocking = PyObject_IsTrue(args[0]);
166 [ # # ]: 0 : if (blocking < 0) {
167 : 0 : goto exit;
168 : : }
169 [ # # ]: 0 : if (!--noptargs) {
170 : 0 : goto skip_optional_pos;
171 : : }
172 : : }
173 : 0 : timeout_obj = args[1];
174 : 0 : skip_optional_pos:
175 : 0 : return_value = _multiprocessing_SemLock_acquire_impl(self, blocking, timeout_obj);
176 : :
177 : 0 : exit:
178 : 0 : return return_value;
179 : : }
180 : :
181 : : #endif /* defined(HAVE_MP_SEMAPHORE) && !defined(MS_WINDOWS) */
182 : :
183 : : #if defined(HAVE_MP_SEMAPHORE) && !defined(MS_WINDOWS)
184 : :
185 : : PyDoc_STRVAR(_multiprocessing_SemLock_release__doc__,
186 : : "release($self, /)\n"
187 : : "--\n"
188 : : "\n"
189 : : "Release the semaphore/lock.");
190 : :
191 : : #define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF \
192 : : {"release", (PyCFunction)_multiprocessing_SemLock_release, METH_NOARGS, _multiprocessing_SemLock_release__doc__},
193 : :
194 : : static PyObject *
195 : : _multiprocessing_SemLock_release_impl(SemLockObject *self);
196 : :
197 : : static PyObject *
198 : 0 : _multiprocessing_SemLock_release(SemLockObject *self, PyObject *Py_UNUSED(ignored))
199 : : {
200 : 0 : return _multiprocessing_SemLock_release_impl(self);
201 : : }
202 : :
203 : : #endif /* defined(HAVE_MP_SEMAPHORE) && !defined(MS_WINDOWS) */
204 : :
205 : : #if defined(HAVE_MP_SEMAPHORE)
206 : :
207 : : static PyObject *
208 : : _multiprocessing_SemLock_impl(PyTypeObject *type, int kind, int value,
209 : : int maxvalue, const char *name, int unlink);
210 : :
211 : : static PyObject *
212 : 0 : _multiprocessing_SemLock(PyTypeObject *type, PyObject *args, PyObject *kwargs)
213 : : {
214 : 0 : PyObject *return_value = NULL;
215 : : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
216 : :
217 : : #define NUM_KEYWORDS 5
218 : : static struct {
219 : : PyGC_Head _this_is_not_used;
220 : : PyObject_VAR_HEAD
221 : : PyObject *ob_item[NUM_KEYWORDS];
222 : : } _kwtuple = {
223 : : .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
224 : : .ob_item = { &_Py_ID(kind), &_Py_ID(value), &_Py_ID(maxvalue), &_Py_ID(name), &_Py_ID(unlink), },
225 : : };
226 : : #undef NUM_KEYWORDS
227 : : #define KWTUPLE (&_kwtuple.ob_base.ob_base)
228 : :
229 : : #else // !Py_BUILD_CORE
230 : : # define KWTUPLE NULL
231 : : #endif // !Py_BUILD_CORE
232 : :
233 : : static const char * const _keywords[] = {"kind", "value", "maxvalue", "name", "unlink", NULL};
234 : : static _PyArg_Parser _parser = {
235 : : .keywords = _keywords,
236 : : .fname = "SemLock",
237 : : .kwtuple = KWTUPLE,
238 : : };
239 : : #undef KWTUPLE
240 : : PyObject *argsbuf[5];
241 : : PyObject * const *fastargs;
242 : 0 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
243 : : int kind;
244 : : int value;
245 : : int maxvalue;
246 : : const char *name;
247 : : int unlink;
248 : :
249 [ # # # # : 0 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 5, 5, 0, argsbuf);
# # # # ]
250 [ # # ]: 0 : if (!fastargs) {
251 : 0 : goto exit;
252 : : }
253 : 0 : kind = _PyLong_AsInt(fastargs[0]);
254 [ # # # # ]: 0 : if (kind == -1 && PyErr_Occurred()) {
255 : 0 : goto exit;
256 : : }
257 : 0 : value = _PyLong_AsInt(fastargs[1]);
258 [ # # # # ]: 0 : if (value == -1 && PyErr_Occurred()) {
259 : 0 : goto exit;
260 : : }
261 : 0 : maxvalue = _PyLong_AsInt(fastargs[2]);
262 [ # # # # ]: 0 : if (maxvalue == -1 && PyErr_Occurred()) {
263 : 0 : goto exit;
264 : : }
265 [ # # ]: 0 : if (!PyUnicode_Check(fastargs[3])) {
266 : 0 : _PyArg_BadArgument("SemLock", "argument 'name'", "str", fastargs[3]);
267 : 0 : goto exit;
268 : : }
269 : : Py_ssize_t name_length;
270 : 0 : name = PyUnicode_AsUTF8AndSize(fastargs[3], &name_length);
271 [ # # ]: 0 : if (name == NULL) {
272 : 0 : goto exit;
273 : : }
274 [ # # ]: 0 : if (strlen(name) != (size_t)name_length) {
275 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
276 : 0 : goto exit;
277 : : }
278 : 0 : unlink = PyObject_IsTrue(fastargs[4]);
279 [ # # ]: 0 : if (unlink < 0) {
280 : 0 : goto exit;
281 : : }
282 : 0 : return_value = _multiprocessing_SemLock_impl(type, kind, value, maxvalue, name, unlink);
283 : :
284 : 0 : exit:
285 : 0 : return return_value;
286 : : }
287 : :
288 : : #endif /* defined(HAVE_MP_SEMAPHORE) */
289 : :
290 : : #if defined(HAVE_MP_SEMAPHORE)
291 : :
292 : : PyDoc_STRVAR(_multiprocessing_SemLock__rebuild__doc__,
293 : : "_rebuild($type, handle, kind, maxvalue, name, /)\n"
294 : : "--\n"
295 : : "\n");
296 : :
297 : : #define _MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF \
298 : : {"_rebuild", _PyCFunction_CAST(_multiprocessing_SemLock__rebuild), METH_FASTCALL|METH_CLASS, _multiprocessing_SemLock__rebuild__doc__},
299 : :
300 : : static PyObject *
301 : : _multiprocessing_SemLock__rebuild_impl(PyTypeObject *type, SEM_HANDLE handle,
302 : : int kind, int maxvalue,
303 : : const char *name);
304 : :
305 : : static PyObject *
306 : 0 : _multiprocessing_SemLock__rebuild(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs)
307 : : {
308 : 0 : PyObject *return_value = NULL;
309 : : SEM_HANDLE handle;
310 : : int kind;
311 : : int maxvalue;
312 : : const char *name;
313 : :
314 [ # # ]: 0 : if (!_PyArg_ParseStack(args, nargs, ""F_SEM_HANDLE"iiz:_rebuild",
315 : : &handle, &kind, &maxvalue, &name)) {
316 : 0 : goto exit;
317 : : }
318 : 0 : return_value = _multiprocessing_SemLock__rebuild_impl(type, handle, kind, maxvalue, name);
319 : :
320 : 0 : exit:
321 : 0 : return return_value;
322 : : }
323 : :
324 : : #endif /* defined(HAVE_MP_SEMAPHORE) */
325 : :
326 : : #if defined(HAVE_MP_SEMAPHORE)
327 : :
328 : : PyDoc_STRVAR(_multiprocessing_SemLock__count__doc__,
329 : : "_count($self, /)\n"
330 : : "--\n"
331 : : "\n"
332 : : "Num of `acquire()`s minus num of `release()`s for this process.");
333 : :
334 : : #define _MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF \
335 : : {"_count", (PyCFunction)_multiprocessing_SemLock__count, METH_NOARGS, _multiprocessing_SemLock__count__doc__},
336 : :
337 : : static PyObject *
338 : : _multiprocessing_SemLock__count_impl(SemLockObject *self);
339 : :
340 : : static PyObject *
341 : 0 : _multiprocessing_SemLock__count(SemLockObject *self, PyObject *Py_UNUSED(ignored))
342 : : {
343 : 0 : return _multiprocessing_SemLock__count_impl(self);
344 : : }
345 : :
346 : : #endif /* defined(HAVE_MP_SEMAPHORE) */
347 : :
348 : : #if defined(HAVE_MP_SEMAPHORE)
349 : :
350 : : PyDoc_STRVAR(_multiprocessing_SemLock__is_mine__doc__,
351 : : "_is_mine($self, /)\n"
352 : : "--\n"
353 : : "\n"
354 : : "Whether the lock is owned by this thread.");
355 : :
356 : : #define _MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF \
357 : : {"_is_mine", (PyCFunction)_multiprocessing_SemLock__is_mine, METH_NOARGS, _multiprocessing_SemLock__is_mine__doc__},
358 : :
359 : : static PyObject *
360 : : _multiprocessing_SemLock__is_mine_impl(SemLockObject *self);
361 : :
362 : : static PyObject *
363 : 0 : _multiprocessing_SemLock__is_mine(SemLockObject *self, PyObject *Py_UNUSED(ignored))
364 : : {
365 : 0 : return _multiprocessing_SemLock__is_mine_impl(self);
366 : : }
367 : :
368 : : #endif /* defined(HAVE_MP_SEMAPHORE) */
369 : :
370 : : #if defined(HAVE_MP_SEMAPHORE)
371 : :
372 : : PyDoc_STRVAR(_multiprocessing_SemLock__get_value__doc__,
373 : : "_get_value($self, /)\n"
374 : : "--\n"
375 : : "\n"
376 : : "Get the value of the semaphore.");
377 : :
378 : : #define _MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF \
379 : : {"_get_value", (PyCFunction)_multiprocessing_SemLock__get_value, METH_NOARGS, _multiprocessing_SemLock__get_value__doc__},
380 : :
381 : : static PyObject *
382 : : _multiprocessing_SemLock__get_value_impl(SemLockObject *self);
383 : :
384 : : static PyObject *
385 : 0 : _multiprocessing_SemLock__get_value(SemLockObject *self, PyObject *Py_UNUSED(ignored))
386 : : {
387 : 0 : return _multiprocessing_SemLock__get_value_impl(self);
388 : : }
389 : :
390 : : #endif /* defined(HAVE_MP_SEMAPHORE) */
391 : :
392 : : #if defined(HAVE_MP_SEMAPHORE)
393 : :
394 : : PyDoc_STRVAR(_multiprocessing_SemLock__is_zero__doc__,
395 : : "_is_zero($self, /)\n"
396 : : "--\n"
397 : : "\n"
398 : : "Return whether semaphore has value zero.");
399 : :
400 : : #define _MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF \
401 : : {"_is_zero", (PyCFunction)_multiprocessing_SemLock__is_zero, METH_NOARGS, _multiprocessing_SemLock__is_zero__doc__},
402 : :
403 : : static PyObject *
404 : : _multiprocessing_SemLock__is_zero_impl(SemLockObject *self);
405 : :
406 : : static PyObject *
407 : 0 : _multiprocessing_SemLock__is_zero(SemLockObject *self, PyObject *Py_UNUSED(ignored))
408 : : {
409 : 0 : return _multiprocessing_SemLock__is_zero_impl(self);
410 : : }
411 : :
412 : : #endif /* defined(HAVE_MP_SEMAPHORE) */
413 : :
414 : : #if defined(HAVE_MP_SEMAPHORE)
415 : :
416 : : PyDoc_STRVAR(_multiprocessing_SemLock__after_fork__doc__,
417 : : "_after_fork($self, /)\n"
418 : : "--\n"
419 : : "\n"
420 : : "Rezero the net acquisition count after fork().");
421 : :
422 : : #define _MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF \
423 : : {"_after_fork", (PyCFunction)_multiprocessing_SemLock__after_fork, METH_NOARGS, _multiprocessing_SemLock__after_fork__doc__},
424 : :
425 : : static PyObject *
426 : : _multiprocessing_SemLock__after_fork_impl(SemLockObject *self);
427 : :
428 : : static PyObject *
429 : 0 : _multiprocessing_SemLock__after_fork(SemLockObject *self, PyObject *Py_UNUSED(ignored))
430 : : {
431 : 0 : return _multiprocessing_SemLock__after_fork_impl(self);
432 : : }
433 : :
434 : : #endif /* defined(HAVE_MP_SEMAPHORE) */
435 : :
436 : : #if defined(HAVE_MP_SEMAPHORE)
437 : :
438 : : PyDoc_STRVAR(_multiprocessing_SemLock___enter____doc__,
439 : : "__enter__($self, /)\n"
440 : : "--\n"
441 : : "\n"
442 : : "Enter the semaphore/lock.");
443 : :
444 : : #define _MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF \
445 : : {"__enter__", (PyCFunction)_multiprocessing_SemLock___enter__, METH_NOARGS, _multiprocessing_SemLock___enter____doc__},
446 : :
447 : : static PyObject *
448 : : _multiprocessing_SemLock___enter___impl(SemLockObject *self);
449 : :
450 : : static PyObject *
451 : 0 : _multiprocessing_SemLock___enter__(SemLockObject *self, PyObject *Py_UNUSED(ignored))
452 : : {
453 : 0 : return _multiprocessing_SemLock___enter___impl(self);
454 : : }
455 : :
456 : : #endif /* defined(HAVE_MP_SEMAPHORE) */
457 : :
458 : : #if defined(HAVE_MP_SEMAPHORE)
459 : :
460 : : PyDoc_STRVAR(_multiprocessing_SemLock___exit____doc__,
461 : : "__exit__($self, exc_type=None, exc_value=None, exc_tb=None, /)\n"
462 : : "--\n"
463 : : "\n"
464 : : "Exit the semaphore/lock.");
465 : :
466 : : #define _MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF \
467 : : {"__exit__", _PyCFunction_CAST(_multiprocessing_SemLock___exit__), METH_FASTCALL, _multiprocessing_SemLock___exit____doc__},
468 : :
469 : : static PyObject *
470 : : _multiprocessing_SemLock___exit___impl(SemLockObject *self,
471 : : PyObject *exc_type,
472 : : PyObject *exc_value, PyObject *exc_tb);
473 : :
474 : : static PyObject *
475 : 0 : _multiprocessing_SemLock___exit__(SemLockObject *self, PyObject *const *args, Py_ssize_t nargs)
476 : : {
477 : 0 : PyObject *return_value = NULL;
478 : 0 : PyObject *exc_type = Py_None;
479 : 0 : PyObject *exc_value = Py_None;
480 : 0 : PyObject *exc_tb = Py_None;
481 : :
482 [ # # # # : 0 : if (!_PyArg_CheckPositional("__exit__", nargs, 0, 3)) {
# # ]
483 : 0 : goto exit;
484 : : }
485 [ # # ]: 0 : if (nargs < 1) {
486 : 0 : goto skip_optional;
487 : : }
488 : 0 : exc_type = args[0];
489 [ # # ]: 0 : if (nargs < 2) {
490 : 0 : goto skip_optional;
491 : : }
492 : 0 : exc_value = args[1];
493 [ # # ]: 0 : if (nargs < 3) {
494 : 0 : goto skip_optional;
495 : : }
496 : 0 : exc_tb = args[2];
497 : 0 : skip_optional:
498 : 0 : return_value = _multiprocessing_SemLock___exit___impl(self, exc_type, exc_value, exc_tb);
499 : :
500 : 0 : exit:
501 : 0 : return return_value;
502 : : }
503 : :
504 : : #endif /* defined(HAVE_MP_SEMAPHORE) */
505 : :
506 : : #ifndef _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF
507 : : #define _MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF
508 : : #endif /* !defined(_MULTIPROCESSING_SEMLOCK_ACQUIRE_METHODDEF) */
509 : :
510 : : #ifndef _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF
511 : : #define _MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF
512 : : #endif /* !defined(_MULTIPROCESSING_SEMLOCK_RELEASE_METHODDEF) */
513 : :
514 : : #ifndef _MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF
515 : : #define _MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF
516 : : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__REBUILD_METHODDEF) */
517 : :
518 : : #ifndef _MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF
519 : : #define _MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF
520 : : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__COUNT_METHODDEF) */
521 : :
522 : : #ifndef _MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF
523 : : #define _MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF
524 : : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__IS_MINE_METHODDEF) */
525 : :
526 : : #ifndef _MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF
527 : : #define _MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF
528 : : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__GET_VALUE_METHODDEF) */
529 : :
530 : : #ifndef _MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF
531 : : #define _MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF
532 : : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__IS_ZERO_METHODDEF) */
533 : :
534 : : #ifndef _MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF
535 : : #define _MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF
536 : : #endif /* !defined(_MULTIPROCESSING_SEMLOCK__AFTER_FORK_METHODDEF) */
537 : :
538 : : #ifndef _MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF
539 : : #define _MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF
540 : : #endif /* !defined(_MULTIPROCESSING_SEMLOCK___ENTER___METHODDEF) */
541 : :
542 : : #ifndef _MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF
543 : : #define _MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF
544 : : #endif /* !defined(_MULTIPROCESSING_SEMLOCK___EXIT___METHODDEF) */
545 : : /*[clinic end generated code: output=dae57a702cc01512 input=a9049054013a1b77]*/
|