/* Wrap void * pointers to be passed between C modules */

#include "Python.h"

/* Internal structure of PyCapsule */
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;
}


int
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_Destructor
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;
}


int
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;
}


int
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;
}


int
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;
}


int
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 PyErr_NoMemory();
 }

 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__,
"Capsule objects let you wrap a C \"void *\" pointer in a Python\n\
object. They're a way of passing data through the Python interpreter\n\
without creating your own custom type.\n\
\n\
Capsules are used for communication between extension modules.\n\
They provide a way for an extension module to export a C interface\n\
to other extension modules, so that extension modules can use the\n\
Python import mechanism to link to one another.\n\
");

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_vectorcall_offset*/
 0, /*tp_getattr*/
 0, /*tp_setattr*/
 0, /*tp_as_async*/
 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*/
};