usage of bool

Author: flexatone

arraymap.c

@@ -29,28 +29,24 @@ static PyTypeObject FAMVType;
 static PyTypeObject FAMType;
 static PyObject *NonUniqueError;
 
-
 // The main storage "table" is an array of TableElement
 typedef struct TableElement{
     Py_ssize_t keys_pos;
     Py_hash_t hash;
 } TableElement;
 
-
 // Table configuration; experimentation shows that these values work well:
 # define LOAD 0.9
 # define SCAN 16
 
 const static size_t UCS4_SIZE = sizeof(Py_UCS4);
 
-
 // Partial, two-argument version of PyUnicode_FromKindAndData for consistent templating with bytes version.
 static inline PyObject*
 PyUnicode_FromUCS4AndData(const void *buffer, Py_ssize_t size) {
     return PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buffer, size);
 }
 
-
 typedef enum KeysArrayType{
     KAT_LIST = 0, // must be falsy
 
@@ -85,27 +81,22 @@ typedef enum KeysArrayType{
     KAT_DTps,
     KAT_DTfs,
     KAT_DTas,
-
 } KeysArrayType;
 
-
 NPY_DATETIMEUNIT
 dt_unit_from_array(PyArrayObject* a) {
     // This is based on get_datetime_metadata_from_dtype in the NumPy source, but that function is private. This does not check that the dytpe is of the appropriate type.
     PyArray_DatetimeMetaData* dma = &(((PyArray_DatetimeDTypeMetaData *)PyArray_DESCR(a)->c_metadata)->meta);
     return dma->base;
 }
 
-
 NPY_DATETIMEUNIT
 dt_unit_from_scalar(PyDatetimeScalarObject* dts) {
     // Based on convert_pyobject_to_datetime and related usage in datetime.c
     PyArray_DatetimeMetaData* dma = &(dts->obmeta);
     return dma->base;
 }
 
-
-
 KeysArrayType
 at_to_kat(int array_t, PyArrayObject* a) {
     switch (array_t) {
@@ -178,8 +169,7 @@ at_to_kat(int array_t, PyArrayObject* a) {
     }
 }
 
-
-// To determine when we can use direct array lookups, this function return 1 if we match, 0 if we do not match. Given a keys array type and the kind of lookup key, return true only for the largest KAT types.s
+// To determine when we can use direct array lookups, this function return 1 if we match, 0 if we do not match. Given a keys array type and the kind of lookup key, return true only for the largest KAT types.
 int
 kat_is_kind(KeysArrayType kat, char kind) {
     switch (kat) {
@@ -226,52 +216,52 @@ kat_is_kind(KeysArrayType kat, char kind) {
 }
 
 // Given a KAT, determine if it matches a NumPy dt64 unit.
-int
+bool
 kat_is_datetime_unit(KeysArrayType kat, NPY_DATETIMEUNIT unit) {
     switch (kat) {
         case KAT_DTY:
-            if (unit == NPY_FR_Y ) {return 1;}
+            if (unit == NPY_FR_Y ) {return true;}
             break;
         case KAT_DTM:
-            if (unit == NPY_FR_M ) {return 1;}
+            if (unit == NPY_FR_M ) {return true;}
             break;
         case KAT_DTW:
-            if (unit == NPY_FR_W ) {return 1;}
+            if (unit == NPY_FR_W ) {return true;}
             break;
         case KAT_DTD:
-            if (unit == NPY_FR_D ) {return 1;}
+            if (unit == NPY_FR_D ) {return true;}
             break;
         case KAT_DTh:
-            if (unit == NPY_FR_h ) {return 1;}
+            if (unit == NPY_FR_h ) {return true;}
             break;
         case KAT_DTm:
-            if (unit == NPY_FR_m ) {return 1;}
+            if (unit == NPY_FR_m ) {return true;}
             break;
         case KAT_DTs:
-            if (unit == NPY_FR_s ) {return 1;}
+            if (unit == NPY_FR_s ) {return true;}
             break;
         case KAT_DTms:
-            if (unit == NPY_FR_ms) {return 1;}
+            if (unit == NPY_FR_ms) {return true;}
             break;
         case KAT_DTus:
-            if (unit == NPY_FR_us) {return 1;}
+            if (unit == NPY_FR_us) {return true;}
             break;
         case KAT_DTns:
-            if (unit == NPY_FR_ns) {return 1;}
+            if (unit == NPY_FR_ns) {return true;}
             break;
         case KAT_DTps:
-            if (unit == NPY_FR_ps) {return 1;}
+            if (unit == NPY_FR_ps) {return true;}
             break;
         case KAT_DTfs:
-            if (unit == NPY_FR_fs) {return 1;}
+            if (unit == NPY_FR_fs) {return true;}
             break;
         case KAT_DTas:
-            if (unit == NPY_FR_as) {return 1;}
+            if (unit == NPY_FR_as) {return true;}
             break;
         default: // non dt64 KATs
-            return 0;
+            return false;
     }
-    return 0;
+    return false;
 }
 
 typedef struct FAMObject{
@@ -284,14 +274,12 @@ typedef struct FAMObject{
     Py_UCS4* key_buffer;
 } FAMObject;
 
-
 typedef enum ViewKind{
     ITEMS,
     KEYS,
     VALUES,
 } ViewKind;
 
-
 // Return the end pointer, or the pointer to the location after the last valid character. The end pointer minus the start pointer is the number of characters. For an empty string, all characters are NULL, and the start pointer and end pointer should be equal. NOTE: would like to use strchr(str, '\0') instead of this routine, but some buffers might not have a null terminator and stread by full to the the dt_size.
 static inline Py_UCS4*
 ucs4_get_end_p(Py_UCS4* p_start, Py_ssize_t dt_size) {
@@ -303,7 +291,6 @@ ucs4_get_end_p(Py_UCS4* p_start, Py_ssize_t dt_size) {
     return p_start;
 }
 
-
 static inline char*
 char_get_end_p(char* p_start, Py_ssize_t dt_size) {
     for (char* p = p_start + dt_size - 1; p >= p_start; p--) {
@@ -314,7 +301,6 @@ char_get_end_p(char* p_start, Py_ssize_t dt_size) {
     return p_start;
 }
 
-
 // This masks the input with INT64_MAX, which removes the MSB; we then cast to an int64; the range is now between 0 and INT64_MAX. We then use the MSB of the original value; if set, we negate the number, producing negative values for the upper half of the uint64 range. Note that we only need to check for hash -1 in this branch.
 static inline Py_hash_t
 uint_to_hash(npy_uint64 v) {
@@ -337,7 +323,6 @@ int_to_hash(npy_int64 v) {
     return hash;
 }
 
-
 // This is a adapted from https://github.com/python/cpython/blob/ba65a065cf07a7a9f53be61057a090f7311a5ad7/Python/pyhash.c#L92
 #define HASH_MODULUS (((size_t)1 << 61) - 1)
 #define HASH_BITS 61
@@ -379,7 +364,6 @@ double_to_hash(double v)
     return (Py_hash_t)x;
 }
 
-
 // The `str` arg is a pointer to a C-array of Py_UCS4; we will only read `len` characters from this. This is a "djb2" hash algorithm.
 static inline Py_hash_t
 unicode_to_hash(Py_UCS4 *str, Py_ssize_t len) {
@@ -395,7 +379,6 @@ unicode_to_hash(Py_UCS4 *str, Py_ssize_t len) {
     return hash;
 }
 
-
 static inline Py_hash_t
 string_to_hash(char *str, Py_ssize_t len) {
     char* p = str;
@@ -410,17 +393,14 @@ string_to_hash(char *str, Py_ssize_t len) {
     return hash;
 }
 
-
 //------------------------------------------------------------------------------
 // the global int_cache is shared among all instances
 
 static PyObject *int_cache = NULL;
 
-
 // NOTE: this used to be a Py_ssize_t, which can be 32 bits on some machines and might easily overflow with a few very large indices. Using an explicit 64-bit int seems safer
 static npy_int64 key_count_global = 0;
 
-
 // Fill the int_cache up to size_needed with PyObject ints; `size` is not the key_count_global.
 static int
 int_cache_fill(Py_ssize_t size_needed)
@@ -446,7 +426,6 @@ int_cache_fill(Py_ssize_t size_needed)
     return 0;
 }
 
-
 // Given the current key_count_global, remove cache elements only if the key_count is less than the the current size of the int_cache.
 void
 int_cache_remove(Py_ssize_t key_count)
@@ -460,7 +439,6 @@ int_cache_remove(Py_ssize_t key_count)
     }
 }
 
-
 //------------------------------------------------------------------------------
 // FrozenAutoMapIterator functions
 
@@ -469,7 +447,7 @@ typedef struct FAMIObject {
     FAMObject *fam;
     PyArrayObject* keys_array;
     ViewKind kind;
-    int reversed;
+    bool reversed;
     Py_ssize_t index; // current index state, mutated in-place
 } FAMIObject;
 
@@ -481,15 +459,13 @@ fami_dealloc(FAMIObject *self)
     PyObject_Del((PyObject *)self);
 }
 
-
 static FAMIObject *
 fami_iter(FAMIObject *self)
 {
     Py_INCREF(self);
     return self;
 }
 
-
 // For a FAMI, Return appropriate PyObject for items, keys, and values. When values are needed they are retrieved from the int_cache. For consistency with NumPy array iteration, arrays use PyArray_ToScalar instead of PyArray_GETITEM.
 static PyObject *
 fami_iternext(FAMIObject *self)
@@ -543,32 +519,27 @@ fami_iternext(FAMIObject *self)
     Py_UNREACHABLE();
 }
 
-
 static PyObject *
 fami_length_hint(FAMIObject *self)
 {
     Py_ssize_t len = Py_MAX(0, self->fam->keys_size - self->index);
     return PyLong_FromSsize_t(len);
 }
 
-
-static PyObject *fami_new(FAMObject *, ViewKind, int);
-
+static PyObject *fami_new(FAMObject *, ViewKind, bool);
 
 static PyObject *
 fami_reversed(FAMIObject *self)
 {
     return fami_new(self->fam, self->kind, !self->reversed);
 }
 
-
 static PyMethodDef fami_methods[] = {
     {"__length_hint__", (PyCFunction)fami_length_hint, METH_NOARGS, NULL},
     {"__reversed__", (PyCFunction)fami_reversed, METH_NOARGS, NULL},
     {NULL},
 };
 
-
 static PyTypeObject FAMIType = {
     PyVarObject_HEAD_INIT(NULL, 0)
     .tp_basicsize = sizeof(FAMIObject),
@@ -581,7 +552,7 @@ static PyTypeObject FAMIType = {
 
 
 static PyObject *
-fami_new(FAMObject *fam, ViewKind kind, int reversed)
+fami_new(FAMObject *fam, ViewKind kind, bool reversed)
 {
     FAMIObject *fami = PyObject_New(FAMIObject, &FAMIType);
     if (!fami) {
@@ -683,7 +654,7 @@ famv_dealloc(FAMVObject *self)
 static PyObject *
 famv_fami_new(FAMVObject *self)
 {
-    return fami_new(self->fam, self->kind, 0);
+    return fami_new(self->fam, self->kind, false);
 }
 
 
@@ -697,7 +668,7 @@ famv_length_hint(FAMVObject *self)
 static PyObject *
 famv_reversed(FAMVObject *self)
 {
-    return fami_new(self->fam, self->kind, 1);
+    return fami_new(self->fam, self->kind, true);
 }
 
 
@@ -755,7 +726,7 @@ static PyTypeObject FAMVType = {
 
 
 static PyObject *
-famv_new(FAMObject *fam, int kind)
+famv_new(FAMObject *fam, ViewKind kind)
 {
     FAMVObject *famv = (FAMVObject *)PyObject_New(FAMVObject, &FAMVType);
     if (!famv) {
@@ -2297,7 +2268,7 @@ fam_hash(FAMObject *self)
 static PyObject *
 fam_iter(FAMObject *self)
 {
-    return fami_new(self, KEYS, 0);
+    return fami_new(self, KEYS, false);
 }
 
 
@@ -2311,7 +2282,7 @@ fam_getnewargs(FAMObject *self)
 static PyObject *
 fam_reversed(FAMObject *self)
 {
-    return fami_new(self, KEYS, 1);
+    return fami_new(self, KEYS, true);
 }