diff -r e9ba95418af8 Modules/_ctypes/_ctypes.c
--- a/Modules/_ctypes/_ctypes.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_ctypes/_ctypes.c	Wed Mar 25 01:56:21 2015 +0100
@@ -649,10 +649,14 @@ CDataType_from_param(PyObject *type, PyO
         Py_DECREF(as_parameter);
         return value;
     }
-    PyErr_Format(PyExc_TypeError,
-                 "expected %s instance instead of %s",
-                 ((PyTypeObject *)type)->tp_name,
-                 Py_TYPE(value)->tp_name);
+
+    if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+        PyErr_Format(PyExc_TypeError,
+                     "expected %s instance instead of %s",
+                     ((PyTypeObject *)type)->tp_name,
+                     Py_TYPE(value)->tp_name);
+    }
     return NULL;
 }
 
@@ -1313,9 +1317,12 @@ PyCArrayType_new(PyTypeObject *type, PyO
 
     length_attr = PyObject_GetAttrString((PyObject *)result, "_length_");
     if (!length_attr || !PyLong_Check(length_attr)) {
-        PyErr_SetString(PyExc_AttributeError,
-                        "class must define a '_length_' attribute, "
-                        "which must be a positive integer");
+        if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_AttributeError,
+                            "class must define a '_length_' attribute, "
+                            "which must be a positive integer");
+        }
         Py_XDECREF(length_attr);
         goto error;
     }
@@ -1330,8 +1337,11 @@ PyCArrayType_new(PyTypeObject *type, PyO
 
     type_attr = PyObject_GetAttrString((PyObject *)result, "_type_");
     if (!type_attr) {
-        PyErr_SetString(PyExc_AttributeError,
-                        "class must define a '_type_' attribute");
+        if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_AttributeError,
+                            "class must define a '_type_' attribute");
+        }
         goto error;
     }
 
@@ -1526,9 +1536,13 @@ c_wchar_p_from_param(PyObject *type, PyO
         Py_DECREF(as_parameter);
         return value;
     }
-    /* XXX better message */
-    PyErr_SetString(PyExc_TypeError,
-                    "wrong type");
+
+    if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+        /* XXX better message */
+        PyErr_SetString(PyExc_TypeError,
+                        "wrong type");
+    }
     return NULL;
 }
 
@@ -1591,9 +1605,12 @@ c_char_p_from_param(PyObject *type, PyOb
         Py_DECREF(as_parameter);
         return value;
     }
-    /* XXX better message */
-    PyErr_SetString(PyExc_TypeError,
-                    "wrong type");
+
+    if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+        /* XXX better message */
+        PyErr_SetString(PyExc_TypeError, "wrong type");
+    }
     return NULL;
 }
 
@@ -2068,8 +2085,10 @@ PyCSimpleType_from_param(PyObject *type,
         Py_DECREF(as_parameter);
         return value;
     }
-    PyErr_SetString(PyExc_TypeError,
-                    "wrong type");
+    if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+        PyErr_SetString(PyExc_TypeError, "wrong type");
+    }
     return NULL;
 }
 
@@ -2166,9 +2185,12 @@ converters_from_argtypes(PyObject *ob)
   argtypes_error_1:
     Py_XDECREF(converters);
     Py_DECREF(ob);
-    PyErr_Format(PyExc_TypeError,
-                 "item %zd in _argtypes_ has no from_param method",
-                 i+1);
+    if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+        PyErr_Format(PyExc_TypeError,
+                     "item %zd in _argtypes_ has no from_param method",
+                     i+1);
+    }
     return NULL;
 }
 
diff -r e9ba95418af8 Modules/_ctypes/callproc.c
--- a/Modules/_ctypes/callproc.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_ctypes/callproc.c	Wed Mar 25 01:56:21 2015 +0100
@@ -696,9 +696,12 @@ static int ConvParam(PyObject *obj, Py_s
             Py_DECREF(arg);
             return result;
         }
-        PyErr_Format(PyExc_TypeError,
-                     "Don't know how to convert parameter %d",
-                     Py_SAFE_DOWNCAST(index, Py_ssize_t, int));
+        if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            PyErr_Clear();
+            PyErr_Format(PyExc_TypeError,
+                         "Don't know how to convert parameter %d",
+                         Py_SAFE_DOWNCAST(index, Py_ssize_t, int));
+        }
         return -1;
     }
 }
