Several changes:

- Conform to standard Python C coding styles.

- All static symbols were renamed and shorted.

- Eyeballed all return values and memory references.

- Fixed a bug in signal.pause() so that exceptions raised in signal
  handlers are now properly caught after pause() returns.

- Removed SIGCPU and SIGFSZ.  We surmise that these were typos for the
  previously missing SIGXCPU and SIGXFSZ.

1 files changed, 157 insertions, 105 deletions

diff --git a/Modules/signalmodule.c b/Modules/signalmodule.c
index 5a91419..2802af7 100644
--- a/Modules/signalmodule.c
+++ b/Modules/signalmodule.c
@@ -49,6 +49,7 @@ PERFORMANCE OF THIS SOFTWARE.
 #endif
 
 
+
 /*
    NOTES ON THE INTERACTION BETWEEN SIGNALS AND THREADS
 
@@ -81,44 +82,39 @@ static long main_thread;
 static pid_t main_pid;
 #endif
 
-struct PySignal_SignalArrayStruct {
-	int	tripped;
-	PyObject *func;
-};
+static struct {
+        int tripped;
+        PyObject *func;
+} Handlers[NSIG];
+
+static int is_tripped = 0; /* Speed up sigcheck() when none tripped */
 
-static struct PySignal_SignalArrayStruct PySignal_SignalHandlerArray[NSIG];
-static int PySignal_IsTripped = 0; /* Speed up sigcheck() when none tripped */
+static PyObject *DefaultHandler;
+static PyObject *IgnoreHandler;
+static PyObject *IntHandler;
 
-static PyObject *PySignal_SignalDefaultHandler;
-static PyObject *PySignal_SignalIgnoreHandler;
-static PyObject *PySignal_DefaultIntHandler;
 
+
 static PyObject *
-PySignal_CDefaultIntHandler(self, arg)
+signal_default_int_handler(self, arg)
 	PyObject *self;
 	PyObject *arg;
 {
 	PyErr_SetNone(PyExc_KeyboardInterrupt);
-	return (PyObject *)NULL;
-}
-
-void
-PyErr_SetInterrupt()
-{
-	PySignal_IsTripped++;
-	PySignal_SignalHandlerArray[SIGINT].tripped = 1;
+	return NULL;
 }
 
+
 static RETSIGTYPE
-PySignal_Handler(sig_num)
+signal_handler(sig_num)
 	int sig_num;
 {
 #ifdef WITH_THREAD
 	/* See NOTES section above */
 	if (getpid() == main_pid) {
 #endif
-		PySignal_IsTripped++;
-		PySignal_SignalHandlerArray[sig_num].tripped = 1;
+		is_tripped++;
+		Handlers[sig_num].tripped = 1;
 #ifdef WITH_THREAD
 	}
 #endif
@@ -131,19 +127,20 @@ PySignal_Handler(sig_num)
 		return;
 	}
 #endif
-	(void *)signal(sig_num, &PySignal_Handler);
+	(void *)signal(sig_num, &signal_handler);
 }
 
 
+
 #ifndef DONT_HAVE_SIG_ALARM
 static PyObject *
-PySignal_Alarm(self, args)
+signal_alarm(self, args)
 	PyObject *self; /* Not used */
 	PyObject *args;
 {
 	int t;
 	if (!PyArg_Parse(args, "i", &t))
-		return (PyObject *)NULL;
+		return NULL;
 	/* alarm() returns the number of seconds remaining */
 	return PyInt_FromLong(alarm(t));
 }
@@ -151,22 +148,30 @@ PySignal_Alarm(self, args)
 
 #ifndef DONT_HAVE_SIG_PAUSE
 static PyObject *
