#include "Python.h"

typedef struct {

PyObject_HEAD

void *pointer;

const char *name;

void *context;

PyCapsule_Destructor destructor;

} PyCapsule;

static int

_is_legal_capsule(PyCapsule *capsule, const char *invalid_capsule)

{

if (!capsule || !PyCapsule_CheckExact(capsule) || capsule->pointer == NULL) {

PyErr_SetString(PyExc_ValueError, invalid_capsule);

return 0;

}

return 1;

}

#define is_legal_capsule(capsule, name) \

(_is_legal_capsule(capsule, \

name " called with invalid PyCapsule object"))

static int

name_matches(const char *name1, const char *name2) {

/* if either is NULL, */

if (!name1 || !name2) {

/* they're only the same if they're both NULL. */

return name1 == name2;

}

return !strcmp(name1, name2);

}

PyObject *

PyCapsule_New(void *pointer, const char *name, PyCapsule_Destructor destructor)

{

PyCapsule *capsule;

if (!pointer) {

PyErr_SetString(PyExc_ValueError, "PyCapsule_New called with null pointer");

return NULL;

}

capsule = PyObject_NEW(PyCapsule, &PyCapsule_Type);

if (capsule == NULL) {

return NULL;

}

capsule->pointer = pointer;

capsule->name = name;

capsule->context = NULL;

capsule->destructor = destructor;

return (PyObject *)capsule;

}

PyCapsule_IsValid(PyObject *o, const char *name)

{

PyCapsule *capsule = (PyCapsule *)o;

return (capsule != NULL &&

PyCapsule_CheckExact(capsule) &&

capsule->pointer != NULL &&

name_matches(capsule->name, name));

}

void *

PyCapsule_GetPointer(PyObject *o, const char *name)

{

PyCapsule *capsule = (PyCapsule *)o;

if (!is_legal_capsule(capsule, "PyCapsule_GetPointer")) {

return NULL;

}

if (!name_matches(name, capsule->name)) {

PyErr_SetString(PyExc_ValueError, "PyCapsule_GetPointer called with incorrect name");

return NULL;

}

return capsule->pointer;

}

const char *

PyCapsule_GetName(PyObject *o)

{

PyCapsule *capsule = (PyCapsule *)o;

if (!is_legal_capsule(capsule, "PyCapsule_GetName")) {

return NULL;

}

return capsule->name;

}

PyCapsule_GetDestructor(PyObject *o)

{

PyCapsule *capsule = (PyCapsule *)o;

if (!is_legal_capsule(capsule, "PyCapsule_GetDestructor")) {

return NULL;

}

return capsule->destructor;

}

void *

PyCapsule_GetContext(PyObject *o)

{

PyCapsule *capsule = (PyCapsule *)o;

if (!is_legal_capsule(capsule, "PyCapsule_GetContext")) {

return NULL;

}

return capsule->context;

}

PyCapsule_SetPointer(PyObject *o, void *pointer)

{

PyCapsule *capsule = (PyCapsule *)o;

if (!pointer) {

PyErr_SetString(PyExc_ValueError, "PyCapsule_SetPointer called with null pointer");

return -1;

}

if (!is_legal_capsule(capsule, "PyCapsule_SetPointer")) {

return -1;

}

capsule->pointer = pointer;

return 0;

}

PyCapsule_SetName(PyObject *o, const char *name)

{

PyCapsule *capsule = (PyCapsule *)o;

if (!is_legal_capsule(capsule, "PyCapsule_SetName")) {

return -1;

}

capsule->name = name;

return 0;

}

PyCapsule_SetDestructor(PyObject *o, PyCapsule_Destructor destructor)

{

PyCapsule *capsule = (PyCapsule *)o;

if (!is_legal_capsule(capsule, "PyCapsule_SetDestructor")) {

return -1;

}

capsule->destructor = destructor;

return 0;

}

PyCapsule_SetContext(PyObject *o, void *context)

{

PyCapsule *capsule = (PyCapsule *)o;

if (!is_legal_capsule(capsule, "PyCapsule_SetContext")) {

return -1;

}

capsule->context = context;

return 0;

}

void *

PyCapsule_Import(const char *name, int no_block)

{

PyObject *object = NULL;

void *return_value = NULL;

char *trace;

size_t name_length = (strlen(name) + 1) * sizeof(char);

char *name_dup = (char *)PyMem_MALLOC(name_length);

if (!name_dup) {

return NULL;

}

memcpy(name_dup, name, name_length);

trace = name_dup;

while (trace) {

char *dot = strchr(trace, '.');

if (dot) {

*dot++ = '\0';

}

if (object == NULL) {

if (no_block) {

object = PyImport_ImportModuleNoBlock(trace);

} else {

object = PyImport_ImportModule(trace);

if (!object) {

PyErr_Format(PyExc_ImportError, "PyCapsule_Import could not import module \"%s\"", trace);

}

}

} else {

PyObject *object2 = PyObject_GetAttrString(object, trace);

Py_DECREF(object);

object = object2;

}

if (!object) {

goto EXIT;

}

trace = dot;

}

/* compare attribute name to module.name by hand */

if (PyCapsule_IsValid(object, name)) {

PyCapsule *capsule = (PyCapsule *)object;

return_value = capsule->pointer;

} else {

PyErr_Format(PyExc_AttributeError,

"PyCapsule_Import \"%s\" is not valid",

name);

}

EXIT:

Py_XDECREF(object);

if (name_dup) {

PyMem_FREE(name_dup);

}

return return_value;

}

static void

capsule_dealloc(PyObject *o)

{

PyCapsule *capsule = (PyCapsule *)o;

if (capsule->destructor) {

capsule->destructor(o);

}

PyObject_DEL(o);

}

static PyObject *

capsule_repr(PyObject *o)

{

PyCapsule *capsule = (PyCapsule *)o;

const char *name;

const char *quote;

if (capsule->name) {

quote = "\"";

name = capsule->name;

} else {

quote = "";

name = "NULL";

}

return PyUnicode_FromFormat("<capsule object %s%s%s at %p>",

quote, name, quote, capsule);

}

PyDoc_STRVAR(PyCapsule_Type__doc__,

");

PyTypeObject PyCapsule_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"PyCapsule", /*tp_name*/

sizeof(PyCapsule), /*tp_basicsize*/

0, /*tp_itemsize*/

/* methods */

capsule_dealloc, /*tp_dealloc*/

0, /*tp_print*/

0, /*tp_getattr*/

0, /*tp_setattr*/

0, /*tp_reserved*/

capsule_repr, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

0, /*tp_hash*/

0, /*tp_call*/

0, /*tp_str*/

0, /*tp_getattro*/

0, /*tp_setattro*/

0, /*tp_as_buffer*/

0, /*tp_flags*/

PyCapsule_Type__doc__ /*tp_doc*/

};