static PyObject *convert(T p[n]) { array_wrap *aw = PyObject_New(array_wrap, &array_wrapType); aw->p = p; return PyObject_Init((PyObject *)aw, &array_wrapType); }
/* Create a thunk without checking if `func` is a strict type. return: A new reference. */ static PyObject * _thunk_new_no_check(PyTypeObject *cls, PyObject *func, PyObject *args, PyObject *kwargs) { thunk *self; if (!(self = (thunk*) cls->tp_alloc(cls, 0))) { return NULL; } Py_INCREF(func); self->th_func = func; Py_INCREF(args); self->th_args = args; Py_XINCREF(kwargs); self->th_kwargs = kwargs; self->th_normal = NULL; PyObject_Init((PyObject*) self, cls); return (PyObject*) self; }
static PyObject * pcap_PcapObject_iter(PyObject *p) { pcap_PcapObject *self = (pcap_PcapObject *)p; pcap_PcapIterObject *it = NULL; PyObject *pIt; attempt { if ('r' != self->mode) { PyErr_Format(PyExc_IOError, "can not read from writable stream"); break; } it = PyObject_New(pcap_PcapIterObject, &pcap_PcapIterType); if (! it) break; pIt = PyObject_Init((PyObject *)it, &pcap_PcapIterType); if (pIt != (PyObject *)it) break; it->pcap = p; Py_INCREF(it->pcap); } recover { if (it) { Py_CLEAR(it->pcap); Py_CLEAR(it); } return NULL; } return (PyObject *)it; }
extern "C" PyObject* _PyObject_New(PyTypeObject* cls) { assert(cls->tp_itemsize == 0); auto rtn = (PyObject*)gc_alloc(cls->tp_basicsize, gc::GCKind::PYTHON); // no memset for this function PyObject_Init(rtn, cls); return rtn; }
extern "C" PyObject* PyType_GenericAlloc(PyTypeObject* cls, Py_ssize_t nitems) { RELEASE_ASSERT(nitems == 0, "unimplemented"); RELEASE_ASSERT(cls->tp_itemsize == 0, "unimplemented"); auto rtn = (PyObject*)gc_alloc(cls->tp_basicsize, gc::GCKind::PYTHON); memset(rtn, 0, cls->tp_basicsize); PyObject_Init(rtn, cls); return rtn; }
static PyObject *PySilcUser_New(SilcClientEntry user) { PySilcUser *pyuser = (PySilcUser *)PyObject_New(PySilcUser, &PySilcUser_Type); if (!pyuser) return NULL; pyuser->silcobj = user; // TODO: maybe we need to do a clone? pyuser->silcobj->context = pyuser; // TODO: self ref should be weak ref? PyObject_Init((PyObject *)pyuser, &PySilcUser_Type); return (PyObject *)pyuser; }
PyObject* PyThunkUnaryPipeline_FromFunction(UnaryPipelineFunction function, PyObject *left) { PyThunkOperation_UnaryPipeline *op = PyObject_MALLOC(sizeof(PyThunkOperation_UnaryPipeline)); if (op == NULL) return PyErr_NoMemory(); PyObject_Init((PyObject*)op, &PyThunkUnaryPipeline_Type); op->function = function; Py_XINCREF(left); op->left = left; return (PyObject*)op; }
PyObject* PyThunk_FromOperation(PyObject *operation, ssize_t cardinality, int cardinality_type, int type) { register PyThunkObject *thunk; thunk = (PyThunkObject *)PyObject_MALLOC(sizeof(PyThunkObject)); if (thunk == NULL) return PyErr_NoMemory(); PyObject_Init((PyObject*)thunk, &PyThunk_Type); PyThunk_FromOperation_Inplace(thunk, operation, cardinality, cardinality_type, type); return (PyObject*)thunk; }
/*static*/ PyObject * PythonScript::QObjectToPython(QObject * o) { pyQObject * obj; obj = PyObject_New(pyQObject, &pyQObjectType); if (!obj) return NULL; obj = (pyQObject*)PyObject_Init((PyObject*)obj, &pyQObjectType); obj->_TWcontext = ENCAPSULATE_C_POINTER(o); return (PyObject*)obj; }
/*static*/ PyObject* PythonScript::getAttribute(PyObject * o, PyObject * attr_name) { QObject * obj; QMetaMethod method; QString propName; QVariant result; pyQObjectMethodObject * pyMethod; // Get the QObject* we operate on if (!PyObject_TypeCheck(o, &pyQObjectType)) { PyErr_SetString(PyExc_TypeError, qPrintable(tr("getattr: not a valid TW object"))); return NULL; } if (!IS_ENCAPSULATED_C_POINTER(((pyQObject*)o)->_TWcontext)) { PyErr_SetString(PyExc_TypeError, qPrintable(tr("getattr: not a valid TW object"))); return NULL; } obj = (QObject*)GET_ENCAPSULATED_C_POINTER((PyObject*)(((pyQObject*)o)->_TWcontext)); if (!asQString(attr_name, propName)) { PyErr_SetString(PyExc_TypeError, qPrintable(tr("getattr: invalid property name"))); return NULL; } if (propName.length() > 1 && propName.endsWith(QChar('_'))) propName.chop(1); switch (doGetProperty(obj, propName, result)) { case Property_DoesNotExist: PyErr_Format(PyExc_AttributeError, qPrintable(tr("getattr: object doesn't have property/method %s")), qPrintable(propName)); return NULL; case Property_NotReadable: PyErr_Format(PyExc_AttributeError, qPrintable(tr("getattr: property %s is not readable")), qPrintable(propName)); return NULL; case Property_Method: pyMethod = PyObject_New(pyQObjectMethodObject, &pyQObjectMethodType); pyMethod = (pyQObjectMethodObject*)PyObject_Init((PyObject*)pyMethod, &pyQObjectMethodType); Py_INCREF(pyMethod); pyMethod->_TWcontext = ENCAPSULATE_C_POINTER(obj); Py_XINCREF(attr_name); pyMethod->_methodName = (PyObject*)attr_name; return (PyObject*)pyMethod; case Property_OK: return PythonScript::VariantToPython(result); default: break; } // we should never reach this point return NULL; }
static PyObject * _thunk_new_normal(PyTypeObject *cls, PyObject *normal) { thunk *self; if (!(self = (thunk*) cls->tp_alloc(cls, 0))) { return NULL; } self->th_func = NULL; self->th_args = NULL; self->th_kwargs = NULL; self->th_normal = normal; Py_INCREF(normal); PyObject_Init((PyObject*) self, cls); return (PyObject*) self; }
PyObject* PyThunk_Copy(PyThunkObject *original) { register PyThunkObject *thunk; thunk = (PyThunkObject *)PyObject_MALLOC(sizeof(PyThunkObject)); if (thunk == NULL) return PyErr_NoMemory(); PyObject_Init((PyObject*)thunk, &PyThunk_Type); thunk->storage = original->storage; thunk->evaluated = original->evaluated; thunk->operation = original->operation; thunk->cardinality = original->cardinality; thunk->type = original->type; thunk->options = original->options; thunk->blockmask = original->blockmask; return (PyObject*)thunk; }
PyObject * possibilitiesToPyObject(HyPossibilities possibilities, PyObject* sack) { _PossibilitiesObject *p; p = PyObject_New(_PossibilitiesObject, &possibilities_Type); if (!p) return NULL; if (!PyObject_Init((PyObject *)p, &possibilities_Type)) { Py_DECREF(p); return NULL; } p->possibilities = possibilities; p->sack = sack; Py_XINCREF(p->sack); return (PyObject *)p; }
/** * Construct a KEY_PRIVATE Key from `p[0..size]` and return it. */ Key * acid_make_private_key(uint8_t *p, Py_ssize_t size) { if(size > KEY_MAXSIZE) { PyErr_SetString(PyExc_ValueError, "Key is too long ."); return NULL; } Key *self = PyObject_Malloc(sizeof(Key) + size); if(self) { PyObject_Init((PyObject *)self, &KeyType); Key_SIZE(self) = size; self->flags = KEY_PRIVATE; self->p = ((uint8_t *) self) + sizeof(Key) + KEY_PREFIX_SLACK; if(p) { memcpy(self->p + KEY_PREFIX_SLACK, p, size); } } return self; }
/* This is the `tp_iter()' method of `EMList' object. */ static PyObject *em_list_iter(em_list_t *self) { em_list_index_hdr_t *index = self->index->address; em_list_iter_t *iter; if((iter = PyObject_New(em_list_iter_t, &em_list_iter_type)) != NULL) { PyObject_Init((PyObject *)iter, &em_list_iter_type); Py_INCREF(self); iter->em_list = self; iter->pos = 0; iter->maxpos = index->used; } else PyErr_SetString(PyExc_RuntimeError, "Failed to initialize iterator"); return (PyObject *)iter; }
PyObject* PyThunk_FromArray(PyObject *unused, PyObject *input) { register PyThunkObject *thunk; (void) unused; input = PyArray_FromAny(input, NULL, 0, 0, NPY_ARRAY_ENSURECOPY, NULL); if (input == NULL || !PyArray_CheckExact(input)) { PyErr_SetString(PyExc_TypeError, "Expected a NumPy array as parameter."); return NULL; } thunk = (PyThunkObject *)PyObject_MALLOC(sizeof(PyThunkObject)); if (thunk == NULL) return PyErr_NoMemory(); PyObject_Init((PyObject*)thunk, &PyThunk_Type); thunk->storage = (PyArrayObject*) input; thunk->evaluated = true; thunk->operation = NULL; thunk->cardinality = PyArray_SIZE(thunk->storage); thunk->type = PyArray_TYPE(thunk->storage); thunk->options = THUNK_CARDINALITY_EXACT; thunk->blockmask = NULL; return (PyObject*)thunk; }
/** * Construct a KEY_SHARED Key from ... */ Key * acid_make_shared_key(PyObject *source, uint8_t *p, Py_ssize_t size) { if(size > KEY_MAXSIZE) { PyErr_SetString(PyExc_ValueError, "Key is too long ."); return NULL; } Key *self = PyObject_Malloc(sizeof(Key) + sizeof(SharedKeyInfo)); // TODO: relies on arch padding rules if(self) { PyObject_Init((PyObject *)self, &KeyType); if(ms_listen(source, (PyObject *) self)) { PyObject_Free(self); return NULL; } self->flags = KEY_SHARED; self->p = p; Key_SIZE(self) = size; Key_INFO(self)->source = source; Py_INCREF(source); } return self; }
static PyObject * ufunc_frompyfunc(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *NPY_UNUSED(kwds)) { /* Keywords are ignored for now */ PyObject *function, *pyname = NULL; int nin, nout, i; PyUFunc_PyFuncData *fdata; PyUFuncObject *self; char *fname, *str; Py_ssize_t fname_len = -1; int offset[2]; if (!PyArg_ParseTuple(args, "Oii", &function, &nin, &nout)) { return NULL; } if (!PyCallable_Check(function)) { PyErr_SetString(PyExc_TypeError, "function must be callable"); return NULL; } if (nin + nout > NPY_MAXARGS) { PyErr_Format(PyExc_ValueError, "Cannot construct a ufunc with more than %d operands " "(requested number were: inputs = %d and outputs = %d)", NPY_MAXARGS, nin, nout); return NULL; } self = PyArray_malloc(sizeof(PyUFuncObject)); if (self == NULL) { return NULL; } PyObject_Init((PyObject *)self, &PyUFunc_Type); self->userloops = NULL; self->nin = nin; self->nout = nout; self->nargs = nin + nout; self->identity = PyUFunc_None; self->functions = pyfunc_functions; self->ntypes = 1; /* generalized ufunc */ self->core_enabled = 0; self->core_num_dim_ix = 0; self->core_num_dims = NULL; self->core_dim_ixs = NULL; self->core_offsets = NULL; self->core_signature = NULL; self->op_flags = PyArray_malloc(sizeof(npy_uint32)*self->nargs); if (self->op_flags == NULL) { return PyErr_NoMemory(); } memset(self->op_flags, 0, sizeof(npy_uint32)*self->nargs); self->iter_flags = 0; self->type_resolver = &object_ufunc_type_resolver; self->legacy_inner_loop_selector = &object_ufunc_loop_selector; pyname = PyObject_GetAttrString(function, "__name__"); if (pyname) { (void) PyString_AsStringAndSize(pyname, &fname, &fname_len); } if (PyErr_Occurred()) { fname = "?"; fname_len = 1; PyErr_Clear(); } /* * self->ptr holds a pointer for enough memory for * self->data[0] (fdata) * self->data * self->name * self->types * * To be safest, all of these need their memory aligned on void * pointers * Therefore, we may need to allocate extra space. */ offset[0] = sizeof(PyUFunc_PyFuncData); i = (sizeof(PyUFunc_PyFuncData) % sizeof(void *)); if (i) { offset[0] += (sizeof(void *) - i); } offset[1] = self->nargs; i = (self->nargs % sizeof(void *)); if (i) { offset[1] += (sizeof(void *)-i); } self->ptr = PyArray_malloc(offset[0] + offset[1] + sizeof(void *) + (fname_len + 14)); if (self->ptr == NULL) { Py_XDECREF(pyname); return PyErr_NoMemory(); } Py_INCREF(function); self->obj = function; fdata = (PyUFunc_PyFuncData *)(self->ptr); fdata->nin = nin; fdata->nout = nout; fdata->callable = function; self->data = (void **)(((char *)self->ptr) + offset[0]); self->data[0] = (void *)fdata; self->types = (char *)self->data + sizeof(void *); for (i = 0; i < self->nargs; i++) { self->types[i] = NPY_OBJECT; } str = self->types + offset[1]; memcpy(str, fname, fname_len); memcpy(str+fname_len, " (vectorized)", 14); self->name = str; Py_XDECREF(pyname); /* Do a better job someday */ self->doc = "dynamic ufunc based on a python function"; return (PyObject *)self; }
fffpy_multi_iterator* fffpy_multi_iterator_new(int narr, int axis, ...) { fffpy_multi_iterator* thisone; va_list va; fff_vector** vector; PyArrayMultiIterObject *multi; PyObject *current, *arr; int i, err=0; /* Create new instance */ thisone = (fffpy_multi_iterator*)malloc(sizeof(fffpy_multi_iterator)); multi = PyArray_malloc(sizeof(PyArrayMultiIterObject)); vector = (fff_vector**)malloc(narr*sizeof(fff_vector*)); /* Initialize the PyArrayMultiIterObject instance from the variadic arguments */ PyObject_Init((PyObject *)multi, &PyArrayMultiIter_Type); for (i=0; i<narr; i++) multi->iters[i] = NULL; multi->numiter = narr; multi->index = 0; va_start(va, axis); for (i=0; i<narr; i++) { current = va_arg(va, PyObject *); arr = PyArray_FROM_O(current); if (arr==NULL) { err=1; break; } else { multi->iters[i] = (PyArrayIterObject *)PyArray_IterAllButAxis(arr, &axis); Py_DECREF(arr); } } va_end(va); /* Test */ if (!err && _PyArray_BroadcastAllButAxis(multi, axis) < 0) err=1; if (err) { FFF_ERROR("Cannot create broadcast object", ENOMEM); free(thisone); free(vector); Py_DECREF(multi); return NULL; } /* Initialize the multi iterator */ PyArray_MultiIter_RESET(multi); /* Create the fff vectors (views or copies) */ for(i=0; i<narr; i++) vector[i] = _fff_vector_new_from_PyArrayIter((const PyArrayIterObject*)multi->iters[i], axis); /* Instantiate fiels */ thisone->narr = narr; thisone->axis = axis; thisone->vector = vector; thisone->multi = multi; thisone->index = thisone->multi->index; thisone->size = thisone->multi->size; return thisone; }
static PyObject * pyshark_iter(PyObject *self, PyObject *args) { gsize i; char *filename; PyObject *keylistobj; const char *dfilter; char *decode_as = NULL; pyshark_Iter *p; gint ret; /* NB: Automatic sanity checks for 1st, 3rd, and optional 4th argument */ if(!PyArg_ParseTuple(args, "sOs|s", &filename, &keylistobj, &dfilter, &decode_as)) { return NULL; } /* NB: Explicit sanity checks needed for the second argument */ if(!PyList_Check(keylistobj)) { PyErr_SetString(PyExc_TypeError, "Second argument must be a list of wireshark fieldnames"); return NULL; } for(i = 0; i < PyList_Size(keylistobj); i++) { PyObject *fieldnameobj = PyList_GetItem(keylistobj, i); if (!PyString_Check(fieldnameobj)) { PyErr_SetString(PyExc_TypeError, "All items in second argument list must be strings"); return NULL; } } /* NB: See PyObject.ob_type in http://docs.python.org/c-api/typeobj.html for more info */ pyshark_IterType.ob_type = &PyType_Type; //pyshark_Iter; /* NB: look at bottom of http://docs.python.org/c-api/type.html */ ret = PyType_Ready(&pyshark_IterType); if(ret) { return NULL; } /* Create our iterator object */ p = PyObject_New(pyshark_Iter, &pyshark_IterType); if(!p) { return NULL; } /* Initialize all our data structures in the iterator object to 0. This makes it easier to implement deallocation logic for both expected and unexpected cases. */ p->clean = FALSE; p->decode_as = NULL; p->stdata = NULL; p->nwpykeylist = NULL; p->wpykeyhash = NULL; p->asel = FALSE; p->show_empty_fields = FALSE; if(!PyObject_Init((PyObject *)p, &pyshark_IterType)) { Py_DECREF(p); return NULL; } p->stdata = stdata_new(); if(!p->stdata) { Py_DECREF(p); return NULL; } p->wpykeyhash = g_hash_table_new(g_str_hash, g_str_equal); p->nwpykeylist = g_ptr_array_new(); /* Iterate through the Python List and add to either fieldnames OR wfieldnames depending on presence of a '*' in the string */ for(i = 0; i < PyList_Size(keylistobj); i++) { /* NB: we know these are not NULL because of our sanity checks above */ PyObject *keyobj = PyList_GetItem(keylistobj, i); /* Check for wildcard entries, e.g. "*", "ip.*", "eth.*", etc. */ const gchar *key = PyString_AsString(keyobj); gchar *ptr = g_strstr_len(key, strnlen(key, 100), "*"); if(ptr) { /* We have a fieldname with a wildcard in it * * Use pointer arithmetic to figure out the length * TODO: better way to do this, maybe? */ gsize prefix_len = (gsize)ptr - (gsize)key; g_ptr_array_add(p->stdata->wfieldnames, g_strndup(key, prefix_len)); } else { /* * Non-wildcard entry. */ g_ptr_array_add(p->stdata->fieldnames, PyString_AsString(keyobj)); /* On the python-module side of things, keep a list of python objects, one for each non-wildcard fieldname to be processed by sharktools. NB: the index between entries in p->{stdata->fieldnames,nwpykeylist} MUST be the same. */ g_ptr_array_add(p->nwpykeylist, keyobj); /* The above array_add() call doesn't deep copy the fieldname, let's increment the refcount, and decrement it when we cleanup. NB: also used for our copy of the key in p->nwpykeylist */ Py_INCREF(keyobj); } } /* If there is a decode_as string set, add it */ if(decode_as) { dprintf("decode as string added: %s\n", decode_as); ret = sharktools_add_decode_as(decode_as); if(ret == FALSE) { dprintf("%s\n", sharktools_errmsg); PyErr_SetString(PySharkError, sharktools_errmsg); Py_DECREF(p); return NULL; } /* NB: Add to object state; we'll need to remove it later */ p->decode_as = strndup(decode_as, strlen(decode_as)); } /* * Create and initialize sharktools' state */ ret = sharktools_iter_init(p->stdata, filename, strdup(dfilter)); if(ret < 0) { dprintf("%s\n", sharktools_errmsg); PyErr_SetString(PySharkError, sharktools_errmsg); Py_DECREF(p); return NULL; } /* NB: We are dirty */ p->clean = FALSE; return (PyObject *)p; }