rename len to size in npy_static_string struct

ngoldbaum · ngoldbaum · commit 7ea409b9fe9f · 2023-09-13T09:18:27.000-06:00
diff --git a/stringdtype/stringdtype/src/casts.c b/stringdtype/stringdtype/src/casts.c
@@ -209,8 +209,8 @@ unicode_to_string(PyArrayMethod_Context *context, char *const data[],
         }
         npy_static_string *out_ss = (npy_static_string *)out;
         npy_string_free(out_ss);
-        if (npy_string_newemptylen(out_num_bytes, out_ss) < 0) {
-            gil_error(PyExc_MemoryError, "npy_string_newemptylen failed");
+        if (npy_string_newemptysize(out_num_bytes, out_ss) < 0) {
+            gil_error(PyExc_MemoryError, "npy_string_newemptysize failed");
             return -1;
         }
         char *out_buf = out_ss->buf;
@@ -342,16 +342,16 @@ string_to_unicode(PyArrayMethod_Context *context, char *const data[],
             if (has_null && !has_string_na) {
                 // lossy but not much else we can do
                 this_string = (unsigned char *)descr->na_name.buf;
-                n_bytes = descr->na_name.len;
+                n_bytes = descr->na_name.size;
             }
             else {
                 this_string = (unsigned char *)(default_string.buf);
-                n_bytes = default_string.len;
+                n_bytes = default_string.size;
             }
         }
         else {
             this_string = (unsigned char *)(s->buf);
-            n_bytes = s->len;
+            n_bytes = s->size;
         }
         size_t tot_n_bytes = 0;
 
@@ -440,10 +440,10 @@ string_to_bool(PyArrayMethod_Context *context, char *const data[],
                 *out = (npy_bool)1;
             }
             else {
-                *out = (npy_bool)(default_string.len == 0);
+                *out = (npy_bool)(default_string.size == 0);
             }
         }
