/* * python bulkload class method */ static PyObject * python_sorted_btree_bulkload(PyObject *klass, PyObject *args) { int i, result; PyObject *item_list, *order, *iter, *item, *prev = NULL; if (!PyArg_ParseTuple(args, "OO!", &item_list, &PyInt_Type, &order)) return NULL; if ((iter = PyObject_GetIter(item_list)) == NULL) return NULL; for (i = 0, item = PyIter_Next(iter); item; ++i, item = PyIter_Next(iter)) { if (i) { result = PyObject_RichCompareBool(prev, item, Py_LT); if (result <= 0) { if (!result) PyErr_SetString(PyExc_ValueError, "the bulkloaded list must already be sorted"); Py_DECREF(prev); Py_DECREF(item); Py_DECREF(iter); return NULL; } Py_DECREF(prev); } prev = item; } if (prev) Py_DECREF(prev); Py_DECREF(iter); if ((iter = PyObject_GetIter(item_list)) == NULL) return NULL; btsort_pyobject *tree = PyObject_GC_New( btsort_pyobject, &btsort_pytypeobj); if (bulkload(tree, iter, (int)PyInt_AsLong(order))) return NULL; return (PyObject *)tree; }
types::set<T> from_python<types::set<T>>::convert(PyObject *obj) { types::set<T> v = types::empty_set(); // may be useful to reserve more space ? PyObject *iterator = PyObject_GetIter(obj); while (PyObject *item = PyIter_Next(iterator)) { v.add(::from_python<T>(item)); Py_DECREF(item); } Py_DECREF(iterator); return v; }
static PyObject * udn_resolve_from_search_list(PyObject *self, PyObject *args, PyObject *keywds) { PyObject *name_space = NULL; PyObject *return_value = NULL; PyObject *iterator = NULL; PyObject *search_list = NULL; PyObject *name; PyObject *default_value = NULL; static char *kwlist[] = {"search_list", "name", "default", NULL}; if (!PyArg_ParseTupleAndKeywords(args, keywds, "OO|O", kwlist, &search_list, &name, &default_value)) { return NULL; } if (!(PyUnicode_Check(name) || PyString_Check(name))) { PyErr_SetString(PyExc_ValueError, "name must be string"); return NULL; } iterator = PyObject_GetIter(search_list); if (iterator == NULL) { return_value = NULL; /* PyErr_SetString(PyExc_TypeError, "search_list is not iterable"); */ goto done; } while ((name_space = PyIter_Next(iterator))) { return_value = _resolve_udn(name_space, name); Py_DECREF(name_space); if (return_value != NULL) { goto done; } } done: if (return_value == NULL) { if (default_value != NULL) { return_value = default_value; Py_INCREF(return_value); } else { return_value = UnresolvedPlaceholder; Py_INCREF(return_value); } } Py_XDECREF(iterator); /* change the return value to be a bit more compatible with the way things work in the python code. */ return return_value; }
static int __Pyx_EndUnpack(PyObject *iter) { PyObject *item; if ((item = PyIter_Next(iter))) { Py_DECREF(item); __Pyx_UnpackError(); return -1; } else if (!PyErr_Occurred()) return 0; else return -1; }
static PyObject * iobase_readlines(PyObject *self, PyObject *args) { Py_ssize_t hint = -1, length = 0; PyObject *result; if (!PyArg_ParseTuple(args, "|O&:readlines", &_PyIO_ConvertSsize_t, &hint)) { return NULL; } result = PyList_New(0); if (result == NULL) return NULL; if (hint <= 0) { /* XXX special-casing this made sense in the Python version in order to remove the bytecode interpretation overhead, but it could probably be removed here. */ _Py_IDENTIFIER(extend); PyObject *ret = _PyObject_CallMethodId(result, &PyId_extend, "O", self); if (ret == NULL) { Py_DECREF(result); return NULL; } Py_DECREF(ret); return result; } while (1) { PyObject *line = PyIter_Next(self); if (line == NULL) { if (PyErr_Occurred()) { Py_DECREF(result); return NULL; } else break; /* StopIteration raised */ } if (PyList_Append(result, line) < 0) { Py_DECREF(line); Py_DECREF(result); return NULL; } length += PyObject_Size(line); Py_DECREF(line); if (length > hint) break; } return result; }
static PyObject *IOManager_submit(IOManager *self, PyObject *args) { PyObject *req_s, *iter; IORequest *item; Py_ssize_t l; int rc; struct iocb **cb, **cb_l; if (!PyArg_ParseTuple(args, "O", &req_s)) return NULL; if ((l = PySequence_Size(req_s)) < 0) return NULL; if (l > (self->nr_events - self->pending_events)) { PyErr_SetString(PyExc_ValueError, "Queue length exceeded."); return NULL; } cb = self->cbs; cb_l = cb + (self->nr_events - self->pending_events); if (!(iter = PyObject_GetIter(req_s))) return NULL; for (; (item = (IORequest*) PyIter_Next(iter)); cb++) { if (!PyObject_IsInstance((PyObject*) item, (PyObject*) &IORequestType)) { Py_DECREF(item); PyErr_SetString(PyExc_TypeError, "Elements of argument 0 must be of type IORequest."); return IOM_iocb_cleanup(self, cb+1); } if (cb == cb_l) { Py_DECREF(item); PyErr_SetString(PyExc_ValueError, "Queue length exceeded (secondary check)"); return IOM_iocb_cleanup(self, cb+1); } if (item->submitted) { Py_DECREF(item); PyErr_SetString(PyExc_ValueError, "Element of argument 0 had already been submitted earlier."); return IOM_iocb_cleanup(self, cb+1); } item->submitted = 1; item->iocb.u.c.resfd = self->fd; *cb = &item->iocb; } if (PyErr_Occurred()) return IOM_iocb_cleanup(self, cb); l = cb - self->cbs; rc = io_submit(self->ctx, l, self->cbs); if (rc < 0) { errno = -rc; PyErr_SetFromErrno(PyExc_OSError); return IOM_iocb_cleanup(self, cb); } /* Keep one reference to each element read from the iterable, to make sure they aren't deallocated while we wait for their IO requests to complete */ self->pending_events += l; Py_RETURN_NONE; }
static PyObject* cstuff_DirectionMap_set_walls(cstuff_DirectionMap* self, PyObject *args) { PyObject *list1, *list2, *iterator1, *iterator2, *value; int whichwall; int row, col, stride; if (!PyArg_ParseTuple(args, "Oi", &list1, &whichwall)) { return NULL; } row = 0; if (!(iterator1 = PyObject_GetIter(list1))) { return NULL; } while ((list2 = PyIter_Next(iterator1)) && row < g_rows) { stride = row * g_cols; if (!(iterator2 = PyObject_GetIter(list2))) { Py_DECREF(list2); break; } col = 0; while ((value = PyIter_Next(iterator2)) && col < g_cols) { if (PyLong_CheckExact(value) && PyLong_AsLong(value) == whichwall) { self->walls->values[stride+col] = 1; } Py_DECREF(value); col += 1; } Py_DECREF(iterator2); Py_DECREF(list2); row += 1; } Py_DECREF(iterator1); if (PyErr_Occurred()) { return NULL; } Py_RETURN_NONE; }
DyND_PyWrapperIter<T> begin(PyObject *obj) { PyObject *iter = PyObject_GetIter(obj); if (iter == NULL) { std::cout << "not an iterator" << std::endl; } DyND_PyWrapperIter<T> it; it.iter = iter; it.item = PyIter_Next(it.iter); return it; }
/* Run an iterator to exhaustion. Shortcut for the extend/extendleft methods when maxlen == 0. */ static PyObject* consume_iterator(PyObject *it) { PyObject *item; while ((item = PyIter_Next(it)) != NULL) { Py_DECREF(item); } Py_DECREF(it); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; }
int _py_itermapping_cb(pgctx_t *ctx, int i, dbtype_t *key, dbtype_t *value, void *user) { PyObject *iter = (PyObject*)user; PyObject *item = PyIter_Next(iter); PyObject *k = PySequence_GetItem(item, 0); PyObject *v = PySequence_GetItem(item, 1); *key = from_python(ctx, k); *value = from_python(ctx, v); Py_DECREF(k); Py_DECREF(v); Py_DECREF(item); if (PyErr_Occurred()) return -1; return 0; }
static PyObject * LDAPEntry_delete(LDAPEntry *self, PyObject *args, PyObject *kwds) { char *dnstr; PyObject *keys = PyMapping_Keys((PyObject *)self); PyObject *iter, *key; PyObject *tmp; LDAPValueList *value; /* Client must be set. */ if (self->client == NULL) { PyErr_SetString(PyExc_AttributeError, "LDAPClient is not set."); return NULL; } /* Get DN string. */ tmp = PyObject_Str(self->dn); dnstr = PyObject2char(tmp); Py_DECREF(tmp); if (dnstr == NULL) return NULL; if (LDAPClient_DelEntryStringDN(self->client, dnstr) != 0) return NULL; if (keys == NULL) return NULL; iter = PyObject_GetIter(keys); Py_DECREF(keys); if (iter == NULL) return NULL; for (key = PyIter_Next(iter); key != NULL; key = PyIter_Next(iter)) { /* Return value: New reference. */ value = (LDAPValueList *)LDAPEntry_GetItem(self, key); if (value == NULL) { Py_DECREF(iter); Py_DECREF(key); return NULL; } value->status = 2; } return Py_None; }
static int Dict_iterNext(JSOBJ obj, JSONTypeContext *tc) { #if PY_MAJOR_VERSION >= 3 PyObject* itemNameTmp; #endif if (GET_TC(tc)->itemName) { Py_DECREF(GET_TC(tc)->itemName); GET_TC(tc)->itemName = NULL; } if (!(GET_TC(tc)->itemName = PyIter_Next(GET_TC(tc)->iterator))) { PRINTMARK(); return 0; } if (!(GET_TC(tc)->itemValue = PyObject_GetItem(GET_TC(tc)->dictObj, GET_TC(tc)->itemName))) { PRINTMARK(); return 0; } if (PyUnicode_Check(GET_TC(tc)->itemName)) { GET_TC(tc)->itemName = PyUnicode_AsUTF8String (GET_TC(tc)->itemName); } else if (!PyString_Check(GET_TC(tc)->itemName)) { if (UNLIKELY(GET_TC(tc)->itemName == Py_None)) { GET_TC(tc)->itemName = PyString_FromString("null"); return 1; } GET_TC(tc)->itemName = PyObject_Str(GET_TC(tc)->itemName); #if PY_MAJOR_VERSION >= 3 itemNameTmp = GET_TC(tc)->itemName; GET_TC(tc)->itemName = PyUnicode_AsUTF8String (GET_TC(tc)->itemName); Py_DECREF(itemNameTmp); #endif } else { Py_INCREF(GET_TC(tc)->itemName); } PRINTMARK(); return 1; }
static PyObject * _io__IOBase_readlines_impl(PyObject *self, Py_ssize_t hint) /*[clinic end generated code: output=2f50421677fa3dea input=9400c786ea9dc416]*/ { Py_ssize_t length = 0; PyObject *result; result = PyList_New(0); if (result == NULL) return NULL; if (hint <= 0) { /* XXX special-casing this made sense in the Python version in order to remove the bytecode interpretation overhead, but it could probably be removed here. */ _Py_IDENTIFIER(extend); PyObject *ret = _PyObject_CallMethodIdObjArgs(result, &PyId_extend, self, NULL); if (ret == NULL) { Py_DECREF(result); return NULL; } Py_DECREF(ret); return result; } while (1) { PyObject *line = PyIter_Next(self); if (line == NULL) { if (PyErr_Occurred()) { Py_DECREF(result); return NULL; } else break; /* StopIteration raised */ } if (PyList_Append(result, line) < 0) { Py_DECREF(line); Py_DECREF(result); return NULL; } length += PyObject_Size(line); Py_DECREF(line); if (length > hint) break; } return result; }
static PyObject * Reader_iternext(ReaderObj *self) { PyObject *lineobj; PyObject *fields = NULL; char *line, c; int linelen; if (parse_reset(self) < 0) return NULL; do { lineobj = PyIter_Next(self->input_iter); if (lineobj == NULL) { /* End of input OR exception */ if (!PyErr_Occurred() && self->field_len != 0) PyErr_Format(error_obj, "newline inside string"); return NULL; } ++self->line_num; line = PyString_AsString(lineobj); linelen = PyString_Size(lineobj); if (line == NULL || linelen < 0) { Py_DECREF(lineobj); return NULL; } while (linelen--) { c = *line++; if (c == '\0') { Py_DECREF(lineobj); PyErr_Format(error_obj, "line contains NULL byte"); goto err; } if (parse_process_char(self, c) < 0) { Py_DECREF(lineobj); goto err; } } Py_DECREF(lineobj); if (parse_process_char(self, 0) < 0) goto err; } while (self->state != START_RECORD); fields = self->fields; self->fields = NULL; err: return fields; }
static PyObject * pyAppendToRecord(PyObject *self, PyObject *args) { PyObject* py_dict; PyObject* py_iter; PyObject* py_key; PyObject* py_val; int recid, rc; char *allData; unsigned size; // retrieve record id and dictionary object if (!PyArg_ParseTuple(args, "iO!", &recid, &PyDict_Type, &py_dict)) { return Py_BuildValue("i", 1); // ERROR - PyArg_ParseTuple } // abort if record id does not exist rc = MEgetAllFieldsById(dbhandle, recid, &allData, &size); if (size == 0) { return Py_BuildValue("i", 2); // ERROR - record ID not found } // retrieve iterator py_iter = PyObject_GetIter(py_dict); if (!py_iter) { return Py_BuildValue("i", 3); // ERROR - Not an iterator } // loop through key-value pairs and append to record int kvcount = 0; while (py_key = PyIter_Next(py_iter)) { py_val = PyDict_GetItem(py_dict, py_key); char * key = PyString_AsString(py_key); char * val = PyString_AsString(py_val); if (debugMode) { printf("pyAppendToRecord: %s - %s\n", key, val); } // add kv pair into meta engine kvcount++; MEaddKeyValue(dbhandle, recid, key, val); Py_DECREF(py_key); } Py_DECREF(py_iter); if (debugMode) { printf("pyAppendToRecord: total kv count: %i\n", kvcount); } return Py_BuildValue("i", 0); // SUCCESS }
llvm_compat_bool iterwrapperHasnextUnboxed(Box* s) { RELEASE_ASSERT(s->cls == iterwrapper_cls, ""); BoxedIterWrapper* self = static_cast<BoxedIterWrapper*>(s); Box* next = PyIter_Next(self->iter); RELEASE_ASSERT(!self->next, ""); self->next = next; if (!next) { if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_StopIteration)) throwCAPIException(); PyErr_Clear(); } return next != NULL; }
static PyObj statement_load_chunks(PyObj self, PyObj args, PyObj kw) { char *words[] = {"chunks_iter", NULL}; PyObj chunk_iter, ob; uint32 total = 0; if (PyPgStatement_GetParameters(self) != Py_None) { PyErr_SetString(PyExc_TypeError, "cannot use load_rows with constant parameters"); return(NULL); } if (!PyArg_ParseTupleAndKeywords(args, kw, "O:load_chunks", words, &chunk_iter)) return(NULL); if (DB_IS_NOT_READY()) return(NULL); chunk_iter = PyObject_GetIter(chunk_iter); if (chunk_iter == NULL) return(NULL); while ((ob = PyIter_Next(chunk_iter))) { PyObj row_iter; int r; row_iter = PyObject_GetIter(ob); Py_DECREF(ob); if (row_iter == NULL) { Py_DECREF(chunk_iter); return(NULL); } r = load_rows(self, row_iter, &total); Py_DECREF(row_iter); if (r) { Py_DECREF(chunk_iter); return(NULL); } } Py_DECREF(chunk_iter); return(PyLong_FromUnsignedLong(total)); }
static PyObject * attr_dir_merge(PyObject *_self, PyObject *map) { PyObject *keys, *iter; PyObject *key, *value; int status; keys = PyMapping_Keys(map); if (!keys) return NULL; iter = PyObject_GetIter(keys); Py_DECREF(keys); if (!iter) return NULL; for (key = PyIter_Next(iter); key; key = PyIter_Next(iter)) { value = PyObject_GetItem(map, key); if (!value) goto err; status = attr_dir_ass_subscript(_self, key, value); Py_DECREF(value); if (status < 0) goto err; Py_DECREF(key); } Py_DECREF(iter); if (PyErr_Occurred()) return NULL; return Py_None; err: Py_DECREF(iter); Py_DECREF(key); return NULL; }
char *uwsgi_python_get_thread_name(PyObject *thread_id) { PyObject *threading_module = PyImport_ImportModule("threading"); if (!threading_module) return NULL; PyObject *threading_dict = PyModule_GetDict(threading_module); if (!threading_dict) return NULL; PyObject *threading_enumerate = PyDict_GetItemString(threading_dict, "enumerate"); if (!threading_enumerate) return NULL; PyObject *threads_list = PyEval_CallObject(threading_enumerate, (PyObject *)NULL); if (!threads_list) return NULL; PyObject *threads_list_iter = PyObject_GetIter(threads_list); if (!threads_list_iter) goto clear; PyObject *threads_list_next = PyIter_Next(threads_list_iter); while(threads_list_next) { PyObject *thread_ident = PyObject_GetAttrString(threads_list_next, "ident"); if (!thread_ident) goto clear2; if (PyInt_AsLong(thread_ident) == PyInt_AsLong(thread_id)) { PyObject *thread_name = PyObject_GetAttrString(threads_list_next, "name"); if (!thread_name) goto clear2; char *name = PyString_AsString(thread_name); Py_DECREF(threads_list_iter); Py_DECREF(threads_list); return name; } threads_list_next = PyIter_Next(threads_list_iter); } clear2: Py_DECREF(threads_list_iter); clear: Py_DECREF(threads_list); return NULL; }
static PyObject * DiscoDBIter_format(DiscoDBIter *self, PyObject *format, int N) { PyObject *iterator = PyObject_GetIter((PyObject *)self), *string = PyString_FromString(""), *item = NULL; int i; if (iterator == NULL) goto Done; if (string == NULL) goto Done; for (i = 0; i < N + 1; i++) { item = PyIter_Next(iterator); if (item == NULL) { if (PyErr_Occurred()) goto Done; else break; } if (i > 0) PyString_ConcatAndDel(&string, PyString_FromString(", ")); if (i < N) PyString_ConcatAndDel(&string, PyString_Format(format, item)); else PyString_ConcatAndDel(&string, PyString_FromString("...")); if (string == NULL) goto Done; Py_CLEAR(item); } Done: Py_CLEAR(iterator); Py_CLEAR(item); if (PyErr_Occurred()) { Py_CLEAR(string); return NULL; } return string; }
static range* _python_function(range_request* rr, const char* funcname, const range** r) { range* result = range_new(rr); PyObject * pLibcrangeCallFunc; PyObject * pNodesReturned; PyObject * pMain = PyImport_AddModule("__main__"); // printf("rr: %p, funcname=%s, range**r = %p\n", rr, funcname, r); pLibcrangeCallFunc = PyObject_GetAttrString(pMain, "libcrange_call_func"); if (pLibcrangeCallFunc && PyCallable_Check(pLibcrangeCallFunc)) { PyObject * pRangeFuncName; PyObject * item; pRangeFuncName = PyString_FromString(funcname); PyObject * pFuncArgs; PyObject * pTempArgList = PyList_New(0); PyList_Append(pTempArgList, pRangeFuncName); Py_DECREF(pRangeFuncName); // build our range** into python function args const range** p_r = r; while (*p_r) { item = range_to_py_array(range_request_pool(rr), *p_r); PyList_Append(pTempArgList, item); Py_DECREF(item); p_r++; } pFuncArgs = PyList_AsTuple(pTempArgList); Py_DECREF(pTempArgList); // call the function pNodesReturned = PyObject_CallObject(pLibcrangeCallFunc, pFuncArgs); Py_DECREF(pFuncArgs); PyObject *iterator = PyObject_GetIter(pNodesReturned); if (iterator == NULL) { printf("ERROR: python function %s ran, but didn't return an iteratable object", funcname); return result; } // an iteratable object was returned, transform it into result while (item = PyIter_Next(iterator)) { // PyObject_Print(item, stdout, 0 ); range_add(result, PyString_AsString(item)); Py_DECREF(item); } Py_DECREF(pNodesReturned); } return result; }
static PyObject * record_items_next(ApgRecordItemsObject *it) { ApgRecordObject *seq; PyObject *key; PyObject *val; PyObject *tup; assert(it != NULL); seq = it->it_seq; if (seq == NULL) { return NULL; } assert(ApgRecord_CheckExact(seq)); assert(it->it_map_iter != NULL); key = PyIter_Next(it->it_map_iter); if (key == NULL) { /* likely it_map_iter had less items than seq has values */ goto exhausted; } if (it->it_index < Py_SIZE(seq)) { val = ApgRecord_GET_ITEM(seq, it->it_index); ++it->it_index; Py_INCREF(val); } else { /* it_map_iter had more items than seq has values */ Py_DECREF(key); goto exhausted; } tup = PyTuple_New(2); if (tup == NULL) { Py_DECREF(val); Py_DECREF(key); goto exhausted; } PyTuple_SET_ITEM(tup, 0, key); PyTuple_SET_ITEM(tup, 1, val); return tup; exhausted: Py_CLEAR(it->it_map_iter); Py_CLEAR(it->it_seq); return NULL; }
static int iterable_iterate(PyObject *v, int (*visit)(PyObject *, void *), void *arg) { if (NyNodeSet_Check(v)) { return NyNodeSet_iterate((NyNodeSetObject *)v, visit, arg); } else if (NyHeapView_Check(v)) { return NyHeapView_iterate((NyHeapViewObject *)v, visit, arg); } else if (PyList_Check(v)) { /* A bit faster than general iterator?? */ int i, r; PyObject *item; for (i = 0; i < PyList_GET_SIZE(v); i++) { item = PyList_GET_ITEM(v, i); Py_INCREF(item); r = visit(item, arg); Py_DECREF(item); if (r == -1) return -1; if (r == 1) break; } return 0; } else { /* Do the general case. */ PyObject *it = PyObject_GetIter(v); int r; if (it == NULL) goto Err; /* Run iterator to exhaustion. */ for (;;) { PyObject *item = PyIter_Next(it); if (item == NULL) { if (PyErr_Occurred()) goto Err; break; } r = visit(item, arg); Py_DECREF(item); if (r == -1) goto Err; if (r == 1) break; } Py_DECREF(it); return 0; Err: Py_XDECREF(it); return -1; } }
/* Set the slice of UniqueList between `ilow` and `ihigh` to the contents of `itemlist`. The `itemlist` must be containing unique elements. The `itemlist` may be NULL, indicating the assignment of an empty list (slice deletion). */ int UniqueList_SetSlice(UniqueList *self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *itemlist) { PyObject *iter = NULL; PyObject *newitem; if (itemlist != NULL) iter = PyObject_GetIter(itemlist); if (iter != NULL) { for (newitem = PyIter_Next(iter); newitem != NULL; newitem = PyIter_Next(iter)) { if (PyDict_Check(newitem) || PyList_Check(newitem) || PyTuple_Check(newitem)) { PyErr_SetString(PyExc_ValueError, "This type of list can not contain instances of Python tuple, list or dict."); return -1; } if (UniqueList_Contains(self, newitem) == 1) { PyErr_Format(PyExc_ValueError, "%R is already in the list.", newitem); return -1; } Py_DECREF(newitem); } Py_DECREF(iter); } return PyList_SetSlice((PyObject *)self, ilow, ihigh, itemlist); }
/* Searches amongs lower-cased keystrings to find a match with the key. Sets the `found` parameter's value to 1 if key found in the list, 0 otherwise. */ PyObject * searchLowerCaseKeyMatch(LDAPEntry *self, PyObject *key, int* found) { PyObject *keys = PyDict_Keys((PyObject *)self); PyObject *iter = PyObject_GetIter(keys); PyObject *item; if (iter == NULL) { Py_DECREF(keys); return NULL; } /* Searching for same lowercase key amongs the other keys. */ for (item = PyIter_Next(iter); item != NULL; item = PyIter_Next(iter)) { if (lowerCaseMatch(item, key) == 1) { key = item; *found = 1; break; } *found = 0; Py_DECREF(item); } Py_DECREF(iter); Py_DECREF(keys); return key; }
static PyObject * chain_next(chainobject *lz) { PyObject *it; PyObject *item; while (lz->iternum < lz->tuplesize) { it = PyTuple_GET_ITEM(lz->ittuple, lz->iternum); item = PyIter_Next(it); if (item != NULL) return item; lz->iternum++; } return NULL; }
void getWords (vector<pair<int, string>> & wordList) { PyObject * pyIter = PyObject_CallMethod (m_pyDict, (char *) "iteritems", NULL); PyObject * pyItem; while (pyItem = PyIter_Next (pyIter)) { const char * key = PyString_AsString (PyTuple_GetItem (pyItem, 0)); long value = PyInt_AsLong (PyTuple_GetItem (pyItem, 1)); wordList . push_back (pair<int, string> (value, key)); Py_DECREF (pyItem); } Py_DECREF (pyIter); }
static response_status start_response_write(client_t *client) { PyObject *iterator; PyObject *item; char *buf; Py_ssize_t buflen; response_status ret; iterator = PyObject_GetIter(client->response); if (PyErr_Occurred()){ /* write_error_log(__FILE__, __LINE__); */ call_error_logger(); return STATUS_ERROR; } client->response_iter = iterator; item = PyIter_Next(iterator); DEBUG("client %p", client); if(item != NULL && PyBytes_Check(item)){ //write string only buf = PyBytes_AS_STRING(item); buflen = PyBytes_GET_SIZE(item); /* DEBUG("status_code %d body:%.*s", client->status_code, (int)buflen, buf); */ ret = write_headers(client, buf, buflen, 0); //TODO when ret == STATUS_SUSPEND keep item Py_DECREF(item); return ret; }else{ if (item == NULL && !PyErr_Occurred()){ //Stop Iteration RDEBUG("WARN iter item == NULL"); return write_headers(client, NULL, 0, 0); }else{ PyErr_SetString(PyExc_TypeError, "response item must be a string"); Py_XDECREF(item); if (PyErr_Occurred()){ /* write_error_log(__FILE__, __LINE__); */ call_error_logger(); return STATUS_ERROR; } } } return STATUS_ERROR; }
static PyObject * deque_extendleft(dequeobject *deque, PyObject *iterable) { PyObject *it, *item; /* Handle case where id(deque) == id(iterable) */ if ((PyObject *)deque == iterable) { PyObject *result; PyObject *s = PySequence_List(iterable); if (s == NULL) return NULL; result = deque_extendleft(deque, s); Py_DECREF(s); return result; } it = PyObject_GetIter(iterable); if (it == NULL) return NULL; if (deque->maxlen == 0) return consume_iterator(it); while ((item = PyIter_Next(it)) != NULL) { deque->state++; if (deque->leftindex == 0) { block *b = newblock(NULL, deque->leftblock, deque->len); if (b == NULL) { Py_DECREF(item); Py_DECREF(it); return NULL; } assert(deque->leftblock->leftlink == NULL); deque->leftblock->leftlink = b; deque->leftblock = b; deque->leftindex = BLOCKLEN; } deque->len++; deque->leftindex--; deque->leftblock->data[deque->leftindex] = item; TRIM(deque, deque_pop); } Py_DECREF(it); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; }
static void copyFlowsToPython(FlowGraph graph, PyObject *edges) { PyObject *item, *iter; int from, to; float flow; iter = PyObject_GetIter(edges); while((item = PyIter_Next(iter))) { from = PyInt_AsLong(PyList_GetItem(item, 0)); to = PyInt_AsLong(PyList_GetItem(item, 1)); flow = Graph_getFlow(graph, from, to); PyList_SetItem(item, 3, PyFloat_FromDouble(flow)); Py_DECREF(item); } Py_DECREF(iter); }