diff options
Diffstat (limited to 'jni/ruby/proc.c')
| -rw-r--r-- | jni/ruby/proc.c | 2886 |
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); +} |