Get receiver object for different levels of calling stack

[lemmuh]

In cruby there is the gem binding_of_caller which can provide the calling object for different levels of the calling stack
e.g.

binding.of_caller(2).eval("self")

Can I get this info also for mruby ?

[dearblue]

There is no way to get it from Ruby side.

From C side, you can get self (receiver) by mrb->c->ci[-caller_level].stack[0].
Valid caller_level is in the range 0 <= caller_level <= (mrb->c->ci - mrb->c->cibase).
Note, however, that when specifying it, a negative sign is added, such as mrb->c->ci[-caller_level].

From C side, you can get self (receiver) by mrb->c->ci[-1 - caller_level].stack[0].
Valid caller_level is in the range 0 <= caller_level < (mrb->c->ci - mrb->c->cibase).

[lemmuh]

Thanks for your reply.

I added a method :of_caller with the caller_level argument to the binding.c file.

This method generates a new binding object with the new self=mrb->c->ci[-caller_level].stack[0]. However, the source_location method returns always nil. Do you know how to fix this ?

static mrb_value
mrb_binding_of_caller(mrb_state *mrb, mrb_value self)
{
  struct RProc *proc;
  struct REnv *env;
  mrb_callinfo *ci;

  mrb_int caller_level;
  mrb_get_args(mrb, "i", &caller_level);

  if (mrb->c->ci->cci != 0)
  {
  caller_err:
    mrb_raise(mrb, E_RUNTIME_ERROR, "Cannot create Binding object for non-Ruby caller");
  }
  proc = (struct RProc *)mrb_proc_get_caller(mrb, &env);
  if (!env || MRB_PROC_CFUNC_P(proc))
  {
    goto caller_err;
  }

  if (caller_level < 0)
    caller_level = 0;
  else if (caller_level > (mrb->c->ci - mrb->c->cibase))
    caller_level = mrb->c->ci - mrb->c->cibase;

  ci = &mrb->c->ci[-caller_level];

  return mrb_binding_new(mrb, proc, ci->stack[0], env);
}

void mrb_mruby_binding_gem_init(mrb_state *mrb)
{
  struct RClass *binding = mrb_define_class(mrb, "Binding", mrb->object_class);
  MRB_SET_INSTANCE_TT(binding, MRB_TT_UNDEF);
  mrb_undef_class_method(mrb, binding, "new");
  mrb_undef_class_method(mrb, binding, "allocate");

  mrb_define_method(mrb, mrb->kernel_module, "binding", mrb_f_binding, MRB_ARGS_NONE());

  mrb_define_method(mrb, binding, "initialize_copy", binding_initialize_copy, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, binding, "local_variable_defined?", binding_local_variable_defined_p, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, binding, "local_variable_get", binding_local_variable_get, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, binding, "local_variable_set", binding_local_variable_set, MRB_ARGS_REQ(2));
  mrb_define_method(mrb, binding, "local_variables", binding_local_variables, MRB_ARGS_NONE());
  mrb_define_method(mrb, binding, "receiver", binding_receiver, MRB_ARGS_NONE());
  mrb_define_method(mrb, binding, "source_location", binding_source_location, MRB_ARGS_NONE());
  mrb_define_method(mrb, binding, "inspect", mrb_any_to_s, MRB_ARGS_NONE());
  mrb_define_method(mrb, binding, "of_caller", mrb_binding_of_caller, MRB_ARGS_REQ(1));
}

[dearblue]

I can think of two things.

• If you are using the mrbc command, the required -g switch is not specified.
• The mrb_proc_get_caller() and mrb_binding_new() used by mrb_binding_of_caller() do not support any level of caller.
  They must be extended to accept ci arguments.

And, there was a mistake in #6072 (comment).
Since the current ci needs to be removed, the range is 0 <= caller_level < (mrb->c->ci - mrb->c->cibase) and is obtained as mrb->c->ci[-1 - caller_level].

[lemmuh]

By using your comments I found a solution which works:

