diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c
index ba95310..33d5392 100644
--- a/Modules/_tkinter.c
+++ b/Modules/_tkinter.c
@@ -724,10 +724,14 @@
 {
 	char *s;
 	double v;
+	int retval;
 
 	if (!PyArg_Parse(args, "s", &s))
 		return NULL;
-	if (Tcl_ExprDouble(Tkapp_Interp(self), s, &v) == TCL_ERROR)
+	PyFPE_START_PROTECT("Tkapp_ExprDouble", return 0)
+	retval = Tcl_ExprDouble (Tkapp_Interp (self), s, &v);
+	PyFPE_END_PROTECT
+	if (retval == TCL_ERROR)
 		return Tkinter_Error(self);
 	return Py_BuildValue("d", v);
 }
diff --git a/Modules/cmathmodule.c b/Modules/cmathmodule.c
index 7e9de1f..438f010 100644
--- a/Modules/cmathmodule.c
+++ b/Modules/cmathmodule.c
@@ -247,7 +247,9 @@
 	if (!PyArg_ParseTuple(args, "D", &x))
 		return NULL;
 	errno = 0;
+	PyFPE_START_PROTECT("complex function", return 0)
 	x = (*func)(x);
+	PyFPE_END_PROTECT
 	CHECK(x.real);
 	CHECK(x.imag);
 	if (errno != 0)
