#include <boost/python/detail/prefix.hpp>

#include <boost/mpl/lambda.hpp> // #including this first is an intel6 workaround

#include <boost/cstdint.hpp>

#include <boost/python/object/class.hpp>

#include <boost/python/object/instance.hpp>

#include <boost/python/object/class_detail.hpp>

#include <boost/python/scope.hpp>

#include <boost/python/converter/registry.hpp>

#include <boost/python/object/find_instance.hpp>

#include <boost/python/object/pickle_support.hpp>

#include <boost/python/detail/map_entry.hpp>

#include <boost/python/object.hpp>

#include <boost/python/object_protocol.hpp>

#include <boost/detail/binary_search.hpp>

#include <boost/python/self.hpp>

#include <boost/python/dict.hpp>

#include <boost/python/str.hpp>

#include <boost/python/ssize_t.hpp>

#include <functional>

#include <vector>

#include <cstddef>

#include <new>

#include <structmember.h>

namespace boost { namespace python {

# ifdef BOOST_PYTHON_SELF_IS_CLASS

namespace self_ns

{

self_t self;

}

# endif

instance_holder::instance_holder()

: m_next(0)

{

}

instance_holder::~instance_holder()

{

}

extern "C"

{

// This is copied from typeobject.c in the Python sources. Even though

// class_metatype_object doesn't set Py_TPFLAGS_HAVE_GC, that bit gets

// filled in by the base class initialization process in

// PyType_Ready(). However, tp_is_gc is *not* copied from the base

// type, making it assume that classes are GC-able even if (like

// class_type_object) they're statically allocated.

static int

type_is_gc(PyTypeObject *python_type)

{

return python_type->tp_flags & Py_TPFLAGS_HEAPTYPE;

}

// This is also copied from the Python sources. We can't implement

// static_data as a subclass property effectively without it.

typedef struct {

PyObject_HEAD

PyObject *prop_get;

PyObject *prop_set;

PyObject *prop_del;

PyObject *prop_doc;

int getter_doc;

} propertyobject;

// Copied from Python source and removed the part for setting docstring,

// since we don't have a setter for __doc__ and trying to set it will

// cause the init fail.

static int property_init(PyObject *self, PyObject *args, PyObject *kwds)

}

static PyObject *

static_data_descr_get(PyObject *self, PyObject * /*obj*/, PyObject * /*type*/)

{

propertyobject *gs = (propertyobject *)self;

return PyObject_CallFunction(gs->prop_get, const_cast<char*>("()"));

}

static int

static_data_descr_set(PyObject *self, PyObject * /*obj*/, PyObject *value)

}

}

static PyTypeObject static_data_object = {

PyVarObject_HEAD_INIT(NULL, 0)

const_cast<char*>("Boost.Python.StaticProperty"),

sizeof(propertyobject),

0,

0, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

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_BASETYPE, /* tp_flags */

0, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, //&PyProperty_Type, /* tp_base */

0, /* tp_dict */

static_data_descr_get, /* tp_descr_get */

static_data_descr_set, /* tp_descr_set */

0, /* tp_dictoffset */

property_init, /* tp_init */

0, /* tp_alloc */

0, // filled in with type_new /* tp_new */

0, // filled in with __PyObject_GC_Del /* tp_free */

0, /* tp_is_gc */

0, /* tp_bases */

0, /* tp_mro */

0, /* tp_cache */

0, /* tp_subclasses */

0, /* tp_weaklist */

#if PYTHON_API_VERSION >= 1012

0 /* tp_del */

#endif

};

namespace objects

{

#if PY_VERSION_HEX < 0x03000000

// XXX Not sure why this run into compiling error in Python 3

extern "C"

{

// This declaration needed due to broken Python 2.2 headers

extern DL_IMPORT(PyTypeObject) PyProperty_Type;

}

#endif

BOOST_PYTHON_DECL PyObject* static_data()

{

if (static_data_object.tp_dict == 0)

{

Py_SET_TYPE(&static_data_object, &PyType_Type);

static_data_object.tp_base = &PyProperty_Type;

if (PyType_Ready(&static_data_object))

return 0;

}

return upcast<PyObject>(&static_data_object);

}

}

extern "C"

