Namespace

          
            
static VALUE
rb_namespace_current(VALUE klass)
{
    const rb_namespace_t *ns = rb_current_namespace();
    if (NAMESPACE_USER_P(ns)) {
        return ns->ns_object;
    }
    if (NAMESPACE_BUILTIN_P(ns)) {
        return Qnil;
    }
    return Qfalse;
}

          
        

          
            
VALUE
rb_current_namespace_details(VALUE opt)
{
    const rb_callable_method_entry_t *cme;
    VALUE str, part, nsobj;
    char buf[2048];
    const char *path;
    int calling = 1;
    long i;
    rb_execution_context_t *ec = GET_EC();
    rb_control_frame_t *cfp = ec->cfp;
    rb_thread_t *th = rb_ec_thread_ptr(ec);
    const rb_namespace_t *ns = rb_current_namespace();
    rb_vm_t *vm = GET_VM();
    VALUE require_stack = vm->require_stack;

    str = rb_namespace_inspect(ns ? ns->ns_object : Qfalse);
    if (NIL_P(opt)) return str;

    rb_str_cat_cstr(str, "\n");

    part = rb_namespace_inspect(th->ns ? th->ns->ns_object : Qfalse);
    snprintf(buf, 2048, "main:%s, th->ns:%s, th->nss:%ld, rstack:%ld\n",
             main_namespace ? "t" : "f",
             RSTRING_PTR(part),
             th->namespaces ? RARRAY_LEN(th->namespaces) : 0,
             require_stack ? RARRAY_LEN(require_stack) : 0);
    RB_GC_GUARD(part);
    rb_str_cat_cstr(str, buf);

    if (th->namespaces && RARRAY_LEN(th->namespaces) > 0) {
        for (i=0; i<RARRAY_LEN(th->namespaces); i++) {
            nsobj = RARRAY_AREF(th->namespaces, i);
            part = rb_namespace_inspect(nsobj);
            snprintf(buf, 2048, "  th->nss[%ld] %s\n", i, RSTRING_PTR(part));
            RB_GC_GUARD(part);
            rb_str_cat_cstr(str, buf);
        }
    }


    rb_str_cat_cstr(str, "calls:\n");

    while (calling && cfp) {
        const rb_namespace_t *proc_ns;
        VALUE bh;
        if (VM_FRAME_NS_SWITCH_P(cfp)) {
            bh = rb_vm_frame_block_handler(cfp);
            if (bh && vm_block_handler_type(bh) == block_handler_type_proc) {
                proc_ns = block_proc_namespace(VM_BH_TO_PROC(bh));
                if (NAMESPACE_USER_P(ns)) {
                    part = rb_namespace_inspect(proc_ns->ns_object);
                    snprintf(buf, 2048, " cfp->ns:%s", RSTRING_PTR(part));
                    RB_GC_GUARD(part);
                    calling = 0;
                    break;
                }
            }
        }
        cme = rb_vm_frame_method_entry(cfp);
        if (cme && cme->def) {
            if (cme->def->type == VM_METHOD_TYPE_ISEQ)
                path = RSTRING_PTR(pathobj_path(cme->def->body.iseq.iseqptr->body->location.pathobj));
            else
                path = "(cfunc)";
            ns = cme->def->ns;
            if (ns) {
                part = rb_namespace_inspect(ns->ns_object);
                if (!namespace_ignore_builtin_primitive_methods_p(ns, cme->def)) {
                    snprintf(buf, 2048, " cfp cme->def id:%s, ns:%s, exprim:t, path:%s\n",
                             rb_id2name(cme->def->original_id),
                             RSTRING_PTR(part),
                             path);
                    RB_GC_GUARD(part);
                    rb_str_cat_cstr(str, buf);
                    calling = 0;
                    break;
                }
                else {
                    snprintf(buf, 2048, " cfp cme->def id:%s, ns:%s, exprim:f, path:%s\n",
                             rb_id2name(cme->def->original_id),
                             RSTRING_PTR(part),
                             path);
                    RB_GC_GUARD(part);
                    rb_str_cat_cstr(str, buf);
                }
            }
            else {
                snprintf(buf, 2048, " cfp cme->def id:%s, ns:null, path:%s\n",
                         rb_id2name(cme->def->original_id),
                         path);
                rb_str_cat_cstr(str, buf);
            }
            cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
        }
        else {
            calling = 0;
        }
    }
    rb_str_cat_cstr(str, ".\n");
    return str;
}

          
        

          
            
static VALUE
rb_namespace_s_getenabled(VALUE namespace)
{
    return RBOOL(rb_namespace_available());
}

          
        

          
            
static VALUE
rb_namespace_s_is_builtin_p(VALUE namespace, VALUE klass)
{
    if (RCLASS_PRIME_CLASSEXT_READABLE_P(klass) && !RCLASS_PRIME_CLASSEXT_WRITABLE_P(klass))
        return Qtrue;
    return Qfalse;
}

          
        

          
            