-PySignal_Pause(self, args)
+signal_pause(self, args)
 	PyObject *self; /* Not used */
 	PyObject *args;
 {
 	if (!PyArg_NoArgs(args))
 		return NULL;
+
 	Py_BEGIN_ALLOW_THREADS
-	pause();
+	(void)pause();
 	Py_END_ALLOW_THREADS
+	/* make sure that any exceptions that got raised are propagated
+	 * back into Python
+	 */
+	if (PyErr_CheckSignals())
+		return NULL;
+
 	Py_INCREF(Py_None);
 	return Py_None;
 }
 #endif
 
+
 static PyObject *
-PySignal_Signal(self, args)
+signal_signal(self, args)
 	PyObject *self; /* Not used */
 	PyObject *args;
 {
@@ -175,76 +180,79 @@ PySignal_Signal(self, args)
 	PyObject *old_handler;
 	RETSIGTYPE (*func)();
 	if (!PyArg_Parse(args, "(iO)", &sig_num, &obj))
-		return (PyObject *)NULL;
+		return NULL;
 #ifdef WITH_THREAD
 	if (get_thread_ident() != main_thread) {
 		PyErr_SetString(PyExc_ValueError,
 				"signal only works in main thread");
-		return (PyObject *)NULL;
+		return NULL;
 	}
 #endif
 	if (sig_num < 1 || sig_num >= NSIG) {
 		PyErr_SetString(PyExc_ValueError,
 				"signal number out of range");
-		return (PyObject *)NULL;
+		return NULL;
 	}
-	if (obj == PySignal_SignalIgnoreHandler)
+	if (obj == IgnoreHandler)
 		func = SIG_IGN;
-	else if (obj == PySignal_SignalDefaultHandler)
+	else if (obj == DefaultHandler)
 		func = SIG_DFL;
 	else if (!PyCallable_Check(obj)) {
 		PyErr_SetString(PyExc_TypeError,
 "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object");
-		return (PyObject *)NULL;
+		return NULL;
 	}
 	else
-		func = PySignal_Handler;
+		func = signal_handler;
 	if (signal(sig_num, func) == SIG_ERR) {
 		PyErr_SetFromErrno(PyExc_RuntimeError);
-		return (PyObject *)NULL;
+		return NULL;
 	}
-	old_handler = PySignal_SignalHandlerArray[sig_num].func;
-	PySignal_SignalHandlerArray[sig_num].tripped = 0;
+	old_handler = Handlers[sig_num].func;
+	Handlers[sig_num].tripped = 0;
 	Py_INCREF(obj);
-	PySignal_SignalHandlerArray[sig_num].func = obj;
+	Handlers[sig_num].func = obj;
 	return old_handler;
 }
 
+
 static PyObject *
-PySignal_GetSignal(self, args)
+signal_get_signal(self, args)
 	PyObject *self; /* Not used */
 	PyObject *args;
 {
 	int sig_num;
 	PyObject *old_handler;
 	if (!PyArg_Parse(args, "i", &sig_num))
-		return (PyObject *)NULL;
+		return NULL;
 	if (sig_num < 1 || sig_num >= NSIG) {
 		PyErr_SetString(PyExc_ValueError,
 				"signal number out of range");
-		return (PyObject *)NULL;
+		return NULL;
 	}
-	old_handler = PySignal_SignalHandlerArray[sig_num].func;
+	old_handler = Handlers[sig_num].func;
 	Py_INCREF(old_handler);
 	return old_handler;
 }
 
 
+
 /* List of functions defined in the module */
