Merge with 3.3

9 files changed, 148 insertions, 130 deletions

diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
index 7d0d258b7a..820a606095 100644
--- a/Modules/_ctypes/_ctypes.c
+++ b/Modules/_ctypes/_ctypes.c
@@ -278,8 +278,10 @@ _ctypes_alloc_format_string(const char *prefix, const char *suffix)
     if (prefix)
         len += strlen(prefix);
     result = PyMem_Malloc(len + 1);
-    if (result == NULL)
+    if (result == NULL) {
+        PyErr_NoMemory();
         return NULL;
+    }
     if (prefix)
         strcpy(result, prefix);
     else
@@ -428,13 +430,7 @@ CDataType_from_buffer(PyObject *type, PyObject *args)
     StgDictObject *dict = PyType_stgdict(type);
     assert (dict);
 
-    if (!PyArg_ParseTuple(args,
-#if (PY_VERSION_HEX < 0x02050000)
-                          "O|i:from_buffer",
-#else
-                          "O|n:from_buffer",
-#endif
-                          &obj, &offset))
+    if (!PyArg_ParseTuple(args, "O|n:from_buffer", &obj, &offset))
         return NULL;
 
     if (-1 == PyObject_AsWriteBuffer(obj, &buffer, &buffer_len))
@@ -447,11 +443,7 @@ CDataType_from_buffer(PyObject *type, PyObject *args)
     }
     if (dict->size > buffer_len - offset) {
         PyErr_Format(PyExc_ValueError,
-#if (PY_VERSION_HEX < 0x02050000)
-                     "Buffer size too small (%d instead of at least %d bytes)",
-#else
                      "Buffer size too small (%zd instead of at least %zd bytes)",
-#endif
                      buffer_len, dict->size + offset);
         return NULL;
     }
@@ -462,7 +454,6 @@ CDataType_from_buffer(PyObject *type, PyObject *args)
 
     Py_INCREF(obj);
     if (-1 == KeepRef((CDataObject *)result, -1, obj)) {
-        Py_DECREF(result);
         return NULL;
     }
     return result;
@@ -484,13 +475,7 @@ CDataType_from_buffer_copy(PyObject *type, PyObject *args)
     StgDictObject *dict = PyType_stgdict(type);
     assert (dict);
 
-    if (!PyArg_ParseTuple(args,
-#if (PY_VERSION_HEX < 0x02050000)
-                          "O|i:from_buffer",
-#else
-                          "O|n:from_buffer",
-#endif
-                          &obj, &offset))
+    if (!PyArg_ParseTuple(args, "O|n:from_buffer", &obj, &offset))
         return NULL;
 
     if (-1 == PyObject_AsReadBuffer(obj, (const void**)&buffer, &buffer_len))
@@ -504,11 +489,7 @@ CDataType_from_buffer_copy(PyObject *type, PyObject *args)
 
     if (dict->size > buffer_len - offset) {
         PyErr_Format(PyExc_ValueError,
-#if (PY_VERSION_HEX < 0x02050000)
-                     "Buffer size too small (%d instead of at least %d bytes)",
-#else
                      "Buffer size too small (%zd instead of at least %zd bytes)",
-#endif
                      buffer_len, dict->size + offset);
         return NULL;
     }
@@ -1326,9 +1307,11 @@ PyCArrayType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     if (stgdict->format == NULL)
         goto error;
     stgdict->ndim = itemdict->ndim + 1;
-    stgdict->shape = PyMem_Malloc(sizeof(Py_ssize_t *) * stgdict->ndim);
-    if (stgdict->shape == NULL)
+    stgdict->shape = PyMem_Malloc(sizeof(Py_ssize_t) * stgdict->ndim);
+    if (stgdict->shape == NULL) {
+        PyErr_NoMemory();
         goto error;
+    }
     stgdict->shape[0] = length;
     memmove(&stgdict->shape[1], itemdict->shape,
         sizeof(Py_ssize_t) * (stgdict->ndim - 1));
