Commit 9ff5642

Const_Assign_Decl,

Namespace_Block

constexpr const char *const ast_node_types[] = {"Id", "Fun_Call", "Unused_Return_Fun_Call", "Arg_List", "Equation", "Var_Decl", "Assign_Decl", "Array_Call", "Dot_Access", "Lambda", "Block", "Scopeless_Block", "Def", "While", "If", "For", "Ranged_For", "Inline_Array", "Inline_Map", "Return", "File", "Prefix", "Break", "Continue", "Map_Pair", "Value_Range", "Inline_Range", "Try", "Catch", "Finally", "Method", "Attr_Decl", "Logical_And", "Logical_Or", "Reference", "Switch", "Case", "Default", "Noop", "Class", "Binary", "Arg", "Global_Decl", "Constant", "Compiled", "Const_Var_Decl", "Const_Assign_Decl", "Namespace_Block"};

if (!m_namespace_generators.count(t_namespace_name)) {

register_namespace([](Namespace & /*space*/) noexcept {}, t_namespace_name);

}

const auto sep_pos = t_namespace_name.find("::");

const std::string root_name = (sep_pos != std::string::npos) ? t_namespace_name.substr(0, sep_pos) : t_namespace_name;

if (!m_engine.get_scripting_objects().count(root_name)) {

import(root_name);

} else if (m_namespace_generators.count(root_name)) {

nest_children(root_name, m_namespace_generators[root_name]());

}

auto &ns = m_namespace_generators[t_namespace_name]();

nest_children(t_namespace_name, ns);

m_engine.add_global(var(std::ref(ns)), t_namespace_name);

/// used. Supports C++-style nested names (e.g. "constants::si") for nested namespaces; parent namespaces are auto-registered if absent.

/// \param[in] t_namespace_generator Namespace generator function.

/// \param[in] t_namespace_name Name of the Namespace function being registered (may contain :: for nesting).

/// \throw std::runtime_error In the case that the namespace name was already registered.