-
-static PyMethodDef PySignal_methods[] = {
+static PyMethodDef signal_methods[] = {
 #ifndef DONT_HAVE_SIG_ALARM
-	{"alarm",	PySignal_Alarm},
+	{"alarm",	        signal_alarm},
 #endif
-	{"signal",	PySignal_Signal},
-	{"getsignal",	PySignal_GetSignal},
+	{"signal",	        signal_signal},
+	{"getsignal",	        signal_get_signal},
 #ifndef DONT_HAVE_SIG_PAUSE
-	{"pause",	PySignal_Pause},
+	{"pause",	        signal_pause},
 #endif
-	{"default_int_handler", PySignal_CDefaultIntHandler},
+	{"default_int_handler", signal_default_int_handler},
 	{NULL,		NULL}		/* sentinel */
 };
 
+
+
 void
 initsignal()
 {
@@ -257,20 +265,29 @@ initsignal()
 #endif
 
 	/* Create the module and add the functions */
-	m = Py_InitModule("signal", PySignal_methods);
+	m = Py_InitModule("signal", signal_methods);
 
 	/* Add some symbolic constants to the module */
 	d = PyModule_GetDict(m);
 
-	PySignal_SignalDefaultHandler = PyInt_FromLong((long)SIG_DFL);
-	PyDict_SetItemString(d, "SIG_DFL", PySignal_SignalDefaultHandler);
-	PySignal_SignalIgnoreHandler = PyInt_FromLong((long)SIG_IGN);
-	PyDict_SetItemString(d, "SIG_IGN", PySignal_SignalIgnoreHandler);
-	PyDict_SetItemString(d, "NSIG", PyInt_FromLong((long)NSIG));
-	PySignal_DefaultIntHandler =
-		PyDict_GetItemString(d, "default_int_handler");
+	x = DefaultHandler = PyInt_FromLong((long)SIG_DFL);
+        if (!x || PyDict_SetItemString(d, "SIG_DFL", x) < 0)
+                goto finally;
+        Py_DECREF(x);
+
+	x = IgnoreHandler = PyInt_FromLong((long)SIG_IGN);
+        if (!x || PyDict_SetItemString(d, "SIG_IGN", x) < 0)
+                goto finally;
+
+        x = PyInt_FromLong((long)NSIG);
+        if (!x || PyDict_SetItemString(d, "NSIG", x) < 0)
+                goto finally;
 
-	PySignal_SignalHandlerArray[0].tripped = 0;
+	x = IntHandler = PyDict_GetItemString(d, "default_int_handler");
+        if (!x)
+                goto finally;
+
+	Handlers[0].tripped = 0;
 	for (i = 1; i < NSIG; i++) {
 		RETSIGTYPE (*t)();
 #ifdef HAVE_SIGACTION
@@ -281,231 +298,266 @@ initsignal()
 		t = signal(i, SIG_IGN);
 		signal(i, t);
 #endif
-		PySignal_SignalHandlerArray[i].tripped = 0;
+		Handlers[i].tripped = 0;
 		if (t == SIG_DFL)
-			PySignal_SignalHandlerArray[i].func =
-				PySignal_SignalDefaultHandler;
+			Handlers[i].func = DefaultHandler;
 		else if (t == SIG_IGN)
-			PySignal_SignalHandlerArray[i].func =
-				PySignal_SignalIgnoreHandler;
+			Handlers[i].func = IgnoreHandler;
 		else
-			PySignal_SignalHandlerArray[i].func =
-				Py_None; /* None of our business */
-		Py_INCREF(PySignal_SignalHandlerArray[i].func);
+			Handlers[i].func = Py_None; /* None of our business */
+		Py_INCREF(Handlers[i].func);
 	}
-	if (PySignal_SignalHandlerArray[SIGINT].func ==
-	    PySignal_SignalDefaultHandler) {
+	if (Handlers[SIGINT].func == DefaultHandler) {
 		/* Install default int handler */
-		Py_DECREF(PySignal_SignalHandlerArray[SIGINT].func);
-		PySignal_SignalHandlerArray[SIGINT].func =
-			PySignal_DefaultIntHandler;
-		Py_INCREF(PySignal_DefaultIntHandler);
-		signal(SIGINT, &PySignal_Handler);
+		Py_DECREF(Handlers[SIGINT].func);
+		Handlers[SIGINT].func = IntHandler;
+		Py_INCREF(IntHandler);
+		signal(SIGINT, &signal_handler);
 	}
 
 #ifdef SIGHUP
 	x = PyInt_FromLong(SIGHUP);
 	PyDict_SetItemString(d, "SIGHUP", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGINT
 	x = PyInt_FromLong(SIGINT);
 	PyDict_SetItemString(d, "SIGINT", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGQUIT
 	x = PyInt_FromLong(SIGQUIT);
 	PyDict_SetItemString(d, "SIGQUIT", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGILL
 	x = PyInt_FromLong(SIGILL);
 	PyDict_SetItemString(d, "SIGILL", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGTRAP
 	x = PyInt_FromLong(SIGTRAP);
 	PyDict_SetItemString(d, "SIGTRAP", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGIOT
 	x = PyInt_FromLong(SIGIOT);
 	PyDict_SetItemString(d, "SIGIOT", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGABRT
 	x = PyInt_FromLong(SIGABRT);
 	PyDict_SetItemString(d, "SIGABRT", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGEMT
 	x = PyInt_FromLong(SIGEMT);
 	PyDict_SetItemString(d, "SIGEMT", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGFPE
 	x = PyInt_FromLong(SIGFPE);
 	PyDict_SetItemString(d, "SIGFPE", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGKILL
 	x = PyInt_FromLong(SIGKILL);
 	PyDict_SetItemString(d, "SIGKILL", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGBUS
 	x = PyInt_FromLong(SIGBUS);
 	PyDict_SetItemString(d, "SIGBUS", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGSEGV
 	x = PyInt_FromLong(SIGSEGV);
 	PyDict_SetItemString(d, "SIGSEGV", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGSYS
 	x = PyInt_FromLong(SIGSYS);
 	PyDict_SetItemString(d, "SIGSYS", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGPIPE
 	x = PyInt_FromLong(SIGPIPE);
 	PyDict_SetItemString(d, "SIGPIPE", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGALRM
 	x = PyInt_FromLong(SIGALRM);
 	PyDict_SetItemString(d, "SIGALRM", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGTERM
 	x = PyInt_FromLong(SIGTERM);
 	PyDict_SetItemString(d, "SIGTERM", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGUSR1
 	x = PyInt_FromLong(SIGUSR1);
 	PyDict_SetItemString(d, "SIGUSR1", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGUSR2
 	x = PyInt_FromLong(SIGUSR2);
 	PyDict_SetItemString(d, "SIGUSR2", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGCLD
 	x = PyInt_FromLong(SIGCLD);
 	PyDict_SetItemString(d, "SIGCLD", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGCHLD
 	x = PyInt_FromLong(SIGCHLD);
 	PyDict_SetItemString(d, "SIGCHLD", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGPWR
 	x = PyInt_FromLong(SIGPWR);
 	PyDict_SetItemString(d, "SIGPWR", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGIO
 	x = PyInt_FromLong(SIGIO);
 	PyDict_SetItemString(d, "SIGIO", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGURG
 	x = PyInt_FromLong(SIGURG);
 	PyDict_SetItemString(d, "SIGURG", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGWINCH
 	x = PyInt_FromLong(SIGWINCH);
 	PyDict_SetItemString(d, "SIGWINCH", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGPOLL
 	x = PyInt_FromLong(SIGPOLL);
 	PyDict_SetItemString(d, "SIGPOLL", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGSTOP
 	x = PyInt_FromLong(SIGSTOP);
 	PyDict_SetItemString(d, "SIGSTOP", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGTSTP
 	x = PyInt_FromLong(SIGTSTP);
 	PyDict_SetItemString(d, "SIGTSTP", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGCONT
 	x = PyInt_FromLong(SIGCONT);
 	PyDict_SetItemString(d, "SIGCONT", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGTTIN
 	x = PyInt_FromLong(SIGTTIN);
 	PyDict_SetItemString(d, "SIGTTIN", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGTTOU
 	x = PyInt_FromLong(SIGTTOU);
 	PyDict_SetItemString(d, "SIGTTOU", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGVTALRM
 	x = PyInt_FromLong(SIGVTALRM);
 	PyDict_SetItemString(d, "SIGVTALRM", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGPROF
 	x = PyInt_FromLong(SIGPROF);
 	PyDict_SetItemString(d, "SIGPROF", x);
-#endif
-#ifdef SIGCPU
-	x = PyInt_FromLong(SIGCPU);
-	PyDict_SetItemString(d, "SIGCPU", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGXCPU
 	x = PyInt_FromLong(SIGXCPU);
 	PyDict_SetItemString(d, "SIGXCPU", x);
-#endif
-#ifdef SIGFSZ
-	x = PyInt_FromLong(SIGFSZ);
-	PyDict_SetItemString(d, "SIGFSZ", x);
+        Py_DECREF(x);
 #endif
 #ifdef SIGXFSZ
 	x = PyInt_FromLong(SIGXFSZ);
 	PyDict_SetItemString(d, "SIGXFSZ", x);
+        Py_DECREF(x);
 #endif
+        if (!PyErr_Occurred())
+                return;
+
 	/* Check for errors */
-	if (PyErr_Occurred())
-		Py_FatalError("can't initialize module signal");
+  finally:
+        Py_FatalError("can't initialize module signal");
 }
 
+
+
+/* Declared in pyerrors.h */
 int
 PyErr_CheckSignals()
 {
 	int i;
 	PyObject *f;
-	if (!PySignal_IsTripped)
+
+	if (!is_tripped)
 		return 0;
 #ifdef WITH_THREAD
 	if (get_thread_ident() != main_thread)
 		return 0;
 #endif
-	f = PyEval_GetFrame();
-	if (f == (PyObject *)NULL)
+	if (!(f = PyEval_GetFrame()))
 		f = Py_None;
+	
 	for (i = 1; i < NSIG; i++) {
-		if (PySignal_SignalHandlerArray[i].tripped) {
-			PyObject *arglist, *result;
-			PySignal_SignalHandlerArray[i].tripped = 0;
-			arglist = Py_BuildValue("(iO)", i, f);
-			if (arglist == (PyObject *)NULL)
-				result = (PyObject *)NULL;
-			else {
-				result = PyEval_CallObject(
-				 PySignal_SignalHandlerArray[i].func, arglist);
+		if (Handlers[i].tripped) {
+			PyObject *result = NULL;
+			PyObject *arglist = Py_BuildValue("(iO)", i, f);
+			Handlers[i].tripped = 0;
+
+			if (arglist) {
+				result = PyEval_CallObject(Handlers[i].func,
+							   arglist);
 				Py_DECREF(arglist);
 			}
-			if (result == (PyObject *)NULL) {
+			if (!result)
 				return 1;
-			} else {
-				Py_DECREF(result);
-			}
+
+			Py_DECREF(result);
 		}
 	}
-	PySignal_IsTripped = 0;
+	is_tripped = 0;
 	return 0;
 }
 
-/* Replacement for intrcheck.c functionality */
+
+/* Replacements for intrcheck.c functionality
+ * Declared in pyerrors.h
+ */
+void
+PyErr_SetInterrupt()
+{
+	is_tripped++;
+	Handlers[SIGINT].tripped = 1;
+}
 
 void
-PyOS_InitInterrupts ()
+PyOS_InitInterrupts()
 {
 	initsignal();
 }
 
 int
-PyOS_InterruptOccurred ()
+PyOS_InterruptOccurred()
 {
-	if (PySignal_SignalHandlerArray[SIGINT].tripped) {
+	if (Handlers[SIGINT].tripped) {
 #ifdef WITH_THREAD
 		if (get_thread_ident() != main_thread)
 			return 0;
 #endif
-		PySignal_SignalHandlerArray[SIGINT].tripped = 0;
+		Handlers[SIGINT].tripped = 0;
 		return 1;
 	}
 	return 0;