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 (!PyArg_Parse(arg, "i:alarm", &seconds)) {
27 goto exit;
28 }
29 _return_value = signal_alarm_impl(module, seconds);
30 if ((_return_value == -1) && PyErr_Occurred()) {
31 goto exit;
32 }
33 return_value = PyLong_FromLong(_return_value);
34
35 exit:
36 return return_value;
37 }
38
39 #endif /* defined(HAVE_ALARM) */
40
41 #if defined(HAVE_PAUSE)
42
43 PyDoc_STRVAR(signal_pause__doc__,
44 "pause($module, /)\n"
45 "--\n"
46 "\n"
47 "Wait until a signal arrives.");
48
49 #define SIGNAL_PAUSE_METHODDEF \
50 {"pause", (PyCFunction)signal_pause, METH_NOARGS, signal_pause__doc__},
51
52 static PyObject *
53 signal_pause_impl(PyObject *module);
54
55 static PyObject *
signal_pause(PyObject * module,PyObject * Py_UNUSED (ignored))56 signal_pause(PyObject *module, PyObject *Py_UNUSED(ignored))
57 {
58 return signal_pause_impl(module);
59 }
60
61 #endif /* defined(HAVE_PAUSE) */
62
63 PyDoc_STRVAR(signal_signal__doc__,
64 "signal($module, signalnum, handler, /)\n"
65 "--\n"
66 "\n"
67 "Set the action for the given signal.\n"
68 "\n"
69 "The action can be SIG_DFL, SIG_IGN, or a callable Python object.\n"
70 "The previous action is returned. See getsignal() for possible return values.\n"
71 "\n"
72 "*** IMPORTANT NOTICE ***\n"
73 "A signal handler function is called with two arguments:\n"
74 "the first is the signal number, the second is the interrupted stack frame.");
75
76 #define SIGNAL_SIGNAL_METHODDEF \
77 {"signal", (PyCFunction)signal_signal, METH_FASTCALL, signal_signal__doc__},
78
79 static PyObject *
80 signal_signal_impl(PyObject *module, int signalnum, PyObject *handler);
81
82 static PyObject *
signal_signal(PyObject * module,PyObject * const * args,Py_ssize_t nargs)83 signal_signal(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
84 {
85 PyObject *return_value = NULL;
86 int signalnum;
87 PyObject *handler;
88
89 if (!_PyArg_ParseStack(args, nargs, "iO:signal",
90 &signalnum, &handler)) {
91 goto exit;
92 }
93 return_value = signal_signal_impl(module, signalnum, handler);
94
95 exit:
96 return return_value;
97 }
98
99 PyDoc_STRVAR(signal_getsignal__doc__,
100 "getsignal($module, signalnum, /)\n"
101 "--\n"
102 "\n"
103 "Return the current action for the given signal.\n"
104 "\n"
105 "The return value can be:\n"
106 " SIG_IGN -- if the signal is being ignored\n"
107 " SIG_DFL -- if the default action for the signal is in effect\n"
108 " None -- if an unknown handler is in effect\n"
109 " anything else -- the callable Python object used as a handler");
110
111 #define SIGNAL_GETSIGNAL_METHODDEF \
112 {"getsignal", (PyCFunction)signal_getsignal, METH_O, signal_getsignal__doc__},
113
114 static PyObject *
115 signal_getsignal_impl(PyObject *module, int signalnum);
116
117 static PyObject *
signal_getsignal(PyObject * module,PyObject * arg)118 signal_getsignal(PyObject *module, PyObject *arg)
119 {
120 PyObject *return_value = NULL;
121 int signalnum;
122
123 if (!PyArg_Parse(arg, "i:getsignal", &signalnum)) {
124 goto exit;
125 }
126 return_value = signal_getsignal_impl(module, signalnum);
127
128 exit:
129 return return_value;
130 }
131
132 #if defined(HAVE_SIGINTERRUPT)
133
134 PyDoc_STRVAR(signal_siginterrupt__doc__,
135 "siginterrupt($module, signalnum, flag, /)\n"
136 "--\n"
137 "\n"
138 "Change system call restart behaviour.\n"
139 "\n"
140 "If flag is False, system calls will be restarted when interrupted by\n"
141 "signal sig, else system calls will be interrupted.");
142
143 #define SIGNAL_SIGINTERRUPT_METHODDEF \
144 {"siginterrupt", (PyCFunction)signal_siginterrupt, METH_FASTCALL, signal_siginterrupt__doc__},
145
146 static PyObject *
147 signal_siginterrupt_impl(PyObject *module, int signalnum, int flag);
148
149 static PyObject *
signal_siginterrupt(PyObject * module,PyObject * const * args,Py_ssize_t nargs)150 signal_siginterrupt(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
151 {
152 PyObject *return_value = NULL;
153 int signalnum;
154 int flag;
155
156 if (!_PyArg_ParseStack(args, nargs, "ii:siginterrupt",
157 &signalnum, &flag)) {
158 goto exit;
159 }
160 return_value = signal_siginterrupt_impl(module, signalnum, flag);
161
162 exit:
163 return return_value;
164 }
165
166 #endif /* defined(HAVE_SIGINTERRUPT) */
167
168 #if defined(HAVE_SETITIMER)
169
170 PyDoc_STRVAR(signal_setitimer__doc__,
171 "setitimer($module, which, seconds, interval=0.0, /)\n"
172 "--\n"
173 "\n"
174 "Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL or ITIMER_PROF).\n"
175 "\n"
176 "The timer will fire after value seconds and after that every interval seconds.\n"
177 "The itimer can be cleared by setting seconds to zero.\n"
178 "\n"
179 "Returns old values as a tuple: (delay, interval).");
180
181 #define SIGNAL_SETITIMER_METHODDEF \
182 {"setitimer", (PyCFunction)signal_setitimer, METH_FASTCALL, signal_setitimer__doc__},
183
184 static PyObject *
185 signal_setitimer_impl(PyObject *module, int which, PyObject *seconds,
186 PyObject *interval);
187
188 static PyObject *
signal_setitimer(PyObject * module,PyObject * const * args,Py_ssize_t nargs)189 signal_setitimer(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
190 {
191 PyObject *return_value = NULL;
192 int which;
193 PyObject *seconds;
194 PyObject *interval = NULL;
195
196 if (!_PyArg_ParseStack(args, nargs, "iO|O:setitimer",
197 &which, &seconds, &interval)) {
198 goto exit;
199 }
200 return_value = signal_setitimer_impl(module, which, seconds, interval);
201
202 exit:
203 return return_value;
204 }
205
206 #endif /* defined(HAVE_SETITIMER) */
207
208 #if defined(HAVE_GETITIMER)
209
210 PyDoc_STRVAR(signal_getitimer__doc__,
211 "getitimer($module, which, /)\n"
212 "--\n"
213 "\n"
214 "Returns current value of given itimer.");
215
216 #define SIGNAL_GETITIMER_METHODDEF \
217 {"getitimer", (PyCFunction)signal_getitimer, METH_O, signal_getitimer__doc__},
218
219 static PyObject *
220 signal_getitimer_impl(PyObject *module, int which);
221
222 static PyObject *
signal_getitimer(PyObject * module,PyObject * arg)223 signal_getitimer(PyObject *module, PyObject *arg)
224 {
225 PyObject *return_value = NULL;
226 int which;
227
228 if (!PyArg_Parse(arg, "i:getitimer", &which)) {
229 goto exit;
230 }
231 return_value = signal_getitimer_impl(module, which);
232
233 exit:
234 return return_value;
235 }
236
237 #endif /* defined(HAVE_GETITIMER) */
238
239 #if defined(PYPTHREAD_SIGMASK)
240
241 PyDoc_STRVAR(signal_pthread_sigmask__doc__,
242 "pthread_sigmask($module, how, mask, /)\n"
243 "--\n"
244 "\n"
245 "Fetch and/or change the signal mask of the calling thread.");
246
247 #define SIGNAL_PTHREAD_SIGMASK_METHODDEF \
248 {"pthread_sigmask", (PyCFunction)signal_pthread_sigmask, METH_FASTCALL, signal_pthread_sigmask__doc__},
249
250 static PyObject *
251 signal_pthread_sigmask_impl(PyObject *module, int how, PyObject *mask);
252
253 static PyObject *
signal_pthread_sigmask(PyObject * module,PyObject * const * args,Py_ssize_t nargs)254 signal_pthread_sigmask(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
255 {
256 PyObject *return_value = NULL;
257 int how;
258 PyObject *mask;
259
260 if (!_PyArg_ParseStack(args, nargs, "iO:pthread_sigmask",
261 &how, &mask)) {
262 goto exit;
263 }
264 return_value = signal_pthread_sigmask_impl(module, how, mask);
265
266 exit:
267 return return_value;
268 }
269
270 #endif /* defined(PYPTHREAD_SIGMASK) */
271
272 #if defined(HAVE_SIGPENDING)
273
274 PyDoc_STRVAR(signal_sigpending__doc__,
275 "sigpending($module, /)\n"
276 "--\n"
277 "\n"
278 "Examine pending signals.\n"
279 "\n"
280 "Returns a set of signal numbers that are pending for delivery to\n"
281 "the calling thread.");
282
283 #define SIGNAL_SIGPENDING_METHODDEF \
284 {"sigpending", (PyCFunction)signal_sigpending, METH_NOARGS, signal_sigpending__doc__},
285
286 static PyObject *
287 signal_sigpending_impl(PyObject *module);
288
289 static PyObject *
signal_sigpending(PyObject * module,PyObject * Py_UNUSED (ignored))290 signal_sigpending(PyObject *module, PyObject *Py_UNUSED(ignored))
291 {
292 return signal_sigpending_impl(module);
293 }
294
295 #endif /* defined(HAVE_SIGPENDING) */
296
297 #if defined(HAVE_SIGWAIT)
298
299 PyDoc_STRVAR(signal_sigwait__doc__,
300 "sigwait($module, sigset, /)\n"
301 "--\n"
302 "\n"
303 "Wait for a signal.\n"
304 "\n"
305 "Suspend execution of the calling thread until the delivery of one of the\n"
306 "signals specified in the signal set sigset. The function accepts the signal\n"
307 "and returns the signal number.");
308
309 #define SIGNAL_SIGWAIT_METHODDEF \
310 {"sigwait", (PyCFunction)signal_sigwait, METH_O, signal_sigwait__doc__},
311
312 #endif /* defined(HAVE_SIGWAIT) */
313
314 #if defined(HAVE_SIGWAITINFO)
315
316 PyDoc_STRVAR(signal_sigwaitinfo__doc__,
317 "sigwaitinfo($module, sigset, /)\n"
318 "--\n"
319 "\n"
320 "Wait synchronously until one of the signals in *sigset* is delivered.\n"
321 "\n"
322 "Returns a struct_siginfo containing information about the signal.");
323
324 #define SIGNAL_SIGWAITINFO_METHODDEF \
325 {"sigwaitinfo", (PyCFunction)signal_sigwaitinfo, METH_O, signal_sigwaitinfo__doc__},
326
327 #endif /* defined(HAVE_SIGWAITINFO) */
328
329 #if defined(HAVE_SIGTIMEDWAIT)
330
331 PyDoc_STRVAR(signal_sigtimedwait__doc__,
332 "sigtimedwait($module, sigset, timeout, /)\n"
333 "--\n"
334 "\n"
335 "Like sigwaitinfo(), but with a timeout.\n"
336 "\n"
337 "The timeout is specified in seconds, with floating point numbers allowed.");
338
339 #define SIGNAL_SIGTIMEDWAIT_METHODDEF \
340 {"sigtimedwait", (PyCFunction)signal_sigtimedwait, METH_FASTCALL, signal_sigtimedwait__doc__},
341
342 static PyObject *
343 signal_sigtimedwait_impl(PyObject *module, PyObject *sigset,
344 PyObject *timeout_obj);
345
346 static PyObject *
signal_sigtimedwait(PyObject * module,PyObject * const * args,Py_ssize_t nargs)347 signal_sigtimedwait(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
348 {
349 PyObject *return_value = NULL;
350 PyObject *sigset;
351 PyObject *timeout_obj;
352
353 if (!_PyArg_UnpackStack(args, nargs, "sigtimedwait",
354 2, 2,
355 &sigset, &timeout_obj)) {
356 goto exit;
357 }
358 return_value = signal_sigtimedwait_impl(module, sigset, timeout_obj);
359
360 exit:
361 return return_value;
362 }
363
364 #endif /* defined(HAVE_SIGTIMEDWAIT) */
365
366 #if defined(HAVE_PTHREAD_KILL)
367
368 PyDoc_STRVAR(signal_pthread_kill__doc__,
369 "pthread_kill($module, thread_id, signalnum, /)\n"
370 "--\n"
371 "\n"
372 "Send a signal to a thread.");
373
374 #define SIGNAL_PTHREAD_KILL_METHODDEF \
375 {"pthread_kill", (PyCFunction)signal_pthread_kill, METH_FASTCALL, signal_pthread_kill__doc__},
376
377 static PyObject *
378 signal_pthread_kill_impl(PyObject *module, unsigned long thread_id,
379 int signalnum);
380
381 static PyObject *
signal_pthread_kill(PyObject * module,PyObject * const * args,Py_ssize_t nargs)382 signal_pthread_kill(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
383 {
384 PyObject *return_value = NULL;
385 unsigned long thread_id;
386 int signalnum;
387
388 if (!_PyArg_ParseStack(args, nargs, "ki:pthread_kill",
389 &thread_id, &signalnum)) {
390 goto exit;
391 }
392 return_value = signal_pthread_kill_impl(module, thread_id, signalnum);
393
394 exit:
395 return return_value;
396 }
397
398 #endif /* defined(HAVE_PTHREAD_KILL) */
399
400 #ifndef SIGNAL_ALARM_METHODDEF
401 #define SIGNAL_ALARM_METHODDEF
402 #endif /* !defined(SIGNAL_ALARM_METHODDEF) */
403
404 #ifndef SIGNAL_PAUSE_METHODDEF
405 #define SIGNAL_PAUSE_METHODDEF
406 #endif /* !defined(SIGNAL_PAUSE_METHODDEF) */
407
408 #ifndef SIGNAL_SIGINTERRUPT_METHODDEF
409 #define SIGNAL_SIGINTERRUPT_METHODDEF
410 #endif /* !defined(SIGNAL_SIGINTERRUPT_METHODDEF) */
411
412 #ifndef SIGNAL_SETITIMER_METHODDEF
413 #define SIGNAL_SETITIMER_METHODDEF
414 #endif /* !defined(SIGNAL_SETITIMER_METHODDEF) */
415
416 #ifndef SIGNAL_GETITIMER_METHODDEF
417 #define SIGNAL_GETITIMER_METHODDEF
418 #endif /* !defined(SIGNAL_GETITIMER_METHODDEF) */
419
420 #ifndef SIGNAL_PTHREAD_SIGMASK_METHODDEF
421 #define SIGNAL_PTHREAD_SIGMASK_METHODDEF
422 #endif /* !defined(SIGNAL_PTHREAD_SIGMASK_METHODDEF) */
423
424 #ifndef SIGNAL_SIGPENDING_METHODDEF
425 #define SIGNAL_SIGPENDING_METHODDEF
426 #endif /* !defined(SIGNAL_SIGPENDING_METHODDEF) */
427
428 #ifndef SIGNAL_SIGWAIT_METHODDEF
429 #define SIGNAL_SIGWAIT_METHODDEF
430 #endif /* !defined(SIGNAL_SIGWAIT_METHODDEF) */
431
432 #ifndef SIGNAL_SIGWAITINFO_METHODDEF
433 #define SIGNAL_SIGWAITINFO_METHODDEF
434 #endif /* !defined(SIGNAL_SIGWAITINFO_METHODDEF) */
435
436 #ifndef SIGNAL_SIGTIMEDWAIT_METHODDEF
437 #define SIGNAL_SIGTIMEDWAIT_METHODDEF
438 #endif /* !defined(SIGNAL_SIGTIMEDWAIT_METHODDEF) */
439
440 #ifndef SIGNAL_PTHREAD_KILL_METHODDEF
441 #define SIGNAL_PTHREAD_KILL_METHODDEF
442 #endif /* !defined(SIGNAL_PTHREAD_KILL_METHODDEF) */
443 /*[clinic end generated code: output=36132f4189381fe0 input=a9049054013a1b77]*/
444