#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#undef NDEBUG

#include "Python.h"

#include "pycore_object.h" // _PyObject_IsFreed()

typedef struct {

const char *name;

} custom_t;

static int

custom_converter(PyObject *obj, custom_t *val)

{

return 1;

}

#include "clinic/_testclinic.c.h"

static PyObject *

pack_arguments_newref(int argc, ...)

{

assert(!PyErr_Occurred());

PyObject *tuple = PyTuple_New(argc);

if (!tuple) {

return NULL;

}

va_list vargs;

va_start(vargs, argc);

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

PyObject *arg = va_arg(vargs, PyObject *);

if (arg) {

if (_PyObject_IsFreed(arg)) {

PyErr_Format(PyExc_AssertionError,

"argument %d at %p is freed or corrupted!",

i, arg);

va_end(vargs);

Py_DECREF(tuple);

return NULL;

}

}

else {

arg = Py_None;

}

PyTuple_SET_ITEM(tuple, i, Py_NewRef(arg));

}

va_end(vargs);

return tuple;

}

#define RETURN_PACKED_ARGS(argc, wrapper, arg_type, ...) do { \

assert(!PyErr_Occurred()); \

arg_type in[argc] = {__VA_ARGS__}; \

PyObject *out[argc] = {NULL,}; \

for (int _i = 0; _i < argc; _i++) { \

out[_i] = wrapper(in[_i]); \

assert(out[_i] || PyErr_Occurred()); \

if (!out[_i]) { \

for (int _j = 0; _j < _i; _j++) { \

Py_DECREF(out[_j]); \

} \

return NULL; \

} \

} \

PyObject *tuple = PyTuple_New(argc); \

if (!tuple) { \

for (int _i = 0; _i < argc; _i++) { \

Py_DECREF(out[_i]); \

} \

return NULL; \

} \

for (int _i = 0; _i < argc; _i++) { \

PyTuple_SET_ITEM(tuple, _i, out[_i]); \

} \

return tuple; \

} while (0)

static PyObject *

test_empty_function_impl(PyObject *module)

{

Py_RETURN_NONE;

}

static PyObject *

objects_converter_impl(PyObject *module, PyObject *a, PyObject *b)

{

return pack_arguments_newref(2, a, b);

}

static PyObject *

bytes_object_converter_impl(PyObject *module, PyBytesObject *a)

{

if (!PyBytes_Check(a)) {

PyErr_SetString(PyExc_AssertionError,

"argument a is not a PyBytesObject");

return NULL;

}

return pack_arguments_newref(1, a);

}

static PyObject *

byte_array_object_converter_impl(PyObject *module, PyByteArrayObject *a)

{

if (!PyByteArray_Check(a)) {

PyErr_SetString(PyExc_AssertionError,

"argument a is not a PyByteArrayObject");

return NULL;

}

return pack_arguments_newref(1, a);

}

static PyObject *

unicode_converter_impl(PyObject *module, PyObject *a)

{

if (!PyUnicode_Check(a)) {

PyErr_SetString(PyExc_AssertionError,

"argument a is not a unicode object");

return NULL;

}

return pack_arguments_newref(1, a);

}

static PyObject *

bool_converter_impl(PyObject *module, int a, int b, int c)

{

PyObject *obj_a = a ? Py_True : Py_False;

PyObject *obj_b = b ? Py_True : Py_False;

PyObject *obj_c = c ? Py_True : Py_False;

return pack_arguments_newref(3, obj_a, obj_b, obj_c);

}

static PyObject *

char_converter_impl(PyObject *module, char a, char b, char c, char d, char e,

char f, char g, char h, char i, char j, char k, char l,

char m, char n)

{

RETURN_PACKED_ARGS(14, PyLong_FromUnsignedLong, unsigned char,

a, b, c, d, e, f, g, h, i, j, k, l, m, n);

}

static PyObject *

unsigned_char_converter_impl(PyObject *module, unsigned char a,

unsigned char b, unsigned char c)

{

RETURN_PACKED_ARGS(3, PyLong_FromUnsignedLong, unsigned char, a, b, c);

}

static PyObject *

