kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

* vm.c: add a prefix "rb_" to exposed functions

Browse source 
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
This commit is contained in:
ko1 2009-01-19 02:38:11 +00:00
parent 2aa6644acd
commit cf23d0f0f0
14 changed files with 92 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

15
ChangeLog
View file

@ -1,3 +1,18 @@
Mon Jan 19 11:27:39 2009 Koichi Sasada <ko1@atdot.net>
* 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.
Mon Jan 19 11:22:51 2009 Nobuyoshi Nakada <nobu@ruby-lang.org> Mon Jan 19 11:22:51 2009 Nobuyoshi Nakada <nobu@ruby-lang.org>
* ext/socket/rubysocket.h (rb_cUNIXSocket, rb_cUNIXServer), * ext/socket/rubysocket.h (rb_cUNIXSocket, rb_cUNIXServer),

6
compile.c
View file

@ -506,11 +506,11 @@ int
rb_iseq_translate_threaded_code(rb_iseq_t *iseq) rb_iseq_translate_threaded_code(rb_iseq_t *iseq)
{ {
#if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE #if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE
extern const void **vm_get_insns_address_table(void); extern const void **rb_vm_get_insns_address_table(void);
#if OPT_DIRECT_THREADED_CODE #if OPT_DIRECT_THREADED_CODE
const void * const *table = vm_get_insns_address_table(); const void * const *table = rb_vm_get_insns_address_table();
#else #else
const void * const *table = vm_get_insns_address_table(); const void * const *table = rb_vm_get_insns_address_table();
#endif #endif
int i; int i;

8
cont.c
View file

@ -247,7 +247,7 @@ cont_new(VALUE klass)
return cont; return cont;
} }
void vm_stack_to_heap(rb_thread_t *th); void rb_vm_stack_to_heap(rb_thread_t *th);
static VALUE static VALUE
cont_capture(volatile int *stat) cont_capture(volatile int *stat)
@ -256,7 +256,7 @@ cont_capture(volatile int *stat)
rb_thread_t *th = GET_THREAD(), *sth; rb_thread_t *th = GET_THREAD(), *sth;
volatile VALUE contval; volatile VALUE contval;
vm_stack_to_heap(th); rb_vm_stack_to_heap(th);
cont = cont_new(rb_cContinuation); cont = cont_new(rb_cContinuation);
contval = cont->self; contval = cont->self;
sth = &cont->saved_thread; sth = &cont->saved_thread;
@ -785,7 +785,7 @@ rb_fiber_start(void)
th->local_svar = Qnil; th->local_svar = Qnil;
fib->status = RUNNING; fib->status = RUNNING;
cont->value = vm_invoke_proc(th, proc, proc->block.self, argc, argv, 0); cont->value = rb_vm_invoke_proc(th, proc, proc->block.self, argc, argv, 0);
} }
TH_POP_TAG(); TH_POP_TAG();
@ -795,7 +795,7 @@ rb_fiber_start(void)
} }
else { else {
th->thrown_errinfo = th->thrown_errinfo =
vm_make_jump_tag_but_local_jump(state, th->errinfo); rb_vm_make_jump_tag_but_local_jump(state, th->errinfo);
} }
RUBY_VM_SET_INTERRUPT(th); RUBY_VM_SET_INTERRUPT(th);
} }

6
eval.c
View file