diff -r e9ba95418af8 Modules/_ctypes/stgdict.c
--- a/Modules/_ctypes/stgdict.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_ctypes/stgdict.c	Wed Mar 25 01:56:21 2015 +0100
@@ -342,8 +342,12 @@ PyCStructUnionType_update_stgdict(PyObje
         pack = _PyLong_AsInt(isPacked);
         if (pack < 0 || PyErr_Occurred()) {
             Py_XDECREF(isPacked);
-            PyErr_SetString(PyExc_ValueError,
-                            "_pack_ must be a non-negative integer");
+            if (!PyErr_Occurred()
+                || PyErr_ExceptionMatches(PyExc_OverflowError)) {
+                PyErr_Clear();
+                PyErr_SetString(PyExc_ValueError,
+                                "_pack_ must be a non-negative integer");
+            }
             return -1;
         }
         Py_DECREF(isPacked);
@@ -433,8 +437,12 @@ PyCStructUnionType_update_stgdict(PyObje
         int bitsize = 0;
 
         if (!pair || !PyArg_ParseTuple(pair, "UO|i", &name, &desc, &bitsize)) {
-            PyErr_SetString(PyExc_TypeError,
-                            "'_fields_' must be a sequence of (name, C type) pairs");
+            if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Clear();
+                PyErr_SetString(PyExc_TypeError,
+                                "'_fields_' must be a sequence of "
+                                "(name, C type) pairs");
+            }
             Py_XDECREF(pair);
             return -1;
         }
diff -r e9ba95418af8 Modules/_datetimemodule.c
--- a/Modules/_datetimemodule.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_datetimemodule.c	Wed Mar 25 01:56:21 2015 +0100
@@ -3500,8 +3500,11 @@ time_new(PyTypeObject *type, PyObject *a
         if (PyTuple_GET_SIZE(args) == 2) {
             tzinfo = PyTuple_GET_ITEM(args, 1);
             if (check_tzinfo_subclass(tzinfo) < 0) {
-                PyErr_SetString(PyExc_TypeError, "bad "
-                    "tzinfo state arg");
+                if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                    PyErr_Clear();
+                    PyErr_SetString(PyExc_TypeError, "bad "
+                        "tzinfo state arg");
+                }
                 return NULL;
             }
         }
@@ -3999,8 +4002,11 @@ datetime_new(PyTypeObject *type, PyObjec
         if (PyTuple_GET_SIZE(args) == 2) {
             tzinfo = PyTuple_GET_ITEM(args, 1);
             if (check_tzinfo_subclass(tzinfo) < 0) {
-                PyErr_SetString(PyExc_TypeError, "bad "
-                    "tzinfo state arg");
+                if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                    PyErr_Clear();
+                    PyErr_SetString(PyExc_TypeError,
+                                    "bad tzinfo state arg");
+                }
                 return NULL;
             }
         }
diff -r e9ba95418af8 Modules/_hashopenssl.c
--- a/Modules/_hashopenssl.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_hashopenssl.c	Wed Mar 25 01:56:21 2015 +0100
@@ -446,7 +446,10 @@ EVP_new(PyObject *self, PyObject *args, 
     }
 
     if (!PyArg_Parse(name_obj, "s", &name)) {
-        PyErr_SetString(PyExc_TypeError, "name must be a string");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_TypeError, "name must be a string");
+        }
         return NULL;
     }
 
diff -r e9ba95418af8 Modules/_io/textio.c
--- a/Modules/_io/textio.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_io/textio.c	Wed Mar 25 01:56:21 2015 +0100
@@ -1503,10 +1503,13 @@ textiowrapper_read_chunk(textio *self, P
         goto fail;
 
     if (PyObject_GetBuffer(input_chunk, &input_chunk_buf, 0) != 0) {
-        PyErr_Format(PyExc_TypeError,
-                     "underlying %s() should have returned a bytes-like object, "
-                     "not '%.200s'", (self->has_read1 ? "read1": "read"),
-                     Py_TYPE(input_chunk)->tp_name);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_Format(PyExc_TypeError,
+                         "underlying %s() should have returned a bytes-like object, "
+                         "not '%.200s'", (self->has_read1 ? "read1": "read"),
+                         Py_TYPE(input_chunk)->tp_name);
+        }
         goto fail;
     }
 
diff -r e9ba95418af8 Modules/_lzmamodule.c
--- a/Modules/_lzmamodule.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_lzmamodule.c	Wed Mar 25 01:56:21 2015 +0100
@@ -251,8 +251,11 @@ parse_filter_spec_lzma(PyObject *spec)
                                      uint32_converter, &options->nice_len,
                                      lzma_mf_converter, &options->mf,
                                      uint32_converter, &options->depth)) {
-        PyErr_SetString(PyExc_ValueError,
-                        "Invalid filter specifier for LZMA filter");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_ValueError,
+                            "Invalid filter specifier for LZMA filter");
+        }
         PyMem_Free(options);
         options = NULL;
     }
@@ -269,8 +272,11 @@ parse_filter_spec_delta(PyObject *spec)
 
     if (!PyArg_ParseTupleAndKeywords(empty_tuple, spec, "|OO&", optnames,
                                      &id, uint32_converter, &dist)) {
-        PyErr_SetString(PyExc_ValueError,
-                        "Invalid filter specifier for delta filter");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_ValueError,
+                            "Invalid filter specifier for delta filter");
+        }
         return NULL;
     }
 
@@ -293,8 +299,11 @@ parse_filter_spec_bcj(PyObject *spec)
 
     if (!PyArg_ParseTupleAndKeywords(empty_tuple, spec, "|OO&", optnames,
                                      &id, uint32_converter, &start_offset)) {
-        PyErr_SetString(PyExc_ValueError,
-                        "Invalid filter specifier for BCJ filter");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_ValueError,
+                            "Invalid filter specifier for BCJ filter");
+        }
         return NULL;
     }
 
@@ -319,9 +328,11 @@ lzma_filter_converter(PyObject *spec, vo
     }
     id_obj = PyMapping_GetItemString(spec, "id");
     if (id_obj == NULL) {
-        if (PyErr_ExceptionMatches(PyExc_KeyError))
+        if (PyErr_ExceptionMatches(PyExc_KeyError)) {
+            PyErr_Clear();
             PyErr_SetString(PyExc_ValueError,
                             "Filter specifier must have an \"id\" entry");
+        }
         return 0;
     }
     f->id = PyLong_AsUnsignedLongLong(id_obj);
diff -r e9ba95418af8 Modules/_pickle.c
--- a/Modules/_pickle.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_pickle.c	Wed Mar 25 01:56:21 2015 +0100
@@ -3146,16 +3146,22 @@ save_global(PicklerObject *self, PyObjec
        extra parameters of __import__ to fix that. */
     module = PyImport_Import(module_name);
     if (module == NULL) {
-        PyErr_Format(st->PicklingError,
-                     "Can't pickle %R: import of module %R failed",
-                     obj, module_name);
+        if (PyErr_ExceptionMatches(PyExc_ImportError)) {
+            PyErr_Clear();
+            PyErr_Format(st->PicklingError,
+                         "Can't pickle %R: import of module %R failed",
+                         obj, module_name);
+        }
         goto error;
     }
     cls = getattribute(module, global_name, self->proto >= 4);
     if (cls == NULL) {
-        PyErr_Format(st->PicklingError,
-                     "Can't pickle %R: attribute lookup %S on %S failed",
-                     obj, global_name, module_name);
+        if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            PyErr_Clear();
+            PyErr_Format(st->PicklingError,
+                         "Can't pickle %R: attribute lookup %S on %S failed",
+                         obj, global_name, module_name);
+        }
         goto error;
     }
     if (cls != obj) {
@@ -4544,8 +4550,11 @@ load_int(UnpicklerObject *self)
         /* XXX: Same thing about the base here. */
         value = PyLong_FromString(s, NULL, 0);
         if (value == NULL) {
-            PyErr_SetString(PyExc_ValueError,
-                            "could not convert string to int");
+            if (PyErr_ExceptionMatches(PyExc_ValueError)) {
+                PyErr_Clear();
+                PyErr_SetString(PyExc_ValueError,
+                                "could not convert string to int");
+            }
             return -1;
         }
     }
