#include <Python.h>

#define PY_ARRAY_UNIQUE_SYMBOL stringdtype_ARRAY_API

#define PY_UFUNC_UNIQUE_SYMBOL stringdtype_UFUNC_API

#define NPY_NO_DEPRECATED_API NPY_2_0_API_VERSION

#define NPY_TARGET_VERSION NPY_2_0_API_VERSION

#define NO_IMPORT_ARRAY

#define NO_IMPORT_UFUNC

#include "numpy/ndarraytypes.h"

#include "numpy/arrayobject.h"

#include "numpy/ufuncobject.h"

#include "numpy/dtype_api.h"

#include "numpy/halffloat.h"

#include "numpy/npy_math.h"

#include "casts.h"

#include "dtype.h"

#include "static_string.h"

#define ANY_TO_STRING_RESOLVE_DESCRIPTORS(safety) \

static NPY_CASTING any_to_string_##safety##_resolve_descriptors( \

PyObject *NPY_UNUSED(self), \

PyArray_DTypeMeta *NPY_UNUSED(dtypes[2]), \

PyArray_Descr *given_descrs[2], PyArray_Descr *loop_descrs[2], \

npy_intp *NPY_UNUSED(view_offset)) \

{ \

if (given_descrs[1] == NULL) { \

PyArray_Descr *new = \

(PyArray_Descr *)new_stringdtype_instance(NULL, 1); \

if (new == NULL) { \

return (NPY_CASTING)-1; \

} \

loop_descrs[1] = new; \

} \

else { \

Py_INCREF(given_descrs[1]); \

loop_descrs[1] = given_descrs[1]; \

} \

\

Py_INCREF(given_descrs[0]); \

loop_descrs[0] = given_descrs[0]; \

\

return NPY_##safety##_CASTING; \

}

ANY_TO_STRING_RESOLVE_DESCRIPTORS(SAFE)

ANY_TO_STRING_RESOLVE_DESCRIPTORS(UNSAFE)

static NPY_CASTING

string_to_string_resolve_descriptors(PyObject *NPY_UNUSED(self),

npy_intp *view_offset)

{

if (given_descrs[1] == NULL) {

loop_descrs[1] = stringdtype_finalize_descr(given_descrs[0]);

}

else {

Py_INCREF(given_descrs[1]);

loop_descrs[1] = given_descrs[1];

}

Py_INCREF(given_descrs[0]);

loop_descrs[0] = given_descrs[0];

StringDTypeObject *descr0 = (StringDTypeObject *)loop_descrs[0];

StringDTypeObject *descr1 = (StringDTypeObject *)loop_descrs[1];

if ((descr0->na_object != NULL) && (descr1->na_object == NULL)) {

// cast from a dtype with an NA to one without, so it's a lossy

// unsafe cast

return NPY_UNSAFE_CASTING;

}

*view_offset = 0;

return NPY_NO_CASTING;

}

static int

string_to_string(PyArrayMethod_Context *context, char *const data[],

npy_intp const dimensions[], npy_intp const strides[],

NpyAuxData *NPY_UNUSED(auxdata))

{

StringDTypeObject *idescr = (StringDTypeObject *)context->descriptors[0];

StringDTypeObject *odescr = (StringDTypeObject *)context->descriptors[1];

int in_hasnull = idescr->na_object != NULL;

int out_hasnull = odescr->na_object != NULL;

const _npy_static_string *in_na_name = &idescr->na_name;

npy_intp N = dimensions[0];

char *in = data[0];

char *out = data[1];

npy_intp in_stride = strides[0];

npy_intp out_stride = strides[1];

npy_string_allocator *iallocator = NULL;

npy_string_allocator *oallocator = NULL;

_NpyString_acquire_allocator2(idescr, odescr, &iallocator, &oallocator);

while (N--) {

const npy_packed_static_string *s = (npy_packed_static_string *)in;

npy_packed_static_string *os = (npy_packed_static_string *)out;

if (in != out) {

if (in_hasnull && !out_hasnull && _NpyString_isnull(s)) {

// lossy but this is an unsafe cast so this is OK

if (_NpyString_pack(odescr->allocator, os, in_na_name->buf,

in_na_name->size) < 0) {

gil_error(PyExc_MemoryError,

"Failed to pack string in string to string "

"cast.");

goto fail;

}

}

else if (free_and_copy(idescr->allocator, odescr->allocator, s, os,

"string to string cast") == -1) {

goto fail;

}

}

in += in_stride;

out += out_stride;

}

_NpyString_release_allocator2(odescr, idescr);

return 0;

fail:

_NpyString_release_allocator2(odescr, idescr);

return -1;

}