@ -251,7 +251,7 @@ static VALUE
rb_mod_nesting(void) rb_mod_nesting(void)
{ {
VALUE ary = rb_ary_new(); VALUE ary = rb_ary_new();
const NODE *cref = vm_cref(); const NODE *cref = rb_vm_cref();
while (cref && cref->nd_next) { while (cref && cref->nd_next) {
VALUE klass = cref->nd_clss; VALUE klass = cref->nd_clss;
@ -280,7 +280,7 @@ rb_mod_nesting(void)
static VALUE static VALUE
rb_mod_s_constants(int argc, VALUE *argv, VALUE mod) rb_mod_s_constants(int argc, VALUE *argv, VALUE mod)
{ {
const NODE *cref = vm_cref(); const NODE *cref = rb_vm_cref();
VALUE klass; VALUE klass;
VALUE cbase = 0; VALUE cbase = 0;
void *data = 0; void *data = 0;
@ -592,7 +592,7 @@ void
rb_need_block() rb_need_block()
{ {
if (!rb_block_given_p()) { if (!rb_block_given_p()) {
vm_localjump_error("no block given", Qnil, 0); rb_vm_localjump_error("no block given", Qnil, 0);
} }
} }

14
eval_intern.h
View file

@ -162,9 +162,9 @@ enum ruby_tag_type {
#define GET_THROWOBJ_CATCH_POINT(obj) ((VALUE*)RNODE((obj))->u2.value) #define GET_THROWOBJ_CATCH_POINT(obj) ((VALUE*)RNODE((obj))->u2.value)
#define GET_THROWOBJ_STATE(obj) ((int)RNODE((obj))->u3.value) #define GET_THROWOBJ_STATE(obj) ((int)RNODE((obj))->u3.value)
#define SCOPE_TEST(f) (vm_cref()->nd_visi & (f)) #define SCOPE_TEST(f) (rb_vm_cref()->nd_visi & (f))
#define SCOPE_CHECK(f) (vm_cref()->nd_visi == (f)) #define SCOPE_CHECK(f) (rb_vm_cref()->nd_visi == (f))
#define SCOPE_SET(f) (vm_cref()->nd_visi = (f)) #define SCOPE_SET(f) (rb_vm_cref()->nd_visi = (f))
#define CHECK_STACK_OVERFLOW(cfp, margin) do \ #define CHECK_STACK_OVERFLOW(cfp, margin) do \
if (((VALUE *)(cfp)->sp) + (margin) + sizeof(rb_control_frame_t) >= ((VALUE *)cfp)) { \ if (((VALUE *)(cfp)->sp) + (margin) + sizeof(rb_control_frame_t) >= ((VALUE *)cfp)) { \
@ -193,11 +193,11 @@ VALUE rb_make_exception(int argc, VALUE *argv);
NORETURN(void rb_fiber_start(void)); NORETURN(void rb_fiber_start(void));
NORETURN(void rb_print_undef(VALUE, ID, int)); NORETURN(void rb_print_undef(VALUE, ID, int));
NORETURN(void vm_localjump_error(const char *,VALUE, int)); NORETURN(void rb_vm_localjump_error(const char *,VALUE, int));
NORETURN(void vm_jump_tag_but_local_jump(int, VALUE)); NORETURN(void rb_vm_jump_tag_but_local_jump(int, VALUE));
VALUE vm_make_jump_tag_but_local_jump(int state, VALUE val); VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val);
NODE *vm_cref(void); NODE *rb_vm_cref(void);
rb_control_frame_t *vm_get_ruby_level_caller_cfp(rb_thread_t *th, rb_control_frame_t *cfp); rb_control_frame_t *vm_get_ruby_level_caller_cfp(rb_thread_t *th, rb_control_frame_t *cfp);
VALUE rb_obj_is_proc(VALUE); VALUE rb_obj_is_proc(VALUE);
VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, const rb_block_t *blockptr, VALUE filename); VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, const rb_block_t *blockptr, VALUE filename);

2
load.c
View file

@ -315,7 +315,7 @@ rb_load(VALUE fname, int wrap)
rb_exc_raise(GET_THREAD()->errinfo); rb_exc_raise(GET_THREAD()->errinfo);
} }
if (state) { if (state) {
vm_jump_tag_but_local_jump(state, Qundef); rb_vm_jump_tag_but_local_jump(state, Qundef);
} }
if (!NIL_P(GET_THREAD()->errinfo)) { if (!NIL_P(GET_THREAD()->errinfo)) {

14
proc.c
View file

@ -274,13 +274,13 @@ binding_clone(VALUE self)
return bindval; return bindval;
} }
rb_control_frame_t *vm_get_ruby_level_next_cfp(rb_thread_t *th, rb_control_frame_t *cfp); rb_control_frame_t *rb_vm_get_ruby_level_next_cfp(rb_thread_t *th, rb_control_frame_t *cfp);
VALUE VALUE
rb_binding_new(void) rb_binding_new(void)
{ {
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = vm_get_ruby_level_next_cfp(th, th->cfp); rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp);
VALUE bindval = binding_alloc(rb_cBinding); VALUE bindval = binding_alloc(rb_cBinding);
rb_binding_t *bind; rb_binding_t *bind;
@ -289,7 +289,7 @@ rb_binding_new(void)
} }
GetBindingPtr(bindval, bind); GetBindingPtr(bindval, bind);
bind->env = vm_make_env_object(th, cfp); bind->env = rb_vm_make_env_object(th, cfp);
return bindval; return bindval;
} }
@ -385,7 +385,7 @@ proc_new(VALUE klass, int is_lambda)
} }
} }
procval = vm_make_proc(th, block, klass); procval = rb_vm_make_proc(th, block, klass);
if (is_lambda) { if (is_lambda) {
rb_proc_t *proc; rb_proc_t *proc;
@ -524,7 +524,7 @@ proc_call(int argc, VALUE *argv, VALUE procval)
} }
} }
return vm_invoke_proc(GET_THREAD(), proc, proc->block.self, return rb_vm_invoke_proc(GET_THREAD(), proc, proc->block.self,
argc, argv, blockptr); argc, argv, blockptr);
} }
@ -533,7 +533,7 @@ rb_proc_call(VALUE self, VALUE args)
{ {
rb_proc_t *proc; rb_proc_t *proc;
GetProcPtr(self, proc); GetProcPtr(self, proc);
return vm_invoke_proc(GET_THREAD(), proc, proc->block.self, return rb_vm_invoke_proc(GET_THREAD(), proc, proc->block.self,
RARRAY_LEN(args), RARRAY_PTR(args), 0); RARRAY_LEN(args), RARRAY_PTR(args), 0);
} }
@ -550,7 +550,7 @@ rb_proc_call_with_block(VALUE self, int argc, VALUE *argv, VALUE pass_procval)
block = &pass_proc->block; block = &pass_proc->block;
} }
return vm_invoke_proc(GET_THREAD(), proc, proc->block.self, return rb_vm_invoke_proc(GET_THREAD(), proc, proc->block.self,
argc, argv, block); argc, argv, block);
} }