@@ -1359,7 +1342,8 @@ PyCArrayType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     if (-1 == PyDict_Update((PyObject *)stgdict, result->tp_dict))
         goto error;
     Py_DECREF(result->tp_dict);
-    result->tp_dict = (PyObject *)stgdict;
+    result->tp_dict = (PyObject *)stgdict;  /* steal the reference */
+    stgdict = NULL;
 
     /* Special case for character arrays.
        A permanent annoyance: char arrays are also strings!
@@ -2261,6 +2245,10 @@ PyCFuncPtrType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
        argtypes would be a ctypes type).
     */
     stgdict->format = _ctypes_alloc_format_string(NULL, "X{}");
+    if (stgdict->format == NULL) {
+        Py_DECREF((PyObject *)stgdict);
+        return NULL;
+    }
     stgdict->flags |= TYPEFLAG_ISPOINTER;
 
     /* create the new instance (which is a class,
@@ -2343,6 +2331,8 @@ PyCData_GetContainer(CDataObject *self)
     if (self->b_objects == NULL) {
         if (self->b_length) {
             self->b_objects = PyDict_New();
+            if (self->b_objects == NULL)
+                return NULL;
         } else {
             Py_INCREF(Py_None);
             self->b_objects = Py_None;
@@ -2354,7 +2344,11 @@ PyCData_GetContainer(CDataObject *self)
 static PyObject *
 GetKeepedObjects(CDataObject *target)
 {
-    return PyCData_GetContainer(target)->b_objects;
+    CDataObject *container;
+    container = PyCData_GetContainer(target);
+    if (container == NULL)
+        return NULL;
+    return container->b_objects;
 }
 
 static PyObject *
@@ -2411,6 +2405,10 @@ KeepRef(CDataObject *target, Py_ssize_t index, PyObject *keep)
         return 0;
     }
     ob = PyCData_GetContainer(target);
+    if (ob == NULL) {
+        Py_DECREF(keep);
+        return -1;
+    }
     if (ob->b_objects == NULL || !PyDict_CheckExact(ob->b_objects)) {
         Py_XDECREF(ob->b_objects);
         ob->b_objects = keep; /* refcount consumed */
@@ -2797,6 +2795,9 @@ _PyCData_set(CDataObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value,
             /* XXX */;
 
         value = GetKeepedObjects(src);
+        if (value == NULL)
+            return NULL;
+
         Py_INCREF(value);
         return value;
     }