static PyType_Slot s2s_slots[] = {

{NPY_METH_resolve_descriptors, &string_to_string_resolve_descriptors},

{NPY_METH_strided_loop, &string_to_string},

{NPY_METH_unaligned_strided_loop, &string_to_string},

{0, NULL}};

static char *s2s_name = "cast_StringDType_to_StringDType";

static int

utf8_size(const Py_UCS4 *codepoints, long max_length, size_t *num_codepoints,

size_t *utf8_bytes)

{

size_t ucs4len = max_length;

while (ucs4len > 0 && codepoints[ucs4len - 1] == 0) {

ucs4len--;

}

// ucs4len is now the number of codepoints that aren't trailing nulls.

size_t num_bytes = 0;

for (size_t i = 0; i < ucs4len; i++) {

Py_UCS4 code = codepoints[i];

if (code <= 0x7F) {

num_bytes += 1;

}

else if (code <= 0x07FF) {

num_bytes += 2;

}

else if (code <= 0xFFFF) {

if ((code >= 0xD800) && (code <= 0xDFFF)) {

// surrogates are invalid UCS4 code points

return -1;

}

num_bytes += 3;

}

else if (code <= 0x10FFFF) {

num_bytes += 4;

}

else {

// codepoint is outside the valid unicode range

return -1;

}

}

*num_codepoints = ucs4len;

*utf8_bytes = num_bytes;

return 0;

}

static size_t

ucs4_code_to_utf8_char(const Py_UCS4 code, char *c)

{

if (code <= 0x7F) {

// 0zzzzzzz -> 0zzzzzzz

c[0] = (char)code;

return 1;

}

else if (code <= 0x07FF) {

// 00000yyy yyzzzzzz -> 110yyyyy 10zzzzzz

c[0] = (0xC0 | (code >> 6));

c[1] = (0x80 | (code & 0x3F));

return 2;

}

else if (code <= 0xFFFF) {

// xxxxyyyy yyzzzzzz -> 110yyyyy 10zzzzzz

c[0] = (0xe0 | (code >> 12));

c[1] = (0x80 | ((code >> 6) & 0x3f));

c[2] = (0x80 | (code & 0x3f));

return 3;

}

else {

// 00wwwxx xxxxyyyy yyzzzzzz -> 11110www 10xxxxxx 10yyyyyy 10zzzzzz

c[0] = (0xf0 | (code >> 18));

c[1] = (0x80 | ((code >> 12) & 0x3f));

c[2] = (0x80 | ((code >> 6) & 0x3f));

c[3] = (0x80 | (code & 0x3f));

return 4;

}

}

static int

unicode_to_string(PyArrayMethod_Context *context, char *const data[],

npy_intp const dimensions[], npy_intp const strides[],

NpyAuxData *NPY_UNUSED(auxdata))

