Fresh start

1 files changed, 2886 insertions, 0 deletions

diff --git a/jni/ruby/proc.c b/jni/ruby/proc.c
new file mode 100644
index 0000000..573dcb4
--- /dev/null
+++ b/jni/ruby/proc.c
@@ -0,0 +1,2886 @@
+/**********************************************************************
+
+  proc.c - Proc, Binding, Env
+
+  $Author: nagachika $
+  created at: Wed Jan 17 12:13:14 2007
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+#include "eval_intern.h"
+#include "internal.h"
+#include "gc.h"
+#include "iseq.h"
+
+const NODE *rb_vm_cref_in_context(VALUE self, VALUE cbase);
+
+struct METHOD {
+    VALUE recv;
+    VALUE rclass;
+    VALUE defined_class;
+    ID id;
+    rb_method_entry_t *me;
+    struct unlinked_method_entry_list_entry *ume;
+};
+
+VALUE rb_cUnboundMethod;
+VALUE rb_cMethod;
+VALUE rb_cBinding;
+VALUE rb_cProc;
+
+static VALUE bmcall(VALUE, VALUE, int, VALUE *, VALUE);
+static int method_arity(VALUE);
+static int method_min_max_arity(VALUE, int *max);
+#define attached id__attached__
+
+/* Proc */
+
+#define IS_METHOD_PROC_NODE(node) (nd_type(node) == NODE_IFUNC && (node)->nd_cfnc == bmcall)
+
+static void
+proc_mark(void *ptr)
+{
+    rb_proc_t *proc = ptr;
+    RUBY_MARK_ENTER("proc");
+    RUBY_MARK_UNLESS_NULL(proc->envval);
+    RUBY_MARK_UNLESS_NULL(proc->blockprocval);
+    RUBY_MARK_UNLESS_NULL(proc->block.proc);
+    RUBY_MARK_UNLESS_NULL(proc->block.self);
+    if (proc->block.iseq && RUBY_VM_IFUNC_P(proc->block.iseq)) {
+	RUBY_MARK_UNLESS_NULL((VALUE)(proc->block.iseq));
+    }
+    RUBY_MARK_LEAVE("proc");
+}
+
+static size_t
+proc_memsize(const void *ptr)
+{
+    return sizeof(rb_proc_t);
+}
+
+static const rb_data_type_t proc_data_type = {
+    "proc",
+    {
+	proc_mark,
+	RUBY_TYPED_DEFAULT_FREE,
+	proc_memsize,
+    },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE
+rb_proc_wrap(VALUE klass, rb_proc_t *proc)
+{
+    proc->block.proc = TypedData_Wrap_Struct(klass, &proc_data_type, proc);
+
+    return proc->block.proc;
+}
+
+VALUE
+rb_obj_is_proc(VALUE proc)
+{
+    if (rb_typeddata_is_kind_of(proc, &proc_data_type)) {
+	return Qtrue;
+    }
+    else {
+	return Qfalse;
+    }
+}
+
+/* :nodoc: */
+static VALUE
+proc_dup(VALUE self)
+{
+    VALUE procval;
+    rb_proc_t *src;
+    rb_proc_t *dst = ALLOC(rb_proc_t);
+
+    GetProcPtr(self, src);
+    *dst = *src;
+    procval = rb_proc_wrap(rb_cProc, dst);
+    RB_GC_GUARD(self); /* for: body = proc_dup(body) */
+
+    return procval;
+}
+
+/* :nodoc: */
+static VALUE
+proc_clone(VALUE self)
+{
+    VALUE procval = proc_dup(self);
+    CLONESETUP(procval, self);
+    return procval;
+}
+
+/*
+ * call-seq:
+ *   prc.lambda? -> true or false
+ *
+ * Returns +true+ for a Proc object for which argument handling is rigid.
+ * Such procs are typically generated by +lambda+.
+ *
+ * A Proc object generated by +proc+ ignores extra arguments.
+ *
+ *   proc {|a,b| [a,b] }.call(1,2,3)    #=> [1,2]
+ *
+ * It provides +nil+ for missing arguments.
+ *
+ *   proc {|a,b| [a,b] }.call(1)        #=> [1,nil]
+ *
+ * It expands a single array argument.
+ *
+ *   proc {|a,b| [a,b] }.call([1,2])    #=> [1,2]
+ *
+ * A Proc object generated by +lambda+ doesn't have such tricks.
+ *
+ *   lambda {|a,b| [a,b] }.call(1,2,3)  #=> ArgumentError
+ *   lambda {|a,b| [a,b] }.call(1)      #=> ArgumentError
+ *   lambda {|a,b| [a,b] }.call([1,2])  #=> ArgumentError
+ *
+ * Proc#lambda? is a predicate for the tricks.
+ * It returns +true+ if no tricks apply.
+ *
+ *   lambda {}.lambda?            #=> true
+ *   proc {}.lambda?              #=> false
+ *
+ * Proc.new is the same as +proc+.
+ *
+ *   Proc.new {}.lambda?          #=> false
+ *
+ * +lambda+, +proc+ and Proc.new preserve the tricks of
+ * a Proc object given by <code>&</code> argument.
+ *
+ *   lambda(&lambda {}).lambda?   #=> true
+ *   proc(&lambda {}).lambda?     #=> true
+ *   Proc.new(&lambda {}).lambda? #=> true
+ *
+ *   lambda(&proc {}).lambda?     #=> false
+ *   proc(&proc {}).lambda?       #=> false
+ *   Proc.new(&proc {}).lambda?   #=> false
+ *
+ * A Proc object generated by <code>&</code> argument has the tricks
+ *
+ *   def n(&b) b.lambda? end
+ *   n {}                         #=> false
+ *
+ * The <code>&</code> argument preserves the tricks if a Proc object
+ * is given by <code>&</code> argument.
+ *
+ *   n(&lambda {})                #=> true
+ *   n(&proc {})                  #=> false
+ *   n(&Proc.new {})              #=> false
+ *
+ * A Proc object converted from a method has no tricks.
+ *
+ *   def m() end
+ *   method(:m).to_proc.lambda?   #=> true
+ *
+ *   n(&method(:m))               #=> true
+ *   n(&method(:m).to_proc)       #=> true
+ *
+ * +define_method+ is treated the same as method definition.
+ * The defined method has no tricks.
+ *
+ *   class C
+ *     define_method(:d) {}
+ *   end
+ *   C.new.d(1,2)       #=> ArgumentError
+ *   C.new.method(:d).to_proc.lambda?   #=> true
+ *
+ * +define_method+ always defines a method without the tricks,
+ * even if a non-lambda Proc object is given.
+ * This is the only exception for which the tricks are not preserved.
+ *
+ *   class C
+ *     define_method(:e, &proc {})
+ *   end
+ *   C.new.e(1,2)       #=> ArgumentError
+ *   C.new.method(:e).to_proc.lambda?   #=> true
+ *
+ * This exception insures that methods never have tricks
+ * and makes it easy to have wrappers to define methods that behave as usual.
+ *
+ *   class C
+ *     def self.def2(name, &body)
+ *       define_method(name, &body)
+ *     end
+ *
+ *     def2(:f) {}
+ *   end
+ *   C.new.f(1,2)       #=> ArgumentError
+ *
+ * The wrapper <i>def2</i> defines a method which has no tricks.
+ *
+ */
+
+VALUE
+rb_proc_lambda_p(VALUE procval)
+{
+    rb_proc_t *proc;
+    GetProcPtr(procval, proc);
+
+    return proc->is_lambda ? Qtrue : Qfalse;
+}
+
+/* Binding */
+
+static void
+binding_free(void *ptr)
+{
+    rb_binding_t *bind;
+    RUBY_FREE_ENTER("binding");
+    if (ptr) {
+	bind = ptr;
+	ruby_xfree(bind);
+    }
+    RUBY_FREE_LEAVE("binding");
+}
+
+static void
+binding_mark(void *ptr)
+{
+    rb_binding_t *bind;
+    RUBY_MARK_ENTER("binding");
+    if (ptr) {
+	bind = ptr;
+	RUBY_MARK_UNLESS_NULL(bind->env);
+	RUBY_MARK_UNLESS_NULL(bind->path);
+	RUBY_MARK_UNLESS_NULL(bind->blockprocval);
+    }
+    RUBY_MARK_LEAVE("binding");
+}
+
+static size_t
+binding_memsize(const void *ptr)
+{
+    return ptr ? sizeof(rb_binding_t) : 0;
+}
+
+const rb_data_type_t ruby_binding_data_type = {
+    "binding",
+    {
+	binding_mark,
+	binding_free,
+	binding_memsize,
+    },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE
+rb_binding_alloc(VALUE klass)
+{
+    VALUE obj;
+    rb_binding_t *bind;
+    obj = TypedData_Make_Struct(klass, rb_binding_t, &ruby_binding_data_type, bind);
+    return obj;
+}
+
+/* :nodoc: */
+static VALUE
+binding_dup(VALUE self)
+{
+    VALUE bindval = rb_binding_alloc(rb_cBinding);
+    rb_binding_t *src, *dst;
+    GetBindingPtr(self, src);
+    GetBindingPtr(bindval, dst);
+    dst->env = src->env;
+    dst->path = src->path;
+    dst->blockprocval = src->blockprocval;
+    dst->first_lineno = src->first_lineno;
+    return bindval;
+}
+
+/* :nodoc: */
+static VALUE
+binding_clone(VALUE self)
+{
+    VALUE bindval = binding_dup(self);
+    CLONESETUP(bindval, self);
+    return bindval;
+}
+
+VALUE
+rb_binding_new(void)
+{
+    rb_thread_t *th = GET_THREAD();
+    return rb_vm_make_binding(th, th->cfp);
+}
+
+/*
+ *  call-seq:
+ *     binding -> a_binding
+ *
+ *  Returns a +Binding+ object, describing the variable and
+ *  method bindings at the point of call. This object can be used when
+ *  calling +eval+ to execute the evaluated command in this
+ *  environment. See also the description of class +Binding+.
+ *
+ *     def get_binding(param)
+ *       return binding
+ *     end
+ *     b = get_binding("hello")
+ *     eval("param", b)   #=> "hello"
+ */
+
+static VALUE
+rb_f_binding(VALUE self)
+{
+    return rb_binding_new();
+}
+
+/*
+ *  call-seq:
+ *     binding.eval(string [, filename [,lineno]])  -> obj
+ *
+ *  Evaluates the Ruby expression(s) in <em>string</em>, in the
+ *  <em>binding</em>'s context.  If the optional <em>filename</em> and
+ *  <em>lineno</em> parameters are present, they will be used when
+ *  reporting syntax errors.
+ *
+ *     def get_binding(param)
+ *       return binding
+ *     end
+ *     b = get_binding("hello")
+ *     b.eval("param")   #=> "hello"
+ */
+
+static VALUE
+bind_eval(int argc, VALUE *argv, VALUE bindval)
+{
+    VALUE args[4];
+
+    rb_scan_args(argc, argv, "12", &args[0], &args[2], &args[3]);
+    args[1] = bindval;
+    return rb_f_eval(argc+1, args, Qnil /* self will be searched in eval */);
+}
+
+static VALUE *
+get_local_variable_ptr(VALUE envval, ID lid)
+{
+    rb_env_t *env;
+
+    do {
+	const rb_iseq_t *iseq;
+	int i;
+
+	GetEnvPtr(envval, env);
+	iseq = env->block.iseq;
+
+	for (i=0; i<iseq->local_table_size; i++) {
+	    if (iseq->local_table[i] == lid) {
+		return &env->env[i];
+	    }
+	}
+    } while ((envval = env->prev_envval) != 0);
+
+    return 0;
+}
+
+/*
+ * check local variable name.
+ * returns ID if it's an already interned symbol, or 0 with setting
+ * local name in String to *namep.
+ */
+static ID
+check_local_id(VALUE bindval, volatile VALUE *pname)
+{
+    ID lid = rb_check_id(pname);
+    VALUE name = *pname, sym = name;
+
+    if (lid) {
+	if (!rb_is_local_id(lid)) {
+	    name = rb_id2str(lid);
+	  wrong:
+	    rb_name_error_str(sym, "wrong local variable name `% "PRIsVALUE"' for %"PRIsVALUE,
+			      name, bindval);
+	}
+    }
+    else {
+	if (!rb_is_local_name(sym)) goto wrong;
+	return 0;
+    }
+    return lid;
+}
+
+/*
+ *  call-seq:
+ *     binding.local_variables -> Array
+ *
+ *  Returns the +symbol+ names of the binding's local variables
+ *
+ *	def foo
+ *  	  a = 1
+ *  	  2.times do |n|
+ *  	    binding.local_variables #=> [:a, :n]
+ *  	  end
+ *  	end
+ *
+ *  This method is short version of the following code.
+ *
+ *	binding.eval("local_variables")
+ *
+ */
+static VALUE
+bind_local_variables(VALUE bindval)
+{
+    const rb_binding_t *bind;
+
+    GetBindingPtr(bindval, bind);
+    return rb_vm_env_local_variables(bind->env);
+}
+
+/*
+ *  call-seq:
+ *     binding.local_variable_get(symbol) -> obj
+ *
+ *  Returns a +value+ of local variable +symbol+.
+ *
+ *	def foo
+ *  	  a = 1
+ *  	  binding.local_variable_get(:a) #=> 1
+ *  	  binding.local_variable_get(:b) #=> NameError
+ *  	end
+ *
+ *  This method is short version of the following code.
+ *
+ *	binding.eval("#{symbol}")
+ *
+ */
+static VALUE
+bind_local_variable_get(VALUE bindval, VALUE sym)
+{
+    ID lid = check_local_id(bindval, &sym);
+    const rb_binding_t *bind;
+    const VALUE *ptr;
+
+    if (!lid) goto undefined;
+
+    GetBindingPtr(bindval, bind);
+
+    if ((ptr = get_local_variable_ptr(bind->env, lid)) == NULL) {
+      undefined:
+	rb_name_error_str(sym, "local variable `%"PRIsVALUE"' not defined for %"PRIsVALUE,
+			  sym, bindval);
+    }
+
+    return *ptr;
+}
+
+/*
+ *  call-seq:
+ *     binding.local_variable_set(symbol, obj) -> obj
+ *
+ *  Set local variable named +symbol+ as +obj+.
+ *
+ *	def foo
+ *  	  a = 1
+ *  	  b = binding
+ *  	  b.local_variable_set(:a, 2) # set existing local variable `a'
+ *  	  b.local_variable_set(:b, 3) # create new local variable `b'
+ *  	                              # `b' exists only in binding.
+ *  	  b.local_variable_get(:a) #=> 2
+ *  	  b.local_variable_get(:b) #=> 3
+ *  	  p a #=> 2
+ *  	  p b #=> NameError
+ *  	end
+ *
+ *  This method is a similar behavior of the following code
+ *
+ *    binding.eval("#{symbol} = #{obj}")
+ *
+ *  if obj can be dumped in Ruby code.
+ */
+static VALUE
+bind_local_variable_set(VALUE bindval, VALUE sym, VALUE val)
+{
+    ID lid = check_local_id(bindval, &sym);
+    rb_binding_t *bind;
+    VALUE *ptr;
+
+    if (!lid) lid = rb_intern_str(sym);
+
+    GetBindingPtr(bindval, bind);
+    if ((ptr = get_local_variable_ptr(bind->env, lid)) == NULL) {
+	/* not found. create new env */
+	ptr = rb_binding_add_dynavars(bind, 1, &lid);
+    }
+
+    *ptr = val;
+
+    return val;
+}
+
+/*
+ *  call-seq:
+ *     binding.local_variable_defined?(symbol) -> obj
+ *
+ *  Returns a +true+ if a local variable +symbol+ exists.
+ *
+ *	def foo
+ *  	  a = 1
+ *  	  binding.local_variable_defined?(:a) #=> true
+ *  	  binding.local_variable_defined?(:b) #=> false
+ *  	end
+ *
+ *  This method is short version of the following code.
+ *
+ *	binding.eval("defined?(#{symbol}) == 'local-variable'")
+ *
+ */
+static VALUE
+bind_local_variable_defined_p(VALUE bindval, VALUE sym)
+{
+    ID lid = check_local_id(bindval, &sym);
+    const rb_binding_t *bind;
+
+    if (!lid) return Qfalse;
+
+    GetBindingPtr(bindval, bind);
+    return get_local_variable_ptr(bind->env, lid) ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     binding.receiver    -> object
+ *
+ *  Returns the bound receiver of the binding object.
+ */
+static VALUE
+bind_receiver(VALUE bindval)
+{
+    const rb_binding_t *bind;
+    const rb_env_t *env;
+
+    GetBindingPtr(bindval, bind);
+    GetEnvPtr(bind->env, env);
+    return env->block.self;
+}
+
+static VALUE
+proc_new(VALUE klass, int8_t is_lambda)
+{
+    VALUE procval = Qnil;
+    rb_thread_t *th = GET_THREAD();
+    rb_control_frame_t *cfp = th->cfp;
+    rb_block_t *block;
+
+    if (!(block = rb_vm_control_frame_block_ptr(cfp))) {
+	cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+
+	if ((block = rb_vm_control_frame_block_ptr(cfp)) != 0) {
+	    if (is_lambda) {
+		rb_warn("tried to create Proc object without a block");
+	    }
+	}
+	else {
+	    rb_raise(rb_eArgError,
+		     "tried to create Proc object without a block");
+	}
+    }
+
+    procval = block->proc;
+
+    if (procval) {
+	if (RBASIC(procval)->klass == klass) {
+	    return procval;
+	}
+	else {
+	    VALUE newprocval = proc_dup(procval);
+	    RBASIC_SET_CLASS(newprocval, klass);
+	    return newprocval;
+	}
+    }
+
+    procval = rb_vm_make_proc_lambda(th, block, klass, is_lambda);
+    return procval;
+}
+
+/*
+ *  call-seq:
+ *     Proc.new {|...| block } -> a_proc
+ *     Proc.new                -> a_proc
+ *
+ *  Creates a new <code>Proc</code> object, bound to the current
+ *  context. <code>Proc::new</code> may be called without a block only
+ *  within a method with an attached block, in which case that block is
+ *  converted to the <code>Proc</code> object.
+ *
+ *     def proc_from
+ *       Proc.new
+ *     end
+ *     proc = proc_from { "hello" }
+ *     proc.call   #=> "hello"
+ */
+
+static VALUE
+rb_proc_s_new(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE block = proc_new(klass, FALSE);
+
+    rb_obj_call_init(block, argc, argv);
+    return block;
+}
+
+/*
+ * call-seq:
+ *   proc   { |...| block }  -> a_proc
+ *
+ * Equivalent to <code>Proc.new</code>.
+ */
+
+VALUE
+rb_block_proc(void)
+{
+    return proc_new(rb_cProc, FALSE);
+}
+
+/*
+ * call-seq:
+ *   lambda { |...| block }  -> a_proc
+ *
+ * Equivalent to <code>Proc.new</code>, except the resulting Proc objects
+ * check the number of parameters passed when called.
+ */
+
+VALUE
+rb_block_lambda(void)
+{
+    return proc_new(rb_cProc, TRUE);
+}
+
+VALUE
+rb_block_clear_env_self(VALUE proc)
+{
+    rb_proc_t *po;
+    rb_env_t *env;
+    GetProcPtr(proc, po);
+    GetEnvPtr(po->envval, env);
+    env->env[0] = Qnil;
+    return proc;
+}
+
+/*  Document-method: ===
+ *
+ *  call-seq:
+ *     proc === obj   -> result_of_proc
+ *
+ *  Invokes the block with +obj+ as the proc's parameter like Proc#call.  It
+ *  is to allow a proc object to be a target of +when+ clause in a case
+ *  statement.
+ */
+
+/* CHECKME: are the argument checking semantics correct? */
+
+/*
+ *  call-seq:
+ *     prc.call(params,...)   -> obj
+ *     prc[params,...]        -> obj
+ *     prc.(params,...)       -> obj
+ *
+ *  Invokes the block, setting the block's parameters to the values in
+ *  <i>params</i> using something close to method calling semantics.
+ *  Generates a warning if multiple values are passed to a proc that
+ *  expects just one (previously this silently converted the parameters
+ *  to an array).  Note that prc.() invokes prc.call() with the parameters
+ *  given.  It's a syntax sugar to hide "call".
+ *
+ *  For procs created using <code>lambda</code> or <code>->()</code> an error
+ *  is generated if the wrong number of parameters are passed to a Proc with
+ *  multiple parameters.  For procs created using <code>Proc.new</code> or
+ *  <code>Kernel.proc</code>, extra parameters are silently discarded.
+ *
+ *  Returns the value of the last expression evaluated in the block. See
+ *  also <code>Proc#yield</code>.
+ *
+ *     a_proc = Proc.new {|a, *b| b.collect {|i| i*a }}
+ *     a_proc.call(9, 1, 2, 3)   #=> [9, 18, 27]
+ *     a_proc[9, 1, 2, 3]        #=> [9, 18, 27]
+ *     a_proc = lambda {|a,b| a}
+ *     a_proc.call(1,2,3)
+ *
+ *  <em>produces:</em>
+ *
+ *     prog.rb:4:in `block in <main>': wrong number of arguments (3 for 2) (ArgumentError)
+ *     	from prog.rb:5:in `call'
+ *     	from prog.rb:5:in `<main>'
+ *
+ */
+
+static VALUE
+proc_call(int argc, VALUE *argv, VALUE procval)
+{
+    VALUE vret;
+    rb_proc_t *proc;
+    rb_block_t *blockptr = 0;
+    rb_iseq_t *iseq;
+    VALUE passed_procval;
+    GetProcPtr(procval, proc);
+
+    iseq = proc->block.iseq;
+    if (RUBY_VM_IFUNC_P(iseq) || iseq->param.flags.has_block) {
+	if (rb_block_given_p()) {
+	    rb_proc_t *passed_proc;
+	    RB_GC_GUARD(passed_procval) = rb_block_proc();
+	    GetProcPtr(passed_procval, passed_proc);
+	    blockptr = &passed_proc->block;
+	}
+    }
+
+    vret = rb_vm_invoke_proc(GET_THREAD(), proc, argc, argv, blockptr);
+    RB_GC_GUARD(procval);
+    return vret;
+}
+
+#if SIZEOF_LONG > SIZEOF_INT
+static inline int
+check_argc(long argc)
+{
+    if (argc > INT_MAX || argc < 0) {
+	rb_raise(rb_eArgError, "too many arguments (%lu)",
+		 (unsigned long)argc);
+    }
+    return (int)argc;
+}
+#else
+#define check_argc(argc) (argc)
+#endif
+
+VALUE
+rb_proc_call(VALUE self, VALUE args)
+{
+    VALUE vret;
+    rb_proc_t *proc;
+    GetProcPtr(self, proc);
+    vret = rb_vm_invoke_proc(GET_THREAD(), proc, check_argc(RARRAY_LEN(args)), RARRAY_CONST_PTR(args), 0);
+    RB_GC_GUARD(self);
+    RB_GC_GUARD(args);
+    return vret;
+}
+
+VALUE
+rb_proc_call_with_block(VALUE self, int argc, const VALUE *argv, VALUE pass_procval)
+{
+    VALUE vret;
+    rb_proc_t *proc;
+    rb_block_t *block = 0;
+    GetProcPtr(self, proc);
+
+    if (!NIL_P(pass_procval)) {
+	rb_proc_t *pass_proc;
+	GetProcPtr(pass_procval, pass_proc);
+	block = &pass_proc->block;
+    }
+
+    vret = rb_vm_invoke_proc(GET_THREAD(), proc, argc, argv, block);
+    RB_GC_GUARD(self);
+    RB_GC_GUARD(pass_procval);
+    return vret;
+}
+
+
+/*
+ *  call-seq:
+ *     prc.arity -> fixnum
+ *
+ *  Returns the number of mandatory arguments. If the block
+ *  is declared to take no arguments, returns 0. If the block is known
+ *  to take exactly n arguments, returns n.
+ *  If the block has optional arguments, returns -n-1, where n is the
+ *  number of mandatory arguments, with the exception for blocks that
+ *  are not lambdas and have only a finite number of optional arguments;
+ *  in this latter case, returns n.
+ *  Keywords arguments will considered as a single additional argument,
+ *  that argument being mandatory if any keyword argument is mandatory.
+ *  A <code>proc</code> with no argument declarations
+ *  is the same as a block declaring <code>||</code> as its arguments.
+ *
+ *     proc {}.arity                  #=>  0
+ *     proc { || }.arity              #=>  0
+ *     proc { |a| }.arity             #=>  1
+ *     proc { |a, b| }.arity          #=>  2
+ *     proc { |a, b, c| }.arity       #=>  3
+ *     proc { |*a| }.arity            #=> -1
+ *     proc { |a, *b| }.arity         #=> -2
+ *     proc { |a, *b, c| }.arity      #=> -3
+ *     proc { |x:, y:, z:0| }.arity   #=>  1
+ *     proc { |*a, x:, y:0| }.arity   #=> -2
+ *
+ *     proc   { |x=0| }.arity         #=>  0
+ *     lambda { |x=0| }.arity         #=> -1
+ *     proc   { |x=0, y| }.arity      #=>  1
+ *     lambda { |x=0, y| }.arity      #=> -2
+ *     proc   { |x=0, y=0| }.arity    #=>  0
+ *     lambda { |x=0, y=0| }.arity    #=> -1
+ *     proc   { |x, y=0| }.arity      #=>  1
+ *     lambda { |x, y=0| }.arity      #=> -2
+ *     proc   { |(x, y), z=0| }.arity #=>  1
+ *     lambda { |(x, y), z=0| }.arity #=> -2
+ *     proc   { |a, x:0, y:0| }.arity #=>  1
+ *     lambda { |a, x:0, y:0| }.arity #=> -2
+ */
+
+static VALUE
+proc_arity(VALUE self)
+{
+    int arity = rb_proc_arity(self);
+    return INT2FIX(arity);
+}
+
+static inline int
+rb_iseq_min_max_arity(const rb_iseq_t *iseq, int *max)
+{
+    *max = iseq->param.flags.has_rest == FALSE ?
+      iseq->param.lead_num + iseq->param.opt_num + iseq->param.post_num +
+      (iseq->param.flags.has_kw == TRUE || iseq->param.flags.has_kwrest == TRUE)
+      : UNLIMITED_ARGUMENTS;
+    return iseq->param.lead_num + iseq->param.post_num + (iseq->param.flags.has_kw && iseq->param.keyword->required_num > 0);
+}
+
+static int
+rb_block_min_max_arity(rb_block_t *block, int *max)
+{
+    rb_iseq_t *iseq = block->iseq;
+    if (iseq) {
+	if (!RUBY_VM_IFUNC_P(iseq)) {
+	    return rb_iseq_min_max_arity(iseq, max);
+	}
+	else {
+	    NODE *node = (NODE *)iseq;
+	    if (IS_METHOD_PROC_NODE(node)) {
+		/* e.g. method(:foo).to_proc.arity */
+		return method_min_max_arity(node->nd_tval, max);
+	    }
+	}
+    }
+    *max = UNLIMITED_ARGUMENTS;
+    return 0;
+}
+
+/*
+ * Returns the number of required parameters and stores the maximum
+ * number of parameters in max, or UNLIMITED_ARGUMENTS if no max.
+ * For non-lambda procs, the maximum is the number of non-ignored
+ * parameters even though there is no actual limit to the number of parameters
+ */
+static int
+rb_proc_min_max_arity(VALUE self, int *max)
+{
+    rb_proc_t *proc;
+    rb_block_t *block;
+    GetProcPtr(self, proc);
+    block = &proc->block;
+    return rb_block_min_max_arity(block, max);
+}
+
+int
+rb_proc_arity(VALUE self)
+{
+    rb_proc_t *proc;
+    int max, min = rb_proc_min_max_arity(self, &max);
+    GetProcPtr(self, proc);
+    return (proc->is_lambda ? min == max : max != UNLIMITED_ARGUMENTS) ? min : -min-1;
+}
+
+int
+rb_block_arity(void)
+{
+    int min, max;
+    rb_thread_t *th = GET_THREAD();
+    rb_control_frame_t *cfp = th->cfp;
+    rb_block_t *block = rb_vm_control_frame_block_ptr(cfp);
+    VALUE proc_value;
+
+    if (!block) rb_raise(rb_eArgError, "no block given");
+    min = rb_block_min_max_arity(block, &max);
+    proc_value = block->proc;
+    if (proc_value) {
+	rb_proc_t *proc;
+	GetProcPtr(proc_value, proc);
+	if (proc)
+	    return (proc->is_lambda ? min == max : max != UNLIMITED_ARGUMENTS) ? min : -min-1;
+    }
+    return max != UNLIMITED_ARGUMENTS ? min : -min-1;
+}
+
+#define get_proc_iseq rb_proc_get_iseq
+
+rb_iseq_t *
+rb_proc_get_iseq(VALUE self, int *is_proc)
+{
+    rb_proc_t *proc;
+    rb_iseq_t *iseq;
+
+    GetProcPtr(self, proc);
+    iseq = proc->block.iseq;
+    if (is_proc) *is_proc = !proc->is_lambda;
+    if (!RUBY_VM_NORMAL_ISEQ_P(iseq)) {
+	NODE *node = (NODE *)iseq;
+	iseq = 0;
+	if (IS_METHOD_PROC_NODE(node)) {
+	    /* method(:foo).to_proc */
+	    iseq = rb_method_get_iseq(node->nd_tval);
+	    if (is_proc) *is_proc = 0;
+	}
+    }
+    return iseq;
+}
+
+static VALUE
+iseq_location(rb_iseq_t *iseq)
+{
+    VALUE loc[2];
+
+    if (!iseq) return Qnil;
+    loc[0] = iseq->location.path;
+    if (iseq->line_info_table) {
+	loc[1] = rb_iseq_first_lineno(iseq->self);
+    }
+    else {
+	loc[1] = Qnil;
+    }
+    return rb_ary_new4(2, loc);
+}
+
+/*
+ * call-seq:
+ *    prc.source_location  -> [String, Fixnum]
+ *
+ * Returns the Ruby source filename and line number containing this proc
+ * or +nil+ if this proc was not defined in Ruby (i.e. native)
+ */
+
+VALUE
+rb_proc_location(VALUE self)
+{
+    return iseq_location(get_proc_iseq(self, 0));
+}
+
+static VALUE
+unnamed_parameters(int arity)
+{
+    VALUE a, param = rb_ary_new2((arity < 0) ? -arity : arity);
+    int n = (arity < 0) ? ~arity : arity;
+    ID req, rest;
+    CONST_ID(req, "req");
+    a = rb_ary_new3(1, ID2SYM(req));
+    OBJ_FREEZE(a);
+    for (; n; --n) {
+	rb_ary_push(param, a);
+    }
+    if (arity < 0) {
+	CONST_ID(rest, "rest");
+	rb_ary_store(param, ~arity, rb_ary_new3(1, ID2SYM(rest)));
+    }
+    return param;
+}
+
+/*
+ * call-seq:
+ *    prc.parameters  -> array
+ *
+ * Returns the parameter information of this proc.
+ *
+ *    prc = lambda{|x, y=42, *other|}
+ *    prc.parameters  #=> [[:req, :x], [:opt, :y], [:rest, :other]]
+ */
+
+static VALUE
+rb_proc_parameters(VALUE self)
+{
+    int is_proc;
+    rb_iseq_t *iseq = get_proc_iseq(self, &is_proc);
+    if (!iseq) {
+	return unnamed_parameters(rb_proc_arity(self));
+    }
+    return rb_iseq_parameters(iseq, is_proc);
+}
+
+st_index_t
+rb_hash_proc(st_index_t hash, VALUE prc)
+{
+    rb_proc_t *proc;
+    GetProcPtr(prc, proc);
+    hash = rb_hash_uint(hash, (st_index_t)proc->block.iseq);
+    hash = rb_hash_uint(hash, (st_index_t)proc->envval);
+    return rb_hash_uint(hash, (st_index_t)proc->block.ep >> 16);
+}
+
+/*
+ * call-seq:
+ *   prc.hash   ->  integer
+ *
+ * Returns a hash value corresponding to proc body.
+ *
+ * See also Object#hash.
+ */
+
+static VALUE
+proc_hash(VALUE self)
+{
+    st_index_t hash;
+    hash = rb_hash_start(0);
+    hash = rb_hash_proc(hash, self);
+    hash = rb_hash_end(hash);
+    return LONG2FIX(hash);
+}
+
+/*
+ * call-seq:
+ *   prc.to_s   -> string
+ *
+ * Returns the unique identifier for this proc, along with
+ * an indication of where the proc was defined.
+ */
+
+static VALUE
+proc_to_s(VALUE self)
+{
+    VALUE str = 0;
+    rb_proc_t *proc;
+    const char *cname = rb_obj_classname(self);
+    rb_iseq_t *iseq;
+    const char *is_lambda;
+
+    GetProcPtr(self, proc);
+    iseq = proc->block.iseq;
+    is_lambda = proc->is_lambda ? " (lambda)" : "";
+
+    if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
+	int first_lineno = 0;
+
+	if (iseq->line_info_table) {
+	    first_lineno = FIX2INT(rb_iseq_first_lineno(iseq->self));
+	}
+	str = rb_sprintf("#<%s:%p@%"PRIsVALUE":%d%s>", cname, (void *)self,
+			 iseq->location.path, first_lineno, is_lambda);
+    }
+    else {
+	str = rb_sprintf("#<%s:%p%s>", cname, (void *)proc->block.iseq,
+			 is_lambda);
+    }
+
+    if (OBJ_TAINTED(self)) {
+	OBJ_TAINT(str);
+    }
+    return str;
+}
+
+/*
+ *  call-seq:
+ *     prc.to_proc -> proc
+ *
+ *  Part of the protocol for converting objects to <code>Proc</code>
+ *  objects. Instances of class <code>Proc</code> simply return
+ *  themselves.
+ */
+
+static VALUE
+proc_to_proc(VALUE self)
+{
+    return self;
+}
+
+static void
+bm_mark(void *ptr)
+{
+    struct METHOD *data = ptr;
+    rb_gc_mark(data->defined_class);
+    rb_gc_mark(data->rclass);
+    rb_gc_mark(data->recv);
+    if (data->me) rb_mark_method_entry(data->me);
+}
+
+static void
+bm_free(void *ptr)
+{
+    struct METHOD *data = ptr;
+    struct unlinked_method_entry_list_entry *ume = data->ume;
+    data->me->mark = 0;
+    ume->me = data->me;
+    ume->next = GET_VM()->unlinked_method_entry_list;
+    GET_VM()->unlinked_method_entry_list = ume;
+    xfree(ptr);
+}
+
+static size_t
+bm_memsize(const void *ptr)
+{
+    return ptr ? sizeof(struct METHOD) : 0;
+}
+
+static const rb_data_type_t method_data_type = {
+    "method",
+    {
+	bm_mark,
+	bm_free,
+	bm_memsize,
+    },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE
+rb_obj_is_method(VALUE m)
+{
+    if (rb_typeddata_is_kind_of(m, &method_data_type)) {
+	return Qtrue;
+    }
+    else {
+	return Qfalse;
+    }
+}
+
+static int
+respond_to_missing_p(VALUE klass, VALUE obj, VALUE sym, int scope)
+{
+    /* TODO: merge with obj_respond_to() */
+    ID rmiss = idRespond_to_missing;
+
+    if (obj == Qundef) return 0;
+    if (rb_method_basic_definition_p(klass, rmiss)) return 0;
+    return RTEST(rb_funcall(obj, rmiss, 2, sym, scope ? Qfalse : Qtrue));
+}
+
+
+static VALUE
+mnew_missing(VALUE rclass, VALUE klass, VALUE obj, ID id, ID rid, VALUE mclass)
+{
+    struct METHOD *data;
+    VALUE method = TypedData_Make_Struct(mclass, struct METHOD, &method_data_type, data);
+    rb_method_entry_t *me;
+    rb_method_definition_t *def;
+
+    data->recv = obj;
+    data->rclass = rclass;
+    data->defined_class = klass;
+    data->id = rid;
+
+    me = ALLOC(rb_method_entry_t);
+    data->me = me;
+    me->flag = 0;
+    me->mark = 0;
+    me->called_id = id;
+    me->klass = klass;
+    me->def = 0;
+
+    def = ALLOC(rb_method_definition_t);
+    me->def = def;
+    def->type = VM_METHOD_TYPE_MISSING;
+    def->original_id = id;
+    def->alias_count = 0;
+
+    data->ume = ALLOC(struct unlinked_method_entry_list_entry);
+    data->me->def->alias_count++;
+
+    OBJ_INFECT(method, klass);
+
+    return method;
+}
+
+static VALUE
+mnew_internal(rb_method_entry_t *me, VALUE defined_class, VALUE klass,
+	      VALUE obj, ID id, VALUE mclass, int scope, int error)
+{
+    struct METHOD *data;
+    VALUE rclass = klass;
+    VALUE method;
+    ID rid = id;
+    rb_method_definition_t *def = 0;
+    rb_method_flag_t flag = NOEX_UNDEF;
+
+  again:
+    if (UNDEFINED_METHOD_ENTRY_P(me)) {
+	if (respond_to_missing_p(klass, obj, ID2SYM(id), scope)) {
+	    return mnew_missing(rclass, klass, obj, id, rid, mclass);
+	}
+	if (!error) return Qnil;
+	rb_print_undef(klass, id, 0);
+    }
+    def = me->def;
+    if (flag == NOEX_UNDEF) {
+	flag = me->flag;
+	if (scope && (flag & NOEX_MASK) != NOEX_PUBLIC) {
+	    if (!error) return Qnil;
+	    rb_print_inaccessible(klass, id, flag & NOEX_MASK);
+	}
+    }
+    if (def && def->type == VM_METHOD_TYPE_ZSUPER) {
+	klass = RCLASS_SUPER(defined_class);
+	id = def->original_id;
+	me = rb_method_entry_without_refinements(klass, id, &defined_class);
+	goto again;
+    }
+
+    klass = defined_class;
+
+    while (rclass != klass &&
+	   (FL_TEST(rclass, FL_SINGLETON) || RB_TYPE_P(rclass, T_ICLASS))) {
+	rclass = RCLASS_SUPER(rclass);
+    }
+
+    method = TypedData_Make_Struct(mclass, struct METHOD, &method_data_type, data);
+
+    data->recv = obj;
+    data->rclass = rclass;
+    data->defined_class = defined_class;
+    data->id = rid;
+    data->me = ALLOC(rb_method_entry_t);
+    *data->me = *me;
+    data->ume = ALLOC(struct unlinked_method_entry_list_entry);
+    data->me->def->alias_count++;
+
+    OBJ_INFECT(method, klass);
+
+    return method;
+}
+
+static VALUE
+mnew_from_me(rb_method_entry_t *me, VALUE defined_class, VALUE klass,
+	     VALUE obj, ID id, VALUE mclass, int scope)
+{
+    return mnew_internal(me, defined_class, klass, obj, id, mclass, scope, TRUE);
+}
+
+static VALUE
+mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope)
+{
+    VALUE defined_class;
+    rb_method_entry_t *me =
+	rb_method_entry_without_refinements(klass, id, &defined_class);
+    return mnew_from_me(me, defined_class, klass, obj, id, mclass, scope);
+}
+
+
+/**********************************************************************
+ *
+ * Document-class : Method
+ *
+ *  Method objects are created by <code>Object#method</code>, and are
+ *  associated with a particular object (not just with a class). They
+ *  may be used to invoke the method within the object, and as a block
+ *  associated with an iterator. They may also be unbound from one
+ *  object (creating an <code>UnboundMethod</code>) and bound to
+ *  another.
+ *
+ *     class Thing
+ *       def square(n)
+ *         n*n
+ *       end
+ *     end
+ *     thing = Thing.new
+ *     meth  = thing.method(:square)
+ *
+ *     meth.call(9)                 #=> 81
+ *     [ 1, 2, 3 ].collect(&meth)   #=> [1, 4, 9]
+ *
+ */
+
+/*
+ * call-seq:
+ *   meth.eql?(other_meth)  -> true or false
+ *   meth == other_meth  -> true or false
+ *
+ * Two method objects are equal if they are bound to the same
+ * object and refer to the same method definition and their owners are the
+ * same class or module.
+ */
+
+static VALUE
+method_eq(VALUE method, VALUE other)
+{
+    struct METHOD *m1, *m2;
+
+    if (!rb_obj_is_method(other))
+	return Qfalse;
+    if (CLASS_OF(method) != CLASS_OF(other))
+	return Qfalse;
+
+    Check_TypedStruct(method, &method_data_type);
+    m1 = (struct METHOD *)DATA_PTR(method);
+    m2 = (struct METHOD *)DATA_PTR(other);
+
+    if (!rb_method_entry_eq(m1->me, m2->me) ||
+	m1->rclass != m2->rclass ||
+	m1->recv != m2->recv) {
+	return Qfalse;
+    }
+
+    return Qtrue;
+}
+
+/*
+ * call-seq:
+ *    meth.hash   -> integer
+ *
+ * Returns a hash value corresponding to the method object.
+ *
+ * See also Object#hash.
+ */
+
+static VALUE
+method_hash(VALUE method)
+{
+    struct METHOD *m;
+    st_index_t hash;
+
+    TypedData_Get_Struct(method, struct METHOD, &method_data_type, m);
+    hash = rb_hash_start((st_index_t)m->rclass);
+    hash = rb_hash_uint(hash, (st_index_t)m->recv);
+    hash = rb_hash_method_entry(hash, m->me);
+    hash = rb_hash_end(hash);
+
+    return INT2FIX(hash);
+}
+
+/*
+ *  call-seq:
+ *     meth.unbind    -> unbound_method
+ *
+ *  Dissociates <i>meth</i> from its current receiver. The resulting
+ *  <code>UnboundMethod</code> can subsequently be bound to a new object
+ *  of the same class (see <code>UnboundMethod</code>).
+ */
+
+static VALUE
+method_unbind(VALUE obj)
+{
+    VALUE method;
+    struct METHOD *orig, *data;
+
+    TypedData_Get_Struct(obj, struct METHOD, &method_data_type, orig);
+    method = TypedData_Make_Struct(rb_cUnboundMethod, struct METHOD,
+				   &method_data_type, data);
+    data->recv = Qundef;
+    data->id = orig->id;
+    data->me = ALLOC(rb_method_entry_t);
+    *data->me = *orig->me;
+    if (orig->me->def) orig->me->def->alias_count++;
+    data->rclass = orig->rclass;
+    data->defined_class = orig->defined_class;
+    data->ume = ALLOC(struct unlinked_method_entry_list_entry);
+    OBJ_INFECT(method, obj);
+
+    return method;
+}
+
+/*
+ *  call-seq:
+ *     meth.receiver    -> object
+ *
+ *  Returns the bound receiver of the method object.
+ */
+
+static VALUE
+method_receiver(VALUE obj)
+{
+    struct METHOD *data;
+
+    TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data);
+    return data->recv;
+}
+
+/*
+ *  call-seq:
+ *     meth.name    -> symbol
+ *
+ *  Returns the name of the method.
+ */
+
+static VALUE
+method_name(VALUE obj)
+{
+    struct METHOD *data;
+
+    TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data);
+    return ID2SYM(data->id);
+}
+
+/*
+ *  call-seq:
+ *     meth.original_name    -> symbol
+ *
+ *  Returns the original name of the method.
+ */
+
+static VALUE
+method_original_name(VALUE obj)
+{
+    struct METHOD *data;
+
+    TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data);
+    return ID2SYM(data->me->def->original_id);
+}
+
+/*
+ *  call-seq:
+ *     meth.owner    -> class_or_module
+ *
+ *  Returns the class or module that defines the method.
+ */
+
+static VALUE
+method_owner(VALUE obj)
+{
+    struct METHOD *data;
+    VALUE defined_class;
+
+    TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data);
+    defined_class = data->defined_class;
+
+    if (RB_TYPE_P(defined_class, T_ICLASS)) {
+	defined_class = RBASIC_CLASS(defined_class);
+    }
+
+    return defined_class;
+}
+
+void
+rb_method_name_error(VALUE klass, VALUE str)
+{
+    const char *s0 = " class";
+    VALUE c = klass;
+
+    if (FL_TEST(c, FL_SINGLETON)) {
+	VALUE obj = rb_ivar_get(klass, attached);
+
+	switch (TYPE(obj)) {
+	  case T_MODULE:
+	  case T_CLASS:
+	    c = obj;
+	    s0 = "";
+	}
+    }
+    else if (RB_TYPE_P(c, T_MODULE)) {
+	s0 = " module";
+    }
+    rb_name_error_str(str, "undefined method `%"PRIsVALUE"' for%s `%"PRIsVALUE"'",
+		      QUOTE(str), s0, rb_class_name(c));
+}
+
+static VALUE
+obj_method(VALUE obj, VALUE vid, int scope)
+{
+    ID id = rb_check_id(&vid);
+    const VALUE klass = CLASS_OF(obj);
+    const VALUE mclass = rb_cMethod;
+
+    if (!id) {
+	if (respond_to_missing_p(klass, obj, vid, scope)) {
+	    id = rb_intern_str(vid);
+	    return mnew_missing(klass, klass, obj, id, id, mclass);
+	}
+	rb_method_name_error(klass, vid);
+    }
+    return mnew(klass, obj, id, mclass, scope);
+}
+
+/*
+ *  call-seq:
+ *     obj.method(sym)    -> method
+ *
+ *  Looks up the named method as a receiver in <i>obj</i>, returning a
+ *  <code>Method</code> object (or raising <code>NameError</code>). The
+ *  <code>Method</code> object acts as a closure in <i>obj</i>'s object
+ *  instance, so instance variables and the value of <code>self</code>
+ *  remain available.
+ *
+ *     class Demo
+ *       def initialize(n)
+ *         @iv = n
+ *       end
+ *       def hello()
+ *         "Hello, @iv = #{@iv}"
+ *       end
+ *     end
+ *
+ *     k = Demo.new(99)
+ *     m = k.method(:hello)
+ *     m.call   #=> "Hello, @iv = 99"
+ *
+ *     l = Demo.new('Fred')
+ *     m = l.method("hello")
+ *     m.call   #=> "Hello, @iv = Fred"
+ */
+
+VALUE
+rb_obj_method(VALUE obj, VALUE vid)
+{
+    return obj_method(obj, vid, FALSE);
+}
+
+/*
+ *  call-seq:
+ *     obj.public_method(sym)    -> method
+ *
+ *  Similar to _method_, searches public method only.
+ */
+
+VALUE
+rb_obj_public_method(VALUE obj, VALUE vid)
+{
+    return obj_method(obj, vid, TRUE);
+}
+
+/*
+ *  call-seq:
+ *     obj.singleton_method(sym)    -> method
+ *
+ *  Similar to _method_, searches singleton method only.
+ *
+ *     class Demo
+ *       def initialize(n)
+ *         @iv = n
+ *       end
+ *       def hello()
+ *         "Hello, @iv = #{@iv}"
+ *       end
+ *     end
+ *
+ *     k = Demo.new(99)
+ *     def k.hi
+ *       "Hi, @iv = #{@iv}"
+ *     end
+ *     m = k.singleton_method(:hi)
+ *     m.call   #=> "Hi, @iv = 99"
+ *     m = k.singleton_method(:hello) #=> NameError
+ */
+
+VALUE
+rb_obj_singleton_method(VALUE obj, VALUE vid)
+{
+    rb_method_entry_t *me;
+    VALUE klass;
+    ID id = rb_check_id(&vid);
+    if (!id) {
+	if (!NIL_P(klass = rb_singleton_class_get(obj)) &&
+	    respond_to_missing_p(klass, obj, vid, FALSE)) {
+	    id = rb_intern_str(vid);
+	    return mnew_missing(klass, klass, obj, id, id, rb_cMethod);
+	}
+	rb_name_error_str(vid, "undefined singleton method `%"PRIsVALUE"' for `%"PRIsVALUE"'",
+			  QUOTE(vid), obj);
+    }
+    if (NIL_P(klass = rb_singleton_class_get(obj)) ||
+	UNDEFINED_METHOD_ENTRY_P(me = rb_method_entry_at(klass, id)) ||
+	UNDEFINED_REFINED_METHOD_P(me->def)) {
+	rb_name_error(id, "undefined singleton method `%"PRIsVALUE"' for `%"PRIsVALUE"'",
+		      QUOTE_ID(id), obj);
+    }
+    return mnew_from_me(me, klass, klass, obj, id, rb_cMethod, FALSE);
+}
+
+/*
+ *  call-seq:
+ *     mod.instance_method(symbol)   -> unbound_method
+ *
+ *  Returns an +UnboundMethod+ representing the given
+ *  instance method in _mod_.
+ *
+ *     class Interpreter
+ *       def do_a() print "there, "; end
+ *       def do_d() print "Hello ";  end
+ *       def do_e() print "!\n";     end
+ *       def do_v() print "Dave";    end
+ *       Dispatcher = {
+ *         "a" => instance_method(:do_a),
+ *         "d" => instance_method(:do_d),
+ *         "e" => instance_method(:do_e),
+ *         "v" => instance_method(:do_v)
+ *       }
+ *       def interpret(string)
+ *         string.each_char {|b| Dispatcher[b].bind(self).call }
+ *       end
+ *     end
+ *
+ *     interpreter = Interpreter.new
+ *     interpreter.interpret('dave')
+ *
+ *  <em>produces:</em>
+ *
+ *     Hello there, Dave!
+ */
+
+static VALUE
+rb_mod_instance_method(VALUE mod, VALUE vid)
+{
+    ID id = rb_check_id(&vid);
+    if (!id) {
+	rb_method_name_error(mod, vid);
+    }
+    return mnew(mod, Qundef, id, rb_cUnboundMethod, FALSE);
+}
+
+/*
+ *  call-seq:
+ *     mod.public_instance_method(symbol)   -> unbound_method
+ *
+ *  Similar to _instance_method_, searches public method only.
+ */
+
+static VALUE
+rb_mod_public_instance_method(VALUE mod, VALUE vid)
+{
+    ID id = rb_check_id(&vid);
+    if (!id) {
+	rb_method_name_error(mod, vid);
+    }
+    return mnew(mod, Qundef, id, rb_cUnboundMethod, TRUE);
+}
+
+/*
+ *  call-seq:
+ *     define_method(symbol, method)     -> symbol
+ *     define_method(symbol) { block }   -> symbol
+ *
+ *  Defines an instance method in the receiver. The _method_
+ *  parameter can be a +Proc+, a +Method+ or an +UnboundMethod+ object.
+ *  If a block is specified, it is used as the method body. This block
+ *  is evaluated using <code>instance_eval</code>, a point that is
+ *  tricky to demonstrate because <code>define_method</code> is private.
+ *  (This is why we resort to the +send+ hack in this example.)
+ *
+ *     class A
+ *       def fred
+ *         puts "In Fred"
+ *       end
+ *       def create_method(name, &block)
+ *         self.class.send(:define_method, name, &block)
+ *       end
+ *       define_method(:wilma) { puts "Charge it!" }
+ *     end
+ *     class B < A
+ *       define_method(:barney, instance_method(:fred))
+ *     end
+ *     a = B.new
+ *     a.barney
+ *     a.wilma
+ *     a.create_method(:betty) { p self }
+ *     a.betty
+ *
+ *  <em>produces:</em>
+ *
+ *     In Fred
+ *     Charge it!
+ *     #<B:0x401b39e8>
+ */
+
+static VALUE
+rb_mod_define_method(int argc, VALUE *argv, VALUE mod)
+{
+    ID id;
+    VALUE body;
+    int noex = NOEX_PUBLIC;
+    const NODE *cref = rb_vm_cref_in_context(mod, mod);
+
+    if (cref) {
+	noex = (int)cref->nd_visi;
+    }
+
+    if (argc == 1) {
+	id = rb_to_id(argv[0]);
+	body = rb_block_lambda();
+    }
+    else {
+	rb_check_arity(argc, 1, 2);
+	id = rb_to_id(argv[0]);
+	body = argv[1];
+	if (!rb_obj_is_method(body) && !rb_obj_is_proc(body)) {
+	    rb_raise(rb_eTypeError,
+		     "wrong argument type %s (expected Proc/Method)",
+		     rb_obj_classname(body));
+	}
+    }
+
+    if (rb_obj_is_method(body)) {
+	struct METHOD *method = (struct METHOD *)DATA_PTR(body);
+	VALUE rclass = method->rclass;
+	if (rclass != mod && !RB_TYPE_P(rclass, T_MODULE) &&
+	    !RTEST(rb_class_inherited_p(mod, rclass))) {
+	    if (FL_TEST(rclass, FL_SINGLETON)) {
+		rb_raise(rb_eTypeError,
+			 "can't bind singleton method to a different class");
+	    }
+	    else {
+		rb_raise(rb_eTypeError,
+			 "bind argument must be a subclass of % "PRIsVALUE,
+			 rb_class_name(rclass));
+	    }
+	}
+	rb_method_entry_set(mod, id, method->me, noex);
+	if (noex == NOEX_MODFUNC) {
+	    rb_method_entry_set(rb_singleton_class(mod), id, method->me, NOEX_PUBLIC);
+	}
+	RB_GC_GUARD(body);
+    }
+    else if (rb_obj_is_proc(body)) {
+	rb_proc_t *proc;
+	body = proc_dup(body);
+	GetProcPtr(body, proc);
+	if (!RUBY_VM_IFUNC_P(proc->block.iseq)) {
+	    proc->block.iseq->defined_method_id = id;
+	    RB_OBJ_WRITE(proc->block.iseq->self, &proc->block.iseq->klass, mod);
+	    proc->is_lambda = TRUE;
+	    proc->is_from_method = TRUE;
+	    proc->block.klass = mod;
+	}
+	rb_add_method(mod, id, VM_METHOD_TYPE_BMETHOD, (void *)body, noex);
+	if (noex == NOEX_MODFUNC) {
+	    rb_add_method(rb_singleton_class(mod), id, VM_METHOD_TYPE_BMETHOD, (void *)body, NOEX_PUBLIC);
+	}
+    }
+    else {
+	/* type error */
+	rb_raise(rb_eTypeError, "wrong argument type (expected Proc/Method)");
+    }
+
+    return ID2SYM(id);
+}
+
+/*
+ *  call-seq:
+ *     define_singleton_method(symbol, method) -> new_method
+ *     define_singleton_method(symbol) { block } -> proc
+ *
+ *  Defines a singleton method in the receiver. The _method_
+ *  parameter can be a +Proc+, a +Method+ or an +UnboundMethod+ object.
+ *  If a block is specified, it is used as the method body.
+ *
+ *     class A
+ *       class << self
+ *         def class_name
+ *           to_s
+ *         end
+ *       end
+ *     end
+ *     A.define_singleton_method(:who_am_i) do
+ *       "I am: #{class_name}"
+ *     end
+ *     A.who_am_i   # ==> "I am: A"
+ *
+ *     guy = "Bob"
+ *     guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
+ *     guy.hello    #=>  "Bob: Hello there!"
+ */
+
+static VALUE
+rb_obj_define_method(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE klass = rb_singleton_class(obj);
+
+    return rb_mod_define_method(argc, argv, klass);
+}
+
+/*
+ *     define_method(symbol, method)     -> new_method
+ *     define_method(symbol) { block }   -> proc
+ *
+ *  Defines a global function by _method_ or the block.
+ */
+
+static VALUE
+top_define_method(int argc, VALUE *argv, VALUE obj)
+{
+    rb_thread_t *th = GET_THREAD();
+    VALUE klass;
+
+    klass = th->top_wrapper;
+    if (klass) {
+	rb_warning("main.define_method in the wrapped load is effective only in wrapper module");
+    }
+    else {
+	klass = rb_cObject;
+    }
+    return rb_mod_define_method(argc, argv, klass);
+}
+
+/*
+ *  call-seq:
+ *    method.clone -> new_method
+ *
+ *  Returns a clone of this method.
+ *
+ *    class A
+ *      def foo
+ *        return "bar"
+ *      end
+ *    end
+ *
+ *    m = A.new.method(:foo)
+ *    m.call # => "bar"
+ *    n = m.clone.call # => "bar"
+ */
+
+static VALUE
+method_clone(VALUE self)
+{
+    VALUE clone;
+    struct METHOD *orig, *data;
+
+    TypedData_Get_Struct(self, struct METHOD, &method_data_type, orig);
+    clone = TypedData_Make_Struct(CLASS_OF(self), struct METHOD, &method_data_type, data);
+    CLONESETUP(clone, self);
+    *data = *orig;
+    data->me = ALLOC(rb_method_entry_t);
+    *data->me = *orig->me;
+    if (data->me->def) data->me->def->alias_count++;
+    data->ume = ALLOC(struct unlinked_method_entry_list_entry);
+
+    return clone;
+}
+
+/*
+ *  call-seq:
+ *     meth.call(args, ...)    -> obj
+ *     meth[args, ...]         -> obj
+ *
+ *  Invokes the <i>meth</i> with the specified arguments, returning the
+ *  method's return value.
+ *
+ *     m = 12.method("+")
+ *     m.call(3)    #=> 15
+ *     m.call(20)   #=> 32
+ */
+
+VALUE
+rb_method_call(int argc, const VALUE *argv, VALUE method)
+{
+    VALUE proc = rb_block_given_p() ? rb_block_proc() : Qnil;
+    return rb_method_call_with_block(argc, argv, method, proc);
+}
+
+VALUE
+rb_method_call_with_block(int argc, const VALUE *argv, VALUE method, VALUE pass_procval)
+{
+    VALUE result = Qnil;	/* OK */
+    struct METHOD *data;
+    int state;
+    volatile int safe = -1;
+
+    TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
+    if (data->recv == Qundef) {
+	rb_raise(rb_eTypeError, "can't call unbound method; bind first");
+    }
+    PUSH_TAG();
+    if (OBJ_TAINTED(method)) {
+	const int safe_level_to_run = RUBY_SAFE_LEVEL_MAX;
+	safe = rb_safe_level();
+	if (safe < safe_level_to_run) {
+	    rb_set_safe_level_force(safe_level_to_run);
+	}
+    }
+    if ((state = EXEC_TAG()) == 0) {
+	rb_thread_t *th = GET_THREAD();
+	rb_block_t *block = 0;
+	VALUE defined_class;
+
+	if (!NIL_P(pass_procval)) {
+	    rb_proc_t *pass_proc;
+	    GetProcPtr(pass_procval, pass_proc);
+	    block = &pass_proc->block;
+	}
+
+	th->passed_block = block;
+	VAR_INITIALIZED(data);
+	defined_class = data->defined_class;
+	if (BUILTIN_TYPE(defined_class) == T_MODULE) defined_class = data->rclass;
+	result = rb_vm_call(th, data->recv, data->id, argc, argv, data->me, defined_class);
+    }
+    POP_TAG();
+    if (safe >= 0)
+	rb_set_safe_level_force(safe);
+    if (state)
+	JUMP_TAG(state);
+    return result;
+}
+
+/**********************************************************************
+ *
+ * Document-class: UnboundMethod
+ *
+ *  Ruby supports two forms of objectified methods. Class
+ *  <code>Method</code> is used to represent methods that are associated
+ *  with a particular object: these method objects are bound to that
+ *  object. Bound method objects for an object can be created using
+ *  <code>Object#method</code>.
+ *
+ *  Ruby also supports unbound methods; methods objects that are not
+ *  associated with a particular object. These can be created either by
+ *  calling <code>Module#instance_method</code> or by calling
+ *  <code>unbind</code> on a bound method object. The result of both of
+ *  these is an <code>UnboundMethod</code> object.
+ *
+ *  Unbound methods can only be called after they are bound to an
+ *  object. That object must be be a kind_of? the method's original
+ *  class.
+ *
+ *     class Square
+ *       def area
+ *         @side * @side
+ *       end
+ *       def initialize(side)
+ *         @side = side
+ *       end
+ *     end
+ *
+ *     area_un = Square.instance_method(:area)
+ *
+ *     s = Square.new(12)
+ *     area = area_un.bind(s)
+ *     area.call   #=> 144
+ *
+ *  Unbound methods are a reference to the method at the time it was
+ *  objectified: subsequent changes to the underlying class will not
+ *  affect the unbound method.
+ *
+ *     class Test
+ *       def test
+ *         :original
+ *       end
+ *     end
+ *     um = Test.instance_method(:test)
+ *     class Test
+ *       def test
+ *         :modified
+ *       end
+ *     end
+ *     t = Test.new
+ *     t.test            #=> :modified
+ *     um.bind(t).call   #=> :original
+ *
+ */
+
+/*
+ *  call-seq:
+ *     umeth.bind(obj) -> method
+ *
+ *  Bind <i>umeth</i> to <i>obj</i>. If <code>Klass</code> was the class
+ *  from which <i>umeth</i> was obtained,
+ *  <code>obj.kind_of?(Klass)</code> must be true.
+ *
+ *     class A
+ *       def test
+ *         puts "In test, class = #{self.class}"
+ *       end
+ *     end
+ *     class B < A
+ *     end
+ *     class C < B
+ *     end
+ *
+ *
+ *     um = B.instance_method(:test)
+ *     bm = um.bind(C.new)
+ *     bm.call
+ *     bm = um.bind(B.new)
+ *     bm.call
+ *     bm = um.bind(A.new)
+ *     bm.call
+ *
+ *  <em>produces:</em>
+ *
+ *     In test, class = C
+ *     In test, class = B
+ *     prog.rb:16:in `bind': bind argument must be an instance of B (TypeError)
+ *     	from prog.rb:16
+ */
+
+static VALUE
+umethod_bind(VALUE method, VALUE recv)
+{
+    struct METHOD *data, *bound;
+    VALUE methclass;
+    VALUE rclass;
+
+    TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
+
+    methclass = data->rclass;
+    if (!RB_TYPE_P(methclass, T_MODULE) &&
+	methclass != CLASS_OF(recv) && !rb_obj_is_kind_of(recv, methclass)) {
+	if (FL_TEST(methclass, FL_SINGLETON)) {
+	    rb_raise(rb_eTypeError,
+		     "singleton method called for a different object");
+	}
+	else {
+	    rb_raise(rb_eTypeError, "bind argument must be an instance of % "PRIsVALUE,
+		     rb_class_name(methclass));
+	}
+    }
+
+    method = TypedData_Make_Struct(rb_cMethod, struct METHOD, &method_data_type, bound);
+    *bound = *data;
+    bound->me = ALLOC(rb_method_entry_t);
+    *bound->me = *data->me;
+    if (bound->me->def) bound->me->def->alias_count++;
+    rclass = CLASS_OF(recv);
+    if (BUILTIN_TYPE(bound->defined_class) == T_MODULE) {
+	VALUE ic = rb_class_search_ancestor(rclass, bound->defined_class);
+	if (ic) {
+	    rclass = ic;
+	}
+	else {
+	    rclass = rb_include_class_new(methclass, rclass);
+	}
+    }
+    bound->recv = recv;
+    bound->rclass = rclass;
+    data->ume = ALLOC(struct unlinked_method_entry_list_entry);
+
+    return method;
+}
+
+/*
+ * Returns the number of required parameters and stores the maximum
+ * number of parameters in max, or UNLIMITED_ARGUMENTS
+ * if there is no maximum.
+ */
+static int
+rb_method_entry_min_max_arity(const rb_method_entry_t *me, int *max)
+{
+    const rb_method_definition_t *def = me->def;
+    if (!def) return *max = 0;
+    switch (def->type) {
+      case VM_METHOD_TYPE_CFUNC:
+	if (def->body.cfunc.argc < 0) {
+	    *max = UNLIMITED_ARGUMENTS;
+	    return 0;
+	}
+	return *max = check_argc(def->body.cfunc.argc);
+      case VM_METHOD_TYPE_ZSUPER:
+	*max = UNLIMITED_ARGUMENTS;
+	return 0;
+      case VM_METHOD_TYPE_ATTRSET:
+	return *max = 1;
+      case VM_METHOD_TYPE_IVAR:
+	return *max = 0;
+      case VM_METHOD_TYPE_BMETHOD:
+	return rb_proc_min_max_arity(def->body.proc, max);
+      case VM_METHOD_TYPE_ISEQ: {
+	rb_iseq_t *iseq = def->body.iseq;
+	return rb_iseq_min_max_arity(iseq, max);
+      }
+      case VM_METHOD_TYPE_UNDEF:
+      case VM_METHOD_TYPE_NOTIMPLEMENTED:
+	return *max = 0;
+      case VM_METHOD_TYPE_MISSING:
+	*max = UNLIMITED_ARGUMENTS;
+	return 0;
+      case VM_METHOD_TYPE_OPTIMIZED: {
+	switch (def->body.optimize_type) {
+	  case OPTIMIZED_METHOD_TYPE_SEND:
+	    *max = UNLIMITED_ARGUMENTS;
+	    return 0;
+	  default:
+	    break;
+	}
+	break;
+      }
+      case VM_METHOD_TYPE_REFINED:
+	*max = UNLIMITED_ARGUMENTS;
+	return 0;
+    }
+    rb_bug("rb_method_entry_min_max_arity: invalid method entry type (%d)", def->type);
+    UNREACHABLE;
+}
+
+int
+rb_method_entry_arity(const rb_method_entry_t *me)
+{
+    int max, min = rb_method_entry_min_max_arity(me, &max);
+    return min == max ? min : -min-1;
+}
+
+/*
+ *  call-seq:
+ *     meth.arity    -> fixnum
+ *
+ *  Returns an indication of the number of arguments accepted by a
+ *  method. Returns a nonnegative integer for methods that take a fixed
+ *  number of arguments. For Ruby methods that take a variable number of
+ *  arguments, returns -n-1, where n is the number of required
+ *  arguments. For methods written in C, returns -1 if the call takes a
+ *  variable number of arguments.
+ *
+ *     class C
+ *       def one;    end
+ *       def two(a); end
+ *       def three(*a);  end
+ *       def four(a, b); end
+ *       def five(a, b, *c);    end
+ *       def six(a, b, *c, &d); end
+ *     end
+ *     c = C.new
+ *     c.method(:one).arity     #=> 0
+ *     c.method(:two).arity     #=> 1
+ *     c.method(:three).arity   #=> -1
+ *     c.method(:four).arity    #=> 2
+ *     c.method(:five).arity    #=> -3
+ *     c.method(:six).arity     #=> -3
+ *
+ *     "cat".method(:size).arity      #=> 0
+ *     "cat".method(:replace).arity   #=> 1
+ *     "cat".method(:squeeze).arity   #=> -1
+ *     "cat".method(:count).arity     #=> -1
+ */
+
+static VALUE
+method_arity_m(VALUE method)
+{
+    int n = method_arity(method);
+    return INT2FIX(n);
+}
+
+static int
+method_arity(VALUE method)
+{
+    struct METHOD *data;
+
+    TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
+    return rb_method_entry_arity(data->me);
+}
+
+static rb_method_entry_t *
+original_method_entry(VALUE mod, ID id)
+{
+    VALUE rclass;
+    rb_method_entry_t *me;
+    while ((me = rb_method_entry(mod, id, &rclass)) != 0) {
+	rb_method_definition_t *def = me->def;
+	if (!def) break;
+	if (def->type != VM_METHOD_TYPE_ZSUPER) break;
+	mod = RCLASS_SUPER(rclass);
+	id = def->original_id;
+    }
+    return me;
+}
+
+static int
+method_min_max_arity(VALUE method, int *max)
+{
+    struct METHOD *data;
+
+    TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
+    return rb_method_entry_min_max_arity(data->me, max);
+}
+
+int
+rb_mod_method_arity(VALUE mod, ID id)
+{
+    rb_method_entry_t *me = original_method_entry(mod, id);
+    if (!me) return 0;		/* should raise? */
+    return rb_method_entry_arity(me);
+}
+
+int
+rb_obj_method_arity(VALUE obj, ID id)
+{
+    return rb_mod_method_arity(CLASS_OF(obj), id);
+}
+
+static inline rb_method_definition_t *
+method_get_def(VALUE method)
+{
+    struct METHOD *data;
+
+    TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
+    return data->me->def;
+}
+
+static rb_iseq_t *
+method_get_iseq(rb_method_definition_t *def)
+{
+    switch (def->type) {
+      case VM_METHOD_TYPE_BMETHOD:
+	return get_proc_iseq(def->body.proc, 0);
+      case VM_METHOD_TYPE_ISEQ:
+	return def->body.iseq;
+      default:
+	return 0;
+    }
+}
+
+rb_iseq_t *
+rb_method_get_iseq(VALUE method)
+{
+    return method_get_iseq(method_get_def(method));
+}
+
+static VALUE
+method_def_location(rb_method_definition_t *def)
+{
+    if (def->type == VM_METHOD_TYPE_ATTRSET || def->type == VM_METHOD_TYPE_IVAR) {
+	if (!def->body.attr.location)
+	    return Qnil;
+	return rb_ary_dup(def->body.attr.location);
+    }
+    return iseq_location(method_get_iseq(def));
+}
+
+VALUE
+rb_method_entry_location(rb_method_entry_t *me)
+{
+    if (!me || !me->def) return Qnil;
+    return method_def_location(me->def);
+}
+
+VALUE
+rb_mod_method_location(VALUE mod, ID id)
+{
+    rb_method_entry_t *me = original_method_entry(mod, id);
+    return rb_method_entry_location(me);
+}
+
+VALUE
+rb_obj_method_location(VALUE obj, ID id)
+{
+    return rb_mod_method_location(CLASS_OF(obj), id);
+}
+
+/*
+ * call-seq:
+ *    meth.source_location  -> [String, Fixnum]
+ *
+ * Returns the Ruby source filename and line number containing this method
+ * or nil if this method was not defined in Ruby (i.e. native)
+ */
+
+VALUE
+rb_method_location(VALUE method)
+{
+    rb_method_definition_t *def = method_get_def(method);
+    return method_def_location(def);
+}
+
+/*
+ * call-seq:
+ *    meth.parameters  -> array
+ *
+ * Returns the parameter information of this method.
+ */
+
+static VALUE
+rb_method_parameters(VALUE method)
+{
+    rb_iseq_t *iseq = rb_method_get_iseq(method);
+    if (!iseq) {
+	return unnamed_parameters(method_arity(method));
+    }
+    return rb_iseq_parameters(iseq, 0);
+}
+
+/*
+ *  call-seq:
+ *   meth.to_s      ->  string
+ *   meth.inspect   ->  string
+ *
+ *  Returns the name of the underlying method.
+ *
+ *    "cat".method(:count).inspect   #=> "#<Method: String#count>"
+ */
+
+static VALUE
+method_inspect(VALUE method)
+{
+    struct METHOD *data;
+    VALUE str;
+    const char *s;
+    const char *sharp = "#";
+    VALUE mklass;
+
+    TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
+    str = rb_str_buf_new2("#<");
+    s = rb_obj_classname(method);
+    rb_str_buf_cat2(str, s);
+    rb_str_buf_cat2(str, ": ");
+
+    mklass = data->me->klass;
+    if (FL_TEST(mklass, FL_SINGLETON)) {
+	VALUE v = rb_ivar_get(mklass, attached);
+
+	if (data->recv == Qundef) {
+	    rb_str_buf_append(str, rb_inspect(mklass));
+	}
+	else if (data->recv == v) {
+	    rb_str_buf_append(str, rb_inspect(v));
+	    sharp = ".";
+	}
+	else {
+	    rb_str_buf_append(str, rb_inspect(data->recv));
+	    rb_str_buf_cat2(str, "(");
+	    rb_str_buf_append(str, rb_inspect(v));
+	    rb_str_buf_cat2(str, ")");
+	    sharp = ".";
+	}
+    }
+    else {
+	rb_str_buf_append(str, rb_class_name(data->rclass));
+	if (data->rclass != mklass) {
+	    rb_str_buf_cat2(str, "(");
+	    rb_str_buf_append(str, rb_class_name(mklass));
+	    rb_str_buf_cat2(str, ")");
+	}
+    }
+    rb_str_buf_cat2(str, sharp);
+    rb_str_append(str, rb_id2str(data->id));
+    if (data->id != data->me->def->original_id) {
+	rb_str_catf(str, "(%"PRIsVALUE")",
+		    rb_id2str(data->me->def->original_id));
+    }
+    if (data->me->def->type == VM_METHOD_TYPE_NOTIMPLEMENTED) {
+        rb_str_buf_cat2(str, " (not-implemented)");
+    }
+    rb_str_buf_cat2(str, ">");
+
+    return str;
+}
+
+static VALUE
+mproc(VALUE method)
+{
+    return rb_funcall2(rb_mRubyVMFrozenCore, idProc, 0, 0);
+}
+
+static VALUE
+mlambda(VALUE method)
+{
+    return rb_funcall(rb_mRubyVMFrozenCore, idLambda, 0, 0);
+}
+
+static VALUE
+bmcall(VALUE args, VALUE method, int argc, VALUE *argv, VALUE passed_proc)
+{
+    volatile VALUE a;
+    VALUE ret;
+
+    if (CLASS_OF(args) != rb_cArray) {
+	args = rb_ary_new3(1, args);
+	argc = 1;
+    }
+    else {
+	argc = check_argc(RARRAY_LEN(args));
+    }
+    ret = rb_method_call_with_block(argc, RARRAY_PTR(args), method, passed_proc);
+    RB_GC_GUARD(a) = args;
+    return ret;
+}
+
+VALUE
+rb_proc_new(
+    VALUE (*func)(ANYARGS), /* VALUE yieldarg[, VALUE procarg] */
+    VALUE val)
+{
+    VALUE procval = rb_iterate(mproc, 0, func, val);
+    return procval;
+}
+
+/*
+ *  call-seq:
+ *     meth.to_proc    -> proc
+ *
+ *  Returns a <code>Proc</code> object corresponding to this method.
+ */
+
+static VALUE
+method_proc(VALUE method)
+{
+    VALUE procval;
+    struct METHOD *meth;
+    rb_proc_t *proc;
+    rb_env_t *env;
+
+    /*
+     * class Method
+     *   def to_proc
+     *     proc{|*args|
+     *       self.call(*args)
+     *     }
+     *   end
+     * end
+     */
+    TypedData_Get_Struct(method, struct METHOD, &method_data_type, meth);
+    procval = rb_iterate(mlambda, 0, bmcall, method);
+    GetProcPtr(procval, proc);
+    proc->is_from_method = 1;
+    proc->block.self = meth->recv;
+    proc->block.klass = meth->defined_class;
+    GetEnvPtr(proc->envval, env);
+    env->block.self = meth->recv;
+    env->block.klass = meth->defined_class;
+    env->block.iseq = method_get_iseq(meth->me->def);
+    return procval;
+}
+
+/*
+ * Returns a Method of superclass, which would be called when super is used.
+ */
+static VALUE
+method_super_method(VALUE method)
+{
+    struct METHOD *data;
+    VALUE defined_class, super_class;
+    rb_method_entry_t *me;
+
+    TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
+    defined_class = data->defined_class;
+    if (BUILTIN_TYPE(defined_class) == T_MODULE) defined_class = data->rclass;
+    super_class = RCLASS_SUPER(defined_class);
+    if (!super_class) return Qnil;
+    me = rb_method_entry_without_refinements(super_class, data->id, &defined_class);
+    if (!me) return Qnil;
+    return mnew_internal(me, defined_class,
+			 super_class, data->recv, data->id,
+			 rb_obj_class(method), FALSE, FALSE);
+}
+
+/*
+ * call-seq:
+ *   local_jump_error.exit_value  -> obj
+ *
+ * Returns the exit value associated with this +LocalJumpError+.
+ */
+static VALUE
+localjump_xvalue(VALUE exc)
+{
+    return rb_iv_get(exc, "@exit_value");
+}
+
+/*
+ * call-seq:
+ *    local_jump_error.reason   -> symbol
+ *
+ * The reason this block was terminated:
+ * :break, :redo, :retry, :next, :return, or :noreason.
+ */
+
+static VALUE
+localjump_reason(VALUE exc)
+{
+    return rb_iv_get(exc, "@reason");
+}
+
+/*
+ *  call-seq:
+ *     prc.binding    -> binding
+ *
+ *  Returns the binding associated with <i>prc</i>. Note that
+ *  <code>Kernel#eval</code> accepts either a <code>Proc</code> or a
+ *  <code>Binding</code> object as its second parameter.
+ *
+ *     def fred(param)
+ *       proc {}
+ *     end
+ *
+ *     b = fred(99)
+ *     eval("param", b.binding)   #=> 99
+ */
+static VALUE
+proc_binding(VALUE self)
+{
+    rb_proc_t *proc;
+    VALUE bindval, envval;
+    rb_binding_t *bind;
+    rb_iseq_t *iseq;
+
+    GetProcPtr(self, proc);
+    envval = proc->envval;
+    iseq = proc->block.iseq;
+    if (RUBY_VM_IFUNC_P(iseq)) {
+	rb_env_t *env;
+	if (!IS_METHOD_PROC_NODE((NODE *)iseq)) {
+	    rb_raise(rb_eArgError, "Can't create Binding from C level Proc");
+	}
+	iseq = rb_method_get_iseq(RNODE(iseq)->u2.value);
+	GetEnvPtr(envval, env);
+	if (iseq && env->local_size < iseq->local_size) {
+	    int prev_local_size = env->local_size;
+	    int local_size = iseq->local_size;
+	    VALUE newenvval = TypedData_Wrap_Struct(RBASIC_CLASS(envval), RTYPEDDATA_TYPE(envval), 0);
+	    rb_env_t *newenv = xmalloc(sizeof(rb_env_t) + ((local_size + 1) * sizeof(VALUE)));
+	    RTYPEDDATA_DATA(newenvval) = newenv;
+	    newenv->env_size = local_size + 2;
+	    newenv->local_size = local_size;
+	    newenv->prev_envval = env->prev_envval;
+	    newenv->block = env->block;
+	    MEMCPY(newenv->env, env->env, VALUE, prev_local_size + 1);
+	    rb_mem_clear(newenv->env + prev_local_size + 1, local_size - prev_local_size);
+	    newenv->env[local_size + 1] = newenvval;
+	    envval = newenvval;
+	}
+    }
+
+    bindval = rb_binding_alloc(rb_cBinding);
+    GetBindingPtr(bindval, bind);
+    bind->env = envval;
+    bind->blockprocval = proc->blockprocval;
+    if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
+	bind->path = iseq->location.path;
+	bind->first_lineno = FIX2INT(rb_iseq_first_lineno(iseq->self));
+    }
+    else {
+	bind->path = Qnil;
+	bind->first_lineno = 0;
+    }
+    return bindval;
+}
+
+static VALUE curry(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc);
+
+static VALUE
+make_curry_proc(VALUE proc, VALUE passed, VALUE arity)
+{
+    VALUE args = rb_ary_new3(3, proc, passed, arity);
+    rb_proc_t *procp;
+    int is_lambda;
+
+    GetProcPtr(proc, procp);
+    is_lambda = procp->is_lambda;
+    rb_ary_freeze(passed);
+    rb_ary_freeze(args);
+    proc = rb_proc_new(curry, args);
+    GetProcPtr(proc, procp);
+    procp->is_lambda = is_lambda;
+    return proc;
+}
+
+static VALUE
+curry(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc)
+{
+    VALUE proc, passed, arity;
+    proc = RARRAY_AREF(args, 0);
+    passed = RARRAY_AREF(args, 1);
+    arity = RARRAY_AREF(args, 2);
+
+    passed = rb_ary_plus(passed, rb_ary_new4(argc, argv));
+    rb_ary_freeze(passed);
+
+    if (RARRAY_LEN(passed) < FIX2INT(arity)) {
+	if (!NIL_P(passed_proc)) {
+	    rb_warn("given block not used");
+	}
+	arity = make_curry_proc(proc, passed, arity);
+	return arity;
+    }
+    else {
+	return rb_proc_call_with_block(proc, check_argc(RARRAY_LEN(passed)), RARRAY_CONST_PTR(passed), passed_proc);
+    }
+}
+
+ /*
+  *  call-seq:
+  *     prc.curry         -> a_proc
+  *     prc.curry(arity)  -> a_proc
+  *
+  *  Returns a curried proc. If the optional <i>arity</i> argument is given,
+  *  it determines the number of arguments.
+  *  A curried proc receives some arguments. If a sufficient number of
+  *  arguments are supplied, it passes the supplied arguments to the original
+  *  proc and returns the result. Otherwise, returns another curried proc that
+  *  takes the rest of arguments.
+  *
+  *     b = proc {|x, y, z| (x||0) + (y||0) + (z||0) }
+  *     p b.curry[1][2][3]           #=> 6
+  *     p b.curry[1, 2][3, 4]        #=> 6
+  *     p b.curry(5)[1][2][3][4][5]  #=> 6
+  *     p b.curry(5)[1, 2][3, 4][5]  #=> 6
+  *     p b.curry(1)[1]              #=> 1
+  *
+  *     b = proc {|x, y, z, *w| (x||0) + (y||0) + (z||0) + w.inject(0, &:+) }
+  *     p b.curry[1][2][3]           #=> 6
+  *     p b.curry[1, 2][3, 4]        #=> 10
+  *     p b.curry(5)[1][2][3][4][5]  #=> 15
+  *     p b.curry(5)[1, 2][3, 4][5]  #=> 15
+  *     p b.curry(1)[1]              #=> 1
+  *
+  *     b = lambda {|x, y, z| (x||0) + (y||0) + (z||0) }
+  *     p b.curry[1][2][3]           #=> 6
+  *     p b.curry[1, 2][3, 4]        #=> wrong number of arguments (4 for 3)
+  *     p b.curry(5)                 #=> wrong number of arguments (5 for 3)
+  *     p b.curry(1)                 #=> wrong number of arguments (1 for 3)
+  *
+  *     b = lambda {|x, y, z, *w| (x||0) + (y||0) + (z||0) + w.inject(0, &:+) }
+  *     p b.curry[1][2][3]           #=> 6
+  *     p b.curry[1, 2][3, 4]        #=> 10
+  *     p b.curry(5)[1][2][3][4][5]  #=> 15
+  *     p b.curry(5)[1, 2][3, 4][5]  #=> 15
+  *     p b.curry(1)                 #=> wrong number of arguments (1 for 3)
+  *
+  *     b = proc { :foo }
+  *     p b.curry[]                  #=> :foo
+  */
+static VALUE
+proc_curry(int argc, const VALUE *argv, VALUE self)
+{
+    int sarity, max_arity, min_arity = rb_proc_min_max_arity(self, &max_arity);
+    VALUE arity;
+
+    rb_scan_args(argc, argv, "01", &arity);
+    if (NIL_P(arity)) {
+	arity = INT2FIX(min_arity);
+    }
+    else {
+	sarity = FIX2INT(arity);
+	if (rb_proc_lambda_p(self)) {
+	    rb_check_arity(sarity, min_arity, max_arity);
+	}
+    }
+
+    return make_curry_proc(self, rb_ary_new(), arity);
+}
+
+/*
+ *  call-seq:
+ *     meth.curry        -> proc
+ *     meth.curry(arity) -> proc
+ *
+ *  Returns a curried proc based on the method. When the proc is called with a number of
+ *  arguments that is lower than the method's arity, then another curried proc is returned.
+ *  Only when enough arguments have been supplied to satisfy the method signature, will the
+ *  method actually be called.
+ *
+ *  The optional <i>arity</i> argument should be supplied when currying methods with
+ *  variable arguments to determine how many arguments are needed before the method is
+ *  called.
+ *
+ *     def foo(a,b,c)
+ *       [a, b, c]
+ *     end
+ *
+ *     proc  = self.method(:foo).curry
+ *     proc2 = proc.call(1, 2)          #=> #<Proc>
+ *     proc2.call(3)                    #=> [1,2,3]
+ *
+ *     def vararg(*args)
+ *       args
+ *     end
+ *
+ *     proc = self.method(:vararg).curry(4)
+ *     proc2 = proc.call(:x)      #=> #<Proc>
+ *     proc3 = proc2.call(:y, :z) #=> #<Proc>
+ *     proc3.call(:a)             #=> [:x, :y, :z, :a]
+ */
+
+static VALUE
+rb_method_curry(int argc, const VALUE *argv, VALUE self)
+{
+    VALUE proc = method_proc(self);
+    return proc_curry(argc, argv, proc);
+}
+
+/*
+ *  Document-class: LocalJumpError
+ *
+ *  Raised when Ruby can't yield as requested.
+ *
+ *  A typical scenario is attempting to yield when no block is given:
+ *
+ *     def call_block
+ *       yield 42
+ *     end
+ *     call_block
+ *
+ *  <em>raises the exception:</em>
+ *
+ *     LocalJumpError: no block given (yield)
+ *
+ *  A more subtle example:
+ *
+ *     def get_me_a_return
+ *       Proc.new { return 42 }
+ *     end
+ *     get_me_a_return.call
+ *
+ *  <em>raises the exception:</em>
+ *
+ *     LocalJumpError: unexpected return
+ */
+
+/*
+ *  Document-class: SystemStackError
+ *
+ *  Raised in case of a stack overflow.
+ *
+ *     def me_myself_and_i
+ *       me_myself_and_i
+ *     end
+ *     me_myself_and_i
+ *
+ *  <em>raises the exception:</em>
+ *
+ *    SystemStackError: stack level too deep
+ */
+
+/*
+ *  <code>Proc</code> objects are blocks of code that have been bound to
+ *  a set of local variables. Once bound, the code may be called in
+ *  different contexts and still access those variables.
+ *
+ *     def gen_times(factor)
+ *       return Proc.new {|n| n*factor }
+ *     end
+ *
+ *     times3 = gen_times(3)
+ *     times5 = gen_times(5)
+ *
+ *     times3.call(12)               #=> 36
+ *     times5.call(5)                #=> 25
+ *     times3.call(times5.call(4))   #=> 60
+ *
+ */
+
+void
+Init_Proc(void)
+{
+    /* Proc */
+    rb_cProc = rb_define_class("Proc", rb_cObject);
+    rb_undef_alloc_func(rb_cProc);
+    rb_define_singleton_method(rb_cProc, "new", rb_proc_s_new, -1);
+
+#if 0 /* incomplete. */
+    rb_add_method(rb_cProc, rb_intern("call"), VM_METHOD_TYPE_OPTIMIZED,
+		  (void *)OPTIMIZED_METHOD_TYPE_CALL, 0);
+    rb_add_method(rb_cProc, rb_intern("[]"), VM_METHOD_TYPE_OPTIMIZED,
+		  (void *)OPTIMIZED_METHOD_TYPE_CALL, 0);
+    rb_add_method(rb_cProc, rb_intern("==="), VM_METHOD_TYPE_OPTIMIZED,
+		  (void *)OPTIMIZED_METHOD_TYPE_CALL, 0);
+    rb_add_method(rb_cProc, rb_intern("yield"), VM_METHOD_TYPE_OPTIMIZED,
+		  (void *)OPTIMIZED_METHOD_TYPE_CALL, 0);
+#else
+    rb_define_method(rb_cProc, "call", proc_call, -1);
+    rb_define_method(rb_cProc, "[]", proc_call, -1);
+    rb_define_method(rb_cProc, "===", proc_call, -1);
+    rb_define_method(rb_cProc, "yield", proc_call, -1);
+#endif
+    rb_define_method(rb_cProc, "to_proc", proc_to_proc, 0);
+    rb_define_method(rb_cProc, "arity", proc_arity, 0);
+    rb_define_method(rb_cProc, "clone", proc_clone, 0);
+    rb_define_method(rb_cProc, "dup", proc_dup, 0);
+    rb_define_method(rb_cProc, "hash", proc_hash, 0);
+    rb_define_method(rb_cProc, "to_s", proc_to_s, 0);
+    rb_define_alias(rb_cProc, "inspect", "to_s");
+    rb_define_method(rb_cProc, "lambda?", rb_proc_lambda_p, 0);
+    rb_define_method(rb_cProc, "binding", proc_binding, 0);
+    rb_define_method(rb_cProc, "curry", proc_curry, -1);
+    rb_define_method(rb_cProc, "source_location", rb_proc_location, 0);
+    rb_define_method(rb_cProc, "parameters", rb_proc_parameters, 0);
+
+    /* Exceptions */
+    rb_eLocalJumpError = rb_define_class("LocalJumpError", rb_eStandardError);
+    rb_define_method(rb_eLocalJumpError, "exit_value", localjump_xvalue, 0);
+    rb_define_method(rb_eLocalJumpError, "reason", localjump_reason, 0);
+
+    rb_eSysStackError = rb_define_class("SystemStackError", rb_eException);
+    rb_vm_register_special_exception(ruby_error_sysstack, rb_eSysStackError, "stack level too deep");
+
+    /* utility functions */
+    rb_define_global_function("proc", rb_block_proc, 0);
+    rb_define_global_function("lambda", rb_block_lambda, 0);
+
+    /* Method */
+    rb_cMethod = rb_define_class("Method", rb_cObject);
+    rb_undef_alloc_func(rb_cMethod);
+    rb_undef_method(CLASS_OF(rb_cMethod), "new");
+    rb_define_method(rb_cMethod, "==", method_eq, 1);
+    rb_define_method(rb_cMethod, "eql?", method_eq, 1);
+    rb_define_method(rb_cMethod, "hash", method_hash, 0);
+    rb_define_method(rb_cMethod, "clone", method_clone, 0);
+    rb_define_method(rb_cMethod, "call", rb_method_call, -1);
+    rb_define_method(rb_cMethod, "curry", rb_method_curry, -1);
+    rb_define_method(rb_cMethod, "[]", rb_method_call, -1);
+    rb_define_method(rb_cMethod, "arity", method_arity_m, 0);
+    rb_define_method(rb_cMethod, "inspect", method_inspect, 0);
+    rb_define_method(rb_cMethod, "to_s", method_inspect, 0);
+    rb_define_method(rb_cMethod, "to_proc", method_proc, 0);
+    rb_define_method(rb_cMethod, "receiver", method_receiver, 0);
+    rb_define_method(rb_cMethod, "name", method_name, 0);
+    rb_define_method(rb_cMethod, "original_name", method_original_name, 0);
+    rb_define_method(rb_cMethod, "owner", method_owner, 0);
+    rb_define_method(rb_cMethod, "unbind", method_unbind, 0);
+    rb_define_method(rb_cMethod, "source_location", rb_method_location, 0);
+    rb_define_method(rb_cMethod, "parameters", rb_method_parameters, 0);
+    rb_define_method(rb_cMethod, "super_method", method_super_method, 0);
+    rb_define_method(rb_mKernel, "method", rb_obj_method, 1);
+    rb_define_method(rb_mKernel, "public_method", rb_obj_public_method, 1);
+    rb_define_method(rb_mKernel, "singleton_method", rb_obj_singleton_method, 1);
+
+    /* UnboundMethod */
+    rb_cUnboundMethod = rb_define_class("UnboundMethod", rb_cObject);
+    rb_undef_alloc_func(rb_cUnboundMethod);
+    rb_undef_method(CLASS_OF(rb_cUnboundMethod), "new");
+    rb_define_method(rb_cUnboundMethod, "==", method_eq, 1);
+    rb_define_method(rb_cUnboundMethod, "eql?", method_eq, 1);
+    rb_define_method(rb_cUnboundMethod, "hash", method_hash, 0);
+    rb_define_method(rb_cUnboundMethod, "clone", method_clone, 0);
+    rb_define_method(rb_cUnboundMethod, "arity", method_arity_m, 0);
+    rb_define_method(rb_cUnboundMethod, "inspect", method_inspect, 0);
+    rb_define_method(rb_cUnboundMethod, "to_s", method_inspect, 0);
+    rb_define_method(rb_cUnboundMethod, "name", method_name, 0);
+    rb_define_method(rb_cUnboundMethod, "original_name", method_original_name, 0);
+    rb_define_method(rb_cUnboundMethod, "owner", method_owner, 0);
+    rb_define_method(rb_cUnboundMethod, "bind", umethod_bind, 1);
+    rb_define_method(rb_cUnboundMethod, "source_location", rb_method_location, 0);
+    rb_define_method(rb_cUnboundMethod, "parameters", rb_method_parameters, 0);
+    rb_define_method(rb_cUnboundMethod, "super_method", method_super_method, 0);
+
+    /* Module#*_method */
+    rb_define_method(rb_cModule, "instance_method", rb_mod_instance_method, 1);
+    rb_define_method(rb_cModule, "public_instance_method", rb_mod_public_instance_method, 1);
+    rb_define_private_method(rb_cModule, "define_method", rb_mod_define_method, -1);
+
+    /* Kernel */
+    rb_define_method(rb_mKernel, "define_singleton_method", rb_obj_define_method, -1);
+
+    rb_define_private_method(rb_singleton_class(rb_vm_top_self()),
+			     "define_method", top_define_method, -1);
+}
+
+/*
+ *  Objects of class <code>Binding</code> encapsulate the execution
+ *  context at some particular place in the code and retain this context
+ *  for future use. The variables, methods, value of <code>self</code>,
+ *  and possibly an iterator block that can be accessed in this context
+ *  are all retained. Binding objects can be created using
+ *  <code>Kernel#binding</code>, and are made available to the callback
+ *  of <code>Kernel#set_trace_func</code>.
+ *
+ *  These binding objects can be passed as the second argument of the
+ *  <code>Kernel#eval</code> method, establishing an environment for the
+ *  evaluation.
+ *
+ *     class Demo
+ *       def initialize(n)
+ *         @secret = n
+ *       end
+ *       def get_binding
+ *         return binding()
+ *       end
+ *     end
+ *
+ *     k1 = Demo.new(99)
+ *     b1 = k1.get_binding
+ *     k2 = Demo.new(-3)
+ *     b2 = k2.get_binding
+ *
+ *     eval("@secret", b1)   #=> 99
+ *     eval("@secret", b2)   #=> -3
+ *     eval("@secret")       #=> nil
+ *
+ *  Binding objects have no class-specific methods.
+ *
+ */
+
+void
+Init_Binding(void)
+{
+    rb_cBinding = rb_define_class("Binding", rb_cObject);
+    rb_undef_alloc_func(rb_cBinding);
+    rb_undef_method(CLASS_OF(rb_cBinding), "new");
+    rb_define_method(rb_cBinding, "clone", binding_clone, 0);
+    rb_define_method(rb_cBinding, "dup", binding_dup, 0);
+    rb_define_method(rb_cBinding, "eval", bind_eval, -1);
+    rb_define_method(rb_cBinding, "local_variables", bind_local_variables, 0);
+    rb_define_method(rb_cBinding, "local_variable_get", bind_local_variable_get, 1);
+    rb_define_method(rb_cBinding, "local_variable_set", bind_local_variable_set, 2);
+    rb_define_method(rb_cBinding, "local_variable_defined?", bind_local_variable_defined_p, 1);
+    rb_define_method(rb_cBinding, "receiver", bind_receiver, 0);
+    rb_define_global_function("binding", rb_f_binding, 0);
+}