• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_VARARGS, 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 * args)83 signal_signal(PyObject *module, PyObject *args)
84 {
85     PyObject *return_value = NULL;
86     int signalnum;
87     PyObject *handler;
88 
89     if (!PyArg_ParseTuple(args, "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_VARARGS, 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 * args)150 signal_siginterrupt(PyObject *module, PyObject *args)
151 {
152     PyObject *return_value = NULL;
153     int signalnum;
154     int flag;
155 
156     if (!PyArg_ParseTuple(args, "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_VARARGS, signal_setitimer__doc__},
183 
184 static PyObject *
185 signal_setitimer_impl(PyObject *module, int which, double seconds,
186                       double interval);
187 
188 static PyObject *
signal_setitimer(PyObject * module,PyObject * args)189 signal_setitimer(PyObject *module, PyObject *args)
190 {
191     PyObject *return_value = NULL;
192     int which;
193     double seconds;
194     double interval = 0.0;
195 
196     if (!PyArg_ParseTuple(args, "id|d: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_VARARGS, 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 * args)254 signal_pthread_sigmask(PyObject *module, PyObject *args)
255 {
256     PyObject *return_value = NULL;
257     int how;
258     PyObject *mask;
259 
260     if (!PyArg_ParseTuple(args, "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_VARARGS, 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 * args)347 signal_sigtimedwait(PyObject *module, PyObject *args)
348 {
349     PyObject *return_value = NULL;
350     PyObject *sigset;
351     PyObject *timeout_obj;
352 
353     if (!PyArg_UnpackTuple(args, "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) && defined(WITH_THREAD))
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_VARARGS, signal_pthread_kill__doc__},
376 
377 static PyObject *
378 signal_pthread_kill_impl(PyObject *module, long thread_id, int signalnum);
379 
380 static PyObject *
signal_pthread_kill(PyObject * module,PyObject * args)381 signal_pthread_kill(PyObject *module, PyObject *args)
382 {
383     PyObject *return_value = NULL;
384     long thread_id;
385     int signalnum;
386 
387     if (!PyArg_ParseTuple(args, "li:pthread_kill",
388         &thread_id, &signalnum)) {
389         goto exit;
390     }
391     return_value = signal_pthread_kill_impl(module, thread_id, signalnum);
392 
393 exit:
394     return return_value;
395 }
396 
397 #endif /* (defined(HAVE_PTHREAD_KILL) && defined(WITH_THREAD)) */
398 
399 #ifndef SIGNAL_ALARM_METHODDEF
400     #define SIGNAL_ALARM_METHODDEF
401 #endif /* !defined(SIGNAL_ALARM_METHODDEF) */
402 
403 #ifndef SIGNAL_PAUSE_METHODDEF
404     #define SIGNAL_PAUSE_METHODDEF
405 #endif /* !defined(SIGNAL_PAUSE_METHODDEF) */
406 
407 #ifndef SIGNAL_SIGINTERRUPT_METHODDEF
408     #define SIGNAL_SIGINTERRUPT_METHODDEF
409 #endif /* !defined(SIGNAL_SIGINTERRUPT_METHODDEF) */
410 
411 #ifndef SIGNAL_SETITIMER_METHODDEF
412     #define SIGNAL_SETITIMER_METHODDEF
413 #endif /* !defined(SIGNAL_SETITIMER_METHODDEF) */
414 
415 #ifndef SIGNAL_GETITIMER_METHODDEF
416     #define SIGNAL_GETITIMER_METHODDEF
417 #endif /* !defined(SIGNAL_GETITIMER_METHODDEF) */
418 
419 #ifndef SIGNAL_PTHREAD_SIGMASK_METHODDEF
420     #define SIGNAL_PTHREAD_SIGMASK_METHODDEF
421 #endif /* !defined(SIGNAL_PTHREAD_SIGMASK_METHODDEF) */
422 
423 #ifndef SIGNAL_SIGPENDING_METHODDEF
424     #define SIGNAL_SIGPENDING_METHODDEF
425 #endif /* !defined(SIGNAL_SIGPENDING_METHODDEF) */
426 
427 #ifndef SIGNAL_SIGWAIT_METHODDEF
428     #define SIGNAL_SIGWAIT_METHODDEF
429 #endif /* !defined(SIGNAL_SIGWAIT_METHODDEF) */
430 
431 #ifndef SIGNAL_SIGWAITINFO_METHODDEF
432     #define SIGNAL_SIGWAITINFO_METHODDEF
433 #endif /* !defined(SIGNAL_SIGWAITINFO_METHODDEF) */
434 
435 #ifndef SIGNAL_SIGTIMEDWAIT_METHODDEF
436     #define SIGNAL_SIGTIMEDWAIT_METHODDEF
437 #endif /* !defined(SIGNAL_SIGTIMEDWAIT_METHODDEF) */
438 
439 #ifndef SIGNAL_PTHREAD_KILL_METHODDEF
440     #define SIGNAL_PTHREAD_KILL_METHODDEF
441 #endif /* !defined(SIGNAL_PTHREAD_KILL_METHODDEF) */
442 /*[clinic end generated code: output=c6990ef0d0ba72b6 input=a9049054013a1b77]*/
443