Parser/intrcheck.c

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