#include <Python.h>

#include <stdio.h>

#include <string.h>

#define NPY_NO_DEPRECATED_API NPY_API_VERSION

#define _MULTIARRAYMODULE

#define _UMATHMODULE

#include "numpy/arrayobject.h"

#include "numpy/ndarraytypes.h"

#include "numpy/npy_math.h"

#include "numpy/ufuncobject.h"

#include "numpyos.h"

#include "dispatching.h"

#include "dtypemeta.h"

#include "convert_datatype.h"

#include "gil_utils.h"

#include "templ_common.h" /* for npy_mul_size_with_overflow_size_t */

#include "string_ufuncs.h"

#include "string_fastsearch.h"

#include "string_buffer.h"

/*

* Helper for templating, avoids warnings about uncovered switch paths.

*/

enum class COMP {

EQ, NE, LT, LE, GT, GE,

};

static char const *

comp_name(COMP comp) {

switch(comp) {

case COMP::EQ: return "equal";

case COMP::NE: return "not_equal";

case COMP::LT: return "less";

case COMP::LE: return "less_equal";

case COMP::GT: return "greater";

case COMP::GE: return "greater_equal";

default:

assert(0);

return nullptr;

}

}

template <bool rstrip, COMP comp, ENCODING enc>

static int

string_comparison_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

/*

* Note, fetching `elsize` from the descriptor is OK even without the GIL,

* however it may be that this should be moved into `auxdata` eventually,

* which may also be slightly faster/cleaner (but more involved).

*/

npy_intp elsize1 = context->descriptors[0]->elsize;

npy_intp elsize2 = context->descriptors[1]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *out = data[2];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf1(in1, elsize1);

Buffer<enc> buf2(in2, elsize2);

int cmp = buf1.strcmp(buf2, rstrip);

npy_bool res;

switch (comp) {

case COMP::EQ:

res = cmp == 0;

break;

case COMP::NE:

res = cmp != 0;

break;

case COMP::LT:

res = cmp < 0;

break;

case COMP::LE:

res = cmp <= 0;

break;

case COMP::GT:

res = cmp > 0;

break;

case COMP::GE:

res = cmp >= 0;

break;

}

*(npy_bool *)out = res;

in1 += strides[0];

in2 += strides[1];

out += strides[2];

}

return 0;

}

template <ENCODING enc>

static int

string_str_len_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

int elsize = context->descriptors[0]->elsize;

char *in = data[0];

char *out = data[1];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf(in, elsize);

*(npy_intp *)out = buf.num_codepoints();

in += strides[0];

out += strides[1];

}

return 0;

}

template <ENCODING enc>

using buffer_method = bool (Buffer<enc>::*)();

template <ENCODING enc>

static int

string_unary_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

buffer_method<enc> is_it = *(buffer_method<enc> *)(context->method->static_data);

int elsize = context->descriptors[0]->elsize;

char *in = data[0];

char *out = data[1];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf(in, elsize);

*(npy_bool *)out = (buf.*is_it)();

in += strides[0];

out += strides[1];

}

return 0;

}

template <ENCODING enc>

static inline void

string_add(Buffer<enc> buf1, Buffer<enc> buf2, Buffer<enc> out)

{

size_t len1 = buf1.num_codepoints();

size_t len2 = buf2.num_codepoints();

buf1.buffer_memcpy(out, len1);

buf2.buffer_memcpy(out + len1, len2);

out.buffer_fill_with_zeros_after_index(len1 + len2);

}

template <ENCODING enc>

static inline int

string_multiply(Buffer<enc> buf1, npy_int64 reps, Buffer<enc> out)

{

size_t len1 = buf1.num_codepoints();

if (reps < 1 || len1 == 0) {

out.buffer_fill_with_zeros_after_index(0);

return 0;

}

size_t width = out.buffer_width();

// we know this is positive

size_t reps_ = (size_t)reps;

if (len1 == 1) {

size_t end_index = reps_ > width ? width : reps_;

out.buffer_memset(*buf1, end_index);

out.buffer_fill_with_zeros_after_index(end_index);

return 0;

}

size_t newlen;

if (NPY_UNLIKELY(npy_mul_with_overflow_size_t(&newlen, reps, len1) != 0) || newlen > PY_SSIZE_T_MAX) {

return -1;

}

size_t pad = 0;

if (width < newlen) {

reps = width / len1;

pad = width % len1;

}

for (npy_int64 i = 0; i < reps; i++) {

buf1.buffer_memcpy(out, len1);

out += len1;

}

buf1.buffer_memcpy(out, pad);

out += pad;

out.buffer_fill_with_zeros_after_index(0);

return 0;

}

