// Copyright Nikolay Mladenov 2007.

// Distributed under the Boost Software License, Version 1.0. (See

// accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

// boost::python::make_tuple below are for gcc 4.4 -std=c++0x compatibility

// (Intel C++ 10 and 11 with -std=c++0x don't need the full qualification).

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

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

#include <boost/python/errors.hpp>

#include <boost/python/str.hpp>

#include <boost/python/args.hpp>

#include <boost/python/tuple.hpp>

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

#include <vector>

namespace boost { namespace python { namespace objects {

bool function_doc_signature_generator::arity_cmp( function const *f1, function const *f2 )

{

return f1->m_fn.max_arity() < f2->m_fn.max_arity();

}

bool function_doc_signature_generator::are_seq_overloads( function const *f1, function const *f2 , bool check_docs)

{

py_function const & impl1 = f1->m_fn;

py_function const & impl2 = f2->m_fn;

//the number of parameters differs by 1

if (impl2.max_arity()-impl1.max_arity() != 1)

return false;

// if check docs then f1 shold not have docstring or have the same docstring as f2

if (check_docs && f2->doc() != f1->doc() && f1->doc())

return false;

python::detail::signature_element const* s1 = impl1.signature();

python::detail::signature_element const* s2 = impl2.signature();

unsigned size = impl1.max_arity()+1;

for (unsigned i = 0; i != size; ++i)

{

//check if the argument types are the same

if (s1[i].basename != s2[i].basename)

return false;

//return type

if (!i) continue;

//check if the argument default values are the same

bool f1_has_names = bool(f1->m_arg_names);

bool f2_has_names = bool(f2->m_arg_names);

if ( (f1_has_names && f2_has_names && f2->m_arg_names[i-1]!=f1->m_arg_names[i-1])

|| (f1_has_names && !f2_has_names)

|| (!f1_has_names && f2_has_names && f2->m_arg_names[i-1]!=python::object())

)

return false;

}

return true;

}

std::vector<function const*> function_doc_signature_generator::flatten(function const *f)

{

object name = f->name();

std::vector<function const*> res;

while (f) {

//this if takes out the not_implemented_function

if (f->name() == name)

res.push_back(f);

f=f->m_overloads.get();

}

//std::sort(res.begin(),res.end(), &arity_cmp);

return res;

}

std::vector<function const*> function_doc_signature_generator::split_seq_overloads( const std::vector<function const *> &funcs, bool split_on_doc_change)

{

std::vector<function const*> res;

std::vector<function const*>::const_iterator fi = funcs.begin();

function const * last = *fi;

while (++fi != funcs.end()){

//check if fi starts a new chain of overloads

if (!are_seq_overloads( last, *fi, split_on_doc_change ))

res.push_back(last);

last = *fi;

}

if (last)

res.push_back(last);

return res;

}

str function_doc_signature_generator::raw_function_pretty_signature(function const *f, size_t n_overloads, bool cpp_types )

{

str res("object");

res = str("%s %s(%s)" % make_tuple( res, f->m_name, str("tuple args, dict kwds")) );

return res;

}

const char * function_doc_signature_generator::py_type_str(const python::detail::signature_element &s)

{

if (s.basename==std::string("void")){

static const char * none = "None";

return none;

}

PyTypeObject const * py_type = s.pytype_f?s.pytype_f():0;

if ( py_type )

return py_type->tp_name;

else{

static const char * object = "object";

return object;

}

}

str function_doc_signature_generator::parameter_string(py_function const &f, size_t n, object arg_names, bool cpp_types)

{

str param;

python::detail::signature_element const * s = f.signature();

if (cpp_types)

{

if(!n)

s = &f.get_return_type();

if (s[n].basename == 0)

{

return str("...");

}

param = str(s[n].basename);

if (s[n].lvalue)

param += " {lvalue}";

}

else

{

if (n) //we are processing an argument and trying to come up with a name for it

{

object kv;

if ( arg_names && (kv = arg_names[n-1]) )

param = str( " (%s)%s" % make_tuple(py_type_str(s[n]),kv[0]) );

else

param = str(" (%s)%s%d" % make_tuple(py_type_str(s[n]),"arg", n) );

}

else //we are processing the return type

param = py_type_str(f.get_return_type());

}

//an argument - check for default value and append it

if(n && arg_names)

{

object kv(arg_names[n-1]);

if (kv && len(kv) == 2)

{

param = str("%s=%r" % make_tuple(param, kv[1]));

}

}

return param;

}

str function_doc_signature_generator::pretty_signature(function const *f, size_t n_overloads, bool cpp_types )

{

py_function

const& impl = f->m_fn;

;

unsigned arity = impl.max_arity();

if(arity == unsigned(-1))// is this the proper raw function test?

{

return raw_function_pretty_signature(f,n_overloads,cpp_types);

}

list formal_params;

size_t n_extra_default_args=0;

for (unsigned n = 0; n <= arity; ++n)

{

str param;

formal_params.append(

parameter_string(impl, n, f->m_arg_names, cpp_types)

);

// find all the arguments with default values preceeding the arity-n_overloads

if (n && f->m_arg_names)

{

object kv(f->m_arg_names[n-1]);

if (kv && len(kv) == 2)

{

//default argument preceeding the arity-n_overloads

if( n <= arity-n_overloads)

++n_extra_default_args;

}

else

//argument without default, preceeding the arity-n_overloads

if( n <= arity-n_overloads)

n_extra_default_args = 0;

}

}

n_overloads+=n_extra_default_args;

if (!arity && cpp_types)

formal_params.append("void");

str ret_type (formal_params.pop(0));

if (cpp_types )

{

return str(

"%s %s(%s%s%s%s)"

% boost::python::make_tuple // workaround, see top

( ret_type

, f->m_name

, str(",").join(formal_params.slice(0,arity-n_overloads))

, n_overloads ? (n_overloads!=arity?str(" [,"):str("[ ")) : str()

, str(" [,").join(formal_params.slice(arity-n_overloads,arity))

, std::string(n_overloads,']')

));

}else{

return str(

"%s(%s%s%s%s) -> %s"

% boost::python::make_tuple // workaround, see top

( f->m_name

, str(",").join(formal_params.slice(0,arity-n_overloads))

, n_overloads ? (n_overloads!=arity?str(" [,"):str("[ ")) : str()

, str(" [,").join(formal_params.slice(arity-n_overloads,arity))

, std::string(n_overloads,']')

, ret_type

));

}

return str(

"%s %s(%s%s%s%s) %s"

% boost::python::make_tuple // workaround, see top

( cpp_types?ret_type:str("")

, f->m_name

, str(",").join(formal_params.slice(0,arity-n_overloads))

, n_overloads ? (n_overloads!=arity?str(" [,"):str("[ ")) : str()

, str(" [,").join(formal_params.slice(arity-n_overloads,arity))

, std::string(n_overloads,']')

, cpp_types?str(""):ret_type

));

}

namespace detail {

char py_signature_tag[] = "PY signature :";

char cpp_signature_tag[] = "C++ signature :";

}

list function_doc_signature_generator::function_doc_signatures( function const * f)

{

list signatures;

std::vector<function const*> funcs = flatten( f);

std::vector<function const*> split_funcs = split_seq_overloads( funcs, true);

std::vector<function const*>::const_iterator sfi=split_funcs.begin(), fi;

size_t n_overloads=0;

for (fi=funcs.begin(); fi!=funcs.end(); ++fi)

{

if(*sfi == *fi){

if((*fi)->doc())

{

str func_doc = str((*fi)->doc());

int doc_len = len(func_doc);

bool show_py_signature = doc_len >= int(sizeof(detail::py_signature_tag)/sizeof(char)-1)

&& str(detail::py_signature_tag) == func_doc.slice(0, int(sizeof(detail::py_signature_tag)/sizeof(char))-1);

if(show_py_signature)

{

func_doc = str(func_doc.slice(int(sizeof(detail::py_signature_tag)/sizeof(char))-1, _));

doc_len = len(func_doc);

}

bool show_cpp_signature = doc_len >= int(sizeof(detail::cpp_signature_tag)/sizeof(char)-1)

&& str(detail::cpp_signature_tag) == func_doc.slice( 1-int(sizeof(detail::cpp_signature_tag)/sizeof(char)), _);

if(show_cpp_signature)

{

func_doc = str(func_doc.slice(_, 1-int(sizeof(detail::cpp_signature_tag)/sizeof(char))));

doc_len = len(func_doc);

}

str res="\n";

str pad = "\n";

if(show_py_signature)

{

str sig = pretty_signature(*fi, n_overloads,false);

res+=sig;

if(doc_len || show_cpp_signature )res+=" :";

pad+= str(" ");

}

if(doc_len)

{

if(show_py_signature)

res+=pad;

res+= pad.join(func_doc.split("\n"));

}

if( show_cpp_signature)

{

if(len(res)>1)

res+="\n"+pad;

res+=detail::cpp_signature_tag+pad+" "+pretty_signature(*fi, n_overloads,true);

}

signatures.append(res);

}

++sfi;

n_overloads = 0;

}else

++n_overloads ;

}

return signatures;

}

}}}