[Numpy-svn] r6444 - trunk/numpy/core/src

numpy-svn@scip... numpy-svn@scip...
Sat Feb 21 17:54:51 CST 2009


Author: charris
Date: 2009-02-21 17:54:31 -0600 (Sat, 21 Feb 2009)
New Revision: 6444

Modified:
   trunk/numpy/core/src/multiarraymodule.c
Log:
Coding style cleanups. Finishes multiarraymodule.c.

Modified: trunk/numpy/core/src/multiarraymodule.c
===================================================================
--- trunk/numpy/core/src/multiarraymodule.c	2009-02-21 17:48:15 UTC (rev 6443)
+++ trunk/numpy/core/src/multiarraymodule.c	2009-02-21 23:54:31 UTC (rev 6444)
@@ -4016,34 +4016,37 @@
                         "argmax is unsupported for this type");
         return NULL;
     }
-    else if (PyArray_ISUNSIGNED(ap))
+    else if (PyArray_ISUNSIGNED(ap)) {
         obj = PyInt_FromLong((long) -1);
-
-    else if (PyArray_TYPE(ap)==PyArray_BOOL)
+    }
+    else if (PyArray_TYPE(ap) == PyArray_BOOL) {
         obj = PyInt_FromLong((long) 1);
-
-    else
+    }
+    else {
         obj = PyInt_FromLong((long) 0);
-
+    }
     new = PyArray_EnsureAnyArray(PyNumber_Subtract(obj, (PyObject *)ap));
     Py_DECREF(obj);