template <ENCODING enc>

static int

string_add_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

int elsize1 = context->descriptors[0]->elsize;

int elsize2 = context->descriptors[1]->elsize;

int outsize = context->descriptors[2]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *out = data[2];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf1(in1, elsize1);

Buffer<enc> buf2(in2, elsize2);

Buffer<enc> outbuf(out, outsize);

string_add<enc>(buf1, buf2, outbuf);

in1 += strides[0];

in2 += strides[1];

out += strides[2];

}

return 0;

}

template <ENCODING enc>

static int

string_multiply_strint_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

int elsize = context->descriptors[0]->elsize;

int outsize = context->descriptors[2]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *out = data[2];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf(in1, elsize);

Buffer<enc> outbuf(out, outsize);

if (NPY_UNLIKELY(string_multiply<enc>(buf, *(npy_int64 *)in2, outbuf) < 0)) {

npy_gil_error(PyExc_OverflowError, "Overflow detected in string multiply");

}

in1 += strides[0];

in2 += strides[1];

out += strides[2];

}

return 0;

}

template <ENCODING enc>

static int

string_multiply_intstr_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

int elsize = context->descriptors[1]->elsize;

int outsize = context->descriptors[2]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *out = data[2];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf(in2, elsize);

Buffer<enc> outbuf(out, outsize);

if (NPY_UNLIKELY(string_multiply<enc>(buf, *(npy_int64 *)in1, outbuf) < 0)) {

npy_gil_error(PyExc_OverflowError, "Overflow detected in string multiply");

}

in1 += strides[0];

in2 += strides[1];

out += strides[2];

}

return 0;

}

template <ENCODING enc>

using findlike_function = npy_intp (*)(Buffer<enc>, Buffer<enc>,

npy_int64, npy_int64);

template <ENCODING enc>

static int

string_findlike_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

findlike_function<enc> function = *(findlike_function<enc>)(context->method->static_data);

int elsize1 = context->descriptors[0]->elsize;

int elsize2 = context->descriptors[1]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *in3 = data[2];

char *in4 = data[3];

char *out = data[4];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf1(in1, elsize1);

Buffer<enc> buf2(in2, elsize2);

npy_intp idx = function(buf1, buf2, *(npy_int64 *)in3, *(npy_int64 *)in4);

if (idx == -2) {

return -1;

}

*(npy_intp *)out = idx;

in1 += strides[0];

in2 += strides[1];

in3 += strides[2];

in4 += strides[3];

out += strides[4];

}

return 0;

}

template <ENCODING enc>

static int

string_replace_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

int elsize1 = context->descriptors[0]->elsize;

int elsize2 = context->descriptors[1]->elsize;

int elsize3 = context->descriptors[2]->elsize;

int outsize = context->descriptors[4]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *in3 = data[2];

char *in4 = data[3];

char *out = data[4];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf1(in1, elsize1);

Buffer<enc> buf2(in2, elsize2);

Buffer<enc> buf3(in3, elsize3);

Buffer<enc> outbuf(out, outsize);

string_replace(buf1, buf2, buf3, *(npy_int64 *) in4, outbuf);

in1 += strides[0];

in2 += strides[1];

in3 += strides[2];

in4 += strides[3];

out += strides[4];

}

return 0;

}

template <ENCODING enc>

static int

string_startswith_endswith_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

STARTPOSITION startposition = *(STARTPOSITION *)(context->method->static_data);

int elsize1 = context->descriptors[0]->elsize;

int elsize2 = context->descriptors[1]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *in3 = data[2];

char *in4 = data[3];

char *out = data[4];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf1(in1, elsize1);

Buffer<enc> buf2(in2, elsize2);

npy_bool match = tailmatch<enc>(buf1, buf2, *(npy_int64 *)in3, *(npy_int64 *)in4,

startposition);