diff -r e9ba95418af8 Modules/_sqlite/connection.c
--- a/Modules/_sqlite/connection.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_sqlite/connection.c	Wed Mar 25 01:56:21 2015 +0100
@@ -1262,8 +1262,10 @@ PyObject* pysqlite_connection_call(pysql
         if (rc == PYSQLITE_TOO_MUCH_SQL) {
             PyErr_SetString(pysqlite_Warning, "You can only execute one statement at a time.");
         } else if (rc == PYSQLITE_SQL_WRONG_TYPE) {
-            if (PyErr_ExceptionMatches(PyExc_TypeError))
+            if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Clear();
                 PyErr_SetString(pysqlite_Warning, "SQL is of wrong type. Must be string.");
+            }
         } else {
             (void)pysqlite_statement_reset(statement);
             _pysqlite_seterror(self->db, NULL);
diff -r e9ba95418af8 Modules/_sre.c
--- a/Modules/_sre.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_sre.c	Wed Mar 25 01:56:21 2015 +0100
@@ -315,7 +315,10 @@ getstring(PyObject* string, Py_ssize_t* 
 
     /* get pointer to byte string buffer */
     if (PyObject_GetBuffer(string, view, PyBUF_SIMPLE) != 0) {
-        PyErr_SetString(PyExc_TypeError, "expected string or buffer");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_TypeError, "expected string or buffer");
+        }
         return NULL;
     }
 
@@ -1463,8 +1466,11 @@ static PyObject *
         unsigned long value = PyLong_AsUnsignedLong(o);
         self->code[i] = (SRE_CODE) value;
         if ((unsigned long) self->code[i] != value) {
-            PyErr_SetString(PyExc_OverflowError,
-                            "regular expression code size limit exceeded");
+            if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_OverflowError)) {
+                PyErr_Clear();
+                PyErr_SetString(PyExc_OverflowError,
+                                "regular expression code size limit exceeded");
+            }
             break;
         }
     }
diff -r e9ba95418af8 Modules/_ssl.c
--- a/Modules/_ssl.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_ssl.c	Wed Mar 25 01:56:21 2015 +0100
@@ -2856,8 +2856,11 @@ load_verify_locations(PySSLContext *self
         goto error;
     }
     if (capath && !PyUnicode_FSConverter(capath, &capath_bytes)) {
-        PyErr_SetString(PyExc_TypeError,
-                        "capath should be a valid filesystem path");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_TypeError,
+                            "capath should be a valid filesystem path");
+        }
         goto error;
     }
 
@@ -2883,9 +2886,12 @@ load_verify_locations(PySSLContext *self
             PyErr_Clear();
             cadata_ascii = PyUnicode_AsASCIIString(cadata);
             if (cadata_ascii == NULL) {
-                PyErr_SetString(PyExc_TypeError,
-                                "cadata should be a ASCII string or a "
-                                "bytes-like object");
+                if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                    PyErr_Clear();
+                    PyErr_SetString(PyExc_TypeError,
+                                    "cadata should be a ASCII string or a "
+                                    "bytes-like object");
+                }
                 goto error;
             }
             r = _add_ca_certs(self,
diff -r e9ba95418af8 Modules/_struct.c
--- a/Modules/_struct.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_struct.c	Wed Mar 25 01:56:21 2015 +0100
@@ -131,9 +131,11 @@ get_long(PyObject *v, long *p)
     x = PyLong_AsLong(v);
     Py_DECREF(v);
     if (x == (long)-1 && PyErr_Occurred()) {
-        if (PyErr_ExceptionMatches(PyExc_OverflowError))
+        if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
+            PyErr_Clear();
             PyErr_SetString(StructError,
                             "argument out of range");
+        }
         return -1;
     }
     *p = x;
@@ -155,9 +157,11 @@ get_ulong(PyObject *v, unsigned long *p)
     x = PyLong_AsUnsignedLong(v);
     Py_DECREF(v);
     if (x == (unsigned long)-1 && PyErr_Occurred()) {
-        if (PyErr_ExceptionMatches(PyExc_OverflowError))
+        if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
+            PyErr_Clear();
             PyErr_SetString(StructError,
                             "argument out of range");
+        }
         return -1;
     }
     *p = x;
@@ -180,9 +184,11 @@ get_longlong(PyObject *v, PY_LONG_LONG *
     x = PyLong_AsLongLong(v);
     Py_DECREF(v);
     if (x == (PY_LONG_LONG)-1 && PyErr_Occurred()) {
-        if (PyErr_ExceptionMatches(PyExc_OverflowError))
+        if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
+            PyErr_Clear();
             PyErr_SetString(StructError,
                             "argument out of range");
+        }
         return -1;
     }
     *p = x;
@@ -203,9 +209,11 @@ get_ulonglong(PyObject *v, unsigned PY_L
     x = PyLong_AsUnsignedLongLong(v);
     Py_DECREF(v);
     if (x == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred()) {
-        if (PyErr_ExceptionMatches(PyExc_OverflowError))
+        if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
+            PyErr_Clear();
             PyErr_SetString(StructError,
                             "argument out of range");
+        }
         return -1;
     }
     *p = x;
