{

PyObject *get = NULL, *set = NULL, *del = NULL, *doc = NULL;

static const char *kwlist[] = {"fget", "fset", "fdel", "doc", 0};

propertyobject *prop = (propertyobject *)self;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO:property",

const_cast<char **>(kwlist), &get, &set, &del, &doc))

return -1;

if (get == Py_None)

get = NULL;

if (set == Py_None)

set = NULL;

if (del == Py_None)

del = NULL;

Py_XINCREF(get);

Py_XINCREF(set);

Py_XINCREF(del);

Py_XINCREF(doc);

prop->prop_get = get;

prop->prop_set = set;

prop->prop_del = del;

prop->prop_doc = doc;

prop->getter_doc = 0;

return 0;

{

propertyobject *gs = (propertyobject *)self;

PyObject *func, *res;

if (value == NULL)

func = gs->prop_del;

else

func = gs->prop_set;

if (func == NULL) {

PyErr_SetString(PyExc_AttributeError,

value == NULL ?

"can't delete attribute" :

"can't set attribute");

return -1;

}

if (value == NULL)

res = PyObject_CallFunction(func, const_cast<char*>("()"));

else

res = PyObject_CallFunction(func, const_cast<char*>("(O)"), value);

if (res == NULL)

return -1;

Py_DECREF(res);

return 0;

{

// Must use "private" Python implementation detail

// _PyType_Lookup instead of PyObject_GetAttr because the

// latter will always end up calling the descr_get function on

// any descriptor it finds; we need the unadulterated

// descriptor here.

PyObject* a = _PyType_Lookup(downcast<PyTypeObject>(obj), name);

// a is a borrowed reference or 0

// If we found a static data descriptor, call it directly to

// force it to set the static data member

if (a != 0 && PyObject_IsInstance(a, objects::static_data()))

return Py_TYPE(a)->tp_descr_set(a, obj, value);

else

return PyType_Type.tp_setattro(obj, name, value);

{

assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self)), &class_metatype_object));

m_next = ((objects::instance<>*)self)->objects;

((objects::instance<>*)self)->objects = this;