@@ -2820,6 +2821,9 @@ _PyCData_set(CDataObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value,
         *(void **)ptr = src->b_ptr;
 
         keep = GetKeepedObjects(src);
+        if (keep == NULL)
+            return NULL;
+
         /*
           We are assigning an array object to a field which represents
           a pointer. This has the same effect as converting an array
@@ -4050,8 +4054,8 @@ Struct_init(PyObject *self, PyObject *args, PyObject *kwds)
         return -1;
     }
     if (PyTuple_GET_SIZE(args)) {
-        int res = _init_pos_args(self, Py_TYPE(self),
-                                 args, kwds, 0);
+        Py_ssize_t res = _init_pos_args(self, Py_TYPE(self),
+                                        args, kwds, 0);
         if (res == -1)
             return -1;
         if (res < PyTuple_GET_SIZE(args)) {
@@ -4222,7 +4226,7 @@ Array_subscript(PyObject *myself, PyObject *item)
             i += self->b_length;
         return Array_item(myself, i);
     }
-    else if PySlice_Check(item) {
+    else if (PySlice_Check(item)) {
         StgDictObject *stgdict, *itemdict;
         PyObject *proto;
         PyObject *np;
@@ -4298,6 +4302,10 @@ Array_subscript(PyObject *myself, PyObject *item)
         for (cur = start, i = 0; i < slicelen;
              cur += step, i++) {
             PyObject *v = Array_item(myself, cur);
+            if (v == NULL) {
+                Py_DECREF(np);
+                return NULL;
+            }
             PyList_SET_ITEM(np, i, v);
         }
         return np;
@@ -4812,6 +4820,9 @@ Pointer_set_contents(CDataObject *self, PyObject *value, void *closure)
         return -1;
 
     keep = GetKeepedObjects(dst);
+    if (keep == NULL)
+        return -1;
+
     Py_INCREF(keep);
     return KeepRef(self, 0, keep);
 }
@@ -5218,9 +5229,14 @@ cast(void *ptr, PyObject *src, PyObject *ctype)
      */
     if (CDataObject_Check(src)) {
         CDataObject *obj = (CDataObject *)src;
+        CDataObject *container;
+
         /* PyCData_GetContainer will initialize src.b_objects, we need
            this so it can be shared */
-        PyCData_GetContainer(obj);
+        container = PyCData_GetContainer(obj);
+        if (container == NULL)
+            goto failed;
+
         /* But we need a dictionary! */
         if (obj->b_objects == Py_None) {
             Py_DECREF(Py_None);
diff --git a/Modules/_ctypes/callbacks.c b/Modules/_ctypes/callbacks.c
index a3d232118b..ec8fd12a89 100644
--- a/Modules/_ctypes/callbacks.c
+++ b/Modules/_ctypes/callbacks.c
@@ -98,20 +98,37 @@ void _ctypes_add_traceback(char *funcname, char *filename, int lineno)
     PyObject *py_globals = 0;
     PyCodeObject *py_code = 0;
     PyFrameObject *py_frame = 0;
+    PyObject *exception, *value, *tb;
+
+    /* (Save and) Clear the current exception. Python functions must not be
+       called with an exception set. Calling Python functions happens when
+       the codec of the filesystem encoding is implemented in pure Python. */
+    PyErr_Fetch(&exception, &value, &tb);
 
     py_globals = PyDict_New();
-    if (!py_globals) goto bad;
+    if (!py_globals)
+        goto bad;
     py_code = PyCode_NewEmpty(filename, funcname, lineno);
-    if (!py_code) goto bad;
+    if (!py_code)
+        goto bad;
     py_frame = PyFrame_New(
         PyThreadState_Get(), /*PyThreadState *tstate,*/
         py_code,             /*PyCodeObject *code,*/
         py_globals,          /*PyObject *globals,*/
         0                    /*PyObject *locals*/
         );
-    if (!py_frame) goto bad;
+    if (!py_frame)
+        goto bad;
     py_frame->f_lineno = lineno;
+
+    PyErr_Restore(exception, value, tb);
     PyTraceBack_Here(py_frame);
+
+    Py_DECREF(py_globals);
+    Py_DECREF(py_code);
+    Py_DECREF(py_frame);
+    return;
+
   bad:
     Py_XDECREF(py_globals);
     Py_XDECREF(py_code);
diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c
index 09eb653b30..74119a3b4d 100644
--- a/Modules/_ctypes/callproc.c
+++ b/Modules/_ctypes/callproc.c
@@ -261,18 +261,18 @@ static void SetException(DWORD code, EXCEPTION_RECORD *pr)
            to a virtual address for which it does not
            have the appropriate access. */
         if (pr->ExceptionInformation[0] == 0)
-            PyErr_Format(PyExc_WindowsError,
+            PyErr_Format(PyExc_OSError,
                          "exception: access violation reading %p",
                          pr->ExceptionInformation[1]);
         else
-            PyErr_Format(PyExc_WindowsError,
+            PyErr_Format(PyExc_OSError,
                          "exception: access violation writing %p",
                          pr->ExceptionInformation[1]);
         break;
 
     case EXCEPTION_BREAKPOINT:
         /* A breakpoint was encountered. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: breakpoint encountered");
         break;
 
@@ -282,14 +282,14 @@ static void SetException(DWORD code, EXCEPTION_RECORD *pr)
            alignment. For example, 16-bit values must be
            aligned on 2-byte boundaries, 32-bit values on
            4-byte boundaries, and so on. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: datatype misalignment");
         break;
 
     case EXCEPTION_SINGLE_STEP:
         /* A trace trap or other single-instruction mechanism
            signaled that one instruction has been executed. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: single step");
         break;
 
@@ -297,7 +297,7 @@ static void SetException(DWORD code, EXCEPTION_RECORD *pr)
         /* The thread attempted to access an array element
            that is out of bounds, and the underlying hardware
            supports bounds checking. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: array bounds exceeded");
         break;
 
@@ -306,28 +306,28 @@ static void SetException(DWORD code, EXCEPTION_RECORD *pr)
            is denormal. A denormal value is one that is too
            small to represent as a standard floating-point
            value. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: floating-point operand denormal");
         break;
 
     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
         /* The thread attempted to divide a floating-point
            value by a floating-point divisor of zero. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: float divide by zero");
         break;
 
     case EXCEPTION_FLT_INEXACT_RESULT:
         /* The result of a floating-point operation cannot be
            represented exactly as a decimal fraction. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: float inexact");
         break;
 
     case EXCEPTION_FLT_INVALID_OPERATION:
         /* This exception represents any floating-point
            exception not included in this list. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: float invalid operation");
         break;
 
@@ -335,21 +335,21 @@ static void SetException(DWORD code, EXCEPTION_RECORD *pr)
         /* The exponent of a floating-point operation is
            greater than the magnitude allowed by the
            corresponding type. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: float overflow");
         break;
 
     case EXCEPTION_FLT_STACK_CHECK:
         /* The stack overflowed or underflowed as the result
            of a floating-point operation. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: stack over/underflow");
         break;
 
     case EXCEPTION_STACK_OVERFLOW:
         /* The stack overflowed or underflowed as the result
            of a floating-point operation. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: stack overflow");
         break;
 
@@ -357,21 +357,21 @@ static void SetException(DWORD code, EXCEPTION_RECORD *pr)
         /* The exponent of a floating-point operation is less
            than the magnitude allowed by the corresponding
            type. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: float underflow");
         break;
 
     case EXCEPTION_INT_DIVIDE_BY_ZERO:
         /* The thread attempted to divide an integer value by
            an integer divisor of zero. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: integer divide by zero");
         break;
 
     case EXCEPTION_INT_OVERFLOW:
         /* The result of an integer operation caused a carry
            out of the most significant bit of the result. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: integer overflow");
         break;
 
@@ -379,14 +379,14 @@ static void SetException(DWORD code, EXCEPTION_RECORD *pr)
         /* The thread attempted to execute an instruction
            whose operation is not allowed in the current
            machine mode. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: priviledged instruction");
         break;
 
     case EXCEPTION_NONCONTINUABLE_EXCEPTION:
         /* The thread attempted to continue execution after a
            noncontinuable exception occurred. */
-        PyErr_SetString(PyExc_WindowsError,
+        PyErr_SetString(PyExc_OSError,
                         "exception: nocontinuable");
         break;
 
@@ -620,6 +620,8 @@ static int ConvParam(PyObject *obj, Py_ssize_t index, struct argument *pa)
         assert(dict->paramfunc);
         /* If it has an stgdict, it is a CDataObject */
         carg = dict->paramfunc((CDataObject *)obj);
+        if (carg == NULL)
+            return -1;
         pa->ffi_type = carg->pffi_type;
         memcpy(&pa->value, &carg->value, sizeof(pa->value));
         pa->keep = (PyObject *)carg;
@@ -1105,9 +1107,7 @@ PyObject *_ctypes_callproc(PPROC pProc,
         if (argtypes && argtype_count > i) {
             PyObject *v;
             converter = PyTuple_GET_ITEM(argtypes, i);
-            v = PyObject_CallFunctionObjArgs(converter,
-                                               arg,
-                                               NULL);
+            v = PyObject_CallFunctionObjArgs(converter, arg, NULL);
             if (v == NULL) {
                 _ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
                 goto cleanup;
@@ -1272,62 +1272,6 @@ static PyObject *free_library(PyObject *self, PyObject *args)
     return Py_None;
 }
 
-/* obsolete, should be removed */
-/* Only used by sample code (in samples\Windows\COM.py) */
-static PyObject *
-call_commethod(PyObject *self, PyObject *args)
-{
-    IUnknown *pIunk;
-    int index;
-    PyObject *arguments;
-    PPROC *lpVtbl;
-    PyObject *result;
-    CDataObject *pcom;
-    PyObject *argtypes = NULL;
-
-    if (!PyArg_ParseTuple(args,
-                          "OiO!|O!",
-                          &pcom, &index,
-                          &PyTuple_Type, &arguments,
-                          &PyTuple_Type, &argtypes))
-        return NULL;
-
-    if (argtypes && (PyTuple_GET_SIZE(arguments) != PyTuple_GET_SIZE(argtypes))) {
-        PyErr_Format(PyExc_TypeError,
-                     "Method takes %d arguments (%d given)",
-                     PyTuple_GET_SIZE(argtypes), PyTuple_GET_SIZE(arguments));
-        return NULL;
-    }
-
-    if (!CDataObject_Check(pcom) || (pcom->b_size != sizeof(void *))) {
-        PyErr_Format(PyExc_TypeError,
-                     "COM Pointer expected instead of %s instance",
-                     Py_TYPE(pcom)->tp_name);
-        return NULL;
-    }
-
-    if ((*(void **)(pcom->b_ptr)) == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                        "The COM 'this' pointer is NULL");
-        return NULL;
-    }
-
-    pIunk = (IUnknown *)(*(void **)(pcom->b_ptr));
-    lpVtbl = (PPROC *)(pIunk->lpVtbl);
-
-    result =  _ctypes_callproc(lpVtbl[index],
-                        arguments,
-#ifdef MS_WIN32
-                        pIunk,
-                        NULL,
-#endif
-                        FUNCFLAG_HRESULT, /* flags */
-                argtypes, /* self->argtypes */
-                NULL, /* self->restype */
-                NULL); /* checker */
-    return result;
-}
-
 static char copy_com_pointer_doc[] =
 "CopyComPointer(src, dst) -> HRESULT value\n";
 
@@ -1489,9 +1433,9 @@ call_cdeclfunction(PyObject *self, PyObject *args)
                         NULL,
 #endif
                         FUNCFLAG_CDECL, /* flags */
-                NULL, /* self->argtypes */
-                NULL, /* self->restype */
-                NULL); /* checker */
+                        NULL, /* self->argtypes */
+                        NULL, /* self->restype */
+                        NULL); /* checker */
     return result;
 }
 
@@ -1822,7 +1766,6 @@ PyMethodDef _ctypes_module_methods[] = {
     {"FormatError", format_error, METH_VARARGS, format_error_doc},
     {"LoadLibrary", load_library, METH_VARARGS, load_library_doc},
     {"FreeLibrary", free_library, METH_VARARGS, free_library_doc},
-    {"call_commethod", call_commethod, METH_VARARGS },
     {"_check_HRESULT", check_hresult, METH_VARARGS},
 #else
     {"dlopen", py_dl_open, METH_VARARGS,
diff --git a/Modules/_ctypes/libffi.diff b/Modules/_ctypes/libffi.diff
index ade28e5f9e..1f931fb3b4 100644
--- a/Modules/_ctypes/libffi.diff
+++ b/Modules/_ctypes/libffi.diff
@@ -167,3 +167,39 @@ diff -urN libffi-3.0.11/src/dlmalloc.c libffi/src/dlmalloc.c
  #endif  /* WIN32 */
  
  #ifdef __OS2__
+@@ -3393,7 +3393,7 @@
+   *ss = m->seg; /* Push current record */
+   m->seg.base = tbase;
+   m->seg.size = tsize;
+-  set_segment_flags(&m->seg, mmapped);
++  (void)set_segment_flags(&m->seg, mmapped);
+   m->seg.next = ss;
+ 
+   /* Insert trailing fenceposts */
+@@ -3553,7 +3553,7 @@
+     if (!is_initialized(m)) { /* first-time initialization */
+       m->seg.base = m->least_addr = tbase;
+       m->seg.size = tsize;
+-      set_segment_flags(&m->seg, mmap_flag);
++      (void)set_segment_flags(&m->seg, mmap_flag);
+       m->magic = mparams.magic;
+       init_bins(m);
+       if (is_global(m)) 
+@@ -4502,7 +4502,7 @@
+     char* tbase = (char*)(CALL_MMAP(tsize));
+     if (tbase != CMFAIL) {
+       m = init_user_mstate(tbase, tsize);
+-      set_segment_flags(&m->seg, IS_MMAPPED_BIT);
++      (void)set_segment_flags(&m->seg, IS_MMAPPED_BIT);
+       set_lock(m, locked);
+     }
+   }
+@@ -4517,7 +4517,7 @@
+   if (capacity > msize + TOP_FOOT_SIZE &&
+       capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {
+     m = init_user_mstate((char*)base, capacity);
+-    set_segment_flags(&m->seg, EXTERN_BIT);
++    (void)set_segment_flags(&m->seg, EXTERN_BIT);
+     set_lock(m, locked);
+   }
+   return (mspace)m;
diff --git a/Modules/_ctypes/libffi/src/dlmalloc.c b/Modules/_ctypes/libffi/src/dlmalloc.c
index 2773953590..fe1e40d651 100644
--- a/Modules/_ctypes/libffi/src/dlmalloc.c
+++ b/Modules/_ctypes/libffi/src/dlmalloc.c
@@ -3393,7 +3393,7 @@ static void add_segment(mstate m, char* tbase, size_t tsize, flag_t mmapped) {
   *ss = m->seg; /* Push current record */
   m->seg.base = tbase;
   m->seg.size = tsize;
-  set_segment_flags(&m->seg, mmapped);
+  (void)set_segment_flags(&m->seg, mmapped);
   m->seg.next = ss;
 
   /* Insert trailing fenceposts */
@@ -3553,7 +3553,7 @@ static void* sys_alloc(mstate m, size_t nb) {
     if (!is_initialized(m)) { /* first-time initialization */
       m->seg.base = m->least_addr = tbase;
       m->seg.size = tsize;
-      set_segment_flags(&m->seg, mmap_flag);
+      (void)set_segment_flags(&m->seg, mmap_flag);
       m->magic = mparams.magic;
       init_bins(m);
       if (is_global(m)) 
@@ -4502,7 +4502,7 @@ mspace create_mspace(size_t capacity, int locked) {
     char* tbase = (char*)(CALL_MMAP(tsize));
     if (tbase != CMFAIL) {
       m = init_user_mstate(tbase, tsize);
-      set_segment_flags(&m->seg, IS_MMAPPED_BIT);
+      (void)set_segment_flags(&m->seg, IS_MMAPPED_BIT);
       set_lock(m, locked);
     }
   }
@@ -4517,7 +4517,7 @@ mspace create_mspace_with_base(void* base, size_t capacity, int locked) {
   if (capacity > msize + TOP_FOOT_SIZE &&
       capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {
     m = init_user_mstate((char*)base, capacity);
-    set_segment_flags(&m->seg, EXTERN_BIT);
+    (void)set_segment_flags(&m->seg, EXTERN_BIT);
     set_lock(m, locked);
   }
   return (mspace)m;
diff --git a/Modules/_ctypes/libffi/testsuite/libffi.call/a.out b/Modules/_ctypes/libffi/testsuite/libffi.call/a.out
deleted file mode 100644
index e69de29bb2..0000000000
--- a/Modules/_ctypes/libffi/testsuite/libffi.call/a.out
+++ /dev/null
diff --git a/Modules/_ctypes/libffi_osx/ffi.c b/Modules/_ctypes/libffi_osx/ffi.c
index bf420936db..96826b5c8e 100644
--- a/Modules/_ctypes/libffi_osx/ffi.c
+++ b/Modules/_ctypes/libffi_osx/ffi.c
@@ -38,12 +38,13 @@ initialize_aggregate(
 /*@out@*/	ffi_type*	arg)
 {
 /*@-usedef@*/
+	ffi_type**	ptr;
 
 	if (arg == NULL || arg->elements == NULL ||
 		arg->size != 0 || arg->alignment != 0)
 		return FFI_BAD_TYPEDEF;
 
-	ffi_type**	ptr = &(arg->elements[0]);
+    ptr = &(arg->elements[0]);
 
 	while ((*ptr) != NULL)
 	{
@@ -135,16 +136,16 @@ ffi_prep_cif(
 /*@dependent@*/ /*@out@*/ /*@partial@*/ ffi_type*	rtype, 
 /*@dependent@*/			ffi_type**		atypes)
 {
+	unsigned int	bytes	= 0;
+	unsigned int	i;
+	ffi_type**		ptr;
+
 	if (cif == NULL)
 		return FFI_BAD_TYPEDEF;
 
 	if (abi <= FFI_FIRST_ABI || abi > FFI_DEFAULT_ABI)
 		return FFI_BAD_ABI;
 
-	unsigned int	bytes	= 0;
-	unsigned int	i;
-	ffi_type**		ptr;
-
 	cif->abi = abi;
 	cif->arg_types = atypes;
 	cif->nargs = nargs;
diff --git a/Modules/_ctypes/libffi_osx/x86/x86-ffi64.c b/Modules/_ctypes/libffi_osx/x86/x86-ffi64.c
index 2affb14c1a..f2610c16c7 100644
--- a/Modules/_ctypes/libffi_osx/x86/x86-ffi64.c
+++ b/Modules/_ctypes/libffi_osx/x86/x86-ffi64.c
@@ -225,14 +225,16 @@ classify_argument(
 			/* Merge the fields of structure.  */
 			for (ptr = type->elements; *ptr != NULL; ptr++)
 			{
+				int num, pos;
+
 				byte_offset = ALIGN(byte_offset, (*ptr)->alignment);
 
-				int	num = classify_argument(*ptr, subclasses, byte_offset % 8);
+				num = classify_argument(*ptr, subclasses, byte_offset % 8);
 
 				if (num == 0)
 					return 0;
 
-				int pos = byte_offset / 8;
+				pos = byte_offset / 8;
 
 				for (i = 0; i < num; i++)
 				{
@@ -589,11 +591,12 @@ ffi_prep_closure(
 	void			(*fun)(ffi_cif*, void*, void**, void*),
 	void*			user_data)
 {
+		volatile unsigned short*	tramp;
+
 	if (cif->abi != FFI_UNIX64)
 		return FFI_BAD_ABI;
 
-	volatile unsigned short*	tramp =
-		(volatile unsigned short*)&closure->tramp[0];
+	tramp = (volatile unsigned short*)&closure->tramp[0];
 
 	tramp[0] = 0xbb49;		/* mov <code>, %r11	*/
 	*(void* volatile*)&tramp[1] = ffi_closure_unix64;
diff --git a/Modules/_ctypes/stgdict.c b/Modules/_ctypes/stgdict.c
index 25d999626a..b95b0a4231 100644
--- a/Modules/_ctypes/stgdict.c
+++ b/Modules/_ctypes/stgdict.c
@@ -417,6 +417,8 @@ PyCStructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct
            that). Use 'B' for bytes. */
         stgdict->format = _ctypes_alloc_format_string(NULL, "B");
     }
+    if (stgdict->format == NULL)
+        return -1;
 
 #define realdict ((PyObject *)&stgdict->dict)
     for (i = 0; i < len; ++i) {
@@ -483,7 +485,7 @@ PyCStructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct
             char *fieldfmt = dict->format ? dict->format : "B";
             char *fieldname = _PyUnicode_AsString(name);
             char *ptr;
-            Py_ssize_t len; 
+            Py_ssize_t len;
             char *buf;
 
             if (fieldname == NULL)