static oskar_Sky* get_handle(PyObject* capsule)
{
oskar_Sky* h = 0;
if (!PyCapsule_CheckExact(capsule))
{
PyErr_SetString(PyExc_RuntimeError, "Input is not a PyCapsule object!");
return 0;
}
h = (oskar_Sky*) PyCapsule_GetPointer(capsule, name);
if (!h)
{
PyErr_SetString(PyExc_RuntimeError,
"Unable to convert PyCapsule object to pointer.");
return 0;
}
return h;
}
PyObject * mlabraw_oldeval(PyObject *, PyObject *args)
{
//XXX how large should this be?
const int BUFSIZE=10000;
char buffer[BUFSIZE];
char *lStr;
char *retStr = buffer;
PyObject *ret;
PyObject *lHandle;
if (! PyArg_ParseTuple(args, "Os:eval", &lHandle, &lStr)) return NULL;
if (! PyCapsule_CheckExact(lHandle)) {
PyErr_SetString(PyExc_TypeError, "Invalid object passed as mlabraw session handle");
return NULL;
}
engOutputBuffer((Engine *)PyCapsule_GetPointer(lHandle, NULL), retStr, BUFSIZE-1);
if (engEvalString((Engine *)PyCapsule_GetPointer(lHandle, NULL), lStr) != 0) {
PyErr_SetString(mlabraw_error,
"Unable to evaluate string in MATLAB(TM) workspace");
return NULL;
}
// skip the prompt if there is one
if (strncmp(">> ", retStr, 3) == 0) {
retStr += 3;
}
else {
//XXX I think there is no prompt under windoze
// printf("###DEBUG: matlab output doesn't start with \">> \"!\n"
// "It starts with: '%s'\n"
// "The command was: '%s'\n", retStr, lStr);
}
// "??? " is how an error message begins in matlab
// obviously there is no proper way to test whether a command was
// succesful... AAARGH
if (strncmp("??? ", retStr, 4) == 0) {
PyErr_SetString(mlabraw_error, retStr + 4); // skip "??? "
return NULL;
}
#ifdef PY3K
ret = PyUnicode_FromString(retStr);
#else
ret = (PyObject *)PyString_FromString(retStr);
#endif
return ret;
}
static void _cffi_init(void)
{
PyObject *module = PyImport_ImportModule("_cffi_backend");
PyObject *c_api_object;
if (module == NULL)
return;
c_api_object = PyObject_GetAttrString(module, "_C_API");
if (c_api_object == NULL)
return;
if (!PyCapsule_CheckExact(c_api_object)) {
PyErr_SetNone(PyExc_ImportError);
return;
}
memcpy(_cffi_exports, PyCapsule_GetPointer(c_api_object, "cffi"),
_CFFI_NUM_EXPORTS * sizeof(void *));
}
void *
PyCObject_AsVoidPtr(PyObject *self)
{
if (self) {
if (PyCapsule_CheckExact(self)) {
const char *name = PyCapsule_GetName(self);
return (void *)PyCapsule_GetPointer(self, name);
}
if (self->ob_type == &PyCObject_Type)
return ((PyCObject *)self)->cobject;
PyErr_SetString(PyExc_TypeError,
"PyCObject_AsVoidPtr with non-C-object");
}
if (!PyErr_Occurred())
PyErr_SetString(PyExc_TypeError,
"PyCObject_AsVoidPtr called with null pointer");
return NULL;
}
/*
* Convert a Python object to the values needed to create a voidptr.
*/
static int vp_convertor(PyObject *arg, struct vp_values *vp)
{
void *ptr;
SIP_SSIZE_T size = -1;
int rw = TRUE;
if (arg == Py_None)
ptr = NULL;
#if defined(SIP_USE_PYCAPSULE)
else if (PyCapsule_CheckExact(arg))
ptr = PyCapsule_GetPointer(arg, NULL);
#endif
#if defined(SIP_SUPPORT_PYCOBJECT)
else if (PyCObject_Check(arg))
ptr = PyCObject_AsVoidPtr(arg);
#endif
else if (PyObject_TypeCheck(arg, &sipVoidPtr_Type))
{
ptr = ((sipVoidPtrObject *)arg)->voidptr;
size = ((sipVoidPtrObject *)arg)->size;
rw = ((sipVoidPtrObject *)arg)->rw;
}
else
{
ptr = PyLong_AsVoidPtr(arg);
if (PyErr_Occurred())
{
#if PY_VERSION_HEX >= 0x03010000
PyErr_SetString(PyExc_TypeError, "a single integer, CObject, None or another sip.voidptr object is required");
#else
PyErr_SetString(PyExc_TypeError, "a single integer, Capsule, CObject, None or another sip.voidptr object is required");
#endif
return 0;
}
}
vp->voidptr = ptr;
vp->size = size;
vp->rw = rw;
return 1;
}
static int
Matcher_init(Matcher *self, PyObject *args, PyObject *kwds)
{
PyObject *items = NULL, *p = NULL, *py_items = NULL, *level1 = NULL, *level2 = NULL, *level3 = NULL, *collator = NULL;
int32_t i = 0;
UErrorCode status = U_ZERO_ERROR;
UCollator *col = NULL;
if (!PyArg_ParseTuple(args, "OOOOO", &items, &collator, &level1, &level2, &level3)) return -1;
// Clone the passed in collator (cloning is needed as collators are not thread safe)
if (!PyCapsule_CheckExact(collator)) { PyErr_SetString(PyExc_TypeError, "Collator must be a capsule"); return -1; }
col = (UCollator*)PyCapsule_GetPointer(collator, NULL);
if (col == NULL) return -1;
self->collator = ucol_safeClone(col, NULL, NULL, &status);
col = NULL;
if (U_FAILURE(status)) { self->collator = NULL; PyErr_SetString(PyExc_ValueError, u_errorName(status)); return -1; }
py_items = PySequence_Fast(items, "Must pass in two sequence objects");
if (py_items == NULL) goto end;
self->item_count = (uint32_t)PySequence_Size(items);
self->items = (UChar**)calloc(self->item_count, sizeof(UChar*));
self->item_lengths = (int32_t*)calloc(self->item_count, sizeof(uint32_t));
self->level1 = python_to_icu(level1, NULL);
self->level2 = python_to_icu(level2, NULL);
self->level3 = python_to_icu(level3, NULL);
if (self->items == NULL || self->item_lengths == NULL ) { PyErr_NoMemory(); goto end; }
if (self->level1 == NULL || self->level2 == NULL || self->level3 == NULL) goto end;
for (i = 0; i < (int32_t)self->item_count; i++) {
p = PySequence_Fast_GET_ITEM(py_items, i);
self->items[i] = python_to_icu(p, self->item_lengths + i);
if (self->items[i] == NULL) { PyErr_NoMemory(); goto end; }
}
end:
Py_XDECREF(py_items);
if (PyErr_Occurred()) { free_matcher(self); }
return (PyErr_Occurred()) ? -1 : 0;
}
PyObject * mlabraw_put(PyObject *, PyObject *args)
{
char *lName;
PyObject *lHandle;
PyObject *lSource;
PyObject *encoded_source;
mxArray *lArray = NULL;
//FIXME should make these objects const
if (! PyArg_ParseTuple(args, "OsO:put", &lHandle, &lName, &lSource)) return NULL;
if (! PyCapsule_CheckExact(lHandle)) {
PyErr_SetString(PyExc_TypeError, "Invalid object passed as mlabraw session handle");
return NULL;
}
Py_INCREF(lSource);
#ifdef PY3K
if (PyUnicode_Check(lSource)) {
encoded_source = PyUnicode_AsUTF8String(lSource);
lArray = char2mx(encoded_source);
Py_DECREF(encoded_source);
#else
if (PyString_Check(lSource)) {
lArray = char2mx(lSource);
#endif
} else {
lArray = numeric2mx(lSource);
}
Py_DECREF(lSource);
if (lArray == NULL) {
return NULL; // Above converter already set error message
}
// for matlab version >= 6.5 (FIXME UNTESTED)
#ifdef _V6_5_OR_LATER
if (engPutVariable((Engine *)PyCapsule_GetPointer(lHandle, NULL), lName, lArray) != 0) {
#else
mxSetName(lArray, lName);
if (engPutArray((Engine *)PyCapsule_GetPointer(lHandle, NULL), lArray) != 0) {
#endif
PyErr_SetString(mlabraw_error,
"Unable to put matrix into MATLAB(TM) workspace");
mxDestroyArray(lArray);
return NULL;
}
mxDestroyArray(lArray);
Py_INCREF(Py_None);
return Py_None;
}
static const char * DOC =
"Mlabraw -- Low-level MATLAB(tm) Engine Interface\n"
"\n"
" open - Open a MATLAB(tm) engine session\n"
" close - Close a MATLAB(tm) engine session\n"
" eval - Evaluates a string in the MATLAB(tm) session\n"
" get - Gets a matrix from the MATLAB(tm) session\n"
" put - Places a matrix into the MATLAB(tm) session\n"
"\n"
"The Numeric package must be installed for this module to be used.\n"
"\n"
"Copyright & Disclaimer\n"
"======================\n"
"Copyright (c) 2002-2007 Alexander Schmolck <*****@*****.**>\n"
"\n"
"Copyright (c) 1998,1999 Andrew Sterian. All Rights Reserved. mailto: [email protected]\n"
"\n"
"Copyright (c) 1998,1999 THE REGENTS OF THE UNIVERSITY OF MICHIGAN. ALL RIGHTS RESERVED \n"
"\n"
"Permission to use, copy, modify, and distribute this software and its\n"
"documentation for any purpose and without fee is hereby granted, provided\n"
"that the above copyright notices appear in all copies and that both these\n"
"copyright notices and this permission notice appear in supporting\n"
"documentation, and that the name of The University of Michigan not be used\n"
"in advertising or publicity pertaining to distribution of the software\n"
"without specific, written prior permission.\n"
"\n"
"THIS SOFTWARE IS PROVIDED AS IS, WITHOUT REPRESENTATION AS TO ITS FITNESS\n"
"FOR ANY PURPOSE, AND WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR\n"
"IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF\n"
"MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE REGENTS OF THE\n"
"UNIVERSITY OF MICHIGAN SHALL NOT BE LIABLE FOR ANY DAMAGES, INCLUDING\n"
"SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WITH RESPECT TO ANY\n"
"CLAIM ARISING OUT OF OR IN CONNECTION WITH THE USE OF THE SOFTWARE, EVEN IF\n"
"IT HAS BEEN OR IS HEREAFTER ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n"
"\n";
static PyMethodDef MlabrawMethods[] = {
{ "open", mlabraw_open, METH_VARARGS, open_doc },
{ "close", mlabraw_close, METH_VARARGS, close_doc },
{ "oldeval", mlabraw_oldeval, METH_VARARGS, "" },
{ "eval", mlabraw_eval, METH_VARARGS, eval_doc }, //FIXME doc
{ "get", mlabraw_get, METH_VARARGS, get_doc },
{ "put", mlabraw_put, METH_VARARGS, put_doc },
{ NULL, NULL, 0 , NULL}, // sentinel
};
struct module_state {
PyObject *error;
};
#ifdef PY3K
#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
#else
#define GETSTATE(m) (&_state)
static struct module_state _state;
#endif
#ifdef PY3K
static int myextension_traverse(PyObject *m, visitproc visit, void *arg) {
Py_VISIT(GETSTATE(m)->error);
return 0;
}
static int myextension_clear(PyObject *m) {
Py_CLEAR(GETSTATE(m)->error);
return 0;
}
static int
Sexp_sexp_set(PyObject *self, PyObject *obj, void *closure)
{
#if (PY_VERSION_HEX < 0x02070000)
if (! PyCObject_Check(obj)) {
PyErr_SetString(PyExc_TypeError, "The value must be a CObject.");
return -1;
}
#else
if (! PyCapsule_CheckExact(obj)) {
PyErr_SetString(PyExc_TypeError, "The value must be a Capsule");
return -1;
}
#endif
SexpObject *sexpobj_orig = ((PySexpObject*)self)->sObj;
#if (PY_VERSION_HEX < 0x02070000)
SexpObject *sexpobj = (SexpObject *)(PyCObject_AsVoidPtr(obj));
#else
SexpObject *sexpobj = (SexpObject *)(PyCapsule_GetPointer(obj,
"rpy2.rinterface._C_API_"));
#endif
if (obj == NULL) {
PyErr_SetString(PyExc_TypeError,
"The value must be a CObject or a Capsule of name 'rpy2.rinterface._C_API_'.");
return -1;
}
#ifdef RPY_DEBUG_COBJECT
printf("Setting %p (count: %i) to %p (count: %i)\n",
sexpobj_orig, (int)sexpobj_orig->count,
sexpobj, (int)sexpobj->count);
#endif
if ( (sexpobj_orig->sexp != R_NilValue) &
(TYPEOF(sexpobj_orig->sexp) != TYPEOF(sexpobj->sexp))
) {
PyErr_Format(PyExc_ValueError,
"Mismatch in SEXP type (as returned by typeof)");
return -1;
}
SEXP sexp = sexpobj->sexp;
if (! sexp) {
PyErr_Format(PyExc_ValueError, "NULL SEXP.");
return -1;
}
/*FIXME: increment count seems needed, but is this leak free ? */
sexpobj->count += 2;
sexpobj_orig->count += 1;
SexpObject_clear(sexpobj_orig);
RPY_SEXP(((PySexpObject*)self)) = sexp;
return 0;
}
PyMODINIT_FUNC SIP_MODULE_ENTRY()
#endif
{
static PyMethodDef sip_methods[] = {
{0, 0, 0, 0}
};
#if PY_MAJOR_VERSION >= 3
static PyModuleDef sip_module_def = {
PyModuleDef_HEAD_INIT,
"MyMath",
NULL,
-1,
sip_methods,
NULL,
NULL,
NULL,
NULL
};
#endif
PyObject *sipModule, *sipModuleDict;
PyObject *sip_sipmod, *sip_capiobj;
/* Initialise the module and get it's dictionary. */
#if PY_MAJOR_VERSION >= 3
sipModule = PyModule_Create(&sip_module_def);
#elif PY_VERSION_HEX >= 0x02050000
sipModule = Py_InitModule(sipName_MyMath, sip_methods);
#else
sipModule = Py_InitModule(const_cast<char *>(sipName_MyMath), sip_methods);
#endif
if (sipModule == NULL)
SIP_MODULE_RETURN(NULL);
sipModuleDict = PyModule_GetDict(sipModule);
/* Get the SIP module's API. */
#if PY_VERSION_HEX >= 0x02050000
sip_sipmod = PyImport_ImportModule(SIP_MODULE_NAME);
#else
sip_sipmod = PyImport_ImportModule(const_cast<char *>(SIP_MODULE_NAME));
#endif
if (sip_sipmod == NULL)
{
SIP_MODULE_DISCARD(sipModule);
SIP_MODULE_RETURN(NULL);
}
sip_capiobj = PyDict_GetItemString(PyModule_GetDict(sip_sipmod), "_C_API");
Py_DECREF(sip_sipmod);
#if defined(SIP_USE_PYCAPSULE)
if (sip_capiobj == NULL || !PyCapsule_CheckExact(sip_capiobj))
#else
if (sip_capiobj == NULL || !PyCObject_Check(sip_capiobj))
#endif
{
SIP_MODULE_DISCARD(sipModule);
SIP_MODULE_RETURN(NULL);
}
#if defined(SIP_USE_PYCAPSULE)
sipAPI_MyMath = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, SIP_MODULE_NAME "._C_API"));
#else
sipAPI_MyMath = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif
#if defined(SIP_USE_PYCAPSULE)
if (sipAPI_MyMath == NULL)
{
SIP_MODULE_DISCARD(sipModule);
SIP_MODULE_RETURN(NULL);
}
#endif
/* Export the module and publish it's API. */
if (sipExportModule(&sipModuleAPI_MyMath,SIP_API_MAJOR_NR,SIP_API_MINOR_NR,0) < 0)
{
SIP_MODULE_DISCARD(sipModule);
SIP_MODULE_RETURN(0);
}
/* Initialise the module now all its dependencies have been set up. */
if (sipInitModule(&sipModuleAPI_MyMath,sipModuleDict) < 0)
{
SIP_MODULE_DISCARD(sipModule);
SIP_MODULE_RETURN(0);
}
SIP_MODULE_RETURN(sipModule);
}
static PyObject* spsolve(PyObject *self, PyObject *args,
PyObject *kwrds)
{
spmatrix *B, *X=NULL;
cholmod_sparse *Bc=NULL, *Xc=NULL;
PyObject *F;
cholmod_factor *L;
int n, sys=0;
#if PY_MAJOR_VERSION >= 3
const char *descr;
#else
char *descr;
#endif
char *kwlist[] = {"F", "B", "sys", NULL};
int sysvalues[] = {CHOLMOD_A, CHOLMOD_LDLt, CHOLMOD_LD,
CHOLMOD_DLt, CHOLMOD_L, CHOLMOD_Lt, CHOLMOD_D, CHOLMOD_P,
CHOLMOD_Pt };
if (!set_options()) return NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|i", kwlist, &F,
&B, &sys)) return NULL;
#if PY_MAJOR_VERSION >= 3
if (!PyCapsule_CheckExact(F) || !(descr = PyCapsule_GetName(F)))
err_CO("F");
if (strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
L = (cholmod_factor *) PyCapsule_GetPointer(F, descr);
#else
if (!PyCObject_Check(F)) err_CO("F");
descr = PyCObject_GetDesc(F);
if (!descr || strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
L = (cholmod_factor *) PyCObject_AsVoidPtr(F);
#endif
if (L->xtype == CHOLMOD_PATTERN)
PY_ERR(PyExc_ValueError, "called with symbolic factor");
n = L->n;
if (L->minor<n) PY_ERR(PyExc_ArithmeticError, "singular matrix");
if (sys < 0 || sys > 8)
PY_ERR(PyExc_ValueError, "invalid value for sys");
if (!SpMatrix_Check(B) ||
(SP_ID(B) == DOUBLE && L->xtype == CHOLMOD_COMPLEX) ||
(SP_ID(B) == COMPLEX && L->xtype == CHOLMOD_REAL))
PY_ERR_TYPE("B must a sparse matrix of the same "
"numerical type as F");
if (SP_NROWS(B) != n)
PY_ERR(PyExc_ValueError, "incompatible dimensions for B");
if (!(Bc = create_matrix(B))) return PyErr_NoMemory();
Xc = CHOL(spsolve)(sysvalues[sys], L, Bc, &Common);
free_matrix(Bc);
if (Common.status == CHOLMOD_OUT_OF_MEMORY) return PyErr_NoMemory();
if (Common.status != CHOLMOD_OK)
PY_ERR(PyExc_ValueError, "solve step failed");
if (!(X = SpMatrix_New(Xc->nrow, Xc->ncol,
((int_t*)Xc->p)[Xc->ncol], (L->xtype == CHOLMOD_REAL ? DOUBLE :
COMPLEX)))) {
CHOL(free_sparse)(&Xc, &Common);
return PyErr_NoMemory();
}
memcpy(SP_COL(X), Xc->p, (Xc->ncol+1)*sizeof(int_t));
memcpy(SP_ROW(X), Xc->i, ((int_t *)Xc->p)[Xc->ncol]*sizeof(int_t));
memcpy(SP_VAL(X), Xc->x,
((int_t *) Xc->p)[Xc->ncol]*E_SIZE[SP_ID(X)]);
CHOL(free_sparse)(&Xc, &Common);
return (PyObject *) X;
}
static PyObject* solve(PyObject *self, PyObject *args, PyObject *kwrds)
{
matrix *B;
PyObject *F;
int i, n, oB=0, ldB=0, nrhs=-1, sys=0;
#if PY_MAJOR_VERSION >= 3
const char *descr;
#else
char *descr;
#endif
char *kwlist[] = {"F", "B", "sys", "nrhs", "ldB", "offsetB", NULL};
int sysvalues[] = { CHOLMOD_A, CHOLMOD_LDLt, CHOLMOD_LD,
CHOLMOD_DLt, CHOLMOD_L, CHOLMOD_Lt, CHOLMOD_D, CHOLMOD_P,
CHOLMOD_Pt };
if (!set_options()) return NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "OO|iiii", kwlist,
&F, &B, &sys, &nrhs, &ldB, &oB)) return NULL;
#if PY_MAJOR_VERSION >= 3
if (!PyCapsule_CheckExact(F) || !(descr = PyCapsule_GetName(F)))
err_CO("F");
if (strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
cholmod_factor *L = (cholmod_factor *) PyCapsule_GetPointer(F, descr);
#else
if (!PyCObject_Check(F)) err_CO("F");
descr = PyCObject_GetDesc(F);
if (!descr || strncmp(descr, "CHOLMOD FACTOR", 14))
PY_ERR_TYPE("F is not a CHOLMOD factor");
cholmod_factor *L = (cholmod_factor *) PyCObject_AsVoidPtr(F);
#endif
if (L->xtype == CHOLMOD_PATTERN)
PY_ERR(PyExc_ValueError, "called with symbolic factor");
n = L->n;
if (L->minor<n) PY_ERR(PyExc_ArithmeticError, "singular matrix");
if (sys < 0 || sys > 8)
PY_ERR(PyExc_ValueError, "invalid value for sys");
if (!Matrix_Check(B) || MAT_ID(B) == INT ||
(MAT_ID(B) == DOUBLE && L->xtype == CHOLMOD_COMPLEX) ||
(MAT_ID(B) == COMPLEX && L->xtype == CHOLMOD_REAL))
PY_ERR_TYPE("B must a dense matrix of the same numerical "
"type as F");
if (nrhs < 0) nrhs = MAT_NCOLS(B);
if (n == 0 || nrhs == 0) return Py_BuildValue("");
if (ldB == 0) ldB = MAX(1,MAT_NROWS(B));
if (ldB < MAX(1,n)) err_ld("ldB");
if (oB < 0) err_nn_int("offsetB");
if (oB + (nrhs-1)*ldB + n > MAT_LGT(B)) err_buf_len("B");
cholmod_dense *x;
cholmod_dense *b = CHOL(allocate_dense)(n, 1, n,
(MAT_ID(B) == DOUBLE ? CHOLMOD_REAL : CHOLMOD_COMPLEX),
&Common);
if (Common.status == CHOLMOD_OUT_OF_MEMORY) return PyErr_NoMemory();
void *b_old = b->x;
for (i=0; i<nrhs; i++){
b->x = MAT_BUF(B) + (i*ldB + oB)*E_SIZE[MAT_ID(B)];
x = CHOL(solve) (sysvalues[sys], L, b, &Common);
if (Common.status != CHOLMOD_OK){
PyErr_SetString(PyExc_ValueError, "solve step failed");
CHOL(free_dense)(&x, &Common);
CHOL(free_dense)(&b, &Common);
return NULL;
}
memcpy(b->x, x->x, n*E_SIZE[MAT_ID(B)]);
CHOL(free_dense)(&x, &Common);
}
b->x = b_old;
CHOL(free_dense)(&b, &Common);
return Py_BuildValue("");
}
static PyObject* numeric(PyObject *self, PyObject *args)
{
spmatrix *A;
PyObject *F;
cholmod_factor *Lc;
cholmod_sparse *Ac = NULL;
char uplo;
#if PY_MAJOR_VERSION >= 3
const char *descr;
#else
char *descr;
#endif
if (!set_options()) return NULL;
if (!PyArg_ParseTuple(args, "OO", &A, &F)) return NULL;
if (!SpMatrix_Check(A) || SP_NROWS(A) != SP_NCOLS(A))
PY_ERR_TYPE("A is not a sparse matrix");
#if PY_MAJOR_VERSION >= 3
if (!PyCapsule_CheckExact(F) || !(descr = PyCapsule_GetName(F)))
err_CO("F");
#else
if (!PyCObject_Check(F)) err_CO("F");
descr = PyCObject_GetDesc(F);
if (!descr) PY_ERR_TYPE("F is not a CHOLMOD factor");
#endif
if (SP_ID(A) == DOUBLE){
if (!strcmp(descr, "CHOLMOD FACTOR D L"))
uplo = 'L';
else if (!strcmp(descr, "CHOLMOD FACTOR D U"))
uplo = 'U';
else
PY_ERR_TYPE("F is not the CHOLMOD factor of a 'd' matrix");
} else {
if (!strcmp(descr, "CHOLMOD FACTOR Z L"))
uplo = 'L';
else if (!strcmp(descr, "CHOLMOD FACTOR Z U"))
uplo = 'U';
else
PY_ERR_TYPE("F is not the CHOLMOD factor of a 'z' matrix");
}
#if PY_MAJOR_VERSION >= 3
Lc = (cholmod_factor *) PyCapsule_GetPointer(F, descr);
#else
Lc = (cholmod_factor *) PyCObject_AsVoidPtr(F);
#endif
if (!(Ac = pack(A, uplo))) return PyErr_NoMemory();
CHOL(factorize) (Ac, Lc, &Common);
CHOL(free_sparse)(&Ac, &Common);
if (Common.status < 0) switch (Common.status) {
case CHOLMOD_OUT_OF_MEMORY:
return PyErr_NoMemory();
default:
PyErr_SetString(PyExc_ValueError, "factorization failed");
return NULL;
}
if (Common.status > 0) switch (Common.status) {
case CHOLMOD_NOT_POSDEF:
PyErr_SetObject(PyExc_ArithmeticError, Py_BuildValue("i",
Lc->minor));
return NULL;
break;
case CHOLMOD_DSMALL:
/* This never happens unless we change the default value
* of Common.dbound (0.0). */
if (Lc->is_ll)
PyErr_Warn(PyExc_RuntimeWarning, "tiny diagonal "\
"elements in L");
else
PyErr_Warn(PyExc_RuntimeWarning, "tiny diagonal "\
"elements in D");
break;
default:
PyErr_Warn(PyExc_UserWarning, "");
}
return Py_BuildValue("");
}
/*
* Convert a Python object to the values needed to create a voidptr.
*/
static int vp_convertor(PyObject *arg, struct vp_values *vp)
{
void *ptr;
SIP_SSIZE_T size = -1;
int rw = TRUE;
if (arg == Py_None)
ptr = NULL;
#if defined(SIP_USE_PYCAPSULE)
else if (PyCapsule_CheckExact(arg))
ptr = PyCapsule_GetPointer(arg, NULL);
#endif
#if defined(SIP_SUPPORT_PYCOBJECT)
else if (PyCObject_Check(arg))
ptr = PyCObject_AsVoidPtr(arg);
#endif
else if (PyObject_TypeCheck(arg, &sipVoidPtr_Type))
{
ptr = ((sipVoidPtrObject *)arg)->voidptr;
size = ((sipVoidPtrObject *)arg)->size;
rw = ((sipVoidPtrObject *)arg)->rw;
}
#if PY_VERSION_HEX >= 0x02060300
else if (PyObject_CheckBuffer(arg))
{
Py_buffer view;
if (PyObject_GetBuffer(arg, &view, PyBUF_SIMPLE) < 0)
return 0;
ptr = view.buf;
size = view.len;
rw = !view.readonly;
PyBuffer_Release(&view);
}
#endif
#if PY_VERSION_HEX < 0x03000000
else if (PyObject_AsReadBuffer(arg, (const void **)&ptr, &size) >= 0)
{
rw = (Py_TYPE(arg)->tp_as_buffer->bf_getwritebuffer != NULL);
}
#endif
else
{
PyErr_Clear();
ptr = PyLong_AsVoidPtr(arg);
if (PyErr_Occurred())
{
#if PY_VERSION_HEX >= 0x03010000
PyErr_SetString(PyExc_TypeError, "a single integer, CObject, None, buffer protocol implementor or another sip.voidptr object is required");
#else
PyErr_SetString(PyExc_TypeError, "a single integer, Capsule, CObject, None, buffer protocol implementor or another sip.voidptr object is required");
#endif
return 0;
}
}
vp->voidptr = ptr;
vp->size = size;
vp->rw = rw;
return 1;
}
static PyObject *bpy_lib_exit(BPy_Library *self, PyObject *UNUSED(args))
{
Main *bmain = CTX_data_main(BPy_GetContext());
Main *mainl = NULL;
int err = 0;
BKE_main_id_flag_all(bmain, LIB_TAG_PRE_EXISTING, true);
/* here appending/linking starts */
mainl = BLO_library_link_begin(bmain, &(self->blo_handle), self->relpath);
{
int idcode_step = 0, idcode;
while ((idcode = BKE_idcode_iter_step(&idcode_step))) {
if (BKE_idcode_is_linkable(idcode)) {
const char *name_plural = BKE_idcode_to_name_plural(idcode);
PyObject *ls = PyDict_GetItemString(self->dict, name_plural);
// printf("lib: %s\n", name_plural);
if (ls && PyList_Check(ls)) {
/* loop */
Py_ssize_t size = PyList_GET_SIZE(ls);
Py_ssize_t i;
PyObject *item;
const char *item_str;
for (i = 0; i < size; i++) {
item = PyList_GET_ITEM(ls, i);
item_str = _PyUnicode_AsString(item);
// printf(" %s\n", item_str);
if (item_str) {
ID *id = BLO_library_link_named_part(mainl, &(self->blo_handle), idcode, item_str);
if (id) {
#ifdef USE_RNA_DATABLOCKS
/* swap name for pointer to the id */
Py_DECREF(item);
item = PyCapsule_New((void *)id, NULL, NULL);
#endif
}
else {
bpy_lib_exit_warn_idname(self, name_plural, item_str);
/* just warn for now */
/* err = -1; */
#ifdef USE_RNA_DATABLOCKS
item = Py_INCREF_RET(Py_None);
#endif
}
/* ID or None */
}
else {
/* XXX, could complain about this */
bpy_lib_exit_warn_type(self, item);
PyErr_Clear();
#ifdef USE_RNA_DATABLOCKS
item = Py_INCREF_RET(Py_None);
#endif
}
#ifdef USE_RNA_DATABLOCKS
PyList_SET_ITEM(ls, i, item);
#endif
}
}
}
}
}
if (err == -1) {
/* exception raised above, XXX, this leaks some memory */
BLO_blendhandle_close(self->blo_handle);
self->blo_handle = NULL;
BKE_main_id_flag_all(bmain, LIB_TAG_PRE_EXISTING, false);
return NULL;
}
else {
Library *lib = mainl->curlib; /* newly added lib, assign before append end */
BLO_library_link_end(mainl, &(self->blo_handle), self->flag, NULL, NULL);
BLO_blendhandle_close(self->blo_handle);
self->blo_handle = NULL;
/* copied from wm_operator.c */
{
/* mark all library linked objects to be updated */
BKE_main_lib_objects_recalc_all(G.main);
/* append, rather than linking */
if ((self->flag & FILE_LINK) == 0) {
BKE_library_make_local(bmain, lib, true);
}
}
BKE_main_id_flag_all(bmain, LIB_TAG_PRE_EXISTING, false);
/* finally swap the capsules for real bpy objects
* important since BLO_library_append_end initializes NodeTree types used by srna->refine */
{
int idcode_step = 0, idcode;
while ((idcode = BKE_idcode_iter_step(&idcode_step))) {
if (BKE_idcode_is_linkable(idcode)) {
const char *name_plural = BKE_idcode_to_name_plural(idcode);
PyObject *ls = PyDict_GetItemString(self->dict, name_plural);
if (ls && PyList_Check(ls)) {
Py_ssize_t size = PyList_GET_SIZE(ls);
Py_ssize_t i;
PyObject *item;
for (i = 0; i < size; i++) {
item = PyList_GET_ITEM(ls, i);
if (PyCapsule_CheckExact(item)) {
PointerRNA id_ptr;
ID *id;
id = PyCapsule_GetPointer(item, NULL);
Py_DECREF(item);
RNA_id_pointer_create(id, &id_ptr);
item = pyrna_struct_CreatePyObject(&id_ptr);
PyList_SET_ITEM(ls, i, item);
}
}
}
}
}
}
Py_RETURN_NONE;
}
}
static
bool Check(PyObject* obj){
return PyCapsule_CheckExact(obj);
}
// Wrapper function for getting int from a Python object, with 2/3 ifdefs
int as_int(PyObject *target)
{
int result;
#if PY_MAJOR_VERSION >= 3
if (!PyLong_Check(target)) {
#else
if (!PyInt_Check(target)) {
#endif
PyErr_SetString(PyExc_ValueError, "Non-integer Python object in as_int");
return -1;
}
#if PY_MAJOR_VERSION >= 3
result = (int) PyLong_AsLong(target);
#else
result = (int) PyInt_AsLong(target);
#endif
return result;
}
// Wrapper function to check if a python object is an int
int is_pyint(PyObject *target)
{
#if PY_MAJOR_VERSION >= 3
return PyLong_Check(target);
#else
return PyInt_Check(target);
#endif
}
// The VMDApp instance will be found in the VMDApp module, under the
// VMDApp dictionary entry. Got it?
VMDApp *get_vmdapp() {
PyObject *module_dict = PyEval_GetBuiltins();
if (!module_dict)
return NULL;
// Python 3 uses a "capsule" to store C pointers
#if PY_MAJOR_VERSION >= 3
PyObject *c_obj = PyDict_GetItemString(module_dict, "-vmdapp-");
if (!c_obj || PyErr_Occurred())
return NULL;
if (PyCapsule_CheckExact(c_obj))
return (VMDApp *)PyCapsule_GetPointer(c_obj, "-vmdapp-");
// Python 2 instead uses the idea of a "C Object"
#else
PyObject *c_obj = PyDict_GetItemString(module_dict, (char *)"-vmdapp-");
if (!c_obj || PyErr_Occurred())
return NULL;
if (PyCObject_Check(c_obj))
return (VMDApp *)PyCObject_AsVoidPtr(c_obj);
#endif
return NULL;
}
void set_vmdapp(VMDApp *app) {
PyObject *module_dict = PyEval_GetBuiltins();
PyObject *cap;
#if PY_MAJOR_VERSION >= 3
cap = PyCapsule_New(app, "-vmdapp-", NULL);
#else
cap = PyCObject_FromVoidPtr(app, NULL);
#endif
PyDict_SetItemString(module_dict, (const char *)"-vmdapp-", cap);
}
static PyObject *Py_GenericFilter(PyObject *obj, PyObject *args)
{
PyArrayObject *input = NULL, *output = NULL, *footprint = NULL;
PyObject *fnc = NULL, *extra_arguments = NULL, *extra_keywords = NULL;
void *func = NULL, *data = NULL;
NI_PythonCallbackData cbdata;
int mode;
PyArray_Dims origin;
double cval;
ccallback_t callback;
static ccallback_signature_t callback_signatures[] = {
{"int (double *, intptr_t, double *, void *)"},
{"int (double *, npy_intp, double *, void *)"},
#if NPY_SIZEOF_INTP == NPY_SIZEOF_SHORT
{"int (double *, short, double *, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_INT
{"int (double *, int, double *, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_LONG
{"int (double *, long, double *, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_LONGLONG
{"int (double *, long long, double *, void *)"},
#endif
{NULL}
};
callback.py_function = NULL;
callback.c_function = NULL;
if (!PyArg_ParseTuple(args, "O&OO&O&idO&OO",
NI_ObjectToInputArray, &input,
&fnc,
NI_ObjectToInputArray, &footprint,
NI_ObjectToOutputArray, &output,
&mode, &cval,
PyArray_IntpConverter, &origin,
&extra_arguments, &extra_keywords)) {
goto exit;
}
if (!_validate_origin(input, origin)) {
goto exit;
}
if (!PyTuple_Check(extra_arguments)) {
PyErr_SetString(PyExc_RuntimeError, "extra_arguments must be a tuple");
goto exit;
}
if (!PyDict_Check(extra_keywords)) {
PyErr_SetString(PyExc_RuntimeError,
"extra_keywords must be a dictionary");
goto exit;
}
if (PyCapsule_CheckExact(fnc) && PyCapsule_GetName(fnc) == NULL) {
func = PyCapsule_GetPointer(fnc, NULL);
data = PyCapsule_GetContext(fnc);
#if PY_VERSION_HEX < 0x03000000
} else if (PyCObject_Check(fnc)) {
/* 'Legacy' low-level callable on Py2 */
func = PyCObject_AsVoidPtr(fnc);
data = PyCObject_GetDesc(fnc);
#endif
} else {
int ret;
ret = ccallback_prepare(&callback, callback_signatures, fnc, CCALLBACK_DEFAULTS);
if (ret == -1) {
goto exit;
}
if (callback.py_function != NULL) {
cbdata.extra_arguments = extra_arguments;
cbdata.extra_keywords = extra_keywords;
callback.info_p = (void*)&cbdata;
func = Py_FilterFunc;
data = (void*)&callback;
}
else {
func = callback.c_function;
data = callback.user_data;
}
}
NI_GenericFilter(input, func, data, footprint, output, (NI_ExtendMode)mode,
cval, origin.ptr);
#ifdef HAVE_WRITEBACKIFCOPY
PyArray_ResolveWritebackIfCopy(output);
#endif
exit:
if (callback.py_function != NULL || callback.c_function != NULL) {
ccallback_release(&callback);
}
Py_XDECREF(input);
Py_XDECREF(output);
Py_XDECREF(footprint);
PyDimMem_FREE(origin.ptr);
return PyErr_Occurred() ? NULL : Py_BuildValue("");
}
PyObject * mlabraw_eval(PyObject *, PyObject *args)
{
//XXX how large should this be? used to be 10000, but looks like matlab
// hangs when it gets bigger than ~9000 I'm not aware of some actual limit
// being documented anywhere; I don't want to make it too small since the
// high overhead of engine calls means that it can be potentially useful to
// eval large chunks.
const int BUFSIZE=4096;
char* fmt = "try, %s; MLABRAW_ERROR_=0; catch, MLABRAW_ERROR_=1; end;";
char buffer[BUFSIZE];
char cmd[BUFSIZE];
char *lStr;
char *retStr = buffer;
PyObject *ret;
PyObject *lHandle;
PyObject *u_ret_str;
PyObject *encoded_ret_str;
if (! PyArg_ParseTuple(args, "Os:eval", &lHandle, &lStr)) return NULL;
if (! PyCapsule_CheckExact(lHandle)) {
PyErr_SetString(PyExc_TypeError, "Invalid object passed as mlabraw session handle");
return NULL;
}
bool ok = my_snprintf(cmd, BUFSIZE, fmt, lStr);
if (!ok) {
PyErr_SetString(mlabraw_error,
"String too long to evaluate.");
return NULL;
}
// std::cout << "DEBUG: CMD " << cmd << std::endl << std::flush;
engOutputBuffer((Engine *)PyCapsule_GetPointer(lHandle, NULL), retStr, BUFSIZE-1);
if (engEvalString((Engine *)PyCapsule_GetPointer(lHandle, NULL), cmd) != 0) {
//std::cout << "DEBUG: RETURN " << retStr << std::endl << std::flush;
#ifdef PY3K
u_ret_str = PyUnicode_DecodeFSDefault(retStr);
encoded_ret_str = PyUnicode_AsUTF8String(u_ret_str);
PyErr_SetString(mlabraw_error, PyBytes_AsString(encoded_ret_str));
Py_DECREF(encoded_ret_str);
Py_DECREF(u_ret_str);
#else
PyErr_SetString(mlabraw_error, retStr);
#endif
return NULL;
}
{
mxArray *lArray = NULL;
char buffer2[BUFSIZE];
char *retStr2 = buffer2;
bool __mlabraw_error;
if (NULL == (lArray = _getMatlabVar(lHandle, "MLABRAW_ERROR_")) ) {
PyErr_SetString(mlabraw_error,
"Something VERY BAD happened whilst trying to evaluate string "
"in MATLAB(TM) workspace.");
return NULL;
}
__mlabraw_error = (bool)*mxGetPr(lArray);
mxDestroyArray(lArray);
if (__mlabraw_error) {
engOutputBuffer((Engine *)PyCapsule_GetPointer(lHandle, NULL), retStr2, BUFSIZE-1);
if (engEvalString((Engine *)PyCapsule_GetPointer(lHandle, NULL),
"disp(subsref(lasterror(),struct('type','.','subs','message')))") != 0) {
PyErr_SetString(mlabraw_error, "THIS SHOULD NOT HAVE HAPPENED!!!");
return NULL;
}
#ifdef PY3K
u_ret_str = PyUnicode_DecodeFSDefault(retStr2 + ((strncmp(">> ", retStr2, 3) == 0) ? 3 : 0));
encoded_ret_str = PyUnicode_AsUTF8String(u_ret_str);
PyErr_SetString(mlabraw_error, PyBytes_AsString(encoded_ret_str));
Py_DECREF(encoded_ret_str);
Py_DECREF(u_ret_str);
#else
PyErr_SetString(mlabraw_error, retStr2 + ((strncmp(">> ", retStr2, 3) == 0) ? 3 : 0));
#endif
return NULL;
}
}
if (strncmp(">> ", retStr, 3) == 0) { retStr += 3; } //FIXME
#ifdef PY3K
//ret = PyUnicode_FromString(retStr);
ret = PyUnicode_DecodeFSDefault(retStr);
#else
ret = (PyObject *)PyString_FromString(retStr);
#endif
return ret;
}
static void
pyccn_Capsule_Destructor(PyObject *capsule)
{
const char *name;
void *pointer;
enum _pyccn_capsules type;
assert(PyCapsule_CheckExact(capsule));
name = PyCapsule_GetName(capsule);
type = name2type(name);
pointer = PyCapsule_GetPointer(capsule, name);
assert(pointer);
switch (type) {
case CLOSURE:
{
PyObject *py_obj_closure;
struct ccn_closure *p = pointer;
py_obj_closure = PyCapsule_GetContext(capsule);
assert(py_obj_closure);
Py_DECREF(py_obj_closure); /* No longer referencing Closure object */
/* If we store something else, than ourselves, it probably is a bug */
assert(capsule == p->data);
free(p);
}
break;
case CONTENT_OBJECT:
{
struct content_object_data *context;
struct ccn_charbuf *p = pointer;
context = PyCapsule_GetContext(capsule);
if (context) {
if (context->pco)
free(context->pco);
ccn_indexbuf_destroy(&context->comps);
free(context);
}
ccn_charbuf_destroy(&p);
}
break;
case HANDLE:
{
struct ccn *p = pointer;
ccn_disconnect(p);
ccn_destroy(&p);
}
break;
case INTEREST:
{
struct interest_data *context;
struct ccn_charbuf *p = pointer;
context = PyCapsule_GetContext(capsule);
if (context) {
if (context->pi)
free(context->pi);
free(context);
}
ccn_charbuf_destroy(&p);
}
break;
case PKEY_PRIV:
case PKEY_PUB:
{
struct ccn_pkey *p = pointer;
ccn_pubkey_free(p);
}
break;
case EXCLUSION_FILTER:
case KEY_LOCATOR:
case NAME:
case SIGNATURE:
case SIGNED_INFO:
{
struct ccn_charbuf *p = pointer;
ccn_charbuf_destroy(&p);
}
break;
case SIGNING_PARAMS:
{
struct ccn_signing_params *p = pointer;
if (p->template_ccnb)
ccn_charbuf_destroy(&p->template_ccnb);
free(p);
}
break;
default:
debug("Got capsule: %s\n", PyCapsule_GetName(capsule));
panic("Unable to destroy the object: got an unknown capsule");
}
}
int
F2PyCapsule_Check(PyObject *ptr)
{
return PyCapsule_CheckExact(ptr);
}
static PyObject *Py_GeometricTransform(PyObject *obj, PyObject *args)
{
PyArrayObject *input = NULL, *output = NULL;
PyArrayObject *coordinates = NULL, *matrix = NULL, *shift = NULL;
PyObject *fnc = NULL, *extra_arguments = NULL, *extra_keywords = NULL;
int mode, order;
double cval;
void *func = NULL, *data = NULL;
NI_PythonCallbackData cbdata;
ccallback_t callback;
static ccallback_signature_t callback_signatures[] = {
{"int (intptr_t *, double *, int, int, void *)"},
{"int (npy_intp *, double *, int, int, void *)"},
#if NPY_SIZEOF_INTP == NPY_SIZEOF_SHORT
{"int (short *, double *, int, int, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_INT
{"int (int *, double *, int, int, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_LONG
{"int (long *, double *, int, int, void *)"},
#endif
#if NPY_SIZEOF_INTP == NPY_SIZEOF_LONGLONG
{"int (long long *, double *, int, int, void *)"},
#endif
{NULL}
};
callback.py_function = NULL;
callback.c_function = NULL;
if (!PyArg_ParseTuple(args, "O&OO&O&O&O&iidOO",
NI_ObjectToInputArray, &input,
&fnc,
NI_ObjectToOptionalInputArray, &coordinates,
NI_ObjectToOptionalInputArray, &matrix,
NI_ObjectToOptionalInputArray, &shift,
NI_ObjectToOutputArray, &output,
&order, &mode, &cval,
&extra_arguments, &extra_keywords))
goto exit;
if (fnc != Py_None) {
if (!PyTuple_Check(extra_arguments)) {
PyErr_SetString(PyExc_RuntimeError,
"extra_arguments must be a tuple");
goto exit;
}
if (!PyDict_Check(extra_keywords)) {
PyErr_SetString(PyExc_RuntimeError,
"extra_keywords must be a dictionary");
goto exit;
}
if (PyCapsule_CheckExact(fnc) && PyCapsule_GetName(fnc) == NULL) {
func = PyCapsule_GetPointer(fnc, NULL);
data = PyCapsule_GetContext(fnc);
#if PY_VERSION_HEX < 0x03000000
} else if (PyCObject_Check(fnc)) {
/* 'Legacy' low-level callable on Py2 */
func = PyCObject_AsVoidPtr(fnc);
data = PyCObject_GetDesc(fnc);
#endif
} else {
int ret;
ret = ccallback_prepare(&callback, callback_signatures, fnc, CCALLBACK_DEFAULTS);
if (ret == -1) {
goto exit;
}
if (callback.py_function != NULL) {
cbdata.extra_arguments = extra_arguments;
cbdata.extra_keywords = extra_keywords;
callback.info_p = (void*)&cbdata;
func = Py_Map;
data = (void*)&callback;
}
else {
func = callback.c_function;
data = callback.user_data;
}
}
}
NI_GeometricTransform(input, func, data, matrix, shift, coordinates,
output, order, (NI_ExtendMode)mode, cval);
#ifdef HAVE_WRITEBACKIFCOPY
PyArray_ResolveWritebackIfCopy(output);
#endif
exit:
if (callback.py_function != NULL || callback.c_function != NULL) {
ccallback_release(&callback);
}
Py_XDECREF(input);
Py_XDECREF(output);
Py_XDECREF(coordinates);
Py_XDECREF(matrix);
Py_XDECREF(shift);
return PyErr_Occurred() ? NULL : Py_BuildValue("");
}
PyMODINIT_FUNC SIP_MODULE_ENTRY()
#endif
{
static PyMethodDef sip_methods[] = {
{0, 0, 0, 0}
};
#if PY_MAJOR_VERSION >= 3
static PyModuleDef sip_module_def = {
PyModuleDef_HEAD_INIT,
"PyQt5.QtWebSockets",
NULL,
-1,
sip_methods,
NULL,
NULL,
NULL,
NULL
};
#endif
PyObject *sipModule, *sipModuleDict;
PyObject *sip_sipmod, *sip_capiobj;
/* Initialise the module and get it's dictionary. */
#if PY_MAJOR_VERSION >= 3
sipModule = PyModule_Create(&sip_module_def);
#elif PY_VERSION_HEX >= 0x02050000
sipModule = Py_InitModule(sipName_PyQt5_QtWebSockets, sip_methods);
#else
sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt5_QtWebSockets), sip_methods);
#endif
if (sipModule == NULL)
SIP_MODULE_RETURN(NULL);
sipModuleDict = PyModule_GetDict(sipModule);
/* Get the SIP module's API. */
#if PY_VERSION_HEX >= 0x02050000
sip_sipmod = PyImport_ImportModule(SIP_MODULE_NAME);
#else
sip_sipmod = PyImport_ImportModule(const_cast<char *>(SIP_MODULE_NAME));
#endif
if (sip_sipmod == NULL)
{
SIP_MODULE_DISCARD(sipModule);
SIP_MODULE_RETURN(NULL);
}
sip_capiobj = PyDict_GetItemString(PyModule_GetDict(sip_sipmod), "_C_API");
Py_DECREF(sip_sipmod);
#if defined(SIP_USE_PYCAPSULE)
if (sip_capiobj == NULL || !PyCapsule_CheckExact(sip_capiobj))
#else
if (sip_capiobj == NULL || !PyCObject_Check(sip_capiobj))
#endif
{
SIP_MODULE_DISCARD(sipModule);
SIP_MODULE_RETURN(NULL);
}
#if defined(SIP_USE_PYCAPSULE)
sipAPI_QtWebSockets = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, SIP_MODULE_NAME "._C_API"));
#else
sipAPI_QtWebSockets = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif
#if defined(SIP_USE_PYCAPSULE)
if (sipAPI_QtWebSockets == NULL)
{
SIP_MODULE_DISCARD(sipModule);
SIP_MODULE_RETURN(NULL);
}
#endif
/* Export the module and publish it's API. */
if (sipExportModule(&sipModuleAPI_QtWebSockets,SIP_API_MAJOR_NR,SIP_API_MINOR_NR,0) < 0)
{
SIP_MODULE_DISCARD(sipModule);
SIP_MODULE_RETURN(0);
}
sip_QtWebSockets_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
sip_QtWebSockets_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
sip_QtWebSockets_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");
if (!sip_QtWebSockets_qt_metacast)
Py_FatalError("Unable to import qtcore_qt_metacast");
/* Initialise the module now all its dependencies have been set up. */
if (sipInitModule(&sipModuleAPI_QtWebSockets,sipModuleDict) < 0)
{
SIP_MODULE_DISCARD(sipModule);
SIP_MODULE_RETURN(0);
}
/* Get the APIs of the modules that this one is dependent on. */
sipModuleAPI_QtWebSockets_QtCore = sipModuleAPI_QtWebSockets.em_imports[0].im_module;
sipModuleAPI_QtWebSockets_QtNetwork = sipModuleAPI_QtWebSockets.em_imports[1].im_module;
SIP_MODULE_RETURN(sipModule);
}
int PyCObject_Check(PyObject *p) {
return PyCapsule_CheckExact(p);
}
