diff -r 57550e1f57d9 Modules/_ctypes/_ctypes.c
--- a/Modules/_ctypes/_ctypes.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Modules/_ctypes/_ctypes.c	Tue Mar 24 15:42:05 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;
 }
 
@@ -1312,11 +1316,22 @@ PyCArrayType_new(PyTypeObject *type, PyO
     type_attr = NULL;
 
     length_attr = PyObject_GetAttrString((PyObject *)result, "_length_");
-    if (!length_attr || !PyLong_Check(length_attr)) {
+    if (!length_attr) {
+        if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            PyErr_Clear();
+            PyErr_SetString(PyExc_AttributeError,
+                            "class must define a '_length_' attribute, "
+                            "which must be a positive integer");
+        }
+        assert(PyErr_Occurred());
+        goto error;
+    }
+    if (!PyLong_Check(length_attr)) {
+        assert(!PyErr_Occurred());
         PyErr_SetString(PyExc_AttributeError,
                         "class must define a '_length_' attribute, "
                         "which must be a positive integer");
-        Py_XDECREF(length_attr);
+        Py_DECREF(length_attr);
         goto error;
     }
     length = PyLong_AsLongAndOverflow(length_attr, &overflow);
@@ -1330,8 +1345,12 @@ 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");
+        }
+        assert(PyErr_Occurred());
         goto error;
     }
 
@@ -1526,9 +1545,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 +1614,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 +2094,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 +2194,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 57550e1f57d9 Modules/_ctypes/callproc.c
--- a/Modules/_ctypes/callproc.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Modules/_ctypes/callproc.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Modules/_ctypes/stgdict.c
--- a/Modules/_ctypes/stgdict.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Modules/_ctypes/stgdict.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Modules/_hashopenssl.c
--- a/Modules/_hashopenssl.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Modules/_hashopenssl.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Modules/_lzmamodule.c
--- a/Modules/_lzmamodule.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Modules/_lzmamodule.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Modules/_pickle.c
--- a/Modules/_pickle.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Modules/_pickle.c	Tue Mar 24 15:42:05 2015 +0100
@@ -3153,9 +3153,12 @@ save_global(PicklerObject *self, PyObjec
     }
     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 +4547,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 57550e1f57d9 Modules/_sqlite/connection.c
--- a/Modules/_sqlite/connection.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Modules/_sqlite/connection.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Modules/_sre.c
--- a/Modules/_sre.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Modules/_sre.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Modules/_ssl.c
--- a/Modules/_ssl.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Modules/_ssl.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Modules/_testcapimodule.c
--- a/Modules/_testcapimodule.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Modules/_testcapimodule.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Modules/posixmodule.c
--- a/Modules/posixmodule.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Modules/posixmodule.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Objects/abstract.c
--- a/Objects/abstract.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Objects/abstract.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Objects/bytearrayobject.c
--- a/Objects/bytearrayobject.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Objects/bytearrayobject.c	Tue Mar 24 15:42:05 2015 +0100
@@ -1471,9 +1471,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
diff -r 57550e1f57d9 Objects/bytesobject.c
--- a/Objects/bytesobject.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Objects/bytesobject.c	Tue Mar 24 15:42:05 2015 +0100
@@ -3197,9 +3197,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
diff -r 57550e1f57d9 Objects/floatobject.c
--- a/Objects/floatobject.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Objects/floatobject.c	Tue Mar 24 15:42:05 2015 +0100
@@ -165,9 +165,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 57550e1f57d9 Objects/longobject.c
--- a/Objects/longobject.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Objects/longobject.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Objects/object.c
--- a/Objects/object.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Objects/object.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Objects/stringlib/join.h
--- a/Objects/stringlib/join.h	Tue Mar 24 14:01:32 2015 +0100
+++ b/Objects/stringlib/join.h	Tue Mar 24 15:42:05 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 57550e1f57d9 Objects/stringlib/unicode_format.h
--- a/Objects/stringlib/unicode_format.h	Tue Mar 24 14:01:32 2015 +0100
+++ b/Objects/stringlib/unicode_format.h	Tue Mar 24 15:42:05 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 57550e1f57d9 Objects/unicodeobject.c
--- a/Objects/unicodeobject.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Objects/unicodeobject.c	Tue Mar 24 15:42:05 2015 +0100
@@ -10914,9 +10914,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;
     }
 
@@ -13182,9 +13185,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);
@@ -13234,9 +13239,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);
@@ -14039,16 +14046,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;
             }
         }
@@ -14159,8 +14170,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 57550e1f57d9 Python/bltinmodule.c
--- a/Python/bltinmodule.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Python/bltinmodule.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Python/pytime.c
--- a/Python/pytime.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Python/pytime.c	Tue Mar 24 15:42:05 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 57550e1f57d9 Python/symtable.c
--- a/Python/symtable.c	Tue Mar 24 14:01:32 2015 +0100
+++ b/Python/symtable.c	Tue Mar 24 15:42:05 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);