{

if (name == nullptr || name[0] == '\0') return root_module();

return bindmodule(value_ref(name));

{

static list_ref to_bind_value(const CxxValue & cxx_value)

{

return list_ref(to_jam(cxx_value));

}

static CxxValue from_bind_value(

list_cref::iterator & i, list_cref::iterator e)

{

return (i == e) ? CxxValue() : from_jam<CxxValue>(*(i++));

}

{

list_ref result;

for (auto & v : cxx_value) result.push_back(to_jam(v));

return result;

list_cref::iterator & i, list_cref::iterator e)

{

CxxValue result;

for (; i != e; ++i) result.emplace_back(from_jam<Value>(*i));

return result;

{

list_ref result;

if (cxx_value.has_value())

result.push_back(to_jam(static_cast<ValueType>(cxx_value)));

return result;

list_cref::iterator & i, list_cref::iterator e)

{

return (i == e) ? CxxValue() : from_jam<ValueType>(*(i++));

list_cref::iterator & i, list_cref::iterator e)

{

list_ref result(i, e);

i = e;

return result;

{

list_ref result;

if (cxx_value.has_value()) result.push_back(cxx_value);

return result;

list_cref::iterator & i, list_cref::iterator e)

{

return (i == e) ? value_ref() : value_ref(*(i++));

{

return to_bind_value(cxx_value,

mp::make_index_sequence<std::tuple_size<CxxValue>::value> { });

const CxxValue & cxx_value, mp::index_sequence<I...>)

{

using std::get;

value_ptr jam_val[] { nullptr, to_jam(get<I>(cxx_value))... };

list_ref result;

for (int i = 1; i <= std::tuple_size<CxxValue>::value; ++i)

result.push_back(jam_val[i]);

return result;

list_cref::iterator & i, list_cref::iterator e)

{

return from_bind_value(i, e,

mp::make_index_sequence<std::tuple_size<CxxValue>::value> { });

list_cref::iterator & i, list_cref::iterator e, mp::index_sequence<I...>)

{

CxxValue result;

int _[] { 0,

((void)(std::get<I>(result) = converter<typename std::tuple_element<

I, CxxValue>::type>::from_bind_value(i, e)),

0)... };

(void)_;

return result;

{

// TODO: Can we optimize this to not do a list copy?

return list_ref(jam_value);

{

list_cref v(jam_value);

auto i = v.begin();

auto e = v.end();

return b2::jam::converter<CxxValue>::from_bind_value(i, e);

{

// Get the hidden C++ self instance for the jam class instance.

template <class Class>

static Class * get(FRAME * frame)

{

value_ref cxx_self_name(value::make("__cxx_self__"));

value_ref cxx_self_value(

list_front(var_get(frame->module, cxx_self_name)));

Class * self = static_cast<Class *>(cxx_self_value->as_object());

return self;

}

// Set the hidden C++ self instance for the jam class instance.

template <class Class>

static void set(FRAME * frame, Class * self)

{

value_ref cxx_self_name(value::make("__cxx_self__"));

value_ref cxx_self_value(value::make(self));

var_set(frame->module, cxx_self_name, list_new(cxx_self_value), VAR_SET);

}

{

template <class ArgsTuple>

static void convert(ArgsTuple & to_args, jam_context & context)

{

LIST * arg_value = lol_get(context.frame->args, N);

if (arg_value != L0)

std::get<N>(to_args)

= jam_binder::convert_from_bind_value<ArgType>(arg_value);

}

{

lists & to_arg = std::get<N>(to_args);

for (int32_t i = N; i < context.frame->args->count; ++i)

to_arg | lol_get(context.frame->args, i);

{

using arg_type = typename std::tuple_element<N, ArgsTuple>::type;

jam_marshal_arg<N, arg_type>::convert(to_args, context);

if (N < std::tuple_size<ArgsTuple>::value)

{

jam_marshal_args<ArgsTuple, N + 1>::convert(to_args, context);

}

{

// static constexpr std::size_t value

// = ::b2::bind::args_<A...>::count

// + jam_arg_spec_count_sum<A...>::value*2

// + 2;

enum : std::size_t

{

value = ::b2::bind::args_<A...>::count

+ jam_arg_spec_count_sum<A...>::value * 2 + 2

};

{

using args_t = ::b2::bind::args_<A...>;

// The jam specification, terminated by a `nullptr`. Note, the `spec` will

// be larger than the actual specification. Hence use the `count` if one

// needs to know the range.

const char * spec[jam_arg_spec_max_size<A...>::value];

// The number of strings in the specification, exclusive of the terminating

// n`nullptr`.

int count;

jam_arg_spec(const args_t & args)

: jam_arg_spec(args, mp::make_index_sequence<sizeof...(A)> { })

{ }

template <std::size_t... I>

jam_arg_spec(const args_t & args, mp::index_sequence<I...>)

{

count = 0;

using std::get;

bool _[] { false, append_arg_list_to_spec(get<I>(args.arg))... };

(void)_; // Avoid unused val warnings on older compilers.

if (count == 0) spec[count++] = "*";

spec[count] = nullptr;

}

template <int C>

bool append_arg_list_to_spec(const ::b2::bind::arg_<C> & arg)

{

if (count > 0) spec[count++] = ":";

for (int i = 0; i < C; ++i)

{

if (arg.args[i].count == ::b2::bind::param_::rest)

{

spec[count++] = "*";

break;

}

spec[count++] = arg.args[i].name;

switch (arg.args[i].count)

{

case ::b2::bind::param_::any: spec[count++] = "*"; break;

case ::b2::bind::param_::many: spec[count++] = "+"; break;

case ::b2::bind::param_::optional: spec[count++] = "?"; break;

case ::b2::bind::param_::one:

case ::b2::bind::param_::rest: break;

}

}

return true;

}

const string_t & rule_name,

ArgSpec & arg_spec,

function_builtin_t native_rule,

Return (*)(Args...))

{

value_ptr rule_name_obj = object_new(rule_name.c_str());

module_t * module = mod(module_name);

int found = 0;

RULE * const rule

= (RULE *)hash_insert(demand_rules(module), rule_name_obj, &found);

rule->name = object_copy(rule_name_obj);

rule->procedure = 0;

rule->module = module;

rule->actions = 0;

rule->exported = 0;

// Register the function as a native jam rule.

declare_native_rule(mod_cstr(module_name), rule_name.c_str(), arg_spec.spec,

native_rule, 0);

// Note, we don't check results of not finding the existing native rule,

// for the obvious reason that we just created it a few lines above.

native_rule_t * np

= (native_rule_t *)hash_find(module->native_rules, rule_name_obj);

// Set a global name for the native rule.

function_set_rulename(

np->procedure, object_new((module_name + "." + rule_name).c_str()));

// Define the native rule in the class module.

new_rule_body(module, np->name, np->procedure, 1);

object_free(rule_name_obj);

const string_t & rule_name,

ArgSpec & arg_spec,

Return (Class::*method)(Args...))

{

// out_printf( "jam_bind: %s.%s.\n", module_name.c_str(), rule_name.c_str()

// );

jam_native_bind(

module_name, rule_name, arg_spec,

[method](FRAME * frame, int flags) -> LIST * {

return jam_call_method(

frame, flags,

[method](Class * self, Args... args) -> Return {

return (self->*method)(args...);

},

static_cast<Return (*)(Class *, Args...)>(nullptr));

},

static_cast<Return (*)(Class *, Args...)>(nullptr));

const string_t & rule_name,

ArgSpec & arg_spec,

Return (Class::*method)(Args...) const)

{

// out_printf( "jam_bind: %s.%s.\n", module_name.c_str(), rule_name.c_str()

// );

jam_native_bind(

module_name, rule_name, arg_spec,

[method](FRAME * frame, int flags) -> LIST * {

return jam_call_method(

frame, flags,

[method](const Class * self, Args... args) -> Return {

return (self->*method)(args...);

},

static_cast<Return (*)(Class *, Args...)>(nullptr));

},

static_cast<Return (*)(Class *, Args...)>(nullptr));

const string_t & rule_name,

ArgSpec & arg_spec,

Return (*function)(Args...))

{

jam_native_bind(

module_name, rule_name, arg_spec,

[function](FRAME * frame, int flags) -> LIST * {

return jam_call_function(

frame, flags,

[function](Args... args) -> Return {

return (*function)(args...);

},

static_cast<Return (*)(Args...)>(nullptr));

},

static_cast<Return (*)(Args...)>(nullptr));

const string_t & rule_name,

ArgSpec & arg_spec,

Class *,

::b2::bind::init_<Args...>)

{

// out_printf( "jam_bind: %s.%s.\n", module_name.c_str(), rule_name.c_str()

// );

jam_native_bind(

module_name, rule_name, arg_spec,

[module_name, rule_name](FRAME * frame, int flags) -> LIST * {

return jam_call_init(

frame, flags,

[](Args... args) -> Class * { return new Class(args...); },

static_cast<Class * (*)(Args...)>(nullptr));

},

(void (*)(Args...)) nullptr);

const char * class_name,

::b2::bind::type_<Class>,

::b2::bind::type_<Bases>...)

{

value_ptr class_name_obj = object_new(class_name);

LIST * class_name_list = list_new(class_name_obj);

value_ptr bases_name_obj[] = {

object_new(::b2::bind::class_<Bases, jam_binder>::name())..., nullptr

};

LIST * bases_name_list = L0;

for (value_ptr base_name_obj : bases_name_obj)

{

if (base_name_obj)

bases_name_list = list_push_back(bases_name_list, base_name_obj);

}

/* value_ptr class_module = */

make_class_module(class_name_list, bases_name_list);

object_free(class_name_obj);

for (value_ptr base_name_obj : bases_name_obj)

{

if (base_name_obj) object_free(base_name_obj);

}

list_free(bases_name_list);

const char * class_name,

const char * method_name,

::b2::bind::args_<A...> args,

Function f)

{

jam_arg_spec<A...> arg_spec { args };

jam_bind(string_t("class@") + class_name, method_name, arg_spec, f);

const char * class_name,

Class * c,

Init i,

::b2::bind::args_<A...> args)

{

jam_arg_spec<A...> arg_spec { args };

jam_bind(string_t("class@") + class_name, "__init__", arg_spec, c, i);

const char * function_name,

::b2::bind::args_<A...> args,

Function f)

{

jam_arg_spec<A...> arg_spec { args };

jam_bind(mod_str(module_name), function_name, arg_spec, f);

{

b2::jam::module_scope scope(

context_ref.get<jam_context>().frame, module_name);

parse_buffer(scope.name(), data, scope.frame());

{

b2::jam::variable modules_loaded("modules", ".loaded");

modules_loaded += module_name;

{

jam_context context { f };

jam_binder binder;

binder.context_ref = context;

binder

// These have to be done in dependency order so that the init code

// each executes is valid.

.bind(jam::modules::modules_module())

.bind(jam::builtin::root_module())

.bind(jam::klass::class_module())

.bind(jam::errors::errors_module())

.bind(paths::paths_module())

.bind(regex_module())

.bind(set_module())

.bind(string_module())

.bind(sysinfo_module())

.bind(version_module())

.bind(db_module())

.bind(command_db_module())

.bind(b2::args::args_module())

.bind(b2::std_info_module());