4
thread.c
View file

@ -383,7 +383,7 @@ thread_start_func_2(rb_thread_t *th, VALUE *stack_start, VALUE *register_stack_s
th->errinfo = Qnil; th->errinfo = Qnil;
th->local_lfp = proc->block.lfp; th->local_lfp = proc->block.lfp;
th->local_svar = Qnil; th->local_svar = Qnil;
th->value = vm_invoke_proc(th, proc, proc->block.self, th->value = rb_vm_invoke_proc(th, proc, proc->block.self,
RARRAY_LEN(args), RARRAY_PTR(args), 0); RARRAY_LEN(args), RARRAY_PTR(args), 0);
} }
else { else {
@ -647,7 +647,7 @@ thread_join(rb_thread_t *target_th, double delay)
/* */ /* */
} }
else if (TYPE(target_th->errinfo) == T_NODE) { else if (TYPE(target_th->errinfo) == T_NODE) {
rb_exc_raise(vm_make_jump_tag_but_local_jump( rb_exc_raise(rb_vm_make_jump_tag_but_local_jump(
GET_THROWOBJ_STATE(err), GET_THROWOBJ_VAL(err))); GET_THROWOBJ_STATE(err), GET_THROWOBJ_VAL(err)));
} }
else { else {

58
vm.c
View file

@ -128,14 +128,14 @@ vm_set_main_stack(rb_thread_t *th, VALUE iseqval)
/* save binding */ /* save binding */
GetISeqPtr(iseqval, iseq); GetISeqPtr(iseqval, iseq);
if (bind && iseq->local_size > 0) { if (bind && iseq->local_size > 0) {
bind->env = vm_make_env_object(th, th->cfp); bind->env = rb_vm_make_env_object(th, th->cfp);
} }
CHECK_STACK_OVERFLOW(th->cfp, iseq->stack_max); CHECK_STACK_OVERFLOW(th->cfp, iseq->stack_max);
} }
rb_control_frame_t * rb_control_frame_t *
vm_get_ruby_level_next_cfp(rb_thread_t *th, rb_control_frame_t *cfp) rb_vm_get_ruby_level_next_cfp(rb_thread_t *th, rb_control_frame_t *cfp)
{ {
while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)) { while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)) {
if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) { if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
@ -390,7 +390,7 @@ vm_collect_local_variables_in_heap(rb_thread_t *th, VALUE *dfp, VALUE ary)
} }
VALUE VALUE
vm_make_env_object(rb_thread_t * th, rb_control_frame_t *cfp) rb_vm_make_env_object(rb_thread_t * th, rb_control_frame_t *cfp)
{ {
VALUE envval; VALUE envval;
@ -409,11 +409,11 @@ vm_make_env_object(rb_thread_t * th, rb_control_frame_t *cfp)
} }
void void
vm_stack_to_heap(rb_thread_t * const th) rb_vm_stack_to_heap(rb_thread_t * const th)
{ {
rb_control_frame_t *cfp = th->cfp; rb_control_frame_t *cfp = th->cfp;
while ((cfp = vm_get_ruby_level_next_cfp(th, cfp)) != 0) { while ((cfp = rb_vm_get_ruby_level_next_cfp(th, cfp)) != 0) {
vm_make_env_object(th, cfp); rb_vm_make_env_object(th, cfp);
cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
} }
} }
@ -429,21 +429,21 @@ vm_make_proc_from_block(rb_thread_t *th, rb_block_t *block)
return block->proc; return block->proc;
} }
proc = vm_make_proc(th, block, rb_cProc); proc = rb_vm_make_proc(th, block, rb_cProc);
block->proc = proc; block->proc = proc;
return proc; return proc;
} }
VALUE VALUE
vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass) rb_vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass)
{ {
VALUE procval, envval, blockprocval = 0; VALUE procval, envval, blockprocval = 0;
rb_proc_t *proc; rb_proc_t *proc;
rb_control_frame_t *cfp = RUBY_VM_GET_CFP_FROM_BLOCK_PTR(block); rb_control_frame_t *cfp = RUBY_VM_GET_CFP_FROM_BLOCK_PTR(block);
if (block->proc) { if (block->proc) {
rb_bug("vm_make_proc: Proc value is already created."); rb_bug("rb_vm_make_proc: Proc value is already created.");
} }
if (GC_GUARDED_PTR_REF(cfp->lfp[0])) { if (GC_GUARDED_PTR_REF(cfp->lfp[0])) {
@ -458,7 +458,7 @@ vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass)
} }
} }
envval = vm_make_env_object(th, cfp); envval = rb_vm_make_env_object(th, cfp);
if (PROCDEBUG) { if (PROCDEBUG) {
check_env_value(envval); check_env_value(envval);
@ -534,7 +534,7 @@ check_block(rb_thread_t *th)
const rb_block_t *blockptr = GC_GUARDED_PTR_REF(th->cfp->lfp[0]); const rb_block_t *blockptr = GC_GUARDED_PTR_REF(th->cfp->lfp[0]);
if (blockptr == 0) { if (blockptr == 0) {
vm_localjump_error("no block given", Qnil, 0); rb_vm_localjump_error("no block given", Qnil, 0);
} }
return blockptr; return blockptr;
@ -555,7 +555,7 @@ vm_yield(rb_thread_t *th, int argc, const VALUE *argv)
} }
VALUE VALUE
vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, VALUE self, rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, VALUE self,
int argc, const VALUE *argv, rb_block_t * blockptr) int argc, const VALUE *argv, rb_block_t * blockptr)
{ {
VALUE val = Qundef; VALUE val = Qundef;
@ -666,7 +666,7 @@ rb_lastline_set(VALUE val)
/* backtrace */ /* backtrace */
int int
vm_get_sourceline(const rb_control_frame_t *cfp) rb_vm_get_sourceline(const rb_control_frame_t *cfp)
{ {
int line_no = 0; int line_no = 0;
const rb_iseq_t *iseq = cfp->iseq; const rb_iseq_t *iseq = cfp->iseq;
@ -700,7 +700,7 @@ vm_backtrace_each(rb_thread_t *th,
if (cfp->pc != 0) { if (cfp->pc != 0) {
rb_iseq_t *iseq = cfp->iseq; rb_iseq_t *iseq = cfp->iseq;
line_no = vm_get_sourceline(cfp); line_no = rb_vm_get_sourceline(cfp);
file = RSTRING_PTR(iseq->filename); file = RSTRING_PTR(iseq->filename);
str = rb_sprintf("%s:%d:in `%s'", str = rb_sprintf("%s:%d:in `%s'",
file, line_no, RSTRING_PTR(iseq->name)); file, line_no, RSTRING_PTR(iseq->name));
@ -749,7 +749,7 @@ const char *
rb_sourcefile(void) rb_sourcefile(void)
{ {
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = vm_get_ruby_level_next_cfp(th, th->cfp); rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp);
if (cfp) { if (cfp) {
return RSTRING_PTR(cfp->iseq->filename); return RSTRING_PTR(cfp->iseq->filename);
@ -763,10 +763,10 @@ int
rb_sourceline(void) rb_sourceline(void)
{ {
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = vm_get_ruby_level_next_cfp(th, th->cfp); rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp);
if (cfp) { if (cfp) {
return vm_get_sourceline(cfp); return rb_vm_get_sourceline(cfp);
} }
else { else {
return 0; return 0;
@ -774,10 +774,10 @@ rb_sourceline(void)
} }
NODE * NODE *
vm_cref(void) rb_vm_cref(void)
{ {
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = vm_get_ruby_level_next_cfp(th, th->cfp); rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp);
return vm_get_cref(cfp->iseq, cfp->lfp, cfp->dfp); return vm_get_cref(cfp->iseq, cfp->lfp, cfp->dfp);
} }
@ -797,7 +797,7 @@ VALUE
rb_vm_cbase(void) rb_vm_cbase(void)
{ {
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = vm_get_ruby_level_next_cfp(th, th->cfp); rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp);
return vm_get_cbase(cfp->iseq, cfp->lfp, cfp->dfp); return vm_get_cbase(cfp->iseq, cfp->lfp, cfp->dfp);
} }
@ -837,14 +837,14 @@ make_localjump_error(const char *mesg, VALUE value, int reason)
} }
void void
vm_localjump_error(const char *mesg, VALUE value, int reason) rb_vm_localjump_error(const char *mesg, VALUE value, int reason)
{ {
VALUE exc = make_localjump_error(mesg, value, reason); VALUE exc = make_localjump_error(mesg, value, reason);
rb_exc_raise(exc); rb_exc_raise(exc);
} }
VALUE VALUE
vm_make_jump_tag_but_local_jump(int state, VALUE val) rb_vm_make_jump_tag_but_local_jump(int state, VALUE val)
{ {
VALUE result = Qnil; VALUE result = Qnil;
@ -876,10 +876,10 @@ vm_make_jump_tag_but_local_jump(int state, VALUE val)
} }
void void
vm_jump_tag_but_local_jump(int state, VALUE val) rb_vm_jump_tag_but_local_jump(int state, VALUE val)
{ {
if (val != Qnil) { if (val != Qnil) {
VALUE exc = vm_make_jump_tag_but_local_jump(state, val); VALUE exc = rb_vm_make_jump_tag_but_local_jump(state, val);
rb_exc_raise(exc); rb_exc_raise(exc);
} }
JUMP_TAG(state); JUMP_TAG(state);
@ -1341,7 +1341,7 @@ rb_thread_current_status(const rb_thread_t *th)
if (cfp->iseq != 0) { if (cfp->iseq != 0) {
if (cfp->pc != 0) { if (cfp->pc != 0) {
rb_iseq_t *iseq = cfp->iseq; rb_iseq_t *iseq = cfp->iseq;
int line_no = vm_get_sourceline(cfp); int line_no = rb_vm_get_sourceline(cfp);
char *file = RSTRING_PTR(iseq->filename); char *file = RSTRING_PTR(iseq->filename);
str = rb_sprintf("%s:%d:in `%s'", str = rb_sprintf("%s:%d:in `%s'",
file, line_no, RSTRING_PTR(iseq->name)); file, line_no, RSTRING_PTR(iseq->name));
@ -1720,7 +1720,7 @@ static VALUE
m_core_define_method(VALUE self, VALUE cbase, VALUE sym, VALUE iseqval) m_core_define_method(VALUE self, VALUE cbase, VALUE sym, VALUE iseqval)
{ {
REWIND_CFP({ REWIND_CFP({
vm_define_method(GET_THREAD(), cbase, SYM2ID(sym), iseqval, 0, vm_cref()); vm_define_method(GET_THREAD(), cbase, SYM2ID(sym), iseqval, 0, rb_vm_cref());
}); });
return Qnil; return Qnil;
} }
@ -1729,7 +1729,7 @@ static VALUE
m_core_define_singleton_method(VALUE self, VALUE cbase, VALUE sym, VALUE iseqval) m_core_define_singleton_method(VALUE self, VALUE cbase, VALUE sym, VALUE iseqval)
{ {
REWIND_CFP({ REWIND_CFP({
vm_define_method(GET_THREAD(), cbase, SYM2ID(sym), iseqval, 1, vm_cref()); vm_define_method(GET_THREAD(), cbase, SYM2ID(sym), iseqval, 1, rb_vm_cref());
}); });
return Qnil; return Qnil;
} }
@ -1769,7 +1769,7 @@ m_core_set_postexe(VALUE self, VALUE iseqval)
rb_iseq_t *blockiseq; rb_iseq_t *blockiseq;
rb_block_t *blockptr; rb_block_t *blockptr;
rb_thread_t *th = GET_THREAD(); rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = vm_get_ruby_level_next_cfp(th, th->cfp); rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp);
VALUE proc; VALUE proc;
extern void rb_call_end_proc(VALUE data); extern void rb_call_end_proc(VALUE data);
@ -1779,7 +1779,7 @@ m_core_set_postexe(VALUE self, VALUE iseqval)
blockptr->iseq = blockiseq; blockptr->iseq = blockiseq;
blockptr->proc = 0; blockptr->proc = 0;
proc = vm_make_proc(th, blockptr, rb_cProc); proc = rb_vm_make_proc(th, blockptr, rb_cProc);
rb_set_end_proc(rb_call_end_proc, proc); rb_set_end_proc(rb_call_end_proc, proc);
}); });
return Qnil; return Qnil;

6
vm_core.h
View file

@ -583,10 +583,10 @@ void rb_enable_interrupt(void);
void rb_disable_interrupt(void); void rb_disable_interrupt(void);
int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, VALUE *klassp); int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, VALUE *klassp);
VALUE vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, VALUE self, VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, VALUE self,
int argc, const VALUE *argv, rb_block_t *blockptr); int argc, const VALUE *argv, rb_block_t *blockptr);
VALUE vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass); VALUE rb_vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass);
VALUE vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp); VALUE rb_vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp);
void *rb_thread_call_with_gvl(void *(*func)(void *), void *data1); void *rb_thread_call_with_gvl(void *(*func)(void *), void *data1);
int ruby_thread_has_gvl_p(void); int ruby_thread_has_gvl_p(void);

