#include <boost/python/docstring_options.hpp>

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

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

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

#include <boost/python/errors.hpp>

#include <boost/python/str.hpp>

#include <boost/python/object_attributes.hpp>

#include <boost/python/args.hpp>

#include <boost/python/refcount.hpp>

#include <boost/python/extract.hpp>

#include <boost/python/tuple.hpp>

#include <boost/python/list.hpp>

#include <boost/python/ssize_t.hpp>

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

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

#include <boost/mpl/vector/vector10.hpp>

#include <boost/bind.hpp>

#include <algorithm>

#include <cstring>

#if BOOST_PYTHON_DEBUG_ERROR_MESSAGES

# include <cstdio>

#endif

namespace boost { namespace python {

volatile bool docstring_options::show_user_defined_ = true;

volatile bool docstring_options::show_cpp_signatures_ = true;

#ifndef BOOST_PYTHON_NO_PY_SIGNATURES

volatile bool docstring_options::show_py_signatures_ = true;

#else

volatile bool docstring_options::show_py_signatures_ = false;

#endif

}}

namespace boost { namespace python { namespace objects {

py_function_impl_base::~py_function_impl_base()

{

}

unsigned py_function_impl_base::max_arity() const

{

return this->min_arity();

}

extern PyTypeObject function_type;

function::function(

}

function::~function()

{

}

PyObject* function::call(PyObject* args, PyObject* keywords) const

{

std::size_t n_unnamed_actual = PyTuple_GET_SIZE(args);

std::size_t n_keyword_actual = keywords ? PyDict_Size(keywords) : 0;

std::size_t n_actual = n_unnamed_actual + n_keyword_actual;

function const* f = this;

// Try overloads looking for a match

do

{

// Check for a plausible number of arguments

unsigned min_arity = f->m_fn.min_arity();

unsigned max_arity = f->m_fn.max_arity();

if (n_actual + f->m_nkeyword_values >= min_arity

&& n_actual <= max_arity)

{

// This will be the args that actually get passed

handle<>inner_args(allow_null(borrowed(args)));

if (n_keyword_actual > 0 // Keyword arguments were supplied

|| n_actual < min_arity) // or default keyword values are needed

{

if (f->m_arg_names.is_none())

{

// this overload doesn't accept keywords

inner_args = handle<>();

}

else

{

// "all keywords are none" is a special case

// indicating we will accept any number of keyword

// arguments

if (PyTuple_Size(f->m_arg_names.ptr()) == 0)

{

// no argument preprocessing

}

else if (n_actual > max_arity)

{

// too many arguments

inner_args = handle<>();

}

else

{

// build a new arg tuple, will adjust its size later

assert(max_arity <= static_cast<std::size_t>(ssize_t_max));

inner_args = handle<>(

PyTuple_New(static_cast<ssize_t>(max_arity)));

// Fill in the positional arguments

for (std::size_t i = 0; i < n_unnamed_actual; ++i)

PyTuple_SET_ITEM(inner_args.get(), i, incref(PyTuple_GET_ITEM(args, i)));

// Grab remaining arguments by name from the keyword dictionary

std::size_t n_actual_processed = n_unnamed_actual;

for (std::size_t arg_pos = n_unnamed_actual; arg_pos < max_arity ; ++arg_pos)

{

// Get the keyword[, value pair] corresponding

PyObject* kv = PyTuple_GET_ITEM(f->m_arg_names.ptr(), arg_pos);

// If there were any keyword arguments,

// look up the one we need for this

// argument position

PyObject* value = n_keyword_actual

? PyDict_GetItem(keywords, PyTuple_GET_ITEM(kv, 0))

: 0;

if (!value)

{

// Not found; check if there's a default value

if (PyTuple_GET_SIZE(kv) > 1)

value = PyTuple_GET_ITEM(kv, 1);

if (!value)

{

// still not found; matching fails

PyErr_Clear();

inner_args = handle<>();

break;

}

}

else

{

++n_actual_processed;

}

PyTuple_SET_ITEM(inner_args.get(), arg_pos, incref(value));

}

if (inner_args.get())

{

//check if we proccessed all the arguments

if(n_actual_processed < n_actual)

inner_args = handle<>();

}

}

}

}

// Call the function. Pass keywords in case it's a

// function accepting any number of keywords

PyObject* result = inner_args ? f->m_fn(inner_args.get(), keywords) : 0;

// If the result is NULL but no error was set, m_fn failed

// the argument-matching test.

// This assumes that all other error-reporters are

// well-behaved and never return NULL to python without

// setting an error.

if (result != 0 || PyErr_Occurred())

return result;

}

f = f->m_overloads.get();

}

while (f);

// None of the overloads matched; time to generate the error message

argument_error(args, keywords);

return 0;

}

object function::signature(bool show_return_type) const

}

object function::signatures(bool show_return_type) const

}

void function::argument_error(PyObject* args, PyObject* /*keywords*/) const

}

void function::add_overload(handle<function> const& overload_)

}