{

PyArray_Descr *const *descrs = context->descriptors;

StringDTypeObject *sdescr = (StringDTypeObject *)descrs[1];

npy_string_allocator *allocator = _NpyString_acquire_allocator(sdescr);

long max_in_size = (descrs[0]->elsize) / 4;

npy_intp N = dimensions[0];

Py_UCS4 *in = (Py_UCS4 *)data[0];

char *out = data[1];

// 4 bytes per UCS4 character

npy_intp in_stride = strides[0] / 4;

npy_intp out_stride = strides[1];

while (N--) {

size_t out_num_bytes = 0;

size_t num_codepoints = 0;

if (utf8_size(in, max_in_size, &num_codepoints, &out_num_bytes) ==

-1) {

gil_error(PyExc_TypeError, "Invalid unicode code point found");

goto fail;

}

npy_packed_static_string *out_pss = (npy_packed_static_string *)out;

if (_NpyString_free(out_pss, allocator) < 0) {

gil_error(PyExc_MemoryError,

"Failed to deallocate string in unicode to string cast");

goto fail;

}

if (_NpyString_newemptysize(out_num_bytes, out_pss, allocator) < 0) {

gil_error(PyExc_MemoryError,

"Failed to allocate string in unicode to string cast");

goto fail;

}

_npy_static_string out_ss = {0, NULL};

int is_null = _NpyString_load(allocator, out_pss, &out_ss);

if (is_null == -1) {

gil_error(PyExc_MemoryError,

"Failed to load string in unicode to string cast");

goto fail;

}

// ignores const to fill in the buffer

char *out_buf = (char *)out_ss.buf;

for (size_t i = 0; i < num_codepoints; i++) {

// get code point

Py_UCS4 code = in[i];

// will be filled with UTF-8 bytes

char utf8_c[4] = {0};

// we already checked for invalid code points above,

// so no need to do error checking here

size_t num_bytes = ucs4_code_to_utf8_char(code, utf8_c);

// copy utf8_c into out_buf

strncpy(out_buf, utf8_c, num_bytes);

// increment out_buf by the size of the character

out_buf += num_bytes;

}

// reset out_buf to the beginning of the string

out_buf -= out_num_bytes;

in += in_stride;

out += out_stride;

}

_NpyString_release_allocator(sdescr);

return 0;

fail:

_NpyString_release_allocator(sdescr);

return -1;

}

static PyType_Slot u2s_slots[] = {{NPY_METH_resolve_descriptors,

&any_to_string_SAFE_resolve_descriptors},

{NPY_METH_strided_loop, &unicode_to_string},

{0, NULL}};

static char *u2s_name = "cast_Unicode_to_StringDType";

static NPY_CASTING

string_to_unicode_resolve_descriptors(PyObject *NPY_UNUSED(self),

npy_intp *NPY_UNUSED(view_offset))

{

if (given_descrs[1] == NULL) {

// currently there's no way to determine the correct output

// size, so set an error and bail

PyErr_SetString(

PyExc_TypeError,

"Casting from StringDType to a fixed-width dtype with an "

"unspecified size is not currently supported, specify "

"an explicit size for the output dtype instead.");

return (NPY_CASTING)-1;

}

else {

Py_INCREF(given_descrs[1]);

loop_descrs[1] = given_descrs[1];

}

Py_INCREF(given_descrs[0]);

loop_descrs[0] = given_descrs[0];

return NPY_UNSAFE_CASTING;

}

utf8_char_to_ucs4_code(unsigned char *c, size_t len, Py_UCS4 *code)

{

if (len == 0) {

*code = (Py_UCS4)0;

return 0;

}

if (c[0] <= 0x7F) {

// 0zzzzzzz -> 0zzzzzzz

*code = (Py_UCS4)(c[0]);

return 1;

}

else if (c[0] <= 0xDF) {

// 110yyyyy 10zzzzzz -> 00000yyy yyzzzzzz

*code = (Py_UCS4)(((c[0] << 6) + c[1]) - ((0xC0 << 6) + 0x80));

return 2;

}

else if (c[0] <= 0xEF) {

// 1110xxxx 10yyyyyy 10zzzzzz -> xxxxyyyy yyzzzzzz

*code = (Py_UCS4)(((c[0] << 12) + (c[1] << 6) + c[2]) -

((0xE0 << 12) + (0x80 << 6) + 0x80));

return 3;

}

else {

// 11110www 10xxxxxx 10yyyyyy 10zzzzzz -> 000wwwxx xxxxyyyy yyzzzzzz

*code = (Py_UCS4)(((c[0] << 18) + (c[1] << 12) + (c[2] << 6) + c[3]) -

((0xF0 << 18) + (0x80 << 12) + (0x80 << 6) + 0x80));

return 4;

}

}