{

// Ordinarily, descriptors have a certain assymetry: you can use

// them to read attributes off the class object they adorn, but

// writing the same attribute on the class object always replaces

// the descriptor in the class __dict__. In order to properly

// represent C++ static data members, we need to allow them to be

// written through the class instance. This function of the

// metaclass makes it possible.

static int

class_setattro(PyObject *obj, PyObject *name, PyObject* value)

}

}

static PyTypeObject class_metatype_object = {

PyVarObject_HEAD_INIT(NULL, 0)

const_cast<char*>("Boost.Python.class"),

PyType_Type.tp_basicsize,

0,

0, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

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 */

class_setattro, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT // | Py_TPFLAGS_HAVE_GC

| Py_TPFLAGS_BASETYPE, /* tp_flags */

0, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, //&PyType_Type, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

0, // filled in with type_new /* tp_new */

0, // filled in with __PyObject_GC_Del /* tp_free */

(inquiry)type_is_gc, /* tp_is_gc */

0, /* tp_bases */

0, /* tp_mro */

0, /* tp_cache */

0, /* tp_subclasses */

0, /* tp_weaklist */

#if PYTHON_API_VERSION >= 1012

0 /* tp_del */

#endif

};

void instance_holder::install(PyObject* self) throw()

}

namespace objects

{

BOOST_PYTHON_DECL type_handle class_metatype()

}

extern "C"

{

static void instance_dealloc(PyObject* inst)

}

static PyObject *

instance_new(PyTypeObject* type_, PyObject* /*args*/, PyObject* /*kw*/)

{

// Attempt to find the __instance_size__ attribute. If not present, no problem.

PyObject* d = type_->tp_dict;

PyObject* instance_size_obj = PyObject_GetAttrString(d, const_cast<char*>("__instance_size__"));

ssize_t instance_size = instance_size_obj ?

#if PY_VERSION_HEX >= 0x03000000

PyLong_AsSsize_t(instance_size_obj) : 0;

#else

PyInt_AsLong(instance_size_obj) : 0;

#endif

if (instance_size < 0)

instance_size = 0;

PyErr_Clear(); // Clear any errors that may have occurred.

instance<>* result = (instance<>*)type_->tp_alloc(type_, instance_size);

if (result)

{

// Guido says we can use ob_size for any purpose we

// like, so we'll store the total size of the object

// there. A negative number indicates that the extra

// instance memory is not yet allocated to any holders.

Py_SET_SIZE(result,-static_cast<int>(offsetof(instance<>,storage) + instance_size));

}

return (PyObject*)result;

}

static PyObject* instance_get_dict(PyObject* op, void*)

{

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

if (inst->dict == 0)

inst->dict = PyDict_New();

return python::xincref(inst->dict);

}

static int instance_set_dict(PyObject* op, PyObject* dict, void*)

}

}

static PyGetSetDef instance_getsets[] = {

{const_cast<char*>("__dict__"), instance_get_dict, instance_set_dict, NULL, 0},

{0, 0, 0, 0, 0}

};

static PyMemberDef instance_members[] = {

{const_cast<char*>("__weakref__"), T_OBJECT, offsetof(instance<>, weakrefs), 0, 0},

{0, 0, 0, 0, 0}

};

static PyTypeObject class_type_object = {

PyVarObject_HEAD_INIT(NULL, 0)

const_cast<char*>("Boost.Python.instance"),

offsetof(instance<>,storage), /* tp_basicsize */

1, /* tp_itemsize */

instance_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

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_BASETYPE, /* tp_flags */

0, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

offsetof(instance<>,weakrefs), /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

instance_members, /* tp_members */

instance_getsets, /* tp_getset */

0, //&PyBaseObject_Type, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

offsetof(instance<>,dict), /* tp_dictoffset */

0, /* tp_init */

PyType_GenericAlloc, /* tp_alloc */

instance_new, /* 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 PYTHON_API_VERSION >= 1012

0 /* tp_del */

#endif

};

BOOST_PYTHON_DECL type_handle class_type()

}

BOOST_PYTHON_DECL void*

find_instance_impl(PyObject* inst, type_info type, bool null_shared_ptr_only)

{

if (!Py_TYPE(Py_TYPE(inst)) ||

!PyType_IsSubtype(Py_TYPE(Py_TYPE(inst)), &class_metatype_object))

return 0;

instance<>* self = reinterpret_cast<instance<>*>(inst);

for (instance_holder* match = self->objects; match != 0; match = match->next())

{

void* const found = match->holds(type, null_shared_ptr_only);

if (found)

return found;

}

return 0;

}

