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
 111 static int interrupted;
 112
 113 void
 114 PyErr_SetInterrupt(void)
 115 {
 116         interrupted = 1;
 117 }
 118
 119 extern int PyErr_CheckSignals(void);
 120
 121 static int
 122 checksignals_witharg(void * arg)
 123 {
 124         return PyErr_CheckSignals();
 125 }
 126
 127 static void
 128 intcatcher(int sig)
 129 {
 130         extern void Py_Exit(int);
 131         static char message[] =
 132 "python: to interrupt a truly hanging Python program, interrupt once more.\n";
 133         switch (interrupted++) {
 134         case 0:
 135                 break;
 136         case 1:
 137 #ifdef RISCOS
 138                 fprintf(stderr, message);
 139 #else
 140                 write(2, message, strlen(message));
 141 #endif
 142                 break;
 143         case 2:
 144                 interrupted = 0;
 145                 Py_Exit(1);
 146                 break;
 147         }
 148         signal(SIGINT, intcatcher);
 149         Py_AddPendingCall(checksignals_witharg, NULL);
 150 }
 151
 152 static void (*old_siginthandler)(int) = SIG_DFL;
 153
 154 void
 155 PyOS_InitInterrupts(void)
 156 {
 157         if ((old_siginthandler = signal(SIGINT, SIG_IGN)) != SIG_IGN)
 158                 signal(SIGINT, intcatcher);
 159 #ifdef HAVE_SIGINTERRUPT
 160         /* This is for SunOS and other modern BSD derivatives.
 161            It means that system calls (like read()) are not restarted
 162            after an interrupt.  This is necessary so interrupting a
 163            read() or readline() call works as expected.
 164            XXX On old BSD (pure 4.2 or older) you may have to do this
 165            differently! */
 166         siginterrupt(SIGINT, 1);
 167 #endif /* HAVE_SIGINTERRUPT */
 168 }
 169
 170 void
 171 PyOS_FiniInterrupts(void)
 172 {
 173         signal(SIGINT, old_siginthandler);
 174 }
 175
 176 int
 177 PyOS_InterruptOccurred(void)
 178 {
 179         if (!interrupted)
 180                 return 0;
 181         interrupted = 0;
 182         return 1;
 183 }
 184
 185 #endif /* !OK */
 186
 187 void
 188 PyOS_AfterFork(void)
 189 {
 190 #ifdef WITH_THREAD
 191         PyEval_ReInitThreads();
 192 #endif
 193 }