diff options
-rw-r--r-- | ChangeLog | 30 | ||||
-rw-r--r-- | common.mk | 4 | ||||
-rw-r--r-- | compile.c | 2 | ||||
-rw-r--r-- | eval.c | 7 | ||||
-rw-r--r-- | inits.c | 4 | ||||
-rw-r--r-- | intern.h | 1 | ||||
-rw-r--r-- | iseq.c | 32 | ||||
-rw-r--r-- | proc.c (renamed from eval_proc.c) | 2764 | ||||
-rw-r--r-- | version.h | 6 | ||||
-rw-r--r-- | vm.c | 8 | ||||
-rw-r--r-- | yarvcore.c | 464 | ||||
-rw-r--r-- | yarvcore.h | 14 |
12 files changed, 1650 insertions, 1686 deletions
@@ -1,3 +1,33 @@ +Wed Jan 17 17:31:28 2007 Koichi Sasada <ko1@atdot.net> + + * some refactoring around yarvcore and proc. + + * eval_proc.c: renamed to proc.c. + + * common.mk: ditto. + + * yarvcore.h, yarvcore.c: rename or remove some global variables + removed: mYarvCore, mYarvInsns + renamed: cYarvISeq -> rb_cISeq, + cYarvProc -> rb_cProc, cYarvBinding -> rb_cBinding + ::YarvCore module is removed and ::YarvCore::VM class becomes ::VM. + And change/remove some functions which added with YARV. + + * compile.c: ditto. + + * eval.c: ditto. + + * iseq.c: ditto. + + * vm.c: ditto. + + * inits.c: rename Init_yarvcore to Init_vm. + + * yarvcore.c, proc.c: move some functions and initialization + from yarvcore.c to proc.c. + + * intern.h, proc.c: add global function rb_binding_new(void). + Tue Jan 16 17:49:29 2007 Koichi Sasada <ko1@atdot.net> * vm.c (eval_search_super_klass): rename to search_super_klass() and @@ -31,7 +31,7 @@ OBJS = array.$(OBJEXT) \ euc_jp.$(OBJEXT) \ eval.$(OBJEXT) \ eval_load.$(OBJEXT) \ - eval_proc.$(OBJEXT) \ + proc.$(OBJEXT) \ eval_thread.$(OBJEXT) \ file.$(OBJEXT) \ gc.$(OBJEXT) \ @@ -408,7 +408,7 @@ eval_thread.$(OBJEXT): {$(VPATH)}eval_thread.c {$(VPATH)}eval_intern.h \ {$(VPATH)}defines.h {$(VPATH)}intern.h {$(VPATH)}missing.h \ {$(VPATH)}node.h {$(VPATH)}util.h \ {$(VPATH)}rubysig.h {$(VPATH)}st.h {$(VPATH)}dln.h {$(VPATH)}yarv.h -eval_proc.$(OBJEXT): {$(VPATH)}eval_proc.c {$(VPATH)}eval_intern.h \ +proc.$(OBJEXT): {$(VPATH)}proc.c {$(VPATH)}eval_intern.h \ {$(VPATH)}ruby.h config.h {$(VPATH)}yarvcore.h \ {$(VPATH)}defines.h {$(VPATH)}intern.h {$(VPATH)}missing.h \ {$(VPATH)}node.h {$(VPATH)}util.h \ @@ -4829,7 +4829,7 @@ iseq_build_body(yarv_iseq_t *iseq, LINK_ANCHOR *anchor, argv[j] = iseq_load(0, op, iseq->self, Qnil); } - else if (CLASS_OF(op) == cYarvISeq) { + else if (CLASS_OF(op) == rb_cISeq) { argv[j] = op; } else { @@ -18,7 +18,7 @@ VALUE rb_cProc; VALUE rb_cBinding; VALUE proc_invoke(VALUE, VALUE, VALUE, VALUE); -VALUE rb_f_binding(VALUE); +VALUE rb_binding_new(); VALUE rb_f_block_given_p(void); @@ -660,7 +660,7 @@ call_trace_func(rb_event_t event, NODE *node, VALUE self, ID id, VALUE klass) srcfile, INT2FIX(ruby_sourceline), id ? ID2SYM(id) : Qnil, - self ? rb_f_binding(self) : Qnil, + self ? rb_binding_new() : Qnil, klass ? klass : Qnil), Qundef, 0); } if (raised) @@ -1934,7 +1934,8 @@ eval(VALUE self, VALUE src, VALUE scope, char *file, int line) VALUE iseqval; if (scope != Qnil) { - if (CLASS_OF(scope) == cYarvBinding) { + + if (CLASS_OF(scope) == rb_cBinding) { GetBindingPtr(scope, bind); envval = bind->env; stored_cref_stack = bind->cref_stack; @@ -46,8 +46,8 @@ void Init_Struct _((void)); void Init_Time _((void)); void Init_var_tables _((void)); void Init_version _((void)); -void Init_yarvcore _((void)); void Init_jump _((void)); +void Init_vm _((void)); void @@ -86,6 +86,6 @@ rb_call_inits() Init_GC(); Init_marshal(); Init_Enumerator(); - Init_yarvcore(); + Init_vm(); Init_version(); } @@ -246,6 +246,7 @@ VALUE rb_f_lambda(void); VALUE rb_proc_new(VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE); VALUE rb_proc_call(VALUE, VALUE); int rb_proc_arity(VALUE); +VALUE rb_binding_new(void); VALUE rb_obj_method(VALUE, VALUE); VALUE rb_method_call(int, VALUE*, VALUE); int rb_mod_method_arity(VALUE, ID); @@ -20,6 +20,8 @@ // #define MARK_FREE_DEBUG 1 #include "gc.h" +VALUE rb_cISeq; + static void compile_data_free(struct iseq_compile_data *compile_data) { @@ -262,7 +264,7 @@ yarv_iseq_new_with_bopt_and_opt(NODE *node, VALUE name, VALUE file_name, const yarv_compile_option_t *option) { yarv_iseq_t *iseq; - VALUE self = iseq_alloc(cYarvISeq); + VALUE self = iseq_alloc(rb_cISeq); GetISeqPtr(self, iseq); iseq->self = self; @@ -300,7 +302,7 @@ VALUE iseq_build_from_ary(yarv_iseq_t *iseq, VALUE line, VALUE iseq_load(VALUE self, VALUE data, VALUE parent, VALUE opt) { - VALUE iseqval = iseq_alloc(cYarvISeq); + VALUE iseqval = iseq_alloc(rb_cISeq); VALUE magic, version1, version2, format_type, misc; VALUE name, filename, line; @@ -569,7 +571,7 @@ insn_operand_intern(yarv_iseq_t *iseq, op = ID2SYM(op); case TS_VALUE: /* VALUE */ ret = rb_inspect(op); - if (CLASS_OF(op) == cYarvISeq) { + if (CLASS_OF(op) == rb_cISeq) { rb_ary_push(child, op); } break; @@ -1328,18 +1330,18 @@ void Init_ISeq(void) { /* declare YARVCore::InstructionSequence */ - cYarvISeq = rb_define_class_under(mYarvCore, "InstructionSequence", rb_cObject); - rb_define_alloc_func(cYarvISeq, iseq_alloc); - rb_define_method(cYarvISeq, "inspect", iseq_inspect, 0); - rb_define_method(cYarvISeq, "disasm", iseq_disasm, 0); - rb_define_method(cYarvISeq, "to_a", iseq_to_a, 0); - rb_define_method(cYarvISeq, "eval", iseq_eval, 0); - - rb_define_singleton_method(cYarvISeq, "load", iseq_s_load, -1); - rb_define_singleton_method(cYarvISeq, "compile", iseq_s_compile, -1); - rb_define_singleton_method(cYarvISeq, "new", iseq_s_compile, -1); - rb_define_singleton_method(cYarvISeq, "compile_file", iseq_s_compile_file, -1); - rb_define_singleton_method(cYarvISeq, "compile_option=", + rb_cISeq = rb_define_class_under(rb_cVM, "InstructionSequence", rb_cObject); + rb_define_alloc_func(rb_cISeq, iseq_alloc); + rb_define_method(rb_cISeq, "inspect", iseq_inspect, 0); + rb_define_method(rb_cISeq, "disasm", iseq_disasm, 0); + rb_define_method(rb_cISeq, "to_a", iseq_to_a, 0); + rb_define_method(rb_cISeq, "eval", iseq_eval, 0); + + rb_define_singleton_method(rb_cISeq, "load", iseq_s_load, -1); + rb_define_singleton_method(rb_cISeq, "compile", iseq_s_compile, -1); + rb_define_singleton_method(rb_cISeq, "new", iseq_s_compile, -1); + rb_define_singleton_method(rb_cISeq, "compile_file", iseq_s_compile_file, -1); + rb_define_singleton_method(rb_cISeq, "compile_option=", iseq_s_compile_option_set, 1); } @@ -1,1207 +1,1557 @@ -/* - Proc, Method, Binding from eval.c - */ - -#include "eval_intern.h" - -struct METHOD { - VALUE klass, rklass; - VALUE recv; - ID id, oid; - NODE *body; -}; - -VALUE rb_cUnboundMethod; -VALUE rb_cMethod; - -static VALUE bmcall(VALUE, VALUE); -static int method_arity(VALUE); -static VALUE rb_obj_is_method(VALUE m); - -/* - * MISSING: documentation - */ - -/* - * MISSING: documentation - */ - -/* - * call-seq: - * binding -> a_binding - * - * Returns a +Binding+ object, describing the variable and - * method bindings at the point of call. This object can be used when - * calling +eval+ to execute the evaluated command in this - * environment. Also see the description of class +Binding+. - * - * def getBinding(param) - * return binding - * end - * b = getBinding("hello") - * eval("param", b) #=> "hello" - */ - -VALUE yarv_binding_alloc(VALUE klass); - -VALUE -rb_f_binding(VALUE self) -{ - yarv_thread_t *th = GET_THREAD(); - yarv_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp); - VALUE bindval = yarv_binding_alloc(cYarvBinding); - yarv_binding_t *bind; - - GetBindingPtr(bindval, bind); - bind->env = th_make_env_object(th, cfp); - bind->cref_stack = ruby_cref(); - return bindval; -} - -/* - * call-seq: - * binding.eval(string [, filename [,lineno]]) => obj - * - * Evaluates the Ruby expression(s) in <em>string</em>, in the - * <em>binding</em>'s context. If the optional <em>filename</em> and - * <em>lineno</em> parameters are present, they will be used when - * reporting syntax errors. - * - * def getBinding(param) - * return binding - * end - * b = getBinding("hello") - * b.eval("param") #=> "hello" - */ - -static VALUE -bind_eval(int argc, VALUE *argv, VALUE bind) -{ - UNSUPPORTED(bind_eval); - return Qnil; -} - -#define PROC_TSHIFT (FL_USHIFT+1) -#define PROC_TMASK (FL_USER1|FL_USER2|FL_USER3) -#define PROC_TMAX (PROC_TMASK >> PROC_TSHIFT) -#define PROC_NOSAFE FL_USER4 - -#define SAFE_LEVEL_MAX PROC_TMASK - -static VALUE -proc_alloc(VALUE klass, int is_lambda) -{ - VALUE procval = Qnil; - yarv_thread_t *th = GET_THREAD(); - yarv_control_frame_t *cfp = th->cfp; - yarv_block_t *block; - - if ((GC_GUARDED_PTR_REF(cfp->lfp[0])) != 0 && - !YARV_CLASS_SPECIAL_P(cfp->lfp[0])) { - block = GC_GUARDED_PTR_REF(cfp->lfp[0]); - } - else { - cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp); - if ((GC_GUARDED_PTR_REF(cfp->lfp[0])) != 0 && - !YARV_CLASS_SPECIAL_P(cfp->lfp[0])) { - block = GC_GUARDED_PTR_REF(cfp->lfp[0]); - - if (is_lambda) { - rb_warn("tried to create Proc object without a block"); - } - } - else { - rb_raise(rb_eArgError, - "tried to create Proc object without a block"); - } - } - - cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp); - procval = th_make_proc(th, cfp, block); - - if (is_lambda) { - yarv_proc_t *proc; - GetProcPtr(procval, proc); - proc->is_lambda = Qtrue; - } - return procval; -} - -/* - * call-seq: - * Proc.new {|...| block } => a_proc - * Proc.new => a_proc - * - * Creates a new <code>Proc</code> object, bound to the current - * context. <code>Proc::new</code> may be called without a block only - * within a method with an attached block, in which case that block is - * converted to the <code>Proc</code> object. - * - * def proc_from - * Proc.new - * end - * proc = proc_from { "hello" } - * proc.call #=> "hello" - */ - -VALUE -rb_proc_s_new(VALUE klass) -{ - return proc_alloc(klass, Qfalse); -} - -/* - * call-seq: - * proc { |...| block } => a_proc - * - * Equivalent to <code>Proc.new</code>. - */ - -VALUE -rb_block_proc(void) -{ - return proc_alloc(rb_cProc, Qfalse); -} - -VALUE -rb_block_lambda(void) -{ - return proc_alloc(rb_cProc, Qtrue); -} - -VALUE -rb_f_lambda(void) -{ - rb_warn("rb_f_lambda() is deprecated; use rb_block_proc() instead"); - return proc_alloc(rb_cProc, Qtrue); -} - -/* - * call-seq: - * lambda { |...| block } => a_proc - * - * Equivalent to <code>Proc.new</code>, except the resulting Proc objects - * check the number of parameters passed when called. - */ - -static VALUE -proc_lambda(void) -{ - return proc_alloc(rb_cProc, Qtrue); -} - -VALUE -proc_invoke(VALUE self, VALUE args, VALUE alt_self, VALUE alt_klass) -{ - yarv_proc_t *proc; - GetProcPtr(self, proc); - - /* ignore self and klass */ - return th_invoke_proc(GET_THREAD(), proc, proc->block.self, - RARRAY_LEN(args), RARRAY_PTR(args)); -} - -/* CHECKME: are the argument checking semantics correct? */ - -/* - * call-seq: - * prc.call(params,...) => obj - * prc[params,...] => obj - * - * Invokes the block, setting the block's parameters to the values in - * <i>params</i> using something close to method calling semantics. - * Generates a warning if multiple values are passed to a proc that - * expects just one (previously this silently converted the parameters - * to an array). - * - * For procs created using <code>Kernel.proc</code>, generates an - * error if the wrong number of parameters - * are passed to a proc with multiple parameters. For procs created using - * <code>Proc.new</code>, extra parameters are silently discarded. - * - * Returns the value of the last expression evaluated in the block. See - * also <code>Proc#yield</code>. - * - * a_proc = Proc.new {|a, *b| b.collect {|i| i*a }} - * a_proc.call(9, 1, 2, 3) #=> [9, 18, 27] - * a_proc[9, 1, 2, 3] #=> [9, 18, 27] - * a_proc = Proc.new {|a,b| a} - * a_proc.call(1,2,3) - * - * <em>produces:</em> - * - * prog.rb:5: wrong number of arguments (3 for 2) (ArgumentError) - * from prog.rb:4:in `call' - * from prog.rb:5 - */ - -VALUE -rb_proc_call(VALUE proc, VALUE args) -{ - return proc_invoke(proc, args, Qundef, 0); -} - -/* - * call-seq: - * prc.arity -> fixnum - * - * 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. - * - * Proc.new {}.arity #=> 0 - * Proc.new {||}.arity #=> 0 - * Proc.new {|a|}.arity #=> 1 - * Proc.new {|a,b|}.arity #=> 2 - * Proc.new {|a,b,c|}.arity #=> 3 - * Proc.new {|*a|}.arity #=> -1 - * Proc.new {|a,*b|}.arity #=> -2 - */ - -/* - * call-seq: - * prc == other_proc => true or false - * - * Return <code>true</code> if <i>prc</i> is the same object as - * <i>other_proc</i>, or if they are both procs with the same body. - */ - - -/* - * call-seq: - * prc.hash => integer - * - * Return hash value corresponding to proc body. - */ - - -/* - * call-seq: - * prc.to_s => string - * - * Shows the unique identifier for this proc, along with - * an indication of where the proc was defined. - */ - -/* - * call-seq: - * prc.to_proc -> prc - * - * Part of the protocol for converting objects to <code>Proc</code> - * objects. Instances of class <code>Proc</code> simply return - * themselves. - */ - -/* - * call-seq: - * prc.binding => binding - * - * Returns the binding associated with <i>prc</i>. Note that - * <code>Kernel#eval</code> accepts either a <code>Proc</code> or a - * <code>Binding</code> object as its second parameter. - * - * def fred(param) - * proc {} - * end - * - * b = fred(99) - * eval("param", b.binding) #=> 99 - * eval("param", b) #=> 99 - */ - -void -bm_mark(struct METHOD *data) -{ - rb_gc_mark(data->rklass); - rb_gc_mark(data->klass); - rb_gc_mark(data->recv); - rb_gc_mark((VALUE)data->body); -} - -NODE *rb_get_method_body(VALUE klass, ID id, ID *idp); - -static VALUE -mnew(VALUE klass, VALUE obj, ID id, VALUE mklass) -{ - VALUE method; - NODE *body; - struct METHOD *data; - VALUE rklass = klass; - ID oid = id; - - again: - if ((body = rb_get_method_body(klass, id, 0)) == 0) { - print_undef(rklass, oid); - } - - klass = body->nd_clss; - body = body->nd_body; - - if (nd_type(body) == NODE_ZSUPER) { - klass = RCLASS(klass)->super; - goto again; - } - - while (rklass != klass && - (FL_TEST(rklass, FL_SINGLETON) || TYPE(rklass) == T_ICLASS)) { - rklass = RCLASS(rklass)->super; - } - if (TYPE(klass) == T_ICLASS) - klass = RBASIC(klass)->klass; - method = Data_Make_Struct(mklass, struct METHOD, bm_mark, -1, data); - data->klass = klass; - data->recv = obj; - - data->id = id; - data->body = body; - data->rklass = rklass; - data->oid = oid; - 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. - * - * class Thing - * def square(n) - * n*n - * end - * end - * thing = Thing.new - * meth = thing.method(:square) - * - * meth.call(9) #=> 81 - * [ 1, 2, 3 ].collect(&meth) #=> [1, 4, 9] - * - */ - -/* - * call-seq: - * meth == other_meth => true or false - * - * Two method objects are equal if that are bound to the same - * object and contain the same body. - */ - - -static VALUE -method_eq(method, other) - VALUE method, other; -{ - struct METHOD *m1, *m2; - - if (TYPE(other) != T_DATA - || RDATA(other)->dmark != (RUBY_DATA_FUNC) bm_mark) - return Qfalse; - if (CLASS_OF(method) != CLASS_OF(other)) - return Qfalse; - - Data_Get_Struct(method, struct METHOD, m1); - Data_Get_Struct(other, struct METHOD, m2); - - if (m1->klass != m2->klass || m1->rklass != m2->rklass || - m1->recv != m2->recv || m1->body != m2->body) - return Qfalse; - - return Qtrue; -} - -/* - * call-seq: - * meth.hash => integer - * - * Return a hash value corresponding to the method object. - */ - -static VALUE -method_hash(method) - VALUE method; -{ - struct METHOD *m; - long hash; - - Data_Get_Struct(method, struct METHOD, m); - hash = (long)m->klass; - hash ^= (long)m->rklass; - hash ^= (long)m->recv; - hash ^= (long)m->body; - - return INT2FIX(hash); -} - -/* - * call-seq: - * meth.unbind => unbound_method - * - * Dissociates <i>meth</i> from it's current receiver. The resulting - * <code>UnboundMethod</code> can subsequently be bound to a new object - * of the same class (see <code>UnboundMethod</code>). - */ - -static VALUE -method_unbind(obj) - VALUE obj; -{ - VALUE method; - struct METHOD *orig, *data; - - Data_Get_Struct(obj, struct METHOD, orig); - method = - Data_Make_Struct(rb_cUnboundMethod, struct METHOD, bm_mark, free, - data); - data->klass = orig->klass; - data->recv = Qundef; - data->id = orig->id; - data->body = orig->body; - data->rklass = orig->rklass; - data->oid = orig->oid; - OBJ_INFECT(method, obj); - - return method; -} - -/* - * call-seq: - * obj.method(sym) => method - * - * Looks up the named method as a receiver in <i>obj</i>, returning a - * <code>Method</code> object (or raising <code>NameError</code>). The - * <code>Method</code> object acts as a closure in <i>obj</i>'s object - * instance, so instance variables and the value of <code>self</code> - * remain available. - * - * class Demo - * def initialize(n) - * @iv = n - * end - * def hello() - * "Hello, @iv = #{@iv}" - * end - * end - * - * k = Demo.new(99) - * m = k.method(:hello) - * m.call #=> "Hello, @iv = 99" - * - * l = Demo.new('Fred') - * m = l.method("hello") - * m.call #=> "Hello, @iv = Fred" - */ - -VALUE -rb_obj_method(obj, vid) - VALUE obj; - VALUE vid; -{ - return mnew(CLASS_OF(obj), obj, rb_to_id(vid), rb_cMethod); -} - -/* - * call-seq: - * mod.instance_method(symbol) => unbound_method - * - * Returns an +UnboundMethod+ representing the given - * instance method in _mod_. - * - * class Interpreter - * def do_a() print "there, "; end - * def do_d() print "Hello "; end - * def do_e() print "!\n"; end - * def do_v() print "Dave"; end - * Dispatcher = { - * ?a => instance_method(:do_a), - * ?d => instance_method(:do_d), - * ?e => instance_method(:do_e), - * ?v => instance_method(:do_v) - * } - * def interpret(string) - * string.each_byte {|b| Dispatcher[b].bind(self).call } - * end - * end - * - * - * interpreter = Interpreter.new - * interpreter.interpret('dave') - * - * <em>produces:</em> - * - * Hello there, Dave! - */ - -static VALUE -rb_mod_method(mod, vid) - VALUE mod; - VALUE vid; -{ - return mnew(mod, Qundef, rb_to_id(vid), rb_cUnboundMethod); -} - -/* - * call-seq: - * define_method(symbol, method) => new_method - * define_method(symbol) { block } => proc - * - * Defines an instance method in the receiver. The _method_ - * parameter can be a +Proc+ or +Method+ object. - * If a block is specified, it is used as the method body. This block - * is evaluated using <code>instance_eval</code>, a point that is - * tricky to demonstrate because <code>define_method</code> is private. - * (This is why we resort to the +send+ hack in this example.) - * - * class A - * def fred - * puts "In Fred" - * end - * def create_method(name, &block) - * self.class.send(:define_method, name, &block) - * end - * define_method(:wilma) { puts "Charge it!" } - * end - * class B < A - * define_method(:barney, instance_method(:fred)) - * end - * a = B.new - * a.barney - * a.wilma - * a.create_method(:betty) { p self } - * a.betty - * - * <em>produces:</em> - * - * In Fred - * Charge it! - * #<B:0x401b39e8> - */ - -VALUE yarv_proc_dup(VALUE self); - -static VALUE -rb_mod_define_method(int argc, VALUE *argv, VALUE mod) -{ - ID id; - VALUE body; - NODE *node; - int noex = NOEX_PUBLIC; - - if (argc == 1) { - id = rb_to_id(argv[0]); - body = rb_block_lambda(); - } - else if (argc == 2) { - id = rb_to_id(argv[0]); - body = argv[1]; - if (!rb_obj_is_method(body) && !yarv_obj_is_proc(body)) { - rb_raise(rb_eTypeError, - "wrong argument type %s (expected Proc/Method)", - rb_obj_classname(body)); - } - } - else { - rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); - } - - if (RDATA(body)->dmark == (RUBY_DATA_FUNC) bm_mark) { - struct METHOD *method = (struct METHOD *)DATA_PTR(body); - VALUE rklass = method->rklass; - if (rklass != mod) { - if (FL_TEST(rklass, FL_SINGLETON)) { - rb_raise(rb_eTypeError, - "can't bind singleton method to a different class"); - } - if (!RTEST(rb_class_inherited_p(mod, rklass))) { - rb_raise(rb_eTypeError, - "bind argument must be a subclass of %s", - rb_class2name(rklass)); - } - } - node = method->body; - } - else if (yarv_obj_is_proc(body)) { - yarv_proc_t *proc; - body = yarv_proc_dup(body); - GetProcPtr(body, proc); - if (BUILTIN_TYPE(proc->block.iseq) != T_NODE) { - proc->block.iseq->defined_method_id = id; - proc->block.iseq->klass = mod; - proc->is_lambda = Qtrue; - } - node = NEW_BMETHOD(body); - } - else { - /* type error */ - rb_raise(rb_eTypeError, "wrong argument type (expected Proc/Method)"); - } - - /* TODO: visibility */ - - rb_add_method(mod, id, node, noex); - return body; -} - - -/* - * MISSING: documentation - */ - -static VALUE -method_clone(self) - VALUE self; -{ - VALUE clone; - struct METHOD *orig, *data; - - Data_Get_Struct(self, struct METHOD, orig); - clone = - Data_Make_Struct(CLASS_OF(self), struct METHOD, bm_mark, free, data); - CLONESETUP(clone, self); - *data = *orig; - - return clone; -} - -/* - * call-seq: - * meth.call(args, ...) => obj - * meth[args, ...] => obj - * - * Invokes the <i>meth</i> with the specified arguments, returning the - * method's return value. - * - * m = 12.method("+") - * m.call(3) #=> 15 - * m.call(20) #=> 32 - */ - -VALUE -rb_method_call(int argc, VALUE *argv, VALUE method) -{ - VALUE result = Qnil; /* OK */ - struct METHOD *data; - int state; - volatile int safe = -1; - - Data_Get_Struct(method, struct METHOD, data); - if (data->recv == Qundef) { - rb_raise(rb_eTypeError, "can't call unbound method; bind first"); - } - PUSH_TAG(PROT_NONE); - if (OBJ_TAINTED(method)) { - safe = rb_safe_level(); - if (rb_safe_level() < 4) { - rb_set_safe_level_force(4); - } - } - if ((state = EXEC_TAG()) == 0) { - PASS_PASSED_BLOCK(); - result = th_call0(GET_THREAD(), - data->klass, data->recv, data->id, data->oid, - argc, argv, data->body, 0); - } - POP_TAG(); - if (safe >= 0) - rb_set_safe_level_force(safe); - if (state) - JUMP_TAG(state); - return result; -} - -/********************************************************************** - * - * Document-class: UnboundMethod - * - * Ruby supports two forms of objectified methods. Class - * <code>Method</code> is used to represent methods that are associated - * with a particular object: these method objects are bound to that - * object. Bound method objects for an object can be created using - * <code>Object#method</code>. - * - * Ruby also supports unbound methods; methods objects that are not - * associated with a particular object. These can be created either by - * calling <code>Module#instance_method</code> or by calling - * <code>unbind</code> on a bound method object. The result of both of - * these is an <code>UnboundMethod</code> object. - * - * Unbound methods can only be called after they are bound to an - * object. That object must be be a kind_of? the method's original - * class. - * - * class Square - * def area - * @side * @side - * end - * def initialize(side) - * @side = side - * end - * end - * - * area_un = Square.instance_method(:area) - * - * s = Square.new(12) - * area = area_un.bind(s) - * area.call #=> 144 - * - * Unbound methods are a reference to the method at the time it was - * objectified: subsequent changes to the underlying class will not - * affect the unbound method. - * - * class Test - * def test - * :original - * end - * end - * um = Test.instance_method(:test) - * class Test - * def test - * :modified - * end - * end - * t = Test.new - * t.test #=> :modified - * um.bind(t).call #=> :original - * - */ - -/* - * call-seq: - * umeth.bind(obj) -> method - * - * Bind <i>umeth</i> to <i>obj</i>. If <code>Klass</code> was the class - * from which <i>umeth</i> was obtained, - * <code>obj.kind_of?(Klass)</code> must be true. - * - * class A - * def test - * puts "In test, class = #{self.class}" - * end - * end - * class B < A - * end - * class C < B - * end - * - * - * um = B.instance_method(:test) - * bm = um.bind(C.new) - * bm.call - * bm = um.bind(B.new) - * bm.call - * bm = um.bind(A.new) - * bm.call - * - * <em>produces:</em> - * - * In test, class = C - * In test, class = B - * prog.rb:16:in `bind': bind argument must be an instance of B (TypeError) - * from prog.rb:16 - */ - -static VALUE -umethod_bind(method, recv) - VALUE method, recv; -{ - struct METHOD *data, *bound; - - Data_Get_Struct(method, struct METHOD, data); - if (data->rklass != CLASS_OF(recv)) { - if (FL_TEST(data->rklass, FL_SINGLETON)) { - rb_raise(rb_eTypeError, - "singleton method called for a different object"); - } - if (!rb_obj_is_kind_of(recv, data->rklass)) { - rb_raise(rb_eTypeError, "bind argument must be an instance of %s", - rb_class2name(data->rklass)); - } - } - - method = - Data_Make_Struct(rb_cMethod, struct METHOD, bm_mark, free, bound); - *bound = *data; - bound->recv = recv; - bound->rklass = CLASS_OF(recv); - - return method; -} - -int -rb_node_arity(NODE * body) -{ - int n; - - switch (nd_type(body)) { - case NODE_CFUNC: - if (body->nd_argc < 0) - return -1; - return body->nd_argc; - case NODE_ZSUPER: - return -1; - case NODE_ATTRSET: - return 1; - case NODE_IVAR: - return 0; - case NODE_BMETHOD: - return rb_proc_arity(body->nd_cval); - case NODE_SCOPE: - body = body->nd_next; /* skip NODE_SCOPE */ - if (nd_type(body) == NODE_BLOCK) - body = body->nd_head; - if (!body) - return 0; - n = body->nd_frml ? RARRAY_LEN(body->nd_frml) : 0; - if (body->nd_opt || body->nd_rest) - n = -n - 1; - return n; - case YARV_METHOD_NODE:{ - yarv_iseq_t *iseq; - GetISeqPtr((VALUE)body->nd_body, iseq); - if (iseq->arg_rest == 0 && iseq->arg_opts == 0) { - return iseq->argc; - } - else { - return -iseq->argc - 1; - } - } - default: - rb_raise(rb_eArgError, "invalid node 0x%x", nd_type(body)); - } -} - -/* - * call-seq: - * meth.arity => fixnum - * - * Returns an indication of the number of arguments accepted by a - * method. Returns a nonnegative integer for methods that take a fixed - * number of arguments. For Ruby methods that take a variable number of - * arguments, returns -n-1, where n is the number of required - * arguments. For methods written in C, returns -1 if the call takes a - * variable number of arguments. - * - * class C - * def one; end - * def two(a); end - * def three(*a); end - * def four(a, b); end - * def five(a, b, *c); end - * def six(a, b, *c, &d); end - * end - * c = C.new - * c.method(:one).arity #=> 0 - * c.method(:two).arity #=> 1 - * c.method(:three).arity #=> -1 - * c.method(:four).arity #=> 2 - * c.method(:five).arity #=> -3 - * c.method(:six).arity #=> -3 - * - * "cat".method(:size).arity #=> 0 - * "cat".method(:replace).arity #=> 1 - * "cat".method(:squeeze).arity #=> -1 - * "cat".method(:count).arity #=> -1 - */ - -static VALUE -method_arity_m(method) - VALUE method; -{ - int n = method_arity(method); - return INT2FIX(n); -} - -static int -method_arity(method) - VALUE method; -{ - struct METHOD *data; - - Data_Get_Struct(method, struct METHOD, data); - return rb_node_arity(data->body); -} - -int -rb_mod_method_arity(mod, id) - VALUE mod; - ID id; -{ - NODE *node = rb_method_node(mod, id); - return rb_node_arity(node); -} - -int -rb_obj_method_arity(obj, id) - VALUE obj; - ID id; -{ - return rb_mod_method_arity(CLASS_OF(obj), id); -} - -/* - * call-seq: - * meth.to_s => string - * meth.inspect => string - * - * Show the name of the underlying method. - * - * "cat".method(:count).inspect #=> "#<Method: String#count>" - */ - -static VALUE -method_inspect(VALUE method) -{ - struct METHOD *data; - VALUE str; - const char *s; - char *sharp = "#"; - - Data_Get_Struct(method, struct METHOD, data); - str = rb_str_buf_new2("#<"); - s = rb_obj_classname(method); - rb_str_buf_cat2(str, s); - rb_str_buf_cat2(str, ": "); - - if (FL_TEST(data->klass, FL_SINGLETON)) { - VALUE v = rb_iv_get(data->klass, "__attached__"); - - if (data->recv == Qundef) { - rb_str_buf_append(str, rb_inspect(data->klass)); - } - else if (data->recv == v) { - rb_str_buf_append(str, rb_inspect(v)); - sharp = "."; - } - else { - rb_str_buf_append(str, rb_inspect(data->recv)); - rb_str_buf_cat2(str, "("); - rb_str_buf_append(str, rb_inspect(v)); - rb_str_buf_cat2(str, ")"); - sharp = "."; - } - } - else { - rb_str_buf_cat2(str, rb_class2name(data->rklass)); - if (data->rklass != data->klass) { - rb_str_buf_cat2(str, "("); - rb_str_buf_cat2(str, rb_class2name(data->klass)); - rb_str_buf_cat2(str, ")"); - } - } - rb_str_buf_cat2(str, sharp); - rb_str_buf_cat2(str, rb_id2name(data->oid)); - rb_str_buf_cat2(str, ">"); - - return str; -} - -static VALUE -mproc(VALUE method) -{ - return rb_funcall(Qnil, rb_intern("proc"), 0); -} - -static VALUE -bmcall(VALUE args, VALUE method) -{ - volatile VALUE a; - if (CLASS_OF(args) != rb_cArray) { - args = rb_ary_new3(1, args); - } - - a = args; - return rb_method_call(RARRAY_LEN(a), RARRAY_PTR(a), method); -} - -VALUE -rb_proc_new( - VALUE (*func)(ANYARGS), /* VALUE yieldarg[, VALUE procarg] */ - VALUE val) -{ - yarv_proc_t *proc; - VALUE procval = rb_iterate((VALUE(*)(VALUE))mproc, 0, func, val); - GetProcPtr(procval, proc); - ((NODE*)proc->block.iseq)->u3.state = 1; - return procval; -} - -/* - * call-seq: - * meth.to_proc => prc - * - * Returns a <code>Proc</code> object corresponding to this method. - */ - -static VALUE -method_proc(VALUE method) -{ - VALUE proc; - /* - * class Method - * def to_proc - * proc{|*args| - * self.call(*args) - * } - * end - * end - */ - proc = rb_iterate((VALUE (*)(VALUE))mproc, 0, bmcall, method); - return proc; -} - -static VALUE -rb_obj_is_method(VALUE m) -{ - if (TYPE(m) == T_DATA && RDATA(m)->dmark == (RUBY_DATA_FUNC) bm_mark) { - return Qtrue; - } - return Qfalse; -} - -/* - * call_seq: - * local_jump_error.exit_value => obj - * - * Returns the exit value associated with this +LocalJumpError+. - */ -static VALUE -localjump_xvalue(VALUE exc) -{ - return rb_iv_get(exc, "@exit_value"); -} - -/* - * call-seq: - * local_jump_error.reason => symbol - * - * The reason this block was terminated: - * :break, :redo, :retry, :next, :return, or :noreason. - */ - -static VALUE -localjump_reason(VALUE exc) -{ - return rb_iv_get(exc, "@reason"); -} - - -/* - * <code>Proc</code> objects are blocks of code that have been bound to - * a set of local variables. Once bound, the code may be called in - * different contexts and still access those variables. - * - * def gen_times(factor) - * return Proc.new {|n| n*factor } - * end - * - * times3 = gen_times(3) - * times5 = gen_times(5) - * - * times3.call(12) #=> 36 - * times5.call(5) #=> 25 - * times3.call(times5.call(4)) #=> 60 - * - */ - -void -Init_Proc() -{ - 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); - - exception_error = rb_exc_new2(rb_eFatal, "exception reentered"); - rb_register_mark_object(exception_error); - - rb_eSysStackError = rb_define_class("SystemStackError", rb_eException); - sysstack_error = rb_exc_new2(rb_eSysStackError, "stack level too deep"); - OBJ_TAINT(sysstack_error); - rb_register_mark_object(sysstack_error); - - rb_define_global_function("proc", rb_block_proc, 0); - rb_define_global_function("lambda", proc_lambda, 0); - - 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, "unbind", method_unbind, 0); - rb_define_method(rb_mKernel, "method", rb_obj_method, 1); - - 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, "bind", umethod_bind, 1); - - rb_define_method(rb_cModule, "instance_method", rb_mod_method, 1); - rb_define_private_method(rb_cModule, "define_method", - rb_mod_define_method, -1); - -} - -/* - * Objects of class <code>Binding</code> encapsulate the execution - * context at some particular place in the code and retain this context - * for future use. The variables, methods, value of <code>self</code>, - * and possibly an iterator block that can be accessed in this context - * are all retained. Binding objects can be created using - * <code>Kernel#binding</code>, and are made available to the callback - * of <code>Kernel#set_trace_func</code>. - * - * These binding objects can be passed as the second argument of the - * <code>Kernel#eval</code> method, establishing an environment for the - * evaluation. - * - * class Demo - * def initialize(n) - * @secret = n - * end - * def getBinding - * return binding() - * end - * end - * - * k1 = Demo.new(99) - * b1 = k1.getBinding - * k2 = Demo.new(-3) - * b2 = k2.getBinding - * - * eval("@secret", b1) #=> 99 - * eval("@secret", b2) #=> -3 - * eval("@secret") #=> nil - * - * Binding objects have no class-specific methods. - * - */ - -void -Init_Binding() -{ - -} +/**********************************************************************
+
+ proc.c - Proc, Bindng, Env
+
+ $Author: ko1 $
+ $Date: $
+ created at: Wed Jan 17 12:13:14 2007
+
+ Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+#include "eval_intern.h"
+#include "gc.h"
+
+struct METHOD {
+ VALUE klass, rklass;
+ VALUE recv;
+ ID id, oid;
+ NODE *body;
+};
+
+VALUE rb_cUnboundMethod;
+VALUE rb_cMethod;
+VALUE rb_cBinding;
+VALUE rb_cProc;
+VALUE rb_cEnv;
+
+static VALUE bmcall(VALUE, VALUE);
+static int method_arity(VALUE);
+static VALUE rb_obj_is_method(VALUE m);
+
+/* Env */
+
+static void
+env_free(void *ptr)
+{
+ yarv_env_t *env;
+ FREE_REPORT_ENTER("env");
+ if (ptr) {
+ env = ptr;
+ FREE_UNLESS_NULL(env->env);
+ ruby_xfree(ptr);
+ }
+ FREE_REPORT_LEAVE("env");
+}
+
+static void
+env_mark(void *ptr)
+{
+ yarv_env_t *env;
+ MARK_REPORT_ENTER("env");
+ if (ptr) {
+ env = ptr;
+ if (env->env) {
+ /* TODO: should mark more restricted range */
+ GC_INFO("env->env\n");
+ rb_gc_mark_locations(env->env, env->env + env->env_size);
+ }
+ GC_INFO("env->prev_envval\n");
+ MARK_UNLESS_NULL(env->prev_envval);
+
+ if (env->block.iseq) {
+ if (BUILTIN_TYPE(env->block.iseq) == T_NODE) {
+ MARK_UNLESS_NULL((VALUE)env->block.iseq);
+ }
+ else {
+ MARK_UNLESS_NULL(env->block.iseq->self);
+ }
+ }
+ }
+ MARK_REPORT_LEAVE("env");
+}
+
+VALUE
+yarv_env_alloc(void)
+{
+ VALUE obj;
+ yarv_env_t *env;
+ obj = Data_Make_Struct(rb_cEnv, yarv_env_t, env_mark, env_free, env);
+ env->env = 0;
+ env->prev_envval = 0;
+ env->block.iseq = 0;
+ return obj;
+}
+
+/* Proc */
+
+static void
+proc_free(void *ptr)
+{
+ FREE_REPORT_ENTER("proc");
+ if (ptr) {
+ ruby_xfree(ptr);
+ }
+ FREE_REPORT_LEAVE("proc");
+}
+
+static void
+proc_mark(void *ptr)
+{
+ yarv_proc_t *proc;
+ MARK_REPORT_ENTER("proc");
+ if (ptr) {
+ proc = ptr;
+ MARK_UNLESS_NULL(proc->envval);
+ MARK_UNLESS_NULL(proc->blockprocval);
+ MARK_UNLESS_NULL((VALUE)proc->special_cref_stack);
+ if (proc->block.iseq && YARV_IFUNC_P(proc->block.iseq)) {
+ MARK_UNLESS_NULL((VALUE)(proc->block.iseq));
+ }
+ }
+ MARK_REPORT_LEAVE("proc");
+}
+
+static VALUE
+proc_alloc(VALUE klass)
+{
+ VALUE obj;
+ yarv_proc_t *proc;
+ obj = Data_Make_Struct(klass, yarv_proc_t, proc_mark, proc_free, proc);
+ MEMZERO(proc, yarv_proc_t, 1);
+ return obj;
+}
+
+VALUE
+yarv_proc_alloc(void)
+{
+ proc_alloc(rb_cProc);
+}
+
+VALUE
+yarv_obj_is_proc(VALUE proc)
+{
+ if (TYPE(proc) == T_DATA &&
+ RDATA(proc)->dfree == (RUBY_DATA_FUNC) proc_free) {
+ return Qtrue;
+ }
+ else {
+ return Qfalse;
+ }
+}
+
+static VALUE
+proc_dup(VALUE self)
+{
+ VALUE procval = proc_alloc(rb_cProc);
+ yarv_proc_t *src, *dst;
+ GetProcPtr(self, src);
+ GetProcPtr(procval, dst);
+
+ dst->block = src->block;
+ dst->envval = src->envval;
+ dst->safe_level = dst->safe_level;
+ dst->special_cref_stack = src->special_cref_stack;
+
+ return procval;
+}
+
+VALUE yarv_proc_dup(VALUE self)
+{
+ return proc_dup(self);
+}
+
+static VALUE
+proc_clone(VALUE self)
+{
+ VALUE procval = proc_dup(self);
+ CLONESETUP(procval, self);
+ return procval;
+}
+
+/* Binding */
+
+static void
+binding_free(void *ptr)
+{
+ yarv_binding_t *bind;
+ FREE_REPORT_ENTER("binding");
+ if (ptr) {
+ bind = ptr;
+ ruby_xfree(ptr);
+ }
+ FREE_REPORT_LEAVE("binding");
+}
+
+static void
+binding_mark(void *ptr)
+{
+ yarv_binding_t *bind;
+ MARK_REPORT_ENTER("binding");
+ if (ptr) {
+ bind = ptr;
+ MARK_UNLESS_NULL(bind->env);
+ MARK_UNLESS_NULL((VALUE)bind->cref_stack);
+ }
+ MARK_REPORT_LEAVE("binding");
+}
+
+static VALUE
+binding_alloc(VALUE klass)
+{
+ VALUE obj;
+ yarv_binding_t *bind;
+ obj = Data_Make_Struct(klass, yarv_binding_t,
+ binding_mark, binding_free, bind);
+ MEMZERO(bind, yarv_binding_t, 1);
+ return obj;
+}
+
+static VALUE
+binding_dup(VALUE self)
+{
+ VALUE bindval = binding_alloc(rb_cBinding);
+ yarv_binding_t *src, *dst;
+ GetBindingPtr(self, src);
+ GetBindingPtr(bindval, dst);
+ dst->env = src->env;
+ dst->cref_stack = src->cref_stack;
+ return bindval;
+}
+
+static VALUE
+binding_clone(VALUE self)
+{
+ VALUE bindval = binding_dup(self);
+ CLONESETUP(bindval, self);
+ return bindval;
+}
+
+VALUE
+rb_binding_new(void)
+{
+ yarv_thread_t *th = GET_THREAD();
+ yarv_control_frame_t *cfp = th_get_ruby_level_cfp(th, th->cfp);
+ VALUE bindval = binding_alloc(rb_cBinding);
+ yarv_binding_t *bind;
+
+ GetBindingPtr(bindval, bind);
+ bind->env = th_make_env_object(th, cfp);
+ bind->cref_stack = ruby_cref();
+ return bindval;
+}
+
+/*
+ * call-seq:
+ * binding -> a_binding
+ *
+ * Returns a +Binding+ object, describing the variable and
+ * method bindings at the point of call. This object can be used when
+ * calling +eval+ to execute the evaluated command in this
+ * environment. Also see the description of class +Binding+.
+ *
+ * def getBinding(param)
+ * return binding
+ * end
+ * b = getBinding("hello")
+ * eval("param", b) #=> "hello"
+ */
+
+static VALUE
+rb_f_binding(VALUE self)
+{
+ return rb_binding_new();
+}
+
+/*
+ * call-seq:
+ * binding.eval(string [, filename [,lineno]]) => obj
+ *
+ * Evaluates the Ruby expression(s) in <em>string</em>, in the
+ * <em>binding</em>'s context. If the optional <em>filename</em> and
+ * <em>lineno</em> parameters are present, they will be used when
+ * reporting syntax errors.
+ *
+ * def getBinding(param)
+ * return binding
+ * end
+ * b = getBinding("hello")
+ * b.eval("param") #=> "hello"
+ */
+
+static VALUE
+bind_eval(int argc, VALUE *argv, VALUE bind)
+{
+ UNSUPPORTED(bind_eval);
+ return Qnil;
+}
+
+#define PROC_TSHIFT (FL_USHIFT+1)
+#define PROC_TMASK (FL_USER1|FL_USER2|FL_USER3)
+#define PROC_TMAX (PROC_TMASK >> PROC_TSHIFT)
+#define PROC_NOSAFE FL_USER4
+
+#define SAFE_LEVEL_MAX PROC_TMASK
+
+static VALUE
+proc_new(VALUE klass, int is_lambda)
+{
+ VALUE procval = Qnil;
+ yarv_thread_t *th = GET_THREAD();
+ yarv_control_frame_t *cfp = th->cfp;
+ yarv_block_t *block;
+
+ if ((GC_GUARDED_PTR_REF(cfp->lfp[0])) != 0 &&
+ !YARV_CLASS_SPECIAL_P(cfp->lfp[0])) {
+ block = GC_GUARDED_PTR_REF(cfp->lfp[0]);
+ }
+ else {
+ cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp);
+ if ((GC_GUARDED_PTR_REF(cfp->lfp[0])) != 0 &&
+ !YARV_CLASS_SPECIAL_P(cfp->lfp[0])) {
+ block = GC_GUARDED_PTR_REF(cfp->lfp[0]);
+
+ if (is_lambda) {
+ rb_warn("tried to create Proc object without a block");
+ }
+ }
+ else {
+ rb_raise(rb_eArgError,
+ "tried to create Proc object without a block");
+ }
+ }
+
+ cfp = YARV_PREVIOUS_CONTROL_FRAME(cfp);
+ procval = th_make_proc(th, cfp, block);
+
+ if (is_lambda) {
+ yarv_proc_t *proc;
+ GetProcPtr(procval, proc);
+ proc->is_lambda = Qtrue;
+ }
+ return procval;
+}
+
+/*
+ * call-seq:
+ * Proc.new {|...| block } => a_proc
+ * Proc.new => a_proc
+ *
+ * Creates a new <code>Proc</code> object, bound to the current
+ * context. <code>Proc::new</code> may be called without a block only
+ * within a method with an attached block, in which case that block is
+ * converted to the <code>Proc</code> object.
+ *
+ * def proc_from
+ * Proc.new
+ * end
+ * proc = proc_from { "hello" }
+ * proc.call #=> "hello"
+ */
+
+static VALUE
+rb_proc_s_new(VALUE klass)
+{
+ return proc_new(klass, Qfalse);
+}
+
+/*
+ * call-seq:
+ * proc { |...| block } => a_proc
+ *
+ * Equivalent to <code>Proc.new</code>.
+ */
+
+VALUE
+rb_block_proc(void)
+{
+ return proc_new(rb_cProc, Qfalse);
+}
+
+VALUE
+rb_block_lambda(void)
+{
+ return proc_new(rb_cProc, Qtrue);
+}
+
+VALUE
+rb_f_lambda(void)
+{
+ rb_warn("rb_f_lambda() is deprecated; use rb_block_proc() instead");
+ return rb_block_lambda();
+}
+
+/*
+ * call-seq:
+ * lambda { |...| block } => a_proc
+ *
+ * Equivalent to <code>Proc.new</code>, except the resulting Proc objects
+ * check the number of parameters passed when called.
+ */
+
+static VALUE
+proc_lambda(void)
+{
+ return rb_block_lambda();
+}
+
+VALUE
+proc_invoke(VALUE self, VALUE args, VALUE alt_self, VALUE alt_klass)
+{
+ yarv_proc_t *proc;
+ GetProcPtr(self, proc);
+
+ /* ignore self and klass */
+ return th_invoke_proc(GET_THREAD(), proc, proc->block.self,
+ RARRAY_LEN(args), RARRAY_PTR(args));
+}
+
+/* CHECKME: are the argument checking semantics correct? */
+
+/*
+ * call-seq:
+ * prc.call(params,...) => obj
+ * prc[params,...] => obj
+ *
+ * Invokes the block, setting the block's parameters to the values in
+ * <i>params</i> using something close to method calling semantics.
+ * Generates a warning if multiple values are passed to a proc that
+ * expects just one (previously this silently converted the parameters
+ * to an array).
+ *
+ * For procs created using <code>Kernel.proc</code>, generates an
+ * error if the wrong number of parameters
+ * are passed to a proc with multiple parameters. For procs created using
+ * <code>Proc.new</code>, extra parameters are silently discarded.
+ *
+ * Returns the value of the last expression evaluated in the block. See
+ * also <code>Proc#yield</code>.
+ *
+ * a_proc = Proc.new {|a, *b| b.collect {|i| i*a }}
+ * a_proc.call(9, 1, 2, 3) #=> [9, 18, 27]
+ * a_proc[9, 1, 2, 3] #=> [9, 18, 27]
+ * a_proc = Proc.new {|a,b| a}
+ * a_proc.call(1,2,3)
+ *
+ * <em>produces:</em>
+ *
+ * prog.rb:5: wrong number of arguments (3 for 2) (ArgumentError)
+ * from prog.rb:4:in `call'
+ * from prog.rb:5
+ */
+
+static VALUE
+proc_call(int argc, VALUE *argv, VALUE procval)
+{
+ yarv_proc_t *proc;
+ GetProcPtr(procval, proc);
+ return th_invoke_proc(GET_THREAD(), proc, proc->block.self, argc, argv);
+}
+
+static VALUE
+proc_yield(int argc, VALUE *argv, VALUE procval)
+{
+ yarv_proc_t *proc;
+ GetProcPtr(procval, proc);
+ return th_invoke_proc(GET_THREAD(), proc, proc->block.self, argc, argv);
+}
+
+VALUE
+rb_proc_call(VALUE proc, VALUE args)
+{
+ return proc_invoke(proc, args, Qundef, 0);
+}
+
+/*
+ * call-seq:
+ * prc.arity -> fixnum
+ *
+ * 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.
+ *
+ * Proc.new {}.arity #=> 0
+ * Proc.new {||}.arity #=> 0
+ * Proc.new {|a|}.arity #=> 1
+ * Proc.new {|a,b|}.arity #=> 2
+ * Proc.new {|a,b,c|}.arity #=> 3
+ * Proc.new {|*a|}.arity #=> -1
+ * Proc.new {|a,*b|}.arity #=> -2
+ */
+
+static VALUE
+proc_arity(VALUE self)
+{
+ yarv_proc_t *proc;
+ yarv_iseq_t *iseq;
+ GetProcPtr(self, proc);
+ iseq = proc->block.iseq;
+ if (iseq && BUILTIN_TYPE(iseq) != T_NODE) {
+ if (iseq->arg_rest == 0 && iseq->arg_opts == 0) {
+ return INT2FIX(iseq->argc);
+ }
+ else {
+ return INT2FIX(-iseq->argc - 1);
+ }
+ }
+ else {
+ return INT2FIX(-1);
+ }
+}
+
+int
+rb_proc_arity(VALUE proc)
+{
+ return FIX2INT(proc_arity(proc));
+}
+
+/*
+ * call-seq:
+ * prc == other_proc => true or false
+ *
+ * Return <code>true</code> if <i>prc</i> is the same object as
+ * <i>other_proc</i>, or if they are both procs with the same body.
+ */
+
+static VALUE
+proc_eq(VALUE self, VALUE other)
+{
+ if (self == other) {
+ return Qtrue;
+ }
+ else {
+ if (TYPE(other) == T_DATA &&
+ RBASIC(other)->klass == rb_cProc &&
+ CLASS_OF(self) == CLASS_OF(other)) {
+ yarv_proc_t *p1, *p2;
+ GetProcPtr(self, p1);
+ GetProcPtr(other, p2);
+ if (p1->block.iseq == p2->block.iseq && p1->envval == p2->envval) {
+ return Qtrue;
+ }
+ }
+ }
+ return Qfalse;
+}
+
+/*
+ * call-seq:
+ * prc.hash => integer
+ *
+ * Return hash value corresponding to proc body.
+ */
+
+static VALUE
+proc_hash(VALUE self)
+{
+ int hash;
+ yarv_proc_t *proc;
+ GetProcPtr(self, proc);
+ hash = (long)proc->block.iseq;
+ hash ^= (long)proc->envval;
+ hash ^= (long)proc->block.lfp >> 16;
+ return INT2FIX(hash);
+}
+
+/*
+ * call-seq:
+ * prc.to_s => string
+ *
+ * Shows the unique identifier for this proc, along with
+ * an indication of where the proc was defined.
+ */
+
+static VALUE
+proc_to_s(VALUE self)
+{
+ VALUE str = 0;
+ yarv_proc_t *proc;
+ char *cname = rb_obj_classname(self);
+ yarv_iseq_t *iseq;
+
+ GetProcPtr(self, proc);
+ iseq = proc->block.iseq;
+
+ if (YARV_NORMAL_ISEQ_P(iseq)) {
+ int line_no = 0;
+
+ if (iseq->insn_info_tbl) {
+ line_no = iseq->insn_info_tbl[0].line_no;
+ }
+ str = rb_sprintf("#<%s:%lx@%s:%d>", cname, self,
+ RSTRING_PTR(iseq->file_name),
+ line_no);
+ }
+ else {
+ str = rb_sprintf("#<%s:%p>", cname, proc->block.iseq);
+ }
+
+ if (OBJ_TAINTED(self)) {
+ OBJ_TAINT(str);
+ }
+ return str;
+}
+
+/*
+ * call-seq:
+ * prc.to_proc -> prc
+ *
+ * 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;
+}
+
+/*
+ * call-seq:
+ * prc.binding => binding
+ *
+ * Returns the binding associated with <i>prc</i>. Note that
+ * <code>Kernel#eval</code> accepts either a <code>Proc</code> or a
+ * <code>Binding</code> object as its second parameter.
+ *
+ * def fred(param)
+ * proc {}
+ * end
+ *
+ * b = fred(99)
+ * eval("param", b.binding) #=> 99
+ * eval("param", b) #=> 99
+ */
+
+void
+bm_mark(struct METHOD *data)
+{
+ rb_gc_mark(data->rklass);
+ rb_gc_mark(data->klass);
+ rb_gc_mark(data->recv);
+ rb_gc_mark((VALUE)data->body);
+}
+
+NODE *rb_get_method_body(VALUE klass, ID id, ID *idp);
+
+static VALUE
+mnew(VALUE klass, VALUE obj, ID id, VALUE mklass)
+{
+ VALUE method;
+ NODE *body;
+ struct METHOD *data;
+ VALUE rklass = klass;
+ ID oid = id;
+
+ again:
+ if ((body = rb_get_method_body(klass, id, 0)) == 0) {
+ print_undef(rklass, oid);
+ }
+
+ klass = body->nd_clss;
+ body = body->nd_body;
+
+ if (nd_type(body) == NODE_ZSUPER) {
+ klass = RCLASS(klass)->super;
+ goto again;
+ }
+
+ while (rklass != klass &&
+ (FL_TEST(rklass, FL_SINGLETON) || TYPE(rklass) == T_ICLASS)) {
+ rklass = RCLASS(rklass)->super;
+ }
+ if (TYPE(klass) == T_ICLASS)
+ klass = RBASIC(klass)->klass;
+ method = Data_Make_Struct(mklass, struct METHOD, bm_mark, -1, data);
+ data->klass = klass;
+ data->recv = obj;
+
+ data->id = id;
+ data->body = body;
+ data->rklass = rklass;
+ data->oid = oid;
+ 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.
+ *
+ * class Thing
+ * def square(n)
+ * n*n
+ * end
+ * end
+ * thing = Thing.new
+ * meth = thing.method(:square)
+ *
+ * meth.call(9) #=> 81
+ * [ 1, 2, 3 ].collect(&meth) #=> [1, 4, 9]
+ *
+ */
+
+/*
+ * call-seq:
+ * meth == other_meth => true or false
+ *
+ * Two method objects are equal if that are bound to the same
+ * object and contain the same body.
+ */
+
+
+static VALUE
+method_eq(method, other)
+ VALUE method, other;
+{
+ struct METHOD *m1, *m2;
+
+ if (TYPE(other) != T_DATA
+ || RDATA(other)->dmark != (RUBY_DATA_FUNC) bm_mark)
+ return Qfalse;
+ if (CLASS_OF(method) != CLASS_OF(other))
+ return Qfalse;
+
+ Data_Get_Struct(method, struct METHOD, m1);
+ Data_Get_Struct(other, struct METHOD, m2);
+
+ if (m1->klass != m2->klass || m1->rklass != m2->rklass ||
+ m1->recv != m2->recv || m1->body != m2->body)
+ return Qfalse;
+
+ return Qtrue;
+}
+
+/*
+ * call-seq:
+ * meth.hash => integer
+ *
+ * Return a hash value corresponding to the method object.
+ */
+
+static VALUE
+method_hash(method)
+ VALUE method;
+{
+ struct METHOD *m;
+ long hash;
+
+ Data_Get_Struct(method, struct METHOD, m);
+ hash = (long)m->klass;
+ hash ^= (long)m->rklass;
+ hash ^= (long)m->recv;
+ hash ^= (long)m->body;
+
+ return INT2FIX(hash);
+}
+
+/*
+ * call-seq:
+ * meth.unbind => unbound_method
+ *
+ * Dissociates <i>meth</i> from it's current receiver. The resulting
+ * <code>UnboundMethod</code> can subsequently be bound to a new object
+ * of the same class (see <code>UnboundMethod</code>).
+ */
+
+static VALUE
+method_unbind(obj)
+ VALUE obj;
+{
+ VALUE method;
+ struct METHOD *orig, *data;
+
+ Data_Get_Struct(obj, struct METHOD, orig);
+ method =
+ Data_Make_Struct(rb_cUnboundMethod, struct METHOD, bm_mark, free,
+ data);
+ data->klass = orig->klass;
+ data->recv = Qundef;
+ data->id = orig->id;
+ data->body = orig->body;
+ data->rklass = orig->rklass;
+ data->oid = orig->oid;
+ OBJ_INFECT(method, obj);
+
+ return method;
+}
+
+/*
+ * call-seq:
+ * obj.method(sym) => method
+ *
+ * Looks up the named method as a receiver in <i>obj</i>, returning a
+ * <code>Method</code> object (or raising <code>NameError</code>). The
+ * <code>Method</code> object acts as a closure in <i>obj</i>'s object
+ * instance, so instance variables and the value of <code>self</code>
+ * remain available.
+ *
+ * class Demo
+ * def initialize(n)
+ * @iv = n
+ * end
+ * def hello()
+ * "Hello, @iv = #{@iv}"
+ * end
+ * end
+ *
+ * k = Demo.new(99)
+ * m = k.method(:hello)
+ * m.call #=> "Hello, @iv = 99"
+ *
+ * l = Demo.new('Fred')
+ * m = l.method("hello")
+ * m.call #=> "Hello, @iv = Fred"
+ */
+
+VALUE
+rb_obj_method(obj, vid)
+ VALUE obj;
+ VALUE vid;
+{
+ return mnew(CLASS_OF(obj), obj, rb_to_id(vid), rb_cMethod);
+}
+
+/*
+ * call-seq:
+ * mod.instance_method(symbol) => unbound_method
+ *
+ * Returns an +UnboundMethod+ representing the given
+ * instance method in _mod_.
+ *
+ * class Interpreter
+ * def do_a() print "there, "; end
+ * def do_d() print "Hello "; end
+ * def do_e() print "!\n"; end
+ * def do_v() print "Dave"; end
+ * Dispatcher = {
+ * ?a => instance_method(:do_a),
+ * ?d => instance_method(:do_d),
+ * ?e => instance_method(:do_e),
+ * ?v => instance_method(:do_v)
+ * }
+ * def interpret(string)
+ * string.each_byte {|b| Dispatcher[b].bind(self).call }
+ * end
+ * end
+ *
+ *
+ * interpreter = Interpreter.new
+ * interpreter.interpret('dave')
+ *
+ * <em>produces:</em>
+ *
+ * Hello there, Dave!
+ */
+
+static VALUE
+rb_mod_method(mod, vid)
+ VALUE mod;
+ VALUE vid;
+{
+ return mnew(mod, Qundef, rb_to_id(vid), rb_cUnboundMethod);
+}
+
+/*
+ * call-seq:
+ * define_method(symbol, method) => new_method
+ * define_method(symbol) { block } => proc
+ *
+ * Defines an instance method in the receiver. The _method_
+ * parameter can be a +Proc+ or +Method+ object.
+ * If a block is specified, it is used as the method body. This block
+ * is evaluated using <code>instance_eval</code>, a point that is
+ * tricky to demonstrate because <code>define_method</code> is private.
+ * (This is why we resort to the +send+ hack in this example.)
+ *
+ * class A
+ * def fred
+ * puts "In Fred"
+ * end
+ * def create_method(name, &block)
+ * self.class.send(:define_method, name, &block)
+ * end
+ * define_method(:wilma) { puts "Charge it!" }
+ * end
+ * class B < A
+ * define_method(:barney, instance_method(:fred))
+ * end
+ * a = B.new
+ * a.barney
+ * a.wilma
+ * a.create_method(:betty) { p self }
+ * a.betty
+ *
+ * <em>produces:</em>
+ *
+ * In Fred
+ * Charge it!
+ * #<B:0x401b39e8>
+ */
+
+VALUE yarv_proc_dup(VALUE self);
+
+static VALUE
+rb_mod_define_method(int argc, VALUE *argv, VALUE mod)
+{
+ ID id;
+ VALUE body;
+ NODE *node;
+ int noex = NOEX_PUBLIC;
+
+ if (argc == 1) {
+ id = rb_to_id(argv[0]);
+ body = rb_block_lambda();
+ }
+ else if (argc == 2) {
+ id = rb_to_id(argv[0]);
+ body = argv[1];
+ if (!rb_obj_is_method(body) && !yarv_obj_is_proc(body)) {
+ rb_raise(rb_eTypeError,
+ "wrong argument type %s (expected Proc/Method)",
+ rb_obj_classname(body));
+ }
+ }
+ else {
+ rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
+ }
+
+ if (RDATA(body)->dmark == (RUBY_DATA_FUNC) bm_mark) {
+ struct METHOD *method = (struct METHOD *)DATA_PTR(body);
+ VALUE rklass = method->rklass;
+ if (rklass != mod) {
+ if (FL_TEST(rklass, FL_SINGLETON)) {
+ rb_raise(rb_eTypeError,
+ "can't bind singleton method to a different class");
+ }
+ if (!RTEST(rb_class_inherited_p(mod, rklass))) {
+ rb_raise(rb_eTypeError,
+ "bind argument must be a subclass of %s",
+ rb_class2name(rklass));
+ }
+ }
+ node = method->body;
+ }
+ else if (yarv_obj_is_proc(body)) {
+ yarv_proc_t *proc;
+ body = yarv_proc_dup(body);
+ GetProcPtr(body, proc);
+ if (BUILTIN_TYPE(proc->block.iseq) != T_NODE) {
+ proc->block.iseq->defined_method_id = id;
+ proc->block.iseq->klass = mod;
+ proc->is_lambda = Qtrue;
+ }
+ node = NEW_BMETHOD(body);
+ }
+ else {
+ /* type error */
+ rb_raise(rb_eTypeError, "wrong argument type (expected Proc/Method)");
+ }
+
+ /* TODO: visibility */
+
+ rb_add_method(mod, id, node, noex);
+ return body;
+}
+
+
+/*
+ * MISSING: documentation
+ */
+
+static VALUE
+method_clone(self)
+ VALUE self;
+{
+ VALUE clone;
+ struct METHOD *orig, *data;
+
+ Data_Get_Struct(self, struct METHOD, orig);
+ clone =
+ Data_Make_Struct(CLASS_OF(self), struct METHOD, bm_mark, free, data);
+ CLONESETUP(clone, self);
+ *data = *orig;
+
+ return clone;
+}
+
+/*
+ * call-seq:
+ * meth.call(args, ...) => obj
+ * meth[args, ...] => obj
+ *
+ * Invokes the <i>meth</i> with the specified arguments, returning the
+ * method's return value.
+ *
+ * m = 12.method("+")
+ * m.call(3) #=> 15
+ * m.call(20) #=> 32
+ */
+
+VALUE
+rb_method_call(int argc, VALUE *argv, VALUE method)
+{
+ VALUE result = Qnil; /* OK */
+ struct METHOD *data;
+ int state;
+ volatile int safe = -1;
+
+ Data_Get_Struct(method, struct METHOD, data);
+ if (data->recv == Qundef) {
+ rb_raise(rb_eTypeError, "can't call unbound method; bind first");
+ }
+ PUSH_TAG(PROT_NONE);
+ if (OBJ_TAINTED(method)) {
+ safe = rb_safe_level();
+ if (rb_safe_level() < 4) {
+ rb_set_safe_level_force(4);
+ }
+ }
+ if ((state = EXEC_TAG()) == 0) {
+ PASS_PASSED_BLOCK();
+ result = th_call0(GET_THREAD(),
+ data->klass, data->recv, data->id, data->oid,
+ argc, argv, data->body, 0);
+ }
+ POP_TAG();
+ if (safe >= 0)
+ rb_set_safe_level_force(safe);
+ if (state)
+ JUMP_TAG(state);
+ return result;
+}
+
+/**********************************************************************
+ *
+ * Document-class: UnboundMethod
+ *
+ * Ruby supports two forms of objectified methods. Class
+ * <code>Method</code> is used to represent methods that are associated
+ * with a particular object: these method objects are bound to that
+ * object. Bound method objects for an object can be created using
+ * <code>Object#method</code>.
+ *
+ * Ruby also supports unbound methods; methods objects that are not
+ * associated with a particular object. These can be created either by
+ * calling <code>Module#instance_method</code> or by calling
+ * <code>unbind</code> on a bound method object. The result of both of
+ * these is an <code>UnboundMethod</code> object.
+ *
+ * Unbound methods can only be called after they are bound to an
+ * object. That object must be be a kind_of? the method's original
+ * class.
+ *
+ * class Square
+ * def area
+ * @side * @side
+ * end
+ * def initialize(side)
+ * @side = side
+ * end
+ * end
+ *
+ * area_un = Square.instance_method(:area)
+ *
+ * s = Square.new(12)
+ * area = area_un.bind(s)
+ * area.call #=> 144
+ *
+ * Unbound methods are a reference to the method at the time it was
+ * objectified: subsequent changes to the underlying class will not
+ * affect the unbound method.
+ *
+ * class Test
+ * def test
+ * :original
+ * end
+ * end
+ * um = Test.instance_method(:test)
+ * class Test
+ * def test
+ * :modified
+ * end
+ * end
+ * t = Test.new
+ * t.test #=> :modified
+ * um.bind(t).call #=> :original
+ *
+ */
+
+/*
+ * call-seq:
+ * umeth.bind(obj) -> method
+ *
+ * Bind <i>umeth</i> to <i>obj</i>. If <code>Klass</code> was the class
+ * from which <i>umeth</i> was obtained,
+ * <code>obj.kind_of?(Klass)</code> must be true.
+ *
+ * class A
+ * def test
+ * puts "In test, class = #{self.class}"
+ * end
+ * end
+ * class B < A
+ * end
+ * class C < B
+ * end
+ *
+ *
+ * um = B.instance_method(:test)
+ * bm = um.bind(C.new)
+ * bm.call
+ * bm = um.bind(B.new)
+ * bm.call
+ * bm = um.bind(A.new)
+ * bm.call
+ *
+ * <em>produces:</em>
+ *
+ * In test, class = C
+ * In test, class = B
+ * prog.rb:16:in `bind': bind argument must be an instance of B (TypeError)
+ * from prog.rb:16
+ */
+
+static VALUE
+umethod_bind(method, recv)
+ VALUE method, recv;
+{
+ struct METHOD *data, *bound;
+
+ Data_Get_Struct(method, struct METHOD, data);
+ if (data->rklass != CLASS_OF(recv)) {
+ if (FL_TEST(data->rklass, FL_SINGLETON)) {
+ rb_raise(rb_eTypeError,
+ "singleton method called for a different object");
+ }
+ if (!rb_obj_is_kind_of(recv, data->rklass)) {
+ rb_raise(rb_eTypeError, "bind argument must be an instance of %s",
+ rb_class2name(data->rklass));
+ }
+ }
+
+ method =
+ Data_Make_Struct(rb_cMethod, struct METHOD, bm_mark, free, bound);
+ *bound = *data;
+ bound->recv = recv;
+ bound->rklass = CLASS_OF(recv);
+
+ return method;
+}
+
+int
+rb_node_arity(NODE * body)
+{
+ int n;
+
+ switch (nd_type(body)) {
+ case NODE_CFUNC:
+ if (body->nd_argc < 0)
+ return -1;
+ return body->nd_argc;
+ case NODE_ZSUPER:
+ return -1;
+ case NODE_ATTRSET:
+ return 1;
+ case NODE_IVAR:
+ return 0;
+ case NODE_BMETHOD:
+ return rb_proc_arity(body->nd_cval);
+ case NODE_SCOPE:
+ body = body->nd_next; /* skip NODE_SCOPE */
+ if (nd_type(body) == NODE_BLOCK)
+ body = body->nd_head;
+ if (!body)
+ return 0;
+ n = body->nd_frml ? RARRAY_LEN(body->nd_frml) : 0;
+ if (body->nd_opt || body->nd_rest)
+ n = -n - 1;
+ return n;
+ case YARV_METHOD_NODE:{
+ yarv_iseq_t *iseq;
+ GetISeqPtr((VALUE)body->nd_body, iseq);
+ if (iseq->arg_rest == 0 && iseq->arg_opts == 0) {
+ return iseq->argc;
+ }
+ else {
+ return -iseq->argc - 1;
+ }
+ }
+ default:
+ rb_raise(rb_eArgError, "invalid node 0x%x", nd_type(body));
+ }
+}
+
+/*
+ * call-seq:
+ * meth.arity => fixnum
+ *
+ * Returns an indication of the number of arguments accepted by a
+ * method. Returns a nonnegative integer for methods that take a fixed
+ * number of arguments. For Ruby methods that take a variable number of
+ * arguments, returns -n-1, where n is the number of required
+ * arguments. For methods written in C, returns -1 if the call takes a
+ * variable number of arguments.
+ *
+ * class C
+ * def one; end
+ * def two(a); end
+ * def three(*a); end
+ * def four(a, b); end
+ * def five(a, b, *c); end
+ * def six(a, b, *c, &d); end
+ * end
+ * c = C.new
+ * c.method(:one).arity #=> 0
+ * c.method(:two).arity #=> 1
+ * c.method(:three).arity #=> -1
+ * c.method(:four).arity #=> 2
+ * c.method(:five).arity #=> -3
+ * c.method(:six).arity #=> -3
+ *
+ * "cat".method(:size).arity #=> 0
+ * "cat".method(:replace).arity #=> 1
+ * "cat".method(:squeeze).arity #=> -1
+ * "cat".method(:count).arity #=> -1
+ */
+
+static VALUE
+method_arity_m(method)
+ VALUE method;
+{
+ int n = method_arity(method);
+ return INT2FIX(n);
+}
+
+static int
+method_arity(method)
+ VALUE method;
+{
+ struct METHOD *data;
+
+ Data_Get_Struct(method, struct METHOD, data);
+ return rb_node_arity(data->body);
+}
+
+int
+rb_mod_method_arity(mod, id)
+ VALUE mod;
+ ID id;
+{
+ NODE *node = rb_method_node(mod, id);
+ return rb_node_arity(node);
+}
+
+int
+rb_obj_method_arity(obj, id)
+ VALUE obj;
+ ID id;
+{
+ return rb_mod_method_arity(CLASS_OF(obj), id);
+}
+
+/*
+ * call-seq:
+ * meth.to_s => string
+ * meth.inspect => string
+ *
+ * Show the name of the underlying method.
+ *
+ * "cat".method(:count).inspect #=> "#<Method: String#count>"
+ */
+
+static VALUE
+method_inspect(VALUE method)
+{
+ struct METHOD *data;
+ VALUE str;
+ const char *s;
+ char *sharp = "#";
+
+ Data_Get_Struct(method, struct METHOD, data);
+ str = rb_str_buf_new2("#<");
+ s = rb_obj_classname(method);
+ rb_str_buf_cat2(str, s);
+ rb_str_buf_cat2(str, ": ");
+
+ if (FL_TEST(data->klass, FL_SINGLETON)) {
+ VALUE v = rb_iv_get(data->klass, "__attached__");
+
+ if (data->recv == Qundef) {
+ rb_str_buf_append(str, rb_inspect(data->klass));
+ }
+ else if (data->recv == v) {
+ rb_str_buf_append(str, rb_inspect(v));
+ sharp = ".";
+ }
+ else {
+ rb_str_buf_append(str, rb_inspect(data->recv));
+ rb_str_buf_cat2(str, "(");
+ rb_str_buf_append(str, rb_inspect(v));
+ rb_str_buf_cat2(str, ")");
+ sharp = ".";
+ }
+ }
+ else {
+ rb_str_buf_cat2(str, rb_class2name(data->rklass));
+ if (data->rklass != data->klass) {
+ rb_str_buf_cat2(str, "(");
+ rb_str_buf_cat2(str, rb_class2name(data->klass));
+ rb_str_buf_cat2(str, ")");
+ }
+ }
+ rb_str_buf_cat2(str, sharp);
+ rb_str_buf_cat2(str, rb_id2name(data->oid));
+ rb_str_buf_cat2(str, ">");
+
+ return str;
+}
+
+static VALUE
+mproc(VALUE method)
+{
+ return rb_funcall(Qnil, rb_intern("proc"), 0);
+}
+
+static VALUE
+bmcall(VALUE args, VALUE method)
+{
+ volatile VALUE a;
+ if (CLASS_OF(args) != rb_cArray) {
+ args = rb_ary_new3(1, args);
+ }
+
+ a = args;
+ return rb_method_call(RARRAY_LEN(a), RARRAY_PTR(a), method);
+}
+
+VALUE
+rb_proc_new(
+ VALUE (*func)(ANYARGS), /* VALUE yieldarg[, VALUE procarg] */
+ VALUE val)
+{
+ yarv_proc_t *proc;
+ VALUE procval = rb_iterate((VALUE(*)(VALUE))mproc, 0, func, val);
+ GetProcPtr(procval, proc);
+ ((NODE*)proc->block.iseq)->u3.state = 1;
+ return procval;
+}
+
+/*
+ * call-seq:
+ * meth.to_proc => prc
+ *
+ * Returns a <code>Proc</code> object corresponding to this method.
+ */
+
+static VALUE
+method_proc(VALUE method)
+{
+ VALUE proc;
+ /*
+ * class Method
+ * def to_proc
+ * proc{|*args|
+ * self.call(*args)
+ * }
+ * end
+ * end
+ */
+ proc = rb_iterate((VALUE (*)(VALUE))mproc, 0, bmcall, method);
+ return proc;
+}
+
+static VALUE
+rb_obj_is_method(VALUE m)
+{
+ if (TYPE(m) == T_DATA && RDATA(m)->dmark == (RUBY_DATA_FUNC) bm_mark) {
+ return Qtrue;
+ }
+ return Qfalse;
+}
+
+/*
+ * call_seq:
+ * local_jump_error.exit_value => obj
+ *
+ * Returns the exit value associated with this +LocalJumpError+.
+ */
+static VALUE
+localjump_xvalue(VALUE exc)
+{
+ return rb_iv_get(exc, "@exit_value");
+}
+
+/*
+ * call-seq:
+ * local_jump_error.reason => symbol
+ *
+ * The reason this block was terminated:
+ * :break, :redo, :retry, :next, :return, or :noreason.
+ */
+
+static VALUE
+localjump_reason(VALUE exc)
+{
+ return rb_iv_get(exc, "@reason");
+}
+
+
+/*
+ * <code>Proc</code> objects are blocks of code that have been bound to
+ * a set of local variables. Once bound, the code may be called in
+ * different contexts and still access those variables.
+ *
+ * def gen_times(factor)
+ * return Proc.new {|n| n*factor }
+ * end
+ *
+ * times3 = gen_times(3)
+ * times5 = gen_times(5)
+ *
+ * times3.call(12) #=> 36
+ * times5.call(5) #=> 25
+ * times3.call(times5.call(4)) #=> 60
+ *
+ */
+
+void
+Init_Proc()
+{
+ /* Env */
+ rb_cVM = rb_define_class("VM", rb_cObject); /* TODO: should be moved to suitable place */
+ rb_cEnv = rb_define_class_under(rb_cVM, "Env", rb_cObject);
+ rb_undef_alloc_func(rb_cEnv);
+
+ /* Proc */
+ rb_cProc = rb_define_class("Proc", rb_cObject);
+ rb_undef_alloc_func(rb_cProc);
+ rb_define_singleton_method(rb_cProc, "new", rb_proc_s_new, 0);
+ rb_define_method(rb_cProc, "call", proc_call, -1);
+ rb_define_method(rb_cProc, "[]", proc_call, -1);
+ rb_define_method(rb_cProc, "yield", proc_yield, -1);
+ 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, "==", proc_eq, 1);
+ rb_define_method(rb_cProc, "eql?", proc_eq, 1);
+ rb_define_method(rb_cProc, "hash", proc_hash, 0);
+ rb_define_method(rb_cProc, "to_s", proc_to_s, 0);
+
+ /* Binding */
+ rb_cBinding = rb_define_class("Binding", rb_cObject);
+ rb_undef_alloc_func(rb_cBinding);
+ rb_undef_method(CLASS_OF(rb_cBinding), "new");
+ rb_define_method(rb_cBinding, "clone", binding_clone, 0);
+ rb_define_method(rb_cBinding, "dup", binding_dup, 0);
+ rb_define_global_function("binding", rb_f_binding, 0);
+
+ 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);
+
+ /* Exceptions */
+ exception_error = rb_exc_new2(rb_eFatal, "exception reentered");
+ rb_register_mark_object(exception_error);
+
+ rb_eSysStackError = rb_define_class("SystemStackError", rb_eException);
+ sysstack_error = rb_exc_new2(rb_eSysStackError, "stack level too deep");
+ OBJ_TAINT(sysstack_error);
+ rb_register_mark_object(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, "unbind", method_unbind, 0);
+ rb_define_method(rb_mKernel, "method", rb_obj_method, 1);
+
+ /* UnboundMethod */
+ rb_cUnboundMethod = rb_define_class("UnboundMethod", rb_cObject);
+ rb_undef_alloc_func(rb_cUnboundMethod);
+ rb_undef_method(CLASS_OF(rb_cUnboundMethod), "new");
+ rb_define_method(rb_cUnboundMethod, "==", method_eq, 1);
+ rb_define_method(rb_cUnboundMethod, "eql?", method_eq, 1);
+ rb_define_method(rb_cUnboundMethod, "hash", method_hash, 0);
+ rb_define_method(rb_cUnboundMethod, "clone", method_clone, 0);
+ rb_define_method(rb_cUnboundMethod, "arity", method_arity_m, 0);
+ rb_define_method(rb_cUnboundMethod, "inspect", method_inspect, 0);
+ rb_define_method(rb_cUnboundMethod, "to_s", method_inspect, 0);
+ rb_define_method(rb_cUnboundMethod, "bind", umethod_bind, 1);
+
+ /* Module#*_method */
+ rb_define_method(rb_cModule, "instance_method", rb_mod_method, 1);
+ rb_define_private_method(rb_cModule, "define_method",
+ rb_mod_define_method, -1);
+}
+
+/*
+ * Objects of class <code>Binding</code> encapsulate the execution
+ * context at some particular place in the code and retain this context
+ * for future use. The variables, methods, value of <code>self</code>,
+ * and possibly an iterator block that can be accessed in this context
+ * are all retained. Binding objects can be created using
+ * <code>Kernel#binding</code>, and are made available to the callback
+ * of <code>Kernel#set_trace_func</code>.
+ *
+ * These binding objects can be passed as the second argument of the
+ * <code>Kernel#eval</code> method, establishing an environment for the
+ * evaluation.
+ *
+ * class Demo
+ * def initialize(n)
+ * @secret = n
+ * end
+ * def getBinding
+ * return binding()
+ * end
+ * end
+ *
+ * k1 = Demo.new(99)
+ * b1 = k1.getBinding
+ * k2 = Demo.new(-3)
+ * b2 = k2.getBinding
+ *
+ * eval("@secret", b1) #=> 99
+ * eval("@secret", b2) #=> -3
+ * eval("@secret") #=> nil
+ *
+ * Binding objects have no class-specific methods.
+ *
+ */
+
+void
+Init_Binding()
+{
+
+}
+
@@ -1,7 +1,7 @@ #define RUBY_VERSION "1.9.0" -#define RUBY_RELEASE_DATE "2007-01-16" +#define RUBY_RELEASE_DATE "2007-01-17" #define RUBY_VERSION_CODE 190 -#define RUBY_RELEASE_CODE 20070116 +#define RUBY_RELEASE_CODE 20070117 #define RUBY_PATCHLEVEL 0 #define RUBY_VERSION_MAJOR 1 @@ -9,7 +9,7 @@ #define RUBY_VERSION_TEENY 0 #define RUBY_RELEASE_YEAR 2007 #define RUBY_RELEASE_MONTH 1 -#define RUBY_RELEASE_DAY 16 +#define RUBY_RELEASE_DAY 17 RUBY_EXTERN const char ruby_version[]; RUBY_EXTERN const char ruby_release_date[]; @@ -180,7 +180,6 @@ th_set_eval_stack(yarv_thread_t *th, VALUE iseqval) } static int check_env(yarv_env_t *env); -VALUE yarv_env_alloc(VALUE klass); static VALUE th_make_env_each(yarv_thread_t *th, yarv_control_frame_t *cfp, @@ -216,10 +215,9 @@ th_make_env_each(yarv_thread_t *th, yarv_control_frame_t *cfp, *envptr = GC_GUARDED_PTR(pcfp->dfp); } } -//SDR2(cfp); -//fprintf(stderr, "lfp: %p, cfp: %p, endptr: %p\n", cfp->lfp, cfp->dfp, endptr); + /* allocate env */ - envval = yarv_env_alloc(cYarvEnv); + envval = yarv_env_alloc(); GetEnvPtr(envval, env); if (!YARV_NORMAL_ISEQ_P(cfp->iseq)) { @@ -402,7 +400,7 @@ th_make_proc(yarv_thread_t *th, yarv_control_frame_t *cfp, if (PROCDEBUG) { check_env_value(envval); } - procval = yarv_proc_alloc(cYarvProc); + procval = yarv_proc_alloc(); GetProcPtr(procval, proc); proc->blockprocval = blockprocval; proc->block.self = block->self; diff --git a/yarvcore.c b/yarvcore.c index 899ffb65e3..543dffd6da 100644 --- a/yarvcore.c +++ b/yarvcore.c @@ -17,14 +17,8 @@ #include "yarv.h" #include "gc.h" -VALUE mYarvCore; -VALUE cYarvISeq; -VALUE cYarvVM; VALUE cYarvThread; -VALUE mYarvInsns; -VALUE cYarvEnv; -VALUE cYarvProc; -VALUE cYarvBinding; +VALUE rb_cVM; VALUE symIFUNC; VALUE symCFUNC; @@ -453,7 +447,6 @@ yarv_thread_alloc(VALUE klass) VALUE th_eval_body(yarv_thread_t *th); void th_set_top_stack(yarv_thread_t *, VALUE iseq); -VALUE rb_f_binding(VALUE); VALUE yarv_th_eval(yarv_thread_t *th, VALUE iseqval) @@ -464,375 +457,19 @@ yarv_th_eval(yarv_thread_t *th, VALUE iseqval) th_set_top_stack(th, iseqval); if (!rb_const_defined(rb_cObject, rb_intern("TOPLEVEL_BINDING"))) { - rb_define_global_const("TOPLEVEL_BINDING", rb_f_binding(Qnil)); + rb_define_global_const("TOPLEVEL_BINDING", rb_binding_new()); } val = th_eval_body(th); tmp = iseqval; /* prohibit tail call optimization */ return val; } - -/***************/ -/* YarvEnv */ -/***************/ - -static void -env_free(void *ptr) -{ - yarv_env_t *env; - FREE_REPORT_ENTER("env"); - if (ptr) { - env = ptr; - FREE_UNLESS_NULL(env->env); - ruby_xfree(ptr); - } - FREE_REPORT_LEAVE("env"); -} - -static void -env_mark(void *ptr) -{ - yarv_env_t *env; - MARK_REPORT_ENTER("env"); - if (ptr) { - env = ptr; - if (env->env) { - /* TODO: should mark more restricted range */ - GC_INFO("env->env\n"); - rb_gc_mark_locations(env->env, env->env + env->env_size); - } - GC_INFO("env->prev_envval\n"); - MARK_UNLESS_NULL(env->prev_envval); - - if (env->block.iseq) { - //printf("env->block.iseq <%p, %d>\n", - // env->block.iseq, BUILTIN_TYPE(env->block.iseq)); - if (BUILTIN_TYPE(env->block.iseq) == T_NODE) { - MARK_UNLESS_NULL((VALUE)env->block.iseq); - } - else { - MARK_UNLESS_NULL(env->block.iseq->self); - } - } - } - MARK_REPORT_LEAVE("env"); -} - -VALUE -yarv_env_alloc(VALUE klass) -{ - VALUE obj; - yarv_env_t *env; - obj = Data_Make_Struct(klass, yarv_env_t, env_mark, env_free, env); - env->env = 0; - env->prev_envval = 0; - env->block.iseq = 0; - return obj; -} - - -/***************/ -/* YarvProc */ -/***************/ - -static void -proc_free(void *ptr) -{ - FREE_REPORT_ENTER("proc"); - if (ptr) { - ruby_xfree(ptr); - } - FREE_REPORT_LEAVE("proc"); -} - -static void -proc_mark(void *ptr) -{ - yarv_proc_t *proc; - MARK_REPORT_ENTER("proc"); - if (ptr) { - proc = ptr; - MARK_UNLESS_NULL(proc->envval); - MARK_UNLESS_NULL(proc->blockprocval); - MARK_UNLESS_NULL((VALUE)proc->special_cref_stack); - if (proc->block.iseq && YARV_IFUNC_P(proc->block.iseq)) { - MARK_UNLESS_NULL((VALUE)(proc->block.iseq)); - } - } - MARK_REPORT_LEAVE("proc"); -} - -static VALUE -proc_alloc(VALUE klass) -{ - VALUE obj; - yarv_proc_t *proc; - obj = Data_Make_Struct(klass, yarv_proc_t, proc_mark, proc_free, proc); - MEMZERO(proc, yarv_proc_t, 1); - return obj; -} - -VALUE -yarv_proc_alloc(VALUE klass) -{ - return proc_alloc(cYarvProc); -} - -static VALUE -proc_call(int argc, VALUE *argv, VALUE procval) -{ - yarv_proc_t *proc; - GetProcPtr(procval, proc); - return th_invoke_proc(GET_THREAD(), proc, proc->block.self, argc, argv); -} - -static VALUE -proc_yield(int argc, VALUE *argv, VALUE procval) -{ - yarv_proc_t *proc; - GetProcPtr(procval, proc); - return th_invoke_proc(GET_THREAD(), proc, proc->block.self, argc, argv); -} - -static VALUE -proc_to_proc(VALUE self) -{ - return self; -} - -VALUE -yarv_obj_is_proc(VALUE proc) -{ - if (TYPE(proc) == T_DATA && - RDATA(proc)->dfree == (RUBY_DATA_FUNC) proc_free) { - return Qtrue; - } - else { - return Qfalse; - } -} - -static VALUE -proc_arity(VALUE self) -{ - yarv_proc_t *proc; - yarv_iseq_t *iseq; - GetProcPtr(self, proc); - iseq = proc->block.iseq; - if (iseq && BUILTIN_TYPE(iseq) != T_NODE) { - if (iseq->arg_rest == 0 && iseq->arg_opts == 0) { - return INT2FIX(iseq->argc); - } - else { - return INT2FIX(-iseq->argc - 1); - } - } - else { - return INT2FIX(-1); - } -} - -int -rb_proc_arity(VALUE proc) -{ - return FIX2INT(proc_arity(proc)); -} - -static VALUE -proc_eq(VALUE self, VALUE other) -{ - if (self == other) { - return Qtrue; - } - else { - if (TYPE(other) == T_DATA && - RBASIC(other)->klass == cYarvProc && - CLASS_OF(self) == CLASS_OF(other)) { - yarv_proc_t *p1, *p2; - GetProcPtr(self, p1); - GetProcPtr(other, p2); - if (p1->block.iseq == p2->block.iseq && p1->envval == p2->envval) { - return Qtrue; - } - } - } - return Qfalse; -} - -static VALUE -proc_hash(VALUE self) -{ - int hash; - yarv_proc_t *proc; - GetProcPtr(self, proc); - hash = (long)proc->block.iseq; - hash ^= (long)proc->envval; - hash ^= (long)proc->block.lfp >> 16; - return INT2FIX(hash); -} - -static VALUE -proc_to_s(VALUE self) -{ - VALUE str = 0; - yarv_proc_t *proc; - char *cname = rb_obj_classname(self); - yarv_iseq_t *iseq; - - GetProcPtr(self, proc); - iseq = proc->block.iseq; - - if (YARV_NORMAL_ISEQ_P(iseq)) { - int line_no = 0; - - if (iseq->insn_info_tbl) { - line_no = iseq->insn_info_tbl[0].line_no; - } - str = rb_sprintf("#<%s:%lx@%s:%d>", cname, self, - RSTRING_PTR(iseq->file_name), - line_no); - } - else { - str = rb_sprintf("#<%s:%p>", cname, proc->block.iseq); - } - - if (OBJ_TAINTED(self)) { - OBJ_TAINT(str); - } - return str; -} - -static VALUE -proc_dup(VALUE self) -{ - VALUE procval = proc_alloc(cYarvProc); - yarv_proc_t *src, *dst; - GetProcPtr(self, src); - GetProcPtr(procval, dst); - - dst->block = src->block; - dst->envval = src->envval; - dst->safe_level = dst->safe_level; - dst->special_cref_stack = src->special_cref_stack; - - return procval; -} - -VALUE yarv_proc_dup(VALUE self) -{ - return proc_dup(self); -} -static VALUE -proc_clone(VALUE self) -{ - VALUE procval = proc_dup(self); - CLONESETUP(procval, self); - return procval; -} - - -/***************/ -/* YarvBinding */ -/***************/ - -static void -binding_free(void *ptr) -{ - yarv_binding_t *bind; - FREE_REPORT_ENTER("binding"); - if (ptr) { - bind = ptr; - ruby_xfree(ptr); - } - FREE_REPORT_LEAVE("binding"); -} - -static void -binding_mark(void *ptr) -{ - yarv_binding_t *bind; - MARK_REPORT_ENTER("binding"); - if (ptr) { - bind = ptr; - MARK_UNLESS_NULL(bind->env); - MARK_UNLESS_NULL((VALUE)bind->cref_stack); - } - MARK_REPORT_LEAVE("binding"); -} - -static VALUE -binding_alloc(VALUE klass) -{ - VALUE obj; - yarv_binding_t *bind; - obj = Data_Make_Struct(klass, yarv_binding_t, - binding_mark, binding_free, bind); - MEMZERO(bind, yarv_binding_t, 1); - return obj; -} - -VALUE -yarv_binding_alloc(VALUE klass) -{ - return binding_alloc(klass); -} - -static VALUE -binding_dup(VALUE self) -{ - VALUE bindval = binding_alloc(cYarvBinding); - yarv_binding_t *src, *dst; - GetBindingPtr(self, src); - GetBindingPtr(bindval, dst); - dst->env = src->env; - dst->cref_stack = src->cref_stack; - return bindval; -} - -static VALUE -binding_clone(VALUE self) -{ - VALUE bindval = binding_dup(self); - CLONESETUP(bindval, self); - return bindval; -} - - /********************************************************************/ -static VALUE -yarv_once() -{ - return rb_yield(Qnil); -} - -static VALUE -yarv_segv() -{ - volatile int *a = 0; - *a = 0; - return Qnil; -} - -static VALUE -proc_func(VALUE v) -{ - dp(v); -} - -static VALUE -cfunc(void) -{ - return rb_proc_new(proc_func, INT2FIX(12345)); -} - -// VALUE yarv_Hash_each(); VALUE insns_name_array(void); VALUE Init_yarvthread(void); extern VALUE *rb_gc_stack_start; -VALUE rb_proc_s_new(VALUE klass); - VALUE sdr(void) { @@ -897,79 +534,41 @@ char *yarv_options = "" void Init_ISeq(void); void -Init_yarvcore(void) +Init_vm(void) { - /* declare YARVCore module */ - mYarvCore = rb_define_module("YARVCore"); - rb_define_const(mYarvCore, "OPTS", rb_str_new2(yarv_options)); - Init_ISeq(); - - /* YARVCore::USAGE_ANALISYS_* */ - rb_define_const(mYarvCore, "USAGE_ANALISYS_INSN", rb_hash_new()); - rb_define_const(mYarvCore, "USAGE_ANALISYS_REGS", rb_hash_new()); - rb_define_const(mYarvCore, "USAGE_ANALISYS_INSN_BIGRAM", rb_hash_new()); - /* YARVCore::InsnNameArray */ - rb_define_const(mYarvCore, "InsnNameArray", insns_name_array()); + /* ::VM */ + rb_cVM = rb_define_class("VM", rb_cObject); + rb_undef_alloc_func(rb_cVM); + + /* ::VM::USAGE_ANALISYS_* */ + rb_define_const(rb_cVM, "USAGE_ANALISYS_INSN", rb_hash_new()); + rb_define_const(rb_cVM, "USAGE_ANALISYS_REGS", rb_hash_new()); + rb_define_const(rb_cVM, "USAGE_ANALISYS_INSN_BIGRAM", rb_hash_new()); + rb_define_const(rb_cVM, "OPTS", rb_str_new2(yarv_options)); - rb_define_singleton_method(mYarvCore, "eval", yarvcore_eval, 3); + /* ::VM::InsnNameArray */ + rb_define_const(rb_cVM, "InsnNameArray", insns_name_array()); - /* declare YARVCore::VM */ - cYarvVM = rb_define_class_under(mYarvCore, "VM", rb_cObject); - rb_undef_alloc_func(cYarvVM); + /* ::VM::eval() */ + rb_define_singleton_method(rb_cVM, "eval", yarvcore_eval, 3); - /* declare YARVCore::VM::Thread */ - cYarvThread = rb_define_class_under(cYarvVM, "Thread", rb_cObject); + /* ::VM::Thread */ + cYarvThread = rb_define_class_under(rb_cVM, "Thread", rb_cObject); rb_define_global_const("Thread", cYarvThread); rb_undef_alloc_func(cYarvThread); rb_define_method(cYarvThread, "initialize", thread_init, 0); - /* declare YARVCore::VM::Env */ - cYarvEnv = rb_define_class_under(cYarvVM, "Env", rb_cObject); - rb_undef_alloc_func(cYarvEnv); - - /* declare YARVCore::VM::Proc */ - rb_cProc = cYarvProc = rb_define_class_under(cYarvVM, "Proc", rb_cObject); - rb_const_set(rb_cObject, rb_intern("Proc"), cYarvProc); - rb_undef_alloc_func(cYarvProc); - rb_define_singleton_method(cYarvProc, "new", rb_proc_s_new, 0); - rb_define_method(cYarvProc, "call", proc_call, -1); - rb_define_method(cYarvProc, "[]", proc_call, -1); - rb_define_method(cYarvProc, "yield", proc_yield, -1); - rb_define_method(cYarvProc, "to_proc", proc_to_proc, 0); - rb_define_method(cYarvProc, "arity", proc_arity, 0); - rb_define_method(cYarvProc, "clone", proc_clone, 0); - rb_define_method(cYarvProc, "dup", proc_dup, 0); - rb_define_method(cYarvProc, "==", proc_eq, 1); - rb_define_method(cYarvProc, "eql?", proc_eq, 1); - rb_define_method(cYarvProc, "hash", proc_hash, 0); - rb_define_method(cYarvProc, "to_s", proc_to_s, 0); - - /* declare YARVCore::VM::Binding */ - cYarvBinding = rb_define_class_under(cYarvVM, "Binding", rb_cObject); - rb_const_set(rb_cObject, rb_intern("Binding"), cYarvBinding); - rb_undef_alloc_func(cYarvBinding); - rb_undef_method(CLASS_OF(cYarvBinding), "new"); - rb_define_method(cYarvBinding, "clone", binding_clone, 0); - rb_define_method(cYarvBinding, "dup", binding_dup, 0); - rb_define_global_function("binding", rb_f_binding, 0); - - /* misc */ - - - /* YARV test functions */ - - rb_define_global_function("once", yarv_once, 0); - rb_define_global_function("segv", yarv_segv, 0); - rb_define_global_function("cfunc", cfunc, 0); - rb_define_global_function("SDR", sdr, 0); - rb_define_global_function("NSDR", nsdr, 0); + /* debug functions */ + rb_define_singleton_method(rb_cVM, "SDR", sdr, 0); + rb_define_singleton_method(rb_cVM, "NSDR", sdr, 0); + /* Symbols */ symIFUNC = ID2SYM(rb_intern("<IFUNC>")); symCFUNC = ID2SYM(rb_intern("<CFUNC>")); - /* for optimize */ + /* IDs */ idPLUS = rb_intern("+"); idMINUS = rb_intern("-"); idMULT = rb_intern("*"); @@ -1014,10 +613,10 @@ Init_yarvcore(void) #if TEST_AOT_COMPILE Init_compiled(); #endif - // make vm + /* VM bootstrap: phase 1 */ { /* create vm object */ - VALUE vmval = vm_alloc(cYarvVM); + VALUE vmval = vm_alloc(rb_cVM); VALUE thval; yarv_vm_t *vm; @@ -1053,21 +652,10 @@ Init_yarvcore(void) yarv_init_redefined_flag(); } -static void -test(void) -{ - int i; - int *p; - printf("!test!\n"); - for (i = 0; i < 1000000; i++) { - p = ALLOC(int); - } -} - void Init_yarv(void) { - /* initialize main thread */ + /* VM bootstrap: phase 1 */ yarv_vm_t *vm = ALLOC(yarv_vm_t); yarv_thread_t *th = ALLOC(yarv_thread_t); diff --git a/yarvcore.h b/yarvcore.h index dcb008db75..5c2579ee29 100644 --- a/yarvcore.h +++ b/yarvcore.h @@ -100,14 +100,10 @@ /* classes and modules */ -extern VALUE mYarvCore; -extern VALUE cYarvISeq; extern VALUE cYarvVM; extern VALUE cYarvThread; -extern VALUE mYarvInsns; -extern VALUE cYarvEnv; -extern VALUE cYarvProc; -extern VALUE cYarvBinding; +extern VALUE rb_cISeq; +extern VALUE rb_cVM; extern VALUE symIFUNC; extern VALUE symCFUNC; @@ -601,10 +597,8 @@ typedef VALUE CDHASH; /* VM related object allocate functions */ /* TODO: should be static functions */ VALUE yarv_thread_alloc(VALUE klass); -VALUE yarv_env_alloc(VALUE klass); -VALUE yarv_proc_alloc(VALUE klass); -VALUE yarv_binding_alloc(VALUE klass); - +VALUE yarv_env_alloc(void); +VALUE yarv_proc_alloc(void); /* for debug */ extern void vm_stack_dump_raw(yarv_thread_t *, yarv_control_frame_t *); |