cpython/Parser/intrcheck.c

202 lines
3.3 KiB
C
Raw Normal View History

1991-02-19 08:39:46 -04:00
/***********************************************************
2000-06-30 20:50:40 -03:00
Copyright (c) 2000, BeOpen.com.
Copyright (c) 1995-2000, Corporation for National Research Initiatives.
Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
All rights reserved.
See the file "Misc/COPYRIGHT" for information on usage and
redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
1991-02-19 08:39:46 -04:00
******************************************************************/
1990-10-14 09:07:46 -03:00
/* Check for interrupts */
#include "Python.h"
1991-06-24 19:30:42 -03:00
1994-08-30 05:27:36 -03:00
#ifdef QUICKWIN
#include <io.h>
void
PyOS_InitInterrupts(void)
1994-08-30 05:27:36 -03:00
{
}
1997-08-02 00:02:27 -03:00
void
PyOS_FiniInterrupts(void)
1997-08-02 00:02:27 -03:00
{
}
1994-08-30 05:27:36 -03:00
int
PyOS_InterruptOccurred(void)
1994-08-30 05:27:36 -03:00
{
_wyield();
}
#define OK
#endif /* QUICKWIN */
1997-12-02 16:34:19 -04:00
#if defined(_M_IX86) && !defined(__QNX__)
1994-08-30 05:27:36 -03:00
#include <io.h>
#endif
#if defined(MSDOS) && !defined(QUICKWIN)
#ifdef __GNUC__
/* This is for DJGPP's GO32 extender. I don't know how to trap
* control-C (There's no API for ctrl-C, and I don't want to mess with
* the interrupt vectors.) However, this DOES catch control-break.
* --Amrit
*/
#include <go32.h>
void
PyOS_InitInterrupts(void)
1994-08-30 05:27:36 -03:00
{
_go32_want_ctrl_break(1 /* TRUE */);
}
1997-08-02 00:02:27 -03:00
void
PyOS_FiniInterrupts(void)
1997-08-02 00:02:27 -03:00
{
}
1994-08-30 05:27:36 -03:00
int
PyOS_InterruptOccurred(void)
1994-08-30 05:27:36 -03:00
{
return _go32_was_ctrl_break_hit();
}
#else /* !__GNUC__ */
1990-10-14 09:07:46 -03:00
1990-12-20 11:06:42 -04:00
/* This might work for MS-DOS (untested though): */
1990-10-14 09:07:46 -03:00
void
PyOS_InitInterrupts(void)
1990-10-14 09:07:46 -03:00
{
}
1997-08-02 00:02:27 -03:00
void
PyOS_FiniInterrupts(void)
1997-08-02 00:02:27 -03:00
{
}
1990-10-14 09:07:46 -03:00
int
PyOS_InterruptOccurred(void)
1990-10-14 09:07:46 -03:00
{
int interrupted = 0;
while (kbhit()) {
if (getch() == '\003')
interrupted = 1;
}
return interrupted;
}
1994-08-30 05:27:36 -03:00
#endif /* __GNUC__ */
1990-10-14 09:07:46 -03:00
#define OK
1994-08-30 05:27:36 -03:00
#endif /* MSDOS && !QUICKWIN */
1990-10-14 09:07:46 -03:00
1991-06-24 19:30:42 -03:00
#ifdef macintosh
1990-10-14 09:07:46 -03:00
1995-01-27 10:40:41 -04:00
/* The Mac interrupt code has moved to macglue.c */
1990-10-14 09:07:46 -03:00
#define OK
1991-06-24 19:30:42 -03:00
#endif /* macintosh */
1990-10-14 09:07:46 -03:00
#ifndef OK
1990-12-20 11:06:42 -04:00
/* Default version -- for real operating systems and for Standard C */
1990-10-14 09:07:46 -03:00
#include <stdio.h>
1994-08-30 05:27:36 -03:00
#include <string.h>
1990-10-14 09:07:46 -03:00
#include <signal.h>
1996-12-02 14:27:33 -04:00
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
1990-10-14 09:07:46 -03:00
1995-01-17 12:11:53 -04:00
static int interrupted;
1990-10-14 09:07:46 -03:00
1995-03-10 11:13:03 -04:00
void
PyErr_SetInterrupt(void)
1995-03-10 11:13:03 -04:00
{
interrupted = 1;
}
extern int PyErr_CheckSignals(void);
static int
checksignals_witharg(void * arg)
{
return PyErr_CheckSignals();
}
static void
intcatcher(int sig)
1990-10-14 09:07:46 -03:00
{
extern void Py_Exit(int);
static char message[] =
"python: to interrupt a truly hanging Python program, interrupt once more.\n";
switch (interrupted++) {
case 0:
break;
case 1:
write(2, message, strlen(message));
break;
case 2:
interrupted = 0;
1997-04-29 18:03:06 -03:00
Py_Exit(1);
break;
}
1990-10-14 09:07:46 -03:00
signal(SIGINT, intcatcher);
Py_AddPendingCall(checksignals_witharg, NULL);
1990-10-14 09:07:46 -03:00
}
static void (*old_siginthandler)(int) = SIG_DFL;
1997-08-02 00:02:27 -03:00
1990-10-14 09:07:46 -03:00
void
PyOS_InitInterrupts(void)
1990-10-14 09:07:46 -03:00
{
1997-08-02 00:02:27 -03:00
if ((old_siginthandler = signal(SIGINT, SIG_IGN)) != SIG_IGN)
1990-10-14 09:07:46 -03:00
signal(SIGINT, intcatcher);
1994-08-30 05:27:36 -03:00
#ifdef HAVE_SIGINTERRUPT
/* This is for SunOS and other modern BSD derivatives.
It means that system calls (like read()) are not restarted
after an interrupt. This is necessary so interrupting a
read() or readline() call works as expected.
XXX On old BSD (pure 4.2 or older) you may have to do this
differently! */
siginterrupt(SIGINT, 1);
1994-08-30 05:27:36 -03:00
#endif /* HAVE_SIGINTERRUPT */
1990-10-14 09:07:46 -03:00
}
1997-08-02 00:02:27 -03:00
void
PyOS_FiniInterrupts(void)
1997-08-02 00:02:27 -03:00
{
signal(SIGINT, old_siginthandler);
}
1990-10-14 09:07:46 -03:00
int
PyOS_InterruptOccurred(void)
1990-10-14 09:07:46 -03:00
{
if (!interrupted)
return 0;
interrupted = 0;
return 1;
}
#endif /* !OK */
void
PyOS_AfterFork(void)
{
#ifdef WITH_THREAD
PyEval_ReInitThreads();
#endif
}