*(npy_bool *)out = match;

in1 += strides[0];

in2 += strides[1];

in3 += strides[2];

in4 += strides[3];

out += strides[4];

}

return 0;

}

template <ENCODING enc>

static int

string_lrstrip_whitespace_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

STRIPTYPE striptype = *(STRIPTYPE *)(context->method->static_data);

int elsize = context->descriptors[0]->elsize;

int outsize = context->descriptors[1]->elsize;

char *in = data[0];

char *out = data[1];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf(in, elsize);

Buffer<enc> outbuf(out, outsize);

string_lrstrip_whitespace(buf, outbuf, striptype);

in += strides[0];

out += strides[1];

}

return 0;

}

template <ENCODING enc>

static int

string_lrstrip_chars_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

STRIPTYPE striptype = *(STRIPTYPE *)(context->method->static_data);

int elsize1 = context->descriptors[0]->elsize;

int elsize2 = context->descriptors[1]->elsize;

int outsize = context->descriptors[2]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *out = data[2];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf1(in1, elsize1);

Buffer<enc> buf2(in2, elsize2);

Buffer<enc> outbuf(out, outsize);

string_lrstrip_chars(buf1, buf2, outbuf, striptype);

in1 += strides[0];

in2 += strides[1];

out += strides[2];

}

return 0;

}

template <ENCODING enc>

static int

string_expandtabs_length_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

int elsize = context->descriptors[0]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *out = data[2];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf(in1, elsize);

*(npy_intp *)out = string_expandtabs_length(buf, *(npy_int64 *)in2);

in1 += strides[0];

in2 += strides[1];

out += strides[2];

}

return 0;

}

template <ENCODING enc>

static int

string_expandtabs_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

int elsize = context->descriptors[0]->elsize;

int outsize = context->descriptors[2]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *out = data[2];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf(in1, elsize);

Buffer<enc> outbuf(out, outsize);

npy_intp new_len = string_expandtabs(buf, *(npy_int64 *)in2, outbuf);

outbuf.buffer_fill_with_zeros_after_index(new_len);

in1 += strides[0];

in2 += strides[1];

out += strides[2];

}

return 0;

}

template <ENCODING bufferenc, ENCODING fillenc>

static int

string_center_ljust_rjust_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

JUSTPOSITION pos = *(JUSTPOSITION *)(context->method->static_data);

int elsize1 = context->descriptors[0]->elsize;

int elsize3 = context->descriptors[2]->elsize;

int outsize = context->descriptors[3]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *in3 = data[2];

char *out = data[3];

npy_intp N = dimensions[0];

while (N--) {

Buffer<bufferenc> buf(in1, elsize1);

Buffer<fillenc> fill(in3, elsize3);

Buffer<bufferenc> outbuf(out, outsize);

if (bufferenc == ENCODING::ASCII && fillenc == ENCODING::UTF32 && *fill > 0x7F) {

npy_gil_error(PyExc_ValueError, "non-ascii fill character is not allowed when buffer is ascii");

return -1;

}

npy_intp len = string_pad(buf, *(npy_int64 *)in2, *fill, pos, outbuf);

if (len < 0) {

return -1;

}

outbuf.buffer_fill_with_zeros_after_index(len);

in1 += strides[0];

in2 += strides[1];

in3 += strides[2];

out += strides[3];

}

return 0;

}

template <ENCODING enc>

static int

string_zfill_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

int elsize = context->descriptors[0]->elsize;

int outsize = context->descriptors[2]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *out = data[2];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf(in1, elsize);

Buffer<enc> outbuf(out, outsize);

npy_intp newlen = string_zfill(buf, *(npy_int64 *)in2, outbuf);

if (newlen < 0) {

return -1;

}

outbuf.buffer_fill_with_zeros_after_index(newlen);

in1 += strides[0];

in2 += strides[1];

out += strides[2];

}

return 0;

}

template <ENCODING enc>

static int

string_partition_index_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

STARTPOSITION startposition = *(STARTPOSITION *)(context->method->static_data);

int elsize1 = context->descriptors[0]->elsize;

int elsize2 = context->descriptors[1]->elsize;

int outsize1 = context->descriptors[3]->elsize;

int outsize2 = context->descriptors[4]->elsize;