short_converter_impl(PyObject *module, short a)

{

RETURN_PACKED_ARGS(1, PyLong_FromLong, long, a);

}

static PyObject *

unsigned_short_converter_impl(PyObject *module, unsigned short a,

unsigned short b, unsigned short c)

{

RETURN_PACKED_ARGS(3, PyLong_FromUnsignedLong, unsigned long, a, b, c);

}

static PyObject *

int_converter_impl(PyObject *module, int a, int b, int c)

{

RETURN_PACKED_ARGS(3, PyLong_FromLong, long, a, b, c);

}

static PyObject *

unsigned_int_converter_impl(PyObject *module, unsigned int a, unsigned int b,

unsigned int c)

{

RETURN_PACKED_ARGS(3, PyLong_FromUnsignedLong, unsigned long, a, b, c);

}

static PyObject *

long_converter_impl(PyObject *module, long a)

{

RETURN_PACKED_ARGS(1, PyLong_FromLong, long, a);

}

static PyObject *

unsigned_long_converter_impl(PyObject *module, unsigned long a,

unsigned long b, unsigned long c)

{

RETURN_PACKED_ARGS(3, PyLong_FromUnsignedLong, unsigned long, a, b, c);

}

static PyObject *

long_long_converter_impl(PyObject *module, long long a)

{

RETURN_PACKED_ARGS(1, PyLong_FromLongLong, long long, a);

}

static PyObject *

unsigned_long_long_converter_impl(PyObject *module, unsigned long long a,

unsigned long long b, unsigned long long c)

{

RETURN_PACKED_ARGS(3, PyLong_FromUnsignedLongLong, unsigned long long,

a, b, c);

}

static PyObject *

py_ssize_t_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,

Py_ssize_t c)

{

RETURN_PACKED_ARGS(3, PyLong_FromSsize_t, Py_ssize_t, a, b, c);

}

static PyObject *

slice_index_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,

Py_ssize_t c)

{

RETURN_PACKED_ARGS(3, PyLong_FromSsize_t, Py_ssize_t, a, b, c);

}

static PyObject *

size_t_converter_impl(PyObject *module, size_t a)

{

RETURN_PACKED_ARGS(1, PyLong_FromSize_t, size_t, a);

}

static PyObject *

float_converter_impl(PyObject *module, float a)

{

RETURN_PACKED_ARGS(1, PyFloat_FromDouble, double, a);

}

static PyObject *

double_converter_impl(PyObject *module, double a)

{

RETURN_PACKED_ARGS(1, PyFloat_FromDouble, double, a);

}

static PyObject *

py_complex_converter_impl(PyObject *module, Py_complex a)

{

RETURN_PACKED_ARGS(1, PyComplex_FromCComplex, Py_complex, a);

}

static PyObject *

str_converter_impl(PyObject *module, const char *a, const char *b,

const char *c, Py_ssize_t c_length)

{

assert(!PyErr_Occurred());

PyObject *out[3] = {NULL,};

int i = 0;

PyObject *arg;

arg = PyUnicode_FromString(a);

assert(arg || PyErr_Occurred());

if (!arg) {

goto error;

}

out[i++] = arg;

arg = PyUnicode_FromString(b);

assert(arg || PyErr_Occurred());

if (!arg) {

goto error;

}

out[i++] = arg;

arg = PyUnicode_FromStringAndSize(c, c_length);

assert(arg || PyErr_Occurred());

if (!arg) {

goto error;

}

out[i++] = arg;

PyObject *tuple = PyTuple_New(3);

if (!tuple) {

goto error;

}

for (int j = 0; j < 3; j++) {

PyTuple_SET_ITEM(tuple, j, out[j]);

}

return tuple;

error:

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

Py_DECREF(out[j]);

}

return NULL;

}

static PyObject *

str_converter_encoding_impl(PyObject *module, char *a, char *b, char *c,

Py_ssize_t c_length)