@@ -228,9 +236,11 @@ get_ssize_t(PyObject *v, Py_ssize_t *p)
     x = PyLong_AsSsize_t(v);
     Py_DECREF(v);
     if (x == (Py_ssize_t)-1 && PyErr_Occurred()) {
-        if (PyErr_ExceptionMatches(PyExc_OverflowError))
+        if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
+            PyErr_Clear();
             PyErr_SetString(StructError,
                             "argument out of range");
+        }
         return -1;
     }
     *p = x;
@@ -251,9 +261,11 @@ get_size_t(PyObject *v, size_t *p)
     x = PyLong_AsSize_t(v);
     Py_DECREF(v);
     if (x == (size_t)-1 && PyErr_Occurred()) {
-        if (PyErr_ExceptionMatches(PyExc_OverflowError))
+        if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
+            PyErr_Clear();
             PyErr_SetString(StructError,
                             "argument out of range");
+        }
         return -1;
     }
     *p = x;
@@ -685,8 +697,11 @@ np_float(char *p, PyObject *v, const for
 {
     float x = (float)PyFloat_AsDouble(v);
     if (x == -1 && PyErr_Occurred()) {
-        PyErr_SetString(StructError,
-                        "required argument is not a float");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(StructError,
+                            "required argument is not a float");
+        }
         return -1;
     }
     memcpy(p, (char *)&x, sizeof x);
@@ -698,8 +713,11 @@ np_double(char *p, PyObject *v, const fo
 {
     double x = PyFloat_AsDouble(v);
     if (x == -1 && PyErr_Occurred()) {
-        PyErr_SetString(StructError,
-                        "required argument is not a float");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(StructError,
+                            "required argument is not a float");
+        }
         return -1;
     }
     memcpy(p, (char *)&x, sizeof(double));
@@ -926,8 +944,11 @@ bp_float(char *p, PyObject *v, const for
 {
     double x = PyFloat_AsDouble(v);
     if (x == -1 && PyErr_Occurred()) {
-        PyErr_SetString(StructError,
-                        "required argument is not a float");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(StructError,
+                            "required argument is not a float");
+        }
         return -1;
     }
     return _PyFloat_Pack4(x, (unsigned char *)p, 0);
@@ -938,8 +959,11 @@ bp_double(char *p, PyObject *v, const fo
 {
     double x = PyFloat_AsDouble(v);
     if (x == -1 && PyErr_Occurred()) {
-        PyErr_SetString(StructError,
-                        "required argument is not a float");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(StructError,
+                            "required argument is not a float");
+        }
         return -1;
     }
     return _PyFloat_Pack8(x, (unsigned char *)p, 0);
@@ -1146,8 +1170,10 @@ lp_float(char *p, PyObject *v, const for
 {
     double x = PyFloat_AsDouble(v);
     if (x == -1 && PyErr_Occurred()) {
-        PyErr_SetString(StructError,
-                        "required argument is not a float");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_SetString(StructError,
+                            "required argument is not a float");
+        }
         return -1;
     }
     return _PyFloat_Pack4(x, (unsigned char *)p, 1);
@@ -1158,8 +1184,10 @@ lp_double(char *p, PyObject *v, const fo
 {
     double x = PyFloat_AsDouble(v);
     if (x == -1 && PyErr_Occurred()) {
-        PyErr_SetString(StructError,
-                        "required argument is not a float");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_SetString(StructError,
+                            "required argument is not a float");
+        }
         return -1;
     }
     return _PyFloat_Pack8(x, (unsigned char *)p, 1);
@@ -1777,9 +1805,12 @@ s_pack_internal(PyStructObject *soself, 
                 *res = Py_SAFE_DOWNCAST(n, Py_ssize_t, unsigned char);
             } else {
                 if (e->pack(res, v, e) < 0) {
-                    if (PyLong_Check(v) && PyErr_ExceptionMatches(PyExc_OverflowError))
+                    if (PyLong_Check(v)
+                        && PyErr_ExceptionMatches(PyExc_OverflowError)) {
+                        PyErr_Clear();
                         PyErr_SetString(StructError,
                                         "int too large to convert");
+                    }
                     return -1;
                 }
             }
diff -r e9ba95418af8 Modules/_testbuffer.c
--- a/Modules/_testbuffer.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_testbuffer.c	Wed Mar 25 01:56:21 2015 +0100
@@ -2512,16 +2512,22 @@ cmp_contig(PyObject *self, PyObject *arg
     }
 
     if (PyObject_GetBuffer(b1, &v1, PyBUF_FULL_RO) < 0) {
-        PyErr_SetString(PyExc_TypeError,
-            "cmp_contig: first argument does not implement the buffer "
-            "protocol");
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_TypeError,
+                "cmp_contig: first argument does not implement the buffer "
+                "protocol");
+        }
         return NULL;
     }
     if (PyObject_GetBuffer(b2, &v2, PyBUF_FULL_RO) < 0) {
-        PyErr_SetString(PyExc_TypeError,
-            "cmp_contig: second argument does not implement the buffer "
-            "protocol");
         PyBuffer_Release(&v1);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_TypeError,
+                "cmp_contig: second argument does not implement the buffer "
+                "protocol");
+        }
         return NULL;
     }
 
@@ -2588,9 +2594,12 @@ is_contiguous(PyObject *self, PyObject *
     }
     else {
         if (PyObject_GetBuffer(obj, &view, PyBUF_FULL_RO) < 0) {
-            PyErr_SetString(PyExc_TypeError,
-                "is_contiguous: object does not implement the buffer "
-                "protocol");
+            if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Clear();
+                PyErr_SetString(PyExc_TypeError,
+                    "is_contiguous: object does not implement the buffer "
+                    "protocol");
+            }
             return NULL;
         }
         ret = PyBuffer_IsContiguous(&view, ord) ? Py_True : Py_False;
diff -r e9ba95418af8 Modules/_testcapimodule.c
--- a/Modules/_testcapimodule.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/_testcapimodule.c	Wed Mar 25 01:56:21 2015 +0100
@@ -1315,8 +1315,12 @@ parse_tuple_and_keywords(PyObject *self,
     for (i = 0; i < size; i++) {
         o = PySequence_Fast_GET_ITEM(sub_keywords, i);
         if (!PyUnicode_FSConverter(o, (void *)(converted + i))) {
-            PyErr_Format(PyExc_ValueError,
-                "parse_tuple_and_keywords: could not convert keywords[%zd] to narrow string", i);
+            if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Clear();
+                PyErr_Format(PyExc_ValueError,
+                             "parse_tuple_and_keywords: could not convert "
+                             "keywords[%zd] to narrow string", i);
+            }
             goto exit;
         }
         keywords[i] = PyBytes_AS_STRING(converted[i]);
diff -r e9ba95418af8 Modules/posixmodule.c
--- a/Modules/posixmodule.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Modules/posixmodule.c	Wed Mar 25 01:56:21 2015 +0100
@@ -428,9 +428,12 @@ int
 
     index = PyNumber_Index(obj);
     if (index == NULL) {
-        PyErr_Format(PyExc_TypeError,
-                     "uid should be integer, not %.200s",
-                     Py_TYPE(obj)->tp_name);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_Format(PyExc_TypeError,
+                         "uid should be integer, not %.200s",
+                         Py_TYPE(obj)->tp_name);
+        }
         return 0;
     }
 
@@ -534,9 +537,12 @@ int
 
     index = PyNumber_Index(obj);
     if (index == NULL) {
-        PyErr_Format(PyExc_TypeError,
-                     "gid should be integer, not %.200s",
-                     Py_TYPE(obj)->tp_name);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_Format(PyExc_TypeError,
+                         "gid should be integer, not %.200s",
+                         Py_TYPE(obj)->tp_name);
+        }
         return 0;
     }
 
@@ -676,9 +682,12 @@ static int
 
     PyObject *index = PyNumber_Index(o);
     if (index == NULL) {
-        PyErr_Format(PyExc_TypeError,
-                     "argument should be %s, not %.200s",
-                     allowed, Py_TYPE(o)->tp_name);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_Format(PyExc_TypeError,
+                         "argument should be %s, not %.200s",
+                         allowed, Py_TYPE(o)->tp_name);
+        }
         return 0;
     }
 
