PyCFrameObject * slp_cframe_new(PyFrame_ExecFunc *exec, unsigned int linked) { PyThreadState *ts = PyThreadState_GET(); PyCFrameObject *cf; PyFrameObject *back; if (free_list == NULL) { cf = PyObject_GC_NewVar(PyCFrameObject, &PyCFrame_Type, 0); if (cf == NULL) return NULL; } else { assert(numfree > 0); --numfree; cf = free_list; free_list = (PyCFrameObject *) free_list->f_back; _Py_NewReference((PyObject *) cf); } back = ts->frame; if (!linked) back = NULL; Py_XINCREF(back); cf->f_execute = exec; cf->f_back = back; cf->ob1 = cf->ob2 = cf->ob3 = NULL; cf->i = cf->n = 0; _PyObject_GC_TRACK(cf); return cf; }
static PyObject* QtGuiObject_alloc(PyTypeObject *type, Py_ssize_t nitems) { PyObject *obj; const size_t size = _PyObject_VAR_SIZE(type, nitems+1); /* note that we need to add one, for the sentinel */ if (PyType_IS_GC(type)) obj = _PyObject_GC_Malloc(size); else obj = (PyObject *)PyObject_MALLOC(size); if (obj == NULL) return PyErr_NoMemory(); // This is why we need this custom alloc: To call the C++ constructor. memset(obj, '\0', size); new ((PyQtGuiObject*) obj) PyQtGuiObject(); if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) Py_INCREF(type); if (type->tp_itemsize == 0) PyObject_INIT(obj, type); else (void) PyObject_INIT_VAR((PyVarObject *)obj, type, nitems); if (PyType_IS_GC(type)) _PyObject_GC_TRACK(obj); return obj; }
static PyObject * record_new_items_iter(PyObject *seq) { ApgRecordItemsObject *it; PyObject *map_iter; if (!ApgRecord_CheckExact(seq)) { PyErr_BadInternalCall(); return NULL; } map_iter = PyObject_GetIter(((ApgRecordObject*)seq)->mapping); if (map_iter == NULL) { return NULL; } it = PyObject_GC_New(ApgRecordItemsObject, &ApgRecordItems_Type); if (it == NULL) return NULL; it->it_map_iter = map_iter; it->it_index = 0; Py_INCREF(seq); it->it_seq = (ApgRecordObject *)seq; _PyObject_GC_TRACK(it); return (PyObject *)it; }
PyObject * PyGen_New(PyFrameObject *f) #endif { PyGenObject *gen = PyObject_GC_New(PyGenObject, &PyGen_Type); if (gen == NULL) { Py_DECREF(f); return NULL; } gen->gi_frame = f; #ifdef STACKLESS /* Support for unpickling generators. This will segmentation fault if called by pricklepit.c:gen_new as that passes Py_None as a placeholder. */ if ((PyObject*)f == Py_None) { Py_INCREF(Py_None); gen->gi_code = Py_None; } else { #endif Py_INCREF(f->f_code); gen->gi_code = (PyObject *)(f->f_code); #ifdef STACKLESS } #endif gen->gi_running = 0; gen->gi_weakreflist = NULL; _PyObject_GC_TRACK(gen); return (PyObject *)gen; }
PyObject * PyMethod_New(PyObject *func, PyObject *self) { PyMethodObject *im; if (self == NULL) { PyErr_BadInternalCall(); return NULL; } im = free_list; if (im != NULL) { free_list = (PyMethodObject *)(im->im_self); PyObject_INIT(im, &PyMethod_Type); numfree--; } else { im = PyObject_GC_New(PyMethodObject, &PyMethod_Type); if (im == NULL) return NULL; } im->im_weakreflist = NULL; Py_INCREF(func); im->im_func = func; Py_XINCREF(self); im->im_self = self; _PyObject_GC_TRACK(im); return (PyObject *)im; }
PyObject * PySlice_New(PyObject *start, PyObject *stop, PyObject *step) { PySliceObject *obj; if (slice_cache != NULL) { obj = slice_cache; slice_cache = NULL; _Py_NewReference((PyObject *)obj); } else { obj = PyObject_GC_New(PySliceObject, &PySlice_Type); if (obj == NULL) return NULL; } if (step == NULL) step = Py_None; Py_INCREF(step); if (start == NULL) start = Py_None; Py_INCREF(start); if (stop == NULL) stop = Py_None; Py_INCREF(stop); obj->step = step; obj->start = start; obj->stop = stop; _PyObject_GC_TRACK(obj); return (PyObject *) obj; }
static PyObject * gen_new_with_qualname(PyTypeObject *type, PyFrameObject *f, PyObject *name, PyObject *qualname) { PyGenObject *gen = PyObject_GC_New(PyGenObject, type); if (gen == NULL) { Py_DECREF(f); return NULL; } gen->gi_frame = f; f->f_gen = (PyObject *) gen; Py_INCREF(f->f_code); gen->gi_code = (PyObject *)(f->f_code); gen->gi_running = 0; gen->gi_weakreflist = NULL; if (name != NULL) gen->gi_name = name; else gen->gi_name = ((PyCodeObject *)gen->gi_code)->co_name; Py_INCREF(gen->gi_name); if (qualname != NULL) gen->gi_qualname = qualname; else gen->gi_qualname = gen->gi_name; Py_INCREF(gen->gi_qualname); _PyObject_GC_TRACK(gen); return (PyObject *)gen; }
PyObject * PyFunction_NewWithQualName(PyObject *code, PyObject *globals, PyObject *qualname) { PyFunctionObject *op; PyObject *doc, *consts, *module; static PyObject *__name__ = NULL; if (__name__ == NULL) { __name__ = PyUnicode_InternFromString("__name__"); if (__name__ == NULL) return NULL; } op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type); if (op == NULL) return NULL; op->func_weakreflist = NULL; Py_INCREF(code); op->func_code = code; Py_INCREF(globals); op->func_globals = globals; op->func_name = ((PyCodeObject *)code)->co_name; Py_INCREF(op->func_name); op->func_defaults = NULL; /* No default arguments */ op->func_kwdefaults = NULL; /* No keyword only defaults */ op->func_closure = NULL; consts = ((PyCodeObject *)code)->co_consts; if (PyTuple_Size(consts) >= 1) { doc = PyTuple_GetItem(consts, 0); if (!PyUnicode_Check(doc)) doc = Py_None; } else doc = Py_None; Py_INCREF(doc); op->func_doc = doc; op->func_dict = NULL; op->func_module = NULL; op->func_annotations = NULL; /* __module__: If module name is in globals, use it. Otherwise, use None. */ module = PyDict_GetItem(globals, __name__); if (module) { Py_INCREF(module); op->func_module = module; } if (qualname) op->func_qualname = qualname; else op->func_qualname = op->func_name; Py_INCREF(op->func_qualname); _PyObject_GC_TRACK(op); return (PyObject *)op; }
PyObject * PyTuple_New(register Py_ssize_t size) { register PyTupleObject *op; Py_ssize_t i; if (size < 0) { PyErr_BadInternalCall(); return NULL; } #if PyTuple_MAXSAVESIZE > 0 if (size == 0 && free_list[0]) { op = free_list[0]; Py_INCREF(op); #ifdef COUNT_ALLOCS tuple_zero_allocs++; #endif return (PyObject *) op; } if (size < PyTuple_MAXSAVESIZE && (op = free_list[size]) != NULL) { free_list[size] = (PyTupleObject *) op->ob_item[0]; numfree[size]--; #ifdef COUNT_ALLOCS fast_tuple_allocs++; #endif /* Inline PyObject_InitVar */ #ifdef Py_TRACE_REFS Py_SIZE(op) = size; Py_TYPE(op) = &PyTuple_Type; #endif _Py_NewReference((PyObject *)op); } else #endif { Py_ssize_t nbytes = size * sizeof(PyObject *); /* Check for overflow */ if (nbytes / sizeof(PyObject *) != (size_t)size || (nbytes > PY_SSIZE_T_MAX - sizeof(PyTupleObject) - sizeof(PyObject *))) { return PyErr_NoMemory(); } nbytes += sizeof(PyTupleObject) - sizeof(PyObject *); op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size); if (op == NULL) return NULL; } for (i=0; i < size; i++) op->ob_item[i] = NULL; #if PyTuple_MAXSAVESIZE > 0 if (size == 0) { free_list[0] = op; ++numfree[0]; Py_INCREF(op); /* extra INCREF so that this is never freed */ } #endif _PyObject_GC_TRACK(op); return (PyObject *) op; }
PyFrameObject* PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals, PyObject *locals) { PyFrameObject *f = _PyFrame_New_NoTrack(tstate, code, globals, locals); if (f) _PyObject_GC_TRACK(f); return f; }
//pycodeobject 对象和 global名字空间传进来 PyObject * PyFunction_New(PyObject *code, PyObject *globals) { PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type); static PyObject *__name__ = 0; if (op != NULL) { PyObject *doc; PyObject *consts; PyObject *module; op->func_weakreflist = NULL; Py_INCREF(code); op->func_code = code;//PyCodeObject 设置上去 Py_INCREF(globals); op->func_globals = globals; op->func_name = ((PyCodeObject *)code)->co_name; Py_INCREF(op->func_name); //默认参数 op->func_defaults = NULL; /* No default arguments */ //闭包数据 op->func_closure = NULL; consts = ((PyCodeObject *)code)->co_consts; if (PyTuple_Size(consts) >= 1) { //第0项一定是doc了.... doc = PyTuple_GetItem(consts, 0); if (!PyString_Check(doc) && !PyUnicode_Check(doc)) doc = Py_None; } else doc = Py_None; Py_INCREF(doc); op->func_doc = doc; op->func_dict = NULL; op->func_module = NULL; /* __module__: If module name is in globals, use it. Otherwise, use None. */ if (!__name__) { __name__ = PyString_InternFromString("__name__"); if (!__name__) { Py_DECREF(op); return NULL; } } module = PyDict_GetItem(globals, __name__); if (module) { Py_INCREF(module); op->func_module = module; } } else return NULL; _PyObject_GC_TRACK(op); return (PyObject *)op; }
int _PyTuple_Resize(PyObject **pv, Py_ssize_t newsize) { PyTupleObject *v; PyTupleObject *sv; Py_ssize_t i; Py_ssize_t oldsize; v = (PyTupleObject *) *pv; if (v == NULL || Py_TYPE(v) != &PyTuple_Type || (Py_SIZE(v) != 0 && Py_REFCNT(v) != 1)) { *pv = 0; Py_XDECREF(v); PyErr_BadInternalCall(); return -1; } oldsize = Py_SIZE(v); if (oldsize == newsize) return 0; if (oldsize == 0) { /* Empty tuples are often shared, so we should never resize them in-place even if we do own the only (current) reference */ Py_DECREF(v); *pv = PyTuple_New(newsize); return *pv == NULL ? -1 : 0; } /* XXX UNREF/NEWREF interface should be more symmetrical */ _Py_DEC_REFTOTAL; if (_PyObject_GC_IS_TRACKED(v)) _PyObject_GC_UNTRACK(v); _Py_ForgetReference((PyObject *) v); /* DECREF items deleted by shrinkage */ for (i = newsize; i < oldsize; i++) { Py_XDECREF(v->ob_item[i]); v->ob_item[i] = NULL; } sv = PyObject_GC_Resize(PyTupleObject, v, newsize); if (sv == NULL) { *pv = NULL; PyObject_GC_Del(v); return -1; } _Py_NewReference((PyObject *) sv); /* Zero out items added by growing */ if (newsize > oldsize) memset(&sv->ob_item[oldsize], 0, sizeof(*sv->ob_item) * (newsize - oldsize)); *pv = (PyObject *) sv; _PyObject_GC_TRACK(sv); return 0; }
PyObject * PyInstanceMethod_New(PyObject *func) { PyInstanceMethodObject *method; method = PyObject_GC_New(PyInstanceMethodObject, &PyInstanceMethod_Type); if (method == NULL) return NULL; Py_INCREF(func); method->func = func; _PyObject_GC_TRACK(method); return (PyObject *)method; }
static PyObject * coro_await(PyCoroObject *coro) { PyCoroWrapper *cw = PyObject_GC_New(PyCoroWrapper, &_PyCoroWrapper_Type); if (cw == NULL) { return NULL; } Py_INCREF(coro); cw->cw_coroutine = coro; _PyObject_GC_TRACK(cw); return (PyObject *)cw; }
PyObject * PyCell_New(PyObject *obj) { PyCellObject *op; op = (PyCellObject *)PyObject_GC_New(PyCellObject, &PyCell_Type); op->ob_ref = obj; Py_XINCREF(obj); _PyObject_GC_TRACK(op); return (PyObject *)op; }
PyObject * PyDictProxy_New(PyObject *dict) { proxyobject *pp; pp = PyObject_GC_New(proxyobject, &proxytype); if (pp != NULL) { Py_INCREF(dict); pp->dict = dict; _PyObject_GC_TRACK(pp); } return (PyObject *)pp; }
PyObject * PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module) { PyCFunctionObject *op; // Sanity check early, to avoid having to clean up from the mixed // free list/allocation scheme below. if (ml->ml_flags & METH_ARG_RANGE) { if (ml->ml_min_arity < 0 || ml->ml_min_arity > PY_MAX_ARITY || ml->ml_max_arity < 0 || ml->ml_max_arity > PY_MAX_ARITY || ml->ml_max_arity < ml->ml_min_arity) { PyErr_BadInternalCall(); return NULL; } } op = free_list; if (op != NULL) { free_list = (PyCFunctionObject *)(op->m_self); PyObject_INIT(op, &PyCFunction_Type); numfree--; } else { op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type); if (op == NULL) return NULL; } /* Rewrite the old METH_O/METH_NOARGS flags to the new METH_ARG_RANGE so we only have to implement METH_ARG_RANGE. */ if (ml->ml_flags & METH_NOARGS) { ml->ml_flags &= ~METH_NOARGS; ml->ml_flags |= METH_ARG_RANGE; ml->ml_min_arity = 0; ml->ml_max_arity = 0; } else if (ml->ml_flags & METH_O) { ml->ml_flags &= ~METH_O; ml->ml_flags |= METH_ARG_RANGE; ml->ml_min_arity = 1; ml->ml_max_arity = 1; } op->m_ml = ml; Py_XINCREF(self); op->m_self = self; Py_XINCREF(module); op->m_module = module; _PyObject_GC_TRACK(op); return (PyObject *)op; }
static PyContext * context_new_from_vars(PyHamtObject *vars) { PyContext *ctx = _context_alloc(); if (ctx == NULL) { return NULL; } Py_INCREF(vars); ctx->ctx_vars = vars; _PyObject_GC_TRACK(ctx); return ctx; }
PyObject * PyCallIter_New(PyObject *callable, PyObject *sentinel) { calliterobject *it; it = PyObject_GC_New(calliterobject, &PyCallIter_Type); if (it == NULL) return NULL; Py_INCREF(callable); it->it_callable = callable; Py_INCREF(sentinel); it->it_sentinel = sentinel; _PyObject_GC_TRACK(it); return (PyObject *)it; }
PyObject * PyGen_New(PyFrameObject *f) { PyGenObject *gen = PyObject_GC_New(PyGenObject, &PyGen_Type); if (gen == NULL) { Py_DECREF(f); return NULL; } gen->gi_frame = f; Py_INCREF(f->f_code); gen->gi_code = (PyObject *)(f->f_code); gen->gi_running = 0; gen->gi_weakreflist = NULL; _PyObject_GC_TRACK(gen); return (PyObject *)gen; }
static PyContext * context_new_empty(void) { PyContext *ctx = _context_alloc(); if (ctx == NULL) { return NULL; } ctx->ctx_vars = _PyHamt_New(); if (ctx->ctx_vars == NULL) { Py_DECREF(ctx); return NULL; } _PyObject_GC_TRACK(ctx); return ctx; }
static PyObject * record_iter(PyObject *seq) { ApgRecordIterObject *it; if (!ApgRecord_CheckExact(seq)) { PyErr_BadInternalCall(); return NULL; } it = PyObject_GC_New(ApgRecordIterObject, &ApgRecordIter_Type); if (it == NULL) return NULL; it->it_index = 0; Py_INCREF(seq); it->it_seq = (ApgRecordObject *)seq; _PyObject_GC_TRACK(it); return (PyObject *)it; }
static PyObject * tuple_iter(PyObject *seq) { tupleiterobject *it; if (!PyTuple_Check(seq)) { PyErr_BadInternalCall(); return NULL; } it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type); if (it == NULL) return NULL; it->it_index = 0; Py_INCREF(seq); it->it_seq = (PyTupleObject *)seq; _PyObject_GC_TRACK(it); return (PyObject *)it; }
PyObject * PySeqIter_New(PyObject *seq) { seqiterobject *it; if (!PySequence_Check(seq)) { PyErr_BadInternalCall(); return NULL; } it = PyObject_GC_New(seqiterobject, &PySeqIter_Type); if (it == NULL) return NULL; it->it_index = 0; Py_INCREF(seq); it->it_seq = seq; _PyObject_GC_TRACK(it); return (PyObject *)it; }
PyObject * PyWrapper_New(PyObject *d, PyObject *self) { wrapperobject *wp; PyWrapperDescrObject *descr; assert(PyObject_TypeCheck(d, &PyWrapperDescr_Type)); descr = (PyWrapperDescrObject *)d; assert(PyObject_IsInstance(self, (PyObject *)(descr->d_type))); wp = PyObject_GC_New(wrapperobject, &wrappertype); if (wp != NULL) { Py_INCREF(descr); wp->descr = descr; Py_INCREF(self); wp->self = self; _PyObject_GC_TRACK(wp); } return (PyObject *)wp; }
static tracebackobject * newtracebackobject(tracebackobject *next, PyFrameObject *frame, int lasti, int lineno) { tracebackobject *tb; if ((next != NULL && !PyTraceBack_Check(next)) || frame == NULL || !PyFrame_Check(frame)) { PyErr_BadInternalCall(); return NULL; } tb = PyObject_GC_New(tracebackobject, &PyTraceBack_Type); if (tb != NULL) { Py_XINCREF(next); tb->tb_next = next; Py_XINCREF(frame); tb->tb_frame = frame; tb->tb_lasti = lasti; tb->tb_lineno = lineno; _PyObject_GC_TRACK(tb); } return tb; }
static void gen_dealloc(PyGenObject *gen) { PyObject *self = (PyObject *) gen; _PyObject_GC_UNTRACK(gen); if (gen->gi_weakreflist != NULL) PyObject_ClearWeakRefs(self); _PyObject_GC_TRACK(self); if (PyObject_CallFinalizerFromDealloc(self)) return; /* resurrected. :( */ _PyObject_GC_UNTRACK(self); Py_CLEAR(gen->gi_frame); Py_CLEAR(gen->gi_code); Py_CLEAR(gen->gi_name); Py_CLEAR(gen->gi_qualname); PyObject_GC_Del(gen); }
PyObject * PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module) { PyCFunctionObject *op; op = free_list; if (op != NULL) { free_list = (PyCFunctionObject *)(op->m_self); PyObject_INIT(op, &PyCFunction_Type); } else { op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type); if (op == NULL) return NULL; } op->m_ml = ml; Py_XINCREF(self); op->m_self = self; Py_XINCREF(module); op->m_module = module; _PyObject_GC_TRACK(op); return (PyObject *)op; }
PyObject * ApgRecord_New(PyObject *mapping, Py_ssize_t size) { ApgRecordObject *o; Py_ssize_t i; if (size < 1 || mapping == NULL) { PyErr_BadInternalCall(); return NULL; } if (size < ApgRecord_MAXSAVESIZE && (o = free_list[size]) != NULL) { free_list[size] = (ApgRecordObject *) o->ob_item[0]; numfree[size]--; _Py_NewReference((PyObject *)o); } else { /* Check for overflow */ if ((size_t)size > ((size_t)PY_SSIZE_T_MAX - sizeof(ApgRecordObject) - sizeof(PyObject *)) / sizeof(PyObject *)) { return PyErr_NoMemory(); } o = PyObject_GC_NewVar(ApgRecordObject, &ApgRecord_Type, size); if (o == NULL) { return NULL; } } for (i = 0; i < size; i++) { o->ob_item[i] = NULL; } Py_INCREF(mapping); o->mapping = mapping; o->self_hash = -1; _PyObject_GC_TRACK(o); return (PyObject *) o; }
static void gen_dealloc(PyGenObject *gen) { PyObject *self = (PyObject *) gen; _PyObject_GC_UNTRACK(gen); if (gen->gi_weakreflist != NULL) PyObject_ClearWeakRefs(self); _PyObject_GC_TRACK(self); if (gen->gi_frame != NULL && gen->gi_frame->f_stacktop != NULL) { /* Generator is paused, so we need to close */ Py_TYPE(gen)->tp_del(self); if (self->ob_refcnt > 0) return; /* resurrected. :( */ } _PyObject_GC_UNTRACK(self); Py_CLEAR(gen->gi_frame); Py_CLEAR(gen->gi_code); PyObject_GC_Del(gen); }