{

if (class_metatype_object.tp_dict == 0)

{

Py_SET_TYPE(&class_metatype_object, &PyType_Type);

class_metatype_object.tp_base = &PyType_Type;

if (PyType_Ready(&class_metatype_object))

return type_handle();

}

return type_handle(borrowed(&class_metatype_object));

{

instance<>* kill_me = (instance<>*)inst;

for (instance_holder* p = kill_me->objects, *next; p != 0; p = next)

{

next = p->next();

p->~instance_holder();

instance_holder::deallocate(inst, dynamic_cast<void*>(p));

}

// Python 2.2.1 won't add weak references automatically when

// tp_itemsize > 0, so we need to manage that

// ourselves. Accordingly, we also have to clean up the

// weakrefs ourselves.

if (kill_me->weakrefs != NULL)

PyObject_ClearWeakRefs(inst);

Py_XDECREF(kill_me->dict);

Py_TYPE(inst)->tp_free(inst);

{

instance<>* inst = downcast<instance<> >(op);

python::xdecref(inst->dict);

inst->dict = python::incref(dict);

return 0;

{

if (class_type_object.tp_dict == 0)

{

Py_SET_TYPE(&class_type_object, incref(class_metatype().get()));

class_type_object.tp_base = &PyBaseObject_Type;

if (PyType_Ready(&class_type_object))

return type_handle();

}

return type_handle(borrowed(&class_type_object));

{

return object(

PyObject_IsInstance(scope().ptr(), upcast<PyObject>(&PyModule_Type))

? object(scope().attr("__name__"))

: api::getattr(scope(), "__module__", str())

);

{

converter::registration const* p = converter::registry::query(id);

return type_handle(

python::borrowed(

python::allow_null(p ? p->m_class_object : 0))

);

{

type_handle result(query_class(id));

if (result.get() == 0)

{

object report("extension class wrapper for base class ");

report = report + id.name() + " has not been created yet";

PyErr_SetObject(PyExc_RuntimeError, report.ptr());

throw_error_already_set();

}

return result;

{

assert(num_types >= 1);

// Build a tuple of the base Python type objects. If no bases

// were declared, we'll use our class_type() as the single base

// class.

ssize_t const num_bases = (std::max)(num_types - 1, static_cast<std::size_t>(1));

handle<> bases(PyTuple_New(num_bases));

for (ssize_t i = 1; i <= num_bases; ++i)

{

type_handle c = (i >= static_cast<ssize_t>(num_types)) ? class_type() : get_class(types[i]);

// PyTuple_SET_ITEM steals this reference

PyTuple_SET_ITEM(bases.get(), static_cast<ssize_t>(i - 1), upcast<PyObject>(c.release()));

}

// Call the class metatype to create a new class

dict d;

object m = module_prefix();

if (m) d["__module__"] = m;

if (doc != 0)

d["__doc__"] = doc;

object result = object(class_metatype())(name, bases, d);

assert(PyType_IsSubtype(Py_TYPE(result.ptr()), &PyType_Type));

if (scope().ptr() != Py_None)

scope().attr(name) = result;

// For pickle. Will lead to informative error messages if pickling

// is not enabled.

result.attr("__reduce__") = object(make_instance_reduce_function());

return result;

char const* name, std::size_t num_types, type_info const* const types, char const* doc)

: object(new_class(name, num_types, types, doc))

{

// Insert the new class object in the registry

converter::registration& converters = const_cast<converter::registration&>(

converter::registry::lookup(types[0]));

// Class object is leaked, for now

converters.m_class_object = (PyTypeObject*)incref(this->ptr());

{

converter::registration& dst_converters

= const_cast<converter::registration&>(converter::registry::lookup(dst));

converter::registration const& src_converters = converter::registry::lookup(src);

dst_converters.m_class_object = src_converters.m_class_object;

char const* name, object const& fget, char const* docstr)

{

object property(

(python::detail::new_reference)

PyObject_CallFunction((PyObject*)&PyProperty_Type, const_cast<char*>("Osss"), fget.ptr(), (char*)NULL, (char*)NULL, docstr));

this->setattr(name, property);

char const* name, object const& fget, object const& fset, char const* docstr)

{

object property(

(python::detail::new_reference)

PyObject_CallFunction((PyObject*)&PyProperty_Type, const_cast<char*>("OOss"), fget.ptr(), fset.ptr(), (char*)NULL, docstr));

this->setattr(name, property);

{

object property(

(python::detail::new_reference)

PyObject_CallFunction(static_data(), const_cast<char*>("O"), fget.ptr())

);

this->setattr(name, property);

{

object property(

(python::detail::new_reference)

PyObject_CallFunction(static_data(), const_cast<char*>("OO"), fget.ptr(), fset.ptr()));

this->setattr(name, property);

{

if (PyObject_SetAttrString(this->ptr(), const_cast<char*>(name), x.ptr()) < 0)

throw_error_already_set();

{

handle<> f(::PyCFunction_New(&no_init_def, 0));

this->setattr("__init__", object(f));

{

setattr("__safe_for_unpickling__", object(true));

if (getstate_manages_dict)

{

setattr("__getstate_manages_dict__", object(true));

}

{

PyTypeObject* self = downcast<PyTypeObject>(this->ptr());

dict d((handle<>(borrowed(self->tp_dict))));

object method(d[method_name]);

this->attr(method_name) = object(

handle<>(

PyStaticMethod_New((callable_check)(method.ptr()) )

));

{

assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self_)), &class_metatype_object));

objects::instance<>* self = (objects::instance<>*)self_;

if (storage != (char*)self + Py_SIZE(self))

{

PyMem_Free(storage);

}