diff --git a/Modules/fpectlmodule.c b/Modules/fpectlmodule.c
new file mode 100644
index 0000000..3fc5d06
--- /dev/null
+++ b/Modules/fpectlmodule.c
@@ -0,0 +1,244 @@
+/*
+     ---------------------------------------------------------------------  
+    /                       Copyright (c) 1996.                           \ 
+   |          The Regents of the University of California.                 |
+   |                        All rights reserved.                           |
+   |                                                                       |
+   |   Permission to use, copy, modify, and distribute this software for   |
+   |   any purpose without fee is hereby granted, provided that this en-   |
+   |   tire notice is included in all copies of any software which is or   |
+   |   includes  a  copy  or  modification  of  this software and in all   |
+   |   copies of the supporting documentation for such software.           |
+   |                                                                       |
+   |   This  work was produced at the University of California, Lawrence   |
+   |   Livermore National Laboratory under  contract  no.  W-7405-ENG-48   |
+   |   between  the  U.S.  Department  of  Energy and The Regents of the   |
+   |   University of California for the operation of UC LLNL.              |
+   |                                                                       |
+   |                              DISCLAIMER                               |
+   |                                                                       |
+   |   This  software was prepared as an account of work sponsored by an   |
+   |   agency of the United States Government. Neither the United States   |
+   |   Government  nor the University of California nor any of their em-   |
+   |   ployees, makes any warranty, express or implied, or  assumes  any   |
+   |   liability  or  responsibility  for the accuracy, completeness, or   |
+   |   usefulness of any information,  apparatus,  product,  or  process   |
+   |   disclosed,   or  represents  that  its  use  would  not  infringe   |
+   |   privately-owned rights. Reference herein to any specific  commer-   |
+   |   cial  products,  process,  or  service  by trade name, trademark,   |
+   |   manufacturer, or otherwise, does not  necessarily  constitute  or   |
+   |   imply  its endorsement, recommendation, or favoring by the United   |
+   |   States Government or the University of California. The views  and   |
+   |   opinions  of authors expressed herein do not necessarily state or   |
+   |   reflect those of the United States Government or  the  University   |
+   |   of  California,  and shall not be used for advertising or product   |
+    \  endorsement purposes.                                              / 
+     ---------------------------------------------------------------------  
+*/
+
+/*
+		  Floating point exception control module.
+
+   This Python module provides bare-bones control over floating point
+   units from several hardware manufacturers.  Specifically, it allows
+   the user to turn on the generation of SIGFPE whenever any of the
+   three serious IEEE 754 exceptions (Division by Zero, Overflow,
+   Invalid Operation) occurs.  We currently ignore Underflow and
+   Inexact Result exceptions, although those could certainly be added
+   if desired.
+
+   The module also establishes a signal handler for SIGFPE during
+   initialization.  This builds on code found in the Python
+   distribution at Include/pyfpe.h and Python/pyfpe.c.  If those files
+   are not in your Python distribution, find them in a patch at
+   ftp://icf.llnl.gov/pub/python/busby/patches.961108.tgz.
+
+   This module is only useful to you if it happens to include code
+   specific for your hardware and software environment.  If you can
+   contribute OS-specific code for new platforms, or corrections for
+   the code provided, it will be greatly appreciated.
+
+   ** Version 1.0: September 20, 1996.  Lee Busby, LLNL.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "Python.h"
+#include <signal.h>
+
+#ifndef WANT_SIGFPE_HANDLER
+/* Define locally if they are not defined in Python.  This gives only
+ * the limited control to induce a core dump in case of an exception.
+ */
+static jmp_buf PyFPE_jbuf;
+static int PyFPE_counter = 0;
+#endif
+
+typedef RETSIGTYPE Sigfunc(int);
+static Sigfunc sigfpe_handler;
+static void fpe_reset(Sigfunc *);
+
+static PyObject *fpe_error;
+void initfpectl(void);
+static PyObject *turnon_sigfpe            (PyObject *self,PyObject *args);
+static PyObject *turnoff_sigfpe           (PyObject *self,PyObject *args);
+
+static PyMethodDef fpectl_methods[] = {
+    {"turnon_sigfpe",		 (PyCFunction) turnon_sigfpe,		 1},
+    {"turnoff_sigfpe",		 (PyCFunction) turnoff_sigfpe, 	         1},
+    {0,0}
+};
+
+static PyObject *turnon_sigfpe(PyObject *self,PyObject *args)
+{
+    /* Do any architecture-specific one-time only initialization here. */
+
+    fpe_reset(sigfpe_handler);
+    Py_INCREF (Py_None);
+    return Py_None;
+}
+
+static void fpe_reset(Sigfunc *handler)
+{
+    /* Reset the exception handling machinery, and reset the signal
+     * handler for SIGFPE to the given handler.
+     */
+
+/*-- IRIX -----------------------------------------------------------------*/
+#if defined(sgi)
+    /* See man page on handle_sigfpes -- must link with -lfpe
+     * My usage doesn't follow the man page exactly.  Maybe somebody
+     * else can explain handle_sigfpes to me....
+     * cc -c -I/usr/local/python/include fpectlmodule.c
+     * ld -shared -o fpectlmodule.so fpectlmodule.o -lfpe 
+     */
+#include <sigfpe.h>
+    typedef void user_routine (unsigned[5], int[2]);
+    typedef void abort_routine (unsigned long);
+    handle_sigfpes(_OFF, 0,
+		 (user_routine *)0,
+		 _TURN_OFF_HANDLER_ON_ERROR,
+		 (abort_routine*)0);
+    handle_sigfpes(_ON, _EN_OVERFL | _EN_DIVZERO | _EN_INVALID,
+		 (user_routine *)0,
+		 _ABORT_ON_ERROR,
+		 (abort_routine*)0);
+    signal(SIGFPE, handler);
+
+/*-- SunOS and Solaris ----------------------------------------------------*/
+#elif defined(sun)
+    /* References: ieee_handler, ieee_sun, ieee_functions, and ieee_flags
+       man pages (SunOS or Solaris)
+       cc -c -I/usr/local/python/include fpectlmodule.c
+       ld -G -o fpectlmodule.so -L/opt/SUNWspro/lib fpectlmodule.o -lsunmath -lm
+     */
+#include <math.h>
+    char *mode="exception", *in="all", *out;
+    (void) nonstandard_arithmetic();
+    (void) ieee_flags("clearall",mode,in,&out);
+    (void) ieee_handler("set","common",(sigfpe_handler_type)handler);
+    signal(SIGFPE, handler);
+
+/*-- HPUX -----------------------------------------------------------------*/
+#elif defined(__hppa) || defined(hppa)
+    /* References:   fpsetmask man page */
+    /* cc -Aa +z -c -I/usr/local/python/include fpectlmodule.c */
+    /* ld -b -o fpectlmodule.sl fpectlmodule.o -lm */
+#include <math.h>
+    fpsetdefaults();
+    signal(SIGFPE, handler);
+
+/*-- IBM AIX --------------------------------------------------------------*/
+#elif defined(__AIX) || defined(_AIX)
+    /* References:   fp_trap, fp_enable man pages */
+#include <fptrap.h>
+    fp_trap(FP_TRAP_SYNC);
+    fp_enable(TRP_INVALID | TRP_DIV_BY_ZERO | TRP_OVERFLOW);
+    signal(SIGFPE, handler);
+
+/*-- DEC ALPHA OSF --------------------------------------------------------*/
+#elif defined(__alpha)
+    /* References:   exception_intro, ieee man pages */
+    /* cc -c -I/usr/local/python/include fpectlmodule.c */
+    /* ld -shared -o fpectlmodule.so fpectlmodule.o */
+#include <machine/fpu.h>
+    unsigned long fp_control =
+    IEEE_TRAP_ENABLE_INV | IEEE_TRAP_ENABLE_DZE | IEEE_TRAP_ENABLE_OVF;
+    ieee_set_fp_control(fp_control);
+    signal(SIGFPE, handler);
+
+/*-- Cray Unicos ----------------------------------------------------------*/
+#elif defined(cray)
+    /* UNICOS delivers SIGFPE by default, but no matherr */
+#ifdef HAS_LIBMSET
+    libmset(-1);
+#endif
+    signal(SIGFPE, handler);
+
+/*-- Linux ----------------------------------------------------------------*/
+#elif defined(linux)
+    /* Linux delivers SIGFPE by default,
+       except for log(0), atanh(-1), 0.^0.
+     */
+    signal(SIGFPE, handler);
+
+/*-- NeXT -----------------------------------------------------------------*/
+#elif defined(NeXT) && defined(m68k) && defined(__GNUC__)
+    /* NeXT needs explicit csr set to generate SIGFPE */
+    asm("fmovel     #0x1400,fpcr");   /* set OVFL and ZD bits */
+    signal(SIGFPE, handler);
+
+/*-- Microsoft Windows, NT ------------------------------------------------*/
+#elif defined(_MSC_VER)
+    /* Reference: Visual C++ Books Online 4.2,
+       Run-Time Library Reference, _control87, _controlfp */
+#include <float.h>
+    unsigned int cw = _EM_INVALID | _EM_ZERODIVIDE | _EM_OVERFLOW;
+    (void)_controlfp(0, cw);
+    signal(SIGFPE, handler);
+
+/*-- Give Up --------------------------------------------------------------*/
+#else
+    fputs("Operation not implemented\n", stderr);
+#endif
+
+}
+
+static PyObject *turnoff_sigfpe(PyObject *self,PyObject *args)
+{
+    fputs("Operation not implemented\n", stderr);
+    Py_INCREF (Py_None);
+    return Py_None;
+}
+
+static void sigfpe_handler(int signo)
+{
+    fpe_reset(sigfpe_handler);
+    if(PyFPE_counter) {
+        longjmp(PyFPE_jbuf, 1);
+    } else {
+        Py_FatalError("Unprotected floating point exception");
+    }
+}
+
+void initfpectl(void)
+{
+    PyObject *m, *d;
+    static int already_initialized = 0;
+
+    if (already_initialized) return;
+    m = Py_InitModule("fpectl", fpectl_methods);
+    d = PyModule_GetDict(m);
+    fpe_error = PyString_FromString("fpectl.error");
+    PyDict_SetItemString(d, "error", fpe_error);
+
+    if (PyErr_Occurred())
+	Py_FatalError("Cannot initialize module fpectl");
+    already_initialized = 1;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/Modules/fpetestmodule.c b/Modules/fpetestmodule.c
new file mode 100644
index 0000000..2156afb
--- /dev/null
+++ b/Modules/fpetestmodule.c
@@ -0,0 +1,228 @@
+/*
+     ---------------------------------------------------------------------  
+    /                       Copyright (c) 1996.                           \ 
+   |          The Regents of the University of California.                 |
+   |                        All rights reserved.                           |
+   |                                                                       |
+   |   Permission to use, copy, modify, and distribute this software for   |
+   |   any purpose without fee is hereby granted, provided that this en-   |
+   |   tire notice is included in all copies of any software which is or   |
+   |   includes  a  copy  or  modification  of  this software and in all   |
+   |   copies of the supporting documentation for such software.           |
+   |                                                                       |
+   |   This  work was produced at the University of California, Lawrence   |
+   |   Livermore National Laboratory under  contract  no.  W-7405-ENG-48   |
+   |   between  the  U.S.  Department  of  Energy and The Regents of the   |
+   |   University of California for the operation of UC LLNL.              |
+   |                                                                       |
+   |                              DISCLAIMER                               |
+   |                                                                       |
+   |   This  software was prepared as an account of work sponsored by an   |
+   |   agency of the United States Government. Neither the United States   |
+   |   Government  nor the University of California nor any of their em-   |
+   |   ployees, makes any warranty, express or implied, or  assumes  any   |
+   |   liability  or  responsibility  for the accuracy, completeness, or   |
+   |   usefulness of any information,  apparatus,  product,  or  process   |
+   |   disclosed,   or  represents  that  its  use  would  not  infringe   |
+   |   privately-owned rights. Reference herein to any specific  commer-   |
+   |   cial  products,  process,  or  service  by trade name, trademark,   |
+   |   manufacturer, or otherwise, does not  necessarily  constitute  or   |
+   |   imply  its endorsement, recommendation, or favoring by the United   |
+   |   States Government or the University of California. The views  and   |
+   |   opinions  of authors expressed herein do not necessarily state or   |
+   |   reflect those of the United States Government or  the  University   |
+   |   of  California,  and shall not be used for advertising or product   |
+    \  endorsement purposes.                                              / 
+     ---------------------------------------------------------------------  
+*/
+
+/*
+		  Floating point exception test module.
+
+ */
+
+#include "Python.h"
+
+static PyObject *fpe_error;
+void initfpetest(void);
+static PyObject *test(PyObject *self,PyObject *args);
+static int db0(void);
+static int overflow(void);
+static int nest1(double);
+static int nest2(double);
+static double nest3(double);
+
+static PyMethodDef fpetest_methods[] = {
+    {"test",		 (PyCFunction) test,		 1},
+    {0,0}
+};
+
+static PyObject *test(PyObject *self,PyObject *args)
+{
+    int i = 0, r;
+
+    fprintf(stderr,"Test trapping overflow\n");
+    r = overflow();
+    if(r){
+      fprintf(stderr,"(Note: No exception was raised.)\n");
+      PyErr_Clear();
+    }else{
+      fprintf(stderr,"Trapped:: ");
+      PyErr_Print();
+      PyErr_Clear();
+    }
+    i += r;
+
+    fprintf(stderr,"Test trapping division by zero\n");
+    r = db0();
+    if(r){
+      fprintf(stderr,"(Note: No exception was raised.)\n");
+      PyErr_Clear();
+    }else{
+      fprintf(stderr,"Trapped:: ");
+      PyErr_Print();
+      PyErr_Clear();
+    }
+    i += r;
+
+    fprintf(stderr,"Test nested protection zones, outer zone\n");
+    r = nest1(0.0);
+    if(r){
+      fprintf(stderr,"(Note: No exception was raised.)\n");
+      PyErr_Clear();
+    }else{
+      fprintf(stderr,"Trapped:: ");
+      PyErr_Print();
+      PyErr_Clear();
+    }
+    i += r;
+
+    fprintf(stderr,"Test nested protection zones, inner zone\n");
+    fprintf(stderr,"(Note: Return will apparently come from outer zone.)\n");
+    r = nest1(1.0);
+    if(r){
+      fprintf(stderr,"(Note: No exception was raised.)\n");
+      PyErr_Clear();
+    }else{
+      fprintf(stderr,"Trapped:: ");
+      PyErr_Print();
+      PyErr_Clear();
+    }
+    i += r;
+
+    fprintf(stderr,"Test nested protection zones, trailing outer zone\n");
+    r = nest1(2.0);
+    if(r){
+      fprintf(stderr,"(Note: No exception was raised.)\n");
+      PyErr_Clear();
+    }else{
+      fprintf(stderr,"Trapped:: ");
+      PyErr_Print();
+      PyErr_Clear();
+    }
+    i += r;
+
+    fprintf(stderr,"Test nested function calls, prior error\n");
+    r = nest2(0.0);
+    if(r){
+      fprintf(stderr,"(Note: No exception was raised.)\n");
+      PyErr_Clear();
+    }else{
+      fprintf(stderr,"Trapped:: ");
+      PyErr_Print();
+      PyErr_Clear();
+    }
+    i += r;
+
+    fprintf(stderr,"Test nested function calls, interior error\n");
+    r = nest2(1.0);
+    if(r){
+      fprintf(stderr,"(Note: No exception was raised.)\n");
+      PyErr_Clear();
+    }else{
+      fprintf(stderr,"Trapped:: ");
+      PyErr_Print();
+      PyErr_Clear();
+    }
+    i += r;
+
+    fprintf(stderr,"Test nested function calls, trailing error\n");
+    r = nest2(2.0);
+    if(r){
+      fprintf(stderr,"(Note: No exception was raised.)\n");
+      PyErr_Clear();
+    }else{
+      fprintf(stderr,"Trapped:: ");
+      PyErr_Print();
+      PyErr_Clear();
+    }
+    i += r;
+
+    fprintf(stderr,"Number of tests failed: %d\n", i);
+    Py_INCREF (Py_None);
+    return Py_None;
+}
+
+static int nest1(double x)
+{
+  double a = 1.0;
+  PyFPE_START_PROTECT("Division by zero, outer zone", return 0)
+  a = 1./x;
+    PyFPE_START_PROTECT("Division by zero, inner zone", return 0)
+    a = 1./(1. - x);
+    PyFPE_END_PROTECT
+  a = 1./(2. - x);
+  PyFPE_END_PROTECT
+  return(1);
+}
+
+static int nest2(double x)
+{
+  double a = 1.0;
+  PyFPE_START_PROTECT("Division by zero, prior error", return 0)
+  a = 1./x;
+  a = nest3(x);
+  a = 1./(2. - x);
+  PyFPE_END_PROTECT
+  return(1);
+}
+
+static double nest3(double x)
+{
+  double result;
+  PyFPE_START_PROTECT("Division by zero, nest3 error", return 0)
+  result = 1./(1. - x);
+  PyFPE_END_PROTECT
+  return result;
+}
+
+static int db0(void)
+{
+  double a = 1.0;
+  PyFPE_START_PROTECT("Division by zero", return 0)
+  a = 1./(a - 1.);
+  PyFPE_END_PROTECT
+  return(1);
+}
+
+static int overflow(void)
+{
+  double a, b = 1.e200;
+  PyFPE_START_PROTECT("Overflow", return 0)
+  a = b*b;
+  PyFPE_END_PROTECT
+  return(1);
+}
+
+void initfpetest(void)
+{
+    PyObject *m, *d;
+
+    m = Py_InitModule("fpetest", fpetest_methods);
+    d = PyModule_GetDict(m);
+    fpe_error = PyString_FromString("fpetest.error");
+    PyDict_SetItemString(d, "error", fpe_error);
+
+    if (PyErr_Occurred())
+	Py_FatalError("Cannot initialize module fpetest");
+}
diff --git a/Modules/imgfile.c b/Modules/imgfile.c
index 33266b9..779169d 100644
--- a/Modules/imgfile.c
+++ b/Modules/imgfile.c
@@ -387,8 +387,10 @@
 		iclose(image);
 		return NULL;
 	}
