1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 #if defined(HAVE_ALARM)
6
7 PyDoc_STRVAR(signal_alarm__doc__,
8 "alarm($module, seconds, /)\n"
9 "--\n"
10 "\n"
11 "Arrange for SIGALRM to arrive after the given number of seconds.");
12
13 #define SIGNAL_ALARM_METHODDEF \
14 {"alarm", (PyCFunction)signal_alarm, METH_O, signal_alarm__doc__},
15
16 static long
17 signal_alarm_impl(PyObject *module, int seconds);
18
19 static PyObject *
signal_alarm(PyObject * module,PyObject * arg)20 signal_alarm(PyObject *module, PyObject *arg)
21 {
22 PyObject *return_value = NULL;
23 int seconds;
24 long _return_value;
25
26 if (PyFloat_Check(arg)) {
27 PyErr_SetString(PyExc_TypeError,
28 "integer argument expected, got float" );
29 goto exit;
30 }
31 seconds = _PyLong_AsInt(arg);
32 if (seconds == -1 && PyErr_Occurred()) {
33 goto exit;
34 }
35 _return_value = signal_alarm_impl(module, seconds);
36 if ((_return_value == -1) && PyErr_Occurred()) {
37 goto exit;
38 }
39 return_value = PyLong_FromLong(_return_value);
40
41 exit:
42 return return_value;
43 }
44
45 #endif /* defined(HAVE_ALARM) */
46
47 #if defined(HAVE_PAUSE)
48
49 PyDoc_STRVAR(signal_pause__doc__,
50 "pause($module, /)\n"
51 "--\n"
52 "\n"
53 "Wait until a signal arrives.");
54
55 #define SIGNAL_PAUSE_METHODDEF \
56 {"pause", (PyCFunction)signal_pause, METH_NOARGS, signal_pause__doc__},
57
58 static PyObject *
59 signal_pause_impl(PyObject *module);
60
61 static PyObject *
signal_pause(PyObject * module,PyObject * Py_UNUSED (ignored))62 signal_pause(PyObject *module, PyObject *Py_UNUSED(ignored))
63 {
64 return signal_pause_impl(module);
65 }
66
67 #endif /* defined(HAVE_PAUSE) */
68
69 PyDoc_STRVAR(signal_raise_signal__doc__,
70 "raise_signal($module, signalnum, /)\n"
71 "--\n"
72 "\n"
73 "Send a signal to the executing process.");
74
75 #define SIGNAL_RAISE_SIGNAL_METHODDEF \
76 {"raise_signal", (PyCFunction)signal_raise_signal, METH_O, signal_raise_signal__doc__},
77
78 static PyObject *
79 signal_raise_signal_impl(PyObject *module, int signalnum);
80
81 static PyObject *
signal_raise_signal(PyObject * module,PyObject * arg)82 signal_raise_signal(PyObject *module, PyObject *arg)
83 {
84 PyObject *return_value = NULL;
85 int signalnum;
86
87 if (PyFloat_Check(arg)) {
88 PyErr_SetString(PyExc_TypeError,
89 "integer argument expected, got float" );
90 goto exit;
91 }
92 signalnum = _PyLong_AsInt(arg);
93 if (signalnum == -1 && PyErr_Occurred()) {
94 goto exit;
95 }
96 return_value = signal_raise_signal_impl(module, signalnum);
97
98 exit:
99 return return_value;
100 }
101
102 PyDoc_STRVAR(signal_signal__doc__,
103 "signal($module, signalnum, handler, /)\n"
104 "--\n"
105 "\n"
106 "Set the action for the given signal.\n"
107 "\n"
108 "The action can be SIG_DFL, SIG_IGN, or a callable Python object.\n"
109 "The previous action is returned. See getsignal() for possible return values.\n"
110 "\n"
111 "*** IMPORTANT NOTICE ***\n"
112 "A signal handler function is called with two arguments:\n"
113 "the first is the signal number, the second is the interrupted stack frame.");
114
115 #define SIGNAL_SIGNAL_METHODDEF \
116 {"signal", (PyCFunction)(void(*)(void))signal_signal, METH_FASTCALL, signal_signal__doc__},
117
118 static PyObject *
119 signal_signal_impl(PyObject *module, int signalnum, PyObject *handler);
120
121 static PyObject *
signal_signal(PyObject * module,PyObject * const * args,Py_ssize_t nargs)122 signal_signal(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
123 {
124 PyObject *return_value = NULL;
125 int signalnum;
126 PyObject *handler;
127
128 if (!_PyArg_CheckPositional("signal", nargs, 2, 2)) {
129 goto exit;
130 }
131 if (PyFloat_Check(args[0])) {
132 PyErr_SetString(PyExc_TypeError,
133 "integer argument expected, got float" );
134 goto exit;
135 }
136 signalnum = _PyLong_AsInt(args[0]);
137 if (signalnum == -1 && PyErr_Occurred()) {
138 goto exit;
139 }
140 handler = args[1];
141 return_value = signal_signal_impl(module, signalnum, handler);
142
143 exit:
144 return return_value;
145 }
146
147 PyDoc_STRVAR(signal_getsignal__doc__,
148 "getsignal($module, signalnum, /)\n"
149 "--\n"
150 "\n"
151 "Return the current action for the given signal.\n"
152 "\n"
153 "The return value can be:\n"
154 " SIG_IGN -- if the signal is being ignored\n"
155 " SIG_DFL -- if the default action for the signal is in effect\n"
156 " None -- if an unknown handler is in effect\n"
157 " anything else -- the callable Python object used as a handler");
158
159 #define SIGNAL_GETSIGNAL_METHODDEF \
160 {"getsignal", (PyCFunction)signal_getsignal, METH_O, signal_getsignal__doc__},
161
162 static PyObject *
163 signal_getsignal_impl(PyObject *module, int signalnum);
164
165 static PyObject *
signal_getsignal(PyObject * module,PyObject * arg)166 signal_getsignal(PyObject *module, PyObject *arg)
167 {
168 PyObject *return_value = NULL;
169 int signalnum;
170
171 if (PyFloat_Check(arg)) {
172 PyErr_SetString(PyExc_TypeError,
173 "integer argument expected, got float" );
174 goto exit;
175 }
176 signalnum = _PyLong_AsInt(arg);
177 if (signalnum == -1 && PyErr_Occurred()) {
178 goto exit;
179 }
180 return_value = signal_getsignal_impl(module, signalnum);
181
182 exit:
183 return return_value;
184 }
185
186 PyDoc_STRVAR(signal_strsignal__doc__,
187 "strsignal($module, signalnum, /)\n"
188 "--\n"
189 "\n"
190 "Return the system description of the given signal.\n"
191 "\n"
192 "The return values can be such as \"Interrupt\", \"Segmentation fault\", etc.\n"
193 "Returns None if the signal is not recognized.");
194
195 #define SIGNAL_STRSIGNAL_METHODDEF \
196 {"strsignal", (PyCFunction)signal_strsignal, METH_O, signal_strsignal__doc__},
197
198 static PyObject *
199 signal_strsignal_impl(PyObject *module, int signalnum);
200
201 static PyObject *
signal_strsignal(PyObject * module,PyObject * arg)202 signal_strsignal(PyObject *module, PyObject *arg)
203 {
204 PyObject *return_value = NULL;
205 int signalnum;
206
207 if (PyFloat_Check(arg)) {
208 PyErr_SetString(PyExc_TypeError,
209 "integer argument expected, got float" );
210 goto exit;
211 }
212 signalnum = _PyLong_AsInt(arg);
213 if (signalnum == -1 && PyErr_Occurred()) {
214 goto exit;
215 }
216 return_value = signal_strsignal_impl(module, signalnum);
217
218 exit:
219 return return_value;
220 }
221
222 #if defined(HAVE_SIGINTERRUPT)
223
224 PyDoc_STRVAR(signal_siginterrupt__doc__,
225 "siginterrupt($module, signalnum, flag, /)\n"
226 "--\n"
227 "\n"
228 "Change system call restart behaviour.\n"
229 "\n"
230 "If flag is False, system calls will be restarted when interrupted by\n"
231 "signal sig, else system calls will be interrupted.");
232
233 #define SIGNAL_SIGINTERRUPT_METHODDEF \
234 {"siginterrupt", (PyCFunction)(void(*)(void))signal_siginterrupt, METH_FASTCALL, signal_siginterrupt__doc__},
235
236 static PyObject *
237 signal_siginterrupt_impl(PyObject *module, int signalnum, int flag);
238
239 static PyObject *
signal_siginterrupt(PyObject * module,PyObject * const * args,Py_ssize_t nargs)240 signal_siginterrupt(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
241 {
242 PyObject *return_value = NULL;
243 int signalnum;
244 int flag;
245
246 if (!_PyArg_CheckPositional("siginterrupt", nargs, 2, 2)) {
247 goto exit;
248 }
249 if (PyFloat_Check(args[0])) {
250 PyErr_SetString(PyExc_TypeError,
251 "integer argument expected, got float" );
252 goto exit;
253 }
254 signalnum = _PyLong_AsInt(args[0]);
255 if (signalnum == -1 && PyErr_Occurred()) {
256 goto exit;
257 }
258 if (PyFloat_Check(args[1])) {
259 PyErr_SetString(PyExc_TypeError,
260 "integer argument expected, got float" );
261 goto exit;
262 }
263 flag = _PyLong_AsInt(args[1]);
264 if (flag == -1 && PyErr_Occurred()) {
265 goto exit;
266 }
267 return_value = signal_siginterrupt_impl(module, signalnum, flag);
268
269 exit:
270 return return_value;
271 }
272
273 #endif /* defined(HAVE_SIGINTERRUPT) */
274
275 #if defined(HAVE_SETITIMER)
276
277 PyDoc_STRVAR(signal_setitimer__doc__,
278 "setitimer($module, which, seconds, interval=0.0, /)\n"
279 "--\n"
280 "\n"
281 "Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL or ITIMER_PROF).\n"
282 "\n"
283 "The timer will fire after value seconds and after that every interval seconds.\n"
284 "The itimer can be cleared by setting seconds to zero.\n"
285 "\n"
286 "Returns old values as a tuple: (delay, interval).");
287
288 #define SIGNAL_SETITIMER_METHODDEF \
289 {"setitimer", (PyCFunction)(void(*)(void))signal_setitimer, METH_FASTCALL, signal_setitimer__doc__},
290
291 static PyObject *
292 signal_setitimer_impl(PyObject *module, int which, PyObject *seconds,
293 PyObject *interval);
294
295 static PyObject *
signal_setitimer(PyObject * module,PyObject * const * args,Py_ssize_t nargs)296 signal_setitimer(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
297 {
298 PyObject *return_value = NULL;
299 int which;
300 PyObject *seconds;
301 PyObject *interval = NULL;
302
303 if (!_PyArg_CheckPositional("setitimer", nargs, 2, 3)) {
304 goto exit;
305 }
306 if (PyFloat_Check(args[0])) {
307 PyErr_SetString(PyExc_TypeError,
308 "integer argument expected, got float" );
309 goto exit;
310 }
311 which = _PyLong_AsInt(args[0]);
312 if (which == -1 && PyErr_Occurred()) {
313 goto exit;
314 }
315 seconds = args[1];
316 if (nargs < 3) {
317 goto skip_optional;
318 }
319 interval = args[2];
320 skip_optional:
321 return_value = signal_setitimer_impl(module, which, seconds, interval);
322
323 exit:
324 return return_value;
325 }
326
327 #endif /* defined(HAVE_SETITIMER) */
328
329 #if defined(HAVE_GETITIMER)
330
331 PyDoc_STRVAR(signal_getitimer__doc__,
332 "getitimer($module, which, /)\n"
333 "--\n"
334 "\n"
335 "Returns current value of given itimer.");
336
337 #define SIGNAL_GETITIMER_METHODDEF \
338 {"getitimer", (PyCFunction)signal_getitimer, METH_O, signal_getitimer__doc__},
339
340 static PyObject *
341 signal_getitimer_impl(PyObject *module, int which);
342
343 static PyObject *
signal_getitimer(PyObject * module,PyObject * arg)344 signal_getitimer(PyObject *module, PyObject *arg)
345 {
346 PyObject *return_value = NULL;
347 int which;
348
349 if (PyFloat_Check(arg)) {
350 PyErr_SetString(PyExc_TypeError,
351 "integer argument expected, got float" );
352 goto exit;
353 }
354 which = _PyLong_AsInt(arg);
355 if (which == -1 && PyErr_Occurred()) {
356 goto exit;
357 }
358 return_value = signal_getitimer_impl(module, which);
359
360 exit:
361 return return_value;
362 }
363
364 #endif /* defined(HAVE_GETITIMER) */
365
366 #if defined(PYPTHREAD_SIGMASK)
367
368 PyDoc_STRVAR(signal_pthread_sigmask__doc__,
369 "pthread_sigmask($module, how, mask, /)\n"
370 "--\n"
371 "\n"
372 "Fetch and/or change the signal mask of the calling thread.");
373
374 #define SIGNAL_PTHREAD_SIGMASK_METHODDEF \
375 {"pthread_sigmask", (PyCFunction)(void(*)(void))signal_pthread_sigmask, METH_FASTCALL, signal_pthread_sigmask__doc__},
376
377 static PyObject *
378 signal_pthread_sigmask_impl(PyObject *module, int how, sigset_t mask);
379
380 static PyObject *
signal_pthread_sigmask(PyObject * module,PyObject * const * args,Py_ssize_t nargs)381 signal_pthread_sigmask(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
382 {
383 PyObject *return_value = NULL;
384 int how;
385 sigset_t mask;
386
387 if (!_PyArg_CheckPositional("pthread_sigmask", nargs, 2, 2)) {
388 goto exit;
389 }
390 if (PyFloat_Check(args[0])) {
391 PyErr_SetString(PyExc_TypeError,
392 "integer argument expected, got float" );
393 goto exit;
394 }
395 how = _PyLong_AsInt(args[0]);
396 if (how == -1 && PyErr_Occurred()) {
397 goto exit;
398 }
399 if (!_Py_Sigset_Converter(args[1], &mask)) {
400 goto exit;
401 }
402 return_value = signal_pthread_sigmask_impl(module, how, mask);
403
404 exit:
405 return return_value;
406 }
407
408 #endif /* defined(PYPTHREAD_SIGMASK) */
409
410 #if defined(HAVE_SIGPENDING)
411
412 PyDoc_STRVAR(signal_sigpending__doc__,
413 "sigpending($module, /)\n"
414 "--\n"
415 "\n"
416 "Examine pending signals.\n"
417 "\n"
418 "Returns a set of signal numbers that are pending for delivery to\n"
419 "the calling thread.");
420
421 #define SIGNAL_SIGPENDING_METHODDEF \
422 {"sigpending", (PyCFunction)signal_sigpending, METH_NOARGS, signal_sigpending__doc__},
423
424 static PyObject *
425 signal_sigpending_impl(PyObject *module);
426
427 static PyObject *
signal_sigpending(PyObject * module,PyObject * Py_UNUSED (ignored))428 signal_sigpending(PyObject *module, PyObject *Py_UNUSED(ignored))
429 {
430 return signal_sigpending_impl(module);
431 }
432
433 #endif /* defined(HAVE_SIGPENDING) */
434
435 #if defined(HAVE_SIGWAIT)
436
437 PyDoc_STRVAR(signal_sigwait__doc__,
438 "sigwait($module, sigset, /)\n"
439 "--\n"
440 "\n"
441 "Wait for a signal.\n"
442 "\n"
443 "Suspend execution of the calling thread until the delivery of one of the\n"
444 "signals specified in the signal set sigset. The function accepts the signal\n"
445 "and returns the signal number.");
446
447 #define SIGNAL_SIGWAIT_METHODDEF \
448 {"sigwait", (PyCFunction)signal_sigwait, METH_O, signal_sigwait__doc__},
449
450 static PyObject *
451 signal_sigwait_impl(PyObject *module, sigset_t sigset);
452
453 static PyObject *
signal_sigwait(PyObject * module,PyObject * arg)454 signal_sigwait(PyObject *module, PyObject *arg)
455 {
456 PyObject *return_value = NULL;
457 sigset_t sigset;
458
459 if (!_Py_Sigset_Converter(arg, &sigset)) {
460 goto exit;
461 }
462 return_value = signal_sigwait_impl(module, sigset);
463
464 exit:
465 return return_value;
466 }
467
468 #endif /* defined(HAVE_SIGWAIT) */
469
470 #if (defined(HAVE_SIGFILLSET) || defined(MS_WINDOWS))
471
472 PyDoc_STRVAR(signal_valid_signals__doc__,
473 "valid_signals($module, /)\n"
474 "--\n"
475 "\n"
476 "Return a set of valid signal numbers on this platform.\n"
477 "\n"
478 "The signal numbers returned by this function can be safely passed to\n"
479 "functions like `pthread_sigmask`.");
480
481 #define SIGNAL_VALID_SIGNALS_METHODDEF \
482 {"valid_signals", (PyCFunction)signal_valid_signals, METH_NOARGS, signal_valid_signals__doc__},
483
484 static PyObject *
485 signal_valid_signals_impl(PyObject *module);
486
487 static PyObject *
signal_valid_signals(PyObject * module,PyObject * Py_UNUSED (ignored))488 signal_valid_signals(PyObject *module, PyObject *Py_UNUSED(ignored))
489 {
490 return signal_valid_signals_impl(module);
491 }
492
493 #endif /* (defined(HAVE_SIGFILLSET) || defined(MS_WINDOWS)) */
494
495 #if defined(HAVE_SIGWAITINFO)
496
497 PyDoc_STRVAR(signal_sigwaitinfo__doc__,
498 "sigwaitinfo($module, sigset, /)\n"
499 "--\n"
500 "\n"
501 "Wait synchronously until one of the signals in *sigset* is delivered.\n"
502 "\n"
503 "Returns a struct_siginfo containing information about the signal.");
504
505 #define SIGNAL_SIGWAITINFO_METHODDEF \
506 {"sigwaitinfo", (PyCFunction)signal_sigwaitinfo, METH_O, signal_sigwaitinfo__doc__},
507
508 static PyObject *
509 signal_sigwaitinfo_impl(PyObject *module, sigset_t sigset);
510
511 static PyObject *
signal_sigwaitinfo(PyObject * module,PyObject * arg)512 signal_sigwaitinfo(PyObject *module, PyObject *arg)
513 {
514 PyObject *return_value = NULL;
515 sigset_t sigset;
516
517 if (!_Py_Sigset_Converter(arg, &sigset)) {
518 goto exit;
519 }
520 return_value = signal_sigwaitinfo_impl(module, sigset);
521
522 exit:
523 return return_value;
524 }
525
526 #endif /* defined(HAVE_SIGWAITINFO) */
527
528 #if defined(HAVE_SIGTIMEDWAIT)
529
530 PyDoc_STRVAR(signal_sigtimedwait__doc__,
531 "sigtimedwait($module, sigset, timeout, /)\n"
532 "--\n"
533 "\n"
534 "Like sigwaitinfo(), but with a timeout.\n"
535 "\n"
536 "The timeout is specified in seconds, with floating point numbers allowed.");
537
538 #define SIGNAL_SIGTIMEDWAIT_METHODDEF \
539 {"sigtimedwait", (PyCFunction)(void(*)(void))signal_sigtimedwait, METH_FASTCALL, signal_sigtimedwait__doc__},
540
541 static PyObject *
542 signal_sigtimedwait_impl(PyObject *module, sigset_t sigset,
543 PyObject *timeout_obj);
544
545 static PyObject *
signal_sigtimedwait(PyObject * module,PyObject * const * args,Py_ssize_t nargs)546 signal_sigtimedwait(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
547 {
548 PyObject *return_value = NULL;
549 sigset_t sigset;
550 PyObject *timeout_obj;
551
552 if (!_PyArg_CheckPositional("sigtimedwait", nargs, 2, 2)) {
553 goto exit;
554 }
555 if (!_Py_Sigset_Converter(args[0], &sigset)) {
556 goto exit;
557 }
558 timeout_obj = args[1];
559 return_value = signal_sigtimedwait_impl(module, sigset, timeout_obj);
560
561 exit:
562 return return_value;
563 }
564
565 #endif /* defined(HAVE_SIGTIMEDWAIT) */
566
567 #if defined(HAVE_PTHREAD_KILL)
568
569 PyDoc_STRVAR(signal_pthread_kill__doc__,
570 "pthread_kill($module, thread_id, signalnum, /)\n"
571 "--\n"
572 "\n"
573 "Send a signal to a thread.");
574
575 #define SIGNAL_PTHREAD_KILL_METHODDEF \
576 {"pthread_kill", (PyCFunction)(void(*)(void))signal_pthread_kill, METH_FASTCALL, signal_pthread_kill__doc__},
577
578 static PyObject *
579 signal_pthread_kill_impl(PyObject *module, unsigned long thread_id,
580 int signalnum);
581
582 static PyObject *
signal_pthread_kill(PyObject * module,PyObject * const * args,Py_ssize_t nargs)583 signal_pthread_kill(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
584 {
585 PyObject *return_value = NULL;
586 unsigned long thread_id;
587 int signalnum;
588
589 if (!_PyArg_CheckPositional("pthread_kill", nargs, 2, 2)) {
590 goto exit;
591 }
592 if (!PyLong_Check(args[0])) {
593 _PyArg_BadArgument("pthread_kill", "argument 1", "int", args[0]);
594 goto exit;
595 }
596 thread_id = PyLong_AsUnsignedLongMask(args[0]);
597 if (PyFloat_Check(args[1])) {
598 PyErr_SetString(PyExc_TypeError,
599 "integer argument expected, got float" );
600 goto exit;
601 }
602 signalnum = _PyLong_AsInt(args[1]);
603 if (signalnum == -1 && PyErr_Occurred()) {
604 goto exit;
605 }
606 return_value = signal_pthread_kill_impl(module, thread_id, signalnum);
607
608 exit:
609 return return_value;
610 }
611
612 #endif /* defined(HAVE_PTHREAD_KILL) */
613
614 #ifndef SIGNAL_ALARM_METHODDEF
615 #define SIGNAL_ALARM_METHODDEF
616 #endif /* !defined(SIGNAL_ALARM_METHODDEF) */
617
618 #ifndef SIGNAL_PAUSE_METHODDEF
619 #define SIGNAL_PAUSE_METHODDEF
620 #endif /* !defined(SIGNAL_PAUSE_METHODDEF) */
621
622 #ifndef SIGNAL_SIGINTERRUPT_METHODDEF
623 #define SIGNAL_SIGINTERRUPT_METHODDEF
624 #endif /* !defined(SIGNAL_SIGINTERRUPT_METHODDEF) */
625
626 #ifndef SIGNAL_SETITIMER_METHODDEF
627 #define SIGNAL_SETITIMER_METHODDEF
628 #endif /* !defined(SIGNAL_SETITIMER_METHODDEF) */
629
630 #ifndef SIGNAL_GETITIMER_METHODDEF
631 #define SIGNAL_GETITIMER_METHODDEF
632 #endif /* !defined(SIGNAL_GETITIMER_METHODDEF) */
633
634 #ifndef SIGNAL_PTHREAD_SIGMASK_METHODDEF
635 #define SIGNAL_PTHREAD_SIGMASK_METHODDEF
636 #endif /* !defined(SIGNAL_PTHREAD_SIGMASK_METHODDEF) */
637
638 #ifndef SIGNAL_SIGPENDING_METHODDEF
639 #define SIGNAL_SIGPENDING_METHODDEF
640 #endif /* !defined(SIGNAL_SIGPENDING_METHODDEF) */
641
642 #ifndef SIGNAL_SIGWAIT_METHODDEF
643 #define SIGNAL_SIGWAIT_METHODDEF
644 #endif /* !defined(SIGNAL_SIGWAIT_METHODDEF) */
645
646 #ifndef SIGNAL_VALID_SIGNALS_METHODDEF
647 #define SIGNAL_VALID_SIGNALS_METHODDEF
648 #endif /* !defined(SIGNAL_VALID_SIGNALS_METHODDEF) */
649
650 #ifndef SIGNAL_SIGWAITINFO_METHODDEF
651 #define SIGNAL_SIGWAITINFO_METHODDEF
652 #endif /* !defined(SIGNAL_SIGWAITINFO_METHODDEF) */
653
654 #ifndef SIGNAL_SIGTIMEDWAIT_METHODDEF
655 #define SIGNAL_SIGTIMEDWAIT_METHODDEF
656 #endif /* !defined(SIGNAL_SIGTIMEDWAIT_METHODDEF) */
657
658 #ifndef SIGNAL_PTHREAD_KILL_METHODDEF
659 #define SIGNAL_PTHREAD_KILL_METHODDEF
660 #endif /* !defined(SIGNAL_PTHREAD_KILL_METHODDEF) */
661 /*[clinic end generated code: output=3320b8f73c20ba60 input=a9049054013a1b77]*/
662