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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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