+	PyFPE_START_PROTECT("readscaled", return 0)
 	xfac = (float)xsize/(float)xwtd;
 	yfac = (float)ysize/(float)ywtd;
+	PyFPE_END_PROTECT
 	cdatap = PyString_AsString(rv);
 	idatap = (long *)cdatap;
 
diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
index abf1d5b..bb4f1e8 100644
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -80,7 +80,9 @@
 	if (!  PyArg_Parse(args, "d", &x))
 		return NULL;
 	errno = 0;
+	PyFPE_START_PROTECT("in math_1", return 0)
 	x = (*func)(x);
+	PyFPE_END_PROTECT
 	CHECK(x);
 	if (errno != 0)
 		return math_error();
@@ -97,7 +99,9 @@
 	if (! PyArg_Parse(args, "(dd)", &x, &y))
 		return NULL;
 	errno = 0;
+	PyFPE_START_PROTECT("in math_2", return 0)
 	x = (*func)(x, y);
+	PyFPE_END_PROTECT
 	CHECK(x);
 	if (errno != 0)
 		return math_error();
@@ -173,7 +177,9 @@
         if (! PyArg_Parse(args, "(dd)", &x, &y))
 		return NULL;
 	errno = 0;
+	PyFPE_START_PROTECT("ldexp", return 0)
 	x = ldexp(x, (int)y);
