2007-02-02 10:21:41 -05:00
|
|
|
/**********************************************************************
|
|
|
|
|
2007-08-30 01:06:52 -04:00
|
|
|
proc.c - Proc, Binding, Env
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
$Author$
|
|
|
|
created at: Wed Jan 17 12:13:14 2007
|
|
|
|
|
|
|
|
Copyright (C) 2004-2007 Koichi Sasada
|
|
|
|
|
|
|
|
**********************************************************************/
|
|
|
|
|
|
|
|
#include "eval_intern.h"
|
2011-05-18 09:41:54 -04:00
|
|
|
#include "internal.h"
|
2007-02-02 10:21:41 -05:00
|
|
|
#include "gc.h"
|
* internal.h: declare internal functions here.
* node.h: declare NODE dependent internal functions here.
* iseq.h: declare rb_iseq_t dependent internal functions here.
* vm_core.h: declare rb_thread_t dependent internal functions here.
* bignum.c, class.c, compile.c, complex.c, cont.c, dir.c, encoding.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c, io.c,
iseq.c, load.c, marshal.c, math.c, numeric.c, object.c, parse.y,
proc.c, process.c, range.c, rational.c, re.c, ruby.c, string.c,
thread.c, time.c, transcode.c, variable.c, vm.c,
tool/compile_prelude.rb: don't declare internal functions declared
in above headers. include above headers if required.
Note that rb_thread_mark() was declared as
void rb_thread_mark(rb_thread_t *th) in cont.c but defined as
void rb_thread_mark(void *ptr) in vm.c. Now it is declared as
the later in internal.h.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@32156 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2011-06-17 18:43:38 -04:00
|
|
|
#include "iseq.h"
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
struct METHOD {
|
|
|
|
VALUE recv;
|
2009-07-15 10:59:41 -04:00
|
|
|
VALUE rclass;
|
2012-08-02 07:08:44 -04:00
|
|
|
VALUE defined_class;
|
2009-07-15 10:59:41 -04:00
|
|
|
ID id;
|
2011-07-25 10:29:28 -04:00
|
|
|
rb_method_entry_t *me;
|
2011-07-25 11:17:56 -04:00
|
|
|
struct unlinked_method_entry_list_entry *ume;
|
2007-02-02 10:21:41 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
VALUE rb_cUnboundMethod;
|
|
|
|
VALUE rb_cMethod;
|
|
|
|
VALUE rb_cBinding;
|
|
|
|
VALUE rb_cProc;
|
|
|
|
|
|
|
|
static VALUE bmcall(VALUE, VALUE);
|
|
|
|
static int method_arity(VALUE);
|
2011-07-23 11:05:03 -04:00
|
|
|
static ID attached;
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
/* Proc */
|
|
|
|
|
2009-09-21 04:12:12 -04:00
|
|
|
#define IS_METHOD_PROC_NODE(node) (nd_type(node) == NODE_IFUNC && (node)->nd_cfnc == bmcall)
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
static void
|
|
|
|
proc_free(void *ptr)
|
|
|
|
{
|
2007-06-24 22:44:20 -04:00
|
|
|
RUBY_FREE_ENTER("proc");
|
2007-02-02 10:21:41 -05:00
|
|
|
if (ptr) {
|
|
|
|
ruby_xfree(ptr);
|
|
|
|
}
|
2007-06-24 22:44:20 -04:00
|
|
|
RUBY_FREE_LEAVE("proc");
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
proc_mark(void *ptr)
|
|
|
|
{
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_proc_t *proc;
|
2007-06-24 22:44:20 -04:00
|
|
|
RUBY_MARK_ENTER("proc");
|
2007-02-02 10:21:41 -05:00
|
|
|
if (ptr) {
|
|
|
|
proc = ptr;
|
2007-06-24 22:44:20 -04:00
|
|
|
RUBY_MARK_UNLESS_NULL(proc->envval);
|
|
|
|
RUBY_MARK_UNLESS_NULL(proc->blockprocval);
|
|
|
|
RUBY_MARK_UNLESS_NULL(proc->block.proc);
|
2008-01-11 06:20:18 -05:00
|
|
|
RUBY_MARK_UNLESS_NULL(proc->block.self);
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
if (proc->block.iseq && RUBY_VM_IFUNC_P(proc->block.iseq)) {
|
2007-06-24 22:44:20 -04:00
|
|
|
RUBY_MARK_UNLESS_NULL((VALUE)(proc->block.iseq));
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
}
|
2007-06-24 22:44:20 -04:00
|
|
|
RUBY_MARK_LEAVE("proc");
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
static size_t
|
2009-09-08 22:11:35 -04:00
|
|
|
proc_memsize(const void *ptr)
|
2009-07-08 04:13:41 -04:00
|
|
|
{
|
|
|
|
return ptr ? sizeof(rb_proc_t) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const rb_data_type_t proc_data_type = {
|
|
|
|
"proc",
|
2010-07-18 03:31:54 -04:00
|
|
|
{
|
|
|
|
proc_mark,
|
|
|
|
proc_free,
|
|
|
|
proc_memsize,
|
|
|
|
},
|
2009-07-08 04:13:41 -04:00
|
|
|
};
|
|
|
|
|
* blockinlining.c: remove "yarv" prefix.
* array.c, numeric.c: ditto.
* insnhelper.ci, insns.def, vm_evalbody.ci: ditto.
* yarvcore.c: removed.
* yarvcore.h: renamed to core.h.
* cont.c, debug.c, error.c, process.c, signal.c : ditto.
* ext/probeprofiler/probeprofiler.c: ditto.
* id.c, id.h: added.
* inits.c: ditto.
* compile.c: rename internal functions.
* compile.h: fix debug flag.
* eval.c, object.c, vm.c: remove ruby_top_self.
use rb_vm_top_self() instead.
* eval_intern.h, eval_load: ditto.
* gc.c: rename yarv_machine_stack_mark() to
rb_gc_mark_machine_stack().
* insnhelper.h: remove unused macros.
* iseq.c: add iseq_compile() to create iseq object
from source string.
* proc.c: rename a internal function.
* template/insns.inc.tmpl: remove YARV prefix.
* thread.c:
* vm.c (rb_iseq_eval): added.
* vm.c: move some functions from yarvcore.c.
* vm_dump.c: fix to remove compiler warning.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12741 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-07-12 00:25:46 -04:00
|
|
|
VALUE
|
|
|
|
rb_proc_alloc(VALUE klass)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_proc_t *proc;
|
2009-07-08 04:13:41 -04:00
|
|
|
return TypedData_Make_Struct(klass, rb_proc_t, &proc_data_type, proc);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_obj_is_proc(VALUE proc)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
2009-07-08 04:13:41 -04:00
|
|
|
if (rb_typeddata_is_kind_of(proc, &proc_data_type)) {
|
2007-02-02 10:21:41 -05:00
|
|
|
return Qtrue;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return Qfalse;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-21 07:06:32 -04:00
|
|
|
/* :nodoc: */
|
2007-02-02 10:21:41 -05:00
|
|
|
static VALUE
|
|
|
|
proc_dup(VALUE self)
|
|
|
|
{
|
* blockinlining.c: remove "yarv" prefix.
* array.c, numeric.c: ditto.
* insnhelper.ci, insns.def, vm_evalbody.ci: ditto.
* yarvcore.c: removed.
* yarvcore.h: renamed to core.h.
* cont.c, debug.c, error.c, process.c, signal.c : ditto.
* ext/probeprofiler/probeprofiler.c: ditto.
* id.c, id.h: added.
* inits.c: ditto.
* compile.c: rename internal functions.
* compile.h: fix debug flag.
* eval.c, object.c, vm.c: remove ruby_top_self.
use rb_vm_top_self() instead.
* eval_intern.h, eval_load: ditto.
* gc.c: rename yarv_machine_stack_mark() to
rb_gc_mark_machine_stack().
* insnhelper.h: remove unused macros.
* iseq.c: add iseq_compile() to create iseq object
from source string.
* proc.c: rename a internal function.
* template/insns.inc.tmpl: remove YARV prefix.
* thread.c:
* vm.c (rb_iseq_eval): added.
* vm.c: move some functions from yarvcore.c.
* vm_dump.c: fix to remove compiler warning.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12741 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-07-12 00:25:46 -04:00
|
|
|
VALUE procval = rb_proc_alloc(rb_cProc);
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_proc_t *src, *dst;
|
2007-02-02 10:21:41 -05:00
|
|
|
GetProcPtr(self, src);
|
|
|
|
GetProcPtr(procval, dst);
|
|
|
|
|
|
|
|
dst->block = src->block;
|
2007-10-01 18:02:23 -04:00
|
|
|
dst->block.proc = procval;
|
2010-05-09 10:51:43 -04:00
|
|
|
dst->blockprocval = src->blockprocval;
|
2007-02-02 10:21:41 -05:00
|
|
|
dst->envval = src->envval;
|
2008-05-21 16:47:26 -04:00
|
|
|
dst->safe_level = src->safe_level;
|
2008-03-30 10:50:55 -04:00
|
|
|
dst->is_lambda = src->is_lambda;
|
2007-10-01 18:02:23 -04:00
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
return procval;
|
|
|
|
}
|
|
|
|
|
2009-09-21 07:06:32 -04:00
|
|
|
/* :nodoc: */
|
2007-02-02 10:21:41 -05:00
|
|
|
static VALUE
|
|
|
|
proc_clone(VALUE self)
|
|
|
|
{
|
|
|
|
VALUE procval = proc_dup(self);
|
|
|
|
CLONESETUP(procval, self);
|
|
|
|
return procval;
|
|
|
|
}
|
|
|
|
|
2007-12-23 10:36:00 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* prc.lambda? -> true or false
|
2007-12-23 10:36:00 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* Returns +true+ for a Proc object for which argument handling is rigid.
|
|
|
|
* Such procs are typically generated by +lambda+.
|
2007-12-23 10:36:00 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* A Proc object generated by +proc+ ignores extra arguments.
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2010-05-17 17:07:33 -04:00
|
|
|
* proc {|a,b| [a,b] }.call(1,2,3) #=> [1,2]
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* It provides +nil+ for missing arguments.
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2010-05-17 17:07:33 -04:00
|
|
|
* proc {|a,b| [a,b] }.call(1) #=> [1,nil]
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* It expands a single array argument.
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2010-05-17 17:07:33 -04:00
|
|
|
* proc {|a,b| [a,b] }.call([1,2]) #=> [1,2]
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* A Proc object generated by +lambda+ doesn't have such tricks.
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2010-05-17 17:07:33 -04:00
|
|
|
* 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
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
|
|
|
* Proc#lambda? is a predicate for the tricks.
|
2011-05-27 09:55:43 -04:00
|
|
|
* It returns +true+ if no tricks apply.
|
2007-12-23 10:36:00 -05:00
|
|
|
*
|
2010-05-17 17:07:33 -04:00
|
|
|
* lambda {}.lambda? #=> true
|
|
|
|
* proc {}.lambda? #=> false
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* Proc.new is the same as +proc+.
|
2007-12-24 01:56:06 -05:00
|
|
|
*
|
2010-05-17 17:07:33 -04:00
|
|
|
* Proc.new {}.lambda? #=> false
|
2007-12-23 10:36:00 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* +lambda+, +proc+ and Proc.new preserve the tricks of
|
|
|
|
* a Proc object given by <code>&</code> argument.
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2010-05-17 17:07:33 -04:00
|
|
|
* lambda(&lambda {}).lambda? #=> true
|
|
|
|
* proc(&lambda {}).lambda? #=> true
|
|
|
|
* Proc.new(&lambda {}).lambda? #=> true
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2010-05-17 17:07:33 -04:00
|
|
|
* lambda(&proc {}).lambda? #=> false
|
|
|
|
* proc(&proc {}).lambda? #=> false
|
|
|
|
* Proc.new(&proc {}).lambda? #=> false
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* A Proc object generated by <code>&</code> argument has the tricks
|
2007-12-23 10:36:00 -05:00
|
|
|
*
|
|
|
|
* def n(&b) b.lambda? end
|
2010-05-17 17:07:33 -04:00
|
|
|
* n {} #=> false
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* The <code>&</code> argument preserves the tricks if a Proc object
|
|
|
|
* is given by <code>&</code> argument.
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2010-05-17 17:07:33 -04:00
|
|
|
* n(&lambda {}) #=> true
|
|
|
|
* n(&proc {}) #=> false
|
|
|
|
* n(&Proc.new {}) #=> false
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
|
|
|
* A Proc object converted from a method has no tricks.
|
|
|
|
*
|
|
|
|
* def m() end
|
2010-05-17 17:07:33 -04:00
|
|
|
* method(:m).to_proc.lambda? #=> true
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2010-05-17 17:07:33 -04:00
|
|
|
* n(&method(:m)) #=> true
|
|
|
|
* n(&method(:m).to_proc) #=> true
|
2007-12-23 10:36:00 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* +define_method+ is treated the same as method definition.
|
2007-12-25 22:49:10 -05:00
|
|
|
* The defined method has no tricks.
|
|
|
|
*
|
2007-12-24 13:36:30 -05:00
|
|
|
* class C
|
|
|
|
* define_method(:d) {}
|
|
|
|
* end
|
2011-05-27 09:55:43 -04:00
|
|
|
* C.new.d(1,2) #=> ArgumentError
|
2010-05-17 17:07:33 -04:00
|
|
|
* C.new.method(:d).to_proc.lambda? #=> true
|
2007-12-24 13:36:30 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* +define_method+ always defines a method without the tricks,
|
2007-12-25 22:49:10 -05:00
|
|
|
* even if a non-lambda Proc object is given.
|
2011-05-27 09:55:43 -04:00
|
|
|
* This is the only exception for which the tricks are not preserved.
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
|
|
|
* class C
|
|
|
|
* define_method(:e, &proc {})
|
|
|
|
* end
|
2010-05-17 17:07:33 -04:00
|
|
|
* C.new.e(1,2) #=> ArgumentError
|
|
|
|
* C.new.method(:e).to_proc.lambda? #=> true
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* This exception insures that methods never have tricks
|
|
|
|
* and makes it easy to have wrappers to define methods that behave as usual.
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* class C
|
|
|
|
* def self.def2(name, &body)
|
2007-12-25 22:49:10 -05:00
|
|
|
* define_method(name, &body)
|
|
|
|
* end
|
2011-05-27 09:55:43 -04:00
|
|
|
*
|
2007-12-25 22:49:10 -05:00
|
|
|
* def2(:f) {}
|
|
|
|
* end
|
2010-05-17 17:07:33 -04:00
|
|
|
* C.new.f(1,2) #=> ArgumentError
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* The wrapper <i>def2</i> defines a method which has no tricks.
|
2007-12-25 22:49:10 -05:00
|
|
|
*
|
2007-12-23 10:36:00 -05:00
|
|
|
*/
|
|
|
|
|
2009-10-24 12:53:11 -04:00
|
|
|
VALUE
|
|
|
|
rb_proc_lambda_p(VALUE procval)
|
2007-06-05 13:26:00 -04:00
|
|
|
{
|
|
|
|
rb_proc_t *proc;
|
|
|
|
GetProcPtr(procval, proc);
|
|
|
|
|
|
|
|
return proc->is_lambda ? Qtrue : Qfalse;
|
|
|
|
}
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
/* Binding */
|
|
|
|
|
|
|
|
static void
|
|
|
|
binding_free(void *ptr)
|
|
|
|
{
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_binding_t *bind;
|
2007-06-24 22:44:20 -04:00
|
|
|
RUBY_FREE_ENTER("binding");
|
2007-02-02 10:21:41 -05:00
|
|
|
if (ptr) {
|
|
|
|
bind = ptr;
|
* bignum.c (big_rshift), compile.c (validate_label,
iseq_build_from_ary_exception), cont.c (cont_capture), dir.c
(dir_open_dir), gc.c (objspace_each_objects), io.c (pipe_open)
(rb_io_advise), parse.y (parser_compile_string)
(rb_parser_compile_file), proc.c (binding_free), process.c
(rb_proc_exec_n, rb_seteuid_core, proc_setegid, rb_setegid_core)
(p_uid_exchange, p_gid_exchange), regparse.c (strdup_with_null),
signal.c (sig_dfl), vm.c (rb_iseq_eval, rb_iseq_eval_main),
vm_insnhelper.c (vm_expandarray): suppress
unused-but-set-variable warnings.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@33951 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2011-12-05 04:57:00 -05:00
|
|
|
ruby_xfree(bind);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
2007-06-24 22:44:20 -04:00
|
|
|
RUBY_FREE_LEAVE("binding");
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
binding_mark(void *ptr)
|
|
|
|
{
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_binding_t *bind;
|
2007-06-24 22:44:20 -04:00
|
|
|
RUBY_MARK_ENTER("binding");
|
2007-02-02 10:21:41 -05:00
|
|
|
if (ptr) {
|
|
|
|
bind = ptr;
|
2007-06-24 22:44:20 -04:00
|
|
|
RUBY_MARK_UNLESS_NULL(bind->env);
|
2012-06-03 22:49:37 -04:00
|
|
|
RUBY_MARK_UNLESS_NULL(bind->path);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
2007-06-24 22:44:20 -04:00
|
|
|
RUBY_MARK_LEAVE("binding");
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
2009-07-08 05:28:09 -04:00
|
|
|
static size_t
|
2009-09-08 22:11:35 -04:00
|
|
|
binding_memsize(const void *ptr)
|
2009-07-08 05:28:09 -04:00
|
|
|
{
|
|
|
|
return ptr ? sizeof(rb_binding_t) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const rb_data_type_t binding_data_type = {
|
|
|
|
"binding",
|
2010-07-18 03:31:54 -04:00
|
|
|
{
|
|
|
|
binding_mark,
|
|
|
|
binding_free,
|
|
|
|
binding_memsize,
|
|
|
|
},
|
2009-07-08 05:28:09 -04:00
|
|
|
};
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
static VALUE
|
|
|
|
binding_alloc(VALUE klass)
|
|
|
|
{
|
|
|
|
VALUE obj;
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_binding_t *bind;
|
2009-07-08 05:28:09 -04:00
|
|
|
obj = TypedData_Make_Struct(klass, rb_binding_t, &binding_data_type, bind);
|
2007-02-02 10:21:41 -05:00
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2009-09-21 07:06:32 -04:00
|
|
|
/* :nodoc: */
|
2007-02-02 10:21:41 -05:00
|
|
|
static VALUE
|
|
|
|
binding_dup(VALUE self)
|
|
|
|
{
|
|
|
|
VALUE bindval = binding_alloc(rb_cBinding);
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_binding_t *src, *dst;
|
2007-02-02 10:21:41 -05:00
|
|
|
GetBindingPtr(self, src);
|
|
|
|
GetBindingPtr(bindval, dst);
|
|
|
|
dst->env = src->env;
|
2012-06-03 22:49:37 -04:00
|
|
|
dst->path = src->path;
|
|
|
|
dst->first_lineno = src->first_lineno;
|
2007-02-02 10:21:41 -05:00
|
|
|
return bindval;
|
|
|
|
}
|
|
|
|
|
2009-09-21 07:06:32 -04:00
|
|
|
/* :nodoc: */
|
2007-02-02 10:21:41 -05:00
|
|
|
static VALUE
|
|
|
|
binding_clone(VALUE self)
|
|
|
|
{
|
|
|
|
VALUE bindval = binding_dup(self);
|
|
|
|
CLONESETUP(bindval, self);
|
|
|
|
return bindval;
|
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
2012-11-29 02:05:27 -05:00
|
|
|
rb_binding_new_with_cfp(rb_thread_t *th, const rb_control_frame_t *src_cfp)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
2012-08-22 01:12:31 -04:00
|
|
|
rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, src_cfp);
|
2007-02-02 10:21:41 -05:00
|
|
|
VALUE bindval = binding_alloc(rb_cBinding);
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_binding_t *bind;
|
2007-02-02 10:21:41 -05:00
|
|
|
|
* vm.c, eval_intern.h (PASS_PASSED_BLOCK):
set a VM_FRAME_FLAG_PASSED flag to skip this frame when
searching ruby-level-cfp.
* eval.c, eval_intern.h, proc.c: fix to check cfp. if there is
no valid ruby-level-cfp, cause RuntimeError exception.
[ruby-dev:34128]
* vm_core.h, vm_evalbody.c, vm.c, vm_dump.c, vm_insnhelper.c,
insns.def: rename FRAME_MAGIC_* to VM_FRAME_MAGIC_*.
* KNOWNBUGS.rb, bootstraptest/test*.rb: move solved bugs.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@17084 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-06-10 17:46:43 -04:00
|
|
|
if (cfp == 0) {
|
|
|
|
rb_raise(rb_eRuntimeError, "Can't create Binding Object on top of Fiber.");
|
|
|
|
}
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
GetBindingPtr(bindval, bind);
|
* vm.c: add a prefix "rb_" to exposed functions
vm_get_ruby_level_next_cfp(), rb_vm_make_env_object(),
vm_stack_to_heap(), vm_make_proc(), vm_invoke_proc(),
vm_get_sourceline(), vm_cref(), vm_localjump_error(),
vm_make_jump_tag_but_local_jump(), vm_jump_tag_but_local_jump().
This changes may affect only core because most of renamed functions
require a pointer of not-exposed struct such as rb_thread_t or NODE.
In short, they are core functions.
* cont.c, eval.c, eval_intern.h, load.c, proc.c, thread.c,
vm_core.h, vm_dump.c, vm_eval.c, vm_exec.c, vm_insnhelper.c:
ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@21659 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-01-18 21:38:11 -05:00
|
|
|
bind->env = rb_vm_make_env_object(th, cfp);
|
2012-06-03 22:49:37 -04:00
|
|
|
bind->path = cfp->iseq->location.path;
|
|
|
|
bind->first_lineno = rb_vm_get_sourceline(cfp);
|
2007-02-02 10:21:41 -05:00
|
|
|
return bindval;
|
|
|
|
}
|
|
|
|
|
2012-08-22 01:12:31 -04:00
|
|
|
VALUE
|
|
|
|
rb_binding_new(void)
|
|
|
|
{
|
|
|
|
rb_thread_t *th = GET_THREAD();
|
|
|
|
return rb_binding_new_with_cfp(th, th->cfp);
|
|
|
|
}
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* binding -> a_binding
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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
|
2011-05-27 09:55:43 -04:00
|
|
|
* environment. See also the description of class +Binding+.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2011-03-07 03:44:45 -05:00
|
|
|
* def get_binding(param)
|
2007-02-02 10:21:41 -05:00
|
|
|
* return binding
|
|
|
|
* end
|
2011-03-07 03:44:45 -05:00
|
|
|
* b = get_binding("hello")
|
2007-02-02 10:21:41 -05:00
|
|
|
* eval("param", b) #=> "hello"
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
rb_f_binding(VALUE self)
|
|
|
|
{
|
|
|
|
return rb_binding_new();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* binding.eval(string [, filename [,lineno]]) -> obj
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2011-03-07 03:44:45 -05:00
|
|
|
* def get_binding(param)
|
2007-02-02 10:21:41 -05:00
|
|
|
* return binding
|
|
|
|
* end
|
2011-03-07 03:44:45 -05:00
|
|
|
* b = get_binding("hello")
|
2007-02-02 10:21:41 -05:00
|
|
|
* b.eval("param") #=> "hello"
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2007-02-05 13:50:35 -05:00
|
|
|
bind_eval(int argc, VALUE *argv, VALUE bindval)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
2007-02-05 13:50:35 -05:00
|
|
|
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 */);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
proc_new(VALUE klass, int is_lambda)
|
|
|
|
{
|
|
|
|
VALUE procval = Qnil;
|
* blockinlining.c, error.c, eval.c, eval_error.h, eval_intern.h,
eval_jump.h, eval_load.c, eval_safe.h, gc.c, proc.c, signal.c,
thread.c, thread_pthread.ci, thread_win32.ci, vm.c, vm.h,
vm_dump.c, vm_evalbody.ci, yarvcore.c, yarvcore.h:
fix typo (rb_thead_t -> rb_thread_t).
* eval_intern.h: remove unused definitions.
* common.mk: fix around vm_opts.h path
and remove harmful argument passed to insns2vm.rb.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11658 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-08 01:37:46 -05:00
|
|
|
rb_thread_t *th = GET_THREAD();
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_control_frame_t *cfp = th->cfp;
|
|
|
|
rb_block_t *block;
|
2007-02-02 10:21:41 -05:00
|
|
|
|
2012-06-10 23:14:59 -04:00
|
|
|
if ((block = rb_vm_control_frame_block_ptr(cfp)) != 0) {
|
|
|
|
/* block found */
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
else {
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
|
2007-05-01 00:35:58 -04:00
|
|
|
|
2012-06-10 23:14:59 -04:00
|
|
|
if ((block = rb_vm_control_frame_block_ptr(cfp)) != 0) {
|
2007-02-02 10:21:41 -05:00
|
|
|
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");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-20 09:28:18 -04:00
|
|
|
procval = block->proc;
|
2008-12-24 22:51:35 -05:00
|
|
|
|
|
|
|
if (procval) {
|
|
|
|
if (RBASIC(procval)->klass == klass) {
|
|
|
|
return procval;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
VALUE newprocval = proc_dup(procval);
|
|
|
|
RBASIC(newprocval)->klass = klass;
|
|
|
|
return newprocval;
|
|
|
|
}
|
2007-06-29 03:42:16 -04:00
|
|
|
}
|
|
|
|
|
* vm.c: add a prefix "rb_" to exposed functions
vm_get_ruby_level_next_cfp(), rb_vm_make_env_object(),
vm_stack_to_heap(), vm_make_proc(), vm_invoke_proc(),
vm_get_sourceline(), vm_cref(), vm_localjump_error(),
vm_make_jump_tag_but_local_jump(), vm_jump_tag_but_local_jump().
This changes may affect only core because most of renamed functions
require a pointer of not-exposed struct such as rb_thread_t or NODE.
In short, they are core functions.
* cont.c, eval.c, eval_intern.h, load.c, proc.c, thread.c,
vm_core.h, vm_dump.c, vm_eval.c, vm_exec.c, vm_insnhelper.c:
ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@21659 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-01-18 21:38:11 -05:00
|
|
|
procval = rb_vm_make_proc(th, block, klass);
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
if (is_lambda) {
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_proc_t *proc;
|
2007-02-02 10:21:41 -05:00
|
|
|
GetProcPtr(procval, proc);
|
2009-07-18 04:05:32 -04:00
|
|
|
proc->is_lambda = TRUE;
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
return procval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* Proc.new {|...| block } -> a_proc
|
|
|
|
* Proc.new -> a_proc
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* def proc_from
|
|
|
|
* Proc.new
|
|
|
|
* end
|
|
|
|
* proc = proc_from { "hello" }
|
|
|
|
* proc.call #=> "hello"
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2007-12-05 02:18:52 -05:00
|
|
|
rb_proc_s_new(int argc, VALUE *argv, VALUE klass)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
2009-07-18 04:05:32 -04:00
|
|
|
VALUE block = proc_new(klass, FALSE);
|
2007-12-05 02:18:52 -05:00
|
|
|
|
|
|
|
rb_obj_call_init(block, argc, argv);
|
|
|
|
return block;
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* proc { |...| block } -> a_proc
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
|
|
|
* Equivalent to <code>Proc.new</code>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_block_proc(void)
|
|
|
|
{
|
2009-07-18 04:05:32 -04:00
|
|
|
return proc_new(rb_cProc, FALSE);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_block_lambda(void)
|
|
|
|
{
|
2009-07-18 04:05:32 -04:00
|
|
|
return proc_new(rb_cProc, TRUE);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_f_lambda(void)
|
|
|
|
{
|
|
|
|
rb_warn("rb_f_lambda() is deprecated; use rb_block_proc() instead");
|
|
|
|
return rb_block_lambda();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* lambda { |...| block } -> a_proc
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
|
|
|
* Equivalent to <code>Proc.new</code>, except the resulting Proc objects
|
|
|
|
* check the number of parameters passed when called.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
proc_lambda(void)
|
|
|
|
{
|
|
|
|
return rb_block_lambda();
|
|
|
|
}
|
|
|
|
|
2011-10-03 18:59:45 -04:00
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
/* CHECKME: are the argument checking semantics correct? */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* prc.call(params,...) -> obj
|
|
|
|
* prc[params,...] -> obj
|
|
|
|
* prc.(params,...) -> obj
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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
|
2008-09-06 10:58:11 -04:00
|
|
|
* to an array). Note that prc.() invokes prc.call() with the parameters
|
|
|
|
* given. It's a syntax sugar to hide "call".
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
2011-10-03 19:16:11 -04:00
|
|
|
* 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.
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
|
|
|
* Returns the value of the last expression evaluated in the block. See
|
|
|
|
* also <code>Proc#yield</code>.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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]
|
2011-10-03 19:16:11 -04:00
|
|
|
* a_proc = lambda {|a,b| a}
|
2007-02-02 10:21:41 -05:00
|
|
|
* a_proc.call(1,2,3)
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* <em>produces:</em>
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2011-10-03 19:16:11 -04:00
|
|
|
* 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>'
|
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
proc_call(int argc, VALUE *argv, VALUE procval)
|
|
|
|
{
|
2011-12-23 22:38:56 -05:00
|
|
|
VALUE vret;
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_proc_t *proc;
|
2007-12-20 02:07:35 -05:00
|
|
|
rb_block_t *blockptr = 0;
|
2008-09-26 09:47:01 -04:00
|
|
|
rb_iseq_t *iseq;
|
2011-01-18 22:21:52 -05:00
|
|
|
VALUE passed_procval;
|
2007-02-02 10:21:41 -05:00
|
|
|
GetProcPtr(procval, proc);
|
2007-05-01 00:35:58 -04:00
|
|
|
|
2008-09-26 09:47:01 -04:00
|
|
|
iseq = proc->block.iseq;
|
|
|
|
if (BUILTIN_TYPE(iseq) == T_NODE || iseq->arg_block != -1) {
|
2007-12-20 02:07:35 -05:00
|
|
|
if (rb_block_given_p()) {
|
2011-01-18 22:21:52 -05:00
|
|
|
rb_proc_t *passed_proc;
|
|
|
|
RB_GC_GUARD(passed_procval) = rb_block_proc();
|
|
|
|
GetProcPtr(passed_procval, passed_proc);
|
|
|
|
blockptr = &passed_proc->block;
|
2007-12-20 02:07:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-20 07:36:34 -04:00
|
|
|
vret = rb_vm_invoke_proc(GET_THREAD(), proc, argc, argv, blockptr);
|
2011-12-23 22:38:56 -05:00
|
|
|
RB_GC_GUARD(procval);
|
|
|
|
return vret;
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
2009-03-14 05:05:09 -04:00
|
|
|
#if SIZEOF_LONG > SIZEOF_INT
|
2009-03-14 05:18:09 -04:00
|
|
|
static inline int
|
|
|
|
check_argc(long argc)
|
|
|
|
{
|
2009-03-14 05:05:09 -04:00
|
|
|
if (argc > INT_MAX || argc < 0) {
|
|
|
|
rb_raise(rb_eArgError, "too many arguments (%lu)",
|
|
|
|
(unsigned long)argc);
|
|
|
|
}
|
2009-03-14 05:18:09 -04:00
|
|
|
return (int)argc;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define check_argc(argc) (argc)
|
2009-03-14 05:05:09 -04:00
|
|
|
#endif
|
2009-03-14 05:18:09 -04:00
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_proc_call(VALUE self, VALUE args)
|
|
|
|
{
|
2011-12-23 22:38:56 -05:00
|
|
|
VALUE vret;
|
2009-03-14 05:18:09 -04:00
|
|
|
rb_proc_t *proc;
|
|
|
|
GetProcPtr(self, proc);
|
2012-08-20 07:36:34 -04:00
|
|
|
vret = rb_vm_invoke_proc(GET_THREAD(), proc,
|
2009-03-14 05:18:09 -04:00
|
|
|
check_argc(RARRAY_LEN(args)), RARRAY_PTR(args), 0);
|
2011-12-23 22:38:56 -05:00
|
|
|
RB_GC_GUARD(self);
|
|
|
|
RB_GC_GUARD(args);
|
|
|
|
return vret;
|
2008-06-10 12:33:51 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_proc_call_with_block(VALUE self, int argc, VALUE *argv, VALUE pass_procval)
|
|
|
|
{
|
2011-12-23 22:38:56 -05:00
|
|
|
VALUE vret;
|
2008-07-31 12:02:18 -04:00
|
|
|
rb_proc_t *proc;
|
|
|
|
rb_block_t *block = 0;
|
2008-06-10 12:33:51 -04:00
|
|
|
GetProcPtr(self, proc);
|
|
|
|
|
|
|
|
if (!NIL_P(pass_procval)) {
|
2008-07-31 12:02:18 -04:00
|
|
|
rb_proc_t *pass_proc;
|
2008-06-10 12:33:51 -04:00
|
|
|
GetProcPtr(pass_procval, pass_proc);
|
2008-07-31 12:02:18 -04:00
|
|
|
block = &pass_proc->block;
|
2008-06-10 12:33:51 -04:00
|
|
|
}
|
|
|
|
|
2012-08-20 07:36:34 -04:00
|
|
|
vret = rb_vm_invoke_proc(GET_THREAD(), proc, argc, argv, block);
|
2011-12-23 22:38:56 -05:00
|
|
|
RB_GC_GUARD(self);
|
|
|
|
RB_GC_GUARD(pass_procval);
|
|
|
|
return vret;
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* prc.arity -> fixnum
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* Returns the number of arguments that would not be ignored. 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, return -n-1, where n is the number of mandatory
|
|
|
|
* arguments. A <code>proc</code> with no argument declarations
|
|
|
|
* is the same a block declaring <code>||</code> as its arguments.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2012-07-17 14:08:40 -04:00
|
|
|
* 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 = 0| }.arity #=> 0
|
|
|
|
* lambda { |a = 0| }.arity #=> -1
|
|
|
|
* proc { |x=0, y| }.arity #=> 0
|
|
|
|
* 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
|
2007-02-02 10:21:41 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
proc_arity(VALUE self)
|
2009-03-14 04:59:12 -04:00
|
|
|
{
|
|
|
|
int arity = rb_proc_arity(self);
|
|
|
|
return INT2FIX(arity);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-03-14 05:03:48 -04:00
|
|
|
rb_proc_arity(VALUE self)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_proc_t *proc;
|
|
|
|
rb_iseq_t *iseq;
|
2007-02-02 10:21:41 -05:00
|
|
|
GetProcPtr(self, proc);
|
|
|
|
iseq = proc->block.iseq;
|
2007-05-01 01:01:15 -04:00
|
|
|
if (iseq) {
|
|
|
|
if (BUILTIN_TYPE(iseq) != T_NODE) {
|
2012-07-17 03:47:52 -04:00
|
|
|
if (iseq->arg_rest < 0 && (!proc->is_lambda || iseq->arg_opts == 0)) {
|
2009-03-14 04:59:12 -04:00
|
|
|
return iseq->argc;
|
2007-05-01 01:01:15 -04:00
|
|
|
}
|
|
|
|
else {
|
2009-03-14 04:59:12 -04:00
|
|
|
return -(iseq->argc + 1 + iseq->arg_post_len);
|
2007-05-01 01:01:15 -04:00
|
|
|
}
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
else {
|
2007-05-01 01:01:15 -04:00
|
|
|
NODE *node = (NODE *)iseq;
|
2009-09-21 04:12:12 -04:00
|
|
|
if (IS_METHOD_PROC_NODE(node)) {
|
2007-05-01 01:01:15 -04:00
|
|
|
/* method(:foo).to_proc.arity */
|
2009-03-14 04:59:12 -04:00
|
|
|
return method_arity(node->nd_tval);
|
2007-05-01 01:01:15 -04:00
|
|
|
}
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
}
|
2009-03-14 04:59:12 -04:00
|
|
|
return -1;
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
2009-09-30 00:15:46 -04:00
|
|
|
#define get_proc_iseq rb_proc_get_iseq
|
|
|
|
|
|
|
|
rb_iseq_t *
|
|
|
|
rb_proc_get_iseq(VALUE self, int *is_proc)
|
2007-12-05 02:18:52 -05:00
|
|
|
{
|
|
|
|
rb_proc_t *proc;
|
|
|
|
rb_iseq_t *iseq;
|
|
|
|
|
|
|
|
GetProcPtr(self, proc);
|
|
|
|
iseq = proc->block.iseq;
|
2008-12-04 23:05:48 -05:00
|
|
|
if (is_proc) *is_proc = !proc->is_lambda;
|
2008-11-27 23:19:37 -05:00
|
|
|
if (!RUBY_VM_NORMAL_ISEQ_P(iseq)) {
|
|
|
|
NODE *node = (NODE *)iseq;
|
|
|
|
iseq = 0;
|
2009-09-21 04:12:12 -04:00
|
|
|
if (IS_METHOD_PROC_NODE(node)) {
|
2008-11-27 23:19:37 -05:00
|
|
|
/* method(:foo).to_proc */
|
2009-07-15 10:59:41 -04:00
|
|
|
iseq = rb_method_get_iseq(node->nd_tval);
|
2008-12-04 23:05:48 -05:00
|
|
|
if (is_proc) *is_proc = 0;
|
2008-11-27 23:19:37 -05:00
|
|
|
}
|
|
|
|
}
|
2007-12-05 02:18:52 -05:00
|
|
|
return iseq;
|
|
|
|
}
|
|
|
|
|
2008-09-26 09:47:01 -04:00
|
|
|
static VALUE
|
|
|
|
iseq_location(rb_iseq_t *iseq)
|
2007-12-05 02:18:52 -05:00
|
|
|
{
|
|
|
|
VALUE loc[2];
|
|
|
|
|
|
|
|
if (!iseq) return Qnil;
|
2012-06-03 22:49:37 -04:00
|
|
|
loc[0] = iseq->location.path;
|
2011-08-24 02:31:15 -04:00
|
|
|
if (iseq->line_info_table) {
|
* include/ruby/node.h, vm_core.h: move definition of
RUBY_VM_METHOD_NODE to node.h.
* class.c, common.mk: remove useless inclusion.
* compile.h, iseq.h, vm_core.h: rename compile.h to iseq.h.
move some definitions from vm_core.h to iseq.h.
* compile.c, iseq.c, vm.c: ditto.
* eval.c, compile.c: move some functions for parser
from eval.c to compile.c.
* eval_intern.h, vm_core.h: move va_init_list() macro to
vm_core.h.
* iseq.c (rb_iseq_new_top, rb_iseq_first_lineno): added.
* load.c, ruby.c: use rb_iseq_new_top() instead of
rb_iseq_new() with ISEQ_TYPE_TOP constant directly.
* proc.c: use rb_iseq_first_lineno() instead of accessing
iseq structure.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@19472 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-09-23 03:49:45 -04:00
|
|
|
loc[1] = INT2FIX(rb_iseq_first_lineno(iseq));
|
2007-12-05 02:18:52 -05:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
loc[1] = Qnil;
|
|
|
|
}
|
|
|
|
return rb_ary_new4(2, loc);
|
|
|
|
}
|
|
|
|
|
2008-09-26 09:47:01 -04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* prc.source_location -> [String, Fixnum]
|
2008-09-26 09:47:01 -04:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* Returns the Ruby source filename and line number containing this proc
|
|
|
|
* or +nil+ if this proc was not defined in Ruby (i.e. native)
|
2008-09-26 09:47:01 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_proc_location(VALUE self)
|
|
|
|
{
|
2008-12-04 23:05:48 -05:00
|
|
|
return iseq_location(get_proc_iseq(self, 0));
|
2008-09-26 09:47:01 -04:00
|
|
|
}
|
|
|
|
|
2008-11-27 23:19:37 -05:00
|
|
|
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:
|
2011-05-27 09:55:43 -04:00
|
|
|
* prc.parameters -> array
|
2008-11-27 23:19:37 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* Returns the parameter information of this proc.
|
2010-05-17 17:07:46 -04:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* prc = lambda{|x, y=42, *other|}
|
|
|
|
* prc.parameters #=> [[:req, :x], [:opt, :y], [:rest, :other]]
|
2008-11-27 23:19:37 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
rb_proc_parameters(VALUE self)
|
|
|
|
{
|
2008-12-04 23:05:48 -05:00
|
|
|
int is_proc;
|
|
|
|
rb_iseq_t *iseq = get_proc_iseq(self, &is_proc);
|
2008-11-27 23:19:37 -05:00
|
|
|
if (!iseq) {
|
2009-03-14 04:59:12 -04:00
|
|
|
return unnamed_parameters(rb_proc_arity(self));
|
2008-11-27 23:19:37 -05:00
|
|
|
}
|
2008-12-04 23:05:48 -05:00
|
|
|
return rb_iseq_parameters(iseq, is_proc);
|
2008-11-27 23:19:37 -05:00
|
|
|
}
|
|
|
|
|
2012-02-20 19:13:44 -05:00
|
|
|
st_index_t
|
|
|
|
rb_hash_proc(st_index_t hash, VALUE prc)
|
|
|
|
{
|
2012-02-21 02:08:21 -05:00
|
|
|
rb_proc_t *proc;
|
|
|
|
GetProcPtr(prc, proc);
|
2012-02-20 19:13:44 -05:00
|
|
|
hash = rb_hash_uint(hash, (st_index_t)proc->block.iseq);
|
|
|
|
hash = rb_hash_uint(hash, (st_index_t)proc->envval);
|
2012-06-10 23:14:59 -04:00
|
|
|
return rb_hash_uint(hash, (st_index_t)proc->block.ep >> 16);
|
2012-02-20 19:13:44 -05:00
|
|
|
}
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* prc.hash -> integer
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* Returns a hash value corresponding to proc body.
|
2007-02-02 10:21:41 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
proc_hash(VALUE self)
|
|
|
|
{
|
2009-09-08 09:10:04 -04:00
|
|
|
st_index_t hash;
|
2012-02-20 19:13:44 -05:00
|
|
|
hash = rb_hash_start(0);
|
2012-02-21 02:08:21 -05:00
|
|
|
hash = rb_hash_proc(hash, self);
|
2009-09-08 09:10:04 -04:00
|
|
|
hash = rb_hash_end(hash);
|
2009-07-05 20:23:36 -04:00
|
|
|
return LONG2FIX(hash);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* prc.to_s -> string
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* Returns the unique identifier for this proc, along with
|
2007-02-02 10:21:41 -05:00
|
|
|
* an indication of where the proc was defined.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
proc_to_s(VALUE self)
|
|
|
|
{
|
|
|
|
VALUE str = 0;
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_proc_t *proc;
|
2008-05-31 05:28:20 -04:00
|
|
|
const char *cname = rb_obj_classname(self);
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
rb_iseq_t *iseq;
|
2007-06-24 03:35:49 -04:00
|
|
|
const char *is_lambda;
|
2009-02-22 09:23:33 -05:00
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
GetProcPtr(self, proc);
|
|
|
|
iseq = proc->block.iseq;
|
2007-06-24 03:35:49 -04:00
|
|
|
is_lambda = proc->is_lambda ? " (lambda)" : "";
|
2007-02-02 10:21:41 -05:00
|
|
|
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
|
2012-06-03 22:49:37 -04:00
|
|
|
int first_lineno = 0;
|
2009-02-22 09:23:33 -05:00
|
|
|
|
2011-08-24 02:31:15 -04:00
|
|
|
if (iseq->line_info_table) {
|
2012-06-03 22:49:37 -04:00
|
|
|
first_lineno = rb_iseq_first_lineno(iseq);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
2007-06-24 03:10:46 -04:00
|
|
|
str = rb_sprintf("#<%s:%p@%s:%d%s>", cname, (void *)self,
|
2012-06-03 22:49:37 -04:00
|
|
|
RSTRING_PTR(iseq->location.path),
|
|
|
|
first_lineno, is_lambda);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
else {
|
* compile.c (iseq_compile_each), gc.c (assign_heap_slot),
(gc_mark_children), parse.y (vtable_alloc, vtable_free, vtable_add),
proc.c (proc_to_s), thread.c (terminate_i, rb_thread_terminate_all),
(thread_start_func_2, blocking_region_begin, blocking_region_end),
(rb_thread_kill), thread_pthread.c (native_thread_create),
(ubf_pthread_cond_signal), vm.c (check_env, thread_free), vm_dump.c
(vm_env_dump_raw, vm_stack_dump_each, vm_thread_dump_state),
(vm_call0): use void pointer for %p.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@20593 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-12-08 23:33:55 -05:00
|
|
|
str = rb_sprintf("#<%s:%p%s>", cname, (void *)proc->block.iseq,
|
2007-06-24 03:10:46 -04:00
|
|
|
is_lambda);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
if (OBJ_TAINTED(self)) {
|
|
|
|
OBJ_TAINT(str);
|
|
|
|
}
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* prc.to_proc -> prc
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2007-12-24 04:09:21 -05:00
|
|
|
static void
|
2009-07-08 04:13:41 -04:00
|
|
|
bm_mark(void *ptr)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
2009-07-08 04:13:41 -04:00
|
|
|
struct METHOD *data = ptr;
|
2012-08-02 07:08:44 -04:00
|
|
|
rb_gc_mark(data->defined_class);
|
2007-11-21 20:17:52 -05:00
|
|
|
rb_gc_mark(data->rclass);
|
2007-02-02 10:21:41 -05:00
|
|
|
rb_gc_mark(data->recv);
|
2011-07-25 10:29:28 -04:00
|
|
|
if (data->me) rb_mark_method_entry(data->me);
|
2009-08-27 22:45:41 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
bm_free(void *ptr)
|
|
|
|
{
|
|
|
|
struct METHOD *data = ptr;
|
2011-07-25 11:17:56 -04:00
|
|
|
struct unlinked_method_entry_list_entry *ume = data->ume;
|
|
|
|
ume->me = data->me;
|
|
|
|
ume->next = GET_VM()->unlinked_method_entry_list;
|
|
|
|
GET_VM()->unlinked_method_entry_list = ume;
|
2010-07-15 08:39:36 -04:00
|
|
|
xfree(ptr);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
static size_t
|
2009-09-08 22:11:35 -04:00
|
|
|
bm_memsize(const void *ptr)
|
2009-07-08 04:13:41 -04:00
|
|
|
{
|
|
|
|
return ptr ? sizeof(struct METHOD) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const rb_data_type_t method_data_type = {
|
|
|
|
"method",
|
2010-07-18 03:31:54 -04:00
|
|
|
{
|
|
|
|
bm_mark,
|
|
|
|
bm_free,
|
|
|
|
bm_memsize,
|
|
|
|
},
|
2009-07-08 04:13:41 -04:00
|
|
|
};
|
|
|
|
|
2010-12-07 08:05:26 -05:00
|
|
|
VALUE
|
2009-07-08 04:13:41 -04:00
|
|
|
rb_obj_is_method(VALUE m)
|
|
|
|
{
|
2010-12-07 08:05:26 -05:00
|
|
|
if (rb_typeddata_is_kind_of(m, &method_data_type)) {
|
|
|
|
return Qtrue;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return Qfalse;
|
|
|
|
}
|
2009-07-08 04:13:41 -04:00
|
|
|
}
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
static VALUE
|
2007-12-17 18:01:50 -05:00
|
|
|
mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
|
|
|
VALUE method;
|
2012-08-02 07:08:44 -04:00
|
|
|
VALUE rclass = klass, defined_class;
|
2009-07-15 10:59:41 -04:00
|
|
|
ID rid = id;
|
|
|
|
struct METHOD *data;
|
2009-09-27 23:09:16 -04:00
|
|
|
rb_method_entry_t *me, meb;
|
|
|
|
rb_method_definition_t *def = 0;
|
2010-01-08 09:40:38 -05:00
|
|
|
rb_method_flag_t flag = NOEX_UNDEF;
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
again:
|
2012-11-29 21:11:59 -05:00
|
|
|
me = rb_method_entry(klass, id, &defined_class);
|
2009-08-27 22:45:41 -04:00
|
|
|
if (UNDEFINED_METHOD_ENTRY_P(me)) {
|
2009-09-24 00:42:28 -04:00
|
|
|
ID rmiss = rb_intern("respond_to_missing?");
|
|
|
|
VALUE sym = ID2SYM(id);
|
|
|
|
|
2009-09-25 00:04:48 -04:00
|
|
|
if (obj != Qundef && !rb_method_basic_definition_p(klass, rmiss)) {
|
2009-11-03 22:49:54 -05:00
|
|
|
if (RTEST(rb_funcall(obj, rmiss, 2, sym, scope ? Qfalse : Qtrue))) {
|
2009-09-27 23:09:16 -04:00
|
|
|
def = ALLOC(rb_method_definition_t);
|
|
|
|
def->type = VM_METHOD_TYPE_MISSING;
|
|
|
|
def->original_id = id;
|
|
|
|
def->alias_count = 0;
|
|
|
|
|
|
|
|
meb.flag = 0;
|
2010-05-16 09:25:29 -04:00
|
|
|
meb.mark = 0;
|
2009-09-27 23:09:16 -04:00
|
|
|
meb.called_id = id;
|
|
|
|
meb.klass = klass;
|
|
|
|
meb.def = def;
|
|
|
|
me = &meb;
|
|
|
|
def = 0;
|
|
|
|
|
|
|
|
goto gen_method;
|
2009-09-24 00:42:28 -04:00
|
|
|
}
|
|
|
|
}
|
2009-07-15 10:59:41 -04:00
|
|
|
rb_print_undef(klass, id, 0);
|
2007-12-17 18:01:50 -05:00
|
|
|
}
|
2009-08-27 22:45:41 -04:00
|
|
|
def = me->def;
|
2010-01-08 09:40:38 -05:00
|
|
|
if (flag == NOEX_UNDEF) {
|
|
|
|
flag = me->flag;
|
|
|
|
if (scope && (flag & NOEX_MASK) != NOEX_PUBLIC) {
|
2010-04-22 10:15:29 -04:00
|
|
|
const char *v = "";
|
|
|
|
switch (flag & NOEX_MASK) {
|
|
|
|
case NOEX_PRIVATE: v = "private"; break;
|
|
|
|
case NOEX_PROTECTED: v = "protected"; break;
|
|
|
|
}
|
|
|
|
rb_name_error(id, "method `%s' for %s `%s' is %s",
|
|
|
|
rb_id2name(id),
|
2011-09-29 07:07:45 -04:00
|
|
|
(RB_TYPE_P(klass, T_MODULE)) ? "module" : "class",
|
2010-04-22 10:15:29 -04:00
|
|
|
rb_class2name(klass),
|
|
|
|
v);
|
2010-01-08 09:40:38 -05:00
|
|
|
}
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
2009-09-27 23:09:16 -04:00
|
|
|
if (def && def->type == VM_METHOD_TYPE_ZSUPER) {
|
2012-08-02 07:08:44 -04:00
|
|
|
klass = RCLASS_SUPER(defined_class);
|
2009-08-27 22:45:41 -04:00
|
|
|
id = def->original_id;
|
2007-02-02 10:21:41 -05:00
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
2012-08-02 07:08:44 -04:00
|
|
|
klass = defined_class;
|
2009-07-15 10:59:41 -04:00
|
|
|
|
2007-11-21 20:17:52 -05:00
|
|
|
while (rclass != klass &&
|
2011-09-29 07:07:45 -04:00
|
|
|
(FL_TEST(rclass, FL_SINGLETON) || RB_TYPE_P(rclass, T_ICLASS))) {
|
2007-11-21 20:17:52 -05:00
|
|
|
rclass = RCLASS_SUPER(rclass);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
2009-07-15 10:59:41 -04:00
|
|
|
|
2011-09-29 07:07:45 -04:00
|
|
|
if (RB_TYPE_P(klass, T_ICLASS)) {
|
2007-02-02 10:21:41 -05:00
|
|
|
klass = RBASIC(klass)->klass;
|
2009-07-15 10:59:41 -04:00
|
|
|
}
|
|
|
|
|
2009-09-27 23:09:16 -04:00
|
|
|
gen_method:
|
2009-07-08 04:13:41 -04:00
|
|
|
method = TypedData_Make_Struct(mclass, struct METHOD, &method_data_type, data);
|
2007-02-02 10:21:41 -05:00
|
|
|
|
2009-07-15 10:59:41 -04:00
|
|
|
data->recv = obj;
|
2007-11-21 20:17:52 -05:00
|
|
|
data->rclass = rclass;
|
2012-08-02 07:08:44 -04:00
|
|
|
data->defined_class = defined_class;
|
2009-07-15 10:59:41 -04:00
|
|
|
data->id = rid;
|
2011-07-25 10:29:28 -04:00
|
|
|
data->me = ALLOC(rb_method_entry_t);
|
|
|
|
*data->me = *me;
|
|
|
|
data->me->def->alias_count++;
|
2011-07-25 11:17:56 -04:00
|
|
|
data->ume = ALLOC(struct unlinked_method_entry_list_entry);
|
2009-07-15 10:59:41 -04:00
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
OBJ_INFECT(method, klass);
|
|
|
|
|
|
|
|
return method;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
*
|
|
|
|
* 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.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* class Thing
|
|
|
|
* def square(n)
|
|
|
|
* n*n
|
|
|
|
* end
|
|
|
|
* end
|
|
|
|
* thing = Thing.new
|
|
|
|
* meth = thing.method(:square)
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* meth.call(9) #=> 81
|
|
|
|
* [ 1, 2, 3 ].collect(&meth) #=> [1, 4, 9]
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth == other_meth -> true or false
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
2009-09-24 16:59:19 -04:00
|
|
|
* Two method objects are equal if they are bound to the same
|
|
|
|
* object and refer to the same method definition.
|
2007-02-02 10:21:41 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2007-02-05 13:31:08 -05:00
|
|
|
method_eq(VALUE method, VALUE other)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
|
|
|
struct METHOD *m1, *m2;
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
if (!rb_obj_is_method(other))
|
2007-02-02 10:21:41 -05:00
|
|
|
return Qfalse;
|
|
|
|
if (CLASS_OF(method) != CLASS_OF(other))
|
|
|
|
return Qfalse;
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
Check_TypedStruct(method, &method_data_type);
|
|
|
|
m1 = (struct METHOD *)DATA_PTR(method);
|
|
|
|
m2 = (struct METHOD *)DATA_PTR(other);
|
2007-02-02 10:21:41 -05:00
|
|
|
|
2011-07-25 10:29:28 -04:00
|
|
|
if (!rb_method_entry_eq(m1->me, m2->me) ||
|
2009-07-15 10:59:41 -04:00
|
|
|
m1->rclass != m2->rclass ||
|
|
|
|
m1->recv != m2->recv) {
|
2007-02-02 10:21:41 -05:00
|
|
|
return Qfalse;
|
2009-07-15 10:59:41 -04:00
|
|
|
}
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
return Qtrue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth.hash -> integer
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* Returns a hash value corresponding to the method object.
|
2007-02-02 10:21:41 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2007-02-05 13:31:08 -05:00
|
|
|
method_hash(VALUE method)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
|
|
|
struct METHOD *m;
|
2009-09-08 09:10:04 -04:00
|
|
|
st_index_t hash;
|
2007-02-02 10:21:41 -05:00
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
TypedData_Get_Struct(method, struct METHOD, &method_data_type, m);
|
2009-09-08 09:10:04 -04:00
|
|
|
hash = rb_hash_start((st_index_t)m->rclass);
|
|
|
|
hash = rb_hash_uint(hash, (st_index_t)m->recv);
|
2012-02-20 19:13:44 -05:00
|
|
|
hash = rb_hash_method_entry(hash, m->me);
|
2009-09-08 09:10:04 -04:00
|
|
|
hash = rb_hash_end(hash);
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
return INT2FIX(hash);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth.unbind -> unbound_method
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* Dissociates <i>meth</i> from its current receiver. The resulting
|
2007-02-02 10:21:41 -05:00
|
|
|
* <code>UnboundMethod</code> can subsequently be bound to a new object
|
|
|
|
* of the same class (see <code>UnboundMethod</code>).
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2007-02-05 13:31:08 -05:00
|
|
|
method_unbind(VALUE obj)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
|
|
|
VALUE method;
|
|
|
|
struct METHOD *orig, *data;
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
TypedData_Get_Struct(obj, struct METHOD, &method_data_type, orig);
|
2009-07-15 10:59:41 -04:00
|
|
|
method = TypedData_Make_Struct(rb_cUnboundMethod, struct METHOD,
|
|
|
|
&method_data_type, data);
|
2007-02-02 10:21:41 -05:00
|
|
|
data->recv = Qundef;
|
|
|
|
data->id = orig->id;
|
2011-07-25 10:29:28 -04:00
|
|
|
data->me = ALLOC(rb_method_entry_t);
|
|
|
|
*data->me = *orig->me;
|
|
|
|
if (orig->me->def) orig->me->def->alias_count++;
|
2007-11-21 20:17:52 -05:00
|
|
|
data->rclass = orig->rclass;
|
2012-08-02 07:08:44 -04:00
|
|
|
data->defined_class = orig->defined_class;
|
2011-07-25 11:17:56 -04:00
|
|
|
data->ume = ALLOC(struct unlinked_method_entry_list_entry);
|
2007-02-02 10:21:41 -05:00
|
|
|
OBJ_INFECT(method, obj);
|
|
|
|
|
|
|
|
return method;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth.receiver -> object
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* Returns the bound receiver of the method object.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
method_receiver(VALUE obj)
|
|
|
|
{
|
|
|
|
struct METHOD *data;
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data);
|
2007-02-02 10:21:41 -05:00
|
|
|
return data->recv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth.name -> symbol
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* Returns the name of the method.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
method_name(VALUE obj)
|
|
|
|
{
|
|
|
|
struct METHOD *data;
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data);
|
2008-04-27 22:12:21 -04:00
|
|
|
return ID2SYM(data->id);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth.owner -> class_or_module
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* Returns the class or module that defines the method.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
method_owner(VALUE obj)
|
|
|
|
{
|
|
|
|
struct METHOD *data;
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data);
|
2011-07-25 10:29:28 -04:00
|
|
|
return data->me->klass;
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
2011-07-26 12:05:35 -04:00
|
|
|
void
|
2011-07-23 11:05:03 -04:00
|
|
|
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 `%s' for%s `%s'",
|
|
|
|
RSTRING_PTR(str), s0, rb_class2name(c));
|
|
|
|
}
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* obj.method(sym) -> method
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* class Demo
|
|
|
|
* def initialize(n)
|
|
|
|
* @iv = n
|
|
|
|
* end
|
|
|
|
* def hello()
|
|
|
|
* "Hello, @iv = #{@iv}"
|
|
|
|
* end
|
|
|
|
* end
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* k = Demo.new(99)
|
|
|
|
* m = k.method(:hello)
|
|
|
|
* m.call #=> "Hello, @iv = 99"
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* l = Demo.new('Fred')
|
|
|
|
* m = l.method("hello")
|
|
|
|
* m.call #=> "Hello, @iv = Fred"
|
|
|
|
*/
|
|
|
|
|
|
|
|
VALUE
|
2007-02-05 13:31:08 -05:00
|
|
|
rb_obj_method(VALUE obj, VALUE vid)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
2011-07-26 12:05:27 -04:00
|
|
|
ID id = rb_check_id(&vid);
|
2011-07-23 11:05:03 -04:00
|
|
|
if (!id) {
|
|
|
|
rb_method_name_error(CLASS_OF(obj), vid);
|
|
|
|
}
|
|
|
|
return mnew(CLASS_OF(obj), obj, id, rb_cMethod, FALSE);
|
2007-12-17 18:01:50 -05:00
|
|
|
}
|
|
|
|
|
2009-09-21 07:06:32 -04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* obj.public_method(sym) -> method
|
2009-09-21 07:06:32 -04:00
|
|
|
*
|
2009-11-03 12:46:28 -05:00
|
|
|
* Similar to _method_, searches public method only.
|
2009-09-21 07:06:32 -04:00
|
|
|
*/
|
|
|
|
|
2007-12-17 18:01:50 -05:00
|
|
|
VALUE
|
|
|
|
rb_obj_public_method(VALUE obj, VALUE vid)
|
|
|
|
{
|
2011-07-26 12:05:27 -04:00
|
|
|
ID id = rb_check_id(&vid);
|
2011-07-23 11:05:03 -04:00
|
|
|
if (!id) {
|
|
|
|
rb_method_name_error(CLASS_OF(obj), vid);
|
|
|
|
}
|
|
|
|
return mnew(CLASS_OF(obj), obj, id, rb_cMethod, TRUE);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* mod.instance_method(symbol) -> unbound_method
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* Returns an +UnboundMethod+ representing the given
|
|
|
|
* instance method in _mod_.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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 = {
|
2009-12-07 14:06:11 -05:00
|
|
|
* "a" => instance_method(:do_a),
|
|
|
|
* "d" => instance_method(:do_d),
|
|
|
|
* "e" => instance_method(:do_e),
|
|
|
|
* "v" => instance_method(:do_v)
|
2007-02-02 10:21:41 -05:00
|
|
|
* }
|
|
|
|
* def interpret(string)
|
2009-12-07 14:06:11 -05:00
|
|
|
* string.each_char {|b| Dispatcher[b].bind(self).call }
|
2007-02-02 10:21:41 -05:00
|
|
|
* end
|
|
|
|
* end
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* interpreter = Interpreter.new
|
|
|
|
* interpreter.interpret('dave')
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* <em>produces:</em>
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* Hello there, Dave!
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2007-12-17 18:01:50 -05:00
|
|
|
rb_mod_instance_method(VALUE mod, VALUE vid)
|
|
|
|
{
|
2011-07-26 12:05:27 -04:00
|
|
|
ID id = rb_check_id(&vid);
|
2011-07-23 11:05:03 -04:00
|
|
|
if (!id) {
|
|
|
|
rb_method_name_error(mod, vid);
|
|
|
|
}
|
|
|
|
return mnew(mod, Qundef, id, rb_cUnboundMethod, FALSE);
|
2007-12-17 18:01:50 -05:00
|
|
|
}
|
|
|
|
|
2009-09-21 07:06:32 -04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* mod.public_instance_method(symbol) -> unbound_method
|
2009-09-21 07:06:32 -04:00
|
|
|
*
|
2009-11-03 12:46:28 -05:00
|
|
|
* Similar to _instance_method_, searches public method only.
|
2009-09-21 07:06:32 -04:00
|
|
|
*/
|
|
|
|
|
2007-12-17 18:01:50 -05:00
|
|
|
static VALUE
|
|
|
|
rb_mod_public_instance_method(VALUE mod, VALUE vid)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
2011-07-26 12:05:27 -04:00
|
|
|
ID id = rb_check_id(&vid);
|
2011-07-23 11:05:03 -04:00
|
|
|
if (!id) {
|
|
|
|
rb_method_name_error(mod, vid);
|
|
|
|
}
|
|
|
|
return mnew(mod, Qundef, id, rb_cUnboundMethod, TRUE);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* define_method(symbol, method) -> new_method
|
|
|
|
* define_method(symbol) { block } -> proc
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* Defines an instance method in the receiver. The _method_
|
2009-09-22 14:53:25 -04:00
|
|
|
* parameter can be a +Proc+, a +Method+ or an +UnboundMethod+ object.
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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.)
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* <em>produces:</em>
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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;
|
|
|
|
|
|
|
|
if (argc == 1) {
|
|
|
|
id = rb_to_id(argv[0]);
|
|
|
|
body = rb_block_lambda();
|
|
|
|
}
|
2012-03-14 17:10:34 -04:00
|
|
|
else {
|
|
|
|
rb_check_arity(argc, 1, 2);
|
2007-02-02 10:21:41 -05:00
|
|
|
id = rb_to_id(argv[0]);
|
|
|
|
body = argv[1];
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
if (!rb_obj_is_method(body) && !rb_obj_is_proc(body)) {
|
2007-02-02 10:21:41 -05:00
|
|
|
rb_raise(rb_eTypeError,
|
|
|
|
"wrong argument type %s (expected Proc/Method)",
|
|
|
|
rb_obj_classname(body));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
if (rb_obj_is_method(body)) {
|
2007-02-02 10:21:41 -05:00
|
|
|
struct METHOD *method = (struct METHOD *)DATA_PTR(body);
|
2007-11-21 20:17:52 -05:00
|
|
|
VALUE rclass = method->rclass;
|
2012-06-25 03:57:42 -04:00
|
|
|
if (rclass != mod && !RB_TYPE_P(rclass, T_MODULE) &&
|
|
|
|
!RTEST(rb_class_inherited_p(mod, rclass))) {
|
2007-11-21 20:17:52 -05:00
|
|
|
if (FL_TEST(rclass, FL_SINGLETON)) {
|
2007-02-02 10:21:41 -05:00
|
|
|
rb_raise(rb_eTypeError,
|
|
|
|
"can't bind singleton method to a different class");
|
|
|
|
}
|
2009-09-22 16:04:59 -04:00
|
|
|
else {
|
2007-02-02 10:21:41 -05:00
|
|
|
rb_raise(rb_eTypeError,
|
|
|
|
"bind argument must be a subclass of %s",
|
2007-11-21 20:17:52 -05:00
|
|
|
rb_class2name(rclass));
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
}
|
2011-07-25 10:29:28 -04:00
|
|
|
rb_method_entry_set(mod, id, method->me, noex);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
* blockinlining.c, compile.c, compile.h, error.c, eval.c,
eval_intern.h, eval_jump.h, eval_load.c, eval_method.h,
eval_safe.h, gc.c, insnhelper.h, insns.def, iseq.c, proc.c,
process.c, signal.c, thread.c, thread_pthread.ci, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, vm_macro.def,
yarv.h, yarvcore.h, yarvcore.c: change type and macro names:
* yarv_*_t -> rb_*_t
* yarv_*_struct -> rb_*_struct
* yarv_tag -> rb_vm_tag
* YARV_* -> RUBY_VM_*
* proc.c, vm.c: move functions about env object creation
from proc.c to vm.c.
* proc.c, yarvcore.c: fix rb_cVM initialization place.
* inits.c: change Init_ISeq() order (after Init_VM).
* ruby.h, proc.c: change declaration place of rb_cEnv
from proc.c to ruby.c.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11651 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 14:00:03 -05:00
|
|
|
else if (rb_obj_is_proc(body)) {
|
|
|
|
rb_proc_t *proc;
|
|
|
|
body = proc_dup(body);
|
2007-02-02 10:21:41 -05:00
|
|
|
GetProcPtr(body, proc);
|
|
|
|
if (BUILTIN_TYPE(proc->block.iseq) != T_NODE) {
|
|
|
|
proc->block.iseq->defined_method_id = id;
|
|
|
|
proc->block.iseq->klass = mod;
|
2009-07-18 04:05:32 -04:00
|
|
|
proc->is_lambda = TRUE;
|
|
|
|
proc->is_from_method = TRUE;
|
2012-08-02 07:08:44 -04:00
|
|
|
proc->block.klass = mod;
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
2009-07-15 10:59:41 -04:00
|
|
|
rb_add_method(mod, id, VM_METHOD_TYPE_BMETHOD, (void *)body, noex);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* type error */
|
|
|
|
rb_raise(rb_eTypeError, "wrong argument type (expected Proc/Method)");
|
|
|
|
}
|
|
|
|
|
|
|
|
return body;
|
|
|
|
}
|
|
|
|
|
2009-07-13 08:41:24 -04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* define_singleton_method(symbol, method) -> new_method
|
|
|
|
* define_singleton_method(symbol) { block } -> proc
|
2009-07-13 08:41:24 -04:00
|
|
|
*
|
|
|
|
* Defines a singleton method in the receiver. The _method_
|
2009-09-22 15:02:42 -04:00
|
|
|
* parameter can be a +Proc+, a +Method+ or an +UnboundMethod+ object.
|
2010-05-29 14:51:39 -04:00
|
|
|
* If a block is specified, it is used as the method body.
|
2009-07-13 08:41:24 -04:00
|
|
|
*
|
|
|
|
* 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!" }
|
2010-05-17 17:07:33 -04:00
|
|
|
* guy.hello #=> "Bob: Hello there!"
|
2009-07-13 08:41:24 -04:00
|
|
|
*/
|
|
|
|
|
2007-08-30 01:06:52 -04:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-11-01 19:24:33 -04:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
rb_secure(4);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
/*
|
2012-08-07 16:51:48 -04:00
|
|
|
* 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"
|
2007-02-02 10:21:41 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2007-02-05 13:31:08 -05:00
|
|
|
method_clone(VALUE self)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
|
|
|
VALUE clone;
|
|
|
|
struct METHOD *orig, *data;
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
TypedData_Get_Struct(self, struct METHOD, &method_data_type, orig);
|
|
|
|
clone = TypedData_Make_Struct(CLASS_OF(self), struct METHOD, &method_data_type, data);
|
2007-02-02 10:21:41 -05:00
|
|
|
CLONESETUP(clone, self);
|
|
|
|
*data = *orig;
|
2011-07-25 10:29:28 -04:00
|
|
|
data->me = ALLOC(rb_method_entry_t);
|
|
|
|
*data->me = *orig->me;
|
|
|
|
if (data->me->def) data->me->def->alias_count++;
|
2011-07-25 11:17:56 -04:00
|
|
|
data->ume = ALLOC(struct unlinked_method_entry_list_entry);
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
return clone;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth.call(args, ...) -> obj
|
|
|
|
* meth[args, ...] -> obj
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* Invokes the <i>meth</i> with the specified arguments, returning the
|
|
|
|
* method's return value.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* m = 12.method("+")
|
|
|
|
* m.call(3) #=> 15
|
|
|
|
* m.call(20) #=> 32
|
|
|
|
*/
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_method_call(int argc, VALUE *argv, VALUE method)
|
|
|
|
{
|
|
|
|
VALUE result = Qnil; /* OK */
|
|
|
|
struct METHOD *data;
|
|
|
|
int state;
|
|
|
|
volatile int safe = -1;
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
|
2007-02-02 10:21:41 -05:00
|
|
|
if (data->recv == Qundef) {
|
|
|
|
rb_raise(rb_eTypeError, "can't call unbound method; bind first");
|
|
|
|
}
|
2007-04-24 21:35:13 -04:00
|
|
|
PUSH_TAG();
|
2007-02-02 10:21:41 -05:00
|
|
|
if (OBJ_TAINTED(method)) {
|
|
|
|
safe = rb_safe_level();
|
|
|
|
if (rb_safe_level() < 4) {
|
|
|
|
rb_set_safe_level_force(4);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((state = EXEC_TAG()) == 0) {
|
* vm.c, eval_intern.h (PASS_PASSED_BLOCK):
set a VM_FRAME_FLAG_PASSED flag to skip this frame when
searching ruby-level-cfp.
* eval.c, eval_intern.h, proc.c: fix to check cfp. if there is
no valid ruby-level-cfp, cause RuntimeError exception.
[ruby-dev:34128]
* vm_core.h, vm_evalbody.c, vm.c, vm_dump.c, vm_insnhelper.c,
insns.def: rename FRAME_MAGIC_* to VM_FRAME_MAGIC_*.
* KNOWNBUGS.rb, bootstraptest/test*.rb: move solved bugs.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@17084 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-06-10 17:46:43 -04:00
|
|
|
rb_thread_t *th = GET_THREAD();
|
* eval_method.c: renamed from vm_method.c. "vm_method.c" is included
by "vm.c".
* vm_eval.c: added. Some codes are moved from "eval.c"
* common.mk: fix for above changes.
* compile.c: make a vm_eval(0)
* eval.c, eval_error.c, eval_intern.h, eval_jump.c, proc.c, vm.c,
id.c, id.h, vm_core.h, vm_dump.c, vm_evalbody.c, vm_insnhelper.c,
blockinlining.c: fix for above changes. and do some refactoring.
this changes improve rb_yield() performance.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@16576 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-05-24 13:50:17 -04:00
|
|
|
|
* vm.c, eval_intern.h (PASS_PASSED_BLOCK):
set a VM_FRAME_FLAG_PASSED flag to skip this frame when
searching ruby-level-cfp.
* eval.c, eval_intern.h, proc.c: fix to check cfp. if there is
no valid ruby-level-cfp, cause RuntimeError exception.
[ruby-dev:34128]
* vm_core.h, vm_evalbody.c, vm.c, vm_dump.c, vm_insnhelper.c,
insns.def: rename FRAME_MAGIC_* to VM_FRAME_MAGIC_*.
* KNOWNBUGS.rb, bootstraptest/test*.rb: move solved bugs.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@17084 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-06-10 17:46:43 -04:00
|
|
|
PASS_PASSED_BLOCK_TH(th);
|
2012-08-02 07:08:44 -04:00
|
|
|
result = rb_vm_call(th, data->recv, data->id, argc, argv, data->me, data->defined_class);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
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>.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* class Square
|
|
|
|
* def area
|
|
|
|
* @side * @side
|
|
|
|
* end
|
|
|
|
* def initialize(side)
|
|
|
|
* @side = side
|
|
|
|
* end
|
|
|
|
* end
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* area_un = Square.instance_method(:area)
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* s = Square.new(12)
|
|
|
|
* area = area_un.bind(s)
|
|
|
|
* area.call #=> 144
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* umeth.bind(obj) -> method
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* class A
|
|
|
|
* def test
|
|
|
|
* puts "In test, class = #{self.class}"
|
|
|
|
* end
|
|
|
|
* end
|
|
|
|
* class B < A
|
|
|
|
* end
|
|
|
|
* class C < B
|
|
|
|
* end
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* <em>produces:</em>
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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
|
2007-02-05 13:31:08 -05:00
|
|
|
umethod_bind(VALUE method, VALUE recv)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
|
|
|
struct METHOD *data, *bound;
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
|
2009-09-22 16:04:59 -04:00
|
|
|
|
|
|
|
if (data->rclass != CLASS_OF(recv) && !rb_obj_is_kind_of(recv, data->rclass)) {
|
2007-11-21 20:17:52 -05:00
|
|
|
if (FL_TEST(data->rclass, FL_SINGLETON)) {
|
2007-02-02 10:21:41 -05:00
|
|
|
rb_raise(rb_eTypeError,
|
|
|
|
"singleton method called for a different object");
|
|
|
|
}
|
2009-09-22 16:04:59 -04:00
|
|
|
else {
|
2007-02-02 10:21:41 -05:00
|
|
|
rb_raise(rb_eTypeError, "bind argument must be an instance of %s",
|
2007-11-21 20:17:52 -05:00
|
|
|
rb_class2name(data->rclass));
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
method = TypedData_Make_Struct(rb_cMethod, struct METHOD, &method_data_type, bound);
|
2007-02-02 10:21:41 -05:00
|
|
|
*bound = *data;
|
2011-07-25 10:29:28 -04:00
|
|
|
bound->me = ALLOC(rb_method_entry_t);
|
|
|
|
*bound->me = *data->me;
|
|
|
|
if (bound->me->def) bound->me->def->alias_count++;
|
2007-02-02 10:21:41 -05:00
|
|
|
bound->recv = recv;
|
2007-11-21 20:17:52 -05:00
|
|
|
bound->rclass = CLASS_OF(recv);
|
2011-07-25 11:17:56 -04:00
|
|
|
data->ume = ALLOC(struct unlinked_method_entry_list_entry);
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
return method;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-07-15 10:59:41 -04:00
|
|
|
rb_method_entry_arity(const rb_method_entry_t *me)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
2009-08-27 22:45:41 -04:00
|
|
|
const rb_method_definition_t *def = me->def;
|
|
|
|
if (!def) return 0;
|
|
|
|
switch (def->type) {
|
2012-10-18 01:22:13 -04:00
|
|
|
case VM_METHOD_TYPE_CFUNC_FRAMELESS:
|
2009-07-15 10:59:41 -04:00
|
|
|
case VM_METHOD_TYPE_CFUNC:
|
2009-08-27 22:45:41 -04:00
|
|
|
if (def->body.cfunc.argc < 0)
|
2007-02-02 10:21:41 -05:00
|
|
|
return -1;
|
2009-08-27 22:45:41 -04:00
|
|
|
return check_argc(def->body.cfunc.argc);
|
2009-07-15 10:59:41 -04:00
|
|
|
case VM_METHOD_TYPE_ZSUPER:
|
2007-02-02 10:21:41 -05:00
|
|
|
return -1;
|
2009-07-15 10:59:41 -04:00
|
|
|
case VM_METHOD_TYPE_ATTRSET:
|
2007-02-02 10:21:41 -05:00
|
|
|
return 1;
|
2009-07-15 10:59:41 -04:00
|
|
|
case VM_METHOD_TYPE_IVAR:
|
2007-02-02 10:21:41 -05:00
|
|
|
return 0;
|
2009-07-15 10:59:41 -04:00
|
|
|
case VM_METHOD_TYPE_BMETHOD:
|
2009-08-27 22:45:41 -04:00
|
|
|
return rb_proc_arity(def->body.proc);
|
2009-07-15 10:59:41 -04:00
|
|
|
case VM_METHOD_TYPE_ISEQ: {
|
2009-08-27 22:45:41 -04:00
|
|
|
rb_iseq_t *iseq = def->body.iseq;
|
2009-08-27 20:45:27 -04:00
|
|
|
if (iseq->arg_rest == -1 && iseq->arg_opts == 0) {
|
|
|
|
return iseq->argc;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return -(iseq->argc + 1 + iseq->arg_post_len);
|
|
|
|
}
|
2009-07-15 10:59:41 -04:00
|
|
|
}
|
2009-07-28 14:14:11 -04:00
|
|
|
case VM_METHOD_TYPE_UNDEF:
|
|
|
|
case VM_METHOD_TYPE_NOTIMPLEMENTED:
|
|
|
|
return 0;
|
2009-09-27 23:09:16 -04:00
|
|
|
case VM_METHOD_TYPE_MISSING:
|
|
|
|
return -1;
|
2009-07-28 06:41:11 -04:00
|
|
|
case VM_METHOD_TYPE_OPTIMIZED: {
|
2009-08-27 22:45:41 -04:00
|
|
|
switch (def->body.optimize_type) {
|
2009-08-27 20:45:27 -04:00
|
|
|
case OPTIMIZED_METHOD_TYPE_SEND:
|
|
|
|
return -1;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2009-07-28 06:41:11 -04:00
|
|
|
}
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
2009-08-27 22:45:41 -04:00
|
|
|
rb_bug("rb_method_entry_arity: invalid method entry type (%d)", def->type);
|
2012-04-13 19:45:37 -04:00
|
|
|
|
|
|
|
UNREACHABLE;
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth.arity -> fixnum
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* 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
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* "cat".method(:size).arity #=> 0
|
|
|
|
* "cat".method(:replace).arity #=> 1
|
|
|
|
* "cat".method(:squeeze).arity #=> -1
|
|
|
|
* "cat".method(:count).arity #=> -1
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2007-02-05 13:31:08 -05:00
|
|
|
method_arity_m(VALUE method)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
|
|
|
int n = method_arity(method);
|
|
|
|
return INT2FIX(n);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-02-05 13:31:08 -05:00
|
|
|
method_arity(VALUE method)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
|
|
|
struct METHOD *data;
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
|
2011-07-25 10:29:28 -04:00
|
|
|
return rb_method_entry_arity(data->me);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2007-02-05 13:31:08 -05:00
|
|
|
rb_mod_method_arity(VALUE mod, ID id)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
2012-08-02 07:08:44 -04:00
|
|
|
rb_method_entry_t *me = rb_method_entry(mod, id, 0);
|
2009-07-15 10:59:41 -04:00
|
|
|
return rb_method_entry_arity(me);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2007-02-05 13:31:08 -05:00
|
|
|
rb_obj_method_arity(VALUE obj, ID id)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
|
|
|
return rb_mod_method_arity(CLASS_OF(obj), id);
|
|
|
|
}
|
|
|
|
|
2010-03-22 07:44:01 -04:00
|
|
|
static inline rb_method_definition_t *
|
|
|
|
method_get_def(VALUE method)
|
2008-09-26 09:47:01 -04:00
|
|
|
{
|
|
|
|
struct METHOD *data;
|
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
|
2011-07-25 10:29:28 -04:00
|
|
|
return data->me->def;
|
2010-03-22 07:44:01 -04:00
|
|
|
}
|
2009-07-15 10:59:41 -04:00
|
|
|
|
2010-03-22 07:44:01 -04:00
|
|
|
static rb_iseq_t *
|
|
|
|
method_get_iseq(rb_method_definition_t *def)
|
|
|
|
{
|
2009-08-27 22:45:41 -04:00
|
|
|
switch (def->type) {
|
2009-07-15 10:59:41 -04:00
|
|
|
case VM_METHOD_TYPE_BMETHOD:
|
2009-08-27 22:45:41 -04:00
|
|
|
return get_proc_iseq(def->body.proc, 0);
|
2009-07-15 10:59:41 -04:00
|
|
|
case VM_METHOD_TYPE_ISEQ:
|
2009-08-27 22:45:41 -04:00
|
|
|
return def->body.iseq;
|
2008-09-26 09:47:01 -04:00
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-22 07:44:01 -04:00
|
|
|
rb_iseq_t *
|
|
|
|
rb_method_get_iseq(VALUE method)
|
|
|
|
{
|
|
|
|
return method_get_iseq(method_get_def(method));
|
|
|
|
}
|
|
|
|
|
2008-09-26 09:47:01 -04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth.source_location -> [String, Fixnum]
|
2008-09-26 09:47:01 -04:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* Returns the Ruby source filename and line number containing this method
|
|
|
|
* or nil if this method was not defined in Ruby (i.e. native)
|
2008-09-26 09:47:01 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_method_location(VALUE method)
|
|
|
|
{
|
2010-03-22 07:44:01 -04:00
|
|
|
rb_method_definition_t *def = method_get_def(method);
|
|
|
|
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));
|
2008-09-26 09:47:01 -04:00
|
|
|
}
|
|
|
|
|
2008-11-27 23:19:37 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth.parameters -> array
|
2008-11-27 23:19:37 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* Returns the parameter information of this method.
|
2008-11-27 23:19:37 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
rb_method_parameters(VALUE method)
|
|
|
|
{
|
2009-07-15 10:59:41 -04:00
|
|
|
rb_iseq_t *iseq = rb_method_get_iseq(method);
|
2008-11-27 23:19:37 -05:00
|
|
|
if (!iseq) {
|
|
|
|
return unnamed_parameters(method_arity(method));
|
|
|
|
}
|
2008-12-04 23:05:48 -05:00
|
|
|
return rb_iseq_parameters(iseq, 0);
|
2008-11-27 23:19:37 -05:00
|
|
|
}
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth.to_s -> string
|
|
|
|
* meth.inspect -> string
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
2011-05-27 09:55:43 -04:00
|
|
|
* Returns the name of the underlying method.
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
|
|
|
* "cat".method(:count).inspect #=> "#<Method: String#count>"
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
method_inspect(VALUE method)
|
|
|
|
{
|
|
|
|
struct METHOD *data;
|
|
|
|
VALUE str;
|
|
|
|
const char *s;
|
2008-05-31 05:28:20 -04:00
|
|
|
const char *sharp = "#";
|
2007-02-02 10:21:41 -05:00
|
|
|
|
2009-07-08 04:13:41 -04:00
|
|
|
TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
|
2007-02-02 10:21:41 -05:00
|
|
|
str = rb_str_buf_new2("#<");
|
|
|
|
s = rb_obj_classname(method);
|
|
|
|
rb_str_buf_cat2(str, s);
|
|
|
|
rb_str_buf_cat2(str, ": ");
|
|
|
|
|
2011-07-25 10:29:28 -04:00
|
|
|
if (FL_TEST(data->me->klass, FL_SINGLETON)) {
|
|
|
|
VALUE v = rb_ivar_get(data->me->klass, attached);
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
if (data->recv == Qundef) {
|
2011-07-25 10:29:28 -04:00
|
|
|
rb_str_buf_append(str, rb_inspect(data->me->klass));
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
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 {
|
2007-11-21 20:17:52 -05:00
|
|
|
rb_str_buf_cat2(str, rb_class2name(data->rclass));
|
2011-07-25 10:29:28 -04:00
|
|
|
if (data->rclass != data->me->klass) {
|
2007-02-02 10:21:41 -05:00
|
|
|
rb_str_buf_cat2(str, "(");
|
2011-07-25 10:29:28 -04:00
|
|
|
rb_str_buf_cat2(str, rb_class2name(data->me->klass));
|
2007-02-02 10:21:41 -05:00
|
|
|
rb_str_buf_cat2(str, ")");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rb_str_buf_cat2(str, sharp);
|
2011-07-25 10:29:28 -04:00
|
|
|
rb_str_append(str, rb_id2str(data->me->def->original_id));
|
|
|
|
if (data->me->def->type == VM_METHOD_TYPE_NOTIMPLEMENTED) {
|
2009-04-16 10:17:14 -04:00
|
|
|
rb_str_buf_cat2(str, " (not-implemented)");
|
|
|
|
}
|
2007-02-02 10:21:41 -05:00
|
|
|
rb_str_buf_cat2(str, ">");
|
|
|
|
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
mproc(VALUE method)
|
|
|
|
{
|
|
|
|
return rb_funcall(Qnil, rb_intern("proc"), 0);
|
|
|
|
}
|
|
|
|
|
2007-06-25 15:06:00 -04:00
|
|
|
static VALUE
|
|
|
|
mlambda(VALUE method)
|
|
|
|
{
|
|
|
|
return rb_funcall(Qnil, rb_intern("lambda"), 0);
|
|
|
|
}
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
static VALUE
|
|
|
|
bmcall(VALUE args, VALUE method)
|
|
|
|
{
|
|
|
|
volatile VALUE a;
|
2009-03-14 05:18:09 -04:00
|
|
|
VALUE ret;
|
|
|
|
int argc;
|
2007-06-25 15:06:00 -04:00
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
if (CLASS_OF(args) != rb_cArray) {
|
|
|
|
args = rb_ary_new3(1, args);
|
2009-03-14 05:18:09 -04:00
|
|
|
argc = 1;
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
2009-03-14 05:18:09 -04:00
|
|
|
else {
|
2009-03-14 05:19:55 -04:00
|
|
|
argc = check_argc(RARRAY_LEN(args));
|
2009-03-14 05:18:09 -04:00
|
|
|
}
|
2009-03-14 13:09:33 -04:00
|
|
|
ret = rb_method_call(argc, RARRAY_PTR(args), method);
|
|
|
|
RB_GC_GUARD(a) = args;
|
2009-03-14 05:18:09 -04:00
|
|
|
return ret;
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_proc_new(
|
|
|
|
VALUE (*func)(ANYARGS), /* VALUE yieldarg[, VALUE procarg] */
|
|
|
|
VALUE val)
|
|
|
|
{
|
2007-12-23 23:55:37 -05:00
|
|
|
VALUE procval = rb_iterate(mproc, 0, func, val);
|
2007-02-02 10:21:41 -05:00
|
|
|
return procval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* meth.to_proc -> prc
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* Returns a <code>Proc</code> object corresponding to this method.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
method_proc(VALUE method)
|
|
|
|
{
|
2007-08-19 00:02:21 -04:00
|
|
|
VALUE procval;
|
|
|
|
rb_proc_t *proc;
|
2007-02-02 10:21:41 -05:00
|
|
|
/*
|
|
|
|
* class Method
|
|
|
|
* def to_proc
|
|
|
|
* proc{|*args|
|
|
|
|
* self.call(*args)
|
|
|
|
* }
|
|
|
|
* end
|
|
|
|
* end
|
|
|
|
*/
|
2007-12-23 23:55:37 -05:00
|
|
|
procval = rb_iterate(mlambda, 0, bmcall, method);
|
2007-08-19 00:02:21 -04:00
|
|
|
GetProcPtr(procval, proc);
|
|
|
|
proc->is_from_method = 1;
|
|
|
|
return procval;
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call_seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* local_jump_error.exit_value -> obj
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
|
|
|
* Returns the exit value associated with this +LocalJumpError+.
|
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
localjump_xvalue(VALUE exc)
|
|
|
|
{
|
|
|
|
return rb_iv_get(exc, "@exit_value");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* local_jump_error.reason -> symbol
|
2007-02-02 10:21:41 -05:00
|
|
|
*
|
|
|
|
* 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");
|
|
|
|
}
|
|
|
|
|
2007-12-20 03:20:02 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* prc.binding -> binding
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-12-20 03:20:02 -05:00
|
|
|
* 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.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-12-20 03:20:02 -05:00
|
|
|
* def fred(param)
|
|
|
|
* proc {}
|
|
|
|
* end
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-12-20 03:20:02 -05:00
|
|
|
* b = fred(99)
|
|
|
|
* eval("param", b.binding) #=> 99
|
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
proc_binding(VALUE self)
|
|
|
|
{
|
|
|
|
rb_proc_t *proc;
|
2009-09-21 04:12:12 -04:00
|
|
|
VALUE bindval;
|
2007-12-20 03:20:02 -05:00
|
|
|
rb_binding_t *bind;
|
|
|
|
|
|
|
|
GetProcPtr(self, proc);
|
2012-05-23 03:13:21 -04:00
|
|
|
if (RB_TYPE_P((VALUE)proc->block.iseq, T_NODE)) {
|
2009-09-21 04:12:12 -04:00
|
|
|
if (!IS_METHOD_PROC_NODE((NODE *)proc->block.iseq)) {
|
|
|
|
rb_raise(rb_eArgError, "Can't create Binding from C level Proc");
|
|
|
|
}
|
2007-12-20 03:20:02 -05:00
|
|
|
}
|
|
|
|
|
2009-09-21 04:12:12 -04:00
|
|
|
bindval = binding_alloc(rb_cBinding);
|
|
|
|
GetBindingPtr(bindval, bind);
|
2007-12-20 03:20:02 -05:00
|
|
|
bind->env = proc->envval;
|
2010-05-16 04:18:49 -04:00
|
|
|
if (RUBY_VM_NORMAL_ISEQ_P(proc->block.iseq)) {
|
2012-06-03 22:49:37 -04:00
|
|
|
bind->path = proc->block.iseq->location.path;
|
|
|
|
bind->first_lineno = rb_iseq_first_lineno(proc->block.iseq);
|
2010-05-16 04:18:49 -04:00
|
|
|
}
|
|
|
|
else {
|
2012-06-03 22:49:37 -04:00
|
|
|
bind->path = Qnil;
|
|
|
|
bind->first_lineno = 0;
|
2010-05-16 04:18:49 -04:00
|
|
|
}
|
2007-12-20 03:20:02 -05:00
|
|
|
return bindval;
|
|
|
|
}
|
2007-02-02 10:21:41 -05:00
|
|
|
|
2008-06-10 12:33:51 -04:00
|
|
|
static VALUE curry(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc);
|
2008-02-13 07:51:31 -05:00
|
|
|
|
|
|
|
static VALUE
|
|
|
|
make_curry_proc(VALUE proc, VALUE passed, VALUE arity)
|
|
|
|
{
|
2008-10-09 01:47:04 -04:00
|
|
|
VALUE args = rb_ary_new3(3, proc, passed, arity);
|
2009-07-05 20:31:55 -04:00
|
|
|
rb_proc_t *procp;
|
|
|
|
int is_lambda;
|
|
|
|
|
|
|
|
GetProcPtr(proc, procp);
|
|
|
|
is_lambda = procp->is_lambda;
|
2008-02-13 07:51:31 -05:00
|
|
|
rb_ary_freeze(passed);
|
|
|
|
rb_ary_freeze(args);
|
2009-07-05 20:31:55 -04:00
|
|
|
proc = rb_proc_new(curry, args);
|
|
|
|
GetProcPtr(proc, procp);
|
|
|
|
procp->is_lambda = is_lambda;
|
|
|
|
return proc;
|
2008-02-13 07:51:31 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2008-06-10 12:33:51 -04:00
|
|
|
curry(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc)
|
2008-02-13 07:51:31 -05:00
|
|
|
{
|
|
|
|
VALUE proc, passed, arity;
|
|
|
|
proc = RARRAY_PTR(args)[0];
|
|
|
|
passed = RARRAY_PTR(args)[1];
|
|
|
|
arity = RARRAY_PTR(args)[2];
|
|
|
|
|
|
|
|
passed = rb_ary_plus(passed, rb_ary_new4(argc, argv));
|
|
|
|
rb_ary_freeze(passed);
|
2008-06-10 12:33:51 -04:00
|
|
|
|
2009-07-05 20:31:55 -04:00
|
|
|
if (RARRAY_LEN(passed) < FIX2INT(arity)) {
|
2008-06-10 12:33:51 -04:00
|
|
|
if (!NIL_P(passed_proc)) {
|
2008-06-09 11:52:51 -04:00
|
|
|
rb_warn("given block not used");
|
|
|
|
}
|
2008-02-13 07:51:31 -05:00
|
|
|
arity = make_curry_proc(proc, passed, arity);
|
|
|
|
return arity;
|
|
|
|
}
|
2008-06-10 12:33:51 -04:00
|
|
|
else {
|
2009-03-14 05:18:09 -04:00
|
|
|
return rb_proc_call_with_block(proc, check_argc(RARRAY_LEN(passed)),
|
|
|
|
RARRAY_PTR(passed), passed_proc);
|
2008-06-10 12:33:51 -04:00
|
|
|
}
|
2008-02-13 07:51:31 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* prc.curry -> a_proc
|
|
|
|
* prc.curry(arity) -> a_proc
|
2008-02-13 07:51:31 -05:00
|
|
|
*
|
|
|
|
* 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
|
* eval.c (make_exception, rb_obj_extend): Fix error messages in case of wrong
number of arguments
* file.c (rb_f_test, rb_file_s_umask): ditto
* numeric.c (int_chr, num_step): ditto
* process.c (rb_f_sleep): ditto
* re.c (rb_reg_initialize_m): ditto
* signal.c (rb_f_kill, sig_trap): ditto
* string.c (rb_str_aref_m, rb_str_aset_m, rb_str_count, rb_str_delete_bang,
rb_str_slice_bang, rb_str_sub_bang, str_gsub): ditto
* proc.c (curry): rdoc fix
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@27558 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-04-29 22:40:57 -04:00
|
|
|
* 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)
|
2008-02-13 07:51:31 -05:00
|
|
|
*
|
|
|
|
* 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
|
* eval.c (make_exception, rb_obj_extend): Fix error messages in case of wrong
number of arguments
* file.c (rb_f_test, rb_file_s_umask): ditto
* numeric.c (int_chr, num_step): ditto
* process.c (rb_f_sleep): ditto
* re.c (rb_reg_initialize_m): ditto
* signal.c (rb_f_kill, sig_trap): ditto
* string.c (rb_str_aref_m, rb_str_aset_m, rb_str_count, rb_str_delete_bang,
rb_str_slice_bang, rb_str_sub_bang, str_gsub): ditto
* proc.c (curry): rdoc fix
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@27558 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2010-04-29 22:40:57 -04:00
|
|
|
* p b.curry(1) #=> wrong number of arguments (1 for 3)
|
2008-02-13 07:51:31 -05:00
|
|
|
*
|
|
|
|
* b = proc { :foo }
|
|
|
|
* p b.curry[] #=> :foo
|
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
proc_curry(int argc, VALUE *argv, VALUE self)
|
|
|
|
{
|
2009-03-14 04:59:12 -04:00
|
|
|
int sarity, marity = rb_proc_arity(self);
|
2008-02-13 07:51:31 -05:00
|
|
|
VALUE arity, opt = Qfalse;
|
|
|
|
|
|
|
|
if (marity < 0) {
|
|
|
|
marity = -marity - 1;
|
|
|
|
opt = Qtrue;
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_scan_args(argc, argv, "01", &arity);
|
|
|
|
if (NIL_P(arity)) {
|
|
|
|
arity = INT2FIX(marity);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
sarity = FIX2INT(arity);
|
2009-10-24 12:53:11 -04:00
|
|
|
if (rb_proc_lambda_p(self) && (sarity < marity || (sarity > marity && !opt))) {
|
2008-02-13 07:51:31 -05:00
|
|
|
rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", sarity, marity);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return make_curry_proc(self, rb_ary_new(), arity);
|
|
|
|
}
|
|
|
|
|
2010-05-08 00:50:09 -04:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2007-02-02 10:21:41 -05:00
|
|
|
/*
|
|
|
|
* <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.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* def gen_times(factor)
|
|
|
|
* return Proc.new {|n| n*factor }
|
|
|
|
* end
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* times3 = gen_times(3)
|
|
|
|
* times5 = gen_times(5)
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* times3.call(12) #=> 36
|
|
|
|
* times5.call(5) #=> 25
|
|
|
|
* times3.call(times5.call(4)) #=> 60
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
2007-02-05 13:31:08 -05:00
|
|
|
Init_Proc(void)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
|
|
|
/* Proc */
|
|
|
|
rb_cProc = rb_define_class("Proc", rb_cObject);
|
|
|
|
rb_undef_alloc_func(rb_cProc);
|
2007-12-05 02:18:52 -05:00
|
|
|
rb_define_singleton_method(rb_cProc, "new", rb_proc_s_new, -1);
|
2009-07-15 10:59:41 -04:00
|
|
|
|
|
|
|
#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
|
2007-02-02 10:21:41 -05:00
|
|
|
rb_define_method(rb_cProc, "call", proc_call, -1);
|
|
|
|
rb_define_method(rb_cProc, "[]", proc_call, -1);
|
2008-09-06 10:58:11 -04:00
|
|
|
rb_define_method(rb_cProc, "===", proc_call, -1);
|
2007-12-20 02:07:35 -05:00
|
|
|
rb_define_method(rb_cProc, "yield", proc_call, -1);
|
2009-07-15 10:59:41 -04:00
|
|
|
#endif
|
2007-02-02 10:21:41 -05:00
|
|
|
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);
|
2012-08-15 07:50:01 -04:00
|
|
|
rb_define_alias(rb_cProc, "inspect", "to_s");
|
2009-10-24 12:53:11 -04:00
|
|
|
rb_define_method(rb_cProc, "lambda?", rb_proc_lambda_p, 0);
|
2007-12-20 03:20:02 -05:00
|
|
|
rb_define_method(rb_cProc, "binding", proc_binding, 0);
|
2008-02-13 07:51:31 -05:00
|
|
|
rb_define_method(rb_cProc, "curry", proc_curry, -1);
|
2008-09-26 09:47:01 -04:00
|
|
|
rb_define_method(rb_cProc, "source_location", rb_proc_location, 0);
|
2008-11-27 23:19:37 -05:00
|
|
|
rb_define_method(rb_cProc, "parameters", rb_proc_parameters, 0);
|
2007-02-02 10:21:41 -05:00
|
|
|
|
2007-02-05 13:31:08 -05:00
|
|
|
/* Exceptions */
|
2007-02-02 10:21:41 -05:00
|
|
|
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);
|
2008-07-02 18:02:58 -04:00
|
|
|
sysstack_error = rb_exc_new3(rb_eSysStackError,
|
|
|
|
rb_obj_freeze(rb_str_new2("stack level too deep")));
|
2007-02-02 10:21:41 -05:00
|
|
|
OBJ_TAINT(sysstack_error);
|
|
|
|
|
|
|
|
/* utility functions */
|
|
|
|
rb_define_global_function("proc", rb_block_proc, 0);
|
|
|
|
rb_define_global_function("lambda", proc_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, "[]", 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, "owner", method_owner, 0);
|
|
|
|
rb_define_method(rb_cMethod, "unbind", method_unbind, 0);
|
2008-09-26 09:47:01 -04:00
|
|
|
rb_define_method(rb_cMethod, "source_location", rb_method_location, 0);
|
2008-11-27 23:19:37 -05:00
|
|
|
rb_define_method(rb_cMethod, "parameters", rb_method_parameters, 0);
|
2007-02-02 10:21:41 -05:00
|
|
|
rb_define_method(rb_mKernel, "method", rb_obj_method, 1);
|
2007-12-17 18:01:50 -05:00
|
|
|
rb_define_method(rb_mKernel, "public_method", rb_obj_public_method, 1);
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
/* 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, "owner", method_owner, 0);
|
|
|
|
rb_define_method(rb_cUnboundMethod, "bind", umethod_bind, 1);
|
2008-09-26 09:47:01 -04:00
|
|
|
rb_define_method(rb_cUnboundMethod, "source_location", rb_method_location, 0);
|
2008-11-27 23:19:37 -05:00
|
|
|
rb_define_method(rb_cUnboundMethod, "parameters", rb_method_parameters, 0);
|
2007-02-02 10:21:41 -05:00
|
|
|
|
|
|
|
/* Module#*_method */
|
2007-12-17 18:01:50 -05:00
|
|
|
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);
|
2007-06-02 03:47:20 -04:00
|
|
|
rb_define_private_method(rb_cModule, "define_method", rb_mod_define_method, -1);
|
2007-08-30 01:06:52 -04:00
|
|
|
|
|
|
|
/* Kernel */
|
|
|
|
rb_define_method(rb_mKernel, "define_singleton_method", rb_obj_define_method, -1);
|
2012-11-01 19:24:33 -04:00
|
|
|
|
|
|
|
rb_define_singleton_method(rb_vm_top_self(), "define_method", top_define_method, -1);
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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>.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* These binding objects can be passed as the second argument of the
|
|
|
|
* <code>Kernel#eval</code> method, establishing an environment for the
|
|
|
|
* evaluation.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* class Demo
|
|
|
|
* def initialize(n)
|
|
|
|
* @secret = n
|
|
|
|
* end
|
2011-03-07 03:44:45 -05:00
|
|
|
* def get_binding
|
2007-02-02 10:21:41 -05:00
|
|
|
* return binding()
|
|
|
|
* end
|
|
|
|
* end
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* k1 = Demo.new(99)
|
2011-03-07 03:44:45 -05:00
|
|
|
* b1 = k1.get_binding
|
2007-02-02 10:21:41 -05:00
|
|
|
* k2 = Demo.new(-3)
|
2011-03-07 03:44:45 -05:00
|
|
|
* b2 = k2.get_binding
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* eval("@secret", b1) #=> 99
|
|
|
|
* eval("@secret", b2) #=> -3
|
|
|
|
* eval("@secret") #=> nil
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
* Binding objects have no class-specific methods.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2007-02-02 10:21:41 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
2007-02-05 13:31:08 -05:00
|
|
|
Init_Binding(void)
|
2007-02-02 10:21:41 -05:00
|
|
|
{
|
2007-02-05 13:31:08 -05:00
|
|
|
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);
|
2007-02-05 13:50:35 -05:00
|
|
|
rb_define_method(rb_cBinding, "eval", bind_eval, -1);
|
2007-02-05 13:31:08 -05:00
|
|
|
rb_define_global_function("binding", rb_f_binding, 0);
|
2011-07-23 11:05:03 -04:00
|
|
|
attached = rb_intern("__attached__");
|
2007-02-02 10:21:41 -05:00
|
|
|
}
|
|
|
|
|