{

assert(!PyErr_Occurred());

PyObject *out[3] = {NULL,};

int i = 0;

PyObject *arg;

arg = PyUnicode_FromString(a);

assert(arg || PyErr_Occurred());

if (!arg) {

goto error;

}

out[i++] = arg;

arg = PyUnicode_FromString(b);

assert(arg || PyErr_Occurred());

if (!arg) {

goto error;

}

out[i++] = arg;

arg = PyUnicode_FromStringAndSize(c, c_length);

assert(arg || PyErr_Occurred());

if (!arg) {

goto error;

}

out[i++] = arg;

PyObject *tuple = PyTuple_New(3);

if (!tuple) {

goto error;

}

for (int j = 0; j < 3; j++) {

PyTuple_SET_ITEM(tuple, j, out[j]);

}

return tuple;

error:

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

Py_DECREF(out[j]);

}

return NULL;

}

static PyObject *

bytes_from_buffer(Py_buffer *buf)

{

PyObject *bytes_obj = PyBytes_FromStringAndSize(NULL, buf->len);

if (!bytes_obj) {

return NULL;

}

void *bytes_obj_buf = ((PyBytesObject *)bytes_obj)->ob_sval;

if (PyBuffer_ToContiguous(bytes_obj_buf, buf, buf->len, 'C') < 0) {

Py_DECREF(bytes_obj);

return NULL;

}

return bytes_obj;

}

static PyObject *

py_buffer_converter_impl(PyObject *module, Py_buffer *a, Py_buffer *b)

{

RETURN_PACKED_ARGS(2, bytes_from_buffer, Py_buffer *, a, b);

}

static PyObject *

keywords_impl(PyObject *module, PyObject *a, PyObject *b)

{

return pack_arguments_newref(2, a, b);

}

static PyObject *

keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b)

{

return pack_arguments_newref(2, a, b);

}

static PyObject *

keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b, PyObject *c)

{

return pack_arguments_newref(3, a, b, c);

}

static PyObject *

keywords_opt_kwonly_impl(PyObject *module, PyObject *a, PyObject *b,

PyObject *c, PyObject *d)

{

return pack_arguments_newref(4, a, b, c, d);

}

static PyObject *

keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,

PyObject *c)

{

return pack_arguments_newref(3, a, b, c);

}

static PyObject *

posonly_keywords_impl(PyObject *module, PyObject *a, PyObject *b)

{

return pack_arguments_newref(2, a, b);

}

static PyObject *

posonly_kwonly_impl(PyObject *module, PyObject *a, PyObject *b)

{

return pack_arguments_newref(2, a, b);

}

static PyObject *

posonly_keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b,

PyObject *c)

{

return pack_arguments_newref(3, a, b, c);

}

static PyObject *

posonly_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b,

PyObject *c, PyObject *d)

{

return pack_arguments_newref(4, a, b, c, d);

}

static PyObject *

posonly_opt_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b,

PyObject *c, PyObject *d)

{

return pack_arguments_newref(4, a, b, c, d);

}

static PyObject *

posonly_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,

PyObject *c, PyObject *d)

{

return pack_arguments_newref(4, a, b, c, d);

}

static PyObject *

posonly_opt_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,

PyObject *c, PyObject *d)

{

return pack_arguments_newref(4, a, b, c, d);

}

static PyObject *

posonly_keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,

PyObject *c, PyObject *d, PyObject *e)

{

return pack_arguments_newref(5, a, b, c, d, e);

}

static PyObject *

posonly_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a,

PyObject *b, PyObject *c, PyObject *d,

PyObject *e)

{

return pack_arguments_newref(5, a, b, c, d, e);

}

static PyObject *

posonly_opt_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a,

PyObject *b, PyObject *c,

PyObject *d)

{

return pack_arguments_newref(4, a, b, c, d);

}

static PyObject *

keyword_only_parameter_impl(PyObject *module, PyObject *a)

{

return pack_arguments_newref(1, a);

}

static PyObject *

posonly_vararg_impl(PyObject *module, PyObject *a, PyObject *b,

PyObject *args)

{

return pack_arguments_newref(3, a, b, args);

}

static PyObject *

vararg_and_posonly_impl(PyObject *module, PyObject *a, PyObject *args)

{

return pack_arguments_newref(2, a, args);

}