object module_prefix()

}

namespace

{

// Find a registered class object corresponding to id. Return a

// null handle if no such class is registered.

inline type_handle query_class(type_info id)

}

// Find a registered class corresponding to id. If not found,

// throw an appropriate exception.

type_handle get_class(type_info id)

}

// class_base constructor

//

// name - the name of the new Python class

//

// num_types - one more than the number of declared bases

//

// types - array of python::type_info, the first item

// corresponding to the class being created, and the

// rest corresponding to its declared bases.

//

inline object

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

}

}

class_base::class_base(

}

BOOST_PYTHON_DECL void copy_class_object(type_info const& src, type_info const& dst)

}

void class_base::set_instance_size(std::size_t instance_size)

{

this->attr("__instance_size__") = instance_size;

}

void class_base::add_property(

}

void class_base::add_property(

}

void class_base::add_static_property(char const* name, object const& fget)

}

void class_base::add_static_property(char const* name, object const& fget, object const& fset)

}

void class_base::setattr(char const* name, object const& x)

}

namespace

{

extern "C" PyObject* no_init(PyObject*, PyObject*)

{

::PyErr_SetString(::PyExc_RuntimeError, const_cast<char*>("This class cannot be instantiated from Python"));

return NULL;

}

static ::PyMethodDef no_init_def = {

const_cast<char*>("__init__"), no_init, METH_VARARGS,

const_cast<char*>("Raises an exception\n"

"This class cannot be instantiated from Python\n")

};

}

void class_base::def_no_init()

}

void class_base::enable_pickling_(bool getstate_manages_dict)

}

namespace

{

PyObject* callable_check(PyObject* callable)

{

if (PyCallable_Check(expect_non_null(callable)))

return callable;

::PyErr_Format(

PyExc_TypeError

, const_cast<char*>("staticmethod expects callable object; got an object of type %s, which is not callable")

, Py_TYPE(callable)->tp_name

);

throw_error_already_set();

return 0;

}

}

void class_base::make_method_static(const char * method_name)

}

BOOST_PYTHON_DECL type_handle registered_class_object(type_info id)

{

return query_class(id);

}

} // namespace objects

typedef unsigned int alignment_marker_t;

void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std::size_t holder_size, std::size_t alignment)

{

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

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

int total_size_needed = holder_offset + holder_size + alignment - 1;

if (-Py_SIZE(self) >= total_size_needed)

{

// holder_offset should at least point into the variable-sized part

assert(holder_offset >= offsetof(objects::instance<>,storage));

size_t allocated = holder_size + alignment;

void* storage = (char*)self + holder_offset;

void* aligned_storage = ::boost::alignment::align(alignment, holder_size, storage, allocated);

// Record the fact that the storage is occupied, noting where it starts

const size_t offset = reinterpret_cast<uintptr_t>(aligned_storage) - reinterpret_cast<uintptr_t>(storage) + holder_offset;

Py_SET_SIZE(self, offset);

return (char*)self + offset;

}

else

{

const size_t base_allocation = sizeof(alignment_marker_t) + holder_size + alignment - 1;

void* const base_storage = PyMem_Malloc(base_allocation);

if (base_storage == 0)

throw std::bad_alloc();

const uintptr_t x = reinterpret_cast<uintptr_t>(base_storage) + sizeof(alignment_marker_t);

//this has problems for x -> max(void *)

//const size_t padding = alignment - ((x + sizeof(alignment_marker_t)) % alignment);

//only works for alignments with alignments of powers of 2, but no edge conditions

const uintptr_t padding = alignment == 1 ? 0 : ( alignment - (x & (alignment - 1)) );

const size_t aligned_offset = sizeof(alignment_marker_t) + padding;

void* const aligned_storage = (char *)base_storage + aligned_offset;

BOOST_ASSERT((char *) aligned_storage + holder_size <= (char *)base_storage + base_allocation);

alignment_marker_t* const marker_storage = reinterpret_cast<alignment_marker_t *>((char *)aligned_storage - sizeof(alignment_marker_t));

*marker_storage = static_cast<alignment_marker_t>(padding);

return aligned_storage;

}

}

void instance_holder::deallocate(PyObject* self_, void* storage) throw()

}

}} // namespace boost::python