/* XXX: Remove this function at some point in the future. The deprecation
* warning tells people what they should be doing.
*/
PyObject *py_ped_constraint_duplicate(PyObject *s, PyObject *args) {
PedConstraint *constraint = NULL, *dup_constraint = NULL;
_ped_Constraint *ret = NULL;
constraint = _ped_Constraint2PedConstraint(s);
if (constraint == NULL) {
return NULL;
}
if (PyErr_WarnEx(PyExc_DeprecationWarning,
"use copy.deepcopy() to duplicate a _ped.Constraint",
1) == -1) {
return NULL;
}
dup_constraint = ped_constraint_duplicate(constraint);
ped_constraint_destroy(constraint);
if (dup_constraint) {
ret = PedConstraint2_ped_Constraint(dup_constraint);
} else {
PyErr_SetString(CreateException, "Could not duplicate constraint");
return NULL;
}
ped_constraint_destroy(dup_constraint);
return (PyObject *) ret;
}
int warning(PyObject *category, int stacklevel, const char *format, ...)
{
va_list args;
va_start(args, format);
#if _WIN32
va_list args2 = args;
#else
va_list args2;
va_copy(args2, args);
#endif
// check the necessary memmory
int result = vsnprintf(NULL, 0, format, args);
char *message = (char*) malloc(result);
if (message) {
// format the message
vsnprintf(message, result, format, args2);
result = PyErr_WarnEx(category, message, stacklevel);
free(message);
} else {
result = 0;
}
va_end(args2);
va_end(args);
return result;
}
/* Returns the psi.mount module */
PyMODINIT_FUNC
MODFUNC(void)
{
PyObject *mod = NULL;
if (prepare_types() < 0)
RETURN(NULL);
if (init_exceptions() < 0)
goto error;
#ifdef PY3K
mod = PyModule_Create(&moduledef);
#else
mod = Py_InitModule3(MODULE_NAME, mount_methods, MODULE_DOC);
#endif
if (mod == NULL)
goto error;
if (add_module_objects(mod) < 0)
goto error;
PyErr_WarnEx(PyExc_FutureWarning, "Experimental API", 1);
RETURN(mod);
error:
Py_XDECREF(mod);
Py_XDECREF(PsiExc_AttrNotAvailableError);
Py_XDECREF(PsiExc_AttrInsufficientPrivsError);
Py_XDECREF(PsiExc_AttrNotImplementedError);
Py_XDECREF(&MountBase_Type);
Py_XDECREF(&LocalMount_Type);
Py_XDECREF(&RemoteMount_Type);
RETURN(NULL);
}
// python function cleanup()
static PyObject *py_cleanup(PyObject *self, PyObject *args)
{
int i;
int found = 0;
if (module_setup && !setup_error)
{
// clean up any /sys/class exports
event_cleanup();
// set everything back to input
for (i=0; i<54; i++)
{
if (gpio_direction[i] != -1)
{
setup_gpio(i, INPUT, PUD_OFF);
gpio_direction[i] = -1;
found = 1;
}
}
}
// check if any channels set up - if not warn about misuse of GPIO.cleanup()
if (!found && gpio_warnings)
{
PyErr_WarnEx(NULL, "No channels have been set up yet - nothing to clean up! Try cleaning up at the end of your program instead!", 1);
}
Py_RETURN_NONE;
}
void _sig_off_warning(const char* file, int line)
{
char buf[320];
snprintf(buf, sizeof(buf), "sig_off() without sig_on() at %s:%i", file, line);
PyErr_WarnEx(PyExc_RuntimeWarning, buf, 2);
print_backtrace();
}
static int
get_long(PyObject *v, long *p)
{
long x = PyInt_AsLong(v);
if (x == -1 && PyErr_Occurred()) {
#ifdef PY_STRUCT_FLOAT_COERCE
if (PyFloat_Check(v)) {
PyObject *o;
int res;
PyErr_Clear();
if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)
return -1;
o = PyNumber_Int(v);
if (o == NULL)
return -1;
res = get_long(o, p);
Py_DECREF(o);
return res;
}
#endif
if (PyErr_ExceptionMatches(PyExc_TypeError))
PyErr_SetString(StructError,
"required argument is not an integer");
return -1;
}
*p = x;
return 0;
}
// python function setup(channel, direction, pull_up_down=PUD_OFF, initial=None)
static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwargs)
{
unsigned int gpio;
int channel, direction;
int pud = PUD_OFF + PY_PUD_CONST_OFFSET;
int initial = -1;
static char *kwlist[] = {"channel", "direction", "pull_up_down", "initial", NULL};
int func;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|ii", kwlist, &channel, &direction, &pud, &initial))
return NULL;
// check module has been imported cleanly
if (setup_error)
{
PyErr_SetString(PyExc_RuntimeError, "Module not imported correctly!");
return NULL;
}
// run init_module if module not set up
if (!module_setup && (init_module() != SETUP_OK))
return NULL;
if (get_gpio_number(channel, &gpio))
return NULL;
if (direction != INPUT && direction != OUTPUT)
{
PyErr_SetString(PyExc_ValueError, "An invalid direction was passed to setup()");
return NULL;
}
if (direction == OUTPUT)
pud = PUD_OFF + PY_PUD_CONST_OFFSET;
pud -= PY_PUD_CONST_OFFSET;
if (pud != PUD_OFF && pud != PUD_DOWN && pud != PUD_UP)
{
PyErr_SetString(PyExc_ValueError, "Invalid value for pull_up_down - should be either PUD_OFF, PUD_UP or PUD_DOWN");
return NULL;
}
func = gpio_function(gpio);
if (gpio_warnings && // warnings enabled and
((func != 0 && func != 1) || // (already one of the alt functions or
(gpio_direction[gpio] == -1 && func == 1))) // already an output not set from this program)
{
PyErr_WarnEx(NULL, "This channel is already in use, continuing anyway. Use GPIO.setwarnings(False) to disable warnings.", 1);
}
if (direction == OUTPUT && (initial == LOW || initial == HIGH))
{
output_gpio(gpio, initial);
}
setup_gpio(gpio, direction, pud);
gpio_direction[gpio] = direction;
Py_RETURN_NONE;
}
// python function cleanup(channel=None)
static PyObject *py_cleanup(PyObject *self, PyObject *args, PyObject *kwargs)
{
int i = 0;
int found = 0,v = 0;
int channel = -666;
unsigned int gpio;
unsigned int sys_gpio;
static char *kwlist[] = {"channel", NULL};
v = get_lmk_revision();
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i", kwlist, &channel))
return NULL;
if (channel != -666 && get_gpio_number(channel, &gpio, &sys_gpio))
return NULL;
if (module_setup && !setup_error) {
if (channel == -666) {
// clean up any /sys/class exports
event_cleanup_all();
// set everything back to input
for (i=0; i<256; i++) {
if (gpio_direction[i] != -1) {
debug("Clean %d \n",i);
if(v == BANANAPRO){
setup_gpio(*(pinTobcm_BP+i), INPUT, PUD_OFF);//take care
} else if(v == LEMAKER_GUITAR){
setup_gpio(*(pinTobcm_GT+i), INPUT, PUD_OFF);//take care
}
gpio_direction[i] = -1;
found = 1;
}
}
} else {
// clean up any /sys/class exports
event_cleanup(sys_gpio);
// set everything back to input
if (gpio_direction[sys_gpio] != -1) {
setup_gpio(gpio, INPUT, PUD_OFF);
gpio_direction[i] = -1;
found = 1;
}
}
}
//printf("-->Before set warning\n");
//printf("found %d \t gpio_warnings %d\n",found,gpio_warnings);
// check if any channels set up - if not warn about misuse of GPIO.cleanup()
if (!found && gpio_warnings) {
PyErr_WarnEx(NULL, "No channels have been set up yet - nothing to clean up! Try cleaning up at the end of your program instead!", 1);
}
//printf("-->After set warning\n");
Py_RETURN_NONE;
}
static int
get_wrapped_long(PyObject *v, long *p)
{
if (get_long(v, p) < 0) {
if (PyLong_Check(v) &&
PyErr_ExceptionMatches(PyExc_OverflowError)) {
PyObject *wrapped;
long x;
PyErr_Clear();
#ifdef PY_STRUCT_FLOAT_COERCE
if (PyFloat_Check(v)) {
PyObject *o;
int res;
PyErr_Clear();
if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)
return -1;
o = PyNumber_Int(v);
if (o == NULL)
return -1;
res = get_wrapped_long(o, p);
Py_DECREF(o);
return res;
}
#endif
if (PyErr_WarnEx(PyExc_DeprecationWarning, INT_OVERFLOW, 2) < 0)
return -1;
wrapped = PyNumber_And(v, pylong_ulong_mask);
if (wrapped == NULL)
return -1;
x = (long)PyLong_AsUnsignedLong(wrapped);
Py_DECREF(wrapped);
if (x == -1 && PyErr_Occurred())
return -1;
*p = x;
} else {
return -1;
}
}
return 0;
}
// python function setup(channel, direction, pull_up_down=PUD_OFF, initial=None)
static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwargs)
{
unsigned int gpio;
int channel, direction;
int pud = PUD_OFF;
int initial = -1;
static char *kwlist[] = {"channel", "direction", "pull_up_down", "initial", NULL};
int func;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|ii", kwlist, &channel, &direction, &pud, &initial))
return NULL;
if (get_gpio_number(channel, &gpio))
return NULL;
if (direction != INPUT && direction != OUTPUT)
{
PyErr_SetString(InvalidDirectionException, "An invalid direction was passed to setup()");
return NULL;
}
if (direction == OUTPUT)
pud = PUD_OFF;
if (pud != PUD_OFF && pud != PUD_DOWN && pud != PUD_UP)
{
PyErr_SetString(InvalidPullException, "Invalid value for pull_up_down - should be either PUD_OFF, PUD_UP or PUD_DOWN");
return NULL;
}
func = gpio_function(gpio);
if (gpio_warnings && // warnings enabled and
((func != 0 && func != 1) || // (already one of the alt functions or
(gpio_direction[gpio] == -1 && func == 1))) // already an output not set from this program)
{
PyErr_WarnEx(NULL, "This channel is already in use, continuing anyway. Use GPIO.setwarnings(False) to disable warnings.", 1);
}
// printf("Setup GPIO %d direction %d pud %d\n", gpio, direction, pud);
if (direction == OUTPUT && (initial == LOW || initial == HIGH))
{
// printf("Writing intial value %d\n",initial);
output_gpio(gpio, initial);
}
setup_gpio(gpio, direction, pud);
gpio_direction[gpio] = direction;
Py_INCREF(Py_None);
return Py_None;
}
static int
get_wrapped_ulong(PyObject *v, unsigned long *p)
{
long x = (long)PyLong_AsUnsignedLong(v);
if (x == -1 && PyErr_Occurred()) {
PyObject *wrapped;
PyErr_Clear();
#ifdef PY_STRUCT_FLOAT_COERCE
if (PyFloat_Check(v)) {
PyObject *o;
int res;
PyErr_Clear();
if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)
return -1;
o = PyNumber_Int(v);
if (o == NULL)
return -1;
res = get_wrapped_ulong(o, p);
Py_DECREF(o);
return res;
}
#endif
wrapped = PyNumber_And(v, pylong_ulong_mask);
if (wrapped == NULL)
return -1;
if (PyErr_WarnEx(PyExc_DeprecationWarning, INT_OVERFLOW, 2) < 0) {
Py_DECREF(wrapped);
return -1;
}
x = (long)PyLong_AsUnsignedLong(wrapped);
Py_DECREF(wrapped);
if (x == -1 && PyErr_Occurred())
return -1;
}
*p = (unsigned long)x;
return 0;
}
void
aubio_log_function(int level, const char *message, void *data)
{
// remove trailing \n
char *pos;
if ((pos=strchr(message, '\n')) != NULL) {
*pos = '\0';
}
// warning or error
if (level == AUBIO_LOG_ERR) {
PyErr_Format(PyExc_RuntimeError, "%s", message);
} else {
PyErr_WarnEx(PyExc_UserWarning, message, 1);
}
}
/* Helper to format the range error exceptions */
static int
_range_error(const formatdef *f, int is_unsigned)
{
/* ulargest is the largest unsigned value with f->size bytes.
* Note that the simpler:
* ((size_t)1 << (f->size * 8)) - 1
* doesn't work when f->size == sizeof(size_t) because C doesn't
* define what happens when a left shift count is >= the number of
* bits in the integer being shifted; e.g., on some boxes it doesn't
* shift at all when they're equal.
*/
const size_t ulargest = (size_t)-1 >> ((SIZEOF_SIZE_T - f->size)*8);
assert(f->size >= 1 && f->size <= SIZEOF_SIZE_T);
if (is_unsigned)
PyErr_Format(StructError,
"'%c' format requires 0 <= number <= %zu",
f->format,
ulargest);
else {
const Py_ssize_t largest = (Py_ssize_t)(ulargest >> 1);
PyErr_Format(StructError,
"'%c' format requires %zd <= number <= %zd",
f->format,
~ largest,
largest);
}
#ifdef PY_STRUCT_OVERFLOW_MASKING
{
PyObject *ptype, *pvalue, *ptraceback;
PyObject *msg;
int rval;
PyErr_Fetch(&ptype, &pvalue, &ptraceback);
assert(pvalue != NULL);
msg = PyObject_Str(pvalue);
Py_XDECREF(ptype);
Py_XDECREF(pvalue);
Py_XDECREF(ptraceback);
if (msg == NULL)
return -1;
rval = PyErr_WarnEx(PyExc_DeprecationWarning,
PyString_AS_STRING(msg), 2);
Py_DECREF(msg);
if (rval == 0)
return 0;
}
#endif
return -1;
}
// python function cleanup(channel=None)
static PyObject *py_cleanup(PyObject *self, PyObject *args, PyObject *kwargs)
{
int i;
int found = 0;
int channel = -666;
unsigned int gpio;
static char *kwlist[] = {"channel", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i", kwlist, &channel))
return NULL;
if (channel != -666 && get_gpio_number(channel, &gpio))
return NULL;
if (module_setup && !setup_error) {
if (channel == -666) {
// clean up any /sys/class exports
event_cleanup_all();
// set everything back to input
for (i=0; i<54; i++) {
if (gpio_direction[i] != -1) {
setup_gpio(i, INPUT, PUD_OFF);
gpio_direction[i] = -1;
found = 1;
}
}
} else {
// clean up any /sys/class exports
event_cleanup(gpio);
// set everything back to input
if (gpio_direction[gpio] != -1) {
setup_gpio(gpio, INPUT, PUD_OFF);
gpio_direction[i] = -1;
found = 1;
}
}
}
// check if any channels set up - if not warn about misuse of GPIO.cleanup()
if (!found && gpio_warnings) {
PyErr_WarnEx(NULL, "No channels have been set up yet - nothing to clean up! Try cleaning up at the end of your program instead!", 1);
}
Py_RETURN_NONE;
}
static PyObject *
pyev_default_loop(PyObject *module, PyObject *args, PyObject *kwargs)
{
if (!DefaultLoop) {
DefaultLoop = new_Loop(&LoopType, args, kwargs, 1);
}
else {
if (PyErr_WarnEx(PyExc_UserWarning,
"returning the 'default loop' created earlier, "
"arguments ignored (if provided).",
1)) {
return NULL;
}
Py_INCREF(DefaultLoop);
}
return (PyObject *)DefaultLoop;
}
// python function output(channel, value)
static PyObject *py_output_gpio(PyObject *self, PyObject *args)
{
int channel, value, r;
char buffer[128];
if (!PyArg_ParseTuple(args, "ii", &channel, &value))
return NULL;
// printf("Output GPIO %d value %d\n", gpio, value);
if( (r=gpio_setpin(channel, value))!=0)
{
sprintf(buffer, "Error on setting pin (%d).", r);
PyErr_WarnEx(NULL, buffer, 1);
}
Py_INCREF(Py_None);
return Py_None;
}
static int __Pyx_check_binary_version(void) {
char ctversion[4], rtversion[4];
PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
char message[200];
PyOS_snprintf(message, sizeof(message),
"compiletime version %s of module '%.100s' "
"does not match runtime version %s",
ctversion, __Pyx_MODULE_NAME, rtversion);
#if PY_VERSION_HEX < 0x02050000
return PyErr_Warn(NULL, message);
#else
return PyErr_WarnEx(NULL, message, 1);
#endif
}
return 0;
}
static void clb_print(NC_VERB_LEVEL level, const char* msg)
{
switch (level) {
case NC_VERB_ERROR:
PyErr_SetString(libnetconfError, msg);
if (syslogEnabled) {syslog(LOG_ERR, "%s", msg);}
break;
case NC_VERB_WARNING:
if (syslogEnabled) {syslog(LOG_WARNING, "%s", msg);}
PyErr_WarnEx(libnetconfWarning, msg, 1);
break;
case NC_VERB_VERBOSE:
if (syslogEnabled) {syslog(LOG_INFO, "%s", msg);}
break;
case NC_VERB_DEBUG:
if (syslogEnabled) {syslog(LOG_DEBUG, "%s", msg);}
break;
}
}
// python function setup(channel, direction, pull_up_down=PUD_OFF)
static PyObject *py_setup_channel(PyObject *self, PyObject *args, PyObject *kwargs)
{
int channel, direction;
static char *kwlist[] = {"channel", "direction", NULL};
int func;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|i", kwlist, &channel, &direction))
return NULL;
if (direction != INPUT && direction != OUTPUT)
{
PyErr_SetString(InvalidDirectionException, "An invalid direction was passed to setup()");
return NULL;
}
func = gpio_open(channel, direction);
if (func != 0) // already an output not set from this program)
{
PyErr_WarnEx(NULL, "This channel is already in use, continuing anyway. Use GPIO.setwarnings(False) to disable warnings.", 1);
}
Py_INCREF(Py_None);
return Py_None;
}
static int
parse_from_Boolean( PyObject *obj, void *addr )
{
int *value = (int *) addr;
if( obj == Py_False ) {
*value = 0;
return 1;
} else if( obj == Py_True ) {
*value = -1;
return 1;
} else {
PyErr_WarnEx( NULL, "Attempt to coerce non-Boolean value into Boolean", 1 );
}
return 0;
}
static zbarProcessor*
processor_new (PyTypeObject *type,
PyObject *args,
PyObject *kwds)
{
static char *kwlist[] = { "enable_threads", NULL };
int threaded = -1;
if(!PyArg_ParseTupleAndKeywords(args, kwds, "|O&", kwlist,
object_to_bool, &threaded))
return(NULL);
#ifdef WITH_THREAD
/* the processor creates a thread that calls back into python,
* so we must ensure that threads are initialized before attempting
* to manipulate the GIL (bug #3349199)
*/
PyEval_InitThreads();
#else
if(threaded > 0 &&
PyErr_WarnEx(NULL, "threading requested but not available", 1))
return(NULL);
threaded = 0;
#endif
zbarProcessor *self = (zbarProcessor*)type->tp_alloc(type, 0);
if(!self)
return(NULL);
self->zproc = zbar_processor_create(threaded);
zbar_processor_set_userdata(self->zproc, self);
if(!self->zproc) {
Py_DECREF(self);
return(NULL);
}
return(self);
}
PyErr_Warn(PyObject *category, const char *text)
{
return PyErr_WarnEx(category, text, 1);
}
void sf_error(char *func_name, sf_error_t code, char *fmt, ...)
{
char msg[2048], info[1024];
static PyObject *py_SpecialFunctionWarning = NULL;
va_list ap;
if (!print_error_messages) {
return;
}
if (func_name == NULL) {
func_name = "?";
}
if ((int)code < 0 || (int)code >= 10) {
code = SF_ERROR_OTHER;
}
if (fmt != NULL && fmt[0] != '\0') {
va_start(ap, fmt);
PyOS_vsnprintf(info, 1024, fmt, ap);
va_end(ap);
PyOS_snprintf(msg, 2048, "scipy.special/%s: (%s) %s",
func_name, sf_error_messages[(int)code], info);
}
else {
PyOS_snprintf(msg, 2048, "scipy.special/%s: %s",
func_name, sf_error_messages[(int)code]);
}
{
#ifdef WITH_THREAD
PyGILState_STATE save = PyGILState_Ensure();
#endif
if (PyErr_Occurred())
goto skip_warn;
if (py_SpecialFunctionWarning == NULL) {
PyObject *scipy_special = NULL;
scipy_special = PyImport_ImportModule("scipy.special");
if (scipy_special == NULL) {
PyErr_Clear();
goto skip_warn;
}
py_SpecialFunctionWarning = PyObject_GetAttrString(
scipy_special, "SpecialFunctionWarning");
if (py_SpecialFunctionWarning == NULL) {
PyErr_Clear();
goto skip_warn;
}
}
if (py_SpecialFunctionWarning != NULL) {
PyErr_WarnEx(py_SpecialFunctionWarning, msg, 1);
/*
* The return value is ignored! We rely on the fact that the
* Ufunc loop will call PyErr_Occurred() later on.
*/
}
skip_warn:
#ifdef WITH_THREAD
PyGILState_Release(save);
#endif
}
}
/* Delaunay implementation methyod. If hide_qhull_errors is 1 then qhull error
* messages are discarded; if it is 0 then they are written to stderr. */
static PyObject*
delaunay_impl(int npoints, const double* x, const double* y,
int hide_qhull_errors)
{
coordT* points = NULL;
facetT* facet;
int i, ntri, max_facet_id;
FILE* error_file = NULL; /* qhull expects a FILE* to write errors to. */
int exitcode; /* Value returned from qh_new_qhull(). */
int* tri_indices = NULL; /* Maps qhull facet id to triangle index. */
int indices[3];
int curlong, totlong; /* Memory remaining after qh_memfreeshort. */
PyObject* tuple; /* Return tuple (triangles, neighbors). */
const int ndim = 2;
npy_intp dims[2];
PyArrayObject* triangles = NULL;
PyArrayObject* neighbors = NULL;
int* triangles_ptr;
int* neighbors_ptr;
/* Allocate points. */
points = (coordT*)malloc(npoints*ndim*sizeof(coordT));
if (points == NULL) {
PyErr_SetString(PyExc_MemoryError,
"Could not allocate points array in qhull.delaunay");
goto error_before_qhull;
}
/* Prepare points array to pass to qhull. */
for (i = 0; i < npoints; ++i) {
points[2*i ] = x[i];
points[2*i+1] = y[i];
}
/* qhull expects a FILE* to write errors to. */
if (hide_qhull_errors) {
/* qhull errors are ignored by writing to OS-equivalent of /dev/null.
* Rather than have OS-specific code here, instead it is determined by
* setupext.py and passed in via the macro MPL_DEVNULL. */
error_file = fopen(STRINGIFY(MPL_DEVNULL), "w");
if (error_file == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"Could not open devnull in qhull.delaunay");
goto error_before_qhull;
}
}
else {
/* qhull errors written to stderr. */
error_file = stderr;
}
/* Perform Delaunay triangulation. */
exitcode = qh_new_qhull(ndim, npoints, points, False,
"qhull d Qt Qbb Qc Qz", NULL, error_file);
if (exitcode != qh_ERRnone) {
PyErr_Format(PyExc_RuntimeError,
"Error in qhull Delaunay triangulation calculation: %s (exitcode=%d)%s",
qhull_error_msg[exitcode], exitcode,
hide_qhull_errors ? "; use python verbose option (-v) to see original qhull error." : "");
goto error;
}
/* Split facets so that they only have 3 points each. */
qh_triangulate();
/* Determine ntri and max_facet_id.
Note that libqhull uses macros to iterate through collections. */
ntri = 0;
FORALLfacets {
if (!facet->upperdelaunay)
++ntri;
}
max_facet_id = qh facet_id - 1;
/* Create array to map facet id to triangle index. */
tri_indices = (int*)malloc((max_facet_id+1)*sizeof(int));
if (tri_indices == NULL) {
PyErr_SetString(PyExc_MemoryError,
"Could not allocate triangle map in qhull.delaunay");
goto error;
}
/* Allocate python arrays to return. */
dims[0] = ntri;
dims[1] = 3;
triangles = (PyArrayObject*)PyArray_SimpleNew(ndim, dims, NPY_INT);
if (triangles == NULL) {
PyErr_SetString(PyExc_MemoryError,
"Could not allocate triangles array in qhull.delaunay");
goto error;
}
neighbors = (PyArrayObject*)PyArray_SimpleNew(ndim, dims, NPY_INT);
if (neighbors == NULL) {
PyErr_SetString(PyExc_MemoryError,
"Could not allocate neighbors array in qhull.delaunay");
goto error;
}
triangles_ptr = (int*)PyArray_DATA(triangles);
neighbors_ptr = (int*)PyArray_DATA(neighbors);
/* Determine triangles array and set tri_indices array. */
i = 0;
FORALLfacets {
if (!facet->upperdelaunay) {
tri_indices[facet->id] = i++;
get_facet_vertices(facet, indices);
*triangles_ptr++ = (facet->toporient ? indices[0] : indices[2]);
*triangles_ptr++ = indices[1];
*triangles_ptr++ = (facet->toporient ? indices[2] : indices[0]);
}
else
tri_indices[facet->id] = -1;
}
/* Determine neighbors array. */
FORALLfacets {
if (!facet->upperdelaunay) {
get_facet_neighbours(facet, tri_indices, indices);
*neighbors_ptr++ = (facet->toporient ? indices[2] : indices[0]);
*neighbors_ptr++ = (facet->toporient ? indices[0] : indices[2]);
*neighbors_ptr++ = indices[1];
}
}
/* Clean up. */
qh_freeqhull(!qh_ALL);
qh_memfreeshort(&curlong, &totlong);
if (curlong || totlong)
PyErr_WarnEx(PyExc_RuntimeWarning,
"Qhull could not free all allocated memory", 1);
if (hide_qhull_errors)
fclose(error_file);
free(tri_indices);
free(points);
tuple = PyTuple_New(2);
PyTuple_SetItem(tuple, 0, (PyObject*)triangles);
PyTuple_SetItem(tuple, 1, (PyObject*)neighbors);
return tuple;
error:
/* Clean up. */
Py_XDECREF(triangles);
Py_XDECREF(neighbors);
qh_freeqhull(!qh_ALL);
qh_memfreeshort(&curlong, &totlong);
/* Don't bother checking curlong and totlong as raising error anyway. */
if (hide_qhull_errors)
fclose(error_file);
free(tri_indices);
error_before_qhull:
free(points);
return NULL;
}
/**
* Call this function for each callback. Note that even if this function
* returns nonzero, CB_THR_BEGIN() must still be called, and the `conn`
* and `mres` out parameters are considered valid
* @param resp base response object
* @param[out] conn the bucket object
* @param[out] res the result object for the individual operation
* @param restype What type should `res` be if it needs to be created
* @param[out] mres the context for the current operation
* @return 0 if operation processing may proceed, nonzero if operation
* processing has completed. In both cases the `conn` and `mres` paramters
* are valid, however.
*/
static int
get_common_objects(const lcb_RESPBASE *resp, pycbc_Bucket **conn,
pycbc_Result **res, int restype, pycbc_MultiResult **mres)
{
PyObject *hkey;
PyObject *mrdict;
int rv;
pycbc_assert(pycbc_multiresult_check(resp->cookie));
*mres = (pycbc_MultiResult*)resp->cookie;
*conn = (*mres)->parent;
CB_THR_END(*conn);
rv = pycbc_tc_decode_key(*conn, resp->key, resp->nkey, &hkey);
if (rv < 0) {
pycbc_multiresult_adderr(*mres);
return -1;
}
mrdict = pycbc_multiresult_dict(*mres);
*res = (pycbc_Result*)PyDict_GetItem(mrdict, hkey);
if (*res) {
int exists_ok = (restype & RESTYPE_EXISTS_OK) ||
( (*mres)->mropts & PYCBC_MRES_F_UALLOCED);
if (!exists_ok) {
if ((*conn)->flags & PYCBC_CONN_F_WARNEXPLICIT) {
PyErr_WarnExplicit(PyExc_RuntimeWarning,
"Found duplicate key",
__FILE__, __LINE__,
"couchbase._libcouchbase",
NULL);
} else {
PyErr_WarnEx(PyExc_RuntimeWarning,
"Found duplicate key",
1);
}
/**
* We need to destroy the existing object and re-create it.
*/
PyDict_DelItem(mrdict, hkey);
*res = NULL;
} else {
Py_XDECREF(hkey);
}
}
if (*res == NULL) {
/* Now, get/set the result object */
if ( (*mres)->mropts & PYCBC_MRES_F_ITEMS) {
*res = (pycbc_Result*)pycbc_item_new(*conn);
} else if (restype & RESTYPE_BASE) {
*res = (pycbc_Result*)pycbc_result_new(*conn);
} else if (restype & RESTYPE_OPERATION) {
*res = (pycbc_Result*)pycbc_opresult_new(*conn);
} else if (restype & RESTYPE_VALUE) {
*res = (pycbc_Result*)pycbc_valresult_new(*conn);
} else {
abort();
}
PyDict_SetItem(mrdict, hkey, (PyObject*)*res);
(*res)->key = hkey;
Py_DECREF(*res);
}
if (resp->rc) {
(*res)->rc = resp->rc;
}
if (resp->rc != LCB_SUCCESS) {
(*mres)->all_ok = 0;
}
return 0;
}
/******************************************************************************
*
* Call the python object with all arguments
*
*/
static void _CallPythonObject(void *mem,
ffi_type *restype,
SETFUNC setfunc,
PyObject *callable,
PyObject *converters,
int flags,
void **pArgs)
{
Py_ssize_t i;
PyObject *result;
PyObject *arglist = NULL;
Py_ssize_t nArgs;
PyObject *error_object = NULL;
int *space;
#ifdef WITH_THREAD
PyGILState_STATE state = PyGILState_Ensure();
#endif
nArgs = PySequence_Length(converters);
/* Hm. What to return in case of error?
For COM, 0xFFFFFFFF seems better than 0.
*/
if (nArgs < 0) {
PrintError("BUG: PySequence_Length");
goto Done;
}
arglist = PyTuple_New(nArgs);
if (!arglist) {
PrintError("PyTuple_New()");
goto Done;
}
for (i = 0; i < nArgs; ++i) {
/* Note: new reference! */
PyObject *cnv = PySequence_GetItem(converters, i);
StgDictObject *dict;
if (cnv)
dict = PyType_stgdict(cnv);
else {
PrintError("Getting argument converter %d\n", i);
goto Done;
}
if (dict && dict->getfunc && !_ctypes_simple_instance(cnv)) {
PyObject *v = dict->getfunc(*pArgs, dict->size);
if (!v) {
PrintError("create argument %d:\n", i);
Py_DECREF(cnv);
goto Done;
}
PyTuple_SET_ITEM(arglist, i, v);
/* XXX XXX XX
We have the problem that c_byte or c_short have dict->size of
1 resp. 4, but these parameters are pushed as sizeof(int) bytes.
BTW, the same problem occurrs when they are pushed as parameters
*/
} else if (dict) {
/* Hm, shouldn't we use PyCData_AtAddress() or something like that instead? */
CDataObject *obj = (CDataObject *)PyObject_CallFunctionObjArgs(cnv, NULL);
if (!obj) {
PrintError("create argument %d:\n", i);
Py_DECREF(cnv);
goto Done;
}
if (!CDataObject_Check(obj)) {
Py_DECREF(obj);
Py_DECREF(cnv);
PrintError("unexpected result of create argument %d:\n", i);
goto Done;
}
memcpy(obj->b_ptr, *pArgs, dict->size);
PyTuple_SET_ITEM(arglist, i, (PyObject *)obj);
#ifdef MS_WIN32
TryAddRef(dict, obj);
#endif
} else {
PyErr_SetString(PyExc_TypeError,
"cannot build parameter");
PrintError("Parsing argument %d\n", i);
Py_DECREF(cnv);
goto Done;
}
Py_DECREF(cnv);
/* XXX error handling! */
pArgs++;
}
#define CHECK(what, x) \
if (x == NULL) _ctypes_add_traceback(what, "_ctypes/callbacks.c", __LINE__ - 1), PyErr_Print()
if (flags & (FUNCFLAG_USE_ERRNO | FUNCFLAG_USE_LASTERROR)) {
error_object = _ctypes_get_errobj(&space);
if (error_object == NULL)
goto Done;
if (flags & FUNCFLAG_USE_ERRNO) {
int temp = space[0];
space[0] = errno;
errno = temp;
}
#ifdef MS_WIN32
if (flags & FUNCFLAG_USE_LASTERROR) {
int temp = space[1];
space[1] = GetLastError();
SetLastError(temp);
}
#endif
}
result = PyObject_CallObject(callable, arglist);
CHECK("'calling callback function'", result);
#ifdef MS_WIN32
if (flags & FUNCFLAG_USE_LASTERROR) {
int temp = space[1];
space[1] = GetLastError();
SetLastError(temp);
}
#endif
if (flags & FUNCFLAG_USE_ERRNO) {
int temp = space[0];
space[0] = errno;
errno = temp;
}
Py_XDECREF(error_object);
if ((restype != &ffi_type_void) && result) {
PyObject *keep;
assert(setfunc);
#ifdef WORDS_BIGENDIAN
/* See the corresponding code in callproc.c, around line 961 */
if (restype->type != FFI_TYPE_FLOAT && restype->size < sizeof(ffi_arg))
mem = (char *)mem + sizeof(ffi_arg) - restype->size;
#endif
keep = setfunc(mem, result, 0);
CHECK("'converting callback result'", keep);
/* keep is an object we have to keep alive so that the result
stays valid. If there is no such object, the setfunc will
have returned Py_None.
If there is such an object, we have no choice than to keep
it alive forever - but a refcount and/or memory leak will
be the result. EXCEPT when restype is py_object - Python
itself knows how to manage the refcount of these objects.
*/
if (keep == NULL) /* Could not convert callback result. */
PyErr_WriteUnraisable(callable);
else if (keep == Py_None) /* Nothing to keep */
Py_DECREF(keep);
else if (setfunc != _ctypes_get_fielddesc("O")->setfunc) {
if (-1 == PyErr_WarnEx(PyExc_RuntimeWarning,
"memory leak in callback function.",
1))
PyErr_WriteUnraisable(callable);
}
}
Py_XDECREF(result);
Done:
Py_XDECREF(arglist);
#ifdef WITH_THREAD
PyGILState_Release(state);
#endif
}
/* Convert 9-item tuple to tm structure. Return 1 on success, set
* an exception and return 0 on error.
*/
static int
gettmarg(PyObject *args, struct tm *p)
{
int y;
memset((void *) p, '\0', sizeof(struct tm));
if (!PyTuple_Check(args)) {
PyErr_SetString(PyExc_TypeError,
"Tuple or struct_time argument required");
return 0;
}
if (!PyArg_ParseTuple(args, "iiiiiiiii",
&y, &p->tm_mon, &p->tm_mday,
&p->tm_hour, &p->tm_min, &p->tm_sec,
&p->tm_wday, &p->tm_yday, &p->tm_isdst))
return 0;
/* If year is specified with less than 4 digits, its interpretation
* depends on the accept2dyear value.
*
* If accept2dyear is true (default), a backward compatibility behavior is
* invoked as follows:
*
* - for 2-digit year, century is guessed according to POSIX rules for
* %y strptime format: 21st century for y < 69, 20th century
* otherwise. A deprecation warning is issued when century
* information is guessed in this way.
*
* - for 3-digit or negative year, a ValueError exception is raised.
*
* If accept2dyear is false (set by the program or as a result of a
* non-empty value assigned to PYTHONY2K environment variable) all year
* values are interpreted as given.
*/
if (y < 1000) {
PyObject *accept = PyDict_GetItemString(moddict,
"accept2dyear");
if (accept != NULL) {
int acceptval = PyObject_IsTrue(accept);
if (acceptval == -1)
return 0;
if (acceptval) {
if (0 <= y && y < 69)
y += 2000;
else if (69 <= y && y < 100)
y += 1900;
else {
PyErr_SetString(PyExc_ValueError,
"year out of range");
return 0;
}
if (PyErr_WarnEx(PyExc_DeprecationWarning,
"Century info guessed for a 2-digit year.", 1) != 0)
return 0;
}
}
else
return 0;
}
p->tm_year = y - 1900;
p->tm_mon--;
p->tm_wday = (p->tm_wday + 1) % 7;
p->tm_yday--;
return 1;
}
static int
pylzma_compfile_init(CCompressionFileObject *self, PyObject *args, PyObject *kwargs)
{
PyObject *inFile;
CLzmaEncProps props;
Byte header[LZMA_PROPS_SIZE];
size_t headerSize = LZMA_PROPS_SIZE;
int result = -1;
// possible keywords for this function
static char *kwlist[] = {"infile", "dictionary", "fastBytes", "literalContextBits",
"literalPosBits", "posBits", "algorithm", "eos", "multithreading", "matchfinder", NULL};
int dictionary = 23; // [0,28], default 23 (8MB)
int fastBytes = 128; // [5,255], default 128
int literalContextBits = 3; // [0,8], default 3
int literalPosBits = 0; // [0,4], default 0
int posBits = 2; // [0,4], default 2
int eos = 1; // write "end of stream" marker?
int multithreading = 1; // use multithreading if available?
char *matchfinder = NULL; // matchfinder algorithm
int algorithm = 2;
int res;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|iiiiiiiis", kwlist, &inFile, &dictionary, &fastBytes,
&literalContextBits, &literalPosBits, &posBits, &algorithm, &eos, &multithreading, &matchfinder))
return -1;
CHECK_RANGE(dictionary, 0, 28, "dictionary must be between 0 and 28");
CHECK_RANGE(fastBytes, 5, 255, "fastBytes must be between 5 and 255");
CHECK_RANGE(literalContextBits, 0, 8, "literalContextBits must be between 0 and 8");
CHECK_RANGE(literalPosBits, 0, 4, "literalPosBits must be between 0 and 4");
CHECK_RANGE(posBits, 0, 4, "posBits must be between 0 and 4");
CHECK_RANGE(algorithm, 0, 2, "algorithm must be between 0 and 2");
if (matchfinder != NULL) {
#if (PY_VERSION_HEX >= 0x02050000)
PyErr_WarnEx(PyExc_DeprecationWarning, "matchfinder selection is deprecated and will be ignored", 1);
#else
PyErr_Warn(PyExc_DeprecationWarning, "matchfinder selection is deprecated and will be ignored");
#endif
}
if (PyString_Check(inFile)) {
// create new cStringIO object from string
inFile = PycStringIO->NewInput(inFile);
if (inFile == NULL)
{
PyErr_NoMemory();
return -1;
}
} else if (!PyObject_HasAttrString(inFile, "read")) {
PyErr_SetString(PyExc_ValueError, "first parameter must be a file-like object");
return -1;
} else {
// protect object from being refcounted out...
Py_INCREF(inFile);
}
self->encoder = LzmaEnc_Create(&allocator);
if (self->encoder == NULL) {
Py_DECREF(inFile);
PyErr_NoMemory();
return -1;
}
LzmaEncProps_Init(&props);
props.dictSize = 1 << dictionary;
props.lc = literalContextBits;
props.lp = literalPosBits;
props.pb = posBits;
props.algo = algorithm;
props.fb = fastBytes;
// props.btMode = 1;
// props.numHashBytes = 4;
// props.mc = 32;
props.writeEndMark = eos ? 1 : 0;
props.numThreads = multithreading ? 2 : 1;
LzmaEncProps_Normalize(&props);
res = LzmaEnc_SetProps(self->encoder, &props);
if (res != SZ_OK) {
Py_DECREF(inFile);
PyErr_Format(PyExc_TypeError, "could not set encoder properties: %d", res);
return -1;
}
self->inFile = inFile;
CreatePythonInStream(&self->inStream, inFile);
CreateMemoryOutStream(&self->outStream);
LzmaEnc_WriteProperties(self->encoder, header, &headerSize);
if (self->outStream.s.Write(&self->outStream, header, headerSize) != headerSize) {
PyErr_SetString(PyExc_TypeError, "could not generate stream header");
goto exit;
}
LzmaEnc_Prepare(self->encoder, &self->inStream.s, &self->outStream.s, &allocator, &allocator);
result = 0;
exit:
return result;
}
static PyObject *
_wrap_g_field_info_set_value (PyGIBaseInfo *self,
PyObject *args)
{
PyObject *instance;
PyObject *py_value;
GIBaseInfo *container_info;
GIInfoType container_info_type;
gpointer pointer;
GITypeInfo *field_type_info;
GIArgument value;
PyObject *retval = NULL;
if (!PyArg_ParseTuple (args, "OO:FieldInfo.set_value", &instance, &py_value)) {
return NULL;
}
container_info = g_base_info_get_container (self->info);
g_assert (container_info != NULL);
/* Check the instance. */
if (!_pygi_g_registered_type_info_check_object ( (GIRegisteredTypeInfo *) container_info, TRUE, instance)) {
_PyGI_ERROR_PREFIX ("argument 1: ");
return NULL;
}
/* Get the pointer to the container. */
container_info_type = g_base_info_get_type (container_info);
switch (container_info_type) {
case GI_INFO_TYPE_UNION:
case GI_INFO_TYPE_STRUCT:
pointer = pyg_boxed_get (instance, void);
break;
case GI_INFO_TYPE_OBJECT:
pointer = pygobject_get (instance);
break;
default:
/* Other types don't have fields. */
g_assert_not_reached();
}
field_type_info = g_field_info_get_type ( (GIFieldInfo *) self->info);
/* Check the value. */
{
gboolean retval;
retval = _pygi_g_type_info_check_object (field_type_info, py_value, TRUE);
if (retval < 0) {
goto out;
}
if (!retval) {
_PyGI_ERROR_PREFIX ("argument 2: ");
goto out;
}
}
/* Set the field's value. */
/* A few types are not handled by g_field_info_set_field, so do it here. */
if (!g_type_info_is_pointer (field_type_info)
&& g_type_info_get_tag (field_type_info) == GI_TYPE_TAG_INTERFACE) {
GIBaseInfo *info;
GIInfoType info_type;
if (! (g_field_info_get_flags ( (GIFieldInfo *) self->info) & GI_FIELD_IS_WRITABLE)) {
PyErr_SetString (PyExc_RuntimeError, "field is not writable");
goto out;
}
info = g_type_info_get_interface (field_type_info);
info_type = g_base_info_get_type (info);
switch (info_type) {
case GI_INFO_TYPE_UNION:
PyErr_SetString (PyExc_NotImplementedError, "setting an union is not supported yet");
goto out;
case GI_INFO_TYPE_STRUCT:
{
gboolean is_simple;
gsize offset;
gssize size;
is_simple = pygi_g_struct_info_is_simple ( (GIStructInfo *) info);
if (!is_simple) {
PyErr_SetString (PyExc_TypeError,
"cannot set a structure which has no well-defined ownership transfer rules");
g_base_info_unref (info);
goto out;
}
value = _pygi_argument_from_object (py_value, field_type_info, GI_TRANSFER_NOTHING);
if (PyErr_Occurred()) {
g_base_info_unref (info);
goto out;
}
offset = g_field_info_get_offset ( (GIFieldInfo *) self->info);
size = g_struct_info_get_size ( (GIStructInfo *) info);
g_assert (size > 0);
g_memmove ((char*) pointer + offset, value.v_pointer, size);
g_base_info_unref (info);
retval = Py_None;
goto out;
}
default:
/* Fallback. */
break;
}
g_base_info_unref (info);
} else if (g_type_info_is_pointer (field_type_info)
&& g_type_info_get_tag (field_type_info) == GI_TYPE_TAG_VOID) {
int offset;
if (py_value != Py_None && !PYGLIB_PyLong_Check(py_value)) {
if (PyErr_WarnEx(PyExc_RuntimeWarning,
"Usage of gpointers to store objects is being deprecated. "
"Please use integer values only, see: https://bugzilla.gnome.org/show_bug.cgi?id=683599",
1))
goto out;
}
offset = g_field_info_get_offset ((GIFieldInfo *) self->info);
value = _pygi_argument_from_object (py_value, field_type_info, GI_TRANSFER_NOTHING);
/* Decrement the previous python object stashed on the void pointer.
* This seems somewhat dangerous as the code is blindly assuming any
* void pointer field stores a python object pointer and then decrefs it.
* This is essentially the same as something like:
* Py_XDECREF(struct->void_ptr); */
Py_XDECREF(G_STRUCT_MEMBER (gpointer, pointer, offset));
/* Assign and increment the newly assigned object. At this point the value
* arg will hold a pointer the python object "py_value" or NULL.
* This is essentially:
* struct->void_ptr = value.v_pointer;
* Py_XINCREF(struct->void_ptr);
*/
G_STRUCT_MEMBER (gpointer, pointer, offset) = (gpointer)value.v_pointer;
Py_XINCREF(G_STRUCT_MEMBER (gpointer, pointer, offset));
retval = Py_None;
goto out;
}
value = _pygi_argument_from_object (py_value, field_type_info, GI_TRANSFER_EVERYTHING);
if (PyErr_Occurred()) {
goto out;
}
if (!g_field_info_set_field ( (GIFieldInfo *) self->info, pointer, &value)) {
_pygi_argument_release (&value, field_type_info, GI_TRANSFER_NOTHING, GI_DIRECTION_IN);
PyErr_SetString (PyExc_RuntimeError, "unable to set value for field");
goto out;
}
retval = Py_None;
out:
g_base_info_unref ( (GIBaseInfo *) field_type_info);
Py_XINCREF (retval);
return retval;
}
PyObject *
PyModule_Create2(struct PyModuleDef* module, int module_api_version)
{
PyObject *d, *v, *n;
PyMethodDef *ml;
const char* name;
PyModuleObject *m;
if (!Py_IsInitialized())
Py_FatalError("Interpreter not initialized (version mismatch?)");
if (PyType_Ready(&moduledef_type) < 0)
return NULL;
if (module->m_base.m_index == 0) {
max_module_number++;
Py_REFCNT(module) = 1;
Py_TYPE(module) = &moduledef_type;
module->m_base.m_index = max_module_number;
}
name = module->m_name;
if (module_api_version != PYTHON_API_VERSION) {
char message[512];
PyOS_snprintf(message, sizeof(message),
api_version_warning, name,
PYTHON_API_VERSION, name,
module_api_version);
if (PyErr_WarnEx(PyExc_RuntimeWarning, message, 1))
return NULL;
}
/* Make sure name is fully qualified.
This is a bit of a hack: when the shared library is loaded,
the module name is "package.module", but the module calls
PyModule_Create*() with just "module" for the name. The shared
library loader squirrels away the true name of the module in
_Py_PackageContext, and PyModule_Create*() will substitute this
(if the name actually matches).
*/
if (_Py_PackageContext != NULL) {
char *p = strrchr(_Py_PackageContext, '.');
if (p != NULL && strcmp(module->m_name, p+1) == 0) {
name = _Py_PackageContext;
_Py_PackageContext = NULL;
}
}
if ((m = (PyModuleObject*)PyModule_New(name)) == NULL)
return NULL;
if (module->m_size > 0) {
m->md_state = PyMem_MALLOC(module->m_size);
if (!m->md_state) {
PyErr_NoMemory();
Py_DECREF(m);
return NULL;
}
memset(m->md_state, 0, module->m_size);
}
d = PyModule_GetDict((PyObject*)m);
if (module->m_methods != NULL) {
n = PyUnicode_FromString(name);
if (n == NULL)
return NULL;
for (ml = module->m_methods; ml->ml_name != NULL; ml++) {
if ((ml->ml_flags & METH_CLASS) ||
(ml->ml_flags & METH_STATIC)) {
PyErr_SetString(PyExc_ValueError,
"module functions cannot set"
" METH_CLASS or METH_STATIC");
Py_DECREF(n);
return NULL;
}
v = PyCFunction_NewEx(ml, (PyObject*)m, n);
if (v == NULL) {
Py_DECREF(n);
return NULL;
}
if (PyDict_SetItemString(d, ml->ml_name, v) != 0) {
Py_DECREF(v);
Py_DECREF(n);
return NULL;
}
Py_DECREF(v);
}
Py_DECREF(n);
}
if (module->m_doc != NULL) {
v = PyUnicode_FromString(module->m_doc);
if (v == NULL || PyDict_SetItemString(d, "__doc__", v) != 0) {
Py_XDECREF(v);
return NULL;
}
Py_DECREF(v);
}
m->md_def = module;
return (PyObject*)m;
}