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