diff -r e9ba95418af8 Objects/abstract.c
--- a/Objects/abstract.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Objects/abstract.c	Wed Mar 25 01:56:21 2015 +0100
@@ -1319,8 +1319,12 @@ PyNumber_Long(PyObject *o)
         return result;
     }
 
-    return type_error("int() argument must be a string, a bytes-like object "
-                      "or a number, not '%.200s'", o);
+    if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+        PyErr_Clear();
+        type_error("int() argument must be a string, a bytes-like object "
+                          "or a number, not '%.200s'", o);
+    }
+    return NULL;
 }
 
 PyObject *
@@ -1780,8 +1784,10 @@ PySequence_Fast(PyObject *v, const char 
 
     it = PyObject_GetIter(v);
     if (it == NULL) {
-        if (PyErr_ExceptionMatches(PyExc_TypeError))
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
             PyErr_SetString(PyExc_TypeError, m);
+        }
         return NULL;
     }
 
@@ -1811,7 +1817,10 @@ Py_ssize_t
 
     it = PyObject_GetIter(seq);
     if (it == NULL) {
-        type_error("argument of type '%.200s' is not iterable", seq);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            type_error("argument of type '%.200s' is not iterable", seq);
+        }
         return -1;
     }
 
diff -r e9ba95418af8 Objects/bytearrayobject.c
--- a/Objects/bytearrayobject.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Objects/bytearrayobject.c	Wed Mar 25 01:56:21 2015 +0100
@@ -38,7 +38,10 @@ static int
     } else {
         PyObject *index = PyNumber_Index(arg);
         if (index == NULL) {
-            PyErr_Format(PyExc_TypeError, "an integer is required");
+            if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Clear();
+                PyErr_Format(PyExc_TypeError, "an integer is required");
+            }
             *value = -1;
             return 0;
         }
@@ -47,8 +50,12 @@ static int
     }
 
     if (face_value < 0 || face_value >= 256) {
-        /* this includes the OverflowError in case the long is too large */
-        PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");
+        if (!PyErr_Occurred()
+            || (PyErr_ExceptionMatches(PyExc_TypeError)
+                || PyErr_ExceptionMatches(PyExc_OverflowError))) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");
+        }
         *value = -1;
         return 0;
     }
@@ -251,8 +258,11 @@ PyByteArray_Concat(PyObject *a, PyObject
     vb.len = -1;
     if (PyObject_GetBuffer(a, &va, PyBUF_SIMPLE) != 0 ||
         PyObject_GetBuffer(b, &vb, PyBUF_SIMPLE) != 0) {
-            PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
-                         Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
+            if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Clear();
+                PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
+                             Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
+            }
             goto done;
     }
 
@@ -317,8 +327,11 @@ bytearray_iconcat(PyByteArrayObject *sel
     Py_buffer vo;
 
     if (PyObject_GetBuffer(other, &vo, PyBUF_SIMPLE) != 0) {
-        PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
-                     Py_TYPE(other)->tp_name, Py_TYPE(self)->tp_name);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
+                         Py_TYPE(other)->tp_name, Py_TYPE(self)->tp_name);
+        }
         return NULL;
     }
 