static int

string_to_unicode(PyArrayMethod_Context *context, char *const data[],

npy_intp const dimensions[], npy_intp const strides[],

NpyAuxData *NPY_UNUSED(auxdata))

{

StringDTypeObject *descr = (StringDTypeObject *)context->descriptors[0];

npy_string_allocator *allocator = _NpyString_acquire_allocator(descr);

int has_null = descr->na_object != NULL;

int has_string_na = descr->has_string_na;

const _npy_static_string *default_string = &descr->default_string;

const _npy_static_string *na_name = &descr->na_name;

npy_intp N = dimensions[0];

char *in = data[0];

Py_UCS4 *out = (Py_UCS4 *)data[1];

npy_intp in_stride = strides[0];

// 4 bytes per UCS4 character

npy_intp out_stride = strides[1] / 4;

// max number of 4 byte UCS4 characters that can fit in the output

long max_out_size = (context->descriptors[1]->elsize) / 4;

while (N--) {

const npy_packed_static_string *ps = (npy_packed_static_string *)in;

_npy_static_string s = {0, NULL};

_npy_static_string name = {0, NULL};

unsigned char *this_string = NULL;

size_t n_bytes;

int is_null = _NpyString_load(allocator, ps, &s);

if (is_null == -1) {

gil_error(PyExc_MemoryError,

"Failed to load string in unicode to string cast");

goto fail;

}

else if (is_null) {

if (has_null && !has_string_na) {

// lossy but not much else we can do

name = *na_name;

}

else {

name = *default_string;

}

}

else {

name = s;

}

this_string = (unsigned char *)(name.buf);

n_bytes = name.size;

size_t tot_n_bytes = 0;

for (int i = 0; i < max_out_size; i++) {

Py_UCS4 code;

// code point for character this_string is currently pointing at

size_t num_bytes =

utf8_char_to_ucs4_code(this_string, n_bytes, &code);

// move to next character

this_string += num_bytes;

tot_n_bytes += num_bytes;

// set output codepoint

out[i] = code;

// stop if we've exhausted the input string

if (tot_n_bytes >= n_bytes) {

break;

}

}

in += in_stride;

out += out_stride;

}

_NpyString_release_allocator(descr);

return 0;

fail:

_NpyString_release_allocator(descr);

return -1;

}

static PyType_Slot s2u_slots[] = {

{NPY_METH_resolve_descriptors, &string_to_unicode_resolve_descriptors},

{NPY_METH_strided_loop, &string_to_unicode},

{0, NULL}};

static char *s2u_name = "cast_StringDType_to_Unicode";

static NPY_CASTING

string_to_bool_resolve_descriptors(PyObject *NPY_UNUSED(self),

npy_intp *NPY_UNUSED(view_offset))

{

if (given_descrs[1] == NULL) {

loop_descrs[1] = PyArray_DescrNewFromType(NPY_BOOL);

}

else {

Py_INCREF(given_descrs[1]);

loop_descrs[1] = given_descrs[1];

}

Py_INCREF(given_descrs[0]);

loop_descrs[0] = given_descrs[0];

return NPY_UNSAFE_CASTING;

}

static int

string_to_bool(PyArrayMethod_Context *context, char *const data[],

npy_intp const dimensions[], npy_intp const strides[],

NpyAuxData *NPY_UNUSED(auxdata))