4
vm_dump.c
View file

@ -102,11 +102,11 @@ control_frame_dump(rb_thread_t *th, rb_control_frame_t *cfp)
iseq_name = "<ifunc>"; iseq_name = "<ifunc>";
} }
else { else {
int vm_get_sourceline(rb_control_frame_t *); int rb_vm_get_sourceline(rb_control_frame_t *);
pc = cfp->pc - cfp->iseq->iseq_encoded; pc = cfp->pc - cfp->iseq->iseq_encoded;
iseq_name = RSTRING_PTR(cfp->iseq->name); iseq_name = RSTRING_PTR(cfp->iseq->name);
line = vm_get_sourceline(cfp); line = rb_vm_get_sourceline(cfp);
if (line) { if (line) {
snprintf(posbuf, MAX_POSBUF, "%s:%d", RSTRING_PTR(cfp->iseq->filename), line); snprintf(posbuf, MAX_POSBUF, "%s:%d", RSTRING_PTR(cfp->iseq->filename), line);
} }

4
vm_eval.c
View file

@ -735,7 +735,7 @@ eval_string_with_cref(VALUE self, VALUE src, VALUE scope, NODE *cref, const char
/* save new env */ /* save new env */
GetISeqPtr(iseqval, iseq); GetISeqPtr(iseqval, iseq);
if (bind && iseq->local_size > 0) { if (bind && iseq->local_size > 0) {
bind->env = vm_make_env_object(th, th->cfp); bind->env = rb_vm_make_env_object(th, th->cfp);
} }
/* kick */ /* kick */
@ -899,7 +899,7 @@ rb_eval_cmd(VALUE cmd, VALUE arg, int level)
POP_TAG(); POP_TAG();
rb_set_safe_level_force(safe); rb_set_safe_level_force(safe);
if (state) vm_jump_tag_but_local_jump(state, val); if (state) rb_vm_jump_tag_but_local_jump(state, val);
return val; return val;
} }

4
vm_exec.c
View file

@ -113,7 +113,7 @@ vm_exec_core(rb_thread_t *th, VALUE initial)
} }
const void ** const void **
vm_get_insns_address_table(void) rb_vm_get_insns_address_table(void)
{ {
return (const void **)vm_exec_core(0, 0); return (const void **)vm_exec_core(0, 0);
} }
@ -124,7 +124,7 @@ vm_get_insns_address_table(void)
#include "vmtc.inc" #include "vmtc.inc"
const void *const * const void *const *
vm_get_insns_address_table(void) rb_vm_get_insns_address_table(void)
{ {
return insns_address_table; return insns_address_table;
} }