{

char const* const binary_operator_names[] =

{

"add__",

"and__",

"div__",

"divmod__",

"eq__",

"floordiv__",

"ge__",

"gt__",

"le__",

"lshift__",

"lt__",

"mod__",

"mul__",

"ne__",

"or__",

"pow__",

"radd__",

"rand__",

"rdiv__",

"rdivmod__",

"rfloordiv__",

"rlshift__",

"rmod__",

"rmul__",

"ror__",

"rpow__",

"rrshift__",

"rshift__",

"rsub__",

"rtruediv__",

"rxor__",

"sub__",

"truediv__",

"xor__"

};

struct less_cstring

};

inline bool is_binary_operator(char const* name)

}

// Something for the end of the chain of binary operators

PyObject* not_implemented(PyObject*, PyObject*)

{

Py_INCREF(Py_NotImplemented);

return Py_NotImplemented;

}

handle<function> not_implemented_function()

}

}

void function::add_to_namespace(

}

namespace detail

{

extern char py_signature_tag[];

extern char cpp_signature_tag[];

}

void function::add_to_namespace(

}

BOOST_PYTHON_DECL void add_to_namespace(

}

BOOST_PYTHON_DECL void add_to_namespace(

}

{

struct bind_return

};

}

extern "C"

{

// Stolen from Python's funcobject.c

static PyObject *

function_descr_get(PyObject *func, PyObject *obj, PyObject *type_)

{

#if PY_VERSION_HEX >= 0x03000000

// The implement is different in Python 3 because of the removal of unbound method

if (obj == Py_None || obj == NULL) {

Py_INCREF(func);

return func;

}

return PyMethod_New(func, obj);

#else

if (obj == Py_None)

obj = NULL;

return PyMethod_New(func, obj, type_);

#endif

}

static void

function_dealloc(PyObject* p)

{

delete static_cast<function*>(p);

}

static PyObject *

function_call(PyObject *func, PyObject *args, PyObject *kw)

{

PyObject* result = 0;

handle_exception(bind_return(result, static_cast<function*>(func), args, kw));

return result;

}

//

// Here we're using the function's tp_getset rather than its

// tp_members to set up __doc__ and __name__, because tp_members

// really depends on having a POD object type (it relies on

// offsets). It might make sense to reformulate function as a POD

// at some point, but this is much more expedient.

//

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

{

function* f = downcast<function>(op);

list signatures = function_doc_signature_generator::function_doc_signatures(f);

if(!signatures) return python::detail::none();

signatures.reverse();

return python::incref( str("\n").join(signatures).ptr());

}

static int function_set_doc(PyObject* op, PyObject* doc, void*)

}

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

{

function* f = downcast<function>(op);

if (f->name().is_none())

#if PY_VERSION_HEX >= 0x03000000

return PyUnicode_InternFromString("<unnamed Boost.Python function>");

#else

return PyString_InternFromString("<unnamed Boost.Python function>");

#endif

else

return python::incref(f->name().ptr());

}

// We add a dummy __class__ attribute in order to fool PyDoc into

// treating these as built-in functions and scanning their

// documentation

static PyObject* function_get_class(PyObject* /*op*/, void*)

{

return python::incref(upcast<PyObject>(&PyCFunction_Type));

}

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

{

function* f = downcast<function>(op);

object const& ns = f->get_namespace();

if (!ns.is_none()) {

return python::incref(ns.ptr());

}

PyErr_SetString(

PyExc_AttributeError, const_cast<char*>(

"Boost.Python function __module__ unknown."));

return 0;

}

}

static PyGetSetDef function_getsetlist[] = {

{const_cast<char*>("__name__"), (getter)function_get_name, 0, 0, 0 },

{const_cast<char*>("func_name"), (getter)function_get_name, 0, 0, 0 },

{const_cast<char*>("__module__"), (getter)function_get_module, 0, 0, 0 },

{const_cast<char*>("func_module"), (getter)function_get_module, 0, 0, 0 },

{const_cast<char*>("__class__"), (getter)function_get_class, 0, 0, 0 }, // see note above

{const_cast<char*>("__doc__"), (getter)function_get_doc, (setter)function_set_doc, 0, 0},

{const_cast<char*>("func_doc"), (getter)function_get_doc, (setter)function_set_doc, 0, 0},

{NULL, 0, 0, 0, 0} /* Sentinel */

};

PyTypeObject function_type = {

PyVarObject_HEAD_INIT(NULL, 0)

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

sizeof(function),

0,

(destructor)function_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

0, //(reprfunc)func_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

function_call, /* tp_call */

0, /* tp_str */

0, // PyObject_GenericGetAttr, /* tp_getattro */

0, // PyObject_GenericSetAttr, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT /* | Py_TPFLAGS_HAVE_GC */,/* tp_flags */

0, /* tp_doc */

0, // (traverseproc)func_traverse, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, //offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

0, // func_memberlist, /* tp_members */

function_getsetlist, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

function_descr_get, /* tp_descr_get */

0, /* tp_descr_set */

0, //offsetof(PyFunctionObject, func_dict), /* 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 PYTHON_API_VERSION >= 1012

0 /* tp_del */

#endif

};

object function_object(

}

object function_object(py_function const& f)

{

return function_object(f, python::detail::keyword_range());

}

handle<> function_handle_impl(py_function const& f)

}

} // namespace objects

namespace detail

{

object BOOST_PYTHON_DECL make_raw_function(objects::py_function f)

}

void BOOST_PYTHON_DECL pure_virtual_called()

}

}

}} // namespace boost::python