static PyObject *py_bug_camera_grab(PyObject *self, PyObject *args,PyObject *kwds) {
pyimgObject *pyimg = (pyimgObject *) pyimgType.tp_alloc(&pyimgType, 0);
Py_BEGIN_ALLOW_THREADS
bug_camera_grab(&(pyimg->img));
Py_END_ALLOW_THREADS
return (PyObject *) pyimg;
}
static PyObject *db_new(PyObject *self, PyObject *args)
{
nmdbobject *db;
#ifdef PYTHON3
db = (nmdbobject *) nmdbType.tp_alloc(&nmdbType, 0);
#elif PYTHON2
db = PyObject_New(nmdbobject, &nmdbType);
#endif
if (db == NULL)
return NULL;
if (!PyArg_ParseTuple(args, ":new")) {
return NULL;
}
db->db = nmdb_init();
if (db->db == NULL) {
return PyErr_NoMemory();
}
/* XXX: is this necessary? */
if (PyErr_Occurred()) {
nmdb_free(db->db);
return NULL;
}
return (PyObject *) db;
}
/*@null@*/ PyObject *
PyStrListProxy_New(
/*@shared@*/ PyObject* owner,
Py_ssize_t size,
Py_ssize_t maxsize,
char (*array)[72]) {
PyStrListProxy* self = NULL;
if (maxsize == 0) {
maxsize = 68;
}
self = (PyStrListProxy*)PyStrListProxyType.tp_alloc(&PyStrListProxyType, 0);
if (self == NULL) {
return NULL;
}
Py_XINCREF(owner);
self->pyobject = owner;
self->size = size;
self->maxsize = maxsize;
self->array = array;
return (PyObject*)self;
}
template <typename U> static PyObject *c2py(U &&x) {
PyTypeObject *p = get_type_ptr(typeid(T));
if (p == nullptr) return NULL;
py_type *self = (py_type *)p->tp_alloc(p, 0);
if (self != NULL) { self->_c = new T{std::forward<U>(x)}; }
return (PyObject *)self;
}
static inline PyObject* execute(Arg& x)
{
BOOST_MPL_ASSERT((mpl::or_<is_class<T>, is_union<T> >));
PyTypeObject* type = Derived::get_class_object(x);
if (type == 0)
return python::detail::none();
PyObject* raw_result = type->tp_alloc(
type, objects::additional_instance_size<Holder>::value);
if (raw_result != 0)
{
python::detail::decref_guard protect(raw_result);
instance_t* instance = (instance_t*)raw_result;
// construct the new C++ object and install the pointer
// in the Python object.
Derived::construct(&instance->storage, (PyObject*)instance, x)->install(raw_result);
// Note the position of the internally-stored Holder,
// for the sake of destruction
Py_SIZE(instance) = offsetof(instance_t, storage);
// Release ownership of the python object
protect.cancel();
}
return raw_result;
}
static PyObject *
BufferSubtype_New(PyTypeObject *subtype,
Py_buffer *view_p,
int filled,
int preserve)
{
BufferObject *bp = (BufferObject *)Py_buffer_Type.tp_alloc(subtype, 0);
if (!bp) {
return 0;
}
bp->view_p = view_p;
bp->flags = 0;
if (bp->view_p) {
if (filled) {
bp->flags |= BUFOBJ_FILLED;
}
else {
bp->view_p->obj = 0;
}
if (!preserve) {
bp->flags |= BUFOBJ_MUTABLE;
}
}
else {
bp->flags = BUFOBJ_MUTABLE;
}
return (PyObject *)bp;
}
PyObject*
IcePy::createConnectionInfo(const Ice::ConnectionInfoPtr& connectionInfo)
{
PyTypeObject* type;
if(Ice::TCPConnectionInfoPtr::dynamicCast(connectionInfo))
{
type = &TCPConnectionInfoType;
}
else if(Ice::UDPConnectionInfoPtr::dynamicCast(connectionInfo))
{
type = &UDPConnectionInfoType;
}
else if(Ice::IPConnectionInfoPtr::dynamicCast(connectionInfo))
{
type = &IPConnectionInfoType;
}
else
{
type = &ConnectionInfoType;
}
ConnectionInfoObject* obj = reinterpret_cast<ConnectionInfoObject*>(type->tp_alloc(type, 0));
if(!obj)
{
return 0;
}
obj->connectionInfo = new Ice::ConnectionInfoPtr(connectionInfo);
return (PyObject*)obj;
}
B_WUR B_FUNC bool
b_py_question_class_set_native_vtable(
B_BORROW PyTypeObject *type,
B_BORROW struct B_QuestionVTable const *vtable) {
struct B_PyQuestionVTable *vtable_py
= (struct B_PyQuestionVTable *)
b_py_question_vtable_type_.tp_alloc(
&b_py_question_vtable_type_, 0);
if (!vtable_py) {
return false;
}
vtable_py->native_vtable = vtable;
vtable_py->python_vtable = b_py_python_question_vtable_;
vtable_py->python_vtable.uuid = vtable->uuid;
vtable_py->python_vtable.answer_vtable
= vtable->answer_vtable; // TODO(strager)
if (PyDict_SetItemString(
type->tp_dict,
b_py_question_vtable_key_,
(PyObject *) vtable_py) == -1) {
Py_DECREF(vtable_py);
return false;
}
Py_DECREF(vtable_py);
return true;
}
/**
* Factory function for a CArray used if only the number of items is known given.
*
* Note that this method does not increment the reference counter. You are responsible for
* calling Py_INCREF(obj) in the returned obj yourself
*/
PyObject* CArray_createFromLength(const char* format, int length) {
PyTypeObject* type = &CArray_Type;
CArrayObj* self;
void* items;
size_t item_size;
item_size = CArray_getItemSize(format);
if (item_size <= 0) {
return NULL;
}
items = calloc(item_size, length);
if (items == NULL) {
PyErr_SetString(PyExc_MemoryError, "out of memory");
return NULL;
}
if (length <= 0) {
PyErr_SetString(PyExc_ValueError, "length must be > 0");
return NULL;
}
self = (CArrayObj*) type->tp_alloc(type, 0);
CArray_initInstance(self, format, items, item_size, length, CArray_releaseElements);
return (PyObject*) self;
}
PyObject *
pygi_struct_new_from_g_type (GType g_type,
gpointer pointer,
gboolean free_on_dealloc)
{
PyGIStruct *self;
PyTypeObject *type;
type = (PyTypeObject *)pygi_type_import_by_g_type (g_type);
if (!type)
type = (PyTypeObject *)&PyGIStruct_Type; /* fallback */
if (!PyType_IsSubtype (type, &PyGIStruct_Type)) {
PyErr_SetString (PyExc_TypeError, "must be a subtype of gi.Struct");
return NULL;
}
self = (PyGIStruct *) type->tp_alloc (type, 0);
if (self == NULL) {
return NULL;
}
pyg_pointer_set_ptr (self, pointer);
( (PyGPointer *) self)->gtype = g_type;
self->free_on_dealloc = free_on_dealloc;
return (PyObject *) self;
}
/* PycairoFontFace_FromFontFace
* Create a new PycairoFontFace from a cairo_font_face_t
* font_face - a cairo_font_face_t to 'wrap' into a Python object.
* it is unreferenced if the PycairoFontFace creation fails
* Return value: New reference or NULL on failure
*/
PyObject *
PycairoFontFace_FromFontFace (cairo_font_face_t *font_face)
{
PyTypeObject *type = NULL;
PyObject *o;
assert (font_face != NULL);
if (Pycairo_Check_Status (cairo_font_face_status (font_face))) {
cairo_font_face_destroy (font_face);
return NULL;
}
switch (cairo_font_face_get_type (font_face)) {
case CAIRO_FONT_TYPE_TOY:
type = &PycairoToyFontFace_Type;
break;
default:
type = &PycairoFontFace_Type;
break;
}
o = type->tp_alloc (type, 0);
if (o == NULL)
cairo_font_face_destroy (font_face);
else
((PycairoFontFace *)o)->font_face = font_face;
return o;
}
static upb_sflow_t PyUpb_Message_StartSequence(void *m, upb_value fval) {
PyObject **seq = PyUpb_Accessor_GetPtr(m, fval);
PyTypeObject *type = ((PyUpb_MessageType*)Py_TYPE(m))->alt_type;
if (!*seq) *seq = type->tp_alloc(type, 0);
upb_stdmsg_sethas(m, fval);
return UPB_CONTINUE_WITH(*seq);
}
static PyObject *
_K_subscript(_K *self, PyObject *key)
{
int i;
K kobj = self->kobj;
char *skey;
int key_length;
int value_index = 1;
if (kobj->t != 5) {
PyErr_Format(PyExc_TypeError,
"k object of type %d is not a dictionary", kobj->t);
return NULL;
}
if (-1 == PyString_AsStringAndSize(key, &skey, &key_length)) {
return NULL;
}
if (skey[key_length-1] == '.') {
--key_length;
++value_index;
}
for (i=0; i < kobj->n; ++i) {
K e = KK(kobj)[i];
if (0 == strncmp(skey,Ks(KK(e)[0]),key_length)) {
PyTypeObject* type = self->ob_type;
_K* k = (_K*)type->tp_alloc(type, 0);
k->kobj = ci(KK(e)[value_index]);
return (PyObject*)k;
}
}
PyErr_SetObject(PyExc_KeyError, key);
return NULL;
}
static upb_sflow_t PyUpb_Message_StartSubmessage(void *m, upb_value fval) {
PyObject **submsg = PyUpb_Accessor_GetPtr(m, fval);
PyTypeObject *type = Py_TYPE(m);
if (!*submsg) *submsg = type->tp_alloc(type, 0);
upb_stdmsg_sethas(m, fval);
return UPB_CONTINUE_WITH(*submsg);
}
PyObject*
IcePy::createEndpointInfo(const Ice::EndpointInfoPtr& endpointInfo)
{
PyTypeObject* type;
if(Ice::TCPEndpointInfoPtr::dynamicCast(endpointInfo))
{
type = &TCPEndpointInfoType;
}
else if(Ice::UDPEndpointInfoPtr::dynamicCast(endpointInfo))
{
type = &UDPEndpointInfoType;
}
else if(Ice::OpaqueEndpointInfoPtr::dynamicCast(endpointInfo))
{
type = &OpaqueEndpointInfoType;
}
else if(Ice::IPEndpointInfoPtr::dynamicCast(endpointInfo))
{
type = &IPEndpointInfoType;
}
else
{
type = &EndpointInfoType;
}
EndpointInfoObject* obj = reinterpret_cast<EndpointInfoObject*>(type->tp_alloc(type, 0));
if(!obj)
{
return 0;
}
obj->endpointInfo = new Ice::EndpointInfoPtr(endpointInfo);
return (PyObject*)obj;
}
static PyObject *PyImage_cnew(Image *im)
{
PyImage *self;
self = (PyImage *)PyImageType.tp_alloc(&PyImageType, 0);
self->x = im;
self->dict = PyDict_New();
return (PyObject *)self;
}
static PyObject *pydega_create(void) {
Dega *dega = (Dega *)pydega_type.tp_alloc(&pydega_type, 0);
dega->input = uchararray_create(MastInput, sizeof(MastInput));
dega->ram = uchararray_create(pMastb->Ram, sizeof(pMastb->Ram));
dega->battery = uchararray_create(pMastb->Sram, sizeof(pMastb->Sram));
dega->readonly = 0;
return (PyObject *)dega;
}
static upb_sflow_t PyUpb_Message_StartRepeatedSubmessage(
void *a, upb_value fval) {
(void)fval;
PyObject **elem = upb_stdarray_append(a, sizeof(void*));
PyTypeObject *type = ((PyUpb_MessageType*)Py_TYPE(a))->alt_type;
if (!*elem) *elem = type->tp_alloc(type, 0);
return UPB_CONTINUE_WITH(*elem);
}
static PyObject*
FibonacciHeap_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
{
FibonacciHeap *fh;
fh = (FibonacciHeap *)FibonacciHeapType.tp_alloc(&FibonacciHeapType, 0);
return (PyObject *)fh;
}
/* PycairoSurface_FromSurface
* Create a new
* PycairoImageSurface,
* PycairoPDFSurface,
* PycairoPSSurface,
* PycairoSVGSurface,
* PycairoWin32Surface, or
* PycairoXlibSurface from a cairo_surface_t.
* surface - a cairo_surface_t to 'wrap' into a Python object.
* It is unreferenced if the PycairoSurface creation fails, or if the
* cairo_surface_t has an error status.
* base - the base object used to create the surface, or NULL.
* It is referenced to keep it alive while the cairo_surface_t is being used.
* Return value: New reference or NULL on failure
*/
PyObject *
PycairoSurface_FromSurface (cairo_surface_t *surface, PyObject *base)
{
PyTypeObject *type = NULL;
PyObject *o;
assert (surface != NULL);
if (Pycairo_Check_Status (cairo_surface_status (surface))) {
cairo_surface_destroy (surface);
return NULL;
}
switch (cairo_surface_get_type (surface)) {
#if CAIRO_HAS_IMAGE_SURFACE
case CAIRO_SURFACE_TYPE_IMAGE:
type = &PycairoImageSurface_Type;
break;
#endif
#if CAIRO_HAS_PDF_SURFACE
case CAIRO_SURFACE_TYPE_PDF:
type = &PycairoPDFSurface_Type;
break;
#endif
#if CAIRO_HAS_PS_SURFACE
case CAIRO_SURFACE_TYPE_PS:
type = &PycairoPSSurface_Type;
break;
#endif
#if CAIRO_HAS_SVG_SURFACE
case CAIRO_SURFACE_TYPE_SVG:
type = &PycairoSVGSurface_Type;
break;
#endif
#if CAIRO_HAS_WIN32_SURFACE
case CAIRO_SURFACE_TYPE_WIN32:
type = &PycairoWin32Surface_Type;
break;
#endif
#if CAIRO_HAS_XLIB_SURFACE
case CAIRO_SURFACE_TYPE_XLIB:
type = &PycairoXlibSurface_Type;
break;
#endif
default:
type = &PycairoSurface_Type;
break;
}
o = type->tp_alloc (type, 0);
if (o == NULL) {
cairo_surface_destroy (surface);
} else {
((PycairoSurface *)o)->surface = surface;
Py_XINCREF(base);
((PycairoSurface *)o)->base = base;
}
return o;
}
// ---------------------------------------------------------------------------------
static PyObject *
Mixer_GetControls( PyMixerObject* obj)
{
// Populate list of destinations first
PyObject* cRes= PyList_New( 0 );
if( !cRes )
return NULL;
// Scan all destinations
for( int i= 0; i< obj->cObj->GetDestinationsCount(); i++ )
{
//
char* sDest= obj->cObj->GetDestinationName( i );
// Scan all sources for destination
for( int j= 0; j< obj->cObj->GetConnectionsCount( i ); j++ )
{
// Set connection wise data
char* sConn= obj->cObj->GetConnectionName( i, j );
// Create lines under connections
for( int k= 0; k< obj->cObj->GetControlsCount( i, j ); k++ )
{
// Create the mixer control object
PyMixerControlObject* cControl= (PyMixerControlObject*)MixerControlType.tp_alloc( &MixerControlType, 0);
if( !cControl )
{
Py_DECREF( cRes );
return NULL;
}
// Set line wise data
cControl->cObj= obj;
Py_INCREF( obj );
cControl->iDest= i;
cControl->iConn= j;
cControl->iControl= k;
strcpy( cControl->sName, obj->cObj->GetControlName( i, j, k ) );
obj->cObj->GetControlValues( i, j, k,
&cControl->iMinValue, &cControl->iMaxValue, &cControl->iStep, &cControl->iType, &cControl->iChannels );
if( cControl->iChannels== 0 )
cControl->iChannels= 1;
// Create dictionary with all names and controls
PyObject *cTmp= Py_BuildValue( "{sssssssisN}",
"destination", sDest,
"connection", sConn,
"name", obj->cObj->GetControlName( i, j, k ),
"active", obj->cObj->IsActive( i, j, k ),
"control", cControl );
PyList_Append( cRes, cTmp );
Py_DECREF( cTmp );
}
}
}
return cRes;
}
PyObject*
PyFeasibilitySet_create(lp_feasibility_set_t* S) {
FeasibilitySet *self;
self = (FeasibilitySet*)FeasibilitySetType.tp_alloc(&FeasibilitySetType, 0);
if (self != NULL) {
self->S = S;
}
return (PyObject *)self;
}
static PyObject*
Camera_new(Camera* obj) {
CameraWrap* self;
self = (CameraWrap*)cameraType.tp_alloc(&cameraType, 0);
self->camObj = obj;
return (PyObject*)self;
}
inline PyObject* create_SizeObject(const Size& d) {
PyTypeObject* t = get_SizeType();
if (t == 0)
return 0;
SizeObject* so;
so = (SizeObject*)t->tp_alloc(t, 0);
so->m_x = new Size(d);
return (PyObject*)so;
}
/* Create a python quad from a C quad */
PyObject*
PyQuad_FromQuad(qdouble x)
{
PYQUAD_PRIVATE* p = (PYQUAD_PRIVATE*)PyQuad_Type.tp_alloc(&PyQuad_Type, 0);
if (p) {
p->obval = x;
}
return (PyObject*)p;
}
inline PyObject* create_RegionMapObject(const RegionMap& d) {
PyTypeObject* t = get_RegionMapType();
if (t == 0)
return 0;
RegionMapObject* so;
so = (RegionMapObject*)t->tp_alloc(t, 0);
so->m_x = new RegionMap(d);
return (PyObject*)so;
}
inline PyObject* create_RegionObject(const Region& d) {
PyTypeObject* t = get_RegionType();
if (t == 0)
return 0;
RegionObject* so;
so = (RegionObject*)t->tp_alloc(t, 0);
((RectObject*)so)->m_x = new Region(d);
return (PyObject*)so;
}
inline PyObject* create_RGBPixelObject(const RGBPixel& d) {
PyTypeObject* t = get_RGBPixelType();
if (t == 0)
return 0;
RGBPixelObject* so;
so = (RGBPixelObject*)t->tp_alloc(t, 0);
so->m_x = new RGBPixel(d);
return (PyObject*)so;
}
inline PyObject* create_FloatPointObject(const FloatPoint& d) {
PyTypeObject* t = get_FloatPointType();
if (t == 0)
return 0;
FloatPointObject* so;
so = (FloatPointObject*)t->tp_alloc(t, 0);
so->m_x = new FloatPoint(d);
return (PyObject*)so;
}
inline PyObject* create_DimObject(const Dim& d) {
PyTypeObject* t = get_DimType();
if (t == 0)
return 0;
DimObject* so;
so = (DimObject*)t->tp_alloc(t, 0);
so->m_x = new Dim(d);
return (PyObject*)so;
}