12
vm_insnhelper.c
View file

@ -185,7 +185,7 @@ vm_callee_setup_arg_complex(rb_thread_t *th, const rb_iseq_t * iseq,
/* make Proc object */ /* make Proc object */
if (blockptr->proc == 0) { if (blockptr->proc == 0) {
rb_proc_t *proc; rb_proc_t *proc;
blockval = vm_make_proc(th, blockptr, rb_cProc); blockval = rb_vm_make_proc(th, blockptr, rb_cProc);
GetProcPtr(blockval, proc); GetProcPtr(blockval, proc);
*block = &proc->block; *block = &proc->block;
} }
@ -397,7 +397,7 @@ vm_call_bmethod(rb_thread_t *th, ID id, VALUE procval, VALUE recv,
(cfp-2)->method_class = klass; (cfp-2)->method_class = klass;
GetProcPtr(procval, proc); GetProcPtr(procval, proc);
val = vm_invoke_proc(th, proc, recv, argc, argv, blockptr); val = rb_vm_invoke_proc(th, proc, recv, argc, argv, blockptr);
return val; return val;
} }
@ -665,7 +665,7 @@ vm_yield_with_cfunc(rb_thread_t *th, const rb_block_t *block,
blockarg = blockargptr->proc; blockarg = blockargptr->proc;
} }
else { else {
blockarg = vm_make_proc(th, blockargptr, rb_cProc); blockarg = rb_vm_make_proc(th, blockargptr, rb_cProc);
} }
} }
else { else {
@ -861,7 +861,7 @@ vm_invoke_block(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_num_t num, rb_n
int argc = num; int argc = num;
if (GET_ISEQ()->local_iseq->type != ISEQ_TYPE_METHOD || block == 0) { if (GET_ISEQ()->local_iseq->type != ISEQ_TYPE_METHOD || block == 0) {
vm_localjump_error("no block given (yield)", Qnil, 0); rb_vm_localjump_error("no block given (yield)", Qnil, 0);
} }
iseq = block->iseq; iseq = block->iseq;
@ -1313,7 +1313,7 @@ vm_throw(rb_thread_t *th, rb_control_frame_t *reg_cfp,
} }
if (is_orphan) { if (is_orphan) {
vm_localjump_error("break from proc-closure", throwobj, TAG_BREAK); rb_vm_localjump_error("break from proc-closure", throwobj, TAG_BREAK);
} }
} }
else if (state == TAG_RETRY) { else if (state == TAG_RETRY) {
@ -1352,7 +1352,7 @@ vm_throw(rb_thread_t *th, rb_control_frame_t *reg_cfp,
cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
} }
vm_localjump_error("unexpected return", throwobj, TAG_RETURN); rb_vm_localjump_error("unexpected return", throwobj, TAG_RETURN);
valid_return: valid_return:
pt = dfp; pt = dfp;