int outsize3 = context->descriptors[5]->elsize;

char *in1 = data[0];

char *in2 = data[1];

char *in3 = data[2];

char *out1 = data[3];

char *out2 = data[4];

char *out3 = data[5];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> buf1(in1, elsize1);

Buffer<enc> buf2(in2, elsize2);

Buffer<enc> outbuf1(out1, outsize1);

Buffer<enc> outbuf2(out2, outsize2);

Buffer<enc> outbuf3(out3, outsize3);

npy_intp final_len1, final_len2, final_len3;

string_partition(buf1, buf2, *(npy_int64 *)in3, outbuf1, outbuf2, outbuf3,

&final_len1, &final_len2, &final_len3, startposition);

if (final_len1 < 0 || final_len2 < 0 || final_len3 < 0) {

return -1;

}

outbuf1.buffer_fill_with_zeros_after_index(final_len1);

outbuf2.buffer_fill_with_zeros_after_index(final_len2);

outbuf3.buffer_fill_with_zeros_after_index(final_len3);

in1 += strides[0];

in2 += strides[1];

in3 += strides[2];

out1 += strides[3];

out2 += strides[4];

out3 += strides[5];

}

return 0;

}

template <ENCODING enc>

static int

string_slice_loop(PyArrayMethod_Context *context,

char *const data[], npy_intp const dimensions[],

npy_intp const strides[], NpyAuxData *NPY_UNUSED(auxdata))

{

int insize = context->descriptors[0]->elsize;

int outsize = context->descriptors[4]->elsize;

char *in_ptr = data[0];

char *start_ptr = data[1];

char *stop_ptr = data[2];

char *step_ptr = data[3];

char *out_ptr = data[4];

npy_intp N = dimensions[0];

while (N--) {

Buffer<enc> inbuf(in_ptr, insize);

Buffer<enc> outbuf(out_ptr, outsize);

// get the slice

npy_intp start = *(npy_intp*)start_ptr;

npy_intp stop = *(npy_intp*)stop_ptr;

npy_intp step = *(npy_intp*)step_ptr;

if (step == 0) {

npy_gil_error(PyExc_ValueError, "slice step cannot be zero");

return -1;

}

// adjust slice to string length in codepoints

// and handle negative indices

size_t num_codepoints = inbuf.num_codepoints();

npy_intp slice_length = PySlice_AdjustIndices(num_codepoints, &start, &stop,

step < -NPY_MAX_INTP ? -NPY_MAX_INTP : step);

// iterate over slice and copy each character of the string

inbuf.advance_chars_or_bytes(start);

for (npy_intp i = 0; i < slice_length; i++) {

// copy one codepoint

inbuf.buffer_memcpy(outbuf, 1);

// Move in outbuf by the number of chars or bytes written

outbuf.advance_chars_or_bytes(1);

// an extreme step overflows the pointer on the final advance

if (i + 1 < slice_length) {

inbuf += step;

}

}

// fill remaining outbuf with zero bytes

for (char *tmp = outbuf.buf; tmp < outbuf.after; tmp++) {

*tmp = 0;

}

// Go to the next array element

in_ptr += strides[0];

start_ptr += strides[1];

stop_ptr += strides[2];

step_ptr += strides[3];

out_ptr += strides[4];

}

return 0;

}

/* Resolve descriptors & promoter functions */

static NPY_CASTING

string_addition_resolve_descriptors(

PyArrayMethodObject *NPY_UNUSED(self),

PyArray_DTypeMeta *const NPY_UNUSED(dtypes[3]),

PyArray_Descr *const given_descrs[3],

PyArray_Descr *loop_descrs[3],

npy_intp *NPY_UNUSED(view_offset))