-    if (new == NULL) return NULL;
+    if (new == NULL) {
+        return NULL;
+    }
     ret = PyArray_ArgMax((PyArrayObject *)new, axis, out);
     Py_DECREF(new);
     return ret;
 }
 
 /*NUMPY_API
-  Max
-*/
+ * Max
+ */
 static PyObject *
 PyArray_Max(PyArrayObject *ap, int axis, PyArrayObject *out)
 {
     PyArrayObject *arr;
     PyObject *ret;
 
-    if ((arr=(PyArrayObject *)_check_axis(ap, &axis, 0))==NULL)
+    if ((arr=(PyArrayObject *)_check_axis(ap, &axis, 0)) == NULL) {
         return NULL;
+    }
     ret = PyArray_GenericReduceFunction(arr, n_ops.maximum, axis,
                                         arr->descr->type_num, out);
     Py_DECREF(arr);
@@ -4051,16 +4054,17 @@
 }
 
 /*NUMPY_API
-  Min
-*/
+ * Min
+ */
 static PyObject *
 PyArray_Min(PyArrayObject *ap, int axis, PyArrayObject *out)
 {
     PyArrayObject *arr;
     PyObject *ret;
 
-    if ((arr=(PyArrayObject *)_check_axis(ap, &axis, 0))==NULL)
+    if ((arr=(PyArrayObject *)_check_axis(ap, &axis, 0)) == NULL) {
         return NULL;
+    }
     ret = PyArray_GenericReduceFunction(arr, n_ops.minimum, axis,
                                         arr->descr->type_num, out);
     Py_DECREF(arr);
@@ -4068,21 +4072,26 @@
 }
 
 /*NUMPY_API
-  Ptp
-*/
+ * Ptp
+ */
 static PyObject *
 PyArray_Ptp(PyArrayObject *ap, int axis, PyArrayObject *out)
 {
     PyArrayObject *arr;
     PyObject *ret;
-    PyObject *obj1=NULL, *obj2=NULL;
+    PyObject *obj1 = NULL, *obj2 = NULL;
 
-    if ((arr=(PyArrayObject *)_check_axis(ap, &axis, 0))==NULL)
+    if ((arr=(PyArrayObject *)_check_axis(ap, &axis, 0)) == NULL) {
         return NULL;
+    }
     obj1 = PyArray_Max(arr, axis, out);
-    if (obj1 == NULL) goto fail;
+    if (obj1 == NULL) {
+        goto fail;
+    }
     obj2 = PyArray_Min(arr, axis, NULL);
-    if (obj2 == NULL) goto fail;
+    if (obj2 == NULL) {
+        goto fail;
+    }
     Py_DECREF(arr);
     if (out) {
         ret = PyObject_CallFunction(n_ops.subtract, "OOO", out, obj2, out);
@@ -4103,58 +4112,60 @@
 
 
 /*NUMPY_API
-  ArgMax
-*/
+ * ArgMax
+ */
 static PyObject *
 PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out)
 {
-    PyArrayObject *ap=NULL, *rp=NULL;
+    PyArrayObject *ap = NULL, *rp = NULL;
     PyArray_ArgFunc* arg_func;
     char *ip;
     intp *rptr;
     intp i, n, m;
     int elsize;
-    int copyret=0;
-
+    int copyret = 0;
     NPY_BEGIN_THREADS_DEF;
 
-        if ((ap=(PyAO *)_check_axis(op, &axis, 0))==NULL) return NULL;
-
-    /* We need to permute the array so that axis is placed at the end.
-       And all other dimensions are shifted left.
-    */
+    if ((ap=(PyAO *)_check_axis(op, &axis, 0)) == NULL) {
+        return NULL;
+    }
+    /*
+     * We need to permute the array so that axis is placed at the end.
+     * And all other dimensions are shifted left.
+     */
     if (axis != ap->nd-1) {
         PyArray_Dims newaxes;
         intp dims[MAX_DIMS];
         int i;
+
         newaxes.ptr = dims;
         newaxes.len = ap->nd;
-        for (i=0; i<axis; i++) dims[i] = i;
-        for (i=axis; i<ap->nd-1; i++) dims[i] = i+1;
-        dims[ap->nd-1] = axis;
+        for (i = 0; i < axis; i++) dims[i] = i;
+        for (i = axis; i < ap->nd - 1; i++) dims[i] = i + 1;
+        dims[ap->nd - 1] = axis;
         op = (PyAO *)PyArray_Transpose(ap, &newaxes);
         Py_DECREF(ap);
-        if (op == NULL) return NULL;
+        if (op == NULL) {
+            return NULL;
+        }
     }
     else {
         op = ap;
     }
 
-    /* Will get native-byte order contiguous copy.
-     */
-    ap = (PyArrayObject *)\
+    /* Will get native-byte order contiguous copy. */
+    ap = (PyArrayObject *)
         PyArray_ContiguousFromAny((PyObject *)op,
                                   op->descr->type_num, 1, 0);
-
     Py_DECREF(op);
-    if (ap == NULL) return NULL;
-
+    if (ap == NULL) {
+        return NULL;
+    }
     arg_func = ap->descr->f->argmax;
     if (arg_func == NULL) {
         PyErr_SetString(PyExc_TypeError, "data type not ordered");
         goto fail;
     }
-
     elsize = ap->descr->elsize;
     m = ap->dimensions[ap->nd-1];
     if (m == 0) {
@@ -4169,11 +4180,13 @@
                                           ap->dimensions, PyArray_INTP,
                                           NULL, NULL, 0, 0,
                                           (PyObject *)ap);
-        if (rp == NULL) goto fail;
+        if (rp == NULL) {
+            goto fail;
+        }
     }
     else {
-        if (PyArray_SIZE(out) != \
-            PyArray_MultiplyList(ap->dimensions, ap->nd-1)) {
+        if (PyArray_SIZE(out) !=
+                PyArray_MultiplyList(ap->dimensions, ap->nd - 1)) {
             PyErr_SetString(PyExc_TypeError,
                             "invalid shape for output array.");
         }
@@ -4181,14 +4194,18 @@
             PyArray_FromArray(out,
                               PyArray_DescrFromType(PyArray_INTP),
                               NPY_CARRAY | NPY_UPDATEIFCOPY);
-        if (rp == NULL) goto fail;
-        if (rp != out) copyret = 1;
+        if (rp == NULL) {
+            goto fail;
+        }
+        if (rp != out) {
+            copyret = 1;
+        }
     }
 
     NPY_BEGIN_THREADS_DESCR(ap->descr);
     n = PyArray_SIZE(ap)/m;
     rptr = (intp *)rp->data;
-    for (ip = ap->data, i=0; i<n; i++, ip+=elsize*m) {
+    for (ip = ap->data, i = 0; i < n; i++, ip += elsize*m) {
         arg_func(ip, m, rptr, ap);
         rptr += 1;
     }
@@ -4212,8 +4229,8 @@
 
 
 /*NUMPY_API
-  Take
-*/
+ * Take
+ */
 static PyObject *
 PyArray_TakeFrom(PyArrayObject *self0, PyObject *indices0, int axis,
                  PyArrayObject *ret, NPY_CLIPMODE clipmode)
@@ -4223,29 +4240,33 @@
     intp nd, i, j, n, m, max_item, tmp, chunk, nelem;
     intp shape[MAX_DIMS];
     char *src, *dest;
-    int copyret=0;
+    int copyret = 0;
     int err;
 
     indices = NULL;
     self = (PyAO *)_check_axis(self0, &axis, CARRAY);
-    if (self == NULL) return NULL;
-
+    if (self == NULL) {
+        return NULL;
+    }
     indices = (PyArrayObject *)PyArray_ContiguousFromAny(indices0,
                                                          PyArray_INTP,
                                                          1, 0);
-    if (indices == NULL) goto fail;
-
+    if (indices == NULL) {
+        goto fail;
+    }
     n = m = chunk = 1;
     nd = self->nd + indices->nd - 1;
-    for (i=0; i< nd; i++) {
+    for (i = 0; i < nd; i++) {
         if (i < axis) {
             shape[i] = self->dimensions[i];
             n *= shape[i];
-        } else {
+        }
+        else {
             if (i < axis+indices->nd) {
                 shape[i] = indices->dimensions[i-axis];
                 m *= shape[i];
-            } else {
+            }
+            else {
                 shape[i] = self->dimensions[i-indices->nd+1];
                 chunk *= shape[i];
             }
@@ -4259,7 +4280,9 @@
                                                     NULL, NULL, 0,
                                                     (PyObject *)self);
 
-        if (ret == NULL) goto fail;
+        if (ret == NULL) {
+            goto fail;
+        }
     }
     else {
         PyArrayObject *obj;
@@ -4275,17 +4298,22 @@
         }
 
         if (clipmode == NPY_RAISE) {
-            /* we need to make sure and get a copy
-               so the input array is not changed
-               before the error is called
-            */
+            /*
+             * we need to make sure and get a copy
+             * so the input array is not changed
+             * before the error is called
+             */
             flags |= NPY_ENSURECOPY;
         }
         obj = (PyArrayObject *)PyArray_FromArray(ret, self->descr,
                                                  flags);
-        if (obj != ret) copyret = 1;
+        if (obj != ret) {
+            copyret = 1;
+        }
         ret = obj;
-	if (ret == NULL) goto fail;
+	if (ret == NULL) {
+            goto fail;
+        }
     }
 
     max_item = self->dimensions[axis];
@@ -4296,63 +4324,73 @@
 
     func = self->descr->f->fasttake;
     if (func == NULL) {
-
-    switch(clipmode) {
-    case NPY_RAISE:
-        for(i=0; i<n; i++) {
-            for(j=0; j<m; j++) {
-                tmp = ((intp *)(indices->data))[j];
-                if (tmp < 0) tmp = tmp+max_item;
-                if ((tmp < 0) || (tmp >= max_item)) {
-                    PyErr_SetString(PyExc_IndexError,
-                                    "index out of range "\
-                                    "for array");
-                    goto fail;
+        switch(clipmode) {
+        case NPY_RAISE:
+            for (i = 0; i < n; i++) {
+                for (j = 0; j < m; j++) {
+                    tmp = ((intp *)(indices->data))[j];
+                    if (tmp < 0) {
+                        tmp = tmp + max_item;
+                    }
+                    if ((tmp < 0) || (tmp >= max_item)) {
+                        PyErr_SetString(PyExc_IndexError,
+                                "index out of range "\
+                                "for array");
+                        goto fail;
+                    }
+                    memmove(dest, src + tmp*chunk, chunk);
+                    dest += chunk;
                 }
-                memmove(dest, src+tmp*chunk, chunk);
-                dest += chunk;
+                src += chunk*max_item;
             }
-            src += chunk*max_item;
-        }
-        break;
-    case NPY_WRAP:
-        for(i=0; i<n; i++) {
-            for(j=0; j<m; j++) {
-                tmp = ((intp *)(indices->data))[j];
-                if (tmp < 0) while (tmp < 0) tmp += max_item;
-                else if (tmp >= max_item)
-                    while (tmp >= max_item)
-                        tmp -= max_item;
-                memmove(dest, src+tmp*chunk, chunk);
-                dest += chunk;
+            break;
+        case NPY_WRAP:
+            for (i = 0; i < n; i++) {
+                for (j = 0; j < m; j++) {
+                    tmp = ((intp *)(indices->data))[j];
+                    if (tmp < 0) {
+                        while (tmp < 0) {
+                            tmp += max_item;
+                        }
+                    }
+                    else if (tmp >= max_item) {
+                        while (tmp >= max_item) {
+                            tmp -= max_item;
+                        }
+                    }
+                    memmove(dest, src + tmp*chunk, chunk);
+                    dest += chunk;
+                }
+                src += chunk*max_item;
             }
-            src += chunk*max_item;
-        }
-        break;
-    case NPY_CLIP:
-        for(i=0; i<n; i++) {
-            for(j=0; j<m; j++) {
-                tmp = ((intp *)(indices->data))[j];
-                if (tmp < 0)
-                    tmp = 0;
-                else if (tmp >= max_item)
-                    tmp = max_item-1;
-                memmove(dest, src+tmp*chunk, chunk);
-                dest += chunk;
+            break;
+        case NPY_CLIP:
+            for (i = 0; i < n; i++) {
+                for (j = 0; j < m; j++) {
+                    tmp = ((intp *)(indices->data))[j];
+                    if (tmp < 0) {
+                        tmp = 0;
+                    }
+                    else if (tmp >= max_item) {
+                        tmp = max_item - 1;
+                    }
+                    memmove(dest, src+tmp*chunk, chunk);
+                    dest += chunk;
+                }
+                src += chunk*max_item;
             }
-            src += chunk*max_item;
+            break;
         }
-        break;
     }
-    }
     else {
         err = func(dest, src, (intp *)(indices->data),
                     max_item, n, m, nelem, clipmode);
-        if (err) goto fail;
+        if (err) {
+            goto fail;
+        }
     }
 
     PyArray_INCREF(ret);
-
     Py_XDECREF(indices);
     Py_XDECREF(self);
     if (copyret) {
@@ -4362,10 +4400,8 @@
         Py_DECREF(ret);
         ret = (PyArrayObject *)obj;
     }
-
     return (PyObject *)ret;
 
-
  fail:
     PyArray_XDECREF_ERR(ret);
     Py_XDECREF(indices);
@@ -4374,8 +4410,8 @@
 }
 
 /*NUMPY_API
-  Put values into an array
-*/
+ * Put values into an array
+ */
 static PyObject *
 PyArray_PutTo(PyArrayObject *self, PyObject* values0, PyObject *indices0,
               NPY_CLIPMODE clipmode)
@@ -4387,7 +4423,6 @@
 
     indices = NULL;
     values = NULL;
-
     if (!PyArray_Check(self)) {
         PyErr_SetString(PyExc_TypeError,
                         "put: first argument must be an array");
@@ -4396,68 +4431,86 @@
     if (!PyArray_ISCONTIGUOUS(self)) {
         PyArrayObject *obj;
         int flags = NPY_CARRAY | NPY_UPDATEIFCOPY;
+
         if (clipmode == NPY_RAISE) {
             flags |= NPY_ENSURECOPY;
         }
         Py_INCREF(self->descr);
         obj = (PyArrayObject *)PyArray_FromArray(self,
                                                  self->descr, flags);
-        if (obj != self) copied = 1;
+        if (obj != self) {
+            copied = 1;
+        }
         self = obj;
     }
     max_item = PyArray_SIZE(self);
     dest = self->data;
     chunk = self->descr->elsize;
-
     indices = (PyArrayObject *)PyArray_ContiguousFromAny(indices0,
                                                          PyArray_INTP, 0, 0);
-    if (indices == NULL) goto fail;
+    if (indices == NULL) {
+        goto fail;
+    }
     ni = PyArray_SIZE(indices);
-
     Py_INCREF(self->descr);
     values = (PyArrayObject *)PyArray_FromAny(values0, self->descr, 0, 0,
                                               DEFAULT | FORCECAST, NULL);
-    if (values == NULL) goto fail;
+    if (values == NULL) {
+        goto fail;
+    }
     nv = PyArray_SIZE(values);
-    if (nv <= 0) goto finish;
+    if (nv <= 0) {
+        goto finish;
+    }
     if (PyDataType_REFCHK(self->descr)) {
         switch(clipmode) {
         case NPY_RAISE:
-            for(i=0; i<ni; i++) {
-                src = values->data + chunk * (i % nv);
+            for (i = 0; i < ni; i++) {
+                src = values->data + chunk*(i % nv);
                 tmp = ((intp *)(indices->data))[i];
-                if (tmp < 0) tmp = tmp+max_item;
+                if (tmp < 0) {
+                    tmp = tmp + max_item;
+                }
                 if ((tmp < 0) || (tmp >= max_item)) {
                     PyErr_SetString(PyExc_IndexError,
-                                    "index out of " \
-                                    "range for array");
+                            "index out of " \
+                            "range for array");
                     goto fail;
                 }
                 PyArray_Item_INCREF(src, self->descr);
                 PyArray_Item_XDECREF(dest+tmp*chunk, self->descr);
-                memmove(dest + tmp * chunk, src, chunk);
+                memmove(dest + tmp*chunk, src, chunk);
             }
             break;
         case NPY_WRAP:
-            for(i=0; i<ni; i++) {
+            for (i = 0; i < ni; i++) {
                 src = values->data + chunk * (i % nv);
                 tmp = ((intp *)(indices->data))[i];
-                if (tmp < 0) while(tmp < 0) tmp+=max_item;
-                else if (tmp >= max_item)
-                    while(tmp >= max_item)
+                if (tmp < 0) {
+                    while (tmp < 0) {
+                        tmp += max_item;
+                    }
+                }
+                else if (tmp >= max_item) {
+                    while (tmp >= max_item) {
                         tmp -= max_item;
+                    }
+                }
                 PyArray_Item_INCREF(src, self->descr);
                 PyArray_Item_XDECREF(dest+tmp*chunk, self->descr);
                 memmove(dest + tmp * chunk, src, chunk);
             }
             break;
         case NPY_CLIP:
-            for(i=0; i<ni; i++) {
+            for (i = 0; i < ni; i++) {
                 src = values->data + chunk * (i % nv);
                 tmp = ((intp *)(indices->data))[i];
-                if (tmp < 0) tmp = 0;
-                else if (tmp >= max_item)
+                if (tmp < 0) {
+                    tmp = 0;
+                }
+                else if (tmp >= max_item) {
                     tmp = max_item - 1;
+                }
                 PyArray_Item_INCREF(src, self->descr);
                 PyArray_Item_XDECREF(dest+tmp*chunk, self->descr);
                 memmove(dest + tmp * chunk, src, chunk);
@@ -4468,37 +4521,48 @@
     else {
         switch(clipmode) {
         case NPY_RAISE:
-            for(i=0; i<ni; i++) {
+            for (i = 0; i < ni; i++) {
                 src = values->data + chunk * (i % nv);
                 tmp = ((intp *)(indices->data))[i];
-                if (tmp < 0) tmp = tmp+max_item;
+                if (tmp < 0) {
+                    tmp = tmp + max_item;
+                }
                 if ((tmp < 0) || (tmp >= max_item)) {
                     PyErr_SetString(PyExc_IndexError,
-                                    "index out of " \
-                                    "range for array");
+                            "index out of " \
+                            "range for array");
                     goto fail;
                 }
                 memmove(dest + tmp * chunk, src, chunk);
             }
             break;
         case NPY_WRAP:
-            for(i=0; i<ni; i++) {
+            for (i = 0; i < ni; i++) {
                 src = values->data + chunk * (i % nv);
                 tmp = ((intp *)(indices->data))[i];
-                if (tmp < 0) while(tmp < 0) tmp+=max_item;
-                else if (tmp >= max_item)
-                    while(tmp >= max_item)
+                if (tmp < 0) {
+                    while (tmp < 0) {
+                        tmp += max_item;
+                    }
+                }
+                else if (tmp >= max_item) {
+                    while (tmp >= max_item) {
                         tmp -= max_item;
+                    }
+                }
                 memmove(dest + tmp * chunk, src, chunk);
             }
             break;
         case NPY_CLIP:
-            for(i=0; i<ni; i++) {
+            for (i = 0; i < ni; i++) {
                 src = values->data + chunk * (i % nv);
                 tmp = ((intp *)(indices->data))[i];
-                if (tmp < 0) tmp = 0;
-                else if (tmp >= max_item)
+                if (tmp < 0) {
+                    tmp = 0;
+                }
+                else if (tmp >= max_item) {
                     tmp = max_item - 1;
+                }
                 memmove(dest + tmp * chunk, src, chunk);
             }
             break;
@@ -4533,15 +4597,15 @@
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!OO:putmask", kwlist,
                                      &PyArray_Type,
-                                     &array, &mask, &values))
+                                     &array, &mask, &values)) {
         return NULL;
-
+    }
     return PyArray_PutMask((PyArrayObject *)array, values, mask);
 }
 
 /*NUMPY_API
-  Put values into an array according to a mask.
-*/
+ * Put values into an array according to a mask.
+ */
 static PyObject *
 PyArray_PutMask(PyArrayObject *self, PyObject* values0, PyObject* mask0)
 {
@@ -4549,11 +4613,10 @@
     PyArrayObject  *mask, *values;
     int i, chunk, ni, max_item, nv, tmp;
     char *src, *dest;
-    int copied=0;
+    int copied = 0;
 
     mask = NULL;
     values = NULL;
-
     if (!PyArray_Check(self)) {
         PyErr_SetString(PyExc_TypeError,
                         "putmask: first argument must "\
@@ -4563,20 +4626,24 @@
     if (!PyArray_ISCONTIGUOUS(self)) {
         PyArrayObject *obj;
         int flags = NPY_CARRAY | NPY_UPDATEIFCOPY;
+
         Py_INCREF(self->descr);
         obj = (PyArrayObject *)PyArray_FromArray(self,
                                                  self->descr, flags);
-        if (obj != self) copied = 1;
+        if (obj != self) {
+            copied = 1;
+        }
         self = obj;
     }
 
     max_item = PyArray_SIZE(self);
     dest = self->data;
     chunk = self->descr->elsize;
-
     mask = (PyArrayObject *)\
         PyArray_FROM_OTF(mask0, PyArray_BOOL, CARRAY | FORCECAST);
-    if (mask == NULL) goto fail;
+    if (mask == NULL) {
+        goto fail;
+    }
     ni = PyArray_SIZE(mask);
     if (ni != max_item) {
         PyErr_SetString(PyExc_ValueError,
@@ -4587,8 +4654,10 @@
     Py_INCREF(self->descr);
     values = (PyArrayObject *)\
         PyArray_FromAny(values0, self->descr, 0, 0, NPY_CARRAY, NULL);
-    if (values == NULL) goto fail;
-    nv = PyArray_SIZE(values);        /* zero if null array */
+    if (values == NULL) {
+        goto fail;
+    }
+    nv = PyArray_SIZE(values); /* zero if null array */
     if (nv <= 0) {
         Py_XDECREF(values);
         Py_XDECREF(mask);
@@ -4596,7 +4665,7 @@
         return Py_None;
     }
     if (PyDataType_REFCHK(self->descr)) {
-        for(i=0; i<ni; i++) {
+        for (i = 0; i < ni; i++) {
             tmp = ((Bool *)(mask->data))[i];
             if (tmp) {
                 src = values->data + chunk * (i % nv);
@@ -4609,11 +4678,11 @@
     else {
         func = self->descr->f->fastputmask;
         if (func == NULL) {
-            for(i=0; i<ni; i++) {
+            for (i = 0; i < ni; i++) {
                 tmp = ((Bool *)(mask->data))[i];
                 if (tmp) {
-                    src = values->data + chunk * (i % nv);
-                    memmove(dest + i * chunk, src, chunk);
+                    src = values->data + chunk*(i % nv);
+                    memmove(dest + i*chunk, src, chunk);
                 }
             }
         }
@@ -4640,18 +4709,17 @@
 }
 
 
-/* This conversion function can be used with the "O&" argument for
-   PyArg_ParseTuple.  It will immediately return an object of array type
-   or will convert to a CARRAY any other object.
-
-   If you use PyArray_Converter, you must DECREF the array when finished
-   as you get a new reference to it.
-*/
-
 /*NUMPY_API
-  Useful to pass as converter function for O& processing in
-  PyArgs_ParseTuple.
-*/
+ *
+ * Useful to pass as converter function for O& processing in PyArgs_ParseTuple.
+ *
+ * This conversion function can be used with the "O&" argument for
+ * PyArg_ParseTuple.  It will immediately return an object of array type
+ * or will convert to a CARRAY any other object.
+ *
+ * If you use PyArray_Converter, you must DECREF the array when finished
+ * as you get a new reference to it.
+ */
 static int
 PyArray_Converter(PyObject *object, PyObject **address)
 {
@@ -4662,15 +4730,17 @@
     }
     else {
         *address = PyArray_FromAny(object, NULL, 0, 0, CARRAY, NULL);
-        if (*address == NULL) return PY_FAIL;
+        if (*address == NULL) {
+            return PY_FAIL;
+        }
         return PY_SUCCEED;
     }
 }
 
 /*NUMPY_API
-  Useful to pass as converter function for O& processing in
-  PyArgs_ParseTuple for output arrays
-*/
+ * Useful to pass as converter function for O& processing in
+ * PyArgs_ParseTuple for output arrays
+ */
 static int
 PyArray_OutputConverter(PyObject *object, PyArrayObject **address)
 {
@@ -4692,22 +4762,26 @@
 
 
 /*NUMPY_API
-  Convert an object to true / false
-*/
+ * Convert an object to true / false
+ */
 static int
 PyArray_BoolConverter(PyObject *object, Bool *val)
 {
-    if (PyObject_IsTrue(object))
-        *val=TRUE;
-    else *val=FALSE;
-    if (PyErr_Occurred())
+    if (PyObject_IsTrue(object)) {
+        *val = TRUE;
+    }
+    else {
+        *val = FALSE;
+    }
+    if (PyErr_Occurred()) {
         return PY_FAIL;
+    }
     return PY_SUCCEED;
 }
 
 /*NUMPY_API
-  Convert an object to FORTRAN / C / ANY
-*/
+ * Convert an object to FORTRAN / C / ANY
+ */
 static int
 PyArray_OrderConverter(PyObject *object, NPY_ORDER *val)
 {
@@ -4716,12 +4790,15 @@
         *val = PyArray_ANYORDER;
     }
     else if (!PyString_Check(object) || PyString_GET_SIZE(object) < 1) {
-        if (PyObject_IsTrue(object))
+        if (PyObject_IsTrue(object)) {
             *val = PyArray_FORTRANORDER;
-        else
+        }
+        else {
             *val = PyArray_CORDER;
-        if (PyErr_Occurred())
+        }
+        if (PyErr_Occurred()) {
             return PY_FAIL;
+        }
         return PY_SUCCEED;
     }
     else {
@@ -4745,8 +4822,8 @@
 }
 
 /*NUMPY_API
-  Convert an object to NPY_RAISE / NPY_CLIP / NPY_WRAP
-*/
+ * Convert an object to NPY_RAISE / NPY_CLIP / NPY_WRAP
+ */
 static int
 PyArray_ClipmodeConverter(PyObject *object, NPY_CLIPMODE *val)
 {
@@ -4772,13 +4849,17 @@
         }
     }
     else {
-        int number;
-        number = PyInt_AsLong(object);
-        if (number == -1 && PyErr_Occurred()) goto fail;
-        if (number <= (int) NPY_RAISE &&
-            number >= (int) NPY_CLIP)
+        int number = PyInt_AsLong(object);
+        if (number == -1 && PyErr_Occurred()) {
+            goto fail;
+        }
+        if (number <= (int) NPY_RAISE
+            && number >= (int) NPY_CLIP) {
             *val = (NPY_CLIPMODE) number;
-        else goto fail;
+        }
+        else {
+            goto fail;
+        }
     }
     return PY_SUCCEED;
 
@@ -4791,18 +4872,20 @@
 
 
 /*NUMPY_API
-  Typestr converter
-*/
+ * Typestr converter
+ */
 static int
 PyArray_TypestrConvert(int itemsize, int gentype)
 {
     register int newtype = gentype;
 
     if (gentype == PyArray_GENBOOLLTR) {
-        if (itemsize == 1)
+        if (itemsize == 1) {
             newtype = PyArray_BOOL;
-        else
+        }
+        else {
             newtype = PyArray_NOTYPE;
+        }
     }
     else if (gentype == PyArray_SIGNEDLTR) {
         switch(itemsize) {
@@ -4827,7 +4910,6 @@
             newtype = PyArray_NOTYPE;
         }
     }
-
     else if (gentype == PyArray_UNSIGNEDLTR) {
         switch(itemsize) {
         case 1:
@@ -4879,7 +4961,6 @@
             newtype = PyArray_NOTYPE;
         }
     }
-
     else if (gentype == PyArray_COMPLEXLTR) {
         switch(itemsize) {
         case 8:
@@ -4907,25 +4988,22 @@
             newtype = PyArray_NOTYPE;
         }
     }
-
     return newtype;
 }
 
 
-/* this function takes a Python object which exposes the (single-segment)
-   buffer interface and returns a pointer to the data segment
-
-   You should increment the reference count by one of buf->base
-   if you will hang on to a reference
-
-   You only get a borrowed reference to the object. Do not free the
-   memory...
-*/
-
-
 /*NUMPY_API
-  Get buffer chunk from object
-*/
+ * Get buffer chunk from object
+ *
+ * this function takes a Python object which exposes the (single-segment)
+ * buffer interface and returns a pointer to the data segment
+ *
+ * You should increment the reference count by one of buf->base
+ * if you will hang on to a reference
+ *
+ * You only get a borrowed reference to the object. Do not free the
+ * memory...
+ */
 static int
 PyArray_BufferConverter(PyObject *obj, PyArray_Chunk *buf)
 {
@@ -4934,38 +5012,40 @@
     buf->ptr = NULL;
     buf->flags = BEHAVED;
     buf->base = NULL;
-
-    if (obj == Py_None)
+    if (obj == Py_None) {
         return PY_SUCCEED;
-
+    }
     if (PyObject_AsWriteBuffer(obj, &(buf->ptr), &buflen) < 0) {
         PyErr_Clear();
         buf->flags &= ~WRITEABLE;
         if (PyObject_AsReadBuffer(obj, (const void **)&(buf->ptr),
-                                  &buflen) < 0)
+                                  &buflen) < 0) {
             return PY_FAIL;
+        }
     }
     buf->len = (intp) buflen;
 
     /* Point to the base of the buffer object if present */
-    if (PyBuffer_Check(obj)) buf->base = ((PyArray_Chunk *)obj)->base;
-    if (buf->base == NULL) buf->base = obj;
-
+    if (PyBuffer_Check(obj)) {
+        buf->base = ((PyArray_Chunk *)obj)->base;
+    }
+    if (buf->base == NULL) {
+        buf->base = obj;
+    }
     return PY_SUCCEED;
 }
 
 
 
-/* This function takes a Python sequence object and allocates and
-   fills in an intp array with the converted values.
-
-   **Remember to free the pointer seq.ptr when done using
-   PyDimMem_FREE(seq.ptr)**
-*/
-
 /*NUMPY_API
-  Get intp chunk from sequence
-*/
+ * Get intp chunk from sequence
+ *
+ * This function takes a Python sequence object and allocates and
+ * fills in an intp array with the converted values.
+ *
+ * Remember to free the pointer seq.ptr when done using
+ * PyDimMem_FREE(seq.ptr)**
+ */
 static int
 PyArray_IntpConverter(PyObject *obj, PyArray_Dims *seq)
 {
@@ -4974,10 +5054,15 @@
 
     seq->ptr = NULL;
     seq->len = 0;
-    if (obj == Py_None) return PY_SUCCEED;
+    if (obj == Py_None) {
+        return PY_SUCCEED;
+    }
     len = PySequence_Size(obj);
-    if (len == -1) { /* Check to see if it is a number */
-        if (PyNumber_Check(obj)) len = 1;
+    if (len == -1) {
+        /* Check to see if it is a number */
+        if (PyNumber_Check(obj)) {
+            len = 1;
+        }
     }
     if (len < 0) {
         PyErr_SetString(PyExc_TypeError,
@@ -5000,27 +5085,28 @@
     nd = PyArray_IntpFromSequence(obj, (intp *)seq->ptr, len);
     if (nd == -1 || nd != len) {
         PyDimMem_FREE(seq->ptr);
-        seq->ptr=NULL;
+        seq->ptr = NULL;
         return PY_FAIL;
     }
     return PY_SUCCEED;
 }
 
 
-/* A tuple type would be either (generic typeobject, typesize)
-   or (fixed-length data-type, shape)
-
-   or (inheriting data-type, new-data-type)
-   The new data-type must have the same itemsize as the inheriting data-type
-   unless the latter is 0
-
-   Thus (int32, {'real':(int16,0),'imag',(int16,2)})
-
-   is one way to specify a descriptor that will give
-   a['real'] and a['imag'] to an int32 array.
-*/
-
-/* leave type reference alone */
+/*
+ * A tuple type would be either (generic typeobject, typesize)
+ * or (fixed-length data-type, shape)
+ *
+ * or (inheriting data-type, new-data-type)
+ * The new data-type must have the same itemsize as the inheriting data-type
+ * unless the latter is 0
+ *
+ * Thus (int32, {'real':(int16,0),'imag',(int16,2)})
+ *
+ * is one way to specify a descriptor that will give
+ * a['real'] and a['imag'] to an int32 array.
+ *
+ * leave type reference alone
+ */
 static PyArray_Descr *
 _use_inherit(PyArray_Descr *type, PyObject *newobj, int *errflag)
 {
@@ -5033,8 +5119,9 @@
     }
     *errflag = 1;
     new = PyArray_DescrNew(type);
-    if (new == NULL) goto fail;
-
+    if (new == NULL) {
+        goto fail;
+    }
     if (new->elsize && new->elsize != conv->elsize) {
         PyErr_SetString(PyExc_ValueError,
                         "mismatch in size of old "\
@@ -5056,7 +5143,6 @@
  fail:
     Py_DECREF(conv);
     return NULL;
-
 }
 
 static PyArray_Descr *
@@ -5066,26 +5152,33 @@
     PyObject *val;
     int errflag;
 
-    if (PyTuple_GET_SIZE(obj) != 2) return NULL;
-
-    if (!PyArray_DescrConverter(PyTuple_GET_ITEM(obj,0), &type))
+    if (PyTuple_GET_SIZE(obj) != 2) {
         return NULL;
+    }
+    if (!PyArray_DescrConverter(PyTuple_GET_ITEM(obj,0), &type)) {
+        return NULL;
+    }
     val = PyTuple_GET_ITEM(obj,1);
     /* try to interpret next item as a type */
     res = _use_inherit(type, val, &errflag);
     if (res || errflag) {
         Py_DECREF(type);
-        if (res) return res;
-        else return NULL;
+        if (res) {
+            return res;
+        }
+        else {
+            return NULL;
+        }
     }
     PyErr_Clear();
-    /* We get here if res was NULL but errflag wasn't set
-       --- i.e. the conversion to a data-descr failed in _use_inherit
-    */
+    /*
+     * We get here if res was NULL but errflag wasn't set
+     * --- i.e. the conversion to a data-descr failed in _use_inherit
+     */
+    if (type->elsize == 0) {
+        /* interpret next item as a typesize */
+        int itemsize = PyArray_PyIntAsInt(PyTuple_GET_ITEM(obj,1));
 
-    if (type->elsize == 0) { /* interpret next item as a typesize */
-        int itemsize;
-        itemsize = PyArray_PyIntAsInt(PyTuple_GET_ITEM(obj,1));
         if (error_converting(itemsize)) {
             PyErr_SetString(PyExc_ValueError,
                             "invalid itemsize in generic type "\
@@ -5093,20 +5186,24 @@
             goto fail;
         }
         PyArray_DESCR_REPLACE(type);
-        if (type->type_num == PyArray_UNICODE)
+        if (type->type_num == PyArray_UNICODE) {
             type->elsize = itemsize << 2;
-        else
+        }
+        else {
             type->elsize = itemsize;
+        }
     }
     else {
-        /* interpret next item as shape (if it's a tuple)
-           and reset the type to PyArray_VOID with
-           a new fields attribute.
-        */
-        PyArray_Dims shape={NULL,-1};
+        /*
+         * interpret next item as shape (if it's a tuple)
+         * and reset the type to PyArray_VOID with
+         * a new fields attribute.
+         */
+        PyArray_Dims shape = {NULL, -1};
         PyArray_Descr *newdescr;
-        if (!(PyArray_IntpConverter(val, &shape)) ||
-            (shape.len > MAX_DIMS)) {
+
+        if (!(PyArray_IntpConverter(val, &shape))
+            || (shape.len > MAX_DIMS)) {
             PyDimMem_FREE(shape.ptr);
             PyErr_SetString(PyExc_ValueError,
                             "invalid shape in fixed-type tuple.");
@@ -5114,16 +5211,18 @@
         }
         /* If (type, 1) was given, it is equivalent to type...
            or (type, ()) was given it is equivalent to type... */
-        if ((shape.len == 1 && shape.ptr[0] == 1 && PyNumber_Check(val)) || \
-            (shape.len == 0 && PyTuple_Check(val))) {
+        if ((shape.len == 1 && shape.ptr[0] == 1 && PyNumber_Check(val))
+            || (shape.len == 0 && PyTuple_Check(val))) {
             PyDimMem_FREE(shape.ptr);
             return type;
         }
         newdescr = PyArray_DescrNewFromType(PyArray_VOID);
-        if (newdescr == NULL) {PyDimMem_FREE(shape.ptr); goto fail;}
+        if (newdescr == NULL) {
+            PyDimMem_FREE(shape.ptr);
+            goto fail;
+        }
         newdescr->elsize = type->elsize;
-        newdescr->elsize *= PyArray_MultiplyList(shape.ptr,
-                                                 shape.len);
+        newdescr->elsize *= PyArray_MultiplyList(shape.ptr, shape.len);
         PyDimMem_FREE(shape.ptr);
         newdescr->subarray = _pya_malloc(sizeof(PyArray_ArrayDescr));
         newdescr->subarray->base = type;
@@ -5143,11 +5242,12 @@
     return NULL;
 }
 
-/* obj is a list.  Each item is a tuple with
-
-   (field-name, data-type (either a list or a string), and an optional
-   shape parameter).
-*/
+/*
+ * obj is a list.  Each item is a tuple with
+ *
+ * (field-name, data-type (either a list or a string), and an optional
+ * shape parameter).
+ */
 static PyArray_Descr *
 _convert_from_array_descr(PyObject *obj, int align)
 {
@@ -5158,34 +5258,43 @@
     PyObject *nameslist;
     PyArray_Descr *new;
     PyArray_Descr *conv;
-    int dtypeflags=0;
+    int dtypeflags = 0;
     int maxalign = 0;
 
 
     n = PyList_GET_SIZE(obj);
     nameslist = PyTuple_New(n);
-    if (!nameslist) return NULL;
+    if (!nameslist) {
+        return NULL;
+    }
     totalsize = 0;
     fields = PyDict_New();
-    for (i=0; i<n; i++) {
+    for (i = 0; i < n; i++) {
         item = PyList_GET_ITEM(obj, i);
-        if (!PyTuple_Check(item) || (PyTuple_GET_SIZE(item) < 2))
+        if (!PyTuple_Check(item) || (PyTuple_GET_SIZE(item) < 2)) {
             goto fail;
+        }
         name = PyTuple_GET_ITEM(item, 0);
         if (PyString_Check(name)) {
-            title=NULL;
+            title = NULL;
         }
         else if (PyTuple_Check(name)) {
-            if (PyTuple_GET_SIZE(name) != 2) goto fail;
+            if (PyTuple_GET_SIZE(name) != 2) {
+                goto fail;
+            }
             title = PyTuple_GET_ITEM(name, 0);
             name = PyTuple_GET_ITEM(name, 1);
-            if (!PyString_Check(name))
+            if (!PyString_Check(name)) {
                 goto fail;
+            }
         }
-        else goto fail;
+        else {
+            goto fail;
+        }
         if (PyString_GET_SIZE(name)==0) {
-            if (title==NULL)
+            if (title == NULL) {
                 name = PyString_FromFormat("f%d", i);
+            }
             else {
                 name = title;
                 Py_INCREF(name);
@@ -5196,19 +5305,22 @@
         }
         PyTuple_SET_ITEM(nameslist, i, name);
         if (PyTuple_GET_SIZE(item) == 2) {
-            ret = PyArray_DescrConverter(PyTuple_GET_ITEM(item, 1),
-                                         &conv);
-            if (ret == PY_FAIL)
-                PyObject_Print(PyTuple_GET_ITEM(item,1),
-                               stderr, 0);
+            ret = PyArray_DescrConverter(PyTuple_GET_ITEM(item, 1), &conv);
+            if (ret == PY_FAIL) {
+                PyObject_Print(PyTuple_GET_ITEM(item,1), stderr, 0);
+            }
         }
         else if (PyTuple_GET_SIZE(item) == 3) {
             newobj = PyTuple_GetSlice(item, 1, 3);
             ret = PyArray_DescrConverter(newobj, &conv);
             Py_DECREF(newobj);
         }
-        else goto fail;
-        if (ret == PY_FAIL) goto fail;
+        else {
+            goto fail;
+        }
+        if (ret == PY_FAIL) {
+            goto fail;
+        }
         if ((PyDict_GetItem(fields, name) != NULL) ||
             (title &&
              (PyString_Check(title) || PyUnicode_Check(title)) &&
@@ -5222,21 +5334,25 @@
         PyTuple_SET_ITEM(tup, 0, (PyObject *)conv);
         if (align) {
             int _align;
+
             _align = conv->alignment;
-            if (_align > 1) totalsize =                     \
-                                ((totalsize + _align - 1)/_align)*_align;
+            if (_align > 1) {
+                totalsize = ((totalsize + _align - 1)/_align)*_align;
+            }
             maxalign = MAX(maxalign, _align);
         }
         PyTuple_SET_ITEM(tup, 1, PyInt_FromLong((long) totalsize));
 
-        /* Title can be "meta-data".  Only insert it
-           into the fields dictionary if it is a string
-        */
+        /*
+         * Title can be "meta-data".  Only insert it
+         * into the fields dictionary if it is a string
+         */
         if (title != NULL) {
             Py_INCREF(title);
             PyTuple_SET_ITEM(tup, 2, title);
-            if (PyString_Check(title) || PyUnicode_Check(title))
+            if (PyString_Check(title) || PyUnicode_Check(title)) {
                 PyDict_SetItem(fields, title, tup);
+            }
         }
         PyDict_SetItem(fields, name, tup);
         totalsize += conv->elsize;
@@ -5250,7 +5366,9 @@
     if (maxalign > 1) {
         totalsize = ((totalsize+maxalign-1)/maxalign)*maxalign;
     }
-    if (align) new->alignment = maxalign;
+    if (align) {
+        new->alignment = maxalign;
+    }
     return new;
 
  fail:
@@ -5260,37 +5378,45 @@
 
 }
 
-/* a list specifying a data-type can just be
-   a list of formats.  The names for the fields
-   will default to f0, f1, f2, and so forth.
-*/
-
+/*
+ * a list specifying a data-type can just be
+ * a list of formats.  The names for the fields
+ * will default to f0, f1, f2, and so forth.
+ */
 static PyArray_Descr *
 _convert_from_list(PyObject *obj, int align)
 {
     int n, i;
     int totalsize;
     PyObject *fields;
-    PyArray_Descr *conv=NULL;
+    PyArray_Descr *conv = NULL;
     PyArray_Descr *new;
     PyObject *key, *tup;
-    PyObject *nameslist=NULL;
+    PyObject *nameslist = NULL;
     int ret;
-    int maxalign=0;
-    int dtypeflags=0;
+    int maxalign = 0;
+    int dtypeflags = 0;
 
     n = PyList_GET_SIZE(obj);
-    /* Ignore any empty string at end which _internal._commastring
-       can produce  */
+    /*
+     * Ignore any empty string at end which _internal._commastring
+     * can produce
+     */
     key = PyList_GET_ITEM(obj, n-1);
-    if (PyString_Check(key) && PyString_GET_SIZE(key) == 0) n = n-1;
+    if (PyString_Check(key) && PyString_GET_SIZE(key) == 0) {
+        n = n - 1;
+    }
     /* End ignore code.*/
     totalsize = 0;
-    if (n==0) return NULL;
+    if (n == 0) {
+        return NULL;
+    }
     nameslist = PyTuple_New(n);
-    if (!nameslist) return NULL;
+    if (!nameslist) {
+        return NULL;
+    }
     fields = PyDict_New();
-    for (i=0; i<n; i++) {
+    for (i = 0; i < n; i++) {
         tup = PyTuple_New(2);
         key = PyString_FromFormat("f%d", i);
         ret = PyArray_DescrConverter(PyList_GET_ITEM(obj, i), &conv);
@@ -5303,9 +5429,11 @@
         PyTuple_SET_ITEM(tup, 0, (PyObject *)conv);
         if (align) {
             int _align;
+
             _align = conv->alignment;
-            if (_align > 1) totalsize =                     \
-                                ((totalsize + _align - 1)/_align)*_align;
+            if (_align > 1) {
+                totalsize = ((totalsize + _align - 1)/_align)*_align;
+            }
             maxalign = MAX(maxalign, _align);
         }
         PyTuple_SET_ITEM(tup, 1, PyInt_FromLong((long) totalsize));
@@ -5321,7 +5449,9 @@
     if (maxalign > 1) {
         totalsize = ((totalsize+maxalign-1)/maxalign)*maxalign;
     }
-    if (align) new->alignment = maxalign;
+    if (align) {
+        new->alignment = maxalign;
+    }
     new->elsize = totalsize;
     return new;
 
@@ -5332,15 +5462,15 @@
 }
 
 
-/* comma-separated string */
-/* this is the format developed by the numarray records module */
-/* and implemented by the format parser in that module */
-/* this is an alternative implementation found in the _internal.py
-   file patterned after that one -- the approach is to try to convert
-   to a list (with tuples if any repeat information is present)
-   and then call the _convert_from_list)
-*/
-
+/*
+ * comma-separated string
+ * this is the format developed by the numarray records module
+ * and implemented by the format parser in that module
+ * this is an alternative implementation found in the _internal.py
+ * file patterned after that one -- the approach is to try to convert
+ * to a list (with tuples if any repeat information is present)
+ * and then call the _convert_from_list)
+ */
 static PyArray_Descr *
 _convert_from_commastring(PyObject *obj, int align)
 {
@@ -5348,13 +5478,18 @@
     PyArray_Descr *res;
     PyObject *_numpy_internal;
 
-    if (!PyString_Check(obj)) return NULL;
+    if (!PyString_Check(obj)) {
+        return NULL;
+    }
     _numpy_internal = PyImport_ImportModule("numpy.core._internal");
-    if (_numpy_internal == NULL) return NULL;
-    listobj = PyObject_CallMethod(_numpy_internal, "_commastring",
-                                  "O", obj);
+    if (_numpy_internal == NULL) {
+        return NULL;
+    }
+    listobj = PyObject_CallMethod(_numpy_internal, "_commastring", "O", obj);
     Py_DECREF(_numpy_internal);
-    if (!listobj) return NULL;
+    if (!listobj) {
+        return NULL;
+    }
     if (!PyList_Check(listobj) || PyList_GET_SIZE(listobj)<1) {
         PyErr_SetString(PyExc_RuntimeError, "_commastring is "  \
                         "not returning a list with len >= 1");
@@ -5379,48 +5514,51 @@
 
 
 
-/* a dictionary specifying a data-type
-   must have at least two and up to four
-   keys These must all be sequences of the same length.
-
-   "names" --- field names
-   "formats" --- the data-type descriptors for the field.
-
-   Optional:
-
-   "offsets" --- integers indicating the offset into the
-   record of the start of the field.
-   if not given, then "consecutive offsets"
-   will be assumed and placed in the dictionary.
-
-   "titles" --- Allows the use of an additional key
-   for the fields dictionary.(if these are strings
-   or unicode objects) or
-   this can also be meta-data to
-   be passed around with the field description.
-
-   Attribute-lookup-based field names merely has to query the fields
-   dictionary of the data-descriptor.  Any result present can be used
-   to return the correct field.
-
-   So, the notion of what is a name and what is a title is really quite
-   arbitrary.
-
-   What does distinguish a title, however, is that if it is not None,
-   it will be placed at the end of the tuple inserted into the
-   fields dictionary.and can therefore be used to carry meta-data around.
-
-   If the dictionary does not have "names" and "formats" entries,
-   then it will be checked for conformity and used directly.
-*/
-
+/*
+ * a dictionary specifying a data-type
+ * must have at least two and up to four
+ * keys These must all be sequences of the same length.
+ *
+ * "names" --- field names
+ * "formats" --- the data-type descriptors for the field.
+ *
+ * Optional:
+ *
+ * "offsets" --- integers indicating the offset into the
+ * record of the start of the field.
+ * if not given, then "consecutive offsets"
+ * will be assumed and placed in the dictionary.
+ *
+ * "titles" --- Allows the use of an additional key
+ * for the fields dictionary.(if these are strings
+ * or unicode objects) or
+ * this can also be meta-data to
+ * be passed around with the field description.
+ *
+ * Attribute-lookup-based field names merely has to query the fields
+ * dictionary of the data-descriptor.  Any result present can be used
+ * to return the correct field.
+ *
+ * So, the notion of what is a name and what is a title is really quite
+ * arbitrary.
+ *
+ * What does distinguish a title, however, is that if it is not None,
+ * it will be placed at the end of the tuple inserted into the
+ * fields dictionary.and can therefore be used to carry meta-data around.
+ *
+ * If the dictionary does not have "names" and "formats" entries,
+ * then it will be checked for conformity and used directly.
+ */
 static PyArray_Descr *
 _use_fields_dict(PyObject *obj, int align)
 {
     PyObject *_numpy_internal;
     PyArray_Descr *res;
+
     _numpy_internal = PyImport_ImportModule("numpy.core._internal");
-    if (_numpy_internal == NULL) return NULL;
+    if (_numpy_internal == NULL) {
+        return NULL;
+    }
     res = (PyArray_Descr *)PyObject_CallMethod(_numpy_internal,
                                                "_usefields",
                                                "Oi", obj, align);
@@ -5432,19 +5570,19 @@
 _convert_from_dict(PyObject *obj, int align)
 {
     PyArray_Descr *new;
-    PyObject *fields=NULL;
+    PyObject *fields = NULL;
     PyObject *names, *offsets, *descrs, *titles;
     int n, i;
     int totalsize;
-    int maxalign=0;
-    int dtypeflags=0;
+    int maxalign = 0;
+    int dtypeflags = 0;
 
     fields = PyDict_New();
-    if (fields == NULL) return (PyArray_Descr *)PyErr_NoMemory();
-
+    if (fields == NULL) {
+        return (PyArray_Descr *)PyErr_NoMemory();
+    }
     names = PyDict_GetItemString(obj, "names");
     descrs = PyDict_GetItemString(obj, "formats");
-
     if (!names || !descrs) {
         Py_DECREF(fields);
         return _use_fields_dict(obj, align);
@@ -5452,9 +5590,9 @@
     n = PyObject_Length(names);
     offsets = PyDict_GetItemString(obj, "offsets");
     titles = PyDict_GetItemString(obj, "titles");
-    if ((n > PyObject_Length(descrs)) ||                    \
-        (offsets && (n > PyObject_Length(offsets))) ||      \
-        (titles && (n > PyObject_Length(titles)))) {
+    if ((n > PyObject_Length(descrs))
+        || (offsets && (n > PyObject_Length(offsets)))
+        || (titles && (n > PyObject_Length(titles)))) {
         PyErr_SetString(PyExc_ValueError,
                         "all items in the dictionary must have" \
                         " the same length.");
@@ -5462,9 +5600,9 @@
     }
 
     totalsize = 0;
-    for(i=0; i<n; i++) {
+    for (i = 0; i < n; i++) {
         PyObject *tup, *descr, *index, *item, *name, *off;
-        int len, ret, _align=1;
+        int len, ret, _align = 1;
         PyArray_Descr *newdescr;
 
         /* Build item to insert (descr, offset, [title])*/
@@ -5473,8 +5611,12 @@
         index = PyInt_FromLong(i);
         if (titles) {
             item=PyObject_GetItem(titles, index);
-            if (item && item != Py_None) len = 3;
-            else Py_XDECREF(item);
+            if (item && item != Py_None) {
+                len = 3;
+            }
+            else {
+                Py_XDECREF(item);
+            }
             PyErr_Clear();
         }
         tup = PyTuple_New(len);
@@ -5506,12 +5648,13 @@
         }
         else {
             if (align && _align > 1) {
-                totalsize = ((totalsize + _align - 1)   \
-                             /_align)*_align;
+                totalsize = ((totalsize + _align - 1)/_align)*_align;
             }
             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(totalsize));
         }
-        if (len == 3) PyTuple_SET_ITEM(tup, 2, item);
+        if (len == 3) {
+            PyTuple_SET_ITEM(tup, 2, item);
+        }
         name = PyObject_GetItem(names, index);
         Py_DECREF(index);
         if (!(PyString_Check(name) || PyUnicode_Check(name))) {
@@ -5530,8 +5673,8 @@
         PyDict_SetItem(fields, name, tup);
         Py_DECREF(name);
         if (len == 3) {
-            if ((PyString_Check(item) || PyUnicode_Check(item)) &&
-                PyDict_GetItem(fields, item) != NULL) {
+            if ((PyString_Check(item) || PyUnicode_Check(item))
+                && PyDict_GetItem(fields, item) != NULL) {
                 PyErr_SetString(PyExc_ValueError,
                                 "title already used as a "\
                                 "name or title.");
@@ -5542,16 +5685,23 @@
             }
         }
         Py_DECREF(tup);
-        if ((ret == PY_FAIL) || (newdescr->elsize == 0)) goto fail;
+        if ((ret == PY_FAIL) || (newdescr->elsize == 0)) {
+            goto fail;
+        }
         dtypeflags |= (newdescr->hasobject & NPY_FROM_FIELDS);
         totalsize += newdescr->elsize;
     }
 
     new = PyArray_DescrNewFromType(PyArray_VOID);
-    if (new == NULL) goto fail;
-    if (maxalign > 1)
+    if (new == NULL) {
+        goto fail;
+    }
+    if (maxalign > 1) {
         totalsize = ((totalsize + maxalign - 1)/maxalign)*maxalign;
-    if (align) new->alignment = maxalign;
+    }
+    if (align) {
+        new->alignment = maxalign;
+    }
     new->elsize = totalsize;
     if (!PyTuple_Check(names)) {
         names = PySequence_Tuple(names);
@@ -5580,59 +5730,56 @@
     /* Check for ints at start of string */
     if ((type[0] >= '0' && type[0] <= '9') ||
         ((len > 1) && _chk_byteorder(type[0]) &&
-         (type[1] >= '0' && type[1] <= '9')))
+         (type[1] >= '0' && type[1] <= '9'))) {
         return 1;
-
+    }
     /* Check for empty tuple */
     if (((len > 1) && (type[0] == '(' && type[1] == ')')) ||
         ((len > 3) && _chk_byteorder(type[0]) &&
-         (type[1] == '(' && type[2] == ')')))
+         (type[1] == '(' && type[2] == ')'))) {
         return 1;
-
+    }
     /* Check for presence of commas */
-    for (i=1;i<len;i++)
-        if (type[i] == ',') return 1;
-
+    for (i = 1; i < len; i++) {
+        if (type[i] == ',') {
+            return 1;
+        }
+    }
     return 0;
 }
 
 #undef _chk_byteorder
 
-/*
-  any object with
-  the .fields attribute and/or .itemsize attribute
-  (if the .fields attribute does not give
-  the total size -- i.e. a partial record naming).
-  If itemsize is given it must be >= size computed from fields
-
-  The .fields attribute must return a convertible dictionary if
-  present.  Result inherits from PyArray_VOID.
-*/
-
-
 /*NUMPY_API
-  Get type-descriptor from an object forcing alignment if possible
-  None goes to DEFAULT type.
+ * Get type-descriptor from an object forcing alignment if possible
+ * None goes to DEFAULT type.
+ *
+ * any object with the .fields attribute and/or .itemsize attribute (if the
+ *.fields attribute does not give the total size -- i.e. a partial record
+ * naming).  If itemsize is given it must be >= size computed from fields
+ *
+ * The .fields attribute must return a convertible dictionary if present.
+ * Result inherits from PyArray_VOID.
 */
 static int
 PyArray_DescrAlignConverter(PyObject *obj, PyArray_Descr **at)
 {
     if PyDict_Check(obj) {
-            *at =  _convert_from_dict(obj, 1);
-        }
+        *at =  _convert_from_dict(obj, 1);
+    }
     else if PyString_Check(obj) {
-            *at = _convert_from_commastring(obj, 1);
-        }
+        *at = _convert_from_commastring(obj, 1);
+    }
     else if PyList_Check(obj) {
-            *at = _convert_from_array_descr(obj, 1);
-        }
+        *at = _convert_from_array_descr(obj, 1);
+    }
     else {
         return PyArray_DescrConverter(obj, at);
     }
     if (*at == NULL) {
         if (!PyErr_Occurred()) {
             PyErr_SetString(PyExc_ValueError,
-                            "data-type-descriptor not understood");
+                    "data-type-descriptor not understood");
         }
         return PY_FAIL;
     }
@@ -5640,28 +5787,28 @@
 }
 
 /*NUMPY_API
-  Get type-descriptor from an object forcing alignment if possible
-  None goes to NULL.
-*/
+ * Get type-descriptor from an object forcing alignment if possible
+ * None goes to NULL.
+ */
 static int
 PyArray_DescrAlignConverter2(PyObject *obj, PyArray_Descr **at)
 {
     if PyDict_Check(obj) {
-            *at =  _convert_from_dict(obj, 1);
-        }
+        *at =  _convert_from_dict(obj, 1);
+    }
     else if PyString_Check(obj) {
-            *at = _convert_from_commastring(obj, 1);
-        }
+        *at = _convert_from_commastring(obj, 1);
+    }
     else if PyList_Check(obj) {
-            *at = _convert_from_array_descr(obj, 1);
-        }
+        *at = _convert_from_array_descr(obj, 1);
+    }
     else {
         return PyArray_DescrConverter2(obj, at);
     }
     if (*at == NULL) {
         if (!PyErr_Occurred()) {
             PyErr_SetString(PyExc_ValueError,
-                            "data-type-descriptor not understood");
+                    "data-type-descriptor not understood");
         }
         return PY_FAIL;
     }
@@ -5670,8 +5817,8 @@
 
 
 /*NUMPY_API
-  Get typenum from an object -- None goes to NULL
-*/
+ * Get typenum from an object -- None goes to NULL
+ */
 static int
 PyArray_DescrConverter2(PyObject *obj, PyArray_Descr **at)
 {
@@ -5679,41 +5826,39 @@
         *at = NULL;
         return PY_SUCCEED;
     }
-    else return PyArray_DescrConverter(obj, at);
+    else {
+        return PyArray_DescrConverter(obj, at);
+    }
 }
 
-/* This function takes a Python object representing a type and converts it
-   to a the correct PyArray_Descr * structure to describe the type.
-
-   Many objects can be used to represent a data-type which in NumPy is
-   quite a flexible concept.
-
-   This is the central code that converts Python objects to
-   Type-descriptor objects that are used throughout numpy.
-*/
-
-/* new reference in *at */
 /*NUMPY_API
-  Get typenum from an object -- None goes to PyArray_DEFAULT
-*/
+ * Get typenum from an object -- None goes to PyArray_DEFAULT
+ * This function takes a Python object representing a type and converts it
+ * to a the correct PyArray_Descr * structure to describe the type.
+ *
+ * Many objects can be used to represent a data-type which in NumPy is
+ * quite a flexible concept.
+ *
+ * This is the central code that converts Python objects to
+ * Type-descriptor objects that are used throughout numpy.
+ * new reference in *at
+ */
 static int
 PyArray_DescrConverter(PyObject *obj, PyArray_Descr **at)
 {
     char *type;
-    int check_num=PyArray_NOTYPE+10;
+    int check_num = PyArray_NOTYPE + 10;
     int len;
     PyObject *item;
     int elsize = 0;
     char endian = '=';
 
-    *at=NULL;
-
+    *at = NULL;
     /* default */
     if (obj == Py_None) {
         *at = PyArray_DescrFromType(PyArray_DEFAULT);
         return PY_SUCCEED;
     }
-
     if (PyArray_DescrCheck(obj)) {
         *at = (PyArray_Descr *)obj;
         Py_INCREF(*at);
@@ -5724,134 +5869,165 @@
         if (PyType_IsSubtype((PyTypeObject *)obj,
                              &PyGenericArrType_Type)) {
             *at = PyArray_DescrFromTypeObject(obj);
-            if (*at) return PY_SUCCEED;
-            else return PY_FAIL;
+            if (*at) {
+                return PY_SUCCEED;
+            }
+            else {
+                return PY_FAIL;
+            }
         }
         check_num = PyArray_OBJECT;
-        if (obj == (PyObject *)(&PyInt_Type))
+        if (obj == (PyObject *)(&PyInt_Type)) {
             check_num = PyArray_LONG;
-        else if (obj == (PyObject *)(&PyLong_Type))
+        }
+        else if (obj == (PyObject *)(&PyLong_Type)) {
             check_num = PyArray_LONGLONG;
-        else if (obj == (PyObject *)(&PyFloat_Type))
+        }
+        else if (obj == (PyObject *)(&PyFloat_Type)) {
             check_num = PyArray_DOUBLE;
-        else if (obj == (PyObject *)(&PyComplex_Type))
+        }
+        else if (obj == (PyObject *)(&PyComplex_Type)) {
             check_num = PyArray_CDOUBLE;
-        else if (obj == (PyObject *)(&PyBool_Type))
+        }
+        else if (obj == (PyObject *)(&PyBool_Type)) {
             check_num = PyArray_BOOL;
-        else if (obj == (PyObject *)(&PyString_Type))
+        }
+        else if (obj == (PyObject *)(&PyString_Type)) {
             check_num = PyArray_STRING;
-        else if (obj == (PyObject *)(&PyUnicode_Type))
+        }
+        else if (obj == (PyObject *)(&PyUnicode_Type)) {
             check_num = PyArray_UNICODE;
-        else if (obj == (PyObject *)(&PyBuffer_Type))
+        }
+        else if (obj == (PyObject *)(&PyBuffer_Type)) {
             check_num = PyArray_VOID;
+        }
         else {
             *at = _arraydescr_fromobj(obj);
-            if (*at) return PY_SUCCEED;
+            if (*at) {
+                return PY_SUCCEED;
+            }
         }
         goto finish;
     }
 
     /* or a typecode string */
-
     if (PyString_Check(obj)) {
         /* Check for a string typecode. */
         type = PyString_AS_STRING(obj);
         len = PyString_GET_SIZE(obj);
-        if (len <= 0) goto fail;
-
-        /* check for commas present
-           or first (or second) element a digit */
+        if (len <= 0) {
+            goto fail;
+        }
+        /* check for commas present or first (or second) element a digit */
         if (_check_for_commastring(type, len)) {
             *at = _convert_from_commastring(obj, 0);
-            if (*at) return PY_SUCCEED;
+            if (*at) {
+                return PY_SUCCEED;
+            }
             return PY_FAIL;
         }
         check_num = (int) type[0];
-        if ((char) check_num == '>' || (char) check_num == '<' || \
-            (char) check_num == '|' || (char) check_num == '=') {
-            if (len <= 1) goto fail;
+        if ((char) check_num == '>' || (char) check_num == '<'
+            || (char) check_num == '|' || (char) check_num == '=') {
+            if (len <= 1) {
+                goto fail;
+            }
             endian = (char) check_num;
             type++; len--;
             check_num = (int) type[0];
-            if (endian == '|') endian = '=';
+            if (endian == '|') {
+                endian = '=';
+            }
         }
         if (len > 1) {
-            elsize = atoi(type+1);
+            elsize = atoi(type + 1);
             if (elsize == 0) {
                 check_num = PyArray_NOTYPE+10;
             }
-            /* When specifying length of UNICODE
-               the number of characters is given to match
-               the STRING interface.  Each character can be
-               more than one byte and itemsize must be
-               the number of bytes.
-            */
+            /*
+             * When specifying length of UNICODE
+             * the number of characters is given to match
+             * the STRING interface.  Each character can be
+             * more than one byte and itemsize must be
+             * the number of bytes.
+             */
             else if (check_num == PyArray_UNICODELTR) {
                 elsize <<= 2;
             }
-            /* Support for generic processing
-               c4, i4, f8, etc...
-            */
-            else if ((check_num != PyArray_STRINGLTR) && \
-                     (check_num != PyArray_VOIDLTR) &&      \
-                     (check_num != PyArray_STRINGLTR2)) {
-                check_num =                             \
-                    PyArray_TypestrConvert(elsize,
-                                           check_num);
-                if (check_num == PyArray_NOTYPE)
+            /* Support for generic processing c4, i4, f8, etc...*/
+            else if ((check_num != PyArray_STRINGLTR)
+                     && (check_num != PyArray_VOIDLTR)
+                     && (check_num != PyArray_STRINGLTR2)) {
+                check_num = PyArray_TypestrConvert(elsize, check_num);
+                if (check_num == PyArray_NOTYPE) {
                     check_num += 10;
+                }
                 elsize = 0;
             }
         }
     }
-    /* or a tuple */
     else if (PyTuple_Check(obj)) {
+        /* or a tuple */
         *at = _convert_from_tuple(obj);
         if (*at == NULL){
-            if (PyErr_Occurred()) return PY_FAIL;
+            if (PyErr_Occurred()) {
+                return PY_FAIL;
+            }
             goto fail;
         }
         return PY_SUCCEED;
     }
-    /* or a list */
     else if (PyList_Check(obj)) {
+        /* or a list */
         *at = _convert_from_array_descr(obj,0);
         if (*at == NULL) {
-            if (PyErr_Occurred()) return PY_FAIL;
+            if (PyErr_Occurred()) {
+                return PY_FAIL;
+            }
             goto fail;
         }
         return PY_SUCCEED;
     }
-    /* or a dictionary */
     else if (PyDict_Check(obj)) {
+        /* or a dictionary */
         *at = _convert_from_dict(obj,0);
         if (*at == NULL) {
-            if (PyErr_Occurred()) return PY_FAIL;
+            if (PyErr_Occurred()) {
+                return PY_FAIL;
+            }
             goto fail;
         }
         return PY_SUCCEED;
     }
-    else if (PyArray_Check(obj)) goto fail;
-    else /* goto fail;*/ {
+    else if (PyArray_Check(obj)) {
+        goto fail;
+    }
+    else {
         *at = _arraydescr_fromobj(obj);
-        if (*at) return PY_SUCCEED;
-        if (PyErr_Occurred()) return PY_FAIL;
+        if (*at) {
+            return PY_SUCCEED;
+        }
+        if (PyErr_Occurred()) {
+            return PY_FAIL;
+        }
         goto fail;
     }
-    if (PyErr_Occurred()) goto fail;
-
+    if (PyErr_Occurred()) {
+        goto fail;
+    }
     /*
       if (check_num == PyArray_NOTYPE) return PY_FAIL;
     */
 
  finish:
-    if ((check_num == PyArray_NOTYPE+10) ||                 \
-        (*at = PyArray_DescrFromType(check_num))==NULL) {
-        /* Now check to see if the object is registered
-           in typeDict */
+    if ((check_num == PyArray_NOTYPE + 10)
+        || (*at = PyArray_DescrFromType(check_num)) == NULL) {
+        /* Now check to see if the object is registered in typeDict */
         if (typeDict != NULL) {
             item = PyDict_GetItem(typeDict, obj);
-            if (item) return PyArray_DescrConverter(item, at);
+            if (item) {
+                return PyArray_DescrConverter(item, at);
+            }
         }
         goto fail;
     }
@@ -5860,51 +6036,58 @@
         PyArray_DESCR_REPLACE(*at);
         (*at)->elsize = elsize;
     }
-    if (endian != '=' && PyArray_ISNBO(endian)) endian = '=';
-
-    if (endian != '=' && (*at)->byteorder != '|' && \
-        (*at)->byteorder != endian) {
+    if (endian != '=' && PyArray_ISNBO(endian)) {
+        endian = '=';
+    }
+    if (endian != '=' && (*at)->byteorder != '|'
+        && (*at)->byteorder != endian) {
         PyArray_DESCR_REPLACE(*at);
         (*at)->byteorder = endian;
     }
-
     return PY_SUCCEED;
 
  fail:
-    PyErr_SetString(PyExc_TypeError,
-                    "data type not understood");
-    *at=NULL;
+    PyErr_SetString(PyExc_TypeError, "data type not understood");
+    *at = NULL;
     return PY_FAIL;
 }
 
 /*NUMPY_API
-  Convert object to endian
-*/
+ * Convert object to endian
+ */
 static int
 PyArray_ByteorderConverter(PyObject *obj, char *endian)
 {
     char *str;
+
     *endian = PyArray_SWAP;
     str = PyString_AsString(obj);
-    if (!str) return PY_FAIL;
+    if (!str) {
+        return PY_FAIL;
+    }
     if (strlen(str) < 1) {
         PyErr_SetString(PyExc_ValueError,
                         "Byteorder string must be at least length 1");
         return PY_FAIL;
     }
     *endian = str[0];
-    if (str[0] != PyArray_BIG && str[0] != PyArray_LITTLE &&        \
-        str[0] != PyArray_NATIVE && str[0] != PyArray_IGNORE) {
-        if (str[0] == 'b' || str[0] == 'B')
+    if (str[0] != PyArray_BIG && str[0] != PyArray_LITTLE
+        && str[0] != PyArray_NATIVE && str[0] != PyArray_IGNORE) {
+        if (str[0] == 'b' || str[0] == 'B') {
             *endian = PyArray_BIG;
-        else if (str[0] == 'l' || str[0] == 'L')
+        }
+        else if (str[0] == 'l' || str[0] == 'L') {
             *endian = PyArray_LITTLE;
-        else if (str[0] == 'n' || str[0] == 'N')
+        }
+        else if (str[0] == 'n' || str[0] == 'N') {
             *endian = PyArray_NATIVE;
-        else if (str[0] == 'i' || str[0] == 'I')
+        }
+        else if (str[0] == 'i' || str[0] == 'I') {
             *endian = PyArray_IGNORE;
-        else if (str[0] == 's' || str[0] == 'S')
+        }
+        else if (str[0] == 's' || str[0] == 'S') {
             *endian = PyArray_SWAP;
+        }
         else {
             PyErr_Format(PyExc_ValueError,
                          "%s is an unrecognized byteorder",
@@ -5916,26 +6099,32 @@
 }
 
 /*NUMPY_API
-  Convert object to sort kind
-*/
+ * Convert object to sort kind
+ */
 static int
 PyArray_SortkindConverter(PyObject *obj, NPY_SORTKIND *sortkind)
 {
     char *str;
+
     *sortkind = PyArray_QUICKSORT;
     str = PyString_AsString(obj);
-    if (!str) return PY_FAIL;
+    if (!str) {
+        return PY_FAIL;
+    }
     if (strlen(str) < 1) {
         PyErr_SetString(PyExc_ValueError,
                         "Sort kind string must be at least length 1");
         return PY_FAIL;
     }
-    if (str[0] == 'q' || str[0] == 'Q')
+    if (str[0] == 'q' || str[0] == 'Q') {
         *sortkind = PyArray_QUICKSORT;
-    else if (str[0] == 'h' || str[0] == 'H')
+    }
+    else if (str[0] == 'h' || str[0] == 'H') {
         *sortkind = PyArray_HEAPSORT;
-    else if (str[0] == 'm' || str[0] == 'M')
+    }
+    else if (str[0] == 'm' || str[0] == 'M') {
         *sortkind = PyArray_MERGESORT;
+    }
     else {
         PyErr_Format(PyExc_ValueError,
                      "%s is an unrecognized kind of sort",
@@ -5946,44 +6135,54 @@
 }
 
 
-/* compare the field dictionary for two types
-   return 1 if the same or 0 if not
-*/
-
+/*
+ * compare the field dictionary for two types
+ * return 1 if the same or 0 if not
+ */
 static int
 _equivalent_fields(PyObject *field1, PyObject *field2) {
 
     int same, val;
 
-    if (field1 == field2) return 1;
-    if (field1 == NULL || field2 == NULL) return 0;
+    if (field1 == field2) {
+        return 1;
+    }
+    if (field1 == NULL || field2 == NULL) {
+        return 0;
+    }
     val = PyObject_Compare(field1, field2);
-    if (val != 0 || PyErr_Occurred()) same = 0;
-    else same = 1;
+    if (val != 0 || PyErr_Occurred()) {
+        same = 0;
+    }
+    else {
+        same = 1;
+    }
     PyErr_Clear();
     return same;
 }
 
-/* This function returns true if the two typecodes are
-   equivalent (same basic kind and same itemsize).
-*/
 
-/*NUMPY_API*/
+/*NUMPY_API
+ *
+ * This function returns true if the two typecodes are
+ * equivalent (same basic kind and same itemsize).
+ */
 static unsigned char
 PyArray_EquivTypes(PyArray_Descr *typ1, PyArray_Descr *typ2)
 {
-    register int typenum1=typ1->type_num;
-    register int typenum2=typ2->type_num;
-    register int size1=typ1->elsize;
-    register int size2=typ2->elsize;
+    int typenum1 = typ1->type_num;
+    int typenum2 = typ2->type_num;
+    int size1 = typ1->elsize;
+    int size2 = typ2->elsize;
 
-    if (size1 != size2) return FALSE;
-
-    if (PyArray_ISNBO(typ1->byteorder) != PyArray_ISNBO(typ2->byteorder))
+    if (size1 != size2) {
         return FALSE;
-
-    if (typenum1 == PyArray_VOID || \
-        typenum2 == PyArray_VOID) {
+    }
+    if (PyArray_ISNBO(typ1->byteorder) != PyArray_ISNBO(typ2->byteorder)) {
+        return FALSE;
+    }
+    if (typenum1 == PyArray_VOID
+        || typenum2 == PyArray_VOID) {
         return ((typenum1 == typenum2) &&
                 _equivalent_fields(typ1->fields, typ2->fields));
     }
@@ -5996,6 +6195,7 @@
 {
     PyArray_Descr *d1, *d2;
     Bool ret;
+
     d1 = PyArray_DescrFromType(typenum1);
     d2 = PyArray_DescrFromType(typenum2);
     ret = PyArray_EquivTypes(d1, d2);
@@ -6011,16 +6211,16 @@
 {
     intp newdims[MAX_DIMS];
     intp newstrides[MAX_DIMS];
-    int i,k,num;
+    int i, k, num;
     PyObject *ret;
 
-    num = ndmin-nd;
-    for (i=0; i<num; i++) {
+    num = ndmin - nd;
+    for (i = 0; i < num; i++) {
         newdims[i] = 1;
         newstrides[i] = arr->descr->elsize;
     }
-    for (i=num;i<ndmin;i++) {
-        k = i-num;
+    for (i = num; i < ndmin; i++) {
+        k = i - num;
         newdims[i] = arr->dimensions[k];
         newstrides[i] = arr->strides[k];
     }
@@ -6028,8 +6228,7 @@
     ret = PyArray_NewFromDescr(arr->ob_type, arr->descr, ndmin,
                                newdims, newstrides, arr->data, arr->flags,
                                (PyObject *)arr);
-    /* steals a reference to arr --- so don't increment
-       here */
+    /* steals a reference to arr --- so don't increment here */
     PyArray_BASE(ret) = (PyObject *)arr;
     return ret;
 }
@@ -6046,23 +6245,22 @@
 static PyObject *
 _array_fromobject(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *kws)
 {
-    PyObject *op, *ret=NULL;
+    PyObject *op, *ret = NULL;
     static char *kwd[]= {"object", "dtype", "copy", "order", "subok",
                          "ndmin", NULL};
-    Bool subok=FALSE;
-    Bool copy=TRUE;
-    int ndmin=0, nd;
-    PyArray_Descr *type=NULL;
-    PyArray_Descr *oldtype=NULL;
+    Bool subok = FALSE;
+    Bool copy = TRUE;
+    int ndmin = 0, nd;
+    PyArray_Descr *type = NULL;
+    PyArray_Descr *oldtype = NULL;
     NPY_ORDER order=PyArray_ANYORDER;
-    int flags=0;
+    int flags = 0;
 
     if (PyTuple_GET_SIZE(args) > 2) {
         PyErr_SetString(PyExc_ValueError,
                         "only 2 non-keyword arguments accepted");
         return NULL;
     }
-
     if(!PyArg_ParseTupleAndKeywords(args, kws, "O|O&O&O&O&i", kwd, &op,
                                     PyArray_DescrConverter2,
                                     &type,
@@ -6074,19 +6272,17 @@
             return NULL;
     }
 
-
     /* fast exit if simple call */
-    if ((subok && PyArray_Check(op)) ||
-        (!subok && PyArray_CheckExact(op))) {
-        if (type==NULL) {
+    if ((subok && PyArray_Check(op))
+        || (!subok && PyArray_CheckExact(op))) {
+        if (type == NULL) {
             if (!copy && STRIDING_OK(op, order)) {
                 Py_INCREF(op);
                 ret = op;
                 goto finish;
             }
             else {
-                ret = PyArray_NewCopy((PyArrayObject*)op,
-                                      order);
+                ret = PyArray_NewCopy((PyArrayObject*)op, order);
                 goto finish;
             }
         }
@@ -6099,9 +6295,10 @@
                 goto finish;
             }
             else {
-                ret = PyArray_NewCopy((PyArrayObject*)op,
-                                      order);
-                if (oldtype == type) goto finish;
+                ret = PyArray_NewCopy((PyArrayObject*)op, order);
+                if (oldtype == type) {
+                    goto finish;
+                }
                 Py_INCREF(oldtype);
                 Py_DECREF(PyArray_DESCR(ret));
                 PyArray_DESCR(ret) = oldtype;
@@ -6116,9 +6313,9 @@
     if (order == PyArray_CORDER) {
         flags |= CONTIGUOUS;
     }
-    else if ((order == PyArray_FORTRANORDER) ||
+    else if ((order == PyArray_FORTRANORDER)
              /* order == PyArray_ANYORDER && */
-             (PyArray_Check(op) && PyArray_ISFORTRAN(op))) {
+             || (PyArray_Check(op) && PyArray_ISFORTRAN(op))) {
         flags |= FORTRAN;
     }
     if (!subok) {
@@ -6126,23 +6323,27 @@
     }
 
     flags |= NPY_FORCECAST;
-
     Py_XINCREF(type);
     ret = PyArray_CheckFromAny(op, type, 0, 0, flags, NULL);
 
  finish:
     Py_XDECREF(type);
-    if (!ret || (nd=PyArray_NDIM(ret)) >= ndmin) return ret;
-    /* create a new array from the same data with ones in the shape */
-    /* steals a reference to ret */
+    if (!ret || (nd=PyArray_NDIM(ret)) >= ndmin) {
+        return ret;
+    }
+    /*
+     * create a new array from the same data with ones in the shape
+     * steals a reference to ret
+     */
     return _prepend_ones((PyArrayObject *)ret, nd, ndmin);
 }
 
-/* accepts NULL type */
-/* steals referenct to type */
 /*NUMPY_API
-  Empty
-*/
+ * Empty
+ *
+ * accepts NULL type
+ * steals referenct to type
+ */
 static PyObject *
 PyArray_Empty(int nd, intp *dims, PyArray_Descr *type, int fortran)
 {
@@ -6153,11 +6354,15 @@
                                                 type, nd, dims,
                                                 NULL, NULL,
                                                 fortran, NULL);
-    if (ret == NULL) return NULL;
-
+    if (ret == NULL) {
+        return NULL;
+    }
     if (PyDataType_REFCHK(type)) {
         PyArray_FillObjectArray(ret, Py_None);
-        if (PyErr_Occurred()) {Py_DECREF(ret); return NULL;}
+        if (PyErr_Occurred()) {
+            Py_DECREF(ret);
+            return NULL;
+        }
     }
     return (PyObject *)ret;
 }
@@ -6167,23 +6372,26 @@
 {
 
     static char *kwlist[] = {"shape","dtype","order",NULL};
-    PyArray_Descr *typecode=NULL;
+    PyArray_Descr *typecode = NULL;
     PyArray_Dims shape = {NULL, 0};
     NPY_ORDER order = PyArray_CORDER;
     Bool fortran;
-    PyObject *ret=NULL;
+    PyObject *ret = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|O&O&",
                                      kwlist, PyArray_IntpConverter,
                                      &shape,
                                      PyArray_DescrConverter,
                                      &typecode,
-                                     PyArray_OrderConverter, &order))
+                                     PyArray_OrderConverter, &order)) {
         goto fail;
-
-    if (order == PyArray_FORTRANORDER) fortran = TRUE;
-    else fortran = FALSE;
-
+    }
+    if (order == PyArray_FORTRANORDER) {
+        fortran = TRUE;
+    }
+    else {
+        fortran = FALSE;
+    }
     ret = PyArray_Empty(shape.len, shape.ptr, typecode, fortran);
     PyDimMem_FREE(shape.ptr);
     return ret;
@@ -6194,17 +6402,18 @@
     return NULL;
 }
 
-/* This function is needed for supporting Pickles of
-   numpy scalar objects.
-*/
+/*
+ * This function is needed for supporting Pickles of
+ * numpy scalar objects.
+ */
 static PyObject *
 array_scalar(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *kwds)
 {
 
     static char *kwlist[] = {"dtype","obj", NULL};
     PyArray_Descr *typecode;
-    PyObject *obj=NULL;
-    int alloc=0;
+    PyObject *obj = NULL;
+    int alloc = 0;
     void *dptr;
     PyObject *ret;
 
@@ -6212,17 +6421,18 @@
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O",
                                      kwlist, &PyArrayDescr_Type,
                                      &typecode,
-                                     &obj))
+                                     &obj)) {
         return NULL;
-
+    }
     if (typecode->elsize == 0) {
-        PyErr_SetString(PyExc_ValueError,               \
-                        "itemsize cannot be zero");
+        PyErr_SetString(PyExc_ValueError, "itemsize cannot be zero");
         return NULL;
     }
 
     if (PyDataType_FLAGCHK(typecode, NPY_ITEM_IS_POINTER)) {
-        if (obj == NULL) obj = Py_None;
+        if (obj == NULL) {
+            obj = Py_None;
+        }
         dptr = &obj;
     }
     else {
@@ -6254,29 +6464,37 @@
     ret = PyArray_Scalar(dptr, typecode, NULL);
 
     /* free dptr which contains zeros */
-    if (alloc) _pya_free(dptr);
+    if (alloc) {
+        _pya_free(dptr);
+    }
     return ret;
 }
 
-/* steal a reference */
-/* accepts NULL type */
 /*NUMPY_API
-  Zeros
-*/
+ * Zeros
+ *
+ * steal a reference
+ * accepts NULL type
+ */
 static PyObject *
 PyArray_Zeros(int nd, intp *dims, PyArray_Descr *type, int fortran)
 {
     PyArrayObject *ret;
 
-    if (!type) type = PyArray_DescrFromType(PyArray_DEFAULT);
+    if (!type) {
+        type = PyArray_DescrFromType(PyArray_DEFAULT);
+    }
     ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type,
                                                 type,
                                                 nd, dims,
                                                 NULL, NULL,
                                                 fortran, NULL);
-    if (ret == NULL) return NULL;
-
-    if (_zerofill(ret) < 0) return NULL;
+    if (ret == NULL) {
+        return NULL;
+    }
+    if (_zerofill(ret) < 0) {
+        return NULL;
+    }
     return (PyObject *)ret;
 
 }
@@ -6285,11 +6503,11 @@
 array_zeros(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *kwds)
 {
     static char *kwlist[] = {"shape","dtype","order",NULL}; /* XXX ? */
-    PyArray_Descr *typecode=NULL;
+    PyArray_Descr *typecode = NULL;
     PyArray_Dims shape = {NULL, 0};
     NPY_ORDER order = PyArray_CORDER;
     Bool fortran = FALSE;
-    PyObject *ret=NULL;
+    PyObject *ret = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|O&O&",
                                      kwlist, PyArray_IntpConverter,
@@ -6297,11 +6515,15 @@
                                      PyArray_DescrConverter,
                                      &typecode,
                                      PyArray_OrderConverter,
-                                     &order))
+                                     &order)) {
         goto fail;
-
-    if (order == PyArray_FORTRANORDER) fortran = TRUE;
-    else fortran = FALSE;
+    }
+    if (order == PyArray_FORTRANORDER) {
+        fortran = TRUE;
+    }
+    else {
+        fortran = FALSE;
+    }
     ret = PyArray_Zeros(shape.len, shape.ptr, typecode, (int) fortran);
     PyDimMem_FREE(shape.ptr);
     return ret;
@@ -6316,23 +6538,28 @@
 array_set_typeDict(PyObject *NPY_UNUSED(ignored), PyObject *args)
 {
     PyObject *dict;
-    if (!PyArg_ParseTuple(args, "O", &dict)) return NULL;
-    Py_XDECREF(typeDict); /* Decrement old reference (if any)*/
+
+    if (!PyArg_ParseTuple(args, "O", &dict)) {
+        return NULL;
+    }
+    /* Decrement old reference (if any)*/
+    Py_XDECREF(typeDict);
     typeDict = dict;
-    Py_INCREF(dict);  /* Create an internal reference to it */
+    /* Create an internal reference to it */
+    Py_INCREF(dict);
     Py_INCREF(Py_None);
     return Py_None;
 }
 
 
-/* Reading from a file or a string.
+/*
+ * Reading from a file or a string.
+ *
+ * As much as possible, we try to use the same code for both files and strings,
+ * so the semantics for fromstring and fromfile are the same, especially with
+ * regards to the handling of text representations.
+ */
 
-   As much as possible, we try to use the same code for both files and strings,
-   so the semantics for fromstring and fromfile are the same, especially with
-   regards to the handling of text representations.
-*/
-
-
 typedef int (*next_element)(void **, void *, PyArray_Descr *, void *);
 typedef int (*skip_separator)(void **, const char *, void *);
 
@@ -6355,14 +6582,16 @@
     return dtype->f->scanfunc(*fp, dptr, NULL, dtype);
 }
 
-/* Remove multiple whitespace from the separator, and add a space to the
-   beginning and end. This simplifies the separator-skipping code below.
-*/
+/*
+ * Remove multiple whitespace from the separator, and add a space to the
+ * beginning and end. This simplifies the separator-skipping code below.
+ */
 static char *
 swab_separator(char *sep)
 {
     int skip_space = 0;
     char *s, *start;
+
     s = start = malloc(strlen(sep)+3);
     /* add space to front if there isn't one */
     if (*sep != '\0' && !isspace(*sep)) {
@@ -6372,14 +6601,18 @@
         if (isspace(*sep)) {
             if (skip_space) {
                 sep++;
-            } else {
+            }
+            else {
                 *s = ' ';
-                s++; sep++;
+                s++;
+                sep++;
                 skip_space = 1;
             }
-        } else {
+        }
+        else {
             *s = *sep;
-            s++; sep++;
+            s++;
+            sep++;
             skip_space = 0;
         }
     }
@@ -6392,17 +6625,17 @@
     return start;
 }
 
-/* Assuming that the separator is the next bit in the string (file), skip it.
-
-   Single spaces in the separator are matched to arbitrary-long sequences
-   of whitespace in the input. If the separator consists only of spaces,
-   it matches one or more whitespace characters.
-
-   If we can't match the separator, return -2.
-   If we hit the end of the string (file), return -1.
-   Otherwise, return 0.
-*/
-
+/*
+ * Assuming that the separator is the next bit in the string (file), skip it.
+ *
+ * Single spaces in the separator are matched to arbitrary-long sequences
+ * of whitespace in the input. If the separator consists only of spaces,
+ * it matches one or more whitespace characters.
+ *
+ * If we can't match the separator, return -2.
+ * If we hit the end of the string (file), return -1.
+ * Otherwise, return 0.
+ */
 static int
 fromstr_skip_separator(char **s, const char *sep, const char *end)
 {
@@ -6413,26 +6646,31 @@
         if (c == '\0' || (end != NULL && string >= end)) {
             result = -1;
             break;
-        } else if (*sep == '\0') {
+        }
+        else if (*sep == '\0') {
             if (string != *s) {
                 /* matched separator */
                 result = 0;
                 break;
-            } else {
+            }
+            else {
                 /* separator was whitespace wildcard that didn't match */
                 result = -2;
                 break;
             }
-        } else if (*sep == ' ') {
+        }
+        else if (*sep == ' ') {
             /* whitespace wildcard */
             if (!isspace(c)) {
                 sep++;
                 continue;
             }
-        } else if (*sep != c) {
+        }
+        else if (*sep != c) {
             result = -2;
             break;
-        } else {
+        }
+        else {
             sep++;
         }
         string++;
@@ -6446,46 +6684,54 @@
 {
     int result = 0;
     const char *sep_start = sep;
+
     while (1) {
         int c = fgetc(*fp);
+
         if (c == EOF) {
             result = -1;
             break;
-        } else if (*sep == '\0') {
+        }
+        else if (*sep == '\0') {
             ungetc(c, *fp);
             if (sep != sep_start) {
                 /* matched separator */
                 result = 0;
                 break;
-            } else {
+            }
+            else {
                 /* separator was whitespace wildcard that didn't match */
                 result = -2;
                 break;
             }
-        } else if (*sep == ' ') {
+        }
+        else if (*sep == ' ') {
             /* whitespace wildcard */
             if (!isspace(c)) {
                 sep++;
                 sep_start++;
                 ungetc(c, *fp);
-            } else if (sep == sep_start) {
+            }
+            else if (sep == sep_start) {
                 sep_start--;
             }
-        } else if (*sep != c) {
+        }
+        else if (*sep != c) {
             ungetc(c, *fp);
             result = -2;
             break;
-        } else {
+        }
+        else {
             sep++;
         }
     }
     return result;
 }
 
-/* Create an array by reading from the given stream, using the passed
-   next_element and skip_separator functions.
-*/
-
+/*
+ * Create an array by reading from the given stream, using the passed
+ * next_element and skip_separator functions.
+ */
 #define FROM_BUFFER_SIZE 4096
 static PyArrayObject *
 array_from_text(PyArray_Descr *dtype, intp num, char *sep, size_t *nread,
@@ -6501,21 +6747,23 @@
     intp bytes, totalbytes;
 
     size = (num >= 0) ? num : FROM_BUFFER_SIZE;
-
     r = (PyArrayObject *)
         PyArray_NewFromDescr(&PyArray_Type,
                              dtype,
                              1, &size,
                              NULL, NULL,
                              0, NULL);
-    if (r == NULL) return NULL;
+    if (r == NULL) {
+        return NULL;
+    }
     clean_sep = swab_separator(sep);
     NPY_BEGIN_ALLOW_THREADS;
     totalbytes = bytes = size * dtype->elsize;
     dptr = r->data;
-    for (i=0; num < 0 || i < num; i++) {
-        if (next(&stream, dptr, dtype, stream_data) < 0)
+    for (i= 0; num < 0 || i < num; i++) {
+        if (next(&stream, dptr, dtype, stream_data) < 0) {
             break;
+        }
         *nread += 1;
         thisbuf += 1;
         dptr += dtype->elsize;
@@ -6530,12 +6778,15 @@
             dptr = tmp + (totalbytes - bytes);
             thisbuf = 0;
         }
-        if (skip_sep(&stream, clean_sep, stream_data) < 0)
+        if (skip_sep(&stream, clean_sep, stream_data) < 0) {
             break;
+        }
     }
     if (num < 0) {
         tmp = PyDataMem_RENEW(r->data, (*nread)*dtype->elsize);
-	if (tmp == NULL) err=1;
+	if (tmp == NULL) {
+            err = 1;
+        }
 	else {
 	    PyArray_DIM(r,0) = *nread;
 	    r->data = tmp;
@@ -6543,7 +6794,9 @@
     }
     NPY_END_ALLOW_THREADS;
     free(clean_sep);
-    if (err == 1) PyErr_NoMemory();
+    if (err == 1) {
+        PyErr_NoMemory();
+    }
     if (PyErr_Occurred()) {
         Py_DECREF(r);
         return NULL;
@@ -6553,26 +6806,26 @@
 #undef FROM_BUFFER_SIZE
 
 /*NUMPY_API
-
-  Given a pointer to a string ``data``, a string length ``slen``, and
-  a ``PyArray_Descr``, return an array corresponding to the data
-  encoded in that string.
-
-  If the dtype is NULL, the default array type is used (double).
-  If non-null, the reference is stolen.
-
-  If ``slen`` is < 0, then the end of string is used for text data.
-  It is an error for ``slen`` to be < 0 for binary data (since embedded NULLs
-  would be the norm).
-
-  The number of elements to read is given as ``num``; if it is < 0, then
-  then as many as possible are read.
-
-  If ``sep`` is NULL or empty, then binary data is assumed, else
-  text data, with ``sep`` as the separator between elements. Whitespace in
-  the separator matches any length of whitespace in the text, and a match
-  for whitespace around the separator is added.
-*/
+ *
+ * Given a pointer to a string ``data``, a string length ``slen``, and
+ * a ``PyArray_Descr``, return an array corresponding to the data
+ * encoded in that string.
+ *
+ * If the dtype is NULL, the default array type is used (double).
+ * If non-null, the reference is stolen.
+ *
+ * If ``slen`` is < 0, then the end of string is used for text data.
+ * It is an error for ``slen`` to be < 0 for binary data (since embedded NULLs
+ * would be the norm).
+ *
+ * The number of elements to read is given as ``num``; if it is < 0, then
+ * then as many as possible are read.
+ *
+ * If ``sep`` is NULL or empty, then binary data is assumed, else
+ * text data, with ``sep`` as the separator between elements. Whitespace in
+ * the separator matches any length of whitespace in the text, and a match
+ * for whitespace around the separator is added.
+ */
 static PyObject *
 PyArray_FromString(char *data, intp slen, PyArray_Descr *dtype,
                    intp num, char *sep)
@@ -6581,9 +6834,9 @@
     PyArrayObject *ret;
     Bool binary;
 
-    if (dtype == NULL)
+    if (dtype == NULL) {
         dtype=PyArray_DescrFromType(PyArray_DEFAULT);
-
+    }
     if (PyDataType_FLAGCHK(dtype, NPY_ITEM_IS_POINTER)) {
         PyErr_SetString(PyExc_ValueError,
                         "Cannot create an object array from"    \
@@ -6591,7 +6844,6 @@
         Py_DECREF(dtype);
         return NULL;
     }
-
     itemsize = dtype->elsize;
     if (itemsize == 0) {
         PyErr_SetString(PyExc_ValueError, "zero-valued itemsize");
@@ -6600,7 +6852,6 @@
     }
 
     binary = ((sep == NULL) || (strlen(sep) == 0));
-
     if (binary) {
         if (num < 0 ) {
             if (slen % itemsize != 0) {
@@ -6611,7 +6862,8 @@
                 return NULL;
             }
             num = slen/itemsize;
-        } else {
+        }
+        else {
             if (slen < num*itemsize) {
                 PyErr_SetString(PyExc_ValueError,
                                 "string is smaller than " \
@@ -6620,17 +6872,20 @@
                 return NULL;
             }
         }
-
         ret = (PyArrayObject *)
             PyArray_NewFromDescr(&PyArray_Type, dtype,
                                  1, &num, NULL, NULL,
                                  0, NULL);
-        if (ret == NULL) return NULL;
+        if (ret == NULL) {
+            return NULL;
+        }
         memcpy(ret->data, data, num*dtype->elsize);
-    } else {
+    }
+    else {
         /* read from character-based string */
         size_t nread = 0;
         char *end;
+
         if (dtype->f->scanfunc == NULL) {
             PyErr_SetString(PyExc_ValueError,
                             "don't know how to read "       \
@@ -6641,7 +6896,8 @@
         }
         if (slen < 0) {
             end = NULL;
-        } else {
+        }
+        else {
             end = data + slen;
         }
         ret = array_from_text(dtype, num, sep, &nread,
@@ -6657,11 +6913,11 @@
 array_fromstring(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds)
 {
     char *data;
-    Py_ssize_t nin=-1;
-    char *sep=NULL;
+    Py_ssize_t nin = -1;
+    char *sep = NULL;
     Py_ssize_t s;
     static char *kwlist[] = {"string", "dtype", "count", "sep", NULL};
-    PyArray_Descr *descr=NULL;
+    PyArray_Descr *descr = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, keywds, "s#|O&"
                                      NPY_SSIZE_T_PYFMT "s", kwlist,
@@ -6671,7 +6927,6 @@
         Py_XDECREF(descr);
         return NULL;
     }
-
     return PyArray_FromString(data, (intp)s, descr, (intp)nin, sep);
 }
 
@@ -6684,14 +6939,23 @@
     intp start, numbytes;
 
     if (num < 0) {
-        int fail=0;
+        int fail = 0;
+
         start = (intp )ftell(fp);
-        if (start < 0) fail=1;
-        if (fseek(fp, 0, SEEK_END) < 0) fail=1;
+        if (start < 0) {
+            fail = 1;
+        }
+        if (fseek(fp, 0, SEEK_END) < 0) {
+            fail = 1;
+        }
         numbytes = (intp) ftell(fp);
-        if (numbytes < 0) fail=1;
+        if (numbytes < 0) {
+            fail = 1;
+        }
         numbytes -= start;
-        if (fseek(fp, start, SEEK_SET) < 0) fail=1;
+        if (fseek(fp, start, SEEK_SET) < 0) {
+            fail = 1;
+        }
         if (fail) {
             PyErr_SetString(PyExc_IOError,
                             "could not seek in file");
@@ -6705,7 +6969,9 @@
                                               1, &num,
                                               NULL, NULL,
                                               0, NULL);
-    if (r==NULL) return NULL;
+    if (r == NULL) {
+        return NULL;
+    }
     NPY_BEGIN_ALLOW_THREADS;
     *nread = fread(r->data, dtype->elsize, num, fp);
     NPY_END_ALLOW_THREADS;
@@ -6713,24 +6979,24 @@
 }
 
 /*NUMPY_API
-
-  Given a ``FILE *`` pointer ``fp``, and a ``PyArray_Descr``, return an
-  array corresponding to the data encoded in that file.
-
-  If the dtype is NULL, the default array type is used (double).
-  If non-null, the reference is stolen.
-
-  The number of elements to read is given as ``num``; if it is < 0, then
-  then as many as possible are read.
-
-  If ``sep`` is NULL or empty, then binary data is assumed, else
-  text data, with ``sep`` as the separator between elements. Whitespace in
-  the separator matches any length of whitespace in the text, and a match
-  for whitespace around the separator is added.
-
-  For memory-mapped files, use the buffer interface. No more data than
-  necessary is read by this routine.
-*/
+ *
+ * Given a ``FILE *`` pointer ``fp``, and a ``PyArray_Descr``, return an
+ * array corresponding to the data encoded in that file.
+ *
+ * If the dtype is NULL, the default array type is used (double).
+ * If non-null, the reference is stolen.
+ *
+ * The number of elements to read is given as ``num``; if it is < 0, then
+ * then as many as possible are read.
+ *
+ * If ``sep`` is NULL or empty, then binary data is assumed, else
+ * text data, with ``sep`` as the separator between elements. Whitespace in
+ * the separator matches any length of whitespace in the text, and a match
+ * for whitespace around the separator is added.
+ *
+ * For memory-mapped files, use the buffer interface. No more data than
+ * necessary is read by this routine.
+ */
 static PyObject *
 PyArray_FromFile(FILE *fp, PyArray_Descr *dtype, intp num, char *sep)
 {
@@ -6749,10 +7015,10 @@
         Py_DECREF(dtype);
         return NULL;
     }
-
     if ((sep == NULL) || (strlen(sep) == 0)) {
         ret = array_fromfile_binary(fp, dtype, num, &nread);
-    } else {
+    }
+    else {
         if (dtype->f->scanfunc == NULL) {
             PyErr_SetString(PyExc_ValueError,
                             "don't know how to read "       \
@@ -6789,12 +7055,12 @@
 static PyObject *
 array_fromfile(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds)
 {
-    PyObject *file=NULL, *ret;
+    PyObject *file = NULL, *ret;
     FILE *fp;
-    char *sep="";
-    Py_ssize_t nin=-1;
+    char *sep = "";
+    Py_ssize_t nin = -1;
     static char *kwlist[] = {"file", "dtype", "count", "sep", NULL};
-    PyArray_Descr *type=NULL;
+    PyArray_Descr *type = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, keywds,
                                      "O|O&" NPY_SSIZE_T_PYFMT "s",
@@ -6805,16 +7071,16 @@
         Py_XDECREF(type);
         return NULL;
     }
-
     if (PyString_Check(file) || PyUnicode_Check(file)) {
         file = PyObject_CallFunction((PyObject *)&PyFile_Type,
                                      "Os", file, "rb");
-        if (file==NULL) return NULL;
+        if (file == NULL) {
+            return NULL;
+        }
     }
     else {
         Py_INCREF(file);
     }
-
     fp = PyFile_AsFile(file);
     if (fp == NULL) {
         PyErr_SetString(PyExc_IOError,
@@ -6822,17 +7088,19 @@
         Py_DECREF(file);
         return NULL;
     }
-
-    if (type == NULL) type = PyArray_DescrFromType(PyArray_DEFAULT);
-
+    if (type == NULL) {
+        type = PyArray_DescrFromType(PyArray_DEFAULT);
+    }
     ret = PyArray_FromFile(fp, type, (intp) nin, sep);
     Py_DECREF(file);
     return ret;
 }
 
 
-/* steals a reference to dtype (which cannot be NULL) */
-/*NUMPY_API */
+/*NUMPY_API
+ *
+ * steals a reference to dtype (which cannot be NULL)
+ */
 static PyObject *
 PyArray_FromIter(PyObject *obj, PyArray_Descr *dtype, intp count)
 {
@@ -6842,8 +7110,9 @@
     intp i, elsize, elcount;
     char *item, *new_data;
 
-    if (iter == NULL) goto done;
-
+    if (iter == NULL) {
+        goto done;
+    }
     elcount = (count < 0) ? 0 : count;
     if ((elsize=dtype->elsize) == 0) {
         PyErr_SetString(PyExc_ValueError, "Must specify length "\
@@ -6851,9 +7120,10 @@
         goto done;
     }
 
-    /* We would need to alter the memory RENEW code to decrement any
-       reference counts before throwing away any memory.
-    */
+    /*
+     * We would need to alter the memory RENEW code to decrement any
+     * reference counts before throwing away any memory.
+     */
     if (PyDataType_REFCHK(dtype)) {
         PyErr_SetString(PyExc_ValueError, "cannot create "\
                         "object arrays from iterator");
@@ -6863,11 +7133,11 @@
     ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype, 1,
                                                 &elcount, NULL,NULL, 0, NULL);
     dtype = NULL;
-    if (ret == NULL) goto done;
-
+    if (ret == NULL) {
+        goto done;
+    }
     for (i = 0; (i < count || count == -1) &&
              (value = PyIter_Next(iter)); i++) {
-
         if (i >= elcount) {
             /*
               Grow ret->data:
@@ -6875,10 +7145,12 @@
               50% overallocation => 0, 4, 8, 14, 23, 36, 56, 86 ...
             */
             elcount = (i >> 1) + (i < 4 ? 4 : 2) + i;
-            if (elcount <= (intp)((~(size_t)0) / elsize))
+            if (elcount <= (intp)((~(size_t)0) / elsize)) {
                 new_data = PyDataMem_RENEW(ret->data, elcount * elsize);
-            else
+            }
+            else {
                 new_data = NULL;
+            }
             if (new_data == NULL) {
                 PyErr_SetString(PyExc_MemoryError,
                                 "cannot allocate array memory");
@@ -6887,15 +7159,14 @@
             }
             ret->data = new_data;
         }
-        ret->dimensions[0] = i+1;
+        ret->dimensions[0] = i + 1;
 
-        if (((item = index2ptr(ret, i)) == NULL) ||
-            (ret->descr->f->setitem(value, item, ret) == -1)) {
+        if (((item = index2ptr(ret, i)) == NULL)
+            || (ret->descr->f->setitem(value, item, ret) == -1)) {
             Py_DECREF(value);
             goto done;
         }
         Py_DECREF(value);
-
     }
 
     if (i < count) {
@@ -6904,10 +7175,12 @@
     }
 
     /*
-      Realloc the data so that don't keep extra memory tied up
-      (assuming realloc is reasonably good about reusing space...)
-    */
-    if (i==0) i = 1;
+     * Realloc the data so that don't keep extra memory tied up
+     * (assuming realloc is reasonably good about reusing space...)
+     */
+    if (i == 0) {
+        i = 1;
+    }
     new_data = PyDataMem_RENEW(ret->data, i * elsize);
     if (new_data == NULL) {
         PyErr_SetString(PyExc_MemoryError, "cannot allocate array memory");
@@ -6929,9 +7202,9 @@
 array_fromiter(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds)
 {
     PyObject *iter;
-    Py_ssize_t nin=-1;
+    Py_ssize_t nin = -1;
     static char *kwlist[] = {"iter", "dtype", "count", NULL};
-    PyArray_Descr *descr=NULL;
+    PyArray_Descr *descr = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, keywds,
                                      "OO&|" NPY_SSIZE_T_PYFMT,
@@ -6942,7 +7215,6 @@
         Py_XDECREF(descr);
         return NULL;
     }
-
     return PyArray_FromIter(iter, descr, (intp)nin);
 }
 
@@ -6957,7 +7229,7 @@
     Py_ssize_t ts;
     intp s, n;
     int itemsize;
-    int write=1;
+    int write = 1;
 
 
     if (PyDataType_REFCHK(type)) {
@@ -6973,21 +7245,25 @@
         Py_DECREF(type);
         return NULL;
     }
-
-    if (buf->ob_type->tp_as_buffer == NULL || \
-        (buf->ob_type->tp_as_buffer->bf_getwritebuffer == NULL &&   \
-         buf->ob_type->tp_as_buffer->bf_getreadbuffer == NULL)) {
+    if (buf->ob_type->tp_as_buffer == NULL
+        || (buf->ob_type->tp_as_buffer->bf_getwritebuffer == NULL
+            && buf->ob_type->tp_as_buffer->bf_getreadbuffer == NULL)) {
         PyObject *newbuf;
         newbuf = PyObject_GetAttrString(buf, "__buffer__");
-        if (newbuf == NULL) {Py_DECREF(type); return NULL;}
+        if (newbuf == NULL) {
+            Py_DECREF(type);
+            return NULL;
+        }
         buf = newbuf;
     }
-    else {Py_INCREF(buf);}
+    else {
+        Py_INCREF(buf);
+    }
 
-    if (PyObject_AsWriteBuffer(buf, (void *)&data, &ts)==-1) {
+    if (PyObject_AsWriteBuffer(buf, (void *)&data, &ts) == -1) {
         write = 0;
         PyErr_Clear();
-        if (PyObject_AsReadBuffer(buf, (void *)&data, &ts)==-1) {
+        if (PyObject_AsReadBuffer(buf, (void *)&data, &ts) == -1) {
             Py_DECREF(buf);
             Py_DECREF(type);
             return NULL;
@@ -7004,7 +7280,6 @@
     s = (intp)ts - offset;
     n = (intp)count;
     itemsize = type->elsize;
-
     if (n < 0 ) {
         if (s % itemsize != 0) {
             PyErr_SetString(PyExc_ValueError,
@@ -7015,7 +7290,8 @@
             return NULL;
         }
         n = s/itemsize;
-    } else {
+    }
+    else {
         if (s < n*itemsize) {
             PyErr_SetString(PyExc_ValueError,
                             "buffer is smaller than requested"\
@@ -7036,8 +7312,9 @@
         return NULL;
     }
 
-    if (!write) ret->flags &= ~WRITEABLE;
-
+    if (!write) {
+        ret->flags &= ~WRITEABLE;
+    }
     /* Store a reference for decref on deallocation */
     ret->base = buf;
     PyArray_UpdateFlags(ret, ALIGNED);
@@ -7047,10 +7324,10 @@
 static PyObject *
 array_frombuffer(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *keywds)
 {
-    PyObject *obj=NULL;
-    Py_ssize_t nin=-1, offset=0;
+    PyObject *obj = NULL;
+    Py_ssize_t nin = -1, offset = 0;
     static char *kwlist[] = {"buffer", "dtype", "count", "offset", NULL};
-    PyArray_Descr *type=NULL;
+    PyArray_Descr *type = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, keywds, "O|O&"
                                      NPY_SSIZE_T_PYFMT
@@ -7061,9 +7338,9 @@
         Py_XDECREF(type);
         return NULL;
     }
-    if (type==NULL)
+    if (type == NULL) {
         type = PyArray_DescrFromType(PyArray_DEFAULT);
-
+    }
     return PyArray_FromBuffer(obj, type, (intp)nin, (intp)offset);
 }
 
@@ -7071,48 +7348,53 @@
 array_concatenate(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds)
 {
     PyObject *a0;
-    int axis=0;
+    int axis = 0;
     static char *kwlist[] = {"seq", "axis", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&", kwlist,
                                      &a0,
-                                     PyArray_AxisConverter, &axis))
+                                     PyArray_AxisConverter, &axis)) {
         return NULL;
+    }
     return PyArray_Concatenate(a0, axis);
 }
 
 static PyObject *array_innerproduct(PyObject *NPY_UNUSED(dummy), PyObject *args) {
     PyObject *b0, *a0;
 
-    if (!PyArg_ParseTuple(args, "OO", &a0, &b0)) return NULL;
-
+    if (!PyArg_ParseTuple(args, "OO", &a0, &b0)) {
+        return NULL;
+    }
     return _ARET(PyArray_InnerProduct(a0, b0));
 }
 
 static PyObject *array_matrixproduct(PyObject *NPY_UNUSED(dummy), PyObject *args) {
     PyObject *v, *a;
 
-    if (!PyArg_ParseTuple(args, "OO", &a, &v)) return NULL;
-
+    if (!PyArg_ParseTuple(args, "OO", &a, &v)) {
+        return NULL;
+    }
     return _ARET(PyArray_MatrixProduct(a, v));
 }
 
 static PyObject *array_fastCopyAndTranspose(PyObject *NPY_UNUSED(dummy), PyObject *args) {
     PyObject *a0;
 
-    if (!PyArg_ParseTuple(args, "O", &a0)) return NULL;
-
+    if (!PyArg_ParseTuple(args, "O", &a0)) {
+        return NULL;
+    }
     return _ARET(PyArray_CopyAndTranspose(a0));
 }
 
 static PyObject *array_correlate(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds) {
     PyObject *shape, *a0;
-    int mode=0;
+    int mode = 0;
     static char *kwlist[] = {"a", "v", "mode", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|i", kwlist,
-                                     &a0, &shape, &mode)) return NULL;
-
+                                     &a0, &shape, &mode)) {
+        return NULL;
+    }
     return PyArray_Correlate(a0, shape, mode);
 }
 
@@ -7136,37 +7418,45 @@
         return PyArray_New(&PyArray_Type, 1, &length, type_num,
                            NULL, NULL, 0, 0, NULL);
     }
-
     range = PyArray_New(&PyArray_Type, 1, &length, type_num,
                         NULL, NULL, 0, 0, NULL);
-    if (range == NULL) return NULL;
-
+    if (range == NULL) {
+        return NULL;
+    }
     funcs = PyArray_DESCR(range)->f;
 
-    /* place start in the buffer and the next value in the second position */
-    /* if length > 2, then call the inner loop, otherwise stop */
-
+    /*
+     * place start in the buffer and the next value in the second position
+     * if length > 2, then call the inner loop, otherwise stop
+     */
     obj = PyFloat_FromDouble(start);
     ret = funcs->setitem(obj, PyArray_DATA(range), (PyArrayObject *)range);
     Py_DECREF(obj);
-    if (ret < 0) goto fail;
-    if (length == 1) return range;
-
+    if (ret < 0) {
+        goto fail;
+    }
+    if (length == 1) {
+        return range;
+    }
     obj = PyFloat_FromDouble(start + step);
     ret = funcs->setitem(obj, PyArray_BYTES(range)+PyArray_ITEMSIZE(range),
                          (PyArrayObject *)range);
     Py_DECREF(obj);
-    if (ret < 0) goto fail;
-    if (length == 2) return range;
-
+    if (ret < 0) {
+        goto fail;
+    }
+    if (length == 2) {
+        return range;
+    }
     if (!funcs->fill) {
         PyErr_SetString(PyExc_ValueError, "no fill-function for data-type.");
         Py_DECREF(range);
         return NULL;
     }
     funcs->fill(PyArray_DATA(range), length, (PyArrayObject *)range);
-    if (PyErr_Occurred()) goto fail;
-
+    if (PyErr_Occurred()) {
+        goto fail;
+    }
     return range;
 
  fail:
@@ -7174,9 +7464,9 @@
     return NULL;
 }
 
-/* the formula is
-   len = (intp) ceil((start - stop) / step);
-*/
+/*
+ * the formula is len = (intp) ceil((start - stop) / step);
+ */
 static intp
 _calc_length(PyObject *start, PyObject *stop, PyObject *step, PyObject **next, int cmplx)
 {
@@ -7195,35 +7485,48 @@
         return -1;
     }
     val = PyNumber_TrueDivide(*next, step);
-    Py_DECREF(*next); *next=NULL;
-    if (!val) return -1;
+    Py_DECREF(*next);
+    *next = NULL;
+    if (!val) {
+        return -1;
+    }
     if (cmplx && PyComplex_Check(val)) {
         value = PyComplex_RealAsDouble(val);
-        if (error_converting(value)) {Py_DECREF(val); return -1;}
+        if (error_converting(value)) {
+            Py_DECREF(val);
+            return -1;
+        }
         len = (intp) ceil(value);
         value = PyComplex_ImagAsDouble(val);
         Py_DECREF(val);
-        if (error_converting(value)) return -1;
+        if (error_converting(value)) {
+            return -1;
+        }
         len = MIN(len, (intp) ceil(value));
     }
     else {
         value = PyFloat_AsDouble(val);
         Py_DECREF(val);
-        if (error_converting(value)) return -1;
+        if (error_converting(value)) {
+            return -1;
+        }
         len = (intp) ceil(value);
     }
-
     if (len > 0) {
         *next = PyNumber_Add(start, step);
-        if (!next) return -1;
+        if (!next) {
+            return -1;
+        }
     }
     return len;
 }
 
-/* this doesn't change the references */
 /*NUMPY_API
-  ArangeObj,
-*/
+ *
+ * ArangeObj,
+ *
+ * this doesn't change the references
+ */
 static PyObject *
 PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr *dtype)
 {
@@ -7231,7 +7534,7 @@
     PyArray_ArrFuncs *funcs;
     PyObject *next;
     intp length;
-    PyArray_Descr *native=NULL;
+    PyArray_Descr *native = NULL;
     int swap;
 
     if (!dtype) {
@@ -7254,33 +7557,41 @@
         }
         dtype = deftype;
     }
-    else Py_INCREF(dtype);
-
+    else {
+        Py_INCREF(dtype);
+    }
     if (!step || step == Py_None) {
         step = PyInt_FromLong(1);
     }
-    else Py_XINCREF(step);
-
+    else {
+        Py_XINCREF(step);
+    }
     if (!stop || stop == Py_None) {
         stop = start;
         start = PyInt_FromLong(0);
     }
-    else Py_INCREF(start);
-
+    else {
+        Py_INCREF(start);
+    }
     /* calculate the length and next = start + step*/
     length = _calc_length(start, stop, step, &next,
                           PyTypeNum_ISCOMPLEX(dtype->type_num));
-
-    if (PyErr_Occurred()) {Py_DECREF(dtype); goto fail;}
+    if (PyErr_Occurred()) {
+        Py_DECREF(dtype);
+        goto fail;
+    }
     if (length <= 0) {
         length = 0;
         range = PyArray_SimpleNewFromDescr(1, &length, dtype);
-        Py_DECREF(step); Py_DECREF(start); return range;
+        Py_DECREF(step);
+        Py_DECREF(start);
+        return range;
     }
 
-    /* If dtype is not in native byte-order then get native-byte
-       order version.  And then swap on the way out.
-    */
+    /*
+     * If dtype is not in native byte-order then get native-byte
+     * order version.  And then swap on the way out.
+     */
     if (!PyArray_ISNBO(dtype->byteorder)) {
         native = PyArray_DescrNewByteorder(dtype, PyArray_NATBYTE);
         swap = 1;
@@ -7291,28 +7602,38 @@
     }
 
     range = PyArray_SimpleNewFromDescr(1, &length, native);
-    if (range == NULL) goto fail;
+    if (range == NULL) {
+        goto fail;
+    }
 
+    /*
+     * place start in the buffer and the next value in the second position
+     * if length > 2, then call the inner loop, otherwise stop
+     */
     funcs = PyArray_DESCR(range)->f;
-
-    /* place start in the buffer and the next value in the second position */
-    /* if length > 2, then call the inner loop, otherwise stop */
-
-    if (funcs->setitem(start, PyArray_DATA(range), (PyArrayObject *)range) < 0)
+    if (funcs->setitem(
+                start, PyArray_DATA(range), (PyArrayObject *)range) < 0) {
         goto fail;
-    if (length == 1) goto finish;
+    }
+    if (length == 1) {
+        goto finish;
+    }
     if (funcs->setitem(next, PyArray_BYTES(range)+PyArray_ITEMSIZE(range),
-                       (PyArrayObject *)range) < 0) goto fail;
-    if (length == 2) goto finish;
-
+                       (PyArrayObject *)range) < 0) {
+        goto fail;
+    }
+    if (length == 2) {
+        goto finish;
+    }
     if (!funcs->fill) {
         PyErr_SetString(PyExc_ValueError, "no fill-function for data-type.");
         Py_DECREF(range);
         goto fail;
     }
     funcs->fill(PyArray_DATA(range), length, (PyArrayObject *)range);
-    if (PyErr_Occurred()) goto fail;
-
+    if (PyErr_Occurred()) {
+        goto fail;
+    }
  finish:
     if (swap) {
         PyObject *new;
@@ -7321,7 +7642,6 @@
         Py_DECREF(PyArray_DESCR(range));
         PyArray_DESCR(range) = dtype;  /* steals the reference */
     }
-
     Py_DECREF(start);
     Py_DECREF(step);
     Py_DECREF(next);
@@ -7336,9 +7656,9 @@
 
 static PyObject *
 array_arange(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *kws) {
-    PyObject *o_start=NULL, *o_stop=NULL, *o_step=NULL;
+    PyObject *o_start = NULL, *o_stop = NULL, *o_step = NULL;
     static char *kwd[]= {"start", "stop", "step", "dtype", NULL};
-    PyArray_Descr *typecode=NULL;
+    PyArray_Descr *typecode = NULL;
 
     if(!PyArg_ParseTupleAndKeywords(args, kws, "O|OOO&", kwd, &o_start,
                                     &o_stop, &o_step,
@@ -7347,14 +7667,13 @@
         Py_XDECREF(typecode);
         return NULL;
     }
-
     return PyArray_ArangeObj(o_start, o_stop, o_step, typecode);
 }
 
 /*
-  Included at the very first so not auto-grabbed and thus not
-  labeled.
-*/
+ * Included at the very first so not auto-grabbed and thus not
+ * labeled.
+ */
 static unsigned int
 PyArray_GetNDArrayCVersion(void)
 {
@@ -7365,8 +7684,10 @@
 array__get_ndarray_c_version(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds)
 {
     static char *kwlist[] = {NULL};
-    if(!PyArg_ParseTupleAndKeywords(args, kwds, "", kwlist )) return NULL;
 
+    if(!PyArg_ParseTupleAndKeywords(args, kwds, "", kwlist )) {
+        return NULL;
+    }
     return PyInt_FromLong( (long) PyArray_GetNDArrayCVersion() );
 }
 
@@ -7377,46 +7698,51 @@
     PyObject *ret;
     PyTypeObject *subtype;
     PyArray_Dims shape = {NULL, 0};
-    PyArray_Descr *dtype=NULL;
+    PyArray_Descr *dtype = NULL;
     if (!PyArg_ParseTuple(args, "O!O&O&", &PyType_Type, &subtype,
                           PyArray_IntpConverter, &shape,
-                          PyArray_DescrConverter, &dtype))
+                          PyArray_DescrConverter, &dtype)) {
         goto fail;
-
+    }
     if (!PyType_IsSubtype(subtype, &PyArray_Type)) {
         PyErr_SetString(PyExc_TypeError,
                         "_reconstruct: First argument must be " \
                         "a sub-type of ndarray");
         goto fail;
     }
-
     ret = PyArray_NewFromDescr(subtype, dtype,
                                (int)shape.len, shape.ptr,
                                NULL, NULL, 0, NULL);
-    if (shape.ptr) PyDimMem_FREE(shape.ptr);
+    if (shape.ptr) {
+        PyDimMem_FREE(shape.ptr);
+    }
     return ret;
 
  fail:
     Py_XDECREF(dtype);
-    if (shape.ptr) PyDimMem_FREE(shape.ptr);
+    if (shape.ptr) {
+        PyDimMem_FREE(shape.ptr);
+    }
     return NULL;
 }
 
 static PyObject *
 array_set_string_function(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds)
 {
-    PyObject *op=NULL;
+    PyObject *op = NULL;
     int repr=1;
     static char *kwlist[] = {"f", "repr", NULL};
 
     if(!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi", kwlist,
-                                    &op, &repr)) return NULL;
-
+                                    &op, &repr)) {
+        return NULL;
+    }
     /* reset the array_repr function to built-in */
-    if (op == Py_None) op = NULL;
+    if (op == Py_None) {
+        op = NULL;
+    }
     if (op != NULL && !PyCallable_Check(op)) {
-        PyErr_SetString(PyExc_TypeError,
-                        "Argument must be callable.");
+        PyErr_SetString(PyExc_TypeError, "Argument must be callable.");
         return NULL;
     }
     PyArray_SetStringFunction(op, repr);
@@ -7427,18 +7753,19 @@
 static PyObject *
 array_set_ops_function(PyObject *NPY_UNUSED(self), PyObject *NPY_UNUSED(args), PyObject *kwds)
 {
-    PyObject *oldops=NULL;
+    PyObject *oldops = NULL;
 
-    if ((oldops = PyArray_GetNumericOps())==NULL) return NULL;
-
-    /* Should probably ensure that objects are at least callable */
-    /*  Leave this to the caller for now --- error will be raised
-        later when use is attempted
-    */
+    if ((oldops = PyArray_GetNumericOps()) == NULL) {
+        return NULL;
+    }
+    /*
+     * Should probably ensure that objects are at least callable
+     *  Leave this to the caller for now --- error will be raised
+     *  later when use is attempted
+     */
     if (kwds && PyArray_SetNumericOps(kwds) == -1) {
         Py_DECREF(oldops);
-        PyErr_SetString(PyExc_ValueError,
-                        "one or more objects not callable");
+        PyErr_SetString(PyExc_ValueError, "one or more objects not callable");
         return NULL;
     }
     return oldops;
@@ -7446,26 +7773,25 @@
 
 
 /*NUMPY_API
-  Where
-*/
+ * Where
+ */
 static PyObject *
 PyArray_Where(PyObject *condition, PyObject *x, PyObject *y)
 {
     PyArrayObject *arr;
-    PyObject *tup=NULL, *obj=NULL;
-    PyObject *ret=NULL, *zero=NULL;
+    PyObject *tup = NULL, *obj = NULL;
+    PyObject *ret = NULL, *zero = NULL;
 
-
     arr = (PyArrayObject *)PyArray_FromAny(condition, NULL, 0, 0, 0, NULL);
-    if (arr == NULL) return NULL;
-
-    if ((x==NULL) && (y==NULL)) {
+    if (arr == NULL) {
+        return NULL;
+    }
+    if ((x == NULL) && (y == NULL)) {
         ret = PyArray_Nonzero(arr);
         Py_DECREF(arr);
         return ret;
     }
-
-    if ((x==NULL) || (y==NULL)) {
+    if ((x == NULL) || (y == NULL)) {
         Py_DECREF(arr);
         PyErr_SetString(PyExc_ValueError, "either both or neither "
                         "of x and y should be given");
@@ -7474,18 +7800,19 @@
 
 
     zero = PyInt_FromLong((long) 0);
-
     obj = PyArray_EnsureAnyArray(PyArray_GenericBinaryFunction(arr, zero,
                                                                n_ops.not_equal));
     Py_DECREF(zero);
     Py_DECREF(arr);
-    if (obj == NULL) return NULL;
-
+    if (obj == NULL) {
+        return NULL;
+    }
     tup = Py_BuildValue("(OO)", y, x);
-    if (tup == NULL) {Py_DECREF(obj); return NULL;}
-
+    if (tup == NULL) {
+        Py_DECREF(obj);
+        return NULL;
+    }
     ret = PyArray_Choose((PyAO *)obj, tup, NULL, NPY_RAISE);
-
     Py_DECREF(obj);
     Py_DECREF(tup);
     return ret;
@@ -7494,23 +7821,25 @@
 static PyObject *
 array_where(PyObject *NPY_UNUSED(ignored), PyObject *args)
 {
-    PyObject *obj=NULL, *x=NULL, *y=NULL;
+    PyObject *obj = NULL, *x = NULL, *y = NULL;
 
-    if (!PyArg_ParseTuple(args, "O|OO", &obj, &x, &y)) return NULL;
-
+    if (!PyArg_ParseTuple(args, "O|OO", &obj, &x, &y)) {
+        return NULL;
+    }
     return PyArray_Where(obj, x, y);
 }
 
 static PyObject *
 array_lexsort(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *kwds)
 {
-    int axis=-1;
+    int axis = -1;
     PyObject *obj;
     static char *kwlist[] = {"keys", "axis", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|i", kwlist,
-                                     &obj, &axis)) return NULL;
-
+                                     &obj, &axis)) {
+        return NULL;
+    }
     return _ARET(PyArray_LexSort(obj, axis));
 }
 
@@ -7519,10 +7848,10 @@
 static PyObject *
 array_can_cast_safely(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds)
 {
-    PyArray_Descr *d1=NULL;
-    PyArray_Descr *d2=NULL;
+    PyArray_Descr *d1 = NULL;
+    PyArray_Descr *d2 = NULL;
     Bool ret;
-    PyObject *retobj=NULL;
+    PyObject *retobj = NULL;
     static char *kwlist[] = {"from", "to", NULL};
 
     if(!PyArg_ParseTupleAndKeywords(args, kwds, "O&O&", kwlist,
@@ -7538,7 +7867,7 @@
     }
 
     ret = PyArray_CanCastTo(d1, d2);
-    retobj = (ret ? Py_True : Py_False);
+    retobj = ret ? Py_True : Py_False;
     Py_INCREF(retobj);
 
  finish:
@@ -7552,9 +7881,9 @@
 {
     int size;
 
-    if(!PyArg_ParseTuple(args, "i", &size))
+    if(!PyArg_ParseTuple(args, "i", &size)) {
         return NULL;
-
+    }
     return PyBuffer_New(size);
 }
 
@@ -7562,22 +7891,22 @@
 buffer_buffer(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds)
 {
     PyObject *obj;
-    Py_ssize_t offset=0, size=Py_END_OF_BUFFER, n;
+    Py_ssize_t offset = 0, size = Py_END_OF_BUFFER, n;
     void *unused;
     static char *kwlist[] = {"object", "offset", "size", NULL};
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|" NPY_SSIZE_T_PYFMT \
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|" NPY_SSIZE_T_PYFMT
                                      NPY_SSIZE_T_PYFMT, kwlist,
-                                     &obj, &offset, &size))
+                                     &obj, &offset, &size)) {
         return NULL;
-
-
+    }
     if (PyObject_AsWriteBuffer(obj, &unused, &n) < 0) {
         PyErr_Clear();
         return PyBuffer_FromObject(obj, offset, size);
     }
-    else
+    else {
         return PyBuffer_FromReadWriteObject(obj, offset, size);
+    }
 }
 
 #ifndef _MSC_VER
@@ -7609,22 +7938,29 @@
 {
     PyObject *mem;
     Py_ssize_t size;
-    Bool ro=FALSE, check=TRUE;
+    Bool ro = FALSE, check = TRUE;
     void *memptr;
     static char *kwlist[] = {"mem", "size", "readonly", "check", NULL};
+
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O" \
                                      NPY_SSIZE_T_PYFMT "|O&O&", kwlist,
                                      &mem, &size, PyArray_BoolConverter,
                                      &ro, PyArray_BoolConverter,
-                                     &check)) return NULL;
+                                     &check)) {
+        return NULL;
+    }
     memptr = PyLong_AsVoidPtr(mem);
-    if (memptr == NULL) return NULL;
-
+    if (memptr == NULL) {
+        return NULL;
+    }
     if (check) {
-        /* Try to dereference the start and end of the memory region */
-        /* Catch segfault and report error if it occurs */
+        /*
+         * Try to dereference the start and end of the memory region
+         * Catch segfault and report error if it occurs
+         */
         char test;
-        int err=0;
+        int err = 0;
+
 #ifdef _MSC_VER
         __try {
             _test_code();
@@ -7635,7 +7971,6 @@
 #else
         PyOS_sighandler_t _npy_sig_save;
         _npy_sig_save = PyOS_setsig(SIGSEGV, _SigSegv_Handler);
-
         if (setjmp(_NPY_SIGSEGV_BUF) == 0) {
             _test_code();
         }
@@ -7696,49 +8031,66 @@
     Bool rstrip;
     char *cmp_str;
     Py_ssize_t strlen;
-    PyObject *res=NULL;
-    static char msg[] = \
-        "comparision must be '==', '!=', '<', '>', '<=', '>='";
-
+    PyObject *res = NULL;
+    static char msg[] = "comparision must be '==', '!=', '<', '>', '<=', '>='";
     static char *kwlist[] = {"a1", "a2", "cmp", "rstrip", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOs#O&", kwlist,
                                      &array, &other,
                                      &cmp_str, &strlen,
-                                     PyArray_BoolConverter, &rstrip))
+                                     PyArray_BoolConverter, &rstrip)) {
         return NULL;
-
-    if (strlen < 1 || strlen > 2) goto err;
+    }
+    if (strlen < 1 || strlen > 2) {
+        goto err;
+    }
     if (strlen > 1) {
-        if (cmp_str[1] != '=') goto err;
-        if (cmp_str[0] == '=') cmp_op = Py_EQ;
-        else if (cmp_str[0] == '!') cmp_op = Py_NE;
-        else if (cmp_str[0] == '<') cmp_op = Py_LE;
-        else if (cmp_str[0] == '>') cmp_op = Py_GE;
-        else goto err;
+        if (cmp_str[1] != '=') {
+            goto err;
+        }
+        if (cmp_str[0] == '=') {
+            cmp_op = Py_EQ;
+        }
+        else if (cmp_str[0] == '!') {
+            cmp_op = Py_NE;
+        }
+        else if (cmp_str[0] == '<') {
+            cmp_op = Py_LE;
+        }
+        else if (cmp_str[0] == '>') {
+            cmp_op = Py_GE;
+        }
+        else {
+            goto err;
+        }
     }
     else {
-        if (cmp_str[0] == '<') cmp_op = Py_LT;
-        else if (cmp_str[0] == '>') cmp_op = Py_GT;
-        else goto err;
+        if (cmp_str[0] == '<') {
+            cmp_op = Py_LT;
+        }
+        else if (cmp_str[0] == '>') {
+            cmp_op = Py_GT;
+        }
+        else {
+            goto err;
+        }
     }
 
     newarr = (PyArrayObject *)PyArray_FROM_O(array);
-    if (newarr == NULL) return NULL;
+    if (newarr == NULL) {
+        return NULL;
+    }
     newoth = (PyArrayObject *)PyArray_FROM_O(other);
     if (newoth == NULL) {
         Py_DECREF(newarr);
         return NULL;
     }
-
     if (PyArray_ISSTRING(newarr) && PyArray_ISSTRING(newoth)) {
         res = _strings_richcompare(newarr, newoth, cmp_op, rstrip != 0);
     }
     else {
-        PyErr_SetString(PyExc_TypeError,
-                        "comparison of non-string arrays");
+        PyErr_SetString(PyExc_TypeError, "comparison of non-string arrays");
     }
-
     Py_DECREF(newarr);
     Py_DECREF(newoth);
     return res;
@@ -7790,120 +8142,158 @@
 static PyObject *
 test_interrupt(PyObject *NPY_UNUSED(self), PyObject *args)
 {
-    int kind=0;
+    int kind = 0;
     int a = 0;
 
-    if (!PyArg_ParseTuple(args, "|i", &kind)) return NULL;
-
+    if (!PyArg_ParseTuple(args, "|i", &kind)) {
+        return NULL;
+    }
     if (kind) {
         Py_BEGIN_ALLOW_THREADS;
-            while (a>=0) {
-                if ((a % 1000 == 0) &&
-                    PyOS_InterruptOccurred()) break;
-                a+=1;
+        while (a >= 0) {
+            if ((a % 1000 == 0) && PyOS_InterruptOccurred()) {
+                break;
             }
+            a += 1;
+        }
         Py_END_ALLOW_THREADS;
-            }
+    }
     else {
-
         NPY_SIGINT_ON
-
-            while(a>=0) {
-                a += 1;
-            }
-
+        while(a >= 0) {
+            a += 1;
+        }
         NPY_SIGINT_OFF
-            }
-
+    }
     return PyInt_FromLong(a);
 }
 
 static struct PyMethodDef array_module_methods[] = {
-    {"_get_ndarray_c_version", (PyCFunction)array__get_ndarray_c_version,
-     METH_VARARGS|METH_KEYWORDS, NULL},
-    {"_reconstruct", (PyCFunction)array__reconstruct,
-     METH_VARARGS, NULL},
-    {"set_string_function", (PyCFunction)array_set_string_function,
-     METH_VARARGS|METH_KEYWORDS, NULL},
-    {"set_numeric_ops", (PyCFunction)array_set_ops_function,
-     METH_VARARGS|METH_KEYWORDS, NULL},
-    {"set_typeDict", (PyCFunction)array_set_typeDict,
-     METH_VARARGS, NULL},
+    {"_get_ndarray_c_version",
+        (PyCFunction)array__get_ndarray_c_version,
+        METH_VARARGS|METH_KEYWORDS, NULL},
+    {"_reconstruct",
+        (PyCFunction)array__reconstruct,
+        METH_VARARGS, NULL},
+    {"set_string_function",
+        (PyCFunction)array_set_string_function,
+        METH_VARARGS|METH_KEYWORDS, NULL},
+    {"set_numeric_ops",
+        (PyCFunction)array_set_ops_function,
+        METH_VARARGS|METH_KEYWORDS, NULL},
+    {"set_typeDict",
+        (PyCFunction)array_set_typeDict,
+        METH_VARARGS, NULL},
 
-    {"array",       (PyCFunction)_array_fromobject,
-     METH_VARARGS|METH_KEYWORDS, NULL},
-    {"arange",  (PyCFunction)array_arange,
-     METH_VARARGS|METH_KEYWORDS, NULL},
-    {"zeros",       (PyCFunction)array_zeros,
-     METH_VARARGS|METH_KEYWORDS, NULL},
-    {"empty",       (PyCFunction)array_empty,
-     METH_VARARGS|METH_KEYWORDS, NULL},
-    {"scalar",      (PyCFunction)array_scalar,
-     METH_VARARGS|METH_KEYWORDS, NULL},
-    {"where",  (PyCFunction)array_where,
-     METH_VARARGS, NULL},
-    {"lexsort", (PyCFunction)array_lexsort,
-     METH_VARARGS | METH_KEYWORDS, NULL},
-    {"putmask", (PyCFunction)array_putmask,
-     METH_VARARGS | METH_KEYWORDS, NULL},
-    {"fromstring",(PyCFunction)array_fromstring,
-     METH_VARARGS|METH_KEYWORDS, NULL},
-    {"fromiter",(PyCFunction)array_fromiter,
-     METH_VARARGS|METH_KEYWORDS, NULL},
-    {"concatenate", (PyCFunction)array_concatenate,
-     METH_VARARGS|METH_KEYWORDS, NULL},
-    {"inner", (PyCFunction)array_innerproduct,
-     METH_VARARGS, NULL},
-    {"dot", (PyCFunction)array_matrixproduct,
-     METH_VARARGS, NULL},
-    {"_fastCopyAndTranspose", (PyCFunction)array_fastCopyAndTranspose,
-     METH_VARARGS, NULL},
-    {"correlate", (PyCFunction)array_correlate,
-     METH_VARARGS | METH_KEYWORDS, NULL},
-    {"frombuffer", (PyCFunction)array_frombuffer,
-     METH_VARARGS | METH_KEYWORDS, NULL},
-    {"fromfile", (PyCFunction)array_fromfile,
-     METH_VARARGS | METH_KEYWORDS, NULL},
-    {"can_cast", (PyCFunction)array_can_cast_safely,
-     METH_VARARGS | METH_KEYWORDS, NULL},
-    {"newbuffer", (PyCFunction)new_buffer,
-     METH_VARARGS, NULL},
-    {"getbuffer", (PyCFunction)buffer_buffer,
-     METH_VARARGS | METH_KEYWORDS, NULL},
-    {"int_asbuffer", (PyCFunction)as_buffer,
-     METH_VARARGS | METH_KEYWORDS, NULL},
-    {"format_longfloat", (PyCFunction)format_longfloat,
-     METH_VARARGS | METH_KEYWORDS, NULL},
-    {"compare_chararrays", (PyCFunction)compare_chararrays,
-     METH_VARARGS | METH_KEYWORDS, NULL},
-    {"test_interrupt", (PyCFunction)test_interrupt,
-     METH_VARARGS, NULL},
+    {"array",
+        (PyCFunction)_array_fromobject,
+        METH_VARARGS|METH_KEYWORDS, NULL},
+    {"arange",
+        (PyCFunction)array_arange,
+        METH_VARARGS|METH_KEYWORDS, NULL},
+    {"zeros",
+        (PyCFunction)array_zeros,
+        METH_VARARGS|METH_KEYWORDS, NULL},
+    {"empty",
+        (PyCFunction)array_empty,
+        METH_VARARGS|METH_KEYWORDS, NULL},
+    {"scalar",
+        (PyCFunction)array_scalar,
+        METH_VARARGS|METH_KEYWORDS, NULL},
+    {"where",
+        (PyCFunction)array_where,
+        METH_VARARGS, NULL},
+    {"lexsort",
+        (PyCFunction)array_lexsort,
+        METH_VARARGS | METH_KEYWORDS, NULL},
+    {"putmask",
+        (PyCFunction)array_putmask,
+        METH_VARARGS | METH_KEYWORDS, NULL},
+    {"fromstring",
+        (PyCFunction)array_fromstring,
+        METH_VARARGS|METH_KEYWORDS, NULL},
+    {"fromiter",
+        (PyCFunction)array_fromiter,
+        METH_VARARGS|METH_KEYWORDS, NULL},
+    {"concatenate",
+        (PyCFunction)array_concatenate,
+        METH_VARARGS|METH_KEYWORDS, NULL},
+    {"inner",
+        (PyCFunction)array_innerproduct,
+        METH_VARARGS, NULL},
+    {"dot",
+        (PyCFunction)array_matrixproduct,
+        METH_VARARGS, NULL},
+    {"_fastCopyAndTranspose",
+        (PyCFunction)array_fastCopyAndTranspose,
+        METH_VARARGS, NULL},
+    {"correlate",
+        (PyCFunction)array_correlate,
+        METH_VARARGS | METH_KEYWORDS, NULL},
+    {"frombuffer",
+        (PyCFunction)array_frombuffer,
+        METH_VARARGS | METH_KEYWORDS, NULL},
+    {"fromfile",
+        (PyCFunction)array_fromfile,
+        METH_VARARGS | METH_KEYWORDS, NULL},
+    {"can_cast",
+        (PyCFunction)array_can_cast_safely,
+        METH_VARARGS | METH_KEYWORDS, NULL},
+    {"newbuffer",
+        (PyCFunction)new_buffer,
+        METH_VARARGS, NULL},
+    {"getbuffer",
+        (PyCFunction)buffer_buffer,
+        METH_VARARGS | METH_KEYWORDS, NULL},
+    {"int_asbuffer",
+        (PyCFunction)as_buffer,
+        METH_VARARGS | METH_KEYWORDS, NULL},
+    {"format_longfloat",
+        (PyCFunction)format_longfloat,
+        METH_VARARGS | METH_KEYWORDS, NULL},
+    {"compare_chararrays",
+        (PyCFunction)compare_chararrays,
+        METH_VARARGS | METH_KEYWORDS, NULL},
+    {"test_interrupt",
+        (PyCFunction)test_interrupt,
+        METH_VARARGS, NULL},
     {NULL, NULL, 0, NULL}                /* sentinel */
 };
 
 #include "__multiarray_api.c"
 
-/* Establish scalar-type hierarchy */
-
-/*  For dual inheritance we need to make sure that the objects being
-    inherited from have the tp->mro object initialized.  This is
-    not necessarily true for the basic type objects of Python (it is
-    checked for single inheritance but not dual in PyType_Ready).
-
-    Thus, we call PyType_Ready on the standard Python Types, here.
-*/
+/* Establish scalar-type hierarchy
+ *
+ *  For dual inheritance we need to make sure that the objects being
+ *  inherited from have the tp->mro object initialized.  This is
+ *  not necessarily true for the basic type objects of Python (it is
+ *  checked for single inheritance but not dual in PyType_Ready).
+ *
+ *  Thus, we call PyType_Ready on the standard Python Types, here.
+ */
 static int
 setup_scalartypes(PyObject *NPY_UNUSED(dict))
 {
-
     initialize_numeric_types();
 
-    if (PyType_Ready(&PyBool_Type) < 0) return -1;
-    if (PyType_Ready(&PyInt_Type) < 0) return -1;
-    if (PyType_Ready(&PyFloat_Type) < 0) return -1;
-    if (PyType_Ready(&PyComplex_Type) < 0) return -1;
-    if (PyType_Ready(&PyString_Type) < 0) return -1;
-    if (PyType_Ready(&PyUnicode_Type) < 0) return -1;
+    if (PyType_Ready(&PyBool_Type) < 0) {
+        return -1;
+    }
+    if (PyType_Ready(&PyInt_Type) < 0) {
+        return -1;
+    }
+    if (PyType_Ready(&PyFloat_Type) < 0) {
+        return -1;
+    }
+    if (PyType_Ready(&PyComplex_Type) < 0) {
+        return -1;
+    }
+    if (PyType_Ready(&PyString_Type) < 0) {
+        return -1;
+    }
+    if (PyType_Ready(&PyUnicode_Type) < 0) {
+        return -1;
+    }
 
 #define SINGLE_INHERIT(child, parent)                                   \
     Py##child##ArrType_Type.tp_base = &Py##parent##ArrType_Type;        \
@@ -7915,9 +8305,9 @@
         return -1;                                                      \
     }
 
-    if (PyType_Ready(&PyGenericArrType_Type) < 0)
+    if (PyType_Ready(&PyGenericArrType_Type) < 0) {
         return -1;
-
+    }
     SINGLE_INHERIT(Number, Generic);
     SINGLE_INHERIT(Integer, Number);
     SINGLE_INHERIT(Inexact, Number);
@@ -7975,7 +8365,11 @@
     SINGLE_INHERIT(LongLong, SignedInteger);
 #endif
 
-    /* fprintf(stderr, "tp_free = %p, PyObject_Del = %p, int_tp_free = %p, base.tp_free = %p\n", PyIntArrType_Type.tp_free, PyObject_Del, PyInt_Type.tp_free, PySignedIntegerArrType_Type.tp_free);
+    /*
+       fprintf(stderr,
+        "tp_free = %p, PyObject_Del = %p, int_tp_free = %p, base.tp_free = %p\n",
+         PyIntArrType_Type.tp_free, PyObject_Del, PyInt_Type.tp_free,
+         PySignedIntegerArrType_Type.tp_free);
      */
     SINGLE_INHERIT(UByte, UnsignedInteger);
     SINGLE_INHERIT(UShort, UnsignedInteger);
@@ -8003,9 +8397,10 @@
 #undef SINGLE_INHERIT
 #undef DUAL_INHERIT
 
-    /* Clean up string and unicode array types so they act more like
-       strings -- get their tables from the standard types.
-    */
+    /*
+     * Clean up string and unicode array types so they act more like
+     * strings -- get their tables from the standard types.
+     */
 }
 
 /* place a flag dictionary in d */
@@ -8057,45 +8452,48 @@
 
     /* Create the module and add the functions */
     m = Py_InitModule("multiarray", array_module_methods);
-    if (!m) goto err;
-
+    if (!m) {
+        goto err;
+    }
     /* Add some symbolic constants to the module */
     d = PyModule_GetDict(m);
-    if (!d) goto err;
-
+    if (!d) {
+        goto err;
+    }
     PyArray_Type.tp_free = _pya_free;
-    if (PyType_Ready(&PyArray_Type) < 0)
+    if (PyType_Ready(&PyArray_Type) < 0) {
         return;
-
-    if (setup_scalartypes(d) < 0) goto err;
-
+    }
+    if (setup_scalartypes(d) < 0) {
+        goto err;
+    }
     PyArrayIter_Type.tp_iter = PyObject_SelfIter;
     PyArrayMultiIter_Type.tp_iter = PyObject_SelfIter;
     PyArrayMultiIter_Type.tp_free = _pya_free;
-    if (PyType_Ready(&PyArrayIter_Type) < 0)
+    if (PyType_Ready(&PyArrayIter_Type) < 0) {
         return;
-
-    if (PyType_Ready(&PyArrayMapIter_Type) < 0)
+    }
+    if (PyType_Ready(&PyArrayMapIter_Type) < 0) {
         return;
-
-    if (PyType_Ready(&PyArrayMultiIter_Type) < 0)
+    }
+    if (PyType_Ready(&PyArrayMultiIter_Type) < 0) {
         return;
-
+    }
     PyArrayDescr_Type.tp_hash = (hashfunc)_Py_HashPointer;
-    if (PyType_Ready(&PyArrayDescr_Type) < 0)
+    if (PyType_Ready(&PyArrayDescr_Type) < 0) {
         return;
-
-    if (PyType_Ready(&PyArrayFlags_Type) < 0)
+    }
+    if (PyType_Ready(&PyArrayFlags_Type) < 0) {
         return;
-
+    }
     c_api = PyCObject_FromVoidPtr((void *)PyArray_API, NULL);
     PyDict_SetItemString(d, "_ARRAY_API", c_api);
     Py_DECREF(c_api);
-    if (PyErr_Occurred()) goto err;
-
+    if (PyErr_Occurred()) {
+        goto err;
+    }
     MultiArrayError = PyString_FromString ("multiarray.error");
     PyDict_SetItemString (d, "error", MultiArrayError);
-
     s = PyString_FromString("3.0");
     PyDict_SetItemString(d, "__version__", s);
     Py_DECREF(s);
@@ -8138,7 +8536,9 @@
 
     set_flaginfo(d);
 
-    if (set_typeinfo(d) != 0) goto err;
+    if (set_typeinfo(d) != 0) {
+        goto err;
+    }
     return;
 
  err:



More information about the Numpy-svn mailing list