{

StringDTypeObject *descr = (StringDTypeObject *)context->descriptors[0];

npy_string_allocator *allocator = _NpyString_acquire_allocator(descr);

int has_null = descr->na_object != NULL;

int has_string_na = descr->has_string_na;

const _npy_static_string *default_string = &descr->default_string;

npy_intp N = dimensions[0];

char *in = data[0];

char *out = data[1];

npy_intp in_stride = strides[0];

npy_intp out_stride = strides[1];

while (N--) {

const npy_packed_static_string *ps = (npy_packed_static_string *)in;

_npy_static_string s = {0, NULL};

int is_null = _NpyString_load(allocator, ps, &s);

if (is_null == -1) {

gil_error(PyExc_MemoryError,

"Failed to load string in unicode to string cast");

goto fail;

}

else if (is_null) {

if (has_null && !has_string_na) {

// numpy treats NaN as truthy, following python

*out = (npy_bool)1;

}

else {

*out = (npy_bool)(default_string->size == 0);

}

}

else if (s.size == 0) {

*out = (npy_bool)0;

}

else {

*out = (npy_bool)1;

}

in += in_stride;

out += out_stride;

}

_NpyString_release_allocator(descr);

return 0;

fail:

_NpyString_release_allocator(descr);

return -1;

}

static PyType_Slot s2b_slots[] = {

{NPY_METH_resolve_descriptors, &string_to_bool_resolve_descriptors},

{NPY_METH_strided_loop, &string_to_bool},

{0, NULL}};

static char *s2b_name = "cast_StringDType_to_Bool";

static int

bool_to_string(PyArrayMethod_Context *context, char *const data[],

npy_intp const dimensions[], npy_intp const strides[],

NpyAuxData *NPY_UNUSED(auxdata))

{

npy_intp N = dimensions[0];

char *in = data[0];

char *out = data[1];

npy_intp in_stride = strides[0];

npy_intp out_stride = strides[1];

StringDTypeObject *descr = (StringDTypeObject *)context->descriptors[1];

npy_string_allocator *allocator = _NpyString_acquire_allocator(descr);

while (N--) {

npy_packed_static_string *out_pss = (npy_packed_static_string *)out;

char *ret_val = NULL;

size_t size = 0;

if ((npy_bool)(*in) == 1) {

ret_val = "True";

size = 4;

}

else if ((npy_bool)(*in) == 0) {

ret_val = "False";

size = 5;

}

else {

gil_error(PyExc_RuntimeError,

"invalid value encountered in bool to string cast");

goto fail;

}

if (_NpyString_pack(allocator, out_pss, ret_val, size) < 0) {

gil_error(PyExc_MemoryError,

"Failed to pack string in bool to string cast");

goto fail;

}

in += in_stride;

out += out_stride;

}

_NpyString_release_allocator(descr);

return 0;

fail:

_NpyString_release_allocator(descr);

return -1;

}

static PyType_Slot b2s_slots[] = {{NPY_METH_resolve_descriptors,

&any_to_string_SAFE_resolve_descriptors},

{NPY_METH_strided_loop, &bool_to_string},

{0, NULL}};

static char *b2s_name = "cast_Bool_to_StringDType";

static PyObject *

string_to_pylong(char *in, int hasnull,

const _npy_static_string *default_string,

npy_string_allocator *allocator)

{

const npy_packed_static_string *ps = (npy_packed_static_string *)in;

_npy_static_string s = {0, NULL};

int isnull = _NpyString_load(allocator, ps, &s);

if (isnull == -1) {

PyErr_SetString(PyExc_MemoryError,

"Failed to load string converting string to int");

return NULL;

}

else if (isnull) {

if (hasnull) {

PyErr_SetString(PyExc_ValueError,

"Arrays with missing data cannot be converted to "

"integers");

return NULL;

}

s = *default_string;

}

PyObject *val_obj = PyUnicode_FromStringAndSize(s.buf, s.size);

if (val_obj == NULL) {

return NULL;

}

// interpret as an integer in base 10

PyObject *pylong_value = PyLong_FromUnicodeObject(val_obj, 10);

Py_DECREF(val_obj);

return pylong_value;

}

static npy_longlong

string_to_uint(char *in, npy_ulonglong *value, int hasnull,

const _npy_static_string *default_string,

npy_string_allocator *allocator)

{

PyObject *pylong_value =

string_to_pylong(in, hasnull, default_string, allocator);

if (pylong_value == NULL) {

return -1;

}

*value = PyLong_AsUnsignedLongLong(pylong_value);

if (*value == (unsigned long long)-1 && PyErr_Occurred()) {

Py_DECREF(pylong_value);

return -1;

}

Py_DECREF(pylong_value);

return 0;

}