{

npy_intp result_itemsize = given_descrs[0]->elsize + given_descrs[1]->elsize;

/* NOTE: elsize can fit more than MAX_INT, but some code may still use ints */

if (result_itemsize > NPY_MAX_INT || result_itemsize < 0) {

npy_intp length = result_itemsize;

if (given_descrs[0]->type == NPY_UNICODE) {

length /= 4;

}

PyErr_Format(PyExc_TypeError,

"addition result string of length %zd is too large to store inside array.",

length);

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[0] = NPY_DT_CALL_ensure_canonical(given_descrs[0]);

if (loop_descrs[0] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[1] = NPY_DT_CALL_ensure_canonical(given_descrs[1]);

if (loop_descrs[1] == NULL) {

Py_DECREF(loop_descrs[0]);

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[2] = PyArray_DescrNew(loop_descrs[0]);

if (loop_descrs[2] == NULL) {

Py_DECREF(loop_descrs[0]);

Py_DECREF(loop_descrs[1]);

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[2]->elsize += loop_descrs[1]->elsize;

return NPY_NO_CASTING;

}

static NPY_CASTING

string_multiply_resolve_descriptors(

PyArrayMethodObject *NPY_UNUSED(self),

PyArray_DTypeMeta *const NPY_UNUSED(dtypes[3]),

PyArray_Descr *const given_descrs[3],

PyArray_Descr *loop_descrs[3],

npy_intp *NPY_UNUSED(view_offset))

{

if (given_descrs[2] == NULL) {

PyErr_SetString(

PyExc_TypeError,

"The 'out' kwarg is necessary when using the string multiply ufunc "

"directly. Use numpy.strings.multiply to multiply strings without "

"specifying 'out'.");

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[0] = NPY_DT_CALL_ensure_canonical(given_descrs[0]);

if (loop_descrs[0] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[1] = NPY_DT_CALL_ensure_canonical(given_descrs[1]);

if (loop_descrs[1] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[2] = NPY_DT_CALL_ensure_canonical(given_descrs[2]);

if (loop_descrs[2] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

return NPY_NO_CASTING;

}

static NPY_CASTING

string_strip_whitespace_resolve_descriptors(

PyArrayMethodObject *NPY_UNUSED(self),

PyArray_DTypeMeta *const NPY_UNUSED(dtypes[2]),

PyArray_Descr *const given_descrs[2],

PyArray_Descr *loop_descrs[2],

npy_intp *NPY_UNUSED(view_offset))

{

loop_descrs[0] = NPY_DT_CALL_ensure_canonical(given_descrs[0]);

if (loop_descrs[0] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

Py_INCREF(loop_descrs[0]);

loop_descrs[1] = loop_descrs[0];

return NPY_NO_CASTING;

}

static NPY_CASTING

string_strip_chars_resolve_descriptors(

PyArrayMethodObject *NPY_UNUSED(self),

PyArray_DTypeMeta *const NPY_UNUSED(dtypes[3]),

PyArray_Descr *const given_descrs[3],

PyArray_Descr *loop_descrs[3],

npy_intp *NPY_UNUSED(view_offset))

{

loop_descrs[0] = NPY_DT_CALL_ensure_canonical(given_descrs[0]);

if (loop_descrs[0] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[1] = NPY_DT_CALL_ensure_canonical(given_descrs[1]);

if (loop_descrs[1] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

Py_INCREF(loop_descrs[0]);

loop_descrs[2] = loop_descrs[0];

return NPY_NO_CASTING;

}

static int

string_findlike_promoter(PyObject *NPY_UNUSED(ufunc),

PyArray_DTypeMeta *const op_dtypes[], PyArray_DTypeMeta *const signature[],

PyArray_DTypeMeta *new_op_dtypes[])

{

Py_INCREF(op_dtypes[0]);

new_op_dtypes[0] = op_dtypes[0];

Py_INCREF(op_dtypes[1]);

new_op_dtypes[1] = op_dtypes[1];

new_op_dtypes[2] = NPY_DT_NewRef(&PyArray_Int64DType);

new_op_dtypes[3] = NPY_DT_NewRef(&PyArray_Int64DType);

new_op_dtypes[4] = PyArray_DTypeFromTypeNum(NPY_DEFAULT_INT);

return 0;

}

static int

string_replace_promoter(PyObject *NPY_UNUSED(ufunc),

PyArray_DTypeMeta *const op_dtypes[], PyArray_DTypeMeta *const signature[],

PyArray_DTypeMeta *new_op_dtypes[])

{

Py_INCREF(op_dtypes[0]);

new_op_dtypes[0] = op_dtypes[0];

Py_INCREF(op_dtypes[1]);

new_op_dtypes[1] = op_dtypes[1];

Py_INCREF(op_dtypes[2]);

new_op_dtypes[2] = op_dtypes[2];

new_op_dtypes[3] = PyArray_DTypeFromTypeNum(NPY_INT64);

Py_INCREF(op_dtypes[0]);

new_op_dtypes[4] = op_dtypes[0];

return 0;

}

static NPY_CASTING

string_replace_resolve_descriptors(

PyArrayMethodObject *NPY_UNUSED(self),

PyArray_DTypeMeta *const NPY_UNUSED(dtypes[5]),

PyArray_Descr *const given_descrs[5],

PyArray_Descr *loop_descrs[5],

npy_intp *NPY_UNUSED(view_offset))

{

if (given_descrs[4] == NULL) {

PyErr_SetString(PyExc_ValueError, "out kwarg should be given");

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[0] = NPY_DT_CALL_ensure_canonical(given_descrs[0]);

if (loop_descrs[0] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[1] = NPY_DT_CALL_ensure_canonical(given_descrs[1]);

if (loop_descrs[1] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[2] = NPY_DT_CALL_ensure_canonical(given_descrs[2]);

if (loop_descrs[2] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[3] = NPY_DT_CALL_ensure_canonical(given_descrs[3]);

if (loop_descrs[3] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[4] = NPY_DT_CALL_ensure_canonical(given_descrs[4]);

if (loop_descrs[4] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

return NPY_NO_CASTING;

}

static int

string_startswith_endswith_promoter(PyObject *NPY_UNUSED(ufunc),

PyArray_DTypeMeta *const op_dtypes[], PyArray_DTypeMeta *const signature[],

PyArray_DTypeMeta *new_op_dtypes[])

{

Py_INCREF(op_dtypes[0]);

new_op_dtypes[0] = op_dtypes[0];

Py_INCREF(op_dtypes[1]);

new_op_dtypes[1] = op_dtypes[1];

new_op_dtypes[2] = NPY_DT_NewRef(&PyArray_Int64DType);

new_op_dtypes[3] = NPY_DT_NewRef(&PyArray_Int64DType);

new_op_dtypes[4] = NPY_DT_NewRef(&PyArray_BoolDType);

return 0;

}

static int

string_expandtabs_length_promoter(PyObject *NPY_UNUSED(ufunc),

PyArray_DTypeMeta *const op_dtypes[], PyArray_DTypeMeta *const signature[],

PyArray_DTypeMeta *new_op_dtypes[])

{

Py_XINCREF(op_dtypes[0]);

new_op_dtypes[0] = op_dtypes[0];

new_op_dtypes[1] = NPY_DT_NewRef(&PyArray_Int64DType);

new_op_dtypes[2] = PyArray_DTypeFromTypeNum(NPY_DEFAULT_INT);

return 0;

}

static int

string_expandtabs_promoter(PyObject *NPY_UNUSED(ufunc),

PyArray_DTypeMeta *const op_dtypes[], PyArray_DTypeMeta *const signature[],

PyArray_DTypeMeta *new_op_dtypes[])

{

Py_INCREF(op_dtypes[0]);

new_op_dtypes[0] = op_dtypes[0];

new_op_dtypes[1] = NPY_DT_NewRef(&PyArray_Int64DType);

Py_INCREF(op_dtypes[0]);

new_op_dtypes[2] = op_dtypes[0];

return 0;

}

static NPY_CASTING

string_expandtabs_resolve_descriptors(

PyArrayMethodObject *NPY_UNUSED(self),

PyArray_DTypeMeta *const NPY_UNUSED(dtypes[3]),

PyArray_Descr *const given_descrs[3],

PyArray_Descr *loop_descrs[3],

npy_intp *NPY_UNUSED(view_offset))

{

if (given_descrs[2] == NULL) {

PyErr_SetString(

PyExc_TypeError,

"The 'out' kwarg is necessary. Use numpy.strings.expandtabs without it.");

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[0] = NPY_DT_CALL_ensure_canonical(given_descrs[0]);

if (loop_descrs[0] == NULL) {

return _NPY_ERROR_OCCURRED_IN_CAST;

}

loop_descrs[1] = NPY_DT_CALL_ensure_canonical(given_descrs[1]);

if (loop_descrs[1] == NULL) {