void
PyArena_Free(PyArena *arena)
{
int r;
assert(arena);
#if defined(Py_DEBUG)
/*
fprintf(stderr,
"alloc=%d size=%d blocks=%d block_size=%d big=%d objects=%d\n",
arena->total_allocs, arena->total_size, arena->total_blocks,
arena->total_block_size, arena->total_big_blocks,
PyList_Size(arena->a_objects));
*/
#endif
block_free(arena->a_head);
/* This property normally holds, except when the code being compiled
is sys.getobjects(0), in which case there will be two references.
assert(arena->a_objects->ob_refcnt == 1);
*/
/* Clear all the elements from the list. This is necessary
to guarantee that they will be DECREFed. */
r = PyList_SetSlice(arena->a_objects,
0, PyList_GET_SIZE(arena->a_objects), NULL);
assert(r == 0);
assert(PyList_GET_SIZE(arena->a_objects) == 0);
Py_DECREF(arena->a_objects);
free(arena);
}
static int
flush_accumulator(_PyAccu *acc)
{
Py_ssize_t nsmall = PyList_GET_SIZE(acc->small);
if (nsmall) {
int ret;
PyObject *joined;
if (acc->large == NULL) {
acc->large = PyList_New(0);
if (acc->large == NULL)
return -1;
}
joined = join_list_unicode(acc->small);
if (joined == NULL)
return -1;
if (PyList_SetSlice(acc->small, 0, nsmall, NULL)) {
Py_DECREF(joined);
return -1;
}
ret = PyList_Append(acc->large, joined);
Py_DECREF(joined);
return ret;
}
return 0;
}
static PyObject *
heappop(PyObject *self, PyObject *heap)
{
PyObject *lastelt, *returnitem;
Py_ssize_t n;
if (!PyList_Check(heap)) {
PyErr_SetString(PyExc_TypeError, "heap argument must be a list");
return NULL;
}
/* # raises appropriate IndexError if heap is empty */
n = PyList_GET_SIZE(heap);
if (n == 0) {
PyErr_SetString(PyExc_IndexError, "index out of range");
return NULL;
}
lastelt = PyList_GET_ITEM(heap, n-1) ;
Py_INCREF(lastelt);
PyList_SetSlice(heap, n-1, n, NULL);
n--;
if (!n)
return lastelt;
returnitem = PyList_GET_ITEM(heap, 0);
PyList_SET_ITEM(heap, 0, lastelt);
if (_siftup((PyListObject *)heap, 0) == -1) {
Py_DECREF(returnitem);
return NULL;
}
return returnitem;
}
static PyObject *
simplequeue_pop_item(simplequeueobject *self)
{
Py_ssize_t count, n;
PyObject *item;
n = PyList_GET_SIZE(self->lst);
assert(self->lst_pos < n);
item = PyList_GET_ITEM(self->lst, self->lst_pos);
Py_INCREF(Py_None);
PyList_SET_ITEM(self->lst, self->lst_pos, Py_None);
self->lst_pos += 1;
count = n - self->lst_pos;
if (self->lst_pos > count) {
/* The list is more than 50% empty, reclaim space at the beginning */
if (PyList_SetSlice(self->lst, 0, self->lst_pos, NULL)) {
/* Undo pop */
self->lst_pos -= 1;
PyList_SET_ITEM(self->lst, self->lst_pos, item);
return NULL;
}
self->lst_pos = 0;
}
return item;
}
/**
* 从连接池中获得一个连接
* args的第一个参数是一个连接池对象
**/
static PyObject*
getconnection(PyObject *self, PyObject *args)
{
PyConnectPoolObject *pool = PySequence_GetItem(args, 0);
PyListObject *conns;
PyConnectObject *con;
if(!PyConnectPool_CheckExact(pool))
{
PyErr_SetString(PyExc_RuntimeError, "参数类型不是connectPool");
return NULL;
}
conns = pool->cons_free;
//空闲缓冲池里面可以获得到空闲的连接
if(PySequence_Length(conns))
{
con = (PyConnectObject*)PySequence_GetItem(conns, 0);
//删除第一个元素
PyList_SetSlice(conns, 0, 1, NULL);
}
else
{
con = (PyConnectObject*)PyConnect_New(pool->host, pool->user, pool->passwd, pool->db, pool->port);
}
if(con == NULL)
{
return PyErr_NoMemory();
}
conns = pool->cons_busy;
PyList_Insert((PyObject*)conns, 0, (PyObject*)con);
return (PyObject*)con;
}
static PyObject *
BinaryHeap_pop(BinaryHeap* self)
{
PyObject *lastelt, *returnitem;
Py_ssize_t n;
/* # raises appropriate IndexError if heap is empty */
n = PyList_GET_SIZE(self->items);
if (n == 0) {
PyErr_SetString(PyExc_IndexError, "index out of range");
return NULL;
}
lastelt = PyList_GET_ITEM(self->items, n-1) ;
Py_INCREF(lastelt);
PyList_SetSlice(self->items, n-1, n, NULL);
n--;
if (!n)
return lastelt;
returnitem = PyList_GET_ITEM(self->items, 1);
PyList_SET_ITEM(self->items, 1, lastelt);
sink(self, 1);
return returnitem;
}
PyObject *
LDAPSearchIter_iternext(LDAPSearchIter *self) {
PyObject *item = NULL;
if (self->buffer == NULL) return NULL;
if (Py_SIZE(self->buffer) != 0) {
/* Get first element from the buffer list. (Borrowed ref.)*/
item = PyList_GetItem(self->buffer, 0);
if (item == NULL) {
PyErr_BadInternalCall();
return NULL;
}
Py_INCREF(item);
/* Remove the first element from the buffer list. */
if (PyList_SetSlice(self->buffer, 0, 1, NULL) != 0) {
PyErr_BadInternalCall();
return NULL;
}
return item;
} else {
Py_DECREF(self->buffer);
self->buffer = NULL;
}
return NULL;
}
/* {{{ _syspath_prepend
*/
static int
_syspath_prepend(const char *dir)
{
PyObject *sys, *path, *dirstr;
if (dir == NULL) {
return -1;
}
sys = PyImport_ImportModule("sys");
path = PyObject_GetAttrString(sys, "path");
dirstr = PyString_FromString(dir);
/* Prepend dir to sys.path if it's not already there. */
if (PySequence_Index(path, dirstr) == -1) {
PyObject *list;
PyErr_Clear();
list = Py_BuildValue("[O]", dirstr);
PyList_SetSlice(path, 0, 0, list);
Py_DECREF(list);
}
Py_DECREF(dirstr);
Py_DECREF(path);
Py_DECREF(sys);
return 0;
}
void BPY_app_handlers_reset(const short do_all)
{
PyGILState_STATE gilstate;
int pos = 0;
gilstate = PyGILState_Ensure();
if (do_all) {
for (pos = 0; pos < BLI_CB_EVT_TOT; pos++) {
/* clear list */
PyList_SetSlice(py_cb_array[pos], 0, PY_SSIZE_T_MAX, NULL);
}
}
else {
/* save string conversion thrashing */
PyObject *perm_id_str = PyUnicode_FromString(PERMINENT_CB_ID);
for (pos = 0; pos < BLI_CB_EVT_TOT; pos++) {
/* clear only items without PERMINENT_CB_ID */
PyObject *ls = py_cb_array[pos];
Py_ssize_t i;
PyObject *item;
PyObject **dict_ptr;
for (i = PyList_GET_SIZE(ls) - 1; i >= 0; i--) {
if ((PyFunction_Check((item = PyList_GET_ITEM(ls, i)))) &&
(dict_ptr = _PyObject_GetDictPtr(item)) &&
(*dict_ptr) &&
(PyDict_GetItem(*dict_ptr, perm_id_str) != NULL))
{
/* keep */
}
else {
/* remove */
/* PySequence_DelItem(ls, i); */ /* more obvious buw slower */
PyList_SetSlice(ls, i, i + 1, NULL);
}
}
}
Py_DECREF(perm_id_str);
}
PyGILState_Release(gilstate);
}
void BPY_app_handlers_reset(void)
{
int pos= 0;
for(pos= 0; pos < BLI_CB_EVT_TOT; pos++) {
PyList_SetSlice(py_cb_array[pos], 0, PY_SSIZE_T_MAX, NULL);
}
}
static int
PLy_result_ass_slice(PyObject *arg, Py_ssize_t lidx, Py_ssize_t hidx, PyObject *slice)
{
int rv;
PLyResultObject *ob = (PLyResultObject *) arg;
rv = PyList_SetSlice(ob->rows, lidx, hidx, slice);
return rv;
}
// Clear the list.
void ListWrapper::clear(QObject *qobj, QList<QObject *> *qlist)
{
qlist->clear();
ListWrapper *lw = findWrapper(qobj, qlist);
if (!lw || PyList_SetSlice(lw->_py_list, 0, PyList_GET_SIZE(lw->_py_list), NULL) < 0)
PyErr_Print();
}
// Remove arguments from the Python argv list that have been removed from the
// C argv array.
void qpycore_UpdatePyArgv(PyObject *argvlist, int argc, char **argv)
{
for (int a = 0, na = 0; a < argc; ++a)
{
// See if it was removed.
if (argv[na] == argv[a + argc + 1])
++na;
else
PyList_SetSlice(argvlist, na, na + 1, 0);
}
}
static int
wrap_ass_slice(PyObject *self, Py_ssize_t i, Py_ssize_t j, PyObject *value)
{
PyObject *obj = Proxy_GET_OBJECT(self);
if (PyList_Check(obj)) {
return PyList_SetSlice(obj, i, j, value);
}
else {
return PySequence_SetSlice(obj, i, j, value);
}
}
/*
Write a series of tokens to the current stack at once.
*/
int Tokenizer_emit_all(Tokenizer* self, PyObject* tokenlist)
{
int pushed = 0;
PyObject *stack, *token, *left, *right, *text;
Textbuffer* buffer;
Py_ssize_t size;
if (PyList_GET_SIZE(tokenlist) > 0) {
token = PyList_GET_ITEM(tokenlist, 0);
switch (PyObject_IsInstance(token, Text)) {
case 0:
break;
case 1: {
pushed = 1;
buffer = self->topstack->textbuffer;
if (buffer->length == 0)
break;
left = Textbuffer_render(buffer);
if (!left)
return -1;
right = PyObject_GetAttrString(token, "text");
if (!right)
return -1;
text = PyUnicode_Concat(left, right);
Py_DECREF(left);
Py_DECREF(right);
if (!text)
return -1;
if (PyObject_SetAttrString(token, "text", text)) {
Py_DECREF(text);
return -1;
}
Py_DECREF(text);
if (Textbuffer_reset(buffer))
return -1;
break;
}
case -1:
return -1;
}
}
if (!pushed) {
if (Tokenizer_push_textbuffer(self))
return -1;
}
stack = self->topstack->stack;
size = PyList_GET_SIZE(stack);
if (PyList_SetSlice(stack, size, size, tokenlist))
return -1;
return 0;
}
PyObject *
PySequence_List(PyObject *v)
{
PySequenceMethods *m;
if (v == NULL)
return null_error();
if (PyList_Check(v))
return PyList_GetSlice(v, 0, PyList_GET_SIZE(v));
m = v->ob_type->tp_as_sequence;
if (m && m->sq_item) {
int i;
PyObject *l;
int n = PySequence_Size(v);
if (n < 0)
return NULL;
l = PyList_New(n);
if (l == NULL)
return NULL;
for (i = 0; ; i++) {
PyObject *item = (*m->sq_item)(v, i);
if (item == NULL) {
if (PyErr_ExceptionMatches(PyExc_IndexError))
PyErr_Clear();
else {
Py_DECREF(l);
l = NULL;
}
break;
}
if (i < n)
PyList_SET_ITEM(l, i, item);
else if (PyList_Append(l, item) < 0) {
Py_DECREF(l);
l = NULL;
break;
}
}
if (i < n && l != NULL) {
if (PyList_SetSlice(l, i, n, (PyObject *)NULL) != 0) {
Py_DECREF(l);
l = NULL;
}
}
return l;
}
return type_error("list() argument must be a sequence");
}
bool KPythonList::Remove(unsigned int index)
{
PyLockGIL lock;
if (index < this->Size())
{
PyObject* emptyList = PyList_New(0);
PyList_SetSlice(this->list, index, index + 1, emptyList);
Py_DECREF(emptyList);
return true;
}
else
{
return false;
}
}
extern "C" void Py_ReprLeave(PyObject* obj) noexcept {
PyObject* dict;
PyObject* list;
Py_ssize_t i;
dict = PyThreadState_GetDict();
if (dict == NULL)
return;
list = PyDict_GetItemString(dict, KEY);
if (list == NULL || !PyList_Check(list))
return;
i = PyList_GET_SIZE(list);
/* Count backwards because we always expect obj to be list[-1] */
while (--i >= 0) {
if (PyList_GET_ITEM(list, i) == obj) {
PyList_SetSlice(list, i, i + 1, NULL);
break;
}
}
}
/* used by import.c:PyImport_Cleanup */
void
_PyState_ClearModules(void)
{
PyInterpreterState *state = PyThreadState_GET()->interp;
if (state->modules_by_index) {
Py_ssize_t i;
for (i = 0; i < PyList_GET_SIZE(state->modules_by_index); i++) {
PyObject *m = PyList_GET_ITEM(state->modules_by_index, i);
if (PyModule_Check(m)) {
/* cleanup the saved copy of module dicts */
PyModuleDef *md = PyModule_GetDef(m);
if (md)
Py_CLEAR(md->m_base.m_copy);
}
}
/* Setting modules_by_index to NULL could be dangerous, so we
clear the list instead. */
if (PyList_SetSlice(state->modules_by_index,
0, PyList_GET_SIZE(state->modules_by_index),
NULL))
PyErr_WriteUnraisable(state->modules_by_index);
}
}
static PyObject *
xpybIter_pop(xpybIter *self)
{
PyObject *cur, *next, *item;
cur = PyList_GET_ITEM(self->stack, self->top);
item = PyIter_Next(cur);
if (item == NULL) {
if (PyErr_Occurred() || self->top < 1)
return NULL;
if (PyList_SetSlice(self->stack, self->top, self->top + 1, NULL) < 0)
return NULL;
self->top--;
return xpybIter_pop(self);
}
if (PySequence_Check(item)) {
next = PyObject_GetIter(item);
if (next == NULL)
goto err1;
if (PyList_Append(self->stack, next) < 0)
goto err2;
self->top++;
Py_DECREF(next);
Py_DECREF(item);
return xpybIter_pop(self);
}
return item;
err2:
Py_DECREF(next);
err1:
Py_DECREF(item);
return NULL;
}
/* 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);
}
static PyObject *
heappop_internal(PyObject *heap, int siftup_func(PyListObject *, Py_ssize_t))
{
PyObject *lastelt, *returnitem;
Py_ssize_t n;
if (!PyList_Check(heap)) {
PyErr_SetString(PyExc_TypeError, "heap argument must be a list");
return NULL;
}
/* raises IndexError if the heap is empty */
n = PyList_GET_SIZE(heap);
if (n == 0) {
PyErr_SetString(PyExc_IndexError, "index out of range");
return NULL;
}
lastelt = PyList_GET_ITEM(heap, n-1) ;
Py_INCREF(lastelt);
if (PyList_SetSlice(heap, n-1, n, NULL) < 0) {
Py_DECREF(lastelt);
return NULL;
}
n--;
if (!n)
return lastelt;
returnitem = PyList_GET_ITEM(heap, 0);
PyList_SET_ITEM(heap, 0, lastelt);
if (siftup_func((PyListObject *)heap, 0) == -1) {
Py_DECREF(returnitem);
return NULL;
}
return returnitem;
}
static int green_updatecurrent(void)
{
PyObject *exc, *val, *tb;
PyThreadState* tstate;
PyGreenlet* current;
PyGreenlet* previous;
PyObject* deleteme;
/* save current exception */
PyErr_Fetch(&exc, &val, &tb);
/* get ts_current from the active tstate */
tstate = PyThreadState_GET();
if (tstate->dict && (current =
(PyGreenlet*) PyDict_GetItem(tstate->dict, ts_curkey))) {
/* found -- remove it, to avoid keeping a ref */
Py_INCREF(current);
PyDict_DelItem(tstate->dict, ts_curkey);
}
else {
/* first time we see this tstate */
current = green_create_main();
if (current == NULL) {
Py_XDECREF(exc);
Py_XDECREF(val);
Py_XDECREF(tb);
return -1;
}
}
green_updatecurrent_retry:
/* update ts_current as soon as possible, in case of nested switches */
Py_INCREF(current);
previous = ts_current;
ts_current = current;
/* save ts_current as the current greenlet of its own thread */
if (PyDict_SetItem(previous->run_info, ts_curkey, (PyObject*) previous)) {
Py_DECREF(previous);
Py_DECREF(current);
Py_XDECREF(exc);
Py_XDECREF(val);
Py_XDECREF(tb);
return -1;
}
Py_DECREF(previous);
/* green_dealloc() cannot delete greenlets from other threads, so
it stores them in the thread dict; delete them now. */
deleteme = PyDict_GetItem(tstate->dict, ts_delkey);
if (deleteme != NULL) {
PyList_SetSlice(deleteme, 0, INT_MAX, NULL);
}
if (ts_current != current) {
/* some Python code executed above and there was a thread switch,
* so ts_current points to some other thread again. We need to
* delete ts_curkey (it's likely there) and retry. */
PyDict_DelItem(tstate->dict, ts_curkey);
goto green_updatecurrent_retry;
}
/* release an extra reference */
Py_DECREF(current);
/* restore current exception */
PyErr_Restore(exc, val, tb);
return 0;
}
void List::setSlice(int start, int stop, const Object &iterable)
{
PyList_SetSlice(mPtr, start, stop, iterable.borrowReference());
PW_PyExcept_Check("List::setSlice");
}
static int cdefer_Deferred_set_callbacks(PyObject *o, PyObject *new_value, void *context) {
cdefer_Deferred *self = (cdefer_Deferred *)o;
PyObject *cb = self->callbacks;
return PyList_SetSlice(cb, self->callback_index, PyList_GET_SIZE(cb), new_value);
}
static PyObject *cdefer_Deferred__runCallbacks(cdefer_Deferred *self) {
PyObject *cb;
PyObject *item;
PyObject *callbacktuple;
PyObject *callback;
PyObject *args;
PyObject *newArgs;
PyObject *newArgs2;
PyObject *kwargs;
PyObject *_continue;
PyObject *type, *value, *traceback;
PyObject *tmp;
PyObject *result;
int size;
int offset;
const char *callback_name;
if (self->running_callbacks) {
Py_INCREF(Py_None);
return Py_None;
}
if (!self->paused) {
cb = self->callbacks;
if (!PyList_Check(cb)) {
PyErr_SetString(PyExc_TypeError, "callbacks must be a list");
return NULL;
}
for (;;) {
size = PyList_GET_SIZE(cb);
if (size == -1) {
return NULL;
}
if (self->callback_index >= size) {
break;
}
item = PyList_GET_ITEM(cb, self->callback_index);
if (!item) {
return NULL;
}
if (cdefer_Deferred__verify_callbacks_item(item)) {
return NULL;
}
if (PyObject_IsInstance(self->result, failure_class)) {
offset = 1;
callback_name = "errback";
} else {
offset = 0;
callback_name = "callback";
}
callbacktuple = PyTuple_GET_ITEM(item, offset);
if (!callbacktuple) {
return NULL;
}
if (cdefer_Deferred__verify_callback_entry(callback_name, callbacktuple)) {
return NULL;
}
callback = PyTuple_GET_ITEM(callbacktuple, 0);
if(!callback) {
return NULL;
}
if (callback == Py_None) {
++self->callback_index;
continue;
}
args = PyTuple_GET_ITEM(callbacktuple, 1);
if (!args) {
return NULL;
}
kwargs = PyTuple_GET_ITEM(callbacktuple, 2);
if (!kwargs) {
return NULL;
}
newArgs = Py_BuildValue("(O)", self->result);
if (!newArgs) {
return NULL;
}
if (args != Py_None) {
newArgs2 = PySequence_InPlaceConcat(newArgs, args);
Py_CLEAR(newArgs);
if (!newArgs2) {
return NULL;
}
} else {
newArgs2 = newArgs;
newArgs = NULL;
}
++self->callback_index;
if (kwargs == Py_None) {
kwargs = NULL;
}
self->running_callbacks = 1;
tmp = PyObject_Call(callback, newArgs2, kwargs);
self->running_callbacks = 0;
Py_DECREF(self->result);
self->result = tmp;
Py_CLEAR(newArgs2);
if (!self->result) {
PyErr_Fetch(&type, &value, &traceback);
PyErr_NormalizeException(&type, &value, &traceback);
if (!traceback) {
traceback = Py_None;
Py_INCREF(traceback);
}
self->result = PyObject_CallFunction(failure_class, "OOO", value, type, traceback);
if (!self->result) {
PyErr_Restore(type, value, traceback);
return NULL;
}
Py_DECREF(type);
Py_DECREF(value);
Py_DECREF(traceback);
continue;
}
if (PyObject_TypeCheck(self->result, &cdefer_DeferredType)) {
PyObject *self_result;
if (PyList_SetSlice(cb, 0, self->callback_index, NULL) == -1) {
return NULL;
}
self->callback_index = 0;
result = PyObject_CallMethod((PyObject *)self, "pause", NULL);
if (!result) {
return NULL;
}
Py_DECREF(result);
_continue = PyObject_GetAttrString((PyObject *)self,
"_continue");
if (!_continue) {
return NULL;
}
self_result = self->result;
Py_INCREF(self_result);
result = cdefer_Deferred__addCallbacks(
(cdefer_Deferred *)self->result, _continue,
_continue, Py_None, Py_None, Py_None, Py_None);
Py_DECREF(self_result);
/* The reference was either copied/incref'd or not
* (when errored) in addCallbacks, either way, we own
* one too, and don't need it anymore. */
Py_DECREF(_continue);
if (!result) {
return NULL;
}
Py_DECREF(result);
goto endLabel;
}
}
if (PyList_SetSlice(cb, 0, PyList_GET_SIZE(cb), NULL) == -1) {
return NULL;
}
self->callback_index = 0;
}
endLabel:
if (PyObject_IsInstance(self->result, failure_class)) {
result = PyObject_CallMethod((PyObject *)self->result,
"cleanFailure", NULL);
if (!result) {
return NULL;
}
Py_DECREF(result);
if (cdefer_Deferred__set_debuginfo_fail_result(self) == -1) {
return NULL;
}
} else {
if (cdefer_Deferred__clear_debuginfo(self) == -1) {
return NULL;
}
}
Py_INCREF(Py_None);
return Py_None;
}
