static PyTracebackObject * newtracebackobject(PyTracebackObject *next, PyFrameObject *frame) { PyTracebackObject *tb; if ((next != NULL && !PyTraceBack_Check(next)) || frame == NULL || !PyFrame_Check(frame)) { PyErr_BadInternalCall(); return NULL; } tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type); if (tb != NULL) { Py_XINCREF(next); tb->tb_next = next; Py_XINCREF(frame); tb->tb_frame = (struct _frame *)frame; // Pyston change: we don't have tb_lasti // tb->tb_lasti = frame->f_lasti; tb->tb_lasti = -1; tb->tb_lineno = PyFrame_GetLineNumber(frame); PyObject_GC_Track(tb); } return tb; }
static __pyx_GeneratorObject *__Pyx_Generator_New(__pyx_generator_body_t body, PyObject *closure) { __pyx_GeneratorObject *gen = PyObject_GC_New(__pyx_GeneratorObject, &__pyx_GeneratorType_type); if (gen == NULL) return NULL; gen->body = body; gen->closure = closure; Py_XINCREF(closure); gen->is_running = 0; gen->resume_label = 0; gen->classobj = NULL; gen->yieldfrom = NULL; gen->exc_type = NULL; gen->exc_value = NULL; gen->exc_traceback = NULL; gen->gi_weakreflist = NULL; PyObject_GC_Track(gen); return 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); numfree--; } 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; }
static PyObject * csv_writer(PyObject *module, PyObject *args, PyObject *keyword_args) { PyObject * output_file, * dialect = NULL; WriterObj * self = PyObject_GC_New(WriterObj, &Writer_Type); _Py_IDENTIFIER(write); if (!self) return NULL; self->dialect = NULL; self->writeline = NULL; self->rec = NULL; self->rec_size = 0; self->rec_len = 0; self->num_fields = 0; if (!PyArg_UnpackTuple(args, "", 1, 2, &output_file, &dialect)) { Py_DECREF(self); return NULL; } self->writeline = _PyObject_GetAttrId(output_file, &PyId_write); if (self->writeline == NULL || !PyCallable_Check(self->writeline)) { PyErr_SetString(PyExc_TypeError, "argument 1 must have a \"write\" method"); Py_DECREF(self); return NULL; } self->dialect = (DialectObj *)_call_dialect(dialect, keyword_args); if (self->dialect == NULL) { Py_DECREF(self); return NULL; } PyObject_GC_Track(self); return (PyObject *)self; }
static PyObject *NumbaFunction_New( PyTypeObject *type, PyMethodDef *ml, int flags, PyObject *closure, PyObject *module, PyObject *code, PyObject *keep_alive) { NumbaFunctionObject *op = PyObject_GC_New(NumbaFunctionObject, type); if (op == NULL) return NULL; op->flags = flags; op->func_weakreflist = NULL; op->func.m_ml = ml; op->func.m_self = (PyObject *) op; /* No incref or decref here */ Py_XINCREF(closure); op->func_closure = closure; Py_XINCREF(module); op->func.m_module = module; op->func_dict = NULL; op->func_name = NULL; op->func_doc = NULL; op->func_classobj = NULL; Py_XINCREF(code); op->func_code = code; /* Dynamic Default args */ op->defaults_pyobjects = 0; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_getter = NULL; Py_XINCREF(keep_alive); op->keep_alive = keep_alive; op->native_func = NULL; op->native_signature = NULL; PyObject_GC_Track(op); return (PyObject *) op; }
PyObject *Nuitka_Method_New( Nuitka_FunctionObject *function, PyObject *object, PyObject *klass ) { Nuitka_MethodObject *result = method_cache_head; if ( result != NULL ) { method_cache_head = (Nuitka_MethodObject *)method_cache_head->m_object; method_cache_size -= 1; PyObject_INIT( result, &Nuitka_Method_Type ); } else { result = PyObject_GC_New( Nuitka_MethodObject, &Nuitka_Method_Type ); } if (unlikely( result == NULL )) { PyErr_Format( PyExc_RuntimeError, "cannot create method %s", Nuitka_String_AsString( function->m_name ) ); return NULL; } result->m_function = (Nuitka_FunctionObject * )INCREASE_REFCOUNT( (PyObject *)function ); result->m_object = INCREASE_REFCOUNT_X( object ); result->m_class = INCREASE_REFCOUNT_X( klass ); result->m_weakrefs = NULL; Nuitka_GC_Track( result ); return (PyObject *)result; }
static PyContextVar * contextvar_new(PyObject *name, PyObject *def) { if (!PyUnicode_Check(name)) { PyErr_SetString(PyExc_TypeError, "context variable name must be a str"); return NULL; } PyContextVar *var = PyObject_GC_New(PyContextVar, &PyContextVar_Type); if (var == NULL) { return NULL; } var->var_hash = contextvar_generate_hash(var, name); if (var->var_hash == -1) { Py_DECREF(var); return NULL; } Py_INCREF(name); var->var_name = name; Py_XINCREF(def); var->var_default = def; var->var_cached = NULL; var->var_cached_tsid = 0; var->var_cached_tsver = 0; if (_PyObject_GC_MAY_BE_TRACKED(name) || (def != NULL && _PyObject_GC_MAY_BE_TRACKED(def))) { PyObject_GC_Track(var); } return var; }
/* pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER * (i.e. it was allocated elsewhere by MEM_mallocN()) * pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON * (i.e. it must be created here with PyMEM_malloc())*/ PyObject *Euler_CreatePyObject(float eul[3], const short order, int type, PyTypeObject *base_type) { EulerObject *self; self = base_type ? (EulerObject *)base_type->tp_alloc(base_type, 0) : (EulerObject *)PyObject_GC_New(EulerObject, &euler_Type); if (self) { /* init callbacks as NULL */ self->cb_user = NULL; self->cb_type = self->cb_subtype = 0; if (type == Py_WRAP) { self->eul = eul; self->wrapped = Py_WRAP; } else if (type == Py_NEW) { self->eul = PyMem_Malloc(EULER_SIZE * sizeof(float)); if (eul) { copy_v3_v3(self->eul, eul); } else { zero_v3(self->eul); } self->wrapped = Py_NEW; } else { Py_FatalError("Euler(): invalid type!"); } self->order = order; } return (PyObject *)self; }
static PyObject * attr_iter_new(attr_dir_object *attr_dir, PyTypeObject *itertype) { attr_iter_object *self; kdump_ctx *ctx = attr_dir->kdumpfile->ctx; kdump_status status; self = PyObject_GC_New(attr_iter_object, itertype); if (self == NULL) return NULL; status = kdump_attr_ref_iter_start(ctx, &attr_dir->baseref, &self->iter); if (status != kdump_ok) { PyErr_Format(exception_map(status), kdump_err_str(ctx)); Py_DECREF(self); return NULL; } Py_INCREF((PyObject*)attr_dir->kdumpfile); self->kdumpfile = attr_dir->kdumpfile; PyObject_GC_Track(self); return (PyObject*)self; }
static PyObject * CSVParser_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { Engine *engine; PyObject *pyfile = NULL; PyObject *map = NULL; ColMap *colmap = NULL; char delimiter = ','; char quotechar = '"'; CSVParser * self = PyObject_GC_New(CSVParser, &CSVParser_Type); if (self == NULL){ return NULL; } if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!OO|cc", parser_kws, &Logq_Engine_Type, &engine, &pyfile, &map, &delimiter, "echar)){ return NULL; } Py_INCREF(pyfile); Py_INCREF(engine); self->engine = engine; if(PyFile_Check(pyfile)){ self->file = PyFile_AsFile(pyfile); self->is_file = 1; self->pyfile = pyfile; }else{ self->file = NULL; self->is_file = 0; self->pyfile = PyObject_GetIter(pyfile); if (self->pyfile == NULL) { PyErr_SetString(PyExc_TypeError, "argument 1 must be an iterator"); return NULL; } } if(!PySequence_Check(map)){ PyErr_SetString(PyExc_TypeError, "argument 2 must be a list"); return NULL; } colmap = ColMap_new(map); if (colmap == NULL) { PyErr_SetString(PyExc_TypeError, "argument 2 must be a list"); return NULL; } self->colmap = colmap; self->fields = NULL; self->field = NULL; self->field_size = 0; self->line_num = 0; self->delimiter = delimiter; self->quotechar = quotechar; if (parse_reset(self) < 0) { Py_DECREF(pyfile); Py_DECREF(engine); Py_DECREF(self); return NULL; } PyObject_GC_Track(self); return (PyObject *)self; }
svms_ConstraintsObject *Constraints_FromConstraints(CONSTSET cset) { svms_ConstraintsObject*so = (svms_ConstraintsObject*) PyObject_GC_New(svms_ConstraintsObject, &svms_ConstraintsType); so->cset = cset; return so; }
static PyObject *fparse_function_1_inner_of_function_1_permalink_of_module_django__db__models( Nuitka_FunctionObject *self, PyObject **args, Py_ssize_t args_size, PyObject *kw ) { assert( kw == NULL || PyDict_Check( kw ) ); NUITKA_MAY_BE_UNUSED Py_ssize_t kw_size = kw ? PyDict_Size( kw ) : 0; NUITKA_MAY_BE_UNUSED Py_ssize_t kw_found = 0; NUITKA_MAY_BE_UNUSED Py_ssize_t kw_only_found = 0; Py_ssize_t args_given = args_size; PyObject *_python_par_args = NULL; PyObject *_python_par_kwargs = NULL; if ( kw == NULL ) { _python_par_kwargs = PyDict_New(); } else { if ( ((PyDictObject *)kw)->ma_used > 0 ) { #if PYTHON_VERSION < 330 _python_par_kwargs = _PyDict_NewPresized( ((PyDictObject *)kw)->ma_used ); for ( int i = 0; i <= ((PyDictObject *)kw)->ma_mask; i++ ) { PyDictEntry *entry = &((PyDictObject *)kw)->ma_table[ i ]; if ( entry->me_value != NULL ) { #if PYTHON_VERSION < 300 if (unlikely( !PyString_Check( entry->me_key ) && !PyUnicode_Check( entry->me_key ) )) #else if (unlikely( !PyUnicode_Check( entry->me_key ) )) #endif { PyErr_Format( PyExc_TypeError, "inner() keywords must be strings" ); goto error_exit; } int res = PyDict_SetItem( _python_par_kwargs, entry->me_key, entry->me_value ); if (unlikely( res == -1 )) { goto error_exit; } } } #else if ( _PyDict_HasSplitTable( ((PyDictObject *)kw) ) ) { PyDictObject *mp = (PyDictObject *)kw; PyObject **newvalues = PyMem_NEW( PyObject *, mp->ma_keys->dk_size ); assert (newvalues != NULL); PyDictObject *split_copy = PyObject_GC_New( PyDictObject, &PyDict_Type ); assert( split_copy != NULL ); split_copy->ma_values = newvalues; split_copy->ma_keys = mp->ma_keys; split_copy->ma_used = mp->ma_used; mp->ma_keys->dk_refcnt += 1; Nuitka_GC_Track( split_copy ); int size = mp->ma_keys->dk_size; for ( int i = 0; i < size; i++ ) { PyDictKeyEntry *entry = &split_copy->ma_keys->dk_entries[ i ]; if (unlikely( !PyUnicode_Check( entry->me_key ) )) { PyErr_Format( PyExc_TypeError, "inner() keywords must be strings" ); goto error_exit; } split_copy->ma_values[ i ] = INCREASE_REFCOUNT_X( mp->ma_values[ i ] ); } _python_par_kwargs = (PyObject *)split_copy; } else {
static int __Pyx_Generator_set_qualname(__pyx_GeneratorObject *self, PyObject *value) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) { #else if (unlikely(value == NULL || !PyString_Check(value))) { #endif PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } tmp = self->gi_qualname; Py_INCREF(value); self->gi_qualname = value; Py_XDECREF(tmp); return 0; } static PyGetSetDef __pyx_Generator_getsets[] = { {(char *) "__name__", (getter)__Pyx_Generator_get_name, (setter)__Pyx_Generator_set_name, (char*) PyDoc_STR("name of the generator"), 0}, {(char *) "__qualname__", (getter)__Pyx_Generator_get_qualname, (setter)__Pyx_Generator_set_qualname, (char*) PyDoc_STR("qualified name of the generator"), 0}, {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_Generator_memberlist[] = { {(char *) "gi_running", T_BOOL, offsetof(__pyx_GeneratorObject, is_running), READONLY, NULL}, {0, 0, 0, 0, 0} }; static PyMethodDef __pyx_Generator_methods[] = { {"send", (PyCFunction) __Pyx_Generator_Send, METH_O, 0}, {"throw", (PyCFunction) __Pyx_Generator_Throw, METH_VARARGS, 0}, {"close", (PyCFunction) __Pyx_Generator_Close, METH_NOARGS, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_GeneratorType_type = { PyVarObject_HEAD_INIT(0, 0) "generator", /*tp_name*/ sizeof(__pyx_GeneratorObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ (destructor) __Pyx_Generator_dealloc,/*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ 0, /*tp_doc*/ (traverseproc) __Pyx_Generator_traverse, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ offsetof(__pyx_GeneratorObject, gi_weakreflist), /*tp_weaklistoffset*/ 0, /*tp_iter*/ (iternextfunc) __Pyx_Generator_Next, /*tp_iternext*/ __pyx_Generator_methods, /*tp_methods*/ __pyx_Generator_memberlist, /*tp_members*/ __pyx_Generator_getsets, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ 0, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_del*/ #else __Pyx_Generator_del, /*tp_del*/ #endif 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 __Pyx_Generator_del, /*tp_finalize*/ #endif }; static __pyx_GeneratorObject *__Pyx_Generator_New(__pyx_generator_body_t body, PyObject *closure, PyObject *name, PyObject *qualname) { __pyx_GeneratorObject *gen = PyObject_GC_New(__pyx_GeneratorObject, &__pyx_GeneratorType_type); if (gen == NULL) return NULL; gen->body = body; gen->closure = closure; Py_XINCREF(closure); gen->is_running = 0; gen->resume_label = 0; gen->classobj = NULL; gen->yieldfrom = NULL; gen->exc_type = NULL; gen->exc_value = NULL; gen->exc_traceback = NULL; gen->gi_weakreflist = NULL; Py_XINCREF(qualname); gen->gi_qualname = qualname; Py_XINCREF(name); gen->gi_name = name; PyObject_GC_Track(gen); return gen; }
/* * Constructor for PKCS12 objects, never called by Python code directly. * The strategy for this object is to create all the Python objects * corresponding to the cert/key/CA certs right away * * Arguments: p12 - A "real" PKCS12 object or NULL * passphrase - Passphrase to use when decrypting the PKCS12 object * Returns: The newly created PKCS12 object */ crypto_PKCS12Obj * crypto_PKCS12_New(PKCS12 *p12, char *passphrase) { crypto_PKCS12Obj *self = NULL; PyObject *cacertobj = NULL; unsigned char *alias_str; int alias_len; X509 *cert = NULL; EVP_PKEY *pkey = NULL; STACK_OF(X509) *cacerts = NULL; int i, cacert_count = 0; /* allocate space for the CA cert stack */ if((cacerts = sk_X509_new_null()) == NULL) { goto error; /* out of memory? */ } /* parse the PKCS12 lump */ if (p12) { if (!PKCS12_parse(p12, passphrase, &pkey, &cert, &cacerts)) { /* * If PKCS12_parse fails, and it allocated cacerts, it seems to * free cacerts, but not re-NULL the pointer. Zounds! Make sure * it is re-set to NULL here, else we'll have a double-free below. */ cacerts = NULL; exception_from_error_queue(crypto_Error); goto error; } else { /* * OpenSSL 1.0.0 sometimes leaves an X509_check_private_key error in * the queue for no particular reason. This error isn't interesting * to anyone outside this function. It's not even interesting to * us. Get rid of it. */ flush_error_queue(); } } if (!(self = PyObject_GC_New(crypto_PKCS12Obj, &crypto_PKCS12_Type))) { goto error; } /* client certificate and friendlyName */ if (cert == NULL) { Py_INCREF(Py_None); self->cert = Py_None; Py_INCREF(Py_None); self->friendlyname = Py_None; } else { if ((self->cert = (PyObject *)crypto_X509_New(cert, 1)) == NULL) { goto error; } /* Now we need to extract the friendlyName of the PKCS12 * that was stored by PKCS_parse() in the alias of the * certificate. */ alias_str = X509_alias_get0(cert, &alias_len); if (alias_str) { self->friendlyname = Py_BuildValue(BYTESTRING_FMT "#", alias_str, alias_len); if (!self->friendlyname) { /* * XXX Untested */ goto error; } /* success */ } else { Py_INCREF(Py_None); self->friendlyname = Py_None; } } /* private key */ if (pkey == NULL) { Py_INCREF(Py_None); self->key = Py_None; } else { if ((self->key = (PyObject *)crypto_PKey_New(pkey, 1)) == NULL) goto error; } /* CA certs */ cacert_count = sk_X509_num(cacerts); if (cacert_count <= 0) { Py_INCREF(Py_None); self->cacerts = Py_None; } else { if ((self->cacerts = PyTuple_New(cacert_count)) == NULL) { goto error; } for (i = 0; i < cacert_count; i++) { cert = sk_X509_value(cacerts, i); if ((cacertobj = (PyObject *)crypto_X509_New(cert, 1)) == NULL) { goto error; } PyTuple_SET_ITEM(self->cacerts, i, cacertobj); } } sk_X509_free(cacerts); /* Don't free the certs, just the container. */ PyObject_GC_Track(self); return self; error: sk_X509_free(cacerts); /* NULL safe. Free just the container. */ if (self) { crypto_PKCS12_clear(self); PyObject_GC_Del(self); } return NULL; }
static PyObject * bounded_lru_cache_wrapper(lru_cache_object *self, PyObject *args, PyObject *kwds) { lru_list_elem *link; PyObject *key, *result; Py_hash_t hash; key = lru_cache_make_key(args, kwds, self->typed); if (!key) return NULL; hash = PyObject_Hash(key); if (hash == -1) { Py_DECREF(key); return NULL; } link = (lru_list_elem *)_PyDict_GetItem_KnownHash(self->cache, key, hash); if (link) { lru_cache_extricate_link(link); lru_cache_append_link(self, link); self->hits++; result = link->result; Py_INCREF(result); Py_DECREF(key); return result; } if (PyErr_Occurred()) { Py_DECREF(key); return NULL; } result = PyObject_Call(self->func, args, kwds); if (!result) { Py_DECREF(key); return NULL; } if (self->full && self->root.next != &self->root) { /* Use the oldest item to store the new key and result. */ PyObject *oldkey, *oldresult; /* Extricate the oldest item. */ link = self->root.next; lru_cache_extricate_link(link); /* Remove it from the cache. The cache dict holds one reference to the link, and the linked list holds yet one reference to it. */ if (_PyDict_DelItem_KnownHash(self->cache, link->key, link->hash) < 0) { lru_cache_append_link(self, link); Py_DECREF(key); Py_DECREF(result); return NULL; } /* Keep a reference to the old key and old result to prevent their ref counts from going to zero during the update. That will prevent potentially arbitrary object clean-up code (i.e. __del__) from running while we're still adjusting the links. */ oldkey = link->key; oldresult = link->result; link->hash = hash; link->key = key; link->result = result; if (_PyDict_SetItem_KnownHash(self->cache, key, (PyObject *)link, hash) < 0) { Py_DECREF(link); Py_DECREF(oldkey); Py_DECREF(oldresult); return NULL; } lru_cache_append_link(self, link); Py_INCREF(result); /* for return */ Py_DECREF(oldkey); Py_DECREF(oldresult); } else { /* Put result in a new link at the front of the queue. */ link = (lru_list_elem *)PyObject_GC_New(lru_list_elem, &lru_list_elem_type); if (link == NULL) { Py_DECREF(key); Py_DECREF(result); return NULL; } link->hash = hash; link->key = key; link->result = result; _PyObject_GC_TRACK(link); if (_PyDict_SetItem_KnownHash(self->cache, key, (PyObject *)link, hash) < 0) { Py_DECREF(link); return NULL; } lru_cache_append_link(self, link); Py_INCREF(result); /* for return */ self->full = (PyDict_GET_SIZE(self->cache) >= self->maxsize); } self->misses++; return result; }
svms_KernelParmObject *KernelParm_FromKernelParm(KERNEL_PARM *kp) { svms_KernelParmObject*so = (svms_KernelParmObject*) PyObject_GC_New(svms_KernelParmObject, &svms_KernelParmType); so->kparm = kp; return so; }
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_GetItemWithError(globals, __name__); if (module) { Py_INCREF(module); op->func_module = module; } else if (PyErr_Occurred()) { Py_DECREF(op); return NULL; } 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; }
} int DomainDepot_clear(TPyDomainDepot *self) { return 0; } PyObject *DomainDepot_new(PyTypeObject *type, PyObject *args, PyObject *) BASED_ON(ROOT, "() -> DomainDepot") { PyTRY if (args && PyTuple_Size(args)) PYERROR(PyExc_TypeError, "no arguments expected", PYNULL); TPyDomainDepot *dd = PyObject_GC_New(TPyDomainDepot, type); if (!dd) return PYNULL; dd->domainDepot = mlnew TDomainDepot; PyObject_GC_Track(dd); return (PyObject *)dd; PyCATCH } bool convertMetasFromPython(PyObject *dict, TMetaVector &metas); bool decodeDescriptors(PyObject *pynames, TDomainDepot::TAttributeDescriptions &attributeDescriptions,
svms_SampleObject *Sample_FromSample(SAMPLE sample) { svms_SampleObject*so = (svms_SampleObject*) PyObject_GC_New(svms_SampleObject, &svms_SampleType); so->sample = sample; return so; }