@@ -1486,9 +1499,12 @@ bytearray_startswith(PyByteArrayObject *
     }
     result = _bytearray_tailmatch(self, subobj, start, end, -1);
     if (result == -1) {
-        if (PyErr_ExceptionMatches(PyExc_TypeError))
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
             PyErr_Format(PyExc_TypeError, "startswith first arg must be bytes "
-                         "or a tuple of bytes, not %s", Py_TYPE(subobj)->tp_name);
+                         "or a tuple of bytes, not %s",
+                         Py_TYPE(subobj)->tp_name);
+        }
         return NULL;
     }
     else
@@ -1529,9 +1545,11 @@ bytearray_endswith(PyByteArrayObject *se
     }
     result = _bytearray_tailmatch(self, subobj, start, end, +1);
     if (result == -1) {
-        if (PyErr_ExceptionMatches(PyExc_TypeError))
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
             PyErr_Format(PyExc_TypeError, "endswith first arg must be bytes or "
                          "a tuple of bytes, not %s", Py_TYPE(subobj)->tp_name);
+        }
         return NULL;
     }
     else
diff -r e9ba95418af8 Objects/bytesobject.c
--- a/Objects/bytesobject.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Objects/bytesobject.c	Wed Mar 25 01:56:21 2015 +0100
@@ -415,8 +415,11 @@ formatfloat(PyObject *v, int flags, int 
 
     x = PyFloat_AsDouble(v);
     if (x == -1.0 && PyErr_Occurred()) {
-        PyErr_Format(PyExc_TypeError, "float argument required, "
-                     "not %.200s", Py_TYPE(v)->tp_name);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_Format(PyExc_TypeError, "float argument required, "
+                         "not %.200s", Py_TYPE(v)->tp_name);
+        }
         return NULL;
     }
 
@@ -436,21 +439,28 @@ formatfloat(PyObject *v, int flags, int 
 Py_LOCAL_INLINE(int)
 byte_converter(PyObject *arg, char *p)
 {
+    long ival;
+
     if (PyBytes_Check(arg) && PyBytes_Size(arg) == 1) {
         *p = PyBytes_AS_STRING(arg)[0];
         return 1;
     }
-    else if (PyByteArray_Check(arg) && PyByteArray_Size(arg) == 1) {
+
+    if (PyByteArray_Check(arg) && PyByteArray_Size(arg) == 1) {
         *p = PyByteArray_AS_STRING(arg)[0];
         return 1;
     }
-    else {
-        long ival = PyLong_AsLong(arg);
-        if (0 <= ival && ival <= 255) {
-            *p = (char)ival;
-            return 1;
-        }
+
+    ival = PyLong_AsLong(arg);
+    if (0 <= ival && ival <= 255) {
+        *p = (char)ival;
+        return 1;
     }
+
+    if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError))
+        return 0;
+
+    PyErr_Clear();
     PyErr_SetString(PyExc_TypeError,
         "%c requires an integer in range(256) or a single byte");
     return 0;
@@ -1236,8 +1246,11 @@ bytes_concat(PyObject *a, PyObject *b)
     vb.len = -1;
     if (PyObject_GetBuffer(a, &va, PyBUF_SIMPLE) != 0 ||
         PyObject_GetBuffer(b, &vb, PyBUF_SIMPLE) != 0) {
-        PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
-                     Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
+                         Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
+        }
         goto done;
     }
 
@@ -3212,9 +3225,11 @@ bytes_startswith(PyBytesObject *self, Py
     }
     result = _bytes_tailmatch(self, subobj, start, end, -1);
     if (result == -1) {
-        if (PyErr_ExceptionMatches(PyExc_TypeError))
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
             PyErr_Format(PyExc_TypeError, "startswith first arg must be bytes "
                          "or a tuple of bytes, not %s", Py_TYPE(subobj)->tp_name);
+        }
         return NULL;
     }
     else
@@ -3256,9 +3271,11 @@ bytes_endswith(PyBytesObject *self, PyOb
     }
     result = _bytes_tailmatch(self, subobj, start, end, +1);
     if (result == -1) {
-        if (PyErr_ExceptionMatches(PyExc_TypeError))
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
             PyErr_Format(PyExc_TypeError, "endswith first arg must be bytes or "
                          "a tuple of bytes, not %s", Py_TYPE(subobj)->tp_name);
+        }
         return NULL;
     }
     else
diff -r e9ba95418af8 Objects/fileobject.c
--- a/Objects/fileobject.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Objects/fileobject.c	Wed Mar 25 01:56:21 2015 +0100
@@ -221,8 +221,12 @@ PyObject_AsFileDescriptor(PyObject *o)
         }
     }
     else {
-        PyErr_SetString(PyExc_TypeError,
-                        "argument must be an int, or have a fileno() method.");
+        if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_TypeError,
+                            "argument must be an int, "
+                            "or have a fileno() method.");
+        }
         return -1;
     }
 
diff -r e9ba95418af8 Objects/floatobject.c
--- a/Objects/floatobject.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Objects/floatobject.c	Wed Mar 25 01:56:21 2015 +0100
@@ -149,9 +149,12 @@ PyFloat_FromString(PyObject *v)
         len = view.len;
     }
     else {
-        PyErr_Format(PyExc_TypeError,
-            "float() argument must be a string or a number, not '%.200s'",
-            Py_TYPE(v)->tp_name);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_Format(PyExc_TypeError,
+                         "float() argument must be a string or a number, "
+                         "not '%.200s'", Py_TYPE(v)->tp_name);
+        }
         return NULL;
     }
     last = s + len;
@@ -165,9 +168,11 @@ PyFloat_FromString(PyObject *v)
      * fine. */
     x = PyOS_string_to_double(s, (char **)&end, NULL);
     if (end != last) {
-        PyErr_Format(PyExc_ValueError,
-                     "could not convert string to float: "
-                     "%R", v);
+        if (!PyErr_Occurred()) {
+            PyErr_Format(PyExc_ValueError,
+                         "could not convert string to float: "
+                         "%R", v);
+        }
         result = NULL;
     }
     else if (x == -1.0 && PyErr_Occurred())
