Parser/intrcheck.c

   1
   2 /* Check for interrupts */
   3
   4 #include "Python.h"
   5
   6 #ifdef QUICKWIN
   7
   8 #include <io.h>
   9
  10 void
  11 PyOS_InitInterrupts(void)
  12 {
  13 }
  14
  15 void
  16 PyOS_FiniInterrupts(void)
  17 {
  18 }
  19
  20 int
  21 PyOS_InterruptOccurred(void)
  22 {
  23         _wyield();
  24 }
  25
  26 #define OK
  27
  28 #endif /* QUICKWIN */
  29
  30 #if defined(_M_IX86) && !defined(__QNX__)
  31 #include <io.h>
  32 #endif
  33
  34 #if defined(MSDOS) && !defined(QUICKWIN)
  35
  36 #ifdef __GNUC__
  37
  38 /* This is for DJGPP's GO32 extender.  I don't know how to trap
  39  * control-C  (There's no API for ctrl-C, and I don't want to mess with
  40  * the interrupt vectors.)  However, this DOES catch control-break.
  41  * --Amrit
  42  */
  43
  44 #include <go32.h>
  45
  46 void
  47 PyOS_InitInterrupts(void)
  48 {
  49         _go32_want_ctrl_break(1 /* TRUE */);
  50 }
  51
  52 void
  53 PyOS_FiniInterrupts(void)
  54 {
  55 }
  56
  57 int
  58 PyOS_InterruptOccurred(void)
  59 {
  60         return _go32_was_ctrl_break_hit();
  61 }
  62
  63 #else /* !__GNUC__ */
  64
  65 /* This might work for MS-DOS (untested though): */
  66
  67 void
  68 PyOS_InitInterrupts(void)
  69 {
  70 }
  71
  72 void
  73 PyOS_FiniInterrupts(void)
  74 {
  75 }
  76
  77 int
  78 PyOS_InterruptOccurred(void)
  79 {
  80         int interrupted = 0;
  81         while (kbhit()) {
  82                 if (getch() == '\003')
  83                         interrupted = 1;
  84         }
  85         return interrupted;
  86 }
  87
  88 #endif /* __GNUC__ */
  89
  90 #define OK
  91
  92 #endif /* MSDOS && !QUICKWIN */
  93
  94
  95 #ifdef macintosh
  96
  97 /* The Mac interrupt code has moved to macglue.c */
  98 #define OK
  99
 100 #endif /* macintosh */
 101
 102
 103 #ifndef OK
 104
 105 /* Default version -- for real operating systems and for Standard C */
 106
 107 #include <stdio.h>
 108 #include <string.h>
 109 #include <signal.h>
 110 #ifdef HAVE_UNISTD_H
 111 #include <unistd.h>
 112 #endif
 113
 114 static int interrupted;
 115
 116 void
 117 PyErr_SetInterrupt(void)
 118 {
 119         interrupted = 1;
 120 }
 121
 122 extern int PyErr_CheckSignals(void);
 123
 124 static int
 125 checksignals_witharg(void * arg)
 126 {
 127         return PyErr_CheckSignals();
 128 }
 129
 130 static void
 131 intcatcher(int sig)
 132 {
 133         extern void Py_Exit(int);
 134         static char message[] =
 135 "python: to interrupt a truly hanging Python program, interrupt once more.\n";
 136         switch (interrupted++) {
 137         case 0:
 138                 break;
 139         case 1:
 140 #ifdef RISCOS
 141                 fprintf(stderr, message);
 142 #else
 143                 write(2, message, strlen(message));
 144 #endif
 145                 break;
 146         case 2:
 147                 interrupted = 0;
 148                 Py_Exit(1);
 149                 break;
 150         }
 151         signal(SIGINT, intcatcher);
 152         Py_AddPendingCall(checksignals_witharg, NULL);
 153 }
 154
 155 static void (*old_siginthandler)(int) = SIG_DFL;
 156
 157 void
 158 PyOS_InitInterrupts(void)
 159 {
 160         if ((old_siginthandler = signal(SIGINT, SIG_IGN)) != SIG_IGN)
 161                 signal(SIGINT, intcatcher);
 162 #ifdef HAVE_SIGINTERRUPT
 163         /* This is for SunOS and other modern BSD derivatives.
 164            It means that system calls (like read()) are not restarted
 165            after an interrupt.  This is necessary so interrupting a
 166            read() or readline() call works as expected.
 167            XXX On old BSD (pure 4.2 or older) you may have to do this
 168            differently! */
 169         siginterrupt(SIGINT, 1);
 170 #endif /* HAVE_SIGINTERRUPT */
 171 }
 172
 173 void
 174 PyOS_FiniInterrupts(void)
 175 {
 176         signal(SIGINT, old_siginthandler);
 177 }
 178
 179 int
 180 PyOS_InterruptOccurred(void)
 181 {
 182         if (!interrupted)
 183                 return 0;
 184         interrupted = 0;
 185         return 1;
 186 }
 187
 188 #endif /* !OK */
 189
 190 void
 191 PyOS_AfterFork(void)
 192 {
 193 #ifdef WITH_THREAD
 194         PyEval_ReInitThreads();
 195 #endif
 196 }