static PyObject * nsmallest(PyObject *self, PyObject *args) { PyObject *heap=NULL, *elem, *iterable, *los, *it, *oldelem; Py_ssize_t i, n; int cmp; if (!PyArg_ParseTuple(args, "nO:nsmallest", &n, &iterable)) return NULL; it = PyObject_GetIter(iterable); if (it == NULL) return NULL; heap = PyList_New(0); if (heap == NULL) goto fail; for (i=0 ; i<n ; i++ ){ elem = PyIter_Next(it); if (elem == NULL) { if (PyErr_Occurred()) goto fail; else goto sortit; } if (PyList_Append(heap, elem) == -1) { Py_DECREF(elem); goto fail; } Py_DECREF(elem); } n = PyList_GET_SIZE(heap); if (n == 0) goto sortit; for (i=n/2-1 ; i>=0 ; i--) if(_siftupmax((PyListObject *)heap, i) == -1) goto fail; los = PyList_GET_ITEM(heap, 0); while (1) { elem = PyIter_Next(it); if (elem == NULL) { if (PyErr_Occurred()) goto fail; else goto sortit; } cmp = PyObject_RichCompareBool(elem, los, Py_LT); if (cmp == -1) { Py_DECREF(elem); goto fail; } if (cmp == 0) { Py_DECREF(elem); continue; } oldelem = PyList_GET_ITEM(heap, 0); PyList_SET_ITEM(heap, 0, elem); Py_DECREF(oldelem); if (_siftupmax((PyListObject *)heap, 0) == -1) goto fail; los = PyList_GET_ITEM(heap, 0); } sortit: if (PyList_Sort(heap) == -1) goto fail; Py_DECREF(it); return heap; fail: Py_DECREF(it); Py_XDECREF(heap); return NULL; }
static PyObject * functools_reduce(PyObject *self, PyObject *args) { PyObject *seq, *func, *result = NULL, *it; if (!PyArg_UnpackTuple(args, "reduce", 2, 3, &func, &seq, &result)) return NULL; if (result != NULL) Py_INCREF(result); it = PyObject_GetIter(seq); if (it == NULL) { if (PyErr_ExceptionMatches(PyExc_TypeError)) PyErr_SetString(PyExc_TypeError, "reduce() arg 2 must support iteration"); Py_XDECREF(result); return NULL; } if ((args = PyTuple_New(2)) == NULL) goto Fail; for (;;) { PyObject *op2; if (args->ob_refcnt > 1) { Py_DECREF(args); if ((args = PyTuple_New(2)) == NULL) goto Fail; } op2 = PyIter_Next(it); if (op2 == NULL) { if (PyErr_Occurred()) goto Fail; break; } if (result == NULL) result = op2; else { PyTuple_SetItem(args, 0, result); PyTuple_SetItem(args, 1, op2); if ((result = PyEval_CallObject(func, args)) == NULL) goto Fail; } } Py_DECREF(args); if (result == NULL) PyErr_SetString(PyExc_TypeError, "reduce() of empty sequence with no initial value"); Py_DECREF(it); return result; Fail: Py_XDECREF(args); Py_XDECREF(result); Py_DECREF(it); return NULL; }
static int convertTo_QSet_0101QAbstractState(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj) { QSet<QAbstractState *> **sipCppPtr = reinterpret_cast<QSet<QAbstractState *> **>(sipCppPtrV); #line 456 "/home/tsheasha/GUC/Bachelors/android-python27/python-build/PyQt-x11-gpl-4.8/sip/QtCore/qset.sip" PyObject *it = PyObject_GetIter(sipPy), *itm; // Check the type if that is all that is required. if (sipIsErr == NULL) { if (it == NULL) return 0; while ((itm = PyIter_Next(it)) != NULL) { int ok = sipCanConvertToType(itm, sipType_QAbstractState, 0); Py_DECREF(itm); if (!ok) { Py_DECREF(it); return 0; } } Py_DECREF(it); return 1; } if (it == NULL) { *sipIsErr = 1; return 0; } QSet<QAbstractState *> *qs = new QSet<QAbstractState *>; while ((itm = PyIter_Next(it)) != NULL) { QAbstractState *t = reinterpret_cast<QAbstractState *>(sipConvertToType(itm, sipType_QAbstractState, sipTransferObj, 0, 0, sipIsErr)); Py_DECREF(itm); if (*sipIsErr) { delete qs; Py_DECREF(it); return 0; } qs->insert(t); } Py_DECREF(it); *sipCppPtr = qs; return sipGetState(sipTransferObj); #line 138 "sipQtCoreQSet0101QAbstractState.cpp" }
PyObject* initialize(PyObject* self, PyObject *originalTimeSeries, PyObject *calculatedTimesSeries) { if (0 < PySequence_Size(PyObject_GetAttrString(self, "_errorValues"))) { PyErr_SetString(PyExc_StandardError, "An ErrorMeasure can only be initialized once."); return NULL; } PyObject_CallMethodObjArgs(originalTimeSeries, PyString_FromString("sort_timeseries"), NULL); PyObject_CallMethodObjArgs(calculatedTimesSeries, PyString_FromString("sort_timeseries"), NULL); int index = 0; PyObject* orgPair; PyObject* calcPair; PyObject* local_error; PyObject* _errorValues = PyList_New(PyObject_Length(originalTimeSeries)); PyObject* _errorDates = PyList_New(PyObject_Length(originalTimeSeries)); PyObject* iterator1 = PyObject_GetIter(originalTimeSeries); while ((orgPair = PyIter_Next(iterator1))) { PyObject* iterator2 = PyObject_GetIter(calculatedTimesSeries); while ((calcPair = PyIter_Next(iterator2))) { if (PyFloat_AsDouble(PySequence_GetItem(orgPair, 0)) != PyFloat_AsDouble(PySequence_GetItem(calcPair, 0))) continue; local_error = PyObject_CallMethodObjArgs(self, PyString_FromString("local_error"), PyList_GetSlice(orgPair, 1, PyList_Size(orgPair)), PyList_GetSlice(calcPair, 1, PyList_Size(calcPair)), NULL ); //NotImplemented Exception if(!local_error || PyErr_Occurred()) { PyErr_SetString(PyExc_NotImplementedError, ""); return NULL; } PyList_SetItem(_errorValues, index, local_error); PyList_SetItem(_errorDates, index, PySequence_GetItem(orgPair, 0)); ++index; Py_DECREF(calcPair); } Py_DECREF(iterator2); Py_DECREF(orgPair); } Py_DECREF(iterator1); //Cut off trailing zeroes _errorValues = PyList_GetSlice(_errorValues, 0, index); _errorDates = PyList_GetSlice(_errorDates, 0, index); //return False, if the error cannot be calculated double _minimalErrorCalculationPercentage = PyFloat_AsDouble(PyObject_GetAttrString(self, "_minimalErrorCalculationPercentage")); if(PyList_Size(_errorValues) < (_minimalErrorCalculationPercentage * (float)PyObject_Length(originalTimeSeries))) Py_RETURN_FALSE; PyObject_SetAttrString(self, "_errorValues", _errorValues); PyObject_SetAttrString(self, "_errorDates", _errorDates); Py_RETURN_TRUE; }
static int convertTo_QList_0100QLowEnergyDescriptor(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj) { QList<QLowEnergyDescriptor> **sipCppPtr = reinterpret_cast<QList<QLowEnergyDescriptor> **>(sipCppPtrV); #line 66 "sip/QtCore/qpycore_qlist.sip" PyObject *iter = PyObject_GetIter(sipPy); if (!sipIsErr) { Py_XDECREF(iter); return (iter #if PY_MAJOR_VERSION < 3 && !PyString_Check(sipPy) #endif && !PyUnicode_Check(sipPy)); } if (!iter) { *sipIsErr = 1; return 0; } QList<QLowEnergyDescriptor> *ql = new QList<QLowEnergyDescriptor>; for (SIP_SSIZE_T i = 0; ; ++i) { PyErr_Clear(); PyObject *itm = PyIter_Next(iter); if (!itm) { if (PyErr_Occurred()) { delete ql; Py_DECREF(iter); *sipIsErr = 1; return 0; } break; } int state; QLowEnergyDescriptor *t = reinterpret_cast<QLowEnergyDescriptor *>( sipForceConvertToType(itm, sipType_QLowEnergyDescriptor, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QLowEnergyDescriptor' is expected", i, Py_TYPE(itm)->tp_name); Py_DECREF(itm); delete ql; Py_DECREF(iter); return 0; } ql->append(*t); sipReleaseType(t, sipType_QLowEnergyDescriptor, state); Py_DECREF(itm); } Py_DECREF(iter); *sipCppPtr = ql; return sipGetState(sipTransferObj); #line 142 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtBluetooth/sipQtBluetoothQList0100QLowEnergyDescriptor.cpp" }
/* function subhandler */ Datum PLy_exec_function(FunctionCallInfo fcinfo, PLyProcedure *proc) { Datum rv; PyObject *volatile plargs = NULL; PyObject *volatile plrv = NULL; ErrorContextCallback plerrcontext; PG_TRY(); { if (!proc->is_setof || proc->setof == NULL) { /* * Simple type returning function or first time for SETOF * function: actually execute the function. */ plargs = PLy_function_build_args(fcinfo, proc); plrv = PLy_procedure_call(proc, "args", plargs); if (!proc->is_setof) { /* * SETOF function parameters will be deleted when last row is * returned */ PLy_function_delete_args(proc); } Assert(plrv != NULL); } /* * If it returns a set, call the iterator to get the next return item. * We stay in the SPI context while doing this, because PyIter_Next() * calls back into Python code which might contain SPI calls. */ if (proc->is_setof) { bool has_error = false; ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo; if (proc->setof == NULL) { /* first time -- do checks and setup */ if (!rsi || !IsA(rsi, ReturnSetInfo) || (rsi->allowedModes & SFRM_ValuePerCall) == 0) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("unsupported set function return mode"), errdetail("PL/Python set-returning functions only support returning only value per call."))); } rsi->returnMode = SFRM_ValuePerCall; /* Make iterator out of returned object */ proc->setof = PyObject_GetIter(plrv); Py_DECREF(plrv); plrv = NULL; if (proc->setof == NULL) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("returned object cannot be iterated"), errdetail("PL/Python set-returning functions must return an iterable object."))); } /* Fetch next from iterator */ plrv = PyIter_Next(proc->setof); if (plrv) rsi->isDone = ExprMultipleResult; else { rsi->isDone = ExprEndResult; has_error = PyErr_Occurred() != NULL; } if (rsi->isDone == ExprEndResult) { /* Iterator is exhausted or error happened */ Py_DECREF(proc->setof); proc->setof = NULL; Py_XDECREF(plargs); Py_XDECREF(plrv); PLy_function_delete_args(proc); if (has_error) PLy_elog(ERROR, "error fetching next item from iterator"); /* Disconnect from the SPI manager before returning */ if (SPI_finish() != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed"); fcinfo->isnull = true; return (Datum) NULL; } } /* * Disconnect from SPI manager and then create the return values datum * (if the input function does a palloc for it this must not be * allocated in the SPI memory context because SPI_finish would free * it). */ if (SPI_finish() != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed"); plerrcontext.callback = plpython_return_error_callback; plerrcontext.previous = error_context_stack; error_context_stack = &plerrcontext; /* * If the function is declared to return void, the Python return value * must be None. For void-returning functions, we also treat a None * return value as a special "void datum" rather than NULL (as is the * case for non-void-returning functions). */ if (proc->result.out.d.typoid == VOIDOID) { if (plrv != Py_None) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("PL/Python function with return type \"void\" did not return None"))); fcinfo->isnull = false; rv = (Datum) 0; } else if (plrv == Py_None) { fcinfo->isnull = true; if (proc->result.is_rowtype < 1) rv = InputFunctionCall(&proc->result.out.d.typfunc, NULL, proc->result.out.d.typioparam, -1); else /* Tuple as None */ rv = (Datum) NULL; } else if (proc->result.is_rowtype >= 1) { TupleDesc desc; /* make sure it's not an unnamed record */ Assert((proc->result.out.d.typoid == RECORDOID && proc->result.out.d.typmod != -1) || (proc->result.out.d.typoid != RECORDOID && proc->result.out.d.typmod == -1)); desc = lookup_rowtype_tupdesc(proc->result.out.d.typoid, proc->result.out.d.typmod); rv = PLyObject_ToCompositeDatum(&proc->result, desc, plrv); fcinfo->isnull = (rv == (Datum) NULL); } else { fcinfo->isnull = false; rv = (proc->result.out.d.func) (&proc->result.out.d, -1, plrv); } } PG_CATCH(); { Py_XDECREF(plargs); Py_XDECREF(plrv); /* * If there was an error the iterator might have not been exhausted * yet. Set it to NULL so the next invocation of the function will * start the iteration again. */ Py_XDECREF(proc->setof); proc->setof = NULL; PG_RE_THROW(); } PG_END_TRY(); error_context_stack = plerrcontext.previous; Py_XDECREF(plargs); Py_DECREF(plrv); return rv; }
static PyObject * namespace_repr(_PyNamespaceObject *ns) { int i, loop_error = 0; PyObject *pairs = NULL, *d = NULL, *keys = NULL, *keys_iter = NULL; PyObject *key; PyObject *separator, *pairsrepr, *repr = NULL; i = Py_ReprEnter((PyObject *)ns); if (i != 0) { return i > 0 ? PyUnicode_FromString("namespace(...)") : NULL; } pairs = PyList_New(0); if (pairs == NULL) goto error; d = ((_PyNamespaceObject *)ns)->ns_dict; assert(d != NULL); Py_INCREF(d); keys = PyDict_Keys(d); if (keys == NULL) goto error; if (PyList_Sort(keys) != 0) goto error; keys_iter = PyObject_GetIter(keys); if (keys_iter == NULL) goto error; while ((key = PyIter_Next(keys_iter)) != NULL) { if (PyUnicode_Check(key) && PyUnicode_GET_SIZE(key) > 0) { PyObject *value, *item; value = PyDict_GetItem(d, key); assert(value != NULL); item = PyUnicode_FromFormat("%S=%R", key, value); if (item == NULL) { loop_error = 1; } else { loop_error = PyList_Append(pairs, item); Py_DECREF(item); } } Py_DECREF(key); if (loop_error) goto error; } separator = PyUnicode_FromString(", "); if (separator == NULL) goto error; pairsrepr = PyUnicode_Join(separator, pairs); Py_DECREF(separator); if (pairsrepr == NULL) goto error; repr = PyUnicode_FromFormat("%s(%S)", ((PyObject *)ns)->ob_type->tp_name, pairsrepr); Py_DECREF(pairsrepr); error: Py_XDECREF(pairs); Py_XDECREF(d); Py_XDECREF(keys); Py_XDECREF(keys_iter); Py_ReprLeave((PyObject *)ns); return repr; }
PyObject *Client_gets_multi(PyClient *self, PyObject *okeys) { //[ ] def gets_multi(self, keys): char *pKey; size_t cbKey; char *pData; size_t cbData; UINT64 cas; int flags; self->client->getBegin(); PyObject *iterator = PyObject_GetIter(okeys); if (iterator == NULL) { return NULL; } PyObject *arg; while ( (arg = PyIter_Next(iterator))) { PyObject *ostr; if (PyString_Check(arg)) { ostr = arg; } else { ostr = PyObject_Str(arg); } self->client->getKeyWrite(PyString_AS_STRING(ostr), PyString_GET_SIZE(ostr)); if (ostr != arg) { Py_DECREF(ostr); } Py_DECREF(arg); } Py_DECREF(iterator); self->client->getFlush(); PyObject *odict = PyDict_New(); bool bError = false; while (self->client->getReadNext(&pKey, &cbKey, &pData, &cbData, &flags, &cas, &bError)) { PyObject *okey = PyString_FromStringAndSize(pKey, cbKey); PyObject *otuple = PyTuple_New(3); PyObject *ovalue = PyString_FromStringAndSize(pData, cbData); PyObject *oflags = PyInt_FromLong(flags); PyObject *ocas = PyLong_FromUnsignedLongLong(cas); PyTuple_SET_ITEM(otuple, 0, ovalue); PyTuple_SET_ITEM(otuple, 1, oflags); PyTuple_SET_ITEM(otuple, 2, ocas); PyDict_SetItem (odict, okey, otuple); Py_DECREF(otuple); Py_DECREF(okey); } if (bError) { Py_DECREF(odict); if (!PyErr_Occurred()) { return PyErr_Format(PyExc_RuntimeError, "umemcache: %s", self->client->getError()); } return NULL; } return odict; }
static PyObject * snakeoil_iflatten_instance_iternext(snakeoil_iflatten_instance *self) { PyObject *tail, *result, *iter; int n, res; if (self->in_iternext) { /* We do not allow this because it means our list could be * manipulated while we are running. Exception raised matches * what a generator raises if you try the same thing. */ PyErr_SetString( PyExc_ValueError, "Recursive calls to iflatten_instance.next are illegal"); return NULL; } self->in_iternext = 1; /* Look at the final iterator on our stack: */ while (n = PyList_GET_SIZE(self->iterables)) { tail = PyList_GET_ITEM(self->iterables, n - 1); /* See if it has any results left: */ /* (This reference is borrowed from the list, but since we disallow recursive calls in here it should be safe to not increment it). */ result = PyIter_Next(tail); if (result) { /* See if we need to iterate over this new result: */ res = PyObject_IsInstance(result, self->skip_flattening); if (res == -1) { Py_DECREF(result); result = NULL; } else if (!res) { /* If it is an iterator add it to our chain, else return it. */ iter = PyObject_GetIter(result); if (!iter) { /* If we get here PyObject_GetIter raised an exception. * If it was TypeError we have a non-iterator we can * just return, else we propagate the error. */ if (PyErr_ExceptionMatches(PyExc_TypeError)) { PyErr_Clear(); } else { Py_DECREF(result); result = NULL; } } if (PyString_Check(result)) { /* Block infinite recursion of single char strings */ Py_ssize_t len = PyObject_Length(result); if (-1 == len) { Py_DECREF(result); Py_DECREF(iter); return NULL; } if (len <= 1) { Py_CLEAR(iter); } } if (iter) { /* Iterable, append to our stack and continue. * */ Py_DECREF(result); result = NULL; res = PyList_Append(self->iterables, iter); Py_DECREF(iter); if (res != -1) { continue; } /* Fall through and propagate the error. */ } } } else { /* PyIter_Next did not return an item. If this was not * because of an error we should pop the exhausted * iterable off and continue. */ if (!PyErr_Occurred() && PySequence_DelItem(self->iterables, n - 1) != -1) { continue; } } self->in_iternext = 0; return result; } /* We ran out of iterables entirely, so we are done */ self->in_iternext = 0; return NULL; }
static PyObject * snakeoil_iflatten_func_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { snakeoil_iflatten_func *self; PyObject *l=NULL, *skip_func=NULL, *tmp; int res; if (kwargs && PyDict_Size(kwargs)) { PyErr_SetString(PyExc_TypeError, "iflatten_func takes no keyword arguments"); return NULL; } if (!PyArg_UnpackTuple(args, "iflatten_func", 2, 2, &l, &skip_func)) { return NULL; } /* Check if we got a single argument that should be skipped. */ tmp = PyObject_CallFunctionObjArgs(skip_func, l, NULL); if (!tmp) { return NULL; } // Py_(True|False) are singletons, thus we're trying to bypass // the PyObject_IsTrue triggering __nonzero__ protocol. if (tmp == Py_True) { res = 1; } else if (tmp == Py_False) { res = 0; } else { res = PyObject_IsTrue(tmp); if (res == -1) { Py_DECREF(tmp); return NULL; } } Py_DECREF(tmp); if (res) { PyObject *tuple = PyTuple_Pack(1, l); if (!tuple) { return NULL; } PyObject *iter = PyObject_GetIter(tuple); Py_DECREF(tuple); return iter; } self = (snakeoil_iflatten_func *)type->tp_alloc(type, 0); if (!self) return NULL; self->in_iternext = 0; if (!(self->iterables = build_initial_iterables(l))) { Py_DECREF(self); return NULL; } Py_INCREF(skip_func); self->skip_func = skip_func; return (PyObject *)self; }
static PyObject* Cache_loadstore(Cache* self, PyObject *args, PyObject *kwds) { PyObject *addrs; unsigned int length = 1; int write_allocate = 1; static char *kwlist[] = {"addrs", "length", "write_allocate", NULL}; PyArg_ParseTupleAndKeywords(args, kwds, "O|Ii", kwlist, &addrs, &length, &write_allocate); // Get and check iterator PyObject *addrs_iter = PyObject_GetIter(addrs); if(addrs_iter == NULL) { PyErr_SetString(PyExc_ValueError, "addrs is not iteratable"); return NULL; } // Iterate of elements in addrs PyObject *loadstore_item, *load_addrs, *store_addrs, *addr, *load_iter, *store_iter; while((loadstore_item = PyIter_Next(addrs_iter))) { if(!PySequence_Check(loadstore_item)) { PyErr_SetString(PyExc_ValueError, "addrs element does not provide a sequence protocol"); return NULL; } // PySys_WriteStdout("LENGTH=%i\n", PySequence_Length(loadstore_item)); if(PySequence_Length(loadstore_item) != 2){ PyErr_SetString(PyExc_ValueError, "each addrs element needs exactly two elements"); return NULL; } load_addrs = PySequence_GetItem(loadstore_item, 0); store_addrs = PySequence_GetItem(loadstore_item, 1); // Unless None (otherwise ignore loads) if(load_addrs != Py_None) { if(!PySequence_Check(load_addrs)) { PyErr_SetString( PyExc_ValueError, "load element does not provide a sequence protocol"); return NULL; } // FIXME maybe this is better: Pass along to iterstore //Cache_iterstore(self, store_addrs, length) // Iterate of elements in load_addrs load_iter = PyObject_GetIter(load_addrs); if(load_iter == NULL) { PyErr_SetString(PyExc_ValueError, "load address is not iteratable"); return NULL; } while((addr = PyIter_Next(load_iter))) { // Each address is expanded to a certain length (default is 1) for(int i=0; i<length; i++) { #if PY_MAJOR_VERSION >= 3 Cache__load(self, PyLong_AsUnsignedLongMask(addr)+i); #else Cache__load(self, PyLong_AsUnsignedLongMask(addr)+i); #endif } Py_DECREF(addr); } } // Unless None (ortherwise ignore stores) if(store_addrs != Py_None) { if(!PySequence_Check(store_addrs)) { PyErr_SetString( PyExc_ValueError, "store element does not provide a sequence protocol"); return NULL; } // FIXME maybe this is better: Pass along to iterstore //Cache_iterload(self, load_addrs, length) // Iterate of elements in store_addrs store_iter = PyObject_GetIter(store_addrs); if(store_iter == NULL) { PyErr_SetString(PyExc_ValueError, "store address is not iteratable"); return NULL; } while((addr = PyIter_Next(store_iter))) { // Each address is expanded to a certain length (default is 1) for(int i=0; i<length; i++) { // Handle write-allocate if(write_allocate) { #if PY_MAJOR_VERSION >= 3 Cache__load(self, PyLong_AsUnsignedLongMask(addr)+i); #else Cache__load(self, PyLong_AsUnsignedLongMask(addr)+i); #endif } #if PY_MAJOR_VERSION >= 3 Cache__store(self, PyLong_AsUnsignedLongMask(addr)+i); #else Cache__store(self, PyLong_AsUnsignedLongMask(addr)+i); #endif } Py_DECREF(addr); } } Py_DECREF(load_addrs); Py_DECREF(store_addrs); Py_DECREF(loadstore_item); } Py_DECREF(addrs_iter); Py_RETURN_NONE; }
static PyObject *frputvect(PyObject *self, PyObject *args, PyObject *keywds) { FrFile *oFile; FrameH *frame; FrProcData *proc; FrAdcData *adc; FrSimData *sim; FrVect *vect; int verbose=0, nData, nBits, type, subType, arrayType; double dx, sampleRate, start; char blank[] = ""; char *filename=NULL, *history=NULL; char channel[MAX_STR_LEN], x_unit[MAX_STR_LEN], y_unit[MAX_STR_LEN], kind[MAX_STR_LEN]; PyObject *temp; char msg[MAX_STR_LEN]; PyObject *channellist, *channellist_iter, *framedict, *array; PyArrayIterObject *arrayIter; PyArray_Descr *temp_descr; static char *kwlist[] = {"filename", "channellist", "history", "verbose", NULL}; /*--------------- unpack arguments --------------------*/ verbose = 0; /* The | in the format string indicates the next arguments are optional. They are simply not assigned anything. */ if (!PyArg_ParseTupleAndKeywords(args, keywds, "sO|si", kwlist, &filename, &channellist, &history, &verbose)) { Py_RETURN_NONE; } FrLibSetLvl(verbose); if (history == NULL) { history = blank; } /*-------- create frames, create vectors, and fill them. ------*/ // Channel-list must be any type of sequence if (!PySequence_Check(channellist)) { PyErr_SetNone(PyExc_TypeError); return NULL; } // Get channel name from first dictionary framedict = PySequence_GetItem(channellist, (Py_ssize_t)0); if (framedict == NULL) { PyErr_SetString(PyExc_ValueError, "channellist is empty!"); return NULL; } PyDict_ExtractString(channel, framedict, "name"); Py_XDECREF(framedict); if (PyErr_Occurred()) {return NULL;} if (verbose > 0) { printf("Creating frame %s...\n", channel); } frame = FrameNew(channel); if (frame == NULL) { snprintf(msg, MAX_STR_LEN, "FrameNew failed (%s)", FrErrorGetHistory()); PyErr_SetString(PyExc_FrError, msg); return NULL; } if (verbose > 0) { printf("Now iterating...\n"); } // Iterators allow one to deal with non-contiguous arrays channellist_iter = PyObject_GetIter(channellist); arrayIter = NULL; while ((framedict = PyIter_Next(channellist_iter))) { if (verbose > 0) { printf("In loop...\n"); } // Extract quantities from dict -- all borrowed references PyDict_ExtractString(channel, framedict, "name"); CHECK_ERROR; start = PyDict_ExtractDouble(framedict, "start"); CHECK_ERROR; dx = PyDict_ExtractDouble(framedict, "dx"); CHECK_ERROR; array = PyDict_GetItemString(framedict, "data"); if (!PyArray_Check(array)) { snprintf(msg, MAX_STR_LEN, "data is not an array"); PyErr_SetString(PyExc_TypeError, msg); } CHECK_ERROR; nData = PyArray_SIZE(array); nBits = PyArray_ITEMSIZE(array)*8; arrayType = PyArray_TYPE(array); // kind, x_unit, y_unit, type, and subType have default values temp = PyDict_GetItemString(framedict, "kind"); if (temp != NULL) {strncpy(kind, PyString_AsString(temp), MAX_STR_LEN);} else {snprintf(kind, MAX_STR_LEN, "PROC");} temp = PyDict_GetItemString(framedict, "x_unit"); if (temp != NULL) {strncpy(x_unit, PyString_AsString(temp), MAX_STR_LEN);} else {strncpy(x_unit, blank, MAX_STR_LEN);} temp = PyDict_GetItemString(framedict, "y_unit"); if (temp != NULL) {strncpy(y_unit, PyString_AsString(temp), MAX_STR_LEN);} else {strncpy(y_unit, blank, MAX_STR_LEN);} temp = PyDict_GetItemString(framedict, "type"); if (temp != NULL) {type = (int)PyInt_AsLong(temp);} else {type = 1;} temp = PyDict_GetItemString(framedict, "subType"); if (temp != NULL) {subType = (int)PyInt_AsLong(temp);} else {subType = 0;} // check for errors CHECK_ERROR; if (dx <= 0 || array == NULL || nData==0) { temp = PyObject_Str(framedict); snprintf(msg, MAX_STR_LEN, "Input dictionary contents: %s", PyString_AsString(temp)); Py_XDECREF(temp); FrameFree(frame); Py_XDECREF(framedict); Py_XDECREF(channellist_iter); PyErr_SetString(PyExc_ValueError, msg); return NULL; } if (verbose > 0) { printf("type = %d, subType = %d, start = %f, dx = %f\n", type, subType, start, dx); } sampleRate = 1./dx; if (verbose > 0) { printf("Now copying data to vector...\n"); } // Create empty vector (-typecode ==> empty) with metadata, // then copy data to vector vect = NULL; arrayIter = (PyArrayIterObject *)PyArray_IterNew(array); if(arrayType == NPY_INT16) { vect = FrVectNew1D(channel,-FR_VECT_2S,nData,dx,x_unit,y_unit); while (arrayIter->index < arrayIter->size) { vect->dataS[arrayIter->index] = *((npy_int16 *)arrayIter->dataptr); PyArray_ITER_NEXT(arrayIter);}} else if(arrayType == NPY_INT32) { vect = FrVectNew1D(channel,-FR_VECT_4S,nData,dx,x_unit,y_unit); while (arrayIter->index < arrayIter->size) { vect->dataI[arrayIter->index] = *((npy_int32 *)arrayIter->dataptr); PyArray_ITER_NEXT(arrayIter);}} else if(arrayType == NPY_INT64) { vect = FrVectNew1D(channel,-FR_VECT_8S,nData,dx,x_unit,y_unit); while (arrayIter->index < arrayIter->size) { vect->dataL[arrayIter->index] = *((npy_int64 *)arrayIter->dataptr); PyArray_ITER_NEXT(arrayIter);}} else if(arrayType == NPY_UINT8) { vect = FrVectNew1D(channel,-FR_VECT_1U,nData,dx,x_unit,y_unit); while (arrayIter->index < arrayIter->size) { vect->dataU[arrayIter->index] = *((npy_uint8 *)arrayIter->dataptr); PyArray_ITER_NEXT(arrayIter);}} else if(arrayType == NPY_UINT16) { vect = FrVectNew1D(channel,-FR_VECT_2U,nData,dx,x_unit,y_unit); while (arrayIter->index < arrayIter->size) { vect->dataUS[arrayIter->index] = *((npy_uint16 *)arrayIter->dataptr); PyArray_ITER_NEXT(arrayIter);}} else if(arrayType == NPY_UINT32) { vect = FrVectNew1D(channel,-FR_VECT_4U,nData,dx,x_unit,y_unit); while (arrayIter->index < arrayIter->size) { vect->dataUI[arrayIter->index] = *((npy_uint32 *)arrayIter->dataptr); PyArray_ITER_NEXT(arrayIter);}} else if(arrayType == NPY_UINT64) { vect = FrVectNew1D(channel,-FR_VECT_8U,nData,dx,x_unit,y_unit); while (arrayIter->index < arrayIter->size) { vect->dataUL[arrayIter->index] = *((npy_uint64 *)arrayIter->dataptr); PyArray_ITER_NEXT(arrayIter);}} else if(arrayType == NPY_FLOAT32) { vect = FrVectNew1D(channel,-FR_VECT_4R,nData,dx,x_unit,y_unit); while (arrayIter->index < arrayIter->size) { vect->dataF[arrayIter->index] = *((npy_float32 *)arrayIter->dataptr); PyArray_ITER_NEXT(arrayIter);}} else if(arrayType == NPY_FLOAT64) { vect = FrVectNew1D(channel,-FR_VECT_8R,nData,dx,x_unit,y_unit); while (arrayIter->index < arrayIter->size) { vect->dataD[arrayIter->index] = *((npy_float64 *)arrayIter->dataptr); PyArray_ITER_NEXT(arrayIter);}} /* FrVects don't have complex pointers. Numpy stores complex numbers in the same way, but we have to trick it into giving us a (real) float pointer. */ else if(arrayType == NPY_COMPLEX64) { vect = FrVectNew1D(channel,-FR_VECT_8C,nData,dx,x_unit,y_unit); temp_descr = PyArray_DescrFromType(NPY_FLOAT32); temp = PyArray_View((PyArrayObject *)array, temp_descr, NULL); Py_XDECREF(temp_descr); Py_XDECREF(arrayIter); arrayIter = (PyArrayIterObject *)PyArray_IterNew(temp); while (arrayIter->index < arrayIter->size) { vect->dataF[arrayIter->index] = *((npy_float32 *)arrayIter->dataptr); PyArray_ITER_NEXT(arrayIter);} Py_XDECREF(temp);} else if(arrayType == NPY_COMPLEX128) { vect = FrVectNew1D(channel,-FR_VECT_16C,nData,dx,x_unit,y_unit); temp_descr = PyArray_DescrFromType(NPY_FLOAT64); temp = PyArray_View((PyArrayObject *)array, temp_descr, NULL); Py_XDECREF(temp_descr); Py_XDECREF(arrayIter); arrayIter = (PyArrayIterObject *)PyArray_IterNew(temp); while (arrayIter->index < arrayIter->size) { vect->dataD[arrayIter->index] = *((npy_float64 *)arrayIter->dataptr); PyArray_ITER_NEXT(arrayIter);} Py_XDECREF(temp);} else PyErr_SetString(PyExc_TypeError, msg); if (PyErr_Occurred()) { if (vect != NULL) FrVectFree(vect); FrameFree(frame); Py_XDECREF(framedict); Py_XDECREF(channellist_iter); Py_XDECREF(arrayIter); return NULL; } if (verbose > 0) { printf("Done copying...\n"); FrameDump(frame, stdout, 6); } // Add Fr*Data to frame and attach vector to Fr*Data if (strncmp(kind, "PROC", MAX_STR_LEN)==0) { proc = FrProcDataNew(frame, channel, sampleRate, 1, nBits); FrVectFree(proc->data); proc->data = vect; proc->type = type; proc->subType = subType; frame->GTimeS = (npy_uint32)start; frame->GTimeN = (npy_uint32)((start-(frame->GTimeS))*1e9); if (type==1) { // time series proc->tRange = nData*dx; frame->dt = nData*dx; } else if (type==2) { // frequency series proc->fRange = nData*dx; } } else if (strncmp(kind, "ADC", MAX_STR_LEN)==0) { adc = FrAdcDataNew(frame, channel, sampleRate, 1, nBits); FrVectFree(adc->data); adc->data = vect; frame->dt = nData*dx; frame->GTimeS = (npy_uint32)start; frame->GTimeN = (npy_uint32)((start-(frame->GTimeS))*1e9); } else {// Already tested that kind is one of these strings above sim = FrSimDataNew(frame, channel, sampleRate, 1, nBits); FrVectFree(sim->data); sim->data = vect; frame->dt = nData*dx; frame->GTimeS = (npy_uint32)start; frame->GTimeN = (npy_uint32)((start-(frame->GTimeS))*1e9); } if (verbose > 0) { printf("Attached vect to frame.\n"); } // Clean up (all python objects in loop should be borrowed references) Py_XDECREF(framedict); Py_XDECREF(arrayIter); } // end iteration over channellist Py_XDECREF(channellist_iter); // At this point, there should be no Python references left! /*------------- Write file -----------------------------*/ oFile = FrFileONewH(filename, 1, history); // 1 ==> gzip contents if (oFile == NULL) { snprintf(msg, MAX_STR_LEN, "%s\n", FrErrorGetHistory()); PyErr_SetString(PyExc_FrError, msg); FrFileOEnd(oFile); return NULL; } if (FrameWrite(frame, oFile) != FR_OK) { snprintf(msg, MAX_STR_LEN, "%s\n", FrErrorGetHistory()); PyErr_SetString(PyExc_FrError, msg); FrFileOEnd(oFile); return NULL; } /* The FrFile owns data and vector memory. Do not free them separately. */ FrFileOEnd(oFile); FrameFree(frame); Py_RETURN_NONE; };
static int convertTo_QJsonArray(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj) { QJsonArray **sipCppPtr = reinterpret_cast<QJsonArray **>(sipCppPtrV); #line 59 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtCore/qjsonarray.sip" PyObject *iter = PyObject_GetIter(sipPy); if (!sipIsErr) { Py_XDECREF(iter); return (iter #if PY_MAJOR_VERSION < 3 && !PyString_Check(sipPy) #endif && !PyUnicode_Check(sipPy)); } if (!iter) { *sipIsErr = 1; return 0; } QJsonArray *ql = new QJsonArray; for (SIP_SSIZE_T i = 0; ; ++i) { PyErr_Clear(); PyObject *itm = PyIter_Next(iter); if (!itm) { if (PyErr_Occurred()) { delete ql; Py_DECREF(iter); *sipIsErr = 1; return 0; } break; } int state; QJsonValue *t = reinterpret_cast<QJsonValue *>( sipForceConvertToType(itm, sipType_QJsonValue, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QJsonValue' is expected", i, Py_TYPE(itm)->tp_name); Py_DECREF(itm); delete ql; Py_DECREF(iter); return 0; } ql->append(*t); sipReleaseType(t, sipType_QJsonValue, state); Py_DECREF(itm); } Py_DECREF(iter); *sipCppPtr = ql; return sipGetState(sipTransferObj); #line 139 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtCore/sipQtCoreQJsonArray.cpp" }
static PyObject * KyotoDB_update(KyotoDB *self, PyObject *args, PyObject *kwds) { Py_ssize_t size = PyTuple_Size(args); if (size > 1) { APR str(PyString_FromFormat("update expected at most 1 arguments, got %zd", size)); PyErr_SetObject(PyExc_TypeError, str.get()); return NULL; } if (size == 1) { APR obj(PyTuple_GetItem(args, 0)); if (PyMapping_Check(obj.get())) { if (!KyotoDB_update_with_mapping(self, obj.get())) return NULL; } else { APR iterator (PyObject_GetIter(obj.get())); APR item; if (iterator == NULL) { PyErr_SetString(PyExc_RuntimeError, "object is not iterable"); return NULL; } Py_ssize_t i = 0; while ((item = PyIter_Next(iterator.get())) != NULL) { if (!PySequence_Check(item.get())) { APR str(PyString_FromFormat("cannot convert dictionary update sequence element #%zd to a sequence", i)); PyErr_SetObject(PyExc_TypeError, str.get()); return NULL; } if (PySequence_Size(item.get()) != 2) { APR str(PyString_FromFormat("dictionary update sequence element #%zd has length %zd; 2 is required", i, PySequence_Size(item.get()))); PyErr_SetObject(PyExc_TypeError, str.get()); return NULL; } APR key(PySequence_GetItem(item.get(), 0)); APR value(PySequence_GetItem(item.get(), 1)); bool ok; std::string ckey = KyotoDB_dump(key, self->use_pickle, &ok); if (!ok) return NULL; std::string cvalue = KyotoDB_dump(value, self->use_pickle, &ok); if (!ok) return NULL; self->m_db->set(ckey, cvalue); i++; } } } if (kwds) { if (!KyotoDB_update_with_mapping(self, kwds)) return NULL; } Py_RETURN_NONE; }
static PyObject* _cbson_insert_message(PyObject* self, PyObject* args) { /* NOTE just using a random number as the request_id */ struct module_state *state = GETSTATE(self); int request_id = rand(); char* collection_name = NULL; int collection_name_length; PyObject* docs; PyObject* doc; PyObject* iterator; int before, cur_size, max_size = 0; int options = 0; unsigned char check_keys; unsigned char safe; unsigned char continue_on_error; unsigned char uuid_subtype; PyObject* last_error_args; buffer_t buffer; int length_location, message_length; PyObject* result; if (!PyArg_ParseTuple(args, "et#ObbObb", "utf-8", &collection_name, &collection_name_length, &docs, &check_keys, &safe, &last_error_args, &continue_on_error, &uuid_subtype)) { return NULL; } if (continue_on_error) { options += 1; } buffer = buffer_new(); if (!buffer) { PyErr_NoMemory(); PyMem_Free(collection_name); return NULL; } // save space for message length length_location = buffer_save_space(buffer, 4); if (length_location == -1) { PyMem_Free(collection_name); PyErr_NoMemory(); return NULL; } if (!buffer_write_bytes(buffer, (const char*)&request_id, 4) || !buffer_write_bytes(buffer, "\x00\x00\x00\x00" "\xd2\x07\x00\x00", 8) || !buffer_write_bytes(buffer, (const char*)&options, 4) || !buffer_write_bytes(buffer, collection_name, collection_name_length + 1)) { PyMem_Free(collection_name); buffer_free(buffer); return NULL; } iterator = PyObject_GetIter(docs); if (iterator == NULL) { PyObject* InvalidOperation = _error("InvalidOperation"); PyErr_SetString(InvalidOperation, "input is not iterable"); Py_DECREF(InvalidOperation); buffer_free(buffer); PyMem_Free(collection_name); return NULL; } while ((doc = PyIter_Next(iterator)) != NULL) { before = buffer_get_position(buffer); if (!write_dict(state->_cbson, buffer, doc, check_keys, uuid_subtype, 1)) { Py_DECREF(doc); Py_DECREF(iterator); buffer_free(buffer); PyMem_Free(collection_name); return NULL; } Py_DECREF(doc); cur_size = buffer_get_position(buffer) - before; max_size = (cur_size > max_size) ? cur_size : max_size; } Py_DECREF(iterator); if (PyErr_Occurred()) { buffer_free(buffer); PyMem_Free(collection_name); return NULL; } if (!max_size) { PyObject* InvalidOperation = _error("InvalidOperation"); PyErr_SetString(InvalidOperation, "cannot do an empty bulk insert"); Py_DECREF(InvalidOperation); buffer_free(buffer); PyMem_Free(collection_name); return NULL; } message_length = buffer_get_position(buffer) - length_location; memcpy(buffer_get_buffer(buffer) + length_location, &message_length, 4); if (safe) { if (!add_last_error(self, buffer, request_id, collection_name, collection_name_length, last_error_args)) { buffer_free(buffer); PyMem_Free(collection_name); return NULL; } } PyMem_Free(collection_name); /* objectify buffer */ result = Py_BuildValue("i" BYTES_FORMAT_STRING "i", request_id, buffer_get_buffer(buffer), buffer_get_position(buffer), max_size); buffer_free(buffer); return result; }
static uint32_t pointless_export_py_rec(pointless_export_state_t* state, PyObject* py_object, uint32_t depth) { // don't go too deep if (depth >= POINTLESS_MAX_DEPTH) { PyErr_SetString(PyExc_ValueError, "structure is too deep"); state->is_error = 1; printf("line: %i\n", __LINE__); state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } // check simple types first uint32_t handle = POINTLESS_CREATE_VALUE_FAIL; // return an error on failure #define RETURN_OOM(state) {PyErr_NoMemory(); (state)->is_error = 1; printf("line: %i\n", __LINE__); state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL;} #define RETURN_OOM_IF_FAIL(handle, state) if ((handle) == POINTLESS_CREATE_VALUE_FAIL) RETURN_OOM(state); // booleans, need this above integer check, cause PyInt_Check return 1 for booleans if (PyBool_Check(py_object)) { if (py_object == Py_True) handle = pointless_create_boolean_true(&state->c); else handle = pointless_create_boolean_false(&state->c); RETURN_OOM_IF_FAIL(handle, state); // integer } else if (PyInt_Check(py_object)) { long v = PyInt_AS_LONG(py_object); // unsigned if (v >= 0) { if (v > UINT32_MAX) { PyErr_Format(PyExc_ValueError, "integer too large for mere 32 bits"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_u32(&state->c, (uint32_t)v); // signed } else { if (!(INT32_MIN <= v && v <= INT32_MAX)) { PyErr_Format(PyExc_ValueError, "integer too large for mere 32 bits with a sign"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_i32(&state->c, (int32_t)v); } RETURN_OOM_IF_FAIL(handle, state); // long } else if (PyLong_Check(py_object)) { // this will raise an overflow error if number is outside the legal range of PY_LONG_LONG PY_LONG_LONG v = PyLong_AsLongLong(py_object); // if there was an exception, clear it, and set our own if (PyErr_Occurred()) { PyErr_Clear(); PyErr_SetString(PyExc_ValueError, "value of long is way beyond what we can store right now"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } // unsigned if (v >= 0) { if (v > UINT32_MAX) { PyErr_Format(PyExc_ValueError, "long too large for mere 32 bits"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_u32(&state->c, (uint32_t)v); // signed } else { if (!(INT32_MIN <= v && v <= INT32_MAX)) { PyErr_Format(PyExc_ValueError, "long too large for mere 32 bits with a sign"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_i32(&state->c, (int32_t)v); } RETURN_OOM_IF_FAIL(handle, state); // None object } else if (py_object == Py_None) { handle = pointless_create_null(&state->c); RETURN_OOM_IF_FAIL(handle, state); } else if (PyFloat_Check(py_object)) { handle = pointless_create_float(&state->c, (float)PyFloat_AS_DOUBLE(py_object)); RETURN_OOM_IF_FAIL(handle, state); } if (handle != POINTLESS_CREATE_VALUE_FAIL) return handle; // remaining types are containers/big-values, which we track // either for space-savings or maintaining circular references // if object has been seen before, return its handle handle = pointless_export_get_seen(state, py_object); if (handle != POINTLESS_CREATE_VALUE_FAIL) return handle; // list/tuple object if (PyList_Check(py_object) || PyTuple_Check(py_object)) { // create and cache handle assert(is_container(py_object)); handle = pointless_create_vector_value(&state->c); RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // populate vector Py_ssize_t i, n_items = PyList_Check(py_object) ? PyList_GET_SIZE(py_object) : PyTuple_GET_SIZE(py_object); for (i = 0; i < n_items; i++) { PyObject* child = PyList_Check(py_object) ? PyList_GET_ITEM(py_object, i) : PyTuple_GET_ITEM(py_object, i); uint32_t child_handle = pointless_export_py_rec(state, child, depth + 1); if (child_handle == POINTLESS_CREATE_VALUE_FAIL) return child_handle; if (pointless_create_vector_value_append(&state->c, handle, child_handle) == POINTLESS_CREATE_VALUE_FAIL) { RETURN_OOM(state); } } // pointless value vectors } else if (PyPointlessVector_Check(py_object)) { // currently, we only support value vectors, they are simple PyPointlessVector* v = (PyPointlessVector*)py_object; const char* error = 0; switch(v->v->type) { case POINTLESS_VECTOR_VALUE: case POINTLESS_VECTOR_VALUE_HASHABLE: handle = pointless_recreate_value(&v->pp->p, v->v, &state->c, &error); if (handle == POINTLESS_CREATE_VALUE_FAIL) { printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; PyErr_Format(PyExc_ValueError, "pointless_recreate_value(): %s", error); return POINTLESS_CREATE_VALUE_FAIL; } break; case POINTLESS_VECTOR_I8: handle = pointless_create_vector_i8_owner(&state->c, pointless_reader_vector_i8(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_U8: handle = pointless_create_vector_u8_owner(&state->c, pointless_reader_vector_u8(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_I16: handle = pointless_create_vector_i16_owner(&state->c, pointless_reader_vector_i16(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_U16: handle = pointless_create_vector_u16_owner(&state->c, pointless_reader_vector_u16(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_I32: handle = pointless_create_vector_i32_owner(&state->c, pointless_reader_vector_i32(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_U32: handle = pointless_create_vector_u32_owner(&state->c, pointless_reader_vector_u32(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_I64: handle = pointless_create_vector_i64_owner(&state->c, pointless_reader_vector_i64(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_U64: handle = pointless_create_vector_u64_owner(&state->c, pointless_reader_vector_u64(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_FLOAT: handle = pointless_create_vector_float_owner(&state->c, pointless_reader_vector_float(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_EMPTY: handle = pointless_create_vector_value(&state->c); break; default: state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; PyErr_SetString(PyExc_ValueError, "internal error: illegal type for primitive vector"); return POINTLESS_CREATE_VALUE_FAIL; } RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // python bytearray } else if (PyByteArray_Check(py_object)) { // create handle and hand over the memory Py_ssize_t n_items = PyByteArray_GET_SIZE(py_object); if (n_items > UINT32_MAX) { PyErr_SetString(PyExc_ValueError, "bytearray has too many items"); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_vector_u8_owner(&state->c, (uint8_t*)PyByteArray_AS_STRING(py_object), (uint32_t)n_items); RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // primitive vectors } else if (PyPointlessPrimVector_Check(py_object)) { // we just hand over the memory PyPointlessPrimVector* prim_vector = (PyPointlessPrimVector*)py_object; uint32_t n_items = pointless_dynarray_n_items(&prim_vector->array); void* data = prim_vector->array._data; switch (prim_vector->type) { case POINTLESS_PRIM_VECTOR_TYPE_I8: handle = pointless_create_vector_i8_owner(&state->c, (int8_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_U8: handle = pointless_create_vector_u8_owner(&state->c, (uint8_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_I16: handle = pointless_create_vector_i16_owner(&state->c, (int16_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_U16: handle = pointless_create_vector_u16_owner(&state->c, (uint16_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_I32: handle = pointless_create_vector_i32_owner(&state->c, (int32_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_U32: handle = pointless_create_vector_u32_owner(&state->c, (uint32_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_I64: handle = pointless_create_vector_i64_owner(&state->c, (int64_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_U64: handle = pointless_create_vector_u64_owner(&state->c, (uint64_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_FLOAT: handle = pointless_create_vector_float_owner(&state->c, (float*)data, n_items); break; default: PyErr_SetString(PyExc_ValueError, "internal error: illegal type for primitive vector"); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; return POINTLESS_CREATE_VALUE_FAIL; } RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // unicode object } else if (PyUnicode_Check(py_object)) { // get it from python Py_UNICODE* python_buffer = PyUnicode_AS_UNICODE(py_object); // string must not contain zero's Py_ssize_t s_len_python = PyUnicode_GET_SIZE(py_object); #if Py_UNICODE_SIZE == 4 uint32_t s_len_pointless = pointless_ucs4_len(python_buffer); #else uint32_t s_len_pointless = pointless_ucs2_len(python_buffer); #endif if (s_len_python < 0 || (uint64_t)s_len_python != s_len_pointless) { PyErr_SetString(PyExc_ValueError, "unicode string contains a zero, where it shouldn't"); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; return POINTLESS_CREATE_VALUE_FAIL; } #if Py_UNICODE_SIZE == 4 if (state->unwiden_strings && pointless_is_ucs4_ascii((uint32_t*)python_buffer)) handle = pointless_create_string_ucs4(&state->c, python_buffer); else handle = pointless_create_unicode_ucs4(&state->c, python_buffer); #else if (state->unwiden_strings && pointless_is_ucs2_ascii(python_buffer)) handle = pointless_create_string_ucs2(&state->c, python_buffer); else handle = pointless_create_unicode_ucs2(&state->c, python_buffer); #endif RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // string object } else if (PyString_Check(py_object)) { // get it from python uint8_t* python_buffer = (uint8_t*)PyString_AS_STRING(py_object); // string must not contain zero's Py_ssize_t s_len_python = PyString_GET_SIZE(py_object); uint32_t s_len_pointless = pointless_ascii_len(python_buffer); if (s_len_python < 0 || (uint64_t)s_len_python != s_len_pointless) { PyErr_SetString(PyExc_ValueError, "string contains a zero, where it shouldn't"); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_string_ascii(&state->c, python_buffer); RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // dict object } else if (PyDict_Check(py_object)) { handle = pointless_create_map(&state->c); RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } PyObject* key = 0; PyObject* value = 0; Py_ssize_t pos = 0; while (PyDict_Next(py_object, &pos, &key, &value)) { uint32_t key_handle = pointless_export_py_rec(state, key, depth + 1); uint32_t value_handle = pointless_export_py_rec(state, value, depth + 1); if (key_handle == POINTLESS_CREATE_VALUE_FAIL || value_handle == POINTLESS_CREATE_VALUE_FAIL) break; if (pointless_create_map_add(&state->c, handle, key_handle, value_handle) == POINTLESS_CREATE_VALUE_FAIL) { PyErr_SetString(PyExc_ValueError, "error adding key/value pair to map"); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; break; } } if (state->is_error) { return POINTLESS_CREATE_VALUE_FAIL; } // set object } else if (PyAnySet_Check(py_object)) { PyObject* iterator = PyObject_GetIter(py_object); PyObject* item = 0; if (iterator == 0) { printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } // get a handle handle = pointless_create_set(&state->c); RETURN_OOM_IF_FAIL(handle, state); // cache object if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // iterate over it while ((item = PyIter_Next(iterator)) != 0) { uint32_t item_handle = pointless_export_py_rec(state, item, depth + 1); if (item_handle == POINTLESS_CREATE_VALUE_FAIL) break; if (pointless_create_set_add(&state->c, handle, item_handle) == POINTLESS_CREATE_VALUE_FAIL) { PyErr_SetString(PyExc_ValueError, "error adding item to set"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; break; } } Py_DECREF(iterator); if (PyErr_Occurred()) { printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } // bitvector } else if (PyPointlessBitvector_Check(py_object)) { PyPointlessBitvector* bitvector = (PyPointlessBitvector*)py_object; if (bitvector->is_pointless) { uint32_t i, n_bits = pointless_reader_bitvector_n_bits(&bitvector->pointless_pp->p, bitvector->pointless_v); void* bits = pointless_calloc(ICEIL(n_bits, 8), 1); if (bits == 0) { RETURN_OOM(state); } for (i = 0; i < n_bits; i++) { if (pointless_reader_bitvector_is_set(&bitvector->pointless_pp->p, bitvector->pointless_v, i)) bm_set_(bits, i); } if (state->normalize_bitvector) handle = pointless_create_bitvector(&state->c, bits, n_bits); else handle = pointless_create_bitvector_no_normalize(&state->c, bits, n_bits); pointless_free(bits); bits = 0; } else { if (state->normalize_bitvector) handle = pointless_create_bitvector(&state->c, bitvector->primitive_bits, bitvector->primitive_n_bits); else handle = pointless_create_bitvector_no_normalize(&state->c, bitvector->primitive_bits, bitvector->primitive_n_bits); } RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } } else if (PyPointlessSet_Check(py_object)) { PyPointlessSet* set = (PyPointlessSet*)py_object; const char* error = 0; handle = pointless_recreate_value(&set->pp->p, set->v, &state->c, &error); if (handle == POINTLESS_CREATE_VALUE_FAIL) { printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; PyErr_Format(PyExc_ValueError, "pointless_recreate_value(): %s", error); return POINTLESS_CREATE_VALUE_FAIL; } if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } } else if (PyPointlessMap_Check(py_object)) { PyPointlessMap* map = (PyPointlessMap*)py_object; const char* error = 0; handle = pointless_recreate_value(&map->pp->p, map->v, &state->c, &error); if (handle == POINTLESS_CREATE_VALUE_FAIL) { printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; PyErr_Format(PyExc_ValueError, "pointless_recreate_value(): %s", error); return POINTLESS_CREATE_VALUE_FAIL; } if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // type not supported } else { PyErr_Format(PyExc_ValueError, "type <%s> not supported", py_object->ob_type->tp_name); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; } #undef RETURN_OOM #undef RETURN_IF_OOM return handle; }
static PyObject *m_build_unpack_pair(PyObject *mod, PyObject *seqs) { // checked Py_ssize_t count = seqs? PyTuple_GET_SIZE(seqs): 0; Py_ssize_t index = 0; PyObject *tmp; if (! count) { Py_INCREF(SibNil); return SibNil; } PyObject *coll = PyList_New(0); while (index < count) { PyObject *item = PyTuple_GET_ITEM(seqs, index++); PyObject *work; if (SibNil_Check(item)) { // skip nil continue; } else if (SibPair_CheckExact(item)) { work = pair_unpack(item, NULL); } else { // todo: check for lists and tuples explicitly, and see if // they're zero-length. If so, avoid creating an iterator, just // continue to the next item. work = PyObject_GetIter(item); } if (! work) { Py_DECREF(coll); return NULL; } // why the everloving f**k isn't this a regular call? tmp will be // NULL for exception, or a new PyNone reference if successful. tmp = _PyList_Extend((PyListObject *) coll, work); Py_CLEAR(work); if (! tmp) { Py_DECREF(coll); return NULL; } else { Py_CLEAR(tmp); } } if (! PyList_GET_SIZE(coll)) { // The collection didn't net any actual elements, so let's skip // out early and just return nil Py_DECREF(coll); Py_INCREF(SibNil); return SibNil; } // I wonder if there isn't a better way to do this. We end up // traversing the last cons pair twice, which means allocating a set // in order to avoid recursion. Is that too expensive? tmp = PyTuple_GET_ITEM(seqs, count - 1); if (SibPair_IsProper(tmp)) { if(PyList_Append(coll, SibNil)) { Py_DECREF(coll); return NULL; } } PyObject *result = SibPair_Cons(coll, 0); Py_DECREF(coll); return result; }