diff -r e9ba95418af8 Objects/longobject.c
--- a/Objects/longobject.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Objects/longobject.c	Wed Mar 25 01:56:21 2015 +0100
@@ -2316,12 +2316,16 @@ PyObject *
     if (end == NULL || (result != NULL && end == s + len))
         return result;
     Py_XDECREF(result);
-    strobj = PyBytes_FromStringAndSize(s, Py_MIN(len, 200));
-    if (strobj != NULL) {
-        PyErr_Format(PyExc_ValueError,
-                     "invalid literal for int() with base %d: %.200R",
-                     base, strobj);
-        Py_DECREF(strobj);
+
+    if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) {
+        PyErr_Clear();
+        strobj = PyBytes_FromStringAndSize(s, Py_MIN(len, 200));
+        if (strobj != NULL) {
+            PyErr_Format(PyExc_ValueError,
+                         "invalid literal for int() with base %d: %.200R",
+                         base, strobj);
+            Py_DECREF(strobj);
+        }
     }
     return NULL;
 }
@@ -2352,6 +2356,7 @@ PyLong_FromUnicodeObject(PyObject *u, in
         Py_DECREF(asciidig);
         if (!PyErr_ExceptionMatches(PyExc_UnicodeEncodeError))
             return NULL;
+        PyErr_Clear();
     }
     else {
         result = PyLong_FromString(buffer, &end, base);
@@ -2361,6 +2366,10 @@ PyLong_FromUnicodeObject(PyObject *u, in
         }
         Py_DECREF(asciidig);
         Py_XDECREF(result);
+
+        if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_ValueError))
+            return NULL;
+        PyErr_Clear();
     }
     PyErr_Format(PyExc_ValueError,
                  "invalid literal for int() with base %d: %.200R",
diff -r e9ba95418af8 Objects/object.c
--- a/Objects/object.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Objects/object.c	Wed Mar 25 01:56:21 2015 +0100
@@ -1104,9 +1104,12 @@ PyObject *
         goto done;
     }
 
-    PyErr_Format(PyExc_AttributeError,
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, name);
+    if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+        PyErr_Format(PyExc_AttributeError,
+                     "'%.50s' object has no attribute '%U'",
+                     tp->tp_name, name);
+    }
   done:
     Py_XDECREF(descr);
     Py_DECREF(name);
@@ -1157,8 +1160,10 @@ int
         dictptr = _PyObject_GetDictPtr(obj);
         if (dictptr != NULL) {
             res = _PyObjectDict_SetItem(Py_TYPE(obj), dictptr, name, value);
-            if (res < 0 && PyErr_ExceptionMatches(PyExc_KeyError))
+            if (res < 0 && PyErr_ExceptionMatches(PyExc_KeyError)) {
+                PyErr_Clear();
                 PyErr_SetObject(PyExc_AttributeError, name);
+            }
             goto done;
         }
     }
diff -r e9ba95418af8 Objects/stringlib/find.h
--- a/Objects/stringlib/find.h	Wed Mar 25 01:55:14 2015 +0100
+++ b/Objects/stringlib/find.h	Wed Mar 25 01:56:21 2015 +0100
@@ -189,7 +189,10 @@ STRINGLIB(parse_args_finds_byte)(const c
     }
 
     if (ival < 0 || ival > 255) {
-        PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");
+        if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_OverflowError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");
+        }
         return 0;
     }
 
diff -r e9ba95418af8 Objects/stringlib/join.h
--- a/Objects/stringlib/join.h	Wed Mar 25 01:55:14 2015 +0100
+++ b/Objects/stringlib/join.h	Wed Mar 25 01:56:21 2015 +0100
@@ -66,10 +66,13 @@ STRINGLIB(bytes_join)(PyObject *sep, PyO
             buffers[i].len = PyBytes_GET_SIZE(item);
         }
         else if (PyObject_GetBuffer(item, &buffers[i], PyBUF_SIMPLE) != 0) {
-            PyErr_Format(PyExc_TypeError,
-                         "sequence item %zd: expected a bytes-like object, "
-                         "%.80s found",
-                         i, Py_TYPE(item)->tp_name);
+            if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Clear();
+                PyErr_Format(PyExc_TypeError,
+                             "sequence item %zd: expected a bytes-like object, "
+                             "%.80s found",
+                             i, Py_TYPE(item)->tp_name);
+            }
             goto error;
         }
         nbufs = i + 1;  /* for error cleanup */
diff -r e9ba95418af8 Objects/stringlib/unicode_format.h
--- a/Objects/stringlib/unicode_format.h	Wed Mar 25 01:55:14 2015 +0100
+++ b/Objects/stringlib/unicode_format.h	Wed Mar 25 01:56:21 2015 +0100
@@ -419,7 +419,10 @@ get_field_object(SubString *input, PyObj
            code is no longer just used with kwargs. It might be passed
            a non-dict when called through format_map. */
         if ((kwargs == NULL) || (obj = PyObject_GetItem(kwargs, key)) == NULL) {
-            PyErr_SetObject(PyExc_KeyError, key);
+            if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_KeyError)) {
+                PyErr_Clear();
+                PyErr_SetObject(PyExc_KeyError, key);
+            }
             Py_DECREF(key);
             goto error;
         }
diff -r e9ba95418af8 Objects/unicodeobject.c
--- a/Objects/unicodeobject.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Objects/unicodeobject.c	Wed Mar 25 01:56:21 2015 +0100
@@ -10931,9 +10931,12 @@ PyUnicode_Contains(PyObject *container, 
     /* Coerce the two arguments */
     sub = PyUnicode_FromObject(element);
     if (!sub) {
-        PyErr_Format(PyExc_TypeError,
-                     "'in <string>' requires string as left operand, not %s",
-                     element->ob_type->tp_name);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_Format(PyExc_TypeError,
+                         "'in <string>' requires string as left operand, not %s",
+                         element->ob_type->tp_name);
+        }
         return -1;
     }
 