static VALUE
namespace_initialize(VALUE namespace)
{
    rb_namespace_t *ns;
    rb_classext_t *object_classext;
    VALUE entry;
    ID id_namespace_entry;
    CONST_ID(id_namespace_entry, "__namespace_entry__");

    if (!rb_namespace_available()) {
        rb_raise(rb_eRuntimeError, "Namespace is disabled. Set RUBY_NAMESPACE=1 environment variable to use Namespace.");
    }

    entry = rb_class_new_instance_pass_kw(0, NULL, rb_cNamespaceEntry);
    ns = get_namespace_struct_internal(entry);

    ns->ns_object = namespace;
    ns->ns_id = namespace_generate_id();
    ns->load_path = rb_ary_dup(GET_VM()->load_path);
    ns->is_user = true;
    rb_define_singleton_method(ns->load_path, "resolve_feature_path", rb_resolve_feature_path, 1);

    // Set the Namespace object unique/consistent from any namespaces to have just single
    // constant table from any view of every (including main) namespace.
    // If a code in the namespace adds a constant, the constant will be visible even from root/main.
    RCLASS_SET_PRIME_CLASSEXT_WRITABLE(namespace, true);

    // fallback to ivptr for ivars from shapes to manipulate the constant table
    rb_evict_ivars_to_hash(namespace);

    // Get a clean constant table of Object even by writable one
    // because ns was just created, so it has not touched any constants yet.
    object_classext = RCLASS_EXT_WRITABLE_IN_NS(rb_cObject, ns);
    RCLASS_SET_CONST_TBL(namespace, RCLASSEXT_CONST_TBL(object_classext), true);

    rb_ivar_set(namespace, id_namespace_entry, entry);

    setup_pushing_loading_namespace(ns);

    return namespace;
}

          
        

          
            
static VALUE
rb_namespace_inspect(VALUE obj)
{
    rb_namespace_t *ns;
    VALUE r;
    if (obj == Qfalse) {
        r = rb_str_new_cstr("#<Namespace:root>");
        return r;
    }
    ns = rb_get_namespace_t(obj);
    r = rb_str_new_cstr("#<Namespace:");
    rb_str_concat(r, rb_funcall(LONG2NUM(ns->ns_id), rb_intern("to_s"), 0));
    if (NAMESPACE_BUILTIN_P(ns)) {
        rb_str_cat_cstr(r, ",builtin");
    }
    if (NAMESPACE_USER_P(ns)) {
        rb_str_cat_cstr(r, ",user");
    }
    if (NAMESPACE_MAIN_P(ns)) {
        rb_str_cat_cstr(r, ",main");
    }
    else if (NAMESPACE_OPTIONAL_P(ns)) {
        rb_str_cat_cstr(r, ",optional");
    }
    rb_str_cat_cstr(r, ">");
    return r;
}

          
        

          
            
static VALUE
rb_namespace_load(int argc, VALUE *argv, VALUE namespace)
{
    VALUE fname, wrap;
    rb_thread_t *th = GET_THREAD();
    rb_namespace_t *ns = rb_get_namespace_t(namespace);

    rb_scan_args(argc, argv, "11", &fname, &wrap);

    VALUE args = rb_ary_new_from_args(2, fname, wrap);
    namespace_push(th, namespace);
    rb_namespace_push_loading_namespace(ns);
    struct namespace_pop2_arg arg = {
        .th = th,
        .ns = ns
    };
    return rb_ensure(rb_load_entrypoint, args, namespace_both_pop, (VALUE)&arg);
}

          
        

          
            
static VALUE
rb_namespace_load_path(VALUE namespace)
{
    return rb_get_namespace_t(namespace)->load_path;
}

          
        

          
            
static VALUE
rb_namespace_require(VALUE namespace, VALUE fname)
{
    rb_thread_t *th = GET_THREAD();
    rb_namespace_t *ns = rb_get_namespace_t(namespace);
    namespace_push(th, namespace);
    rb_namespace_push_loading_namespace(ns);
    struct namespace_pop2_arg arg = {
        .th = th,
        .ns = ns
    };
    return rb_ensure(rb_require_string, fname, namespace_both_pop, (VALUE)&arg);
}

          
        

          
            
static VALUE
rb_namespace_require_relative(VALUE namespace, VALUE fname)
{
    rb_thread_t *th = GET_THREAD();
    rb_namespace_t *ns = rb_get_namespace_t(namespace);
    namespace_push(th, namespace);
    rb_namespace_push_loading_namespace(ns);
    struct namespace_pop2_arg arg = {
        .th = th,
        .ns = ns
    };
    return rb_ensure(rb_require_relative_entrypoint, fname, namespace_both_pop, (VALUE)&arg);
}