-        else if (s->len == 0) {
+        else if (s->size == 0) {
             *out = (npy_bool)0;
         }
         else {
@@ -482,14 +482,14 @@ bool_to_string(PyArrayMethod_Context *NPY_UNUSED(context), char *const data[],
         npy_static_string *out_ss = (npy_static_string *)out;
         npy_string_free(out_ss);
         if ((npy_bool)(*in) == 1) {
-            if (npy_string_newlen("True", 4, out_ss) < 0) {
-                gil_error(PyExc_MemoryError, "npy_string_newlen failed");
+            if (npy_string_newsize("True", 4, out_ss) < 0) {
+                gil_error(PyExc_MemoryError, "npy_string_newsize failed");
                 return -1;
             }
         }
         else if ((npy_bool)(*in) == 0) {
-            if (npy_string_newlen("False", 5, out_ss) < 0) {
-                gil_error(PyExc_MemoryError, "npy_string_newlen failed");
+            if (npy_string_newsize("False", 5, out_ss) < 0) {
+                gil_error(PyExc_MemoryError, "npy_string_newsize failed");
                 return -1;
             }
         }
@@ -527,7 +527,7 @@ string_to_pylong(char *in, int hasnull)
         }
         s = &EMPTY_STRING;
     }
-    PyObject *val_obj = PyUnicode_FromStringAndSize(s->buf, s->len);
+    PyObject *val_obj = PyUnicode_FromStringAndSize(s->buf, s->size);
     if (val_obj == NULL) {
         return NULL;
     }
@@ -587,8 +587,8 @@ pyobj_to_string(PyObject *obj, char *out)
     }
     npy_static_string *out_ss = (npy_static_string *)out;
     npy_string_free(out_ss);
-    if (npy_string_newlen(cstr_val, length, out_ss) < 0) {
-        PyErr_SetString(PyExc_MemoryError, "npy_string_newlen failed");
+    if (npy_string_newsize(cstr_val, length, out_ss) < 0) {
+        PyErr_SetString(PyExc_MemoryError, "npy_string_newsize failed");
         Py_DECREF(pystr_val);
         return -1;
     }
@@ -779,7 +779,7 @@ string_to_pyfloat(char *in, int hasnull)
         }
         s = &EMPTY_STRING;
     }
-    PyObject *val_obj = PyUnicode_FromStringAndSize(s->buf, s->len);
+    PyObject *val_obj = PyUnicode_FromStringAndSize(s->buf, s->size);
     if (val_obj == NULL) {
         return NULL;
     }
@@ -1004,7 +1004,7 @@ string_to_datetime(PyArrayMethod_Context *context, char *const data[],
             s = &default_string;
         }
         if (NpyDatetime_ParseISO8601Datetime(
-                    (const char *)s->buf, s->len, in_unit, NPY_UNSAFE_CASTING,
+                    (const char *)s->buf, s->size, in_unit, NPY_UNSAFE_CASTING,
                     &dts, &in_meta.base, &out_special) < 0) {
             return -1;
         }
@@ -1072,9 +1072,10 @@ datetime_to_string(PyArrayMethod_Context *context, char *const data[],
                 return -1;
             }
 
-            if (npy_string_newlen(datetime_buf, strlen(datetime_buf), out_ss) <
-                0) {
-                PyErr_SetString(PyExc_MemoryError, "npy_string_newlen failed");
+            if (npy_string_newsize(datetime_buf, strlen(datetime_buf),
+                                   out_ss) < 0) {
+                PyErr_SetString(PyExc_MemoryError,
+                                "npy_string_newsize failed");
                 return -1;
             }
         }
diff --git a/stringdtype/stringdtype/src/dtype.c b/stringdtype/stringdtype/src/dtype.c
@@ -32,7 +32,7 @@ new_stringdtype_instance(PyObject *na_object, int coerce)
             Py_ssize_t size = 0;
             const char *buf = PyUnicode_AsUTF8AndSize(na_object, &size);
             default_string = NULL_STRING;
-            int res = npy_string_newlen(buf, (size_t)size, &default_string);
+            int res = npy_string_newsize(buf, (size_t)size, &default_string);
             if (res == -1) {
                 PyErr_NoMemory();
                 Py_DECREF(new);
@@ -72,7 +72,7 @@ new_stringdtype_instance(PyObject *na_object, int coerce)
 
         Py_ssize_t size = 0;
         const char *utf8_ptr = PyUnicode_AsUTF8AndSize(na_pystr, &size);
-        int res = npy_string_newlen(utf8_ptr, (size_t)size, &na_name);
+        int res = npy_string_newsize(utf8_ptr, (size_t)size, &na_name);
         if (res == -1) {
             PyErr_NoMemory();
             Py_DECREF(new);
@@ -224,7 +224,7 @@ stringdtype_setitem(StringDTypeObject *descr, PyObject *obj, char **dataptr)
         }
 
         // copies contents of val into item_val->buf
-        int res = npy_string_newlen(val, length, sdata);
+        int res = npy_string_newsize(val, length, sdata);
 
         if (res == -1) {
             PyErr_NoMemory();
@@ -261,8 +261,8 @@ stringdtype_getitem(StringDTypeObject *descr, char **dataptr)
     }
     else {
         char *data = sdata->buf;
-        size_t len = sdata->len;
-        val_obj = PyUnicode_FromStringAndSize(data, len);
+        size_t size = sdata->size;
+        val_obj = PyUnicode_FromStringAndSize(data, size);
         if (val_obj == NULL) {
             return NULL;
         }
@@ -287,7 +287,7 @@ stringdtype_getitem(StringDTypeObject *descr, char **dataptr)
 npy_bool
 nonzero(void *data, void *NPY_UNUSED(arr))
 {
-    return ((npy_static_string *)data)->len != 0;
+    return ((npy_static_string *)data)->size != 0;
 }
 
 // Implementation of PyArray_CompareFunc.
@@ -421,7 +421,7 @@ stringdtype_fill_zero_loop(void *NPY_UNUSED(traverse_context),
                            NpyAuxData *NPY_UNUSED(auxdata))
 {
     while (size--) {
-        if (npy_string_newlen("", 0, (npy_static_string *)(data)) < 0) {
+        if (npy_string_newsize("", 0, (npy_static_string *)(data)) < 0) {
             return -1;
         }
         data += stride;
diff --git a/stringdtype/stringdtype/src/main.c b/stringdtype/stringdtype/src/main.c
@@ -58,7 +58,7 @@ _memory_usage(PyObject *NPY_UNUSED(self), PyObject *obj)
         npy_intp count = *innersizeptr;
 
         while (count--) {
-            memory_usage += ((npy_static_string *)in)->len;
+            memory_usage += ((npy_static_string *)in)->size;
             in += stride;
         }
 
diff --git a/stringdtype/stringdtype/src/static_string.c b/stringdtype/stringdtype/src/static_string.c
@@ -9,26 +9,26 @@ const npy_static_string EMPTY_STRING = {0, "\0"};
 const npy_static_string NULL_STRING = {0, NULL};
 
 int
-npy_string_newlen(const char *init, size_t len, npy_static_string *to_init)
+npy_string_newsize(const char *init, size_t size, npy_static_string *to_init)
 {
-    if ((to_init == NULL) || (to_init->buf != NULL) || (to_init->len != 0)) {
+    if ((to_init == NULL) || (to_init->buf != NULL) || (to_init->size != 0)) {
         return -2;
     }
 
-    if (len == 0) {
+    if (size == 0) {
         *to_init = EMPTY_STRING;
         return 0;
     }
 
-    char *ret_buf = (char *)PyMem_RawMalloc(sizeof(char) * len);
+    char *ret_buf = (char *)PyMem_RawMalloc(sizeof(char) * size);
 
     if (ret_buf == NULL) {
         return -1;
     }
 
-    to_init->len = len;
+    to_init->size = size;
 
-    memcpy(ret_buf, init, len);
+    memcpy(ret_buf, init, size);
 
     to_init->buf = ret_buf;
 
@@ -42,37 +42,37 @@ npy_string_free(npy_static_string *str)
         PyMem_RawFree(str->buf);
         str->buf = NULL;
     }
-    str->len = 0;
+    str->size = 0;
 }
 
 int
 npy_string_dup(const npy_static_string *in, npy_static_string *out)
 {
     if (npy_string_isnull(in)) {
-        out->len = 0;
+        out->size = 0;
         out->buf = NULL;
         return 0;
     }
     else {
-        return npy_string_newlen(in->buf, in->len, out);
+        return npy_string_newsize(in->buf, in->size, out);
     }
 }
 
 int
-npy_string_newemptylen(size_t num_bytes, npy_static_string *out)
+npy_string_newemptysize(size_t size, npy_static_string *out)
 {
-    if (out->len != 0 || out->buf != NULL) {
+    if (out->size != 0 || out->buf != NULL) {
         return -2;
     }
 
-    out->len = num_bytes;
+    out->size = size;
 
-    if (num_bytes == 0) {
+    if (size == 0) {
         *out = EMPTY_STRING;
         return 0;
     }
 
-    char *buf = (char *)PyMem_RawMalloc(sizeof(char) * num_bytes);
+    char *buf = (char *)PyMem_RawMalloc(sizeof(char) * size);
 
     if (buf == NULL) {
         return -1;
@@ -86,15 +86,15 @@ npy_string_newemptylen(size_t num_bytes, npy_static_string *out)
 int
 npy_string_cmp(const npy_static_string *s1, const npy_static_string *s2)
 {
-    size_t minlen = s1->len < s2->len ? s1->len : s2->len;
+    size_t minsize = s1->size < s2->size ? s1->size : s2->size;
 
-    int cmp = strncmp(s1->buf, s2->buf, minlen);
+    int cmp = strncmp(s1->buf, s2->buf, minsize);
 
     if (cmp == 0) {
-        if (s1->len > minlen) {
+        if (s1->size > minsize) {
             return 1;
         }
-        if (s2->len > minlen) {
+        if (s2->size > minsize) {
             return -1;
         }
     }
@@ -105,7 +105,7 @@ npy_string_cmp(const npy_static_string *s1, const npy_static_string *s2)
 int
 npy_string_isnull(const npy_static_string *in)
 {
-    if (in->len == 0 && in->buf == NULL) {
+    if (in->size == 0 && in->buf == NULL) {
         return 1;
     }
     return 0;
diff --git a/stringdtype/stringdtype/src/static_string.h b/stringdtype/stringdtype/src/static_string.h
@@ -5,7 +5,7 @@
 #include "string.h"
 
 typedef struct npy_static_string {
-    size_t len;
+    size_t size;
     char *buf;
 } npy_static_string;
 
@@ -18,10 +18,11 @@ extern const npy_static_string EMPTY_STRING;
 extern const npy_static_string NULL_STRING;
 
 // Allocates a new buffer for *to_init*, filling with the copied contents of
-// *init* and sets *to_init->len* to *len*. Returns -1 if malloc fails and -2
-// if *to_init* is not empty. Returns 0 on success.
+// the first *size*entries in *init*, which must be valid and initialized
+// beforehand, and sets *to_init->size* to *size*. Returns -1 if malloc fails
+// and -2 if *to_init* is not NULL. Returns 0 on success.
 int
-npy_string_newlen(const char *init, size_t len, npy_static_string *to_init);
+npy_string_newsize(const char *init, size_t size, npy_static_string *to_init);
 
 // Sets len to 0 and if str->buf is not already NULL, frees it and sets it to
 // NULL. Cannot fail.
@@ -36,12 +37,11 @@ int
 npy_string_dup(const npy_static_string *in, npy_static_string *out);
 
 // Allocates a new string buffer for *out* with enough capacity to store
-// *num_bytes* of text. The actual allocation is num_bytes + 1 bytes, to
-// account for the null terminator. Does not do any initialization, the caller
-// must initialize and null-terminate the string buffer. Returns -1 if malloc
-// fails and -2 if *out* is not empty. Returns 0 on success.
+// *size* bytes of text. Does not do any initialization, the caller must
+// initialize the string buffer. Returns -1 if malloc fails and -2 if *out* is
+// not NULL. Returns 0 on success.
 int
-npy_string_newemptylen(size_t num_bytes, npy_static_string *out);
+npy_string_newemptysize(size_t size, npy_static_string *out);
 
 // Determine if *in* corresponds to a NULL npy_static_string struct (e.g. len
 // is zero and buf is NULL. Returns 1 if this is the case and zero otherwise.
diff --git a/stringdtype/stringdtype/src/umath.c b/stringdtype/stringdtype/src/umath.c
@@ -67,16 +67,16 @@ multiply_resolve_descriptors(
                 }                                                             \
             }                                                                 \
             npy_##shortname factor = *(npy_##shortname *)iin;                 \
-            size_t newlen = (size_t)((is->len) * factor);                     \
+            size_t newsize = (size_t)((is->size) * factor);                   \
                                                                               \
-            if (npy_string_newemptylen(newlen, os) < 0) {                     \
+            if (npy_string_newemptysize(newsize, os) < 0) {                   \
                 gil_error(PyExc_MemoryError,                                  \
-                          "npy_string_newemptylen failed");                   \
+                          "npy_string_newemptysize failed");                  \
                 return -1;                                                    \
             }                                                                 \
                                                                               \
             for (size_t i = 0; i < (size_t)factor; i++) {                     \
-                memcpy(os->buf + i * is->len, is->buf, is->len);              \
+                memcpy(os->buf + i * is->size, is->buf, is->size);            \
             }                                                                 \
                                                                               \
             sin += s_stride;                                                  \
@@ -215,7 +215,7 @@ add_strided_loop(PyArrayMethod_Context *context, char *const data[],
     npy_static_string *os = NULL;
 
     while (N--) {
-        int newlen = 0;
+        int newsize = 0;
         s1 = (npy_static_string *)in1;
         s2 = (npy_static_string *)in2;
         int s1_isnull = npy_string_isnull(s1);
@@ -240,13 +240,13 @@ add_strided_loop(PyArrayMethod_Context *context, char *const data[],
                           "Cannot add null that is not a nan-like value");
             }
         }
-        newlen = s1->len + s2->len;
-        if (npy_string_newemptylen(newlen, os) < 0) {
+        newsize = s1->size + s2->size;
+        if (npy_string_newemptysize(newsize, os) < 0) {
             return -1;
         }
 
-        memcpy(os->buf, s1->buf, s1->len);
-        memcpy(os->buf + s1->len, s2->buf, s2->len);
+        memcpy(os->buf, s1->buf, s1->size);
+        memcpy(os->buf + s1->size, s2->buf, s2->size);
 
     next_step:
         in1 += in1_stride;
@@ -385,7 +385,7 @@ string_equal_strided_loop(PyArrayMethod_Context *context, char *const data[],
                 }
             }
         }
-        if (s1->len == s2->len && strncmp(s1->buf, s2->buf, s1->len) == 0) {
+        if (s1->size == s2->size && strncmp(s1->buf, s2->buf, s1->size) == 0) {
             *out = (npy_bool)1;
         }
         else {
@@ -450,7 +450,7 @@ string_not_equal_strided_loop(PyArrayMethod_Context *context,
                 }
             }
         }
-        if (s1->len == s2->len && strncmp(s1->buf, s2->buf, s1->len) == 0) {
+        if (s1->size == s2->size && strncmp(s1->buf, s2->buf, s1->size) == 0) {
             *out = (npy_bool)0;
         }
         else {

Original file line number	Diff line number	Diff line change
`@@ -209,8 +209,8 @@ unicode_to_string(PyArrayMethod_Context context, char const data[],`
`209`	`209`	`}`
`210`	`210`	`npy_static_string out_ss = (npy_static_string )out;`
`211`	`211`	`npy_string_free(out_ss);`
`212`		`- if (npy_string_newemptylen(out_num_bytes, out_ss) < 0) {`
`213`		`- gil_error(PyExc_MemoryError, "npy_string_newemptylen failed");`
	`212`	`+ if (npy_string_newemptysize(out_num_bytes, out_ss) < 0) {`
	`213`	`+ gil_error(PyExc_MemoryError, "npy_string_newemptysize failed");`
`214`	`214`	`return -1;`
`215`	`215`	`}`
`216`	`216`	`char *out_buf = out_ss->buf;`
`@@ -342,16 +342,16 @@ string_to_unicode(PyArrayMethod_Context context, char const data[],`
`342`	`342`	`if (has_null && !has_string_na) {`
`343`	`343`	`// lossy but not much else we can do`
`344`	`344`	`this_string = (unsigned char *)descr->na_name.buf;`
`345`		`- n_bytes = descr->na_name.len;`
	`345`	`+ n_bytes = descr->na_name.size;`
`346`	`346`	`}`
`347`	`347`	`else {`
`348`	`348`	`this_string = (unsigned char *)(default_string.buf);`
`349`		`- n_bytes = default_string.len;`
	`349`	`+ n_bytes = default_string.size;`
`350`	`350`	`}`
`351`	`351`	`}`
`352`	`352`	`else {`
`353`	`353`	`this_string = (unsigned char *)(s->buf);`
`354`		`- n_bytes = s->len;`
	`354`	`+ n_bytes = s->size;`
`355`	`355`	`}`
`356`	`356`	`size_t tot_n_bytes = 0;`
`357`	`357`
`@@ -440,10 +440,10 @@ string_to_bool(PyArrayMethod_Context context, char const data[],`
`440`	`440`	`*out = (npy_bool)1;`
`441`	`441`	`}`
`442`	`442`	`else {`
`443`		`- *out = (npy_bool)(default_string.len == 0);`
	`443`	`+ *out = (npy_bool)(default_string.size == 0);`
`444`	`444`	`}`
`445`	`445`	`}`
`446`		`- else if (s->len == 0) {`
	`446`	`+ else if (s->size == 0) {`
`447`	`447`	`*out = (npy_bool)0;`
`448`	`448`	`}`
`449`	`449`	`else {`
`@@ -482,14 +482,14 @@ bool_to_string(PyArrayMethod_Context NPY_UNUSED(context), char const data[],`
`482`	`482`	`npy_static_string out_ss = (npy_static_string )out;`
`483`	`483`	`npy_string_free(out_ss);`
`484`	`484`	`if ((npy_bool)(*in) == 1) {`
`485`		`- if (npy_string_newlen("True", 4, out_ss) < 0) {`
`486`		`- gil_error(PyExc_MemoryError, "npy_string_newlen failed");`
	`485`	`+ if (npy_string_newsize("True", 4, out_ss) < 0) {`
	`486`	`+ gil_error(PyExc_MemoryError, "npy_string_newsize failed");`
`487`	`487`	`return -1;`
`488`	`488`	`}`
`489`	`489`	`}`
`490`	`490`	`else if ((npy_bool)(*in) == 0) {`
`491`		`- if (npy_string_newlen("False", 5, out_ss) < 0) {`
`492`		`- gil_error(PyExc_MemoryError, "npy_string_newlen failed");`
	`491`	`+ if (npy_string_newsize("False", 5, out_ss) < 0) {`
	`492`	`+ gil_error(PyExc_MemoryError, "npy_string_newsize failed");`
`493`	`493`	`return -1;`
`494`	`494`	`}`
`495`	`495`	`}`
`@@ -527,7 +527,7 @@ string_to_pylong(char *in, int hasnull)`
`527`	`527`	`}`
`528`	`528`	`s = &EMPTY_STRING;`
`529`	`529`	`}`
`530`		`- PyObject *val_obj = PyUnicode_FromStringAndSize(s->buf, s->len);`
	`530`	`+ PyObject *val_obj = PyUnicode_FromStringAndSize(s->buf, s->size);`
`531`	`531`	`if (val_obj == NULL) {`
`532`	`532`	`return NULL;`
`533`	`533`	`}`
`@@ -587,8 +587,8 @@ pyobj_to_string(PyObject obj, char out)`
`587`	`587`	`}`
`588`	`588`	`npy_static_string out_ss = (npy_static_string )out;`
`589`	`589`	`npy_string_free(out_ss);`
`590`		`- if (npy_string_newlen(cstr_val, length, out_ss) < 0) {`
`591`		`- PyErr_SetString(PyExc_MemoryError, "npy_string_newlen failed");`
	`590`	`+ if (npy_string_newsize(cstr_val, length, out_ss) < 0) {`
	`591`	`+ PyErr_SetString(PyExc_MemoryError, "npy_string_newsize failed");`
`592`	`592`	`Py_DECREF(pystr_val);`
`593`	`593`	`return -1;`
`594`	`594`	`}`
`@@ -779,7 +779,7 @@ string_to_pyfloat(char *in, int hasnull)`
`779`	`779`	`}`
`780`	`780`	`s = &EMPTY_STRING;`
`781`	`781`	`}`
`782`		`- PyObject *val_obj = PyUnicode_FromStringAndSize(s->buf, s->len);`
	`782`	`+ PyObject *val_obj = PyUnicode_FromStringAndSize(s->buf, s->size);`
`783`	`783`	`if (val_obj == NULL) {`
`784`	`784`	`return NULL;`
`785`	`785`	`}`
`@@ -1004,7 +1004,7 @@ string_to_datetime(PyArrayMethod_Context context, char const data[],`
`1004`	`1004`	`s = &default_string;`
`1005`	`1005`	`}`
`1006`	`1006`	`if (NpyDatetime_ParseISO8601Datetime(`
`1007`		`- (const char *)s->buf, s->len, in_unit, NPY_UNSAFE_CASTING,`
	`1007`	`+ (const char *)s->buf, s->size, in_unit, NPY_UNSAFE_CASTING,`
`1008`	`1008`	`&dts, &in_meta.base, &out_special) < 0) {`
`1009`	`1009`	`return -1;`
`1010`	`1010`	`}`
`@@ -1072,9 +1072,10 @@ datetime_to_string(PyArrayMethod_Context context, char const data[],`
`1072`	`1072`	`return -1;`
`1073`	`1073`	`}`
`1074`	`1074`
`1075`		`- if (npy_string_newlen(datetime_buf, strlen(datetime_buf), out_ss) <`
`1076`		`- 0) {`
`1077`		`- PyErr_SetString(PyExc_MemoryError, "npy_string_newlen failed");`
	`1075`	`+ if (npy_string_newsize(datetime_buf, strlen(datetime_buf),`
	`1076`	`+ out_ss) < 0) {`
	`1077`	`+ PyErr_SetString(PyExc_MemoryError,`
	`1078`	`+ "npy_string_newsize failed");`
`1078`	`1079`	`return -1;`
`1079`	`1080`	`}`
`1080`	`1081`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ _memory_usage(PyObject NPY_UNUSED(self), PyObject obj)`
`58`	`58`	`npy_intp count = *innersizeptr;`
`59`	`59`
`60`	`60`	`while (count--) {`
`61`		`- memory_usage += ((npy_static_string *)in)->len;`
	`61`	`+ memory_usage += ((npy_static_string *)in)->size;`
`62`	`62`	`in += stride;`
`63`	`63`	`}`
`64`	`64`
Original file line number	Diff line number	Diff line change
`@@ -9,26 +9,26 @@ const npy_static_string EMPTY_STRING = {0, "\0"};`
`9`	`9`	`const npy_static_string NULL_STRING = {0, NULL};`
`10`	`10`
`11`	`11`	`int`
`12`		`-npy_string_newlen(const char init, size_t len, npy_static_string to_init)`
	`12`	`+npy_string_newsize(const char init, size_t size, npy_static_string to_init)`
`13`	`13`	`{`
`14`		`- if ((to_init == NULL) \|\| (to_init->buf != NULL) \|\| (to_init->len != 0)) {`
	`14`	`+ if ((to_init == NULL) \|\| (to_init->buf != NULL) \|\| (to_init->size != 0)) {`
`15`	`15`	`return -2;`
`16`	`16`	`}`
`17`	`17`
`18`		`- if (len == 0) {`
	`18`	`+ if (size == 0) {`
`19`	`19`	`*to_init = EMPTY_STRING;`
`20`	`20`	`return 0;`
`21`	`21`	`}`
`22`	`22`
`23`		`- char ret_buf = (char )PyMem_RawMalloc(sizeof(char) * len);`
	`23`	`+ char ret_buf = (char )PyMem_RawMalloc(sizeof(char) * size);`
`24`	`24`
`25`	`25`	`if (ret_buf == NULL) {`
`26`	`26`	`return -1;`
`27`	`27`	`}`
`28`	`28`
`29`		`- to_init->len = len;`
	`29`	`+ to_init->size = size;`
`30`	`30`
`31`		`- memcpy(ret_buf, init, len);`
	`31`	`+ memcpy(ret_buf, init, size);`
`32`	`32`
`33`	`33`	`to_init->buf = ret_buf;`
`34`	`34`
`@@ -42,37 +42,37 @@ npy_string_free(npy_static_string *str)`
`42`	`42`	`PyMem_RawFree(str->buf);`
`43`	`43`	`str->buf = NULL;`
`44`	`44`	`}`
`45`		`- str->len = 0;`
	`45`	`+ str->size = 0;`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`int`
`49`	`49`	`npy_string_dup(const npy_static_string in, npy_static_string out)`
`50`	`50`	`{`
`51`	`51`	`if (npy_string_isnull(in)) {`
`52`		`- out->len = 0;`
	`52`	`+ out->size = 0;`
`53`	`53`	`out->buf = NULL;`
`54`	`54`	`return 0;`
`55`	`55`	`}`
`56`	`56`	`else {`
`57`		`- return npy_string_newlen(in->buf, in->len, out);`
	`57`	`+ return npy_string_newsize(in->buf, in->size, out);`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`int`
`62`		`-npy_string_newemptylen(size_t num_bytes, npy_static_string *out)`
	`62`	`+npy_string_newemptysize(size_t size, npy_static_string *out)`
`63`	`63`	`{`
`64`		`- if (out->len != 0 \|\| out->buf != NULL) {`
	`64`	`+ if (out->size != 0 \|\| out->buf != NULL) {`
`65`	`65`	`return -2;`
`66`	`66`	`}`
`67`	`67`
`68`		`- out->len = num_bytes;`
	`68`	`+ out->size = size;`
`69`	`69`
`70`		`- if (num_bytes == 0) {`
	`70`	`+ if (size == 0) {`
`71`	`71`	`*out = EMPTY_STRING;`
`72`	`72`	`return 0;`
`73`	`73`	`}`
`74`	`74`
`75`		`- char buf = (char )PyMem_RawMalloc(sizeof(char) * num_bytes);`
	`75`	`+ char buf = (char )PyMem_RawMalloc(sizeof(char) * size);`
`76`	`76`
`77`	`77`	`if (buf == NULL) {`
`78`	`78`	`return -1;`
`@@ -86,15 +86,15 @@ npy_string_newemptylen(size_t num_bytes, npy_static_string *out)`
`86`	`86`	`int`
`87`	`87`	`npy_string_cmp(const npy_static_string s1, const npy_static_string s2)`
`88`	`88`	`{`
`89`		`- size_t minlen = s1->len < s2->len ? s1->len : s2->len;`
	`89`	`+ size_t minsize = s1->size < s2->size ? s1->size : s2->size;`
`90`	`90`
`91`		`- int cmp = strncmp(s1->buf, s2->buf, minlen);`
	`91`	`+ int cmp = strncmp(s1->buf, s2->buf, minsize);`
`92`	`92`
`93`	`93`	`if (cmp == 0) {`
`94`		`- if (s1->len > minlen) {`
	`94`	`+ if (s1->size > minsize) {`
`95`	`95`	`return 1;`
`96`	`96`	`}`
`97`		`- if (s2->len > minlen) {`
	`97`	`+ if (s2->size > minsize) {`
`98`	`98`	`return -1;`
`99`	`99`	`}`
`100`	`100`	`}`
`@@ -105,7 +105,7 @@ npy_string_cmp(const npy_static_string s1, const npy_static_string s2)`
`105`	`105`	`int`
`106`	`106`	`npy_string_isnull(const npy_static_string *in)`
`107`	`107`	`{`
`108`		`- if (in->len == 0 && in->buf == NULL) {`
	`108`	`+ if (in->size == 0 && in->buf == NULL) {`
`109`	`109`	`return 1;`
`110`	`110`	`}`
`111`	`111`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -67,16 +67,16 @@ multiply_resolve_descriptors(`
`67`	`67`	`} \`
`68`	`68`	`} \`
`69`	`69`	`npy_##shortname factor = (npy_##shortname )iin; \`
`70`		`- size_t newlen = (size_t)((is->len) * factor); \`
	`70`	`+ size_t newsize = (size_t)((is->size) * factor); \`
`71`	`71`	`\`
`72`		`- if (npy_string_newemptylen(newlen, os) < 0) { \`
	`72`	`+ if (npy_string_newemptysize(newsize, os) < 0) { \`
`73`	`73`	`gil_error(PyExc_MemoryError, \`
`74`		`- "npy_string_newemptylen failed"); \`
	`74`	`+ "npy_string_newemptysize failed"); \`
`75`	`75`	`return -1; \`
`76`	`76`	`} \`
`77`	`77`	`\`
`78`	`78`	`for (size_t i = 0; i < (size_t)factor; i++) { \`
`79`		`- memcpy(os->buf + i * is->len, is->buf, is->len); \`
	`79`	`+ memcpy(os->buf + i * is->size, is->buf, is->size); \`
`80`	`80`	`} \`
`81`	`81`	`\`
`82`	`82`	`sin += s_stride; \`
`@@ -215,7 +215,7 @@ add_strided_loop(PyArrayMethod_Context context, char const data[],`
`215`	`215`	`npy_static_string *os = NULL;`
`216`	`216`
`217`	`217`	`while (N--) {`
`218`		`- int newlen = 0;`
	`218`	`+ int newsize = 0;`
`219`	`219`	`s1 = (npy_static_string *)in1;`
`220`	`220`	`s2 = (npy_static_string *)in2;`
`221`	`221`	`int s1_isnull = npy_string_isnull(s1);`
`@@ -240,13 +240,13 @@ add_strided_loop(PyArrayMethod_Context context, char const data[],`
`240`	`240`	`"Cannot add null that is not a nan-like value");`
`241`	`241`	`}`
`242`	`242`	`}`
`243`		`- newlen = s1->len + s2->len;`
`244`		`- if (npy_string_newemptylen(newlen, os) < 0) {`
	`243`	`+ newsize = s1->size + s2->size;`
	`244`	`+ if (npy_string_newemptysize(newsize, os) < 0) {`
`245`	`245`	`return -1;`
`246`	`246`	`}`
`247`	`247`
`248`		`- memcpy(os->buf, s1->buf, s1->len);`
`249`		`- memcpy(os->buf + s1->len, s2->buf, s2->len);`
	`248`	`+ memcpy(os->buf, s1->buf, s1->size);`
	`249`	`+ memcpy(os->buf + s1->size, s2->buf, s2->size);`
`250`	`250`
`251`	`251`	`next_step:`
`252`	`252`	`in1 += in1_stride;`
`@@ -385,7 +385,7 @@ string_equal_strided_loop(PyArrayMethod_Context context, char const data[],`
`385`	`385`	`}`
`386`	`386`	`}`
`387`	`387`	`}`
`388`		`- if (s1->len == s2->len && strncmp(s1->buf, s2->buf, s1->len) == 0) {`
	`388`	`+ if (s1->size == s2->size && strncmp(s1->buf, s2->buf, s1->size) == 0) {`
`389`	`389`	`*out = (npy_bool)1;`
`390`	`390`	`}`
`391`	`391`	`else {`
`@@ -450,7 +450,7 @@ string_not_equal_strided_loop(PyArrayMethod_Context *context,`
`450`	`450`	`}`
`451`	`451`	`}`
`452`	`452`	`}`
`453`		`- if (s1->len == s2->len && strncmp(s1->buf, s2->buf, s1->len) == 0) {`
	`453`	`+ if (s1->size == s2->size && strncmp(s1->buf, s2->buf, s1->size) == 0) {`
`454`	`454`	`*out = (npy_bool)0;`
`455`	`455`	`}`
`456`	`456`	`else {`