@@ -13222,9 +13225,11 @@ unicode_startswith(PyObject *self,
     }
     substring = PyUnicode_FromObject(subobj);
     if (substring == NULL) {
-        if (PyErr_ExceptionMatches(PyExc_TypeError))
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
             PyErr_Format(PyExc_TypeError, "startswith first arg must be str or "
                          "a tuple of str, not %s", Py_TYPE(subobj)->tp_name);
+        }
         return NULL;
     }
     result = tailmatch(self, substring, start, end, -1);
@@ -13274,9 +13279,11 @@ unicode_endswith(PyObject *self,
     }
     substring = PyUnicode_FromObject(subobj);
     if (substring == NULL) {
-        if (PyErr_ExceptionMatches(PyExc_TypeError))
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
             PyErr_Format(PyExc_TypeError, "endswith first arg must be str or "
                          "a tuple of str, not %s", Py_TYPE(subobj)->tp_name);
+        }
         return NULL;
     }
     result = tailmatch(self, substring, start, end, +1);
@@ -14079,16 +14086,20 @@ mainformatlong(PyObject *v,
         if (type == 'o' || type == 'x' || type == 'X') {
             iobj = PyNumber_Index(v);
             if (iobj == NULL) {
-                if (PyErr_ExceptionMatches(PyExc_TypeError))
+                if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                    PyErr_Clear();
                     goto wrongtype;
+                }
                 return -1;
             }
         }
         else {
             iobj = PyNumber_Long(v);
             if (iobj == NULL ) {
-                if (PyErr_ExceptionMatches(PyExc_TypeError))
+                if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                    PyErr_Clear();
                     goto wrongtype;
+                }
                 return -1;
             }
         }
@@ -14199,8 +14210,11 @@ formatchar(PyObject *v)
     }
 
   onError:
-    PyErr_SetString(PyExc_TypeError,
-                    "%c requires int or char");
+    if (!PyErr_Occurred() || PyErr_ExceptionMatches(PyExc_TypeError)) {
+        PyErr_Clear();
+        PyErr_SetString(PyExc_TypeError,
+                        "%c requires int or char");
+    }
     return (Py_UCS4) -1;
 }
 
diff -r e9ba95418af8 Python/bltinmodule.c
--- a/Python/bltinmodule.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Python/bltinmodule.c	Wed Mar 25 01:56:21 2015 +0100
@@ -740,9 +740,12 @@ source_as_string(PyObject *cmd, const ch
         size = view->len;
     }
     else {
-        PyErr_Format(PyExc_TypeError,
-          "%s() arg 1 must be a %s object",
-          funcname, what);
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            PyErr_Clear();
+            PyErr_Format(PyExc_TypeError,
+              "%s() arg 1 must be a %s object",
+              funcname, what);
+        }
         return NULL;
     }
 
@@ -2675,8 +2678,11 @@ builtin_vars(PyObject *self, PyObject *a
     else {
         d = _PyObject_GetAttrId(v, &PyId___dict__);
         if (d == NULL) {
-            PyErr_SetString(PyExc_TypeError,
-                "vars() argument must have __dict__ attribute");
+            if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+                PyErr_Clear();
+                PyErr_SetString(PyExc_TypeError,
+                    "vars() argument must have __dict__ attribute");
+            }
             return NULL;
         }
     }
@@ -3050,10 +3056,12 @@ zip_new(PyTypeObject *type, PyObject *ar
         PyObject *item = PyTuple_GET_ITEM(args, i);
         PyObject *it = PyObject_GetIter(item);
         if (it == NULL) {
-            if (PyErr_ExceptionMatches(PyExc_TypeError))
+            if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Clear();
                 PyErr_Format(PyExc_TypeError,
                     "zip argument #%zd must support iteration",
                     i+1);
+            }
             Py_DECREF(ittuple);
             return NULL;
         }
diff -r e9ba95418af8 Python/ceval.c
--- a/Python/ceval.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Python/ceval.c	Wed Mar 25 01:56:21 2015 +0100
@@ -4534,6 +4534,7 @@ ext_do_call(PyObject *func, PyObject ***
                  * is not a mapping.
                  */
                 if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+                    PyErr_Clear();
                     PyErr_Format(PyExc_TypeError,
                                  "%.200s%.200s argument after ** "
                                  "must be a mapping, not %.200s",
@@ -4554,6 +4555,7 @@ ext_do_call(PyObject *func, PyObject ***
             t = PySequence_Tuple(stararg);
             if (t == NULL) {
                 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                    PyErr_Clear();
                     PyErr_Format(PyExc_TypeError,
                                  "%.200s%.200s argument after * "
                                  "must be a sequence, not %.200s",
diff -r e9ba95418af8 Python/pytime.c
--- a/Python/pytime.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Python/pytime.c	Wed Mar 25 01:56:21 2015 +0100
@@ -260,8 +260,10 @@ time_t
     val = PyLong_AsLong(obj);
 #endif
     if (val == -1 && PyErr_Occurred()) {
-        if (PyErr_ExceptionMatches(PyExc_OverflowError))
+        if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
+            PyErr_Clear();
             error_time_t_overflow();
+        }
         return -1;
     }
     return (time_t)val;
diff -r e9ba95418af8 Python/symtable.c
--- a/Python/symtable.c	Wed Mar 25 01:55:14 2015 +0100
+++ b/Python/symtable.c	Wed Mar 25 01:56:21 2015 +0100
@@ -946,6 +946,7 @@ symtable_warn(struct symtable *st, char 
                                  lineno, NULL, NULL) < 0)     {
         Py_DECREF(message);
         if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) {
+            PyErr_Clear();
             PyErr_SetString(PyExc_SyntaxError, msg);
             PyErr_SyntaxLocationObject(st->st_filename, st->st_cur->ste_lineno,
                                        st->st_cur->ste_col_offset);