+	PyFPE_END_PROTECT
 	CHECK(x);
 	if (errno != 0)
 		return math_error();
diff --git a/Modules/mpzmodule.c b/Modules/mpzmodule.c
index 1f356e1..bf83109 100644
--- a/Modules/mpzmodule.c
+++ b/Modules/mpzmodule.c
@@ -1488,6 +1488,8 @@
 	/* let those bits come, let those bits go,
 	   e.g. dismantle mpzscratch, build PyFloatObject */
 
+	/* Can this overflow?  Dunno, protect against that possibility. */
+	PyFPE_START_PROTECT("mpz_float", return 0)
 	x = 0.0;
 	mulstate = 1.0;
 	while (i--) {
@@ -1495,6 +1497,7 @@
 		mulstate *= multiplier;
 		mpz_div_2exp(&mpzscratch, &mpzscratch, BITS_PER_MP_LIMB);
 	}
+	PyFPE_END_PROTECT
 
 	assert(mpz_cmp_ui(&mpzscratch, (unsigned long int)0) == 0);
 	mpz_clear(&mpzscratch);
diff --git a/Modules/stropmodule.c b/Modules/stropmodule.c
index cb062ad..8ddf37d 100644
--- a/Modules/stropmodule.c
+++ b/Modules/stropmodule.c
@@ -661,7 +661,9 @@
 		return NULL;
 	}
 	errno = 0;
+	PyFPE_START_PROTECT("strop_atof", return 0)
 	x = strtod(s, &end);
+	PyFPE_END_PROTECT
 	while (*end && isspace(Py_CHARMASK(*end)))
 		end++;
 	if (*end != '\0') {