static npy_longlong

string_to_int(char *in, npy_longlong *value, int hasnull,

const _npy_static_string *default_string,

npy_string_allocator *allocator)

{

PyObject *pylong_value =

string_to_pylong(in, hasnull, default_string, allocator);

if (pylong_value == NULL) {

return -1;

}

*value = PyLong_AsLongLong(pylong_value);

if (*value == -1 && PyErr_Occurred()) {

Py_DECREF(pylong_value);

return -1;

}

Py_DECREF(pylong_value);

return 0;

}

static int

pyobj_to_string(PyObject *obj, char *out, npy_string_allocator *allocator)

{

if (obj == NULL) {

return -1;

}

PyObject *pystr_val = PyObject_Str(obj);

Py_DECREF(obj);

if (pystr_val == NULL) {

return -1;

}

Py_ssize_t length;

const char *cstr_val = PyUnicode_AsUTF8AndSize(pystr_val, &length);

if (cstr_val == NULL) {

Py_DECREF(pystr_val);

return -1;

}

npy_packed_static_string *out_ss = (npy_packed_static_string *)out;

if (_NpyString_pack(allocator, out_ss, cstr_val, length) < 0) {

gil_error(PyExc_MemoryError,

"Failed to pack string while converting from python "

"string");

Py_DECREF(pystr_val);

return -1;

}

// implicitly deallocates cstr_val as well

Py_DECREF(pystr_val);

return 0;

}

static int

int_to_string(long long in, char *out, npy_string_allocator *allocator)

{

PyObject *pylong_val = PyLong_FromLongLong(in);

return pyobj_to_string(pylong_val, out, allocator);

}

static int

uint_to_string(unsigned long long in, char *out,

npy_string_allocator *allocator)

{

PyObject *pylong_val = PyLong_FromUnsignedLongLong(in);

return pyobj_to_string(pylong_val, out, allocator);

}

#define STRING_INT_CASTS(typename, typekind, shortname, numpy_tag, \

printf_code, npy_longtype, longtype) \

static NPY_CASTING string_to_##typename##_resolve_descriptors( \

PyObject *NPY_UNUSED(self), \

PyArray_DTypeMeta *NPY_UNUSED(dtypes[2]), \

PyArray_Descr *given_descrs[2], PyArray_Descr *loop_descrs[2], \

npy_intp *NPY_UNUSED(view_offset)) \

{ \

if (given_descrs[1] == NULL) { \

loop_descrs[1] = PyArray_DescrNewFromType(numpy_tag); \

} \

else { \

Py_INCREF(given_descrs[1]); \

loop_descrs[1] = given_descrs[1]; \

} \

\

Py_INCREF(given_descrs[0]); \

loop_descrs[0] = given_descrs[0]; \

\

return NPY_UNSAFE_CASTING; \

} \

\

static int string_to_## \

typename(PyArrayMethod_Context * context, char *const data[], \

npy_intp const dimensions[], npy_intp const strides[], \

NpyAuxData *NPY_UNUSED(auxdata)) \