if (m_namespace_generators.count(t_namespace_name)) {

m_namespace_generators.emplace(std::make_pair(t_namespace_name, [=, space = Namespace()]() mutable -> Namespace & {

t_namespace_generator(space);

return space;

}));

auto pos = t_namespace_name.rfind("::");

while (pos != std::string::npos) {

const std::string parent = t_namespace_name.substr(0, pos);

if (!m_namespace_generators.count(parent)) {

m_namespace_generators.emplace(std::make_pair(parent, [space = Namespace()]() mutable -> Namespace & {

return space;

}));

}

pos = parent.rfind("::");

}

private:

void nest_children(const std::string &t_parent_name, Namespace &t_parent) {

const std::string prefix = t_parent_name + "::";

for (auto &[name, generator] : m_namespace_generators) {

if (name.size() > prefix.size() && name.compare(0, prefix.size(), prefix) == 0) {

const std::string remainder = name.substr(prefix.size());

if (remainder.find("::") == std::string::npos) {

auto &child_ns = generator();

nest_children(name, child_ns);

t_parent[remainder] = var(std::ref(child_ns));

}

}

}

}

public:

static std::shared_ptr<dispatch::Proxy_Function_Base> make_proxy_function(

const Def_AST_Node<T> &t_node, const chaiscript::detail::Dispatch_State &t_ss) {

if ((t_node.children.size() > 1) && (t_node.children[1]->identifier == AST_Node_Type::Arg_List)) {

numparams = t_node.children[1]->children.size();

t_param_names = Arg_List_AST_Node<T>::get_arg_names(*t_node.children[1]);

param_types = Arg_List_AST_Node<T>::get_arg_types(*t_node.children[1], t_ss);

if (t_node.m_guard_node) {

[engine, guardnode = t_node.m_guard_node, t_param_names](const Function_Params &t_params) {

t_node.m_guard_node);

return dispatch::make_dynamic_proxy_function(

[engine, func_node = t_node.m_body_node, t_param_names](const Function_Params &t_params) {

return detail::eval_function(engine, *func_node, t_param_names, t_params);

},

static_cast<int>(numparams),

t_node.m_body_node,

param_types,

guard);

}

Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const override {

t_ss->add(make_proxy_function(*this, t_ss), this->children[0]->text);

template<typename T>

struct Namespace_Block_AST_Node final : AST_Node_Impl<T> {

Namespace_Block_AST_Node(std::string t_ast_node_text, Parse_Location t_loc, std::vector<AST_Node_Impl_Ptr<T>> t_children)

: AST_Node_Impl<T>(std::move(t_ast_node_text), AST_Node_Type::Namespace_Block, std::move(t_loc), std::move(t_children)) {

}

Boxed_Value eval_internal(const chaiscript::detail::Dispatch_State &t_ss) const override {

const auto &ns_name = this->children[0]->text;

auto ns_name_bv = const_var(ns_name);

t_ss->call_function("namespace", m_ns_loc, Function_Params{ns_name_bv}, t_ss.conversions());

std::vector<std::string> parts;

{

std::string::size_type start = 0;

std::string::size_type pos = 0;

while ((pos = ns_name.find("::", start)) != std::string::npos) {

parts.push_back(ns_name.substr(start, pos - start));

start = pos + 2;

}

parts.push_back(ns_name.substr(start));

}

Boxed_Value ns_bv = t_ss.get_object(parts[0], m_root_loc);

for (size_t i = 1; i < parts.size(); ++i) {

auto &parent_ns = boxed_cast<dispatch::Dynamic_Object &>(ns_bv);

ns_bv = parent_ns.get_attr(parts[i]);

}

auto &target_ns = boxed_cast<dispatch::Dynamic_Object &>(ns_bv);

const auto process_statement = [&](const AST_Node_Impl<T> &stmt) {

if (stmt.identifier == AST_Node_Type::Def) {

const auto &def_node = static_cast<const Def_AST_Node<T> &>(stmt);

target_ns[def_node.children[0]->text] =

Boxed_Value(Def_AST_Node<T>::make_proxy_function(def_node, t_ss));

} else if (stmt.identifier == AST_Node_Type::Assign_Decl

|| stmt.identifier == AST_Node_Type::Const_Assign_Decl) {

const auto &var_name = stmt.children[0]->text;

auto value = detail::clone_if_necessary(stmt.children[1]->eval(t_ss), m_clone_loc, t_ss);

value.reset_return_value();

if (stmt.identifier == AST_Node_Type::Const_Assign_Decl) {

value.make_const();

}

target_ns[var_name] = std::move(value);

} else if (stmt.identifier == AST_Node_Type::Equation

&& !stmt.children.empty()

&& (stmt.children[0]->identifier == AST_Node_Type::Var_Decl

|| stmt.children[0]->identifier == AST_Node_Type::Const_Var_Decl)) {

const auto &var_name = stmt.children[0]->children[0]->text;

auto value = detail::clone_if_necessary(stmt.children[1]->eval(t_ss), m_clone_loc, t_ss);

value.reset_return_value();

target_ns[var_name] = std::move(value);

} else if (stmt.identifier == AST_Node_Type::Var_Decl) {

const auto &var_name = stmt.children[0]->text;

target_ns[var_name] = Boxed_Value();

} else {

throw exception::eval_error("Only declarations (def, var, auto, global) are allowed inside namespace blocks");

}

};

const auto &body = this->children[1];

if (body->identifier == AST_Node_Type::Block

|| body->identifier == AST_Node_Type::Scopeless_Block) {

for (const auto &child : body->children) {

process_statement(*child);

}

} else {

process_statement(*body);

}

return void_var();

}

private:

mutable std::atomic_uint_fast32_t m_ns_loc = {0};

mutable std::atomic_uint_fast32_t m_root_loc = {0};

mutable std::atomic_uint_fast32_t m_clone_loc = {0};

};

bool Namespace_Block() {

Depth_Counter dc{this};

const auto prev_stack_top = m_match_stack.size();

const auto prev_pos = m_position;

if (Keyword("namespace")) {

if (Id(true)) {

std::string ns_name = m_match_stack.back()->text;

while (Symbol("::")) {

if (!Id(true)) {

throw exception::eval_error("Incomplete namespace name after '::'",

File_Position(m_position.line, m_position.col),

*m_filename);

}

ns_name += "::" + m_match_stack.back()->text;

m_match_stack.pop_back();

}

m_match_stack.back() = make_node<eval::Id_AST_Node<Tracer>>(ns_name, prev_pos.line, prev_pos.col);

while (Eol()) {

}

if (Block()) {

build_match<eval::Namespace_Block_AST_Node<Tracer>>(prev_stack_top);

return true;

}

}

m_position = prev_pos;

while (prev_stack_top != m_match_stack.size()) {

m_match_stack.pop_back();

}

}

return false;

}

} else if (Symbol(".") || Symbol("::")) {

if (Def() || Try() || If() || While() || Namespace_Block() || Class(t_class_allowed) || For() || Switch()) {