const struct RProc *
mrb_proc_get_caller_(mrb_state *mrb, struct REnv **envp, mrb_callinfo *ci)
{
  struct mrb_context *c = mrb->c;
  const struct RProc *proc = ci->proc;

  if (!proc || MRB_PROC_CFUNC_P(proc))
  {
    if (envp)
      *envp = NULL;
  }
  else
  {
    struct RClass *tc = MRB_PROC_TARGET_CLASS(proc);
    struct REnv *e = mrb_vm_ci_env(ci);

    if (e == NULL)
    {
      int nstacks = proc->body.irep->nlocals;
      e = mrb_env_new(mrb, c, ci, nstacks, ci->stack, tc);
      ci->u.env = e;
    }
    else if (tc)
    {
      e->c = tc;
      mrb_field_write_barrier(mrb, (struct RBasic *)e, (struct RBasic *)tc);
    }
    if (envp)
      *envp = e;
  }

  return proc;
}

mrb_value
mrb_binding_new_(mrb_state *mrb, const struct RProc *proc, mrb_value recv, struct REnv *env, mrb_callinfo *ci)
{
  struct RObject *binding = MRB_OBJ_ALLOC(mrb, MRB_TT_OBJECT, mrb_class_get_id(mrb, MRB_SYM(Binding)));

  if (proc && !MRB_PROC_CFUNC_P(proc))
  {
    const mrb_irep *irep = proc->body.irep;
    mrb_obj_iv_set(mrb, binding, MRB_SYM(pc), mrb_fixnum_value(ci->pc - irep->iseq - 1 /* step back */));
  }
  proc = binding_wrap_lvspace(mrb, proc, &env);

  mrb_obj_iv_set(mrb, binding, MRB_SYM(proc), mrb_obj_value((void *)proc));
  mrb_obj_iv_set(mrb, binding, MRB_SYM(recv), recv);
  mrb_obj_iv_set(mrb, binding, MRB_SYM(env), mrb_obj_value(env));

  return mrb_obj_value(binding);
}

static mrb_value
mrb_binding_of_caller(mrb_state *mrb, mrb_value self)
{
  struct REnv *env;
  struct RProc *proc;
  mrb_int caller_level;
  mrb_callinfo *ci;

  mrb_get_args(mrb, "i", &caller_level);

  if (caller_level < 0)
    caller_level = 0;
  else if (caller_level >= (mrb->c->ci - mrb->c->cibase))
    caller_level = (mrb->c->ci - mrb->c->cibase) - 1;

  ci = &mrb->c->ci[-1 - caller_level];

  if (mrb->c->ci->cci != 0)
  {
  caller_err:
    mrb_raise(mrb, E_RUNTIME_ERROR, "Cannot create Binding object for non-Ruby caller");
  }
  proc = (struct RProc *)mrb_proc_get_caller_(mrb, &env, ci);
  if (!env || MRB_PROC_CFUNC_P(proc))
  {
    goto caller_err;
  }

  return mrb_binding_new_(mrb, ci->proc, ci->stack[0], env, ci);
}

void mrb_mruby_binding_gem_init(mrb_state *mrb)
{
  struct RClass *binding = mrb_define_class(mrb, "Binding", mrb->object_class);
  MRB_SET_INSTANCE_TT(binding, MRB_TT_UNDEF);
  mrb_undef_class_method(mrb, binding, "new");
  mrb_undef_class_method(mrb, binding, "allocate");

  mrb_define_method(mrb, mrb->kernel_module, "binding", mrb_f_binding, MRB_ARGS_NONE());

  mrb_define_method(mrb, binding, "initialize_copy", binding_initialize_copy, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, binding, "local_variable_defined?", binding_local_variable_defined_p, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, binding, "local_variable_get", binding_local_variable_get, MRB_ARGS_REQ(1));
  mrb_define_method(mrb, binding, "local_variable_set", binding_local_variable_set, MRB_ARGS_REQ(2));
  mrb_define_method(mrb, binding, "local_variables", binding_local_variables, MRB_ARGS_NONE());
  mrb_define_method(mrb, binding, "receiver", binding_receiver, MRB_ARGS_NONE());
  mrb_define_method(mrb, binding, "source_location", binding_source_location, MRB_ARGS_NONE());
  mrb_define_method(mrb, binding, "inspect", mrb_any_to_s, MRB_ARGS_NONE());
  mrb_define_method(mrb, binding, "of_caller", mrb_binding_of_caller, MRB_ARGS_REQ(1));
}

Thanks for your help !

[lemmuh]

Can this discussion be kept open/stored somewhere in order that others can benefit out of this ?

[dearblue]

You can mark comments that have been answered.
https://docs.github.com/en/discussions/collaborating-with-your-community-using-discussions/participating-in-a-discussion#marking-a-comment-as-an-answer

The status of this discussion should not need to be closed.
However, you should close duplicate #6073.