{ \

StringDTypeObject *descr = \

((StringDTypeObject *)context->descriptors[0]); \

npy_string_allocator *allocator = _NpyString_acquire_allocator(descr); \

int hasnull = descr->na_object != NULL; \

const _npy_static_string *default_string = &descr->default_string; \

\

npy_intp N = dimensions[0]; \

char *in = data[0]; \

npy_##typename *out = (npy_##typename *)data[1]; \

\

npy_intp in_stride = strides[0]; \

npy_intp out_stride = strides[1] / sizeof(npy_##typename); \

\

while (N--) { \

npy_longtype value; \

if (string_to_##typekind(in, &value, hasnull, default_string, \

allocator) != 0) { \

goto fail; \

} \

*out = (npy_##typename)value; \

if (*out != value) { \

/* out of bounds, raise error following NEP 50 behavior */ \

char message[200]; \

snprintf(message, sizeof(message), \

"Integer %" #printf_code \

" is out of bounds " \

"for " #typename, \

value); \

gil_error(PyExc_OverflowError, message); \

goto fail; \

} \

in += in_stride; \

out += out_stride; \

} \

\

_NpyString_release_allocator(descr); \

return 0; \

\

fail: \

_NpyString_release_allocator(descr); \

return -1; \

} \

\

static PyType_Slot s2##shortname##_slots[] = { \

{NPY_METH_resolve_descriptors, \

&string_to_##typename##_resolve_descriptors}, \

{NPY_METH_strided_loop, &string_to_##typename}, \

{0, NULL}}; \

\

static char *s2##shortname##_name = "cast_StringDType_to_" #typename; \

\

static int typename##_to_string( \

PyArrayMethod_Context *context, char *const data[], \

npy_intp const dimensions[], npy_intp const strides[], \

NpyAuxData *NPY_UNUSED(auxdata)) \

{ \

npy_intp N = dimensions[0]; \

npy_##typename *in = (npy_##typename *)data[0]; \

char *out = data[1]; \

\

npy_intp in_stride = strides[0] / sizeof(npy_##typename); \

npy_intp out_stride = strides[1]; \

\

StringDTypeObject *descr = \

(StringDTypeObject *)context->descriptors[1]; \

npy_string_allocator *allocator = _NpyString_acquire_allocator(descr); \

\

while (N--) { \

if (typekind##_to_string((longtype)*in, out, allocator) != 0) { \

goto fail; \

} \

\

in += in_stride; \

out += out_stride; \

} \

\

_NpyString_release_allocator(descr); \

return 0; \

\

fail: \

_NpyString_release_allocator(descr); \

return -1; \

} \

\

static PyType_Slot shortname##2s_slots [] = { \

{NPY_METH_resolve_descriptors, \

&any_to_string_UNSAFE_resolve_descriptors}, \

{NPY_METH_strided_loop, &typename##_to_string}, \

{0, NULL}}; \

\

static char *shortname##2s_name = "cast_" #typename "_to_StringDType";

#define DTYPES_AND_CAST_SPEC(shortname, typename) \

PyArray_DTypeMeta **s2##shortname##_dtypes = get_dtypes( \

(PyArray_DTypeMeta *)&StringDType, &PyArray_##typename##DType); \

\

PyArrayMethod_Spec *StringTo##typename##CastSpec = \

get_cast_spec(s2##shortname##_name, NPY_UNSAFE_CASTING, \

NPY_METH_REQUIRES_PYAPI, s2##shortname##_dtypes, \

s2##shortname##_slots); \

\

PyArray_DTypeMeta **shortname##2s_dtypes = get_dtypes( \

&PyArray_##typename##DType, (PyArray_DTypeMeta *)&StringDType); \

\

PyArrayMethod_Spec *typename##ToStringCastSpec = get_cast_spec( \

shortname##2s_name, NPY_UNSAFE_CASTING, NPY_METH_REQUIRES_PYAPI, \

shortname##2s_dtypes, shortname##2s_slots);

STRING_INT_CASTS(int8, int, i8, NPY_INT8, lli, npy_longlong, long long)

STRING_INT_CASTS(int16, int, i16, NPY_INT16, lli, npy_longlong, long long)

STRING_INT_CASTS(int32, int, i32, NPY_INT32, lli, npy_longlong, long long)

STRING_INT_CASTS(int64, int, i64, NPY_INT64, lli, npy_longlong, long long)

STRING_INT_CASTS(uint8, uint, u8, NPY_UINT8, llu, npy_ulonglong,

unsigned long long)

STRING_INT_CASTS(uint16, uint, u16, NPY_UINT16, llu, npy_ulonglong,

unsigned long long)

STRING_INT_CASTS(uint32, uint, u32, NPY_UINT32, llu, npy_ulonglong,

unsigned long long)

STRING_INT_CASTS(uint64, uint, u64, NPY_UINT64, llu, npy_ulonglong,

unsigned long long)

#if NPY_SIZEOF_BYTE == NPY_SIZEOF_SHORT

STRING_INT_CASTS(byte, int, byte, NPY_BYTE, lli, npy_longlong, long long)

STRING_INT_CASTS(ubyte, uint, ubyte, NPY_UBYTE, llu, npy_ulonglong,

unsigned long long)

#if NPY_SIZEOF_SHORT == NPY_SIZEOF_INT

STRING_INT_CASTS(short, int, short, NPY_SHORT, lli, npy_longlong, long long)

STRING_INT_CASTS(ushort, uint, ushort, NPY_USHORT, llu, npy_ulonglong,

unsigned long long)

#if NPY_SIZEOF_INT == NPY_SIZEOF_LONG

STRING_INT_CASTS(int, int, int, NPY_INT, lli, npy_longlong, long long)

STRING_INT_CASTS(uint, uint, uint, NPY_UINT, llu, npy_longlong, long long)

#if NPY_SIZEOF_LONGLONG == NPY_SIZEOF_LONG

STRING_INT_CASTS(longlong, int, longlong, NPY_LONGLONG, lli, npy_longlong,

long long)

STRING_INT_CASTS(ulonglong, uint, ulonglong, NPY_ULONGLONG, llu, npy_ulonglong,

unsigned long long)

static PyObject *

string_to_pyfloat(char *in, int hasnull,

const _npy_static_string *default_string,

npy_string_allocator *allocator)

{

const npy_packed_static_string *ps = (npy_packed_static_string *)in;

_npy_static_string s = {0, NULL};

int isnull = _NpyString_load(allocator, ps, &s);

if (isnull == -1) {

PyErr_SetString(

PyExc_MemoryError,

"Failed to load string while converting string to float");

return NULL;

}

if (isnull) {

if (hasnull) {

PyErr_SetString(PyExc_ValueError,

"Arrays with missing data cannot be converted to "

"integers");

return NULL;

}

s = *default_string;

}

PyObject *val_obj = PyUnicode_FromStringAndSize(s.buf, s.size);

if (val_obj == NULL) {

return NULL;

}

PyObject *pyfloat_value = PyFloat_FromString(val_obj);

Py_DECREF(val_obj);

return pyfloat_value;

}

#define STRING_TO_FLOAT_CAST(typename, shortname, isinf_name, \

double_to_float) \

static int string_to_## \

typename(PyArrayMethod_Context * context, char *const data[], \

npy_intp const dimensions[], npy_intp const strides[], \

NpyAuxData *NPY_UNUSED(auxdata)) \

{ \

StringDTypeObject *descr = \

(StringDTypeObject *)context->descriptors[0]; \

npy_string_allocator *allocator = _NpyString_acquire_allocator(descr); \

int hasnull = (descr->na_object != NULL); \

const _npy_static_string *default_string = &descr->default_string; \

\

npy_intp N = dimensions[0]; \

char *in = data[0]; \

npy_##typename *out = (npy_##typename *)data[1]; \

\

npy_intp in_stride = strides[0]; \

npy_intp out_stride = strides[1] / sizeof(npy_##typename); \

\

while (N--) { \

PyObject *pyfloat_value = string_to_pyfloat( \

in, hasnull, default_string, allocator); \

if (pyfloat_value == NULL) { \

goto fail; \

} \

double dval = PyFloat_AS_DOUBLE(pyfloat_value); \

npy_##typename fval = (double_to_float)(dval); \

\

if (NPY_UNLIKELY(isinf_name(fval) && !(npy_isinf(dval)))) { \

if (PyUFunc_GiveFloatingpointErrors("cast", \

NPY_FPE_OVERFLOW) < 0) { \

goto fail; \

} \

} \

\

*out = fval; \

\

in += in_stride; \

out += out_stride; \

} \

\

_NpyString_release_allocator(descr); \

return 0; \

fail: \

_NpyString_release_allocator(descr); \

return -1; \

} \

\

static PyType_Slot s2##shortname##_slots[] = { \

{NPY_METH_resolve_descriptors, \