summaryrefslogtreecommitdiff
path: root/vm_insnhelper.c
diff options
context:
space:
mode:
authorTakashi Kokubun <takashikkbn@gmail.com>2022-07-21 09:23:58 -0700
committerTakashi Kokubun <takashikkbn@gmail.com>2022-07-21 09:42:04 -0700
commit5b21e94bebed90180d8ff63dad03b8b948361089 (patch)
treef9f7196d84b51b7a3a8001658e4391a63b71c396 /vm_insnhelper.c
parent3ff53c8e04ecc91e0190de6d5950ecce2a2ea188 (diff)
Expand tabs [ci skip]
[Misc #18891]
Notes
Notes: Merged: https://github.com/ruby/ruby/pull/6094
Diffstat (limited to 'vm_insnhelper.c')
-rw-r--r--vm_insnhelper.c1890
1 files changed, 945 insertions, 945 deletions
diff --git a/vm_insnhelper.c b/vm_insnhelper.c
index 3c81544ba9..2fb1ecb5f7 100644
--- a/vm_insnhelper.c
+++ b/vm_insnhelper.c
@@ -61,10 +61,10 @@ ec_stack_overflow(rb_execution_context_t *ec, int setup)
VALUE mesg = rb_ec_vm_ptr(ec)->special_exceptions[ruby_error_sysstack];
ec->raised_flag = RAISED_STACKOVERFLOW;
if (setup) {
- VALUE at = rb_ec_backtrace_object(ec);
- mesg = ruby_vm_special_exception_copy(mesg);
- rb_ivar_set(mesg, idBt, at);
- rb_ivar_set(mesg, idBt_locations, at);
+ VALUE at = rb_ec_backtrace_object(ec);
+ mesg = ruby_vm_special_exception_copy(mesg);
+ rb_ivar_set(mesg, idBt, at);
+ rb_ivar_set(mesg, idBt_locations, at);
}
ec->errinfo = mesg;
EC_JUMP_TAG(ec, TAG_RAISE);
@@ -89,9 +89,9 @@ rb_ec_stack_overflow(rb_execution_context_t *ec, int crit)
rb_bug("system stack overflow during GC. Faulty native extension?");
}
if (crit) {
- ec->raised_flag = RAISED_STACKOVERFLOW;
- ec->errinfo = rb_ec_vm_ptr(ec)->special_exceptions[ruby_error_stackfatal];
- EC_JUMP_TAG(ec, TAG_RAISE);
+ ec->raised_flag = RAISED_STACKOVERFLOW;
+ ec->errinfo = rb_ec_vm_ptr(ec)->special_exceptions[ruby_error_stackfatal];
+ EC_JUMP_TAG(ec, TAG_RAISE);
}
#ifdef USE_SIGALTSTACK
ec_stack_overflow(ec, TRUE);
@@ -111,15 +111,15 @@ callable_class_p(VALUE klass)
default:
break;
case T_ICLASS:
- if (!RB_TYPE_P(RCLASS_SUPER(klass), T_MODULE)) break;
+ if (!RB_TYPE_P(RCLASS_SUPER(klass), T_MODULE)) break;
case T_MODULE:
- return TRUE;
+ return TRUE;
}
while (klass) {
- if (klass == rb_cBasicObject) {
- return TRUE;
- }
- klass = RCLASS_SUPER(klass);
+ if (klass == rb_cBasicObject) {
+ return TRUE;
+ }
+ klass = RCLASS_SUPER(klass);
}
return FALSE;
#else
@@ -152,62 +152,62 @@ vm_check_frame_detail(VALUE type, int req_block, int req_me, int req_cref, VALUE
enum imemo_type cref_or_me_type = imemo_env; /* impossible value */
if (RB_TYPE_P(cref_or_me, T_IMEMO)) {
- cref_or_me_type = imemo_type(cref_or_me);
+ cref_or_me_type = imemo_type(cref_or_me);
}
if (type & VM_FRAME_FLAG_BMETHOD) {
- req_me = TRUE;
+ req_me = TRUE;
}
if (req_block && (type & VM_ENV_FLAG_LOCAL) == 0) {
- rb_bug("vm_push_frame: specval (%p) should be a block_ptr on %x frame", (void *)specval, magic);
+ rb_bug("vm_push_frame: specval (%p) should be a block_ptr on %x frame", (void *)specval, magic);
}
if (!req_block && (type & VM_ENV_FLAG_LOCAL) != 0) {
- rb_bug("vm_push_frame: specval (%p) should not be a block_ptr on %x frame", (void *)specval, magic);
+ rb_bug("vm_push_frame: specval (%p) should not be a block_ptr on %x frame", (void *)specval, magic);
}
if (req_me) {
- if (cref_or_me_type != imemo_ment) {
- rb_bug("vm_push_frame: (%s) should be method entry on %x frame", rb_obj_info(cref_or_me), magic);
- }
+ if (cref_or_me_type != imemo_ment) {
+ rb_bug("vm_push_frame: (%s) should be method entry on %x frame", rb_obj_info(cref_or_me), magic);
+ }
}
else {
- if (req_cref && cref_or_me_type != imemo_cref) {
- rb_bug("vm_push_frame: (%s) should be CREF on %x frame", rb_obj_info(cref_or_me), magic);
- }
- else { /* cref or Qfalse */
- if (cref_or_me != Qfalse && cref_or_me_type != imemo_cref) {
- if (((type & VM_FRAME_FLAG_LAMBDA) || magic == VM_FRAME_MAGIC_IFUNC) && (cref_or_me_type == imemo_ment)) {
- /* ignore */
- }
- else {
- rb_bug("vm_push_frame: (%s) should be false or cref on %x frame", rb_obj_info(cref_or_me), magic);
- }
- }
- }
+ if (req_cref && cref_or_me_type != imemo_cref) {
+ rb_bug("vm_push_frame: (%s) should be CREF on %x frame", rb_obj_info(cref_or_me), magic);
+ }
+ else { /* cref or Qfalse */
+ if (cref_or_me != Qfalse && cref_or_me_type != imemo_cref) {
+ if (((type & VM_FRAME_FLAG_LAMBDA) || magic == VM_FRAME_MAGIC_IFUNC) && (cref_or_me_type == imemo_ment)) {
+ /* ignore */
+ }
+ else {
+ rb_bug("vm_push_frame: (%s) should be false or cref on %x frame", rb_obj_info(cref_or_me), magic);
+ }
+ }
+ }
}
if (cref_or_me_type == imemo_ment) {
- const rb_callable_method_entry_t *me = (const rb_callable_method_entry_t *)cref_or_me;
+ const rb_callable_method_entry_t *me = (const rb_callable_method_entry_t *)cref_or_me;
- if (!callable_method_entry_p(me)) {
- rb_bug("vm_push_frame: ment (%s) should be callable on %x frame.", rb_obj_info(cref_or_me), magic);
- }
+ if (!callable_method_entry_p(me)) {
+ rb_bug("vm_push_frame: ment (%s) should be callable on %x frame.", rb_obj_info(cref_or_me), magic);
+ }
}
if ((type & VM_FRAME_MAGIC_MASK) == VM_FRAME_MAGIC_DUMMY) {
- VM_ASSERT(iseq == NULL ||
- RUBY_VM_NORMAL_ISEQ_P(iseq) /* argument error. it should be fixed */);
+ VM_ASSERT(iseq == NULL ||
+ RUBY_VM_NORMAL_ISEQ_P(iseq) /* argument error. it should be fixed */);
}
else {
- VM_ASSERT(is_cframe == !RUBY_VM_NORMAL_ISEQ_P(iseq));
+ VM_ASSERT(is_cframe == !RUBY_VM_NORMAL_ISEQ_P(iseq));
}
}
static void
vm_check_frame(VALUE type,
- VALUE specval,
- VALUE cref_or_me,
- const rb_iseq_t *iseq)
+ VALUE specval,
+ VALUE cref_or_me,
+ const rb_iseq_t *iseq)
{
VALUE given_magic = type & VM_FRAME_MAGIC_MASK;
VM_ASSERT(FIXNUM_P(type));
@@ -215,21 +215,21 @@ vm_check_frame(VALUE type,
#define CHECK(magic, req_block, req_me, req_cref, is_cframe) \
case magic: \
vm_check_frame_detail(type, req_block, req_me, req_cref, \
- specval, cref_or_me, is_cframe, iseq); \
+ specval, cref_or_me, is_cframe, iseq); \
break
switch (given_magic) {
- /* BLK ME CREF CFRAME */
- CHECK(VM_FRAME_MAGIC_METHOD, TRUE, TRUE, FALSE, FALSE);
- CHECK(VM_FRAME_MAGIC_CLASS, TRUE, FALSE, TRUE, FALSE);
- CHECK(VM_FRAME_MAGIC_TOP, TRUE, FALSE, TRUE, FALSE);
- CHECK(VM_FRAME_MAGIC_CFUNC, TRUE, TRUE, FALSE, TRUE);
- CHECK(VM_FRAME_MAGIC_BLOCK, FALSE, FALSE, FALSE, FALSE);
- CHECK(VM_FRAME_MAGIC_IFUNC, FALSE, FALSE, FALSE, TRUE);
- CHECK(VM_FRAME_MAGIC_EVAL, FALSE, FALSE, FALSE, FALSE);
- CHECK(VM_FRAME_MAGIC_RESCUE, FALSE, FALSE, FALSE, FALSE);
- CHECK(VM_FRAME_MAGIC_DUMMY, TRUE, FALSE, FALSE, FALSE);
+ /* BLK ME CREF CFRAME */
+ CHECK(VM_FRAME_MAGIC_METHOD, TRUE, TRUE, FALSE, FALSE);
+ CHECK(VM_FRAME_MAGIC_CLASS, TRUE, FALSE, TRUE, FALSE);
+ CHECK(VM_FRAME_MAGIC_TOP, TRUE, FALSE, TRUE, FALSE);
+ CHECK(VM_FRAME_MAGIC_CFUNC, TRUE, TRUE, FALSE, TRUE);
+ CHECK(VM_FRAME_MAGIC_BLOCK, FALSE, FALSE, FALSE, FALSE);
+ CHECK(VM_FRAME_MAGIC_IFUNC, FALSE, FALSE, FALSE, TRUE);
+ CHECK(VM_FRAME_MAGIC_EVAL, FALSE, FALSE, FALSE, FALSE);
+ CHECK(VM_FRAME_MAGIC_RESCUE, FALSE, FALSE, FALSE, FALSE);
+ CHECK(VM_FRAME_MAGIC_DUMMY, TRUE, FALSE, FALSE, FALSE);
default:
- rb_bug("vm_push_frame: unknown type (%x)", (unsigned int)given_magic);
+ rb_bug("vm_push_frame: unknown type (%x)", (unsigned int)given_magic);
}
#undef CHECK
}
@@ -349,15 +349,15 @@ STATIC_ASSERT(VM_ENV_DATA_INDEX_FLAGS, VM_ENV_DATA_INDEX_FLAGS == -0);
static void
vm_push_frame(rb_execution_context_t *ec,
- const rb_iseq_t *iseq,
- VALUE type,
- VALUE self,
- VALUE specval,
- VALUE cref_or_me,
- const VALUE *pc,
- VALUE *sp,
- int local_size,
- int stack_max)
+ const rb_iseq_t *iseq,
+ VALUE type,
+ VALUE self,
+ VALUE specval,
+ VALUE cref_or_me,
+ const VALUE *pc,
+ VALUE *sp,
+ int local_size,
+ int stack_max)
{
rb_control_frame_t *const cfp = RUBY_VM_NEXT_CONTROL_FRAME(ec->cfp);
@@ -372,7 +372,7 @@ vm_push_frame(rb_execution_context_t *ec,
/* initialize local variables */
for (int i=0; i < local_size; i++) {
- *sp++ = Qnil;
+ *sp++ = Qnil;
}
/* setup ep with managing data */
@@ -398,7 +398,7 @@ vm_push_frame(rb_execution_context_t *ec,
ec->cfp = cfp;
if (VMDEBUG == 2) {
- SDR();
+ SDR();
}
vm_push_frame_debug_counter_inc(ec, cfp, type);
}
@@ -430,13 +430,13 @@ rb_arity_error_new(int argc, int min, int max)
{
VALUE err_mess = 0;
if (min == max) {
- err_mess = rb_sprintf("wrong number of arguments (given %d, expected %d)", argc, min);
+ err_mess = rb_sprintf("wrong number of arguments (given %d, expected %d)", argc, min);
}
else if (max == UNLIMITED_ARGUMENTS) {
- err_mess = rb_sprintf("wrong number of arguments (given %d, expected %d+)", argc, min);
+ err_mess = rb_sprintf("wrong number of arguments (given %d, expected %d+)", argc, min);
}
else {
- err_mess = rb_sprintf("wrong number of arguments (given %d, expected %d..%d)", argc, min, max);
+ err_mess = rb_sprintf("wrong number of arguments (given %d, expected %d..%d)", argc, min, max);
}
return rb_exc_new3(rb_eArgError, err_mess);
}
@@ -466,10 +466,10 @@ vm_env_write(const VALUE *ep, int index, VALUE v)
{
VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
if (LIKELY((flags & VM_ENV_FLAG_WB_REQUIRED) == 0)) {
- VM_STACK_ENV_WRITE(ep, index, v);
+ VM_STACK_ENV_WRITE(ep, index, v);
}
else {
- vm_env_write_slowpath(ep, index, v);
+ vm_env_write_slowpath(ep, index, v);
}
}
@@ -477,20 +477,20 @@ MJIT_STATIC VALUE
rb_vm_bh_to_procval(const rb_execution_context_t *ec, VALUE block_handler)
{
if (block_handler == VM_BLOCK_HANDLER_NONE) {
- return Qnil;
+ return Qnil;
}
else {
- switch (vm_block_handler_type(block_handler)) {
- case block_handler_type_iseq:
- case block_handler_type_ifunc:
- return rb_vm_make_proc(ec, VM_BH_TO_CAPT_BLOCK(block_handler), rb_cProc);
- case block_handler_type_symbol:
- return rb_sym_to_proc(VM_BH_TO_SYMBOL(block_handler));
- case block_handler_type_proc:
- return VM_BH_TO_PROC(block_handler);
- default:
- VM_UNREACHABLE(rb_vm_bh_to_procval);
- }
+ switch (vm_block_handler_type(block_handler)) {
+ case block_handler_type_iseq:
+ case block_handler_type_ifunc:
+ return rb_vm_make_proc(ec, VM_BH_TO_CAPT_BLOCK(block_handler), rb_cProc);
+ case block_handler_type_symbol:
+ return rb_sym_to_proc(VM_BH_TO_SYMBOL(block_handler));
+ case block_handler_type_proc:
+ return VM_BH_TO_PROC(block_handler);
+ default:
+ VM_UNREACHABLE(rb_vm_bh_to_procval);
+ }
}
}
@@ -501,14 +501,14 @@ static int
vm_svar_valid_p(VALUE svar)
{
if (RB_TYPE_P((VALUE)svar, T_IMEMO)) {
- switch (imemo_type(svar)) {
- case imemo_svar:
- case imemo_cref:
- case imemo_ment:
- return TRUE;
- default:
- break;
- }
+ switch (imemo_type(svar)) {
+ case imemo_svar:
+ case imemo_cref:
+ case imemo_ment:
+ return TRUE;
+ default:
+ break;
+ }
}
rb_bug("vm_svar_valid_p: unknown type: %s", rb_obj_info(svar));
return FALSE;
@@ -521,10 +521,10 @@ lep_svar(const rb_execution_context_t *ec, const VALUE *lep)
VALUE svar;
if (lep && (ec == NULL || ec->root_lep != lep)) {
- svar = lep[VM_ENV_DATA_INDEX_ME_CREF];
+ svar = lep[VM_ENV_DATA_INDEX_ME_CREF];
}
else {
- svar = ec->root_svar;
+ svar = ec->root_svar;
}
VM_ASSERT(svar == Qfalse || vm_svar_valid_p(svar));
@@ -538,10 +538,10 @@ lep_svar_write(const rb_execution_context_t *ec, const VALUE *lep, const struct
VM_ASSERT(vm_svar_valid_p((VALUE)svar));
if (lep && (ec == NULL || ec->root_lep != lep)) {
- vm_env_write(lep, VM_ENV_DATA_INDEX_ME_CREF, (VALUE)svar);
+ vm_env_write(lep, VM_ENV_DATA_INDEX_ME_CREF, (VALUE)svar);
}
else {
- RB_OBJ_WRITE(rb_ec_thread_ptr(ec)->self, &ec->root_svar, svar);
+ RB_OBJ_WRITE(rb_ec_thread_ptr(ec)->self, &ec->root_svar, svar);
}
}
@@ -554,18 +554,18 @@ lep_svar_get(const rb_execution_context_t *ec, const VALUE *lep, rb_num_t key)
switch (key) {
case VM_SVAR_LASTLINE:
- return svar->lastline;
+ return svar->lastline;
case VM_SVAR_BACKREF:
- return svar->backref;
+ return svar->backref;
default: {
- const VALUE ary = svar->others;
-
- if (NIL_P(ary)) {
- return Qnil;
- }
- else {
- return rb_ary_entry(ary, key - VM_SVAR_EXTRA_START);
- }
+ const VALUE ary = svar->others;
+
+ if (NIL_P(ary)) {
+ return Qnil;
+ }
+ else {
+ return rb_ary_entry(ary, key - VM_SVAR_EXTRA_START);
+ }
}
}
}
@@ -582,23 +582,23 @@ lep_svar_set(const rb_execution_context_t *ec, const VALUE *lep, rb_num_t key, V
struct vm_svar *svar = lep_svar(ec, lep);
if ((VALUE)svar == Qfalse || imemo_type((VALUE)svar) != imemo_svar) {
- lep_svar_write(ec, lep, svar = svar_new((VALUE)svar));
+ lep_svar_write(ec, lep, svar = svar_new((VALUE)svar));
}
switch (key) {
case VM_SVAR_LASTLINE:
- RB_OBJ_WRITE(svar, &svar->lastline, val);
- return;
+ RB_OBJ_WRITE(svar, &svar->lastline, val);
+ return;
case VM_SVAR_BACKREF:
- RB_OBJ_WRITE(svar, &svar->backref, val);
- return;
+ RB_OBJ_WRITE(svar, &svar->backref, val);
+ return;
default: {
- VALUE ary = svar->others;
+ VALUE ary = svar->others;
- if (NIL_P(ary)) {
- RB_OBJ_WRITE(svar, &svar->others, ary = rb_ary_new());
- }
- rb_ary_store(ary, key - VM_SVAR_EXTRA_START, val);
+ if (NIL_P(ary)) {
+ RB_OBJ_WRITE(svar, &svar->others, ary = rb_ary_new());
+ }
+ rb_ary_store(ary, key - VM_SVAR_EXTRA_START, val);
}
}
}
@@ -609,32 +609,32 @@ vm_getspecial(const rb_execution_context_t *ec, const VALUE *lep, rb_num_t key,
VALUE val;
if (type == 0) {
- val = lep_svar_get(ec, lep, key);
+ val = lep_svar_get(ec, lep, key);
}
else {
- VALUE backref = lep_svar_get(ec, lep, VM_SVAR_BACKREF);
-
- if (type & 0x01) {
- switch (type >> 1) {
- case '&':
- val = rb_reg_last_match(backref);
- break;
- case '`':
- val = rb_reg_match_pre(backref);
- break;
- case '\'':
- val = rb_reg_match_post(backref);
- break;
- case '+':
- val = rb_reg_match_last(backref);
- break;
- default:
- rb_bug("unexpected back-ref");
- }
- }
- else {
- val = rb_reg_nth_match((int)(type >> 1), backref);
- }
+ VALUE backref = lep_svar_get(ec, lep, VM_SVAR_BACKREF);
+
+ if (type & 0x01) {
+ switch (type >> 1) {
+ case '&':
+ val = rb_reg_last_match(backref);
+ break;
+ case '`':
+ val = rb_reg_match_pre(backref);
+ break;
+ case '\'':
+ val = rb_reg_match_post(backref);
+ break;
+ case '+':
+ val = rb_reg_match_last(backref);
+ break;
+ default:
+ rb_bug("unexpected back-ref");
+ }
+ }
+ else {
+ val = rb_reg_nth_match((int)(type >> 1), backref);
+ }
}
return val;
}
@@ -651,18 +651,18 @@ check_method_entry(VALUE obj, int can_be_svar)
switch (imemo_type(obj)) {
case imemo_ment:
- return (rb_callable_method_entry_t *)obj;
+ return (rb_callable_method_entry_t *)obj;
case imemo_cref:
- return NULL;
+ return NULL;
case imemo_svar:
- if (can_be_svar) {
- return check_method_entry(((struct vm_svar *)obj)->cref_or_me, FALSE);
- }
+ if (can_be_svar) {
+ return check_method_entry(((struct vm_svar *)obj)->cref_or_me, FALSE);
+ }
default:
#if VM_CHECK_MODE > 0
- rb_bug("check_method_entry: svar should not be there:");
+ rb_bug("check_method_entry: svar should not be there:");
#endif
- return NULL;
+ return NULL;
}
}
@@ -673,8 +673,8 @@ rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
rb_callable_method_entry_t *me;
while (!VM_ENV_LOCAL_P(ep)) {
- if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return me;
- ep = VM_ENV_PREV_EP(ep);
+ if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return me;
+ ep = VM_ENV_PREV_EP(ep);
}
return check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
@@ -696,9 +696,9 @@ method_entry_cref(const rb_callable_method_entry_t *me)
{
switch (me->def->type) {
case VM_METHOD_TYPE_ISEQ:
- return me->def->body.iseq.cref;
+ return me->def->body.iseq.cref;
default:
- return NULL;
+ return NULL;
}
}
@@ -716,18 +716,18 @@ check_cref(VALUE obj, int can_be_svar)
switch (imemo_type(obj)) {
case imemo_ment:
- return method_entry_cref((rb_callable_method_entry_t *)obj);
+ return method_entry_cref((rb_callable_method_entry_t *)obj);
case imemo_cref:
- return (rb_cref_t *)obj;
+ return (rb_cref_t *)obj;
case imemo_svar:
- if (can_be_svar) {
- return check_cref(((struct vm_svar *)obj)->cref_or_me, FALSE);
- }
+ if (can_be_svar) {
+ return check_cref(((struct vm_svar *)obj)->cref_or_me, FALSE);
+ }
default:
#if VM_CHECK_MODE > 0
- rb_bug("check_method_entry: svar should not be there:");
+ rb_bug("check_method_entry: svar should not be there:");
#endif
- return NULL;
+ return NULL;
}
}
@@ -737,8 +737,8 @@ vm_env_cref(const VALUE *ep)
rb_cref_t *cref;
while (!VM_ENV_LOCAL_P(ep)) {
- if ((cref = check_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return cref;
- ep = VM_ENV_PREV_EP(ep);
+ if ((cref = check_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return cref;
+ ep = VM_ENV_PREV_EP(ep);
}
return check_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
@@ -748,14 +748,14 @@ static int
is_cref(const VALUE v, int can_be_svar)
{
if (RB_TYPE_P(v, T_IMEMO)) {
- switch (imemo_type(v)) {
- case imemo_cref:
- return TRUE;
- case imemo_svar:
- if (can_be_svar) return is_cref(((struct vm_svar *)v)->cref_or_me, FALSE);
- default:
- break;
- }
+ switch (imemo_type(v)) {
+ case imemo_cref:
+ return TRUE;
+ case imemo_svar:
+ if (can_be_svar) return is_cref(((struct vm_svar *)v)->cref_or_me, FALSE);
+ default:
+ break;
+ }
}
return FALSE;
}
@@ -764,8 +764,8 @@ static int
vm_env_cref_by_cref(const VALUE *ep)
{
while (!VM_ENV_LOCAL_P(ep)) {
- if (is_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) return TRUE;
- ep = VM_ENV_PREV_EP(ep);
+ if (is_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) return TRUE;
+ ep = VM_ENV_PREV_EP(ep);
}
return is_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
}
@@ -777,27 +777,27 @@ cref_replace_with_duplicated_cref_each_frame(const VALUE *vptr, int can_be_svar,
rb_cref_t *cref, *new_cref;
if (RB_TYPE_P(v, T_IMEMO)) {
- switch (imemo_type(v)) {
- case imemo_cref:
- cref = (rb_cref_t *)v;
- new_cref = vm_cref_dup(cref);
- if (parent) {
- RB_OBJ_WRITE(parent, vptr, new_cref);
- }
- else {
- VM_FORCE_WRITE(vptr, (VALUE)new_cref);
- }
- return (rb_cref_t *)new_cref;
- case imemo_svar:
- if (can_be_svar) {
- return cref_replace_with_duplicated_cref_each_frame(&((struct vm_svar *)v)->cref_or_me, FALSE, v);
- }
+ switch (imemo_type(v)) {
+ case imemo_cref:
+ cref = (rb_cref_t *)v;
+ new_cref = vm_cref_dup(cref);
+ if (parent) {
+ RB_OBJ_WRITE(parent, vptr, new_cref);
+ }
+ else {
+ VM_FORCE_WRITE(vptr, (VALUE)new_cref);
+ }
+ return (rb_cref_t *)new_cref;
+ case imemo_svar:
+ if (can_be_svar) {
+ return cref_replace_with_duplicated_cref_each_frame(&((struct vm_svar *)v)->cref_or_me, FALSE, v);
+ }
/* fall through */
- case imemo_ment:
- rb_bug("cref_replace_with_duplicated_cref_each_frame: unreachable");
- default:
- break;
- }
+ case imemo_ment:
+ rb_bug("cref_replace_with_duplicated_cref_each_frame: unreachable");
+ default:
+ break;
+ }
}
return FALSE;
}
@@ -806,21 +806,21 @@ static rb_cref_t *
vm_cref_replace_with_duplicated_cref(const VALUE *ep)
{
if (vm_env_cref_by_cref(ep)) {
- rb_cref_t *cref;
- VALUE envval;
-
- while (!VM_ENV_LOCAL_P(ep)) {
- envval = VM_ENV_ESCAPED_P(ep) ? VM_ENV_ENVVAL(ep) : Qfalse;
- if ((cref = cref_replace_with_duplicated_cref_each_frame(&ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE, envval)) != NULL) {
- return cref;
- }
- ep = VM_ENV_PREV_EP(ep);
- }
- envval = VM_ENV_ESCAPED_P(ep) ? VM_ENV_ENVVAL(ep) : Qfalse;
- return cref_replace_with_duplicated_cref_each_frame(&ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE, envval);
+ rb_cref_t *cref;
+ VALUE envval;
+
+ while (!VM_ENV_LOCAL_P(ep)) {
+ envval = VM_ENV_ESCAPED_P(ep) ? VM_ENV_ENVVAL(ep) : Qfalse;
+ if ((cref = cref_replace_with_duplicated_cref_each_frame(&ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE, envval)) != NULL) {
+ return cref;
+ }
+ ep = VM_ENV_PREV_EP(ep);
+ }
+ envval = VM_ENV_ESCAPED_P(ep) ? VM_ENV_ENVVAL(ep) : Qfalse;
+ return cref_replace_with_duplicated_cref_each_frame(&ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE, envval);
}
else {
- rb_bug("vm_cref_dup: unreachable");
+ rb_bug("vm_cref_dup: unreachable");
}
}
@@ -830,7 +830,7 @@ vm_get_cref(const VALUE *ep)
rb_cref_t *cref = vm_env_cref(ep);
if (cref != NULL) {
- return cref;
+ return cref;
}
else {
rb_bug("vm_get_cref: unreachable");
@@ -864,8 +864,8 @@ vm_get_const_key_cref(const VALUE *ep)
if (FL_TEST(CREF_CLASS(cref), FL_SINGLETON) ||
FL_TEST(CREF_CLASS(cref), RCLASS_CLONED)) {
return key_cref;
- }
- cref = CREF_NEXT(cref);
+ }
+ cref = CREF_NEXT(cref);
}
/* does not include singleton class */
@@ -878,15 +878,15 @@ rb_vm_rewrite_cref(rb_cref_t *cref, VALUE old_klass, VALUE new_klass, rb_cref_t
rb_cref_t *new_cref;
while (cref) {
- if (CREF_CLASS(cref) == old_klass) {
- new_cref = vm_cref_new_use_prev(new_klass, METHOD_VISI_UNDEF, FALSE, cref, FALSE);
- *new_cref_ptr = new_cref;
- return;
- }
- new_cref = vm_cref_new_use_prev(CREF_CLASS(cref), METHOD_VISI_UNDEF, FALSE, cref, FALSE);
- cref = CREF_NEXT(cref);
- *new_cref_ptr = new_cref;
- new_cref_ptr = &new_cref->next;
+ if (CREF_CLASS(cref) == old_klass) {
+ new_cref = vm_cref_new_use_prev(new_klass, METHOD_VISI_UNDEF, FALSE, cref, FALSE);
+ *new_cref_ptr = new_cref;
+ return;
+ }
+ new_cref = vm_cref_new_use_prev(CREF_CLASS(cref), METHOD_VISI_UNDEF, FALSE, cref, FALSE);
+ cref = CREF_NEXT(cref);
+ *new_cref_ptr = new_cref;
+ new_cref_ptr = &new_cref->next;
}
*new_cref_ptr = NULL;
}
@@ -897,14 +897,14 @@ vm_cref_push(const rb_execution_context_t *ec, VALUE klass, const VALUE *ep, int
rb_cref_t *prev_cref = NULL;
if (ep) {
- prev_cref = vm_env_cref(ep);
+ prev_cref = vm_env_cref(ep);
}
else {
- rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(ec, ec->cfp);
+ rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(ec, ec->cfp);
- if (cfp) {
- prev_cref = vm_env_cref(cfp->ep);
- }
+ if (cfp) {
+ prev_cref = vm_env_cref(cfp->ep);
+ }
}
return vm_cref_new(klass, METHOD_VISI_PUBLIC, FALSE, prev_cref, pushed_by_eval, singleton);
@@ -937,7 +937,7 @@ static inline void
vm_check_if_namespace(VALUE klass)
{
if (!RB_TYPE_P(klass, T_CLASS) && !RB_TYPE_P(klass, T_MODULE)) {
- rb_raise(rb_eTypeError, "%+"PRIsVALUE" is not a class/module", klass);
+ rb_raise(rb_eTypeError, "%+"PRIsVALUE" is not a class/module", klass);
}
}
@@ -945,7 +945,7 @@ static inline void
vm_ensure_not_refinement_module(VALUE self)
{
if (RB_TYPE_P(self, T_MODULE) && FL_TEST(self, RMODULE_IS_REFINEMENT)) {
- rb_warn("not defined at the refinement, but at the outer class/module");
+ rb_warn("not defined at the refinement, but at the outer class/module");
}
}
@@ -962,43 +962,43 @@ vm_get_ev_const(rb_execution_context_t *ec, VALUE orig_klass, ID id, bool allow_
VALUE val;
if (NIL_P(orig_klass) && allow_nil) {
- /* in current lexical scope */
+ /* in current lexical scope */
const rb_cref_t *root_cref = vm_get_cref(ec->cfp->ep);
- const rb_cref_t *cref;
- VALUE klass = Qnil;
-
- while (root_cref && CREF_PUSHED_BY_EVAL(root_cref)) {
- root_cref = CREF_NEXT(root_cref);
- }
- cref = root_cref;
- while (cref && CREF_NEXT(cref)) {
- if (CREF_PUSHED_BY_EVAL(cref)) {
- klass = Qnil;
- }
- else {
- klass = CREF_CLASS(cref);
- }
- cref = CREF_NEXT(cref);
-
- if (!NIL_P(klass)) {
- VALUE av, am = 0;
- rb_const_entry_t *ce;
- search_continue:
- if ((ce = rb_const_lookup(klass, id))) {
- rb_const_warn_if_deprecated(ce, klass, id);
- val = ce->value;
- if (val == Qundef) {
- if (am == klass) break;
- am = klass;
- if (is_defined) return 1;
- if (rb_autoloading_value(klass, id, &av, NULL)) return av;
- rb_autoload_load(klass, id);
- goto search_continue;
- }
- else {
- if (is_defined) {
- return 1;
- }
+ const rb_cref_t *cref;
+ VALUE klass = Qnil;
+
+ while (root_cref && CREF_PUSHED_BY_EVAL(root_cref)) {
+ root_cref = CREF_NEXT(root_cref);
+ }
+ cref = root_cref;
+ while (cref && CREF_NEXT(cref)) {
+ if (CREF_PUSHED_BY_EVAL(cref)) {
+ klass = Qnil;
+ }
+ else {
+ klass = CREF_CLASS(cref);
+ }
+ cref = CREF_NEXT(cref);
+
+ if (!NIL_P(klass)) {
+ VALUE av, am = 0;
+ rb_const_entry_t *ce;
+ search_continue:
+ if ((ce = rb_const_lookup(klass, id))) {
+ rb_const_warn_if_deprecated(ce, klass, id);
+ val = ce->value;
+ if (val == Qundef) {
+ if (am == klass) break;
+ am = klass;
+ if (is_defined) return 1;
+ if (rb_autoloading_value(klass, id, &av, NULL)) return av;
+ rb_autoload_load(klass, id);
+ goto search_continue;
+ }
+ else {
+ if (is_defined) {
+ return 1;
+ }
else {
if (UNLIKELY(!rb_ractor_main_p())) {
if (!rb_ractor_shareable_p(val)) {
@@ -1006,36 +1006,36 @@ vm_get_ev_const(rb_execution_context_t *ec, VALUE orig_klass, ID id, bool allow_
"can not access non-shareable objects in constant %"PRIsVALUE"::%s by non-main ractor.", rb_class_path(klass), rb_id2name(id));
}
}
- return val;
- }
- }
- }
- }
- }
-
- /* search self */
- if (root_cref && !NIL_P(CREF_CLASS(root_cref))) {
- klass = vm_get_iclass(ec->cfp, CREF_CLASS(root_cref));
- }
- else {
- klass = CLASS_OF(ec->cfp->self);
- }
-
- if (is_defined) {
- return rb_const_defined(klass, id);
- }
- else {
- return rb_const_get(klass, id);
- }
+ return val;
+ }
+ }
+ }
+ }
+ }
+
+ /* search self */
+ if (root_cref && !NIL_P(CREF_CLASS(root_cref))) {
+ klass = vm_get_iclass(ec->cfp, CREF_CLASS(root_cref));
+ }
+ else {
+ klass = CLASS_OF(ec->cfp->self);
+ }
+
+ if (is_defined) {
+ return rb_const_defined(klass, id);
+ }
+ else {
+ return rb_const_get(klass, id);
+ }
}
else {
- vm_check_if_namespace(orig_klass);
- if (is_defined) {
- return rb_public_const_defined_from(orig_klass, id);
- }
- else {
- return rb_public_const_get_from(orig_klass, id);
- }
+ vm_check_if_namespace(orig_klass);
+ if (is_defined) {
+ return rb_public_const_defined_from(orig_klass, id);
+ }
+ else {
+ return rb_public_const_get_from(orig_klass, id);
+ }
}
}
@@ -1045,13 +1045,13 @@ vm_get_cvar_base(const rb_cref_t *cref, const rb_control_frame_t *cfp, int top_l
VALUE klass;
if (!cref) {
- rb_bug("vm_get_cvar_base: no cref");
+ rb_bug("vm_get_cvar_base: no cref");
}
while (CREF_NEXT(cref) &&
- (NIL_P(CREF_CLASS(cref)) || FL_TEST(CREF_CLASS(cref), FL_SINGLETON) ||
- CREF_PUSHED_BY_EVAL(cref) || CREF_SINGLETON(cref))) {
- cref = CREF_NEXT(cref);
+ (NIL_P(CREF_CLASS(cref)) || FL_TEST(CREF_CLASS(cref), FL_SINGLETON) ||
+ CREF_PUSHED_BY_EVAL(cref) || CREF_SINGLETON(cref))) {
+ cref = CREF_NEXT(cref);
}
if (top_level_raise && !CREF_NEXT(cref)) {
rb_raise(rb_eRuntimeError, "class variable access from toplevel");
@@ -1060,7 +1060,7 @@ vm_get_cvar_base(const rb_cref_t *cref, const rb_control_frame_t *cfp, int top_l
klass = vm_get_iclass(cfp, CREF_CLASS(cref));
if (NIL_P(klass)) {
- rb_raise(rb_eTypeError, "no class variables available");
+ rb_raise(rb_eTypeError, "no class variables available");
}
return klass;
}
@@ -1239,8 +1239,8 @@ vm_setivar(VALUE obj, ID id, VALUE val, const rb_iseq_t *iseq, IVC ic, const str
VM_ASSERT(!rb_ractor_shareable_p(obj));
- if (LIKELY(
- (!is_attr && RB_DEBUG_COUNTER_INC_UNLESS(ivar_set_ic_miss_serial, vm_ic_entry_p(ic) && ic->entry->class_serial == RCLASS_SERIAL(RBASIC(obj)->klass))) ||
+ if (LIKELY(
+ (!is_attr && RB_DEBUG_COUNTER_INC_UNLESS(ivar_set_ic_miss_serial, vm_ic_entry_p(ic) && ic->entry->class_serial == RCLASS_SERIAL(RBASIC(obj)->klass))) ||
( is_attr && RB_DEBUG_COUNTER_INC_UNLESS(ivar_set_ic_miss_unset, vm_cc_attr_index_p(cc))))) {
uint32_t index = !is_attr ? vm_ic_entry_index(ic) : vm_cc_attr_index(cc);
@@ -1251,10 +1251,10 @@ vm_setivar(VALUE obj, ID id, VALUE val, const rb_iseq_t *iseq, IVC ic, const str
RB_OBJ_WRITE(obj, &ptr[index], val);
RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);
return val; /* inline cache hit */
- }
+ }
}
else {
- RB_DEBUG_COUNTER_INC(ivar_set_ic_miss_noobject);
+ RB_DEBUG_COUNTER_INC(ivar_set_ic_miss_noobject);
}
#endif /* OPT_IC_FOR_IVAR */
if (is_attr) {
@@ -1394,16 +1394,16 @@ vm_throw_continue(const rb_execution_context_t *ec, VALUE err)
/* continue throw */
if (FIXNUM_P(err)) {
- ec->tag->state = FIX2INT(err);
+ ec->tag->state = FIX2INT(err);
}
else if (SYMBOL_P(err)) {
- ec->tag->state = TAG_THROW;
+ ec->tag->state = TAG_THROW;
}
else if (THROW_DATA_P(err)) {
- ec->tag->state = THROW_DATA_STATE((struct vm_throw_data *)err);
+ ec->tag->state = THROW_DATA_STATE((struct vm_throw_data *)err);
}
else {
- ec->tag->state = TAG_RAISE;
+ ec->tag->state = TAG_RAISE;
}
return err;
}
@@ -1416,79 +1416,79 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
const rb_control_frame_t * const eocfp = RUBY_VM_END_CONTROL_FRAME(ec); /* end of control frame pointer */
if (flag != 0) {
- /* do nothing */
+ /* do nothing */
}
else if (state == TAG_BREAK) {
- int is_orphan = 1;
- const VALUE *ep = GET_EP();
- const rb_iseq_t *base_iseq = GET_ISEQ();
- escape_cfp = reg_cfp;
+ int is_orphan = 1;
+ const VALUE *ep = GET_EP();
+ const rb_iseq_t *base_iseq = GET_ISEQ();
+ escape_cfp = reg_cfp;
while (ISEQ_BODY(base_iseq)->type != ISEQ_TYPE_BLOCK) {
if (ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_CLASS) {
- escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
- ep = escape_cfp->ep;
- base_iseq = escape_cfp->iseq;
- }
- else {
- ep = VM_ENV_PREV_EP(ep);
+ escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
+ ep = escape_cfp->ep;
+ base_iseq = escape_cfp->iseq;
+ }
+ else {
+ ep = VM_ENV_PREV_EP(ep);
base_iseq = ISEQ_BODY(base_iseq)->parent_iseq;
- escape_cfp = rb_vm_search_cf_from_ep(ec, escape_cfp, ep);
- VM_ASSERT(escape_cfp->iseq == base_iseq);
- }
- }
-
- if (VM_FRAME_LAMBDA_P(escape_cfp)) {
- /* lambda{... break ...} */
- is_orphan = 0;
- state = TAG_RETURN;
- }
- else {
- ep = VM_ENV_PREV_EP(ep);
-
- while (escape_cfp < eocfp) {
- if (escape_cfp->ep == ep) {
- const rb_iseq_t *const iseq = escape_cfp->iseq;
+ escape_cfp = rb_vm_search_cf_from_ep(ec, escape_cfp, ep);
+ VM_ASSERT(escape_cfp->iseq == base_iseq);
+ }
+ }
+
+ if (VM_FRAME_LAMBDA_P(escape_cfp)) {
+ /* lambda{... break ...} */
+ is_orphan = 0;
+ state = TAG_RETURN;
+ }
+ else {
+ ep = VM_ENV_PREV_EP(ep);
+
+ while (escape_cfp < eocfp) {
+ if (escape_cfp->ep == ep) {
+ const rb_iseq_t *const iseq = escape_cfp->iseq;
const VALUE epc = escape_cfp->pc - ISEQ_BODY(iseq)->iseq_encoded;
const struct iseq_catch_table *const ct = ISEQ_BODY(iseq)->catch_table;
- unsigned int i;
-
- if (!ct) break;
- for (i=0; i < ct->size; i++) {
- const struct iseq_catch_table_entry *const entry =
- UNALIGNED_MEMBER_PTR(ct, entries[i]);
-
- if (entry->type == CATCH_TYPE_BREAK &&
- entry->iseq == base_iseq &&
- entry->start < epc && entry->end >= epc) {
- if (entry->cont == epc) { /* found! */
- is_orphan = 0;
- }
- break;
- }
- }
- break;
- }
-
- escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
- }
- }
-
- if (is_orphan) {
- rb_vm_localjump_error("break from proc-closure", throwobj, TAG_BREAK);
- }
+ unsigned int i;
+
+ if (!ct) break;
+ for (i=0; i < ct->size; i++) {
+ const struct iseq_catch_table_entry *const entry =
+ UNALIGNED_MEMBER_PTR(ct, entries[i]);
+
+ if (entry->type == CATCH_TYPE_BREAK &&
+ entry->iseq == base_iseq &&
+ entry->start < epc && entry->end >= epc) {
+ if (entry->cont == epc) { /* found! */
+ is_orphan = 0;
+ }
+ break;
+ }
+ }
+ break;
+ }
+
+ escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
+ }
+ }
+
+ if (is_orphan) {
+ rb_vm_localjump_error("break from proc-closure", throwobj, TAG_BREAK);
+ }
}
else if (state == TAG_RETRY) {
- const VALUE *ep = VM_ENV_PREV_EP(GET_EP());
+ const VALUE *ep = VM_ENV_PREV_EP(GET_EP());
- escape_cfp = rb_vm_search_cf_from_ep(ec, reg_cfp, ep);
+ escape_cfp = rb_vm_search_cf_from_ep(ec, reg_cfp, ep);
}
else if (state == TAG_RETURN) {
- const VALUE *current_ep = GET_EP();
+ const VALUE *current_ep = GET_EP();
const VALUE *target_ep = NULL, *target_lep, *ep = current_ep;
- int in_class_frame = 0;
- int toplevel = 1;
- escape_cfp = reg_cfp;
+ int in_class_frame = 0;
+ int toplevel = 1;
+ escape_cfp = reg_cfp;
// find target_lep, target_ep
while (!VM_ENV_LOCAL_P(ep)) {
@@ -1502,45 +1502,45 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
while (escape_cfp < eocfp) {
const VALUE *lep = VM_CF_LEP(escape_cfp);
- if (!target_lep) {
- target_lep = lep;
- }
+ if (!target_lep) {
+ target_lep = lep;
+ }
- if (lep == target_lep &&
- VM_FRAME_RUBYFRAME_P(escape_cfp) &&
+ if (lep == target_lep &&
+ VM_FRAME_RUBYFRAME_P(escape_cfp) &&
ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_CLASS) {
- in_class_frame = 1;
- target_lep = 0;
- }
-
- if (lep == target_lep) {
- if (VM_FRAME_LAMBDA_P(escape_cfp)) {
- toplevel = 0;
- if (in_class_frame) {
- /* lambda {class A; ... return ...; end} */
+ in_class_frame = 1;
+ target_lep = 0;
+ }
+
+ if (lep == target_lep) {
+ if (VM_FRAME_LAMBDA_P(escape_cfp)) {
+ toplevel = 0;
+ if (in_class_frame) {
+ /* lambda {class A; ... return ...; end} */
goto valid_return;
- }
- else {
- const VALUE *tep = current_ep;
+ }
+ else {
+ const VALUE *tep = current_ep;
- while (target_lep != tep) {
- if (escape_cfp->ep == tep) {
- /* in lambda */
+ while (target_lep != tep) {
+ if (escape_cfp->ep == tep) {
+ /* in lambda */
if (tep == target_ep) {
goto valid_return;
}
else {
goto unexpected_return;
}
- }
- tep = VM_ENV_PREV_EP(tep);
- }
- }
- }
- else if (VM_FRAME_RUBYFRAME_P(escape_cfp)) {
+ }
+ tep = VM_ENV_PREV_EP(tep);
+ }
+ }
+ }
+ else if (VM_FRAME_RUBYFRAME_P(escape_cfp)) {
switch (ISEQ_BODY(escape_cfp->iseq)->type) {
- case ISEQ_TYPE_TOP:
- case ISEQ_TYPE_MAIN:
+ case ISEQ_TYPE_TOP:
+ case ISEQ_TYPE_MAIN:
if (toplevel) {
if (in_class_frame) goto unexpected_return;
if (target_ep == NULL) {
@@ -1550,16 +1550,16 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
goto unexpected_return;
}
}
- break;
- case ISEQ_TYPE_EVAL:
- case ISEQ_TYPE_CLASS:
- toplevel = 0;
- break;
- default:
- break;
- }
- }
- }
+ break;
+ case ISEQ_TYPE_EVAL:
+ case ISEQ_TYPE_CLASS:
+ toplevel = 0;
+ break;
+ default:
+ break;
+ }
+ }
+ }
if (escape_cfp->ep == target_lep && ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_METHOD) {
if (target_ep == NULL) {
@@ -1568,18 +1568,18 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
else {
goto unexpected_return;
}
- }
+ }
- escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
- }
+ escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
+ }
unexpected_return:;
- rb_vm_localjump_error("unexpected return", throwobj, TAG_RETURN);
+ rb_vm_localjump_error("unexpected return", throwobj, TAG_RETURN);
valid_return:;
- /* do nothing */
+ /* do nothing */
}
else {
- rb_bug("isns(throw): unsupported throw type");
+ rb_bug("isns(throw): unsupported throw type");
}
ec->tag->state = state;
@@ -1588,7 +1588,7 @@ vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_c
static VALUE
vm_throw(const rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
- rb_num_t throw_state, VALUE throwobj)
+ rb_num_t throw_state, VALUE throwobj)
{
const int state = (int)(throw_state & VM_THROW_STATE_MASK);
const int flag = (int)(throw_state & VM_THROW_NO_ESCAPE_FLAG);
@@ -1597,7 +1597,7 @@ vm_throw(const rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
return vm_throw_start(ec, reg_cfp, state, flag, throwobj);
}
else {
- return vm_throw_continue(ec, throwobj);
+ return vm_throw_continue(ec, throwobj);
}
}
@@ -1612,57 +1612,57 @@ vm_expandarray(VALUE *sp, VALUE ary, rb_num_t num, int flag)
const VALUE obj = ary;
if (!RB_TYPE_P(ary, T_ARRAY) && NIL_P(ary = rb_check_array_type(ary))) {
- ary = obj;
- ptr = &ary;
- len = 1;
+ ary = obj;
+ ptr = &ary;
+ len = 1;
}
else {
ptr = RARRAY_CONST_PTR_TRANSIENT(ary);
- len = (rb_num_t)RARRAY_LEN(ary);
+ len = (rb_num_t)RARRAY_LEN(ary);
}
if (space_size == 0) {
/* no space left on stack */
}
else if (flag & 0x02) {
- /* post: ..., nil ,ary[-1], ..., ary[0..-num] # top */
- rb_num_t i = 0, j;
-
- if (len < num) {
- for (i=0; i<num-len; i++) {
- *base++ = Qnil;
- }
- }
- for (j=0; i<num; i++, j++) {
- VALUE v = ptr[len - j - 1];
- *base++ = v;
- }
- if (is_splat) {
- *base = rb_ary_new4(len - j, ptr);
- }
+ /* post: ..., nil ,ary[-1], ..., ary[0..-num] # top */
+ rb_num_t i = 0, j;
+
+ if (len < num) {
+ for (i=0; i<num-len; i++) {
+ *base++ = Qnil;
+ }
+ }
+ for (j=0; i<num; i++, j++) {
+ VALUE v = ptr[len - j - 1];
+ *base++ = v;
+ }
+ if (is_splat) {
+ *base = rb_ary_new4(len - j, ptr);
+ }
}
else {
- /* normal: ary[num..-1], ary[num-2], ary[num-3], ..., ary[0] # top */
- rb_num_t i;
- VALUE *bptr = &base[space_size - 1];
-
- for (i=0; i<num; i++) {
- if (len <= i) {
- for (; i<num; i++) {
- *bptr-- = Qnil;
- }
- break;
- }
- *bptr-- = ptr[i];
- }
- if (is_splat) {
- if (num > len) {
- *bptr = rb_ary_new();
- }
- else {
- *bptr = rb_ary_new4(len - num, ptr + num);
- }
- }
+ /* normal: ary[num..-1], ary[num-2], ary[num-3], ..., ary[0] # top */
+ rb_num_t i;
+ VALUE *bptr = &base[space_size - 1];
+
+ for (i=0; i<num; i++) {
+ if (len <= i) {
+ for (; i<num; i++) {
+ *bptr-- = Qnil;
+ }
+ break;
+ }
+ *bptr-- = ptr[i];
+ }
+ if (is_splat) {
+ if (num > len) {
+ *bptr = rb_ary_new();
+ }
+ else {
+ *bptr = rb_ary_new4(len - num, ptr + num);
+ }
+ }
}
RB_GC_GUARD(ary);
}
@@ -2132,17 +2132,17 @@ check_match(rb_execution_context_t *ec, VALUE pattern, VALUE target, enum vm_che
{
switch (type) {
case VM_CHECKMATCH_TYPE_WHEN:
- return pattern;
+ return pattern;
case VM_CHECKMATCH_TYPE_RESCUE:
- if (!rb_obj_is_kind_of(pattern, rb_cModule)) {
- rb_raise(rb_eTypeError, "class or module required for rescue clause");
- }
- /* fall through */
+ if (!rb_obj_is_kind_of(pattern, rb_cModule)) {
+ rb_raise(rb_eTypeError, "class or module required for rescue clause");
+ }
+ /* fall through */
case VM_CHECKMATCH_TYPE_CASE: {
return rb_vm_call_with_refinements(ec, pattern, idEqq, 1, &target, RB_NO_KEYWORDS);
}
default:
- rb_bug("check_match: unreachable");
+ rb_bug("check_match: unreachable");
}
}
@@ -2190,21 +2190,21 @@ vm_base_ptr(const rb_control_frame_t *cfp)
if (cfp->iseq && VM_FRAME_RUBYFRAME_P(cfp)) {
VALUE *bp = prev_cfp->sp + ISEQ_BODY(cfp->iseq)->local_table_size + VM_ENV_DATA_SIZE;
if (ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_METHOD) {
- /* adjust `self' */
- bp += 1;
- }
+ /* adjust `self' */
+ bp += 1;
+ }
#if VM_DEBUG_BP_CHECK
- if (bp != cfp->bp_check) {
- ruby_debug_printf("bp_check: %ld, bp: %ld\n",
- (long)(cfp->bp_check - GET_EC()->vm_stack),
- (long)(bp - GET_EC()->vm_stack));
- rb_bug("vm_base_ptr: unreachable");
- }
+ if (bp != cfp->bp_check) {
+ ruby_debug_printf("bp_check: %ld, bp: %ld\n",
+ (long)(cfp->bp_check - GET_EC()->vm_stack),
+ (long)(bp - GET_EC()->vm_stack));
+ rb_bug("vm_base_ptr: unreachable");
+ }
#endif
- return bp;
+ return bp;
}
else {
- return NULL;
+ return NULL;
}
#else
return cfp->__bp__;
@@ -2479,7 +2479,7 @@ vm_call_iseq_setup_kwparm_nokwarg(rb_execution_context_t *ec, rb_control_frame_t
static inline int
vm_callee_setup_arg(rb_execution_context_t *ec, struct rb_calling_info *calling,
- const rb_iseq_t *iseq, VALUE *argv, int param_size, int local_size)
+ const rb_iseq_t *iseq, VALUE *argv, int param_size, int local_size)
{
const struct rb_callinfo *ci = calling->ci;
const struct rb_callcache *cc = calling->cc;
@@ -2632,15 +2632,15 @@ vm_call_iseq_setup_tailcall(rb_execution_context_t *ec, rb_control_frame_t *cfp,
VALUE finish_flag = VM_FRAME_FINISHED_P(cfp) ? VM_FRAME_FLAG_FINISH : 0;
if (VM_BH_FROM_CFP_P(calling->block_handler, cfp)) {
- struct rb_captured_block *dst_captured = VM_CFP_TO_CAPTURED_BLOCK(RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
- const struct rb_captured_block *src_captured = VM_BH_TO_CAPT_BLOCK(calling->block_handler);
- dst_captured->code.val = src_captured->code.val;
- if (VM_BH_ISEQ_BLOCK_P(calling->block_handler)) {
- calling->block_handler = VM_BH_FROM_ISEQ_BLOCK(dst_captured);
- }
- else {
- calling->block_handler = VM_BH_FROM_IFUNC_BLOCK(dst_captured);
- }
+ struct rb_captured_block *dst_captured = VM_CFP_TO_CAPTURED_BLOCK(RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
+ const struct rb_captured_block *src_captured = VM_BH_TO_CAPT_BLOCK(calling->block_handler);
+ dst_captured->code.val = src_captured->code.val;
+ if (VM_BH_ISEQ_BLOCK_P(calling->block_handler)) {
+ calling->block_handler = VM_BH_FROM_ISEQ_BLOCK(dst_captured);
+ }
+ else {
+ calling->block_handler = VM_BH_FROM_IFUNC_BLOCK(dst_captured);
+ }
}
vm_pop_frame(ec, cfp, cfp->ep);
@@ -2654,7 +2654,7 @@ vm_call_iseq_setup_tailcall(rb_execution_context_t *ec, rb_control_frame_t *cfp,
/* copy arguments */
for (i=0; i < ISEQ_BODY(iseq)->param.size; i++) {
- *sp++ = src_argv[i];
+ *sp++ = src_argv[i];
}
vm_push_frame(ec, iseq, VM_FRAME_MAGIC_METHOD | VM_ENV_FLAG_LOCAL | finish_flag,
@@ -2948,8 +2948,8 @@ vm_cfp_consistent_p(rb_execution_context_t *ec, const rb_control_frame_t *reg_cf
const int ov_flags = RAISED_STACKOVERFLOW;
if (LIKELY(reg_cfp == ec->cfp + 1)) return TRUE;
if (rb_ec_raised_p(ec, ov_flags)) {
- rb_ec_raised_reset(ec, ov_flags);
- return TRUE;
+ rb_ec_raised_reset(ec, ov_flags);
+ return TRUE;
}
return FALSE;
}
@@ -2966,21 +2966,21 @@ vm_method_cfunc_entry(const rb_callable_method_entry_t *me)
switch (me->def->type) {
case VM_METHOD_TYPE_CFUNC:
case VM_METHOD_TYPE_NOTIMPLEMENTED:
- break;
+ break;
# define METHOD_BUG(t) case VM_METHOD_TYPE_##t: rb_bug("wrong method type: " #t)
- METHOD_BUG(ISEQ);
- METHOD_BUG(ATTRSET);
- METHOD_BUG(IVAR);
- METHOD_BUG(BMETHOD);
- METHOD_BUG(ZSUPER);
- METHOD_BUG(UNDEF);
- METHOD_BUG(OPTIMIZED);
- METHOD_BUG(MISSING);
- METHOD_BUG(REFINED);
- METHOD_BUG(ALIAS);
+ METHOD_BUG(ISEQ);
+ METHOD_BUG(ATTRSET);
+ METHOD_BUG(IVAR);
+ METHOD_BUG(BMETHOD);
+ METHOD_BUG(ZSUPER);
+ METHOD_BUG(UNDEF);
+ METHOD_BUG(OPTIMIZED);
+ METHOD_BUG(MISSING);
+ METHOD_BUG(REFINED);
+ METHOD_BUG(ALIAS);
# undef METHOD_BUG
default:
- rb_bug("wrong method type: %d", me->def->type);
+ rb_bug("wrong method type: %d", me->def->type);
}
#endif
return UNALIGNED_MEMBER_PTR(me->def, body.cfunc);
@@ -3011,8 +3011,8 @@ vm_call_cfunc_with_frame(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp
EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_CALL, recv, me->def->original_id, vm_ci_mid(ci), me->owner, Qundef);
vm_push_frame(ec, NULL, frame_type, recv,
- block_handler, (VALUE)me,
- 0, ec->cfp->sp, 0, 0);
+ block_handler, (VALUE)me,
+ 0, ec->cfp->sp, 0, 0);
if (len >= 0) rb_check_arity(argc, len, len);
@@ -3117,11 +3117,11 @@ rb_find_defined_class_by_owner(VALUE current_class, VALUE target_owner)
}
while (RTEST(klass)) {
- VALUE owner = RB_TYPE_P(klass, T_ICLASS) ? RBASIC_CLASS(klass) : klass;
- if (owner == target_owner) {
- return klass;
- }
- klass = RCLASS_SUPER(klass);
+ VALUE owner = RB_TYPE_P(klass, T_ICLASS) ? RBASIC_CLASS(klass) : klass;
+ if (owner == target_owner) {
+ return klass;
+ }
+ klass = RCLASS_SUPER(klass);
}
return current_class; /* maybe module function */
@@ -3135,20 +3135,20 @@ aliased_callable_method_entry(const rb_callable_method_entry_t *me)
if (orig_me->defined_class == 0) {
VALUE defined_class = rb_find_defined_class_by_owner(me->defined_class, orig_me->owner);
- VM_ASSERT(RB_TYPE_P(orig_me->owner, T_MODULE));
- cme = rb_method_entry_complement_defined_class(orig_me, me->called_id, defined_class);
-
- if (me->def->alias_count + me->def->complemented_count == 0) {
- RB_OBJ_WRITE(me, &me->def->body.alias.original_me, cme);
- }
- else {
- rb_method_definition_t *def =
- rb_method_definition_create(VM_METHOD_TYPE_ALIAS, me->def->original_id);
- rb_method_definition_set((rb_method_entry_t *)me, def, (void *)cme);
- }
+ VM_ASSERT(RB_TYPE_P(orig_me->owner, T_MODULE));
+ cme = rb_method_entry_complement_defined_class(orig_me, me->called_id, defined_class);
+
+ if (me->def->alias_count + me->def->complemented_count == 0) {
+ RB_OBJ_WRITE(me, &me->def->body.alias.original_me, cme);
+ }
+ else {
+ rb_method_definition_t *def =
+ rb_method_definition_create(VM_METHOD_TYPE_ALIAS, me->def->original_id);
+ rb_method_definition_set((rb_method_entry_t *)me, def, (void *)cme);
+ }
}
else {
- cme = (const rb_callable_method_entry_t *)orig_me;
+ cme = (const rb_callable_method_entry_t *)orig_me;
}
VM_ASSERT(callable_method_entry_p(cme));
@@ -3259,7 +3259,7 @@ vm_call_opt_send(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct
i = calling->argc - 1;
if (calling->argc == 0) {
- rb_raise(rb_eArgError, "no method name given");
+ rb_raise(rb_eArgError, "no method name given");
}
else {
sym = TOPN(i);
@@ -3276,12 +3276,12 @@ vm_call_opt_send(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct
* | recv | | recv | 3
* --+------+--------+------+------
*/
- /* shift arguments */
- if (i > 0) {
- MEMMOVE(&TOPN(i), &TOPN(i-1), VALUE, i);
- }
- calling->argc -= 1;
- DEC_SP(1);
+ /* shift arguments */
+ if (i > 0) {
+ MEMMOVE(&TOPN(i), &TOPN(i-1), VALUE, i);
+ }
+ calling->argc -= 1;
+ DEC_SP(1);
return vm_call_symbol(ec, reg_cfp, calling, calling->ci, sym);
}
@@ -3306,7 +3306,7 @@ vm_call_method_missing_body(rb_execution_context_t *ec, rb_control_frame_t *reg_
CHECK_VM_STACK_OVERFLOW(reg_cfp, 1);
vm_check_canary(ec, reg_cfp->sp);
if (argc > 1) {
- MEMMOVE(argv+1, argv, VALUE, argc-1);
+ MEMMOVE(argv+1, argv, VALUE, argc-1);
}
argv[0] = ID2SYM(vm_ci_mid(orig_ci));
INC_SP(1);
@@ -3348,7 +3348,7 @@ static inline VALUE
find_refinement(VALUE refinements, VALUE klass)
{
if (NIL_P(refinements)) {
- return Qnil;
+ return Qnil;
}
return rb_hash_lookup(refinements, klass);
}
@@ -3362,13 +3362,13 @@ current_method_entry(const rb_execution_context_t *ec, rb_control_frame_t *cfp)
if (cfp->iseq && ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_BLOCK) {
const rb_iseq_t *local_iseq = ISEQ_BODY(cfp->iseq)->local_iseq;
- do {
- cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
- if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
- /* TODO: orphan block */
- return top_cfp;
- }
- } while (cfp->iseq != local_iseq);
+ do {
+ cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+ if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
+ /* TODO: orphan block */
+ return top_cfp;
+ }
+ } while (cfp->iseq != local_iseq);
}
return cfp;
}
@@ -3380,17 +3380,17 @@ refined_method_callable_without_refinement(const rb_callable_method_entry_t *me)
const rb_callable_method_entry_t *cme;
if (orig_me->defined_class == 0) {
- cme = NULL;
- rb_notimplement();
+ cme = NULL;
+ rb_notimplement();
}
else {
- cme = (const rb_callable_method_entry_t *)orig_me;
+ cme = (const rb_callable_method_entry_t *)orig_me;
}
VM_ASSERT(callable_method_entry_p(cme));
if (UNDEFINED_METHOD_ENTRY_P(cme)) {
- cme = NULL;
+ cme = NULL;
}
return cme;
@@ -3461,12 +3461,12 @@ vm_call_refined(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_c
static inline VALUE vm_invoke_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling, const struct rb_callinfo *ci, bool is_lambda, VALUE block_handler);
NOINLINE(static VALUE
- vm_invoke_block_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
- struct rb_calling_info *calling, const struct rb_callinfo *ci, VALUE block_handler));
+ vm_invoke_block_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
+ struct rb_calling_info *calling, const struct rb_callinfo *ci, VALUE block_handler));
static VALUE
vm_invoke_block_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
- struct rb_calling_info *calling, const struct rb_callinfo *ci, VALUE block_handler)
+ struct rb_calling_info *calling, const struct rb_callinfo *ci, VALUE block_handler)
{
int argc = calling->argc;
@@ -3496,10 +3496,10 @@ vm_call_opt_block_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
const struct rb_callinfo *ci = calling->ci;
if (BASIC_OP_UNREDEFINED_P(BOP_CALL, PROC_REDEFINED_OP_FLAG)) {
- return vm_invoke_block_opt_call(ec, reg_cfp, calling, ci, block_handler);
+ return vm_invoke_block_opt_call(ec, reg_cfp, calling, ci, block_handler);
}
else {
- calling->recv = rb_vm_bh_to_procval(ec, block_handler);
+ calling->recv = rb_vm_bh_to_procval(ec, block_handler);
calling->cc = rb_vm_search_method_slowpath(ci, CLASS_OF(calling->recv));
return vm_call_general(ec, reg_cfp, calling);
}
@@ -3625,8 +3625,8 @@ vm_call_method_each_type(rb_execution_context_t *ec, rb_control_frame_t *cfp, st
CALLER_SETUP_ARG(cfp, calling, ci);
CALLER_REMOVE_EMPTY_KW_SPLAT(cfp, calling, ci);
- rb_check_arity(calling->argc, 1, 1);
- vm_cc_attr_index_initialize(cc);
+ rb_check_arity(calling->argc, 1, 1);
+ vm_cc_attr_index_initialize(cc);
const unsigned int aset_mask = (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT | VM_CALL_KWARG);
VM_CALL_METHOD_ATTR(v,
vm_call_attrset(ec, cfp, calling),
@@ -3636,8 +3636,8 @@ vm_call_method_each_type(rb_execution_context_t *ec, rb_control_frame_t *cfp, st
case VM_METHOD_TYPE_IVAR:
CALLER_SETUP_ARG(cfp, calling, ci);
CALLER_REMOVE_EMPTY_KW_SPLAT(cfp, calling, ci);
- rb_check_arity(calling->argc, 0, 0);
- vm_cc_attr_index_initialize(cc);
+ rb_check_arity(calling->argc, 0, 0);
+ vm_cc_attr_index_initialize(cc);
const unsigned int ivar_mask = (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT);
VM_CALL_METHOD_ATTR(v,
vm_call_ivar(ec, cfp, calling),
@@ -3661,7 +3661,7 @@ vm_call_method_each_type(rb_execution_context_t *ec, rb_control_frame_t *cfp, st
return vm_call_optimized(ec, cfp, calling, ci, cc);
case VM_METHOD_TYPE_UNDEF:
- break;
+ break;
case VM_METHOD_TYPE_ZSUPER:
return vm_call_zsuper(ec, cfp, calling, RCLASS_ORIGIN(vm_cc_cme(cc)->defined_class));
@@ -3685,9 +3685,9 @@ vm_call_method_nome(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct
const int stat = ci_missing_reason(ci);
if (vm_ci_mid(ci) == idMethodMissing) {
- rb_control_frame_t *reg_cfp = cfp;
- VALUE *argv = STACK_ADDR_FROM_TOP(calling->argc);
- vm_raise_method_missing(ec, calling->argc, argv, calling->recv, stat);
+ rb_control_frame_t *reg_cfp = cfp;
+ VALUE *argv = STACK_ADDR_FROM_TOP(calling->argc);
+ vm_raise_method_missing(ec, calling->argc, argv, calling->recv, stat);
}
else {
return vm_call_method_missing_body(ec, cfp, calling, ci, stat);
@@ -3716,42 +3716,42 @@ vm_call_method(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_ca
VM_ASSERT(callable_method_entry_p(vm_cc_cme(cc)));
if (vm_cc_cme(cc) != NULL) {
- switch (METHOD_ENTRY_VISI(vm_cc_cme(cc))) {
- case METHOD_VISI_PUBLIC: /* likely */
+ switch (METHOD_ENTRY_VISI(vm_cc_cme(cc))) {
+ case METHOD_VISI_PUBLIC: /* likely */
return vm_call_method_each_type(ec, cfp, calling);
- case METHOD_VISI_PRIVATE:
- if (!(vm_ci_flag(ci) & VM_CALL_FCALL)) {
- enum method_missing_reason stat = MISSING_PRIVATE;
- if (vm_ci_flag(ci) & VM_CALL_VCALL) stat |= MISSING_VCALL;
+ case METHOD_VISI_PRIVATE:
+ if (!(vm_ci_flag(ci) & VM_CALL_FCALL)) {
+ enum method_missing_reason stat = MISSING_PRIVATE;
+ if (vm_ci_flag(ci) & VM_CALL_VCALL) stat |= MISSING_VCALL;
vm_cc_method_missing_reason_set(cc, stat);
CC_SET_FASTPATH(cc, vm_call_method_missing, TRUE);
return vm_call_method_missing(ec, cfp, calling);
- }
+ }
return vm_call_method_each_type(ec, cfp, calling);
- case METHOD_VISI_PROTECTED:
- if (!(vm_ci_flag(ci) & (VM_CALL_OPT_SEND | VM_CALL_FCALL))) {
+ case METHOD_VISI_PROTECTED:
+ if (!(vm_ci_flag(ci) & (VM_CALL_OPT_SEND | VM_CALL_FCALL))) {
VALUE defined_class = vm_defined_class_for_protected_call(vm_cc_cme(cc));
if (!rb_obj_is_kind_of(cfp->self, defined_class)) {
vm_cc_method_missing_reason_set(cc, MISSING_PROTECTED);
return vm_call_method_missing(ec, cfp, calling);
- }
- else {
- /* caching method info to dummy cc */
- VM_ASSERT(vm_cc_cme(cc) != NULL);
+ }
+ else {
+ /* caching method info to dummy cc */
+ VM_ASSERT(vm_cc_cme(cc) != NULL);
struct rb_callcache cc_on_stack = *cc;
FL_SET_RAW((VALUE)&cc_on_stack, VM_CALLCACHE_UNMARKABLE);
calling->cc = &cc_on_stack;
return vm_call_method_each_type(ec, cfp, calling);
- }
- }
+ }
+ }
return vm_call_method_each_type(ec, cfp, calling);
- default:
- rb_bug("unreachable");
- }
+ default:
+ rb_bug("unreachable");
+ }
}
else {
return vm_call_method_nome(ec, cfp, calling);
@@ -3796,8 +3796,8 @@ vm_search_normal_superclass(VALUE klass)
{
if (BUILTIN_TYPE(klass) == T_ICLASS &&
RB_TYPE_P(RBASIC(klass)->klass, T_MODULE) &&
- FL_TEST_RAW(RBASIC(klass)->klass, RMODULE_IS_REFINEMENT)) {
- klass = RBASIC(klass)->klass;
+ FL_TEST_RAW(RBASIC(klass)->klass, RMODULE_IS_REFINEMENT)) {
+ klass = RBASIC(klass)->klass;
}
klass = RCLASS_ORIGIN(klass);
return RCLASS_SUPER(klass);
@@ -3828,7 +3828,7 @@ vm_search_super_method(const rb_control_frame_t *reg_cfp, struct rb_call_data *c
const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(reg_cfp);
if (!me) {
- vm_super_outside();
+ vm_super_outside();
}
current_defined_class = vm_defined_class_for_protected_call(me);
@@ -3836,7 +3836,7 @@ vm_search_super_method(const rb_control_frame_t *reg_cfp, struct rb_call_data *c
if (BUILTIN_TYPE(current_defined_class) != T_MODULE &&
reg_cfp->iseq != method_entry_iseqptr(me) &&
!rb_obj_is_kind_of(recv, current_defined_class)) {
- VALUE m = RB_TYPE_P(current_defined_class, T_ICLASS) ?
+ VALUE m = RB_TYPE_P(current_defined_class, T_ICLASS) ?
RCLASS_INCLUDER(current_defined_class) : current_defined_class;
if (m) { /* not bound UnboundMethod */
@@ -3848,10 +3848,10 @@ vm_search_super_method(const rb_control_frame_t *reg_cfp, struct rb_call_data *c
}
if (me->def->type == VM_METHOD_TYPE_BMETHOD && (vm_ci_flag(cd->ci) & VM_CALL_ZSUPER)) {
- rb_raise(rb_eRuntimeError,
- "implicit argument passing of super from method defined"
- " by define_method() is not supported."
- " Specify all arguments explicitly.");
+ rb_raise(rb_eRuntimeError,
+ "implicit argument passing of super from method defined"
+ " by define_method() is not supported."
+ " Specify all arguments explicitly.");
}
ID mid = me->def->original_id;
@@ -3869,7 +3869,7 @@ vm_search_super_method(const rb_control_frame_t *reg_cfp, struct rb_call_data *c
VALUE klass = vm_search_normal_superclass(me->defined_class);
if (!klass) {
- /* bound instance method of module */
+ /* bound instance method of module */
cc = vm_cc_new(klass, NULL, vm_call_method_missing);
RB_OBJ_WRITE(reg_cfp->iseq, &cd->cc, cc);
}
@@ -3920,17 +3920,17 @@ block_proc_is_lambda(const VALUE procval)
rb_proc_t *proc;
if (procval) {
- GetProcPtr(procval, proc);
- return proc->is_lambda;
+ GetProcPtr(procval, proc);
+ return proc->is_lambda;
}
else {
- return 0;
+ return 0;
}
}
static VALUE
vm_yield_with_cfunc(rb_execution_context_t *ec,
- const struct rb_captured_block *captured,
+ const struct rb_captured_block *captured,
VALUE self, int argc, const VALUE *argv, int kw_splat, VALUE block_handler,
const rb_callable_method_entry_t *me)
{
@@ -3940,13 +3940,13 @@ vm_yield_with_cfunc(rb_execution_context_t *ec,
const struct vm_ifunc *ifunc = captured->code.ifunc;
if (is_lambda) {
- arg = rb_ary_new4(argc, argv);
+ arg = rb_ary_new4(argc, argv);
}
else if (argc == 0) {
- arg = Qnil;
+ arg = Qnil;
}
else {
- arg = argv[0];
+ arg = argv[0];
}
blockarg = rb_vm_bh_to_procval(ec, block_handler);
@@ -3958,10 +3958,10 @@ vm_yield_with_cfunc(rb_execution_context_t *ec,
vm_push_frame(ec, (const rb_iseq_t *)captured->code.ifunc,
frame_flag,
- self,
- VM_GUARDED_PREV_EP(captured->ep),
+ self,
+ VM_GUARDED_PREV_EP(captured->ep),
(VALUE)me,
- 0, ec->cfp->sp, 0, 0);
+ 0, ec->cfp->sp, 0, 0);
val = (*ifunc->func)(arg, (VALUE)ifunc->data, argc, argv, blockarg);
rb_vm_pop_frame(ec);
@@ -3983,7 +3983,7 @@ vm_callee_setup_block_arg_arg0_splat(rb_control_frame_t *cfp, const rb_iseq_t *i
CHECK_VM_STACK_OVERFLOW(cfp, ISEQ_BODY(iseq)->param.lead_num);
for (i=0; i<len && i<ISEQ_BODY(iseq)->param.lead_num; i++) {
- argv[i] = RARRAY_AREF(ary, i);
+ argv[i] = RARRAY_AREF(ary, i);
}
return i;
@@ -4006,41 +4006,41 @@ static int
vm_callee_setup_block_arg(rb_execution_context_t *ec, struct rb_calling_info *calling, const struct rb_callinfo *ci, const rb_iseq_t *iseq, VALUE *argv, const enum arg_setup_type arg_setup_type)
{
if (rb_simple_iseq_p(iseq)) {
- rb_control_frame_t *cfp = ec->cfp;
- VALUE arg0;
+ rb_control_frame_t *cfp = ec->cfp;
+ VALUE arg0;
CALLER_SETUP_ARG(cfp, calling, ci);
CALLER_REMOVE_EMPTY_KW_SPLAT(cfp, calling, ci);
- if (arg_setup_type == arg_setup_block &&
- calling->argc == 1 &&
+ if (arg_setup_type == arg_setup_block &&
+ calling->argc == 1 &&
ISEQ_BODY(iseq)->param.flags.has_lead &&
!ISEQ_BODY(iseq)->param.flags.ambiguous_param0 &&
- !NIL_P(arg0 = vm_callee_setup_block_arg_arg0_check(argv))) {
- calling->argc = vm_callee_setup_block_arg_arg0_splat(cfp, iseq, argv, arg0);
- }
+ !NIL_P(arg0 = vm_callee_setup_block_arg_arg0_check(argv))) {
+ calling->argc = vm_callee_setup_block_arg_arg0_splat(cfp, iseq, argv, arg0);
+ }
if (calling->argc != ISEQ_BODY(iseq)->param.lead_num) {
- if (arg_setup_type == arg_setup_block) {
+ if (arg_setup_type == arg_setup_block) {
if (calling->argc < ISEQ_BODY(iseq)->param.lead_num) {
- int i;
+ int i;
CHECK_VM_STACK_OVERFLOW(cfp, ISEQ_BODY(iseq)->param.lead_num);
for (i=calling->argc; i<ISEQ_BODY(iseq)->param.lead_num; i++) argv[i] = Qnil;
calling->argc = ISEQ_BODY(iseq)->param.lead_num; /* fill rest parameters */
- }
+ }
else if (calling->argc > ISEQ_BODY(iseq)->param.lead_num) {
calling->argc = ISEQ_BODY(iseq)->param.lead_num; /* simply truncate arguments */
- }
- }
- else {
+ }
+ }
+ else {
argument_arity_error(ec, iseq, calling->argc, ISEQ_BODY(iseq)->param.lead_num, ISEQ_BODY(iseq)->param.lead_num);
- }
- }
+ }
+ }
- return 0;
+ return 0;
}
else {
- return setup_parameters_complex(ec, iseq, calling, ci, argv, arg_setup_type);
+ return setup_parameters_complex(ec, iseq, calling, ci, argv, arg_setup_type);
}
}
@@ -4063,7 +4063,7 @@ vm_yield_setup_args(rb_execution_context_t *ec, const rb_iseq_t *iseq, const int
static VALUE
vm_invoke_iseq_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
- struct rb_calling_info *calling, const struct rb_callinfo *ci,
+ struct rb_calling_info *calling, const struct rb_callinfo *ci,
bool is_lambda, VALUE block_handler)
{
const struct rb_captured_block *captured = VM_BH_TO_ISEQ_BLOCK(block_handler);
@@ -4075,11 +4075,11 @@ vm_invoke_iseq_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
SET_SP(rsp);
vm_push_frame(ec, iseq,
- VM_FRAME_MAGIC_BLOCK | (is_lambda ? VM_FRAME_FLAG_LAMBDA : 0),
- captured->self,
- VM_GUARDED_PREV_EP(captured->ep), 0,
+ VM_FRAME_MAGIC_BLOCK | (is_lambda ? VM_FRAME_FLAG_LAMBDA : 0),
+ captured->self,
+ VM_GUARDED_PREV_EP(captured->ep), 0,
ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
- rsp + arg_size,
+ rsp + arg_size,
ISEQ_BODY(iseq)->local_table_size - arg_size, ISEQ_BODY(iseq)->stack_max);
return Qundef;
@@ -4087,7 +4087,7 @@ vm_invoke_iseq_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
static VALUE
vm_invoke_symbol_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
- struct rb_calling_info *calling, const struct rb_callinfo *ci,
+ struct rb_calling_info *calling, const struct rb_callinfo *ci,
MAYBE_UNUSED(bool is_lambda), VALUE block_handler)
{
if (calling->argc < 1) {
@@ -4103,7 +4103,7 @@ vm_invoke_symbol_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
static VALUE
vm_invoke_ifunc_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
- struct rb_calling_info *calling, const struct rb_callinfo *ci,
+ struct rb_calling_info *calling, const struct rb_callinfo *ci,
MAYBE_UNUSED(bool is_lambda), VALUE block_handler)
{
VALUE val;
@@ -4124,13 +4124,13 @@ vm_proc_to_block_handler(VALUE procval)
switch (vm_block_type(block)) {
case block_type_iseq:
- return VM_BH_FROM_ISEQ_BLOCK(&block->as.captured);
+ return VM_BH_FROM_ISEQ_BLOCK(&block->as.captured);
case block_type_ifunc:
- return VM_BH_FROM_IFUNC_BLOCK(&block->as.captured);
+ return VM_BH_FROM_IFUNC_BLOCK(&block->as.captured);
case block_type_symbol:
- return VM_BH_FROM_SYMBOL(block->as.symbol);
+ return VM_BH_FROM_SYMBOL(block->as.symbol);
case block_type_proc:
- return VM_BH_FROM_PROC(block->as.proc);
+ return VM_BH_FROM_PROC(block->as.proc);
}
VM_UNREACHABLE(vm_yield_with_proc);
return Qundef;
@@ -4178,7 +4178,7 @@ vm_make_proc_with_iseq(const rb_iseq_t *blockiseq)
struct rb_captured_block *captured;
if (cfp == 0) {
- rb_bug("vm_make_proc_with_iseq: unreachable");
+ rb_bug("vm_make_proc_with_iseq: unreachable");
}
captured = VM_CFP_TO_CAPTURED_BLOCK(cfp);
@@ -4213,10 +4213,10 @@ check_respond_to_missing(VALUE obj, VALUE v)
args[0] = obj; args[1] = Qfalse;
r = rb_check_funcall(v, idRespond_to_missing, 2, args);
if (r != Qundef && RTEST(r)) {
- return true;
+ return true;
}
else {
- return false;
+ return false;
}
}
@@ -4229,75 +4229,75 @@ vm_defined(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t op_
switch (type) {
case DEFINED_IVAR:
return rb_ivar_defined(GET_SELF(), SYM2ID(obj));
- break;
+ break;
case DEFINED_GVAR:
return rb_gvar_defined(SYM2ID(obj));
- break;
+ break;
case DEFINED_CVAR: {
const rb_cref_t *cref = vm_get_cref(GET_EP());
klass = vm_get_cvar_base(cref, GET_CFP(), 0);
return rb_cvar_defined(klass, SYM2ID(obj));
- break;
+ break;
}
case DEFINED_CONST:
case DEFINED_CONST_FROM: {
- bool allow_nil = type == DEFINED_CONST;
- klass = v;
+ bool allow_nil = type == DEFINED_CONST;
+ klass = v;
return vm_get_ev_const(ec, klass, SYM2ID(obj), allow_nil, true);
- break;
+ break;
}
case DEFINED_FUNC:
- klass = CLASS_OF(v);
+ klass = CLASS_OF(v);
return rb_ec_obj_respond_to(ec, v, SYM2ID(obj), TRUE);
- break;
+ break;
case DEFINED_METHOD:{
- VALUE klass = CLASS_OF(v);
- const rb_method_entry_t *me = rb_method_entry_with_refinements(klass, SYM2ID(obj), NULL);
-
- if (me) {
- switch (METHOD_ENTRY_VISI(me)) {
- case METHOD_VISI_PRIVATE:
- break;
- case METHOD_VISI_PROTECTED:
- if (!rb_obj_is_kind_of(GET_SELF(), rb_class_real(me->defined_class))) {
- break;
- }
- case METHOD_VISI_PUBLIC:
+ VALUE klass = CLASS_OF(v);
+ const rb_method_entry_t *me = rb_method_entry_with_refinements(klass, SYM2ID(obj), NULL);
+
+ if (me) {
+ switch (METHOD_ENTRY_VISI(me)) {
+ case METHOD_VISI_PRIVATE:
+ break;
+ case METHOD_VISI_PROTECTED:
+ if (!rb_obj_is_kind_of(GET_SELF(), rb_class_real(me->defined_class))) {
+ break;
+ }
+ case METHOD_VISI_PUBLIC:
return true;
- break;
- default:
- rb_bug("vm_defined: unreachable: %u", (unsigned int)METHOD_ENTRY_VISI(me));
- }
- }
- else {
- return check_respond_to_missing(obj, v);
- }
- break;
+ break;
+ default:
+ rb_bug("vm_defined: unreachable: %u", (unsigned int)METHOD_ENTRY_VISI(me));
+ }
+ }
+ else {
+ return check_respond_to_missing(obj, v);
+ }
+ break;
}
case DEFINED_YIELD:
- if (GET_BLOCK_HANDLER() != VM_BLOCK_HANDLER_NONE) {
+ if (GET_BLOCK_HANDLER() != VM_BLOCK_HANDLER_NONE) {
return true;
- }
- break;
+ }
+ break;
case DEFINED_ZSUPER:
- {
- const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(GET_CFP());
+ {
+ const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(GET_CFP());
- if (me) {
- VALUE klass = vm_search_normal_superclass(me->defined_class);
- ID id = me->def->original_id;
+ if (me) {
+ VALUE klass = vm_search_normal_superclass(me->defined_class);
+ ID id = me->def->original_id;
- return rb_method_boundp(klass, id, 0);
- }
- }
- break;
+ return rb_method_boundp(klass, id, 0);
+ }
+ }
+ break;
case DEFINED_REF:{
- return vm_getspecial(ec, GET_LEP(), Qfalse, FIX2INT(obj)) != Qnil;
- break;
+ return vm_getspecial(ec, GET_LEP(), Qfalse, FIX2INT(obj)) != Qnil;
+ break;
}
default:
- rb_bug("unimplemented defined? type (VM)");
- break;
+ rb_bug("unimplemented defined? type (VM)");
+ break;
}
return false;
@@ -4315,24 +4315,24 @@ vm_get_ep(const VALUE *const reg_ep, rb_num_t lv)
rb_num_t i;
const VALUE *ep = reg_ep;
for (i = 0; i < lv; i++) {
- ep = GET_PREV_EP(ep);
+ ep = GET_PREV_EP(ep);
}
return ep;
}
static VALUE
vm_get_special_object(const VALUE *const reg_ep,
- enum vm_special_object_type type)
+ enum vm_special_object_type type)
{
switch (type) {
case VM_SPECIAL_OBJECT_VMCORE:
- return rb_mRubyVMFrozenCore;
+ return rb_mRubyVMFrozenCore;
case VM_SPECIAL_OBJECT_CBASE:
- return vm_get_cbase(reg_ep);
+ return vm_get_cbase(reg_ep);
case VM_SPECIAL_OBJECT_CONST_BASE:
- return vm_get_const_base(reg_ep);
+ return vm_get_const_base(reg_ep);
default:
- rb_bug("putspecialobject insn: unknown value_type %d", type);
+ rb_bug("putspecialobject insn: unknown value_type %d", type);
}
}
@@ -4344,15 +4344,15 @@ vm_concat_array(VALUE ary1, VALUE ary2st)
VALUE tmp2 = rb_check_to_array(ary2);
if (NIL_P(tmp1)) {
- tmp1 = rb_ary_new3(1, ary1);
+ tmp1 = rb_ary_new3(1, ary1);
}
if (NIL_P(tmp2)) {
- tmp2 = rb_ary_new3(1, ary2);
+ tmp2 = rb_ary_new3(1, ary2);
}
if (tmp1 == ary1) {
- tmp1 = rb_ary_dup(ary1);
+ tmp1 = rb_ary_dup(ary1);
}
return rb_ary_concat(tmp1, tmp2);
}
@@ -4362,13 +4362,13 @@ vm_splat_array(VALUE flag, VALUE ary)
{
VALUE tmp = rb_check_to_array(ary);
if (NIL_P(tmp)) {
- return rb_ary_new3(1, ary);
+ return rb_ary_new3(1, ary);
}
else if (RTEST(flag)) {
- return rb_ary_dup(tmp);
+ return rb_ary_dup(tmp);
}
else {
- return tmp;
+ return tmp;
}
}
@@ -4384,21 +4384,21 @@ vm_check_match(rb_execution_context_t *ec, VALUE target, VALUE pattern, rb_num_t
enum vm_check_match_type type = ((int)flag) & VM_CHECKMATCH_TYPE_MASK;
if (flag & VM_CHECKMATCH_ARRAY) {
- long i;
- const long n = RARRAY_LEN(pattern);
+ long i;
+ const long n = RARRAY_LEN(pattern);
- for (i = 0; i < n; i++) {
- VALUE v = RARRAY_AREF(pattern, i);
- VALUE c = check_match(ec, v, target, type);
+ for (i = 0; i < n; i++) {
+ VALUE v = RARRAY_AREF(pattern, i);
+ VALUE c = check_match(ec, v, target, type);
- if (RTEST(c)) {
- return c;
- }
- }
- return Qfalse;
+ if (RTEST(c)) {
+ return c;
+ }
+ }
+ return Qfalse;
}
else {
- return check_match(ec, pattern, target, type);
+ return check_match(ec, pattern, target, type);
}
}
@@ -4408,13 +4408,13 @@ vm_check_keyword(lindex_t bits, lindex_t idx, const VALUE *ep)
const VALUE kw_bits = *(ep - bits);
if (FIXNUM_P(kw_bits)) {
- unsigned int b = (unsigned int)FIX2ULONG(kw_bits);
- if ((idx < KW_SPECIFIED_BITS_MAX) && (b & (0x01 << idx)))
- return Qfalse;
+ unsigned int b = (unsigned int)FIX2ULONG(kw_bits);
+ if ((idx < KW_SPECIFIED_BITS_MAX) && (b & (0x01 << idx)))
+ return Qfalse;
}
else {
- VM_ASSERT(RB_TYPE_P(kw_bits, T_HASH));
- if (rb_hash_has_key(kw_bits, INT2FIX(idx))) return Qfalse;
+ VM_ASSERT(RB_TYPE_P(kw_bits, T_HASH));
+ if (rb_hash_has_key(kw_bits, INT2FIX(idx))) return Qfalse;
}
return Qtrue;
}
@@ -4423,24 +4423,24 @@ static void
vm_dtrace(rb_event_flag_t flag, rb_execution_context_t *ec)
{
if (RUBY_DTRACE_METHOD_ENTRY_ENABLED() ||
- RUBY_DTRACE_METHOD_RETURN_ENABLED() ||
- RUBY_DTRACE_CMETHOD_ENTRY_ENABLED() ||
- RUBY_DTRACE_CMETHOD_RETURN_ENABLED()) {
+ RUBY_DTRACE_METHOD_RETURN_ENABLED() ||
+ RUBY_DTRACE_CMETHOD_ENTRY_ENABLED() ||
+ RUBY_DTRACE_CMETHOD_RETURN_ENABLED()) {
- switch (flag) {
- case RUBY_EVENT_CALL:
- RUBY_DTRACE_METHOD_ENTRY_HOOK(ec, 0, 0);
- return;
- case RUBY_EVENT_C_CALL:
- RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, 0, 0);
- return;
- case RUBY_EVENT_RETURN:
- RUBY_DTRACE_METHOD_RETURN_HOOK(ec, 0, 0);
- return;
- case RUBY_EVENT_C_RETURN:
- RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, 0, 0);
- return;
- }
+ switch (flag) {
+ case RUBY_EVENT_CALL:
+ RUBY_DTRACE_METHOD_ENTRY_HOOK(ec, 0, 0);
+ return;
+ case RUBY_EVENT_C_CALL:
+ RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, 0, 0);
+ return;
+ case RUBY_EVENT_RETURN:
+ RUBY_DTRACE_METHOD_RETURN_HOOK(ec, 0, 0);
+ return;
+ case RUBY_EVENT_C_RETURN:
+ RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, 0, 0);
+ return;
+ }
}
}
@@ -4465,19 +4465,19 @@ vm_check_if_class(ID id, rb_num_t flags, VALUE super, VALUE klass)
return 0;
}
else if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags)) {
- VALUE tmp = rb_class_real(RCLASS_SUPER(klass));
+ VALUE tmp = rb_class_real(RCLASS_SUPER(klass));
- if (tmp != super) {
- rb_raise(rb_eTypeError,
- "superclass mismatch for class %"PRIsVALUE"",
- rb_id2str(id));
- }
- else {
- return klass;
- }
+ if (tmp != super) {
+ rb_raise(rb_eTypeError,
+ "superclass mismatch for class %"PRIsVALUE"",
+ rb_id2str(id));
+ }
+ else {
+ return klass;
+ }
}
else {
- return klass;
+ return klass;
}
}
@@ -4488,7 +4488,7 @@ vm_check_if_module(ID id, VALUE mod)
return 0;
}
else {
- return mod;
+ return mod;
}
}
@@ -4540,9 +4540,9 @@ vm_define_class(ID id, rb_num_t flags, VALUE cbase, VALUE super)
VALUE klass;
if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags) && !RB_TYPE_P(super, T_CLASS)) {
- rb_raise(rb_eTypeError,
+ rb_raise(rb_eTypeError,
"superclass must be an instance of Class (given an instance of %"PRIsVALUE")",
- rb_obj_class(super));
+ rb_obj_class(super));
}
vm_check_if_namespace(cbase);
@@ -4555,7 +4555,7 @@ vm_define_class(ID id, rb_num_t flags, VALUE cbase, VALUE super)
return klass;
}
else {
- return vm_declare_class(id, flags, cbase, super);
+ return vm_declare_class(id, flags, cbase, super);
}
}
@@ -4571,33 +4571,33 @@ vm_define_module(ID id, rb_num_t flags, VALUE cbase)
return mod;
}
else {
- return vm_declare_module(id, cbase);
+ return vm_declare_module(id, cbase);
}
}
static VALUE
vm_find_or_create_class_by_id(ID id,
- rb_num_t flags,
- VALUE cbase,
- VALUE super)
+ rb_num_t flags,
+ VALUE cbase,
+ VALUE super)
{
rb_vm_defineclass_type_t type = VM_DEFINECLASS_TYPE(flags);
switch (type) {
case VM_DEFINECLASS_TYPE_CLASS:
- /* classdef returns class scope value */
- return vm_define_class(id, flags, cbase, super);
+ /* classdef returns class scope value */
+ return vm_define_class(id, flags, cbase, super);
case VM_DEFINECLASS_TYPE_SINGLETON_CLASS:
- /* classdef returns class scope value */
- return rb_singleton_class(cbase);
+ /* classdef returns class scope value */
+ return rb_singleton_class(cbase);
case VM_DEFINECLASS_TYPE_MODULE:
- /* classdef returns class scope value */
- return vm_define_module(id, flags, cbase);
+ /* classdef returns class scope value */
+ return vm_define_module(id, flags, cbase);
default:
- rb_bug("unknown defineclass type: %d", (int)type);
+ rb_bug("unknown defineclass type: %d", (int)type);
}
}
@@ -4853,10 +4853,10 @@ static VALUE
vm_opt_str_freeze(VALUE str, int bop, ID id)
{
if (BASIC_OP_UNREDEFINED_P(bop, STRING_REDEFINED_OP_FLAG)) {
- return str;
+ return str;
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -4867,21 +4867,21 @@ static VALUE
vm_opt_newarray_max(rb_execution_context_t *ec, rb_num_t num, const VALUE *ptr)
{
if (BASIC_OP_UNREDEFINED_P(BOP_MAX, ARRAY_REDEFINED_OP_FLAG)) {
- if (num == 0) {
- return Qnil;
- }
- else {
- struct cmp_opt_data cmp_opt = { 0, 0 };
- VALUE result = *ptr;
+ if (num == 0) {
+ return Qnil;
+ }
+ else {
+ struct cmp_opt_data cmp_opt = { 0, 0 };
+ VALUE result = *ptr;
rb_snum_t i = num - 1;
- while (i-- > 0) {
- const VALUE v = *++ptr;
- if (OPTIMIZED_CMP(v, result, cmp_opt) > 0) {
- result = v;
- }
- }
- return result;
- }
+ while (i-- > 0) {
+ const VALUE v = *++ptr;
+ if (OPTIMIZED_CMP(v, result, cmp_opt) > 0) {
+ result = v;
+ }
+ }
+ return result;
+ }
}
else {
return rb_vm_call_with_refinements(ec, rb_ary_new4(num, ptr), idMax, 0, NULL, RB_NO_KEYWORDS);
@@ -4892,21 +4892,21 @@ static VALUE
vm_opt_newarray_min(rb_execution_context_t *ec, rb_num_t num, const VALUE *ptr)
{
if (BASIC_OP_UNREDEFINED_P(BOP_MIN, ARRAY_REDEFINED_OP_FLAG)) {
- if (num == 0) {
- return Qnil;
- }
- else {
- struct cmp_opt_data cmp_opt = { 0, 0 };
- VALUE result = *ptr;
+ if (num == 0) {
+ return Qnil;
+ }
+ else {
+ struct cmp_opt_data cmp_opt = { 0, 0 };
+ VALUE result = *ptr;
rb_snum_t i = num - 1;
- while (i-- > 0) {
- const VALUE v = *++ptr;
- if (OPTIMIZED_CMP(v, result, cmp_opt) < 0) {
- result = v;
- }
- }
- return result;
- }
+ while (i-- > 0) {
+ const VALUE v = *++ptr;
+ if (OPTIMIZED_CMP(v, result, cmp_opt) < 0) {
+ result = v;
+ }
+ }
+ return result;
+ }
}
else {
return rb_vm_call_with_refinements(ec, rb_ary_new4(num, ptr), idMin, 0, NULL, RB_NO_KEYWORDS);
@@ -5023,26 +5023,26 @@ vm_once_dispatch(rb_execution_context_t *ec, ISEQ iseq, ISE is)
again:
if (is->once.running_thread == RUNNING_THREAD_ONCE_DONE) {
- return is->once.value;
+ return is->once.value;
}
else if (is->once.running_thread == NULL) {
- VALUE val;
- is->once.running_thread = th;
- val = rb_ensure(vm_once_exec, (VALUE)iseq, vm_once_clear, (VALUE)is);
- RB_OBJ_WRITE(ec->cfp->iseq, &is->once.value, val);
- /* is->once.running_thread is cleared by vm_once_clear() */
- is->once.running_thread = RUNNING_THREAD_ONCE_DONE; /* success */
- return val;
+ VALUE val;
+ is->once.running_thread = th;
+ val = rb_ensure(vm_once_exec, (VALUE)iseq, vm_once_clear, (VALUE)is);
+ RB_OBJ_WRITE(ec->cfp->iseq, &is->once.value, val);
+ /* is->once.running_thread is cleared by vm_once_clear() */
+ is->once.running_thread = RUNNING_THREAD_ONCE_DONE; /* success */
+ return val;
}
else if (is->once.running_thread == th) {
- /* recursive once */
- return vm_once_exec((VALUE)iseq);
+ /* recursive once */
+ return vm_once_exec((VALUE)iseq);
}
else {
- /* waiting for finish */
- RUBY_VM_CHECK_INTS(ec);
- rb_thread_schedule();
- goto again;
+ /* waiting for finish */
+ RUBY_VM_CHECK_INTS(ec);
+ rb_thread_schedule();
+ goto again;
}
}
@@ -5055,45 +5055,45 @@ vm_case_dispatch(CDHASH hash, OFFSET else_offset, VALUE key)
case T_SYMBOL:
case T_BIGNUM:
case T_STRING:
- if (BASIC_OP_UNREDEFINED_P(BOP_EQQ,
- SYMBOL_REDEFINED_OP_FLAG |
- INTEGER_REDEFINED_OP_FLAG |
- FLOAT_REDEFINED_OP_FLAG |
- NIL_REDEFINED_OP_FLAG |
- TRUE_REDEFINED_OP_FLAG |
- FALSE_REDEFINED_OP_FLAG |
- STRING_REDEFINED_OP_FLAG)) {
- st_data_t val;
- if (RB_FLOAT_TYPE_P(key)) {
- double kval = RFLOAT_VALUE(key);
- if (!isinf(kval) && modf(kval, &kval) == 0.0) {
- key = FIXABLE(kval) ? LONG2FIX((long)kval) : rb_dbl2big(kval);
- }
- }
+ if (BASIC_OP_UNREDEFINED_P(BOP_EQQ,
+ SYMBOL_REDEFINED_OP_FLAG |
+ INTEGER_REDEFINED_OP_FLAG |
+ FLOAT_REDEFINED_OP_FLAG |
+ NIL_REDEFINED_OP_FLAG |
+ TRUE_REDEFINED_OP_FLAG |
+ FALSE_REDEFINED_OP_FLAG |
+ STRING_REDEFINED_OP_FLAG)) {
+ st_data_t val;
+ if (RB_FLOAT_TYPE_P(key)) {
+ double kval = RFLOAT_VALUE(key);
+ if (!isinf(kval) && modf(kval, &kval) == 0.0) {
+ key = FIXABLE(kval) ? LONG2FIX((long)kval) : rb_dbl2big(kval);
+ }
+ }
if (rb_hash_stlike_lookup(hash, key, &val)) {
- return FIX2LONG((VALUE)val);
- }
- else {
- return else_offset;
- }
- }
+ return FIX2LONG((VALUE)val);
+ }
+ else {
+ return else_offset;
+ }
+ }
}
return 0;
}
NORETURN(static void
- vm_stack_consistency_error(const rb_execution_context_t *ec,
- const rb_control_frame_t *,
- const VALUE *));
+ vm_stack_consistency_error(const rb_execution_context_t *ec,
+ const rb_control_frame_t *,
+ const VALUE *));
static void
vm_stack_consistency_error(const rb_execution_context_t *ec,
- const rb_control_frame_t *cfp,
- const VALUE *bp)
+ const rb_control_frame_t *cfp,
+ const VALUE *bp)
{
const ptrdiff_t nsp = VM_SP_CNT(ec, cfp->sp);
const ptrdiff_t nbp = VM_SP_CNT(ec, bp);
static const char stack_consistency_error[] =
- "Stack consistency error (sp: %"PRIdPTRDIFF", bp: %"PRIdPTRDIFF")";
+ "Stack consistency error (sp: %"PRIdPTRDIFF", bp: %"PRIdPTRDIFF")";
#if defined RUBY_DEVEL
VALUE mesg = rb_sprintf(stack_consistency_error, nsp, nbp);
rb_str_cat_cstr(mesg, "\n");
@@ -5108,33 +5108,33 @@ static VALUE
vm_opt_plus(VALUE recv, VALUE obj)
{
if (FIXNUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_PLUS, INTEGER_REDEFINED_OP_FLAG)) {
- return rb_fix_plus_fix(recv, obj);
+ BASIC_OP_UNREDEFINED_P(BOP_PLUS, INTEGER_REDEFINED_OP_FLAG)) {
+ return rb_fix_plus_fix(recv, obj);
}
else if (FLONUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
- return DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
+ BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
+ return DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
}
else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cFloat &&
- RBASIC_CLASS(obj) == rb_cFloat &&
- BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
- return DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
+ RBASIC_CLASS(obj) == rb_cFloat &&
+ BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
+ return DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
}
else if (RBASIC_CLASS(recv) == rb_cString &&
- RBASIC_CLASS(obj) == rb_cString &&
- BASIC_OP_UNREDEFINED_P(BOP_PLUS, STRING_REDEFINED_OP_FLAG)) {
+ RBASIC_CLASS(obj) == rb_cString &&
+ BASIC_OP_UNREDEFINED_P(BOP_PLUS, STRING_REDEFINED_OP_FLAG)) {
return rb_str_opt_plus(recv, obj);
}
else if (RBASIC_CLASS(recv) == rb_cArray &&
RBASIC_CLASS(obj) == rb_cArray &&
- BASIC_OP_UNREDEFINED_P(BOP_PLUS, ARRAY_REDEFINED_OP_FLAG)) {
- return rb_ary_plus(recv, obj);
+ BASIC_OP_UNREDEFINED_P(BOP_PLUS, ARRAY_REDEFINED_OP_FLAG)) {
+ return rb_ary_plus(recv, obj);
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5142,23 +5142,23 @@ static VALUE
vm_opt_minus(VALUE recv, VALUE obj)
{
if (FIXNUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_MINUS, INTEGER_REDEFINED_OP_FLAG)) {
- return rb_fix_minus_fix(recv, obj);
+ BASIC_OP_UNREDEFINED_P(BOP_MINUS, INTEGER_REDEFINED_OP_FLAG)) {
+ return rb_fix_minus_fix(recv, obj);
}
else if (FLONUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) {
- return DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj));
+ BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) {
+ return DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj));
}
else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cFloat &&
- RBASIC_CLASS(obj) == rb_cFloat &&
- BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) {
- return DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj));
+ RBASIC_CLASS(obj) == rb_cFloat &&
+ BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) {
+ return DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj));
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5166,23 +5166,23 @@ static VALUE
vm_opt_mult(VALUE recv, VALUE obj)
{
if (FIXNUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_MULT, INTEGER_REDEFINED_OP_FLAG)) {
- return rb_fix_mul_fix(recv, obj);
+ BASIC_OP_UNREDEFINED_P(BOP_MULT, INTEGER_REDEFINED_OP_FLAG)) {
+ return rb_fix_mul_fix(recv, obj);
}
else if (FLONUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) {
- return DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj));
+ BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) {
+ return DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj));
}
else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cFloat &&
- RBASIC_CLASS(obj) == rb_cFloat &&
- BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) {
- return DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj));
+ RBASIC_CLASS(obj) == rb_cFloat &&
+ BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) {
+ return DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj));
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5190,23 +5190,23 @@ static VALUE
vm_opt_div(VALUE recv, VALUE obj)
{
if (FIXNUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_DIV, INTEGER_REDEFINED_OP_FLAG)) {
- return (FIX2LONG(obj) == 0) ? Qundef : rb_fix_div_fix(recv, obj);
+ BASIC_OP_UNREDEFINED_P(BOP_DIV, INTEGER_REDEFINED_OP_FLAG)) {
+ return (FIX2LONG(obj) == 0) ? Qundef : rb_fix_div_fix(recv, obj);
}
else if (FLONUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
+ BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
return rb_flo_div_flo(recv, obj);
}
else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cFloat &&
- RBASIC_CLASS(obj) == rb_cFloat &&
- BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
+ RBASIC_CLASS(obj) == rb_cFloat &&
+ BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
return rb_flo_div_flo(recv, obj);
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5214,23 +5214,23 @@ static VALUE
vm_opt_mod(VALUE recv, VALUE obj)
{
if (FIXNUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_MOD, INTEGER_REDEFINED_OP_FLAG)) {
- return (FIX2LONG(obj) == 0) ? Qundef : rb_fix_mod_fix(recv, obj);
+ BASIC_OP_UNREDEFINED_P(BOP_MOD, INTEGER_REDEFINED_OP_FLAG)) {
+ return (FIX2LONG(obj) == 0) ? Qundef : rb_fix_mod_fix(recv, obj);
}
else if (FLONUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) {
- return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)));
+ BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) {
+ return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)));
}
else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cFloat &&
- RBASIC_CLASS(obj) == rb_cFloat &&
- BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) {
- return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)));
+ RBASIC_CLASS(obj) == rb_cFloat &&
+ BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) {
+ return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)));
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5240,9 +5240,9 @@ vm_opt_neq(const rb_iseq_t *iseq, CALL_DATA cd, CALL_DATA cd_eq, VALUE recv, VAL
if (vm_method_cfunc_is(iseq, cd, recv, rb_obj_not_equal)) {
VALUE val = opt_equality(iseq, recv, obj, cd_eq);
- if (val != Qundef) {
- return RBOOL(!RTEST(val));
- }
+ if (val != Qundef) {
+ return RBOOL(!RTEST(val));
+ }
}
return Qundef;
@@ -5252,24 +5252,24 @@ static VALUE
vm_opt_lt(VALUE recv, VALUE obj)
{
if (FIXNUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_LT, INTEGER_REDEFINED_OP_FLAG)) {
- return RBOOL((SIGNED_VALUE)recv < (SIGNED_VALUE)obj);
+ BASIC_OP_UNREDEFINED_P(BOP_LT, INTEGER_REDEFINED_OP_FLAG)) {
+ return RBOOL((SIGNED_VALUE)recv < (SIGNED_VALUE)obj);
}
else if (FLONUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) {
- return RBOOL(RFLOAT_VALUE(recv) < RFLOAT_VALUE(obj));
+ BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) {
+ return RBOOL(RFLOAT_VALUE(recv) < RFLOAT_VALUE(obj));
}
else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cFloat &&
- RBASIC_CLASS(obj) == rb_cFloat &&
- BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) {
- CHECK_CMP_NAN(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj));
- return RBOOL(RFLOAT_VALUE(recv) < RFLOAT_VALUE(obj));
+ RBASIC_CLASS(obj) == rb_cFloat &&
+ BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) {
+ CHECK_CMP_NAN(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj));
+ return RBOOL(RFLOAT_VALUE(recv) < RFLOAT_VALUE(obj));
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5277,24 +5277,24 @@ static VALUE
vm_opt_le(VALUE recv, VALUE obj)
{
if (FIXNUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_LE, INTEGER_REDEFINED_OP_FLAG)) {
- return RBOOL((SIGNED_VALUE)recv <= (SIGNED_VALUE)obj);
+ BASIC_OP_UNREDEFINED_P(BOP_LE, INTEGER_REDEFINED_OP_FLAG)) {
+ return RBOOL((SIGNED_VALUE)recv <= (SIGNED_VALUE)obj);
}
else if (FLONUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) {
- return RBOOL(RFLOAT_VALUE(recv) <= RFLOAT_VALUE(obj));
+ BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) {
+ return RBOOL(RFLOAT_VALUE(recv) <= RFLOAT_VALUE(obj));
}
else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cFloat &&
- RBASIC_CLASS(obj) == rb_cFloat &&
- BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) {
- CHECK_CMP_NAN(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj));
- return RBOOL(RFLOAT_VALUE(recv) <= RFLOAT_VALUE(obj));
+ RBASIC_CLASS(obj) == rb_cFloat &&
+ BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) {
+ CHECK_CMP_NAN(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj));
+ return RBOOL(RFLOAT_VALUE(recv) <= RFLOAT_VALUE(obj));
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5302,24 +5302,24 @@ static VALUE
vm_opt_gt(VALUE recv, VALUE obj)
{
if (FIXNUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_GT, INTEGER_REDEFINED_OP_FLAG)) {
- return RBOOL((SIGNED_VALUE)recv > (SIGNED_VALUE)obj);
+ BASIC_OP_UNREDEFINED_P(BOP_GT, INTEGER_REDEFINED_OP_FLAG)) {
+ return RBOOL((SIGNED_VALUE)recv > (SIGNED_VALUE)obj);
}
else if (FLONUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) {
- return RBOOL(RFLOAT_VALUE(recv) > RFLOAT_VALUE(obj));
+ BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) {
+ return RBOOL(RFLOAT_VALUE(recv) > RFLOAT_VALUE(obj));
}
else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cFloat &&
- RBASIC_CLASS(obj) == rb_cFloat &&
- BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) {
- CHECK_CMP_NAN(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj));
- return RBOOL(RFLOAT_VALUE(recv) > RFLOAT_VALUE(obj));
+ RBASIC_CLASS(obj) == rb_cFloat &&
+ BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) {
+ CHECK_CMP_NAN(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj));
+ return RBOOL(RFLOAT_VALUE(recv) > RFLOAT_VALUE(obj));
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5327,24 +5327,24 @@ static VALUE
vm_opt_ge(VALUE recv, VALUE obj)
{
if (FIXNUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_GE, INTEGER_REDEFINED_OP_FLAG)) {
- return RBOOL((SIGNED_VALUE)recv >= (SIGNED_VALUE)obj);
+ BASIC_OP_UNREDEFINED_P(BOP_GE, INTEGER_REDEFINED_OP_FLAG)) {
+ return RBOOL((SIGNED_VALUE)recv >= (SIGNED_VALUE)obj);
}
else if (FLONUM_2_P(recv, obj) &&
- BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) {
- return RBOOL(RFLOAT_VALUE(recv) >= RFLOAT_VALUE(obj));
+ BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) {
+ return RBOOL(RFLOAT_VALUE(recv) >= RFLOAT_VALUE(obj));
}
else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cFloat &&
- RBASIC_CLASS(obj) == rb_cFloat &&
- BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) {
- CHECK_CMP_NAN(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj));
- return RBOOL(RFLOAT_VALUE(recv) >= RFLOAT_VALUE(obj));
+ RBASIC_CLASS(obj) == rb_cFloat &&
+ BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) {
+ CHECK_CMP_NAN(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj));
+ return RBOOL(RFLOAT_VALUE(recv) >= RFLOAT_VALUE(obj));
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5353,22 +5353,22 @@ static VALUE
vm_opt_ltlt(VALUE recv, VALUE obj)
{
if (SPECIAL_CONST_P(recv)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cString &&
- BASIC_OP_UNREDEFINED_P(BOP_LTLT, STRING_REDEFINED_OP_FLAG)) {
- if (LIKELY(RB_TYPE_P(obj, T_STRING))) {
- return rb_str_buf_append(recv, obj);
- } else {
- return rb_str_concat(recv, obj);
- }
+ BASIC_OP_UNREDEFINED_P(BOP_LTLT, STRING_REDEFINED_OP_FLAG)) {
+ if (LIKELY(RB_TYPE_P(obj, T_STRING))) {
+ return rb_str_buf_append(recv, obj);
+ } else {
+ return rb_str_concat(recv, obj);
+ }
}
else if (RBASIC_CLASS(recv) == rb_cArray &&
- BASIC_OP_UNREDEFINED_P(BOP_LTLT, ARRAY_REDEFINED_OP_FLAG)) {
- return rb_ary_push(recv, obj);
+ BASIC_OP_UNREDEFINED_P(BOP_LTLT, ARRAY_REDEFINED_OP_FLAG)) {
+ return rb_ary_push(recv, obj);
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5410,10 +5410,10 @@ vm_opt_aref(VALUE recv, VALUE obj)
BASIC_OP_UNREDEFINED_P(BOP_AREF, INTEGER_REDEFINED_OP_FLAG)) {
return rb_fix_aref(recv, obj);
}
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cArray &&
- BASIC_OP_UNREDEFINED_P(BOP_AREF, ARRAY_REDEFINED_OP_FLAG)) {
+ BASIC_OP_UNREDEFINED_P(BOP_AREF, ARRAY_REDEFINED_OP_FLAG)) {
if (FIXNUM_P(obj)) {
return rb_ary_entry_internal(recv, FIX2LONG(obj));
}
@@ -5422,11 +5422,11 @@ vm_opt_aref(VALUE recv, VALUE obj)
}
}
else if (RBASIC_CLASS(recv) == rb_cHash &&
- BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG)) {
- return rb_hash_aref(recv, obj);
+ BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG)) {
+ return rb_hash_aref(recv, obj);
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5434,21 +5434,21 @@ static VALUE
vm_opt_aset(VALUE recv, VALUE obj, VALUE set)
{
if (SPECIAL_CONST_P(recv)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cArray &&
- BASIC_OP_UNREDEFINED_P(BOP_ASET, ARRAY_REDEFINED_OP_FLAG) &&
- FIXNUM_P(obj)) {
- rb_ary_store(recv, FIX2LONG(obj), set);
- return set;
+ BASIC_OP_UNREDEFINED_P(BOP_ASET, ARRAY_REDEFINED_OP_FLAG) &&
+ FIXNUM_P(obj)) {
+ rb_ary_store(recv, FIX2LONG(obj), set);
+ return set;
}
else if (RBASIC_CLASS(recv) == rb_cHash &&
- BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG)) {
- rb_hash_aset(recv, obj, set);
- return set;
+ BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG)) {
+ rb_hash_aset(recv, obj, set);
+ return set;
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5456,12 +5456,12 @@ static VALUE
vm_opt_aref_with(VALUE recv, VALUE key)
{
if (!SPECIAL_CONST_P(recv) && RBASIC_CLASS(recv) == rb_cHash &&
- BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG) &&
- rb_hash_compare_by_id_p(recv) == Qfalse) {
- return rb_hash_aref(recv, key);
+ BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG) &&
+ rb_hash_compare_by_id_p(recv) == Qfalse) {
+ return rb_hash_aref(recv, key);
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5469,12 +5469,12 @@ static VALUE
vm_opt_aset_with(VALUE recv, VALUE key, VALUE val)
{
if (!SPECIAL_CONST_P(recv) && RBASIC_CLASS(recv) == rb_cHash &&
- BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG) &&
- rb_hash_compare_by_id_p(recv) == Qfalse) {
- return rb_hash_aset(recv, key, val);
+ BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG) &&
+ rb_hash_compare_by_id_p(recv) == Qfalse) {
+ return rb_hash_aset(recv, key, val);
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5482,27 +5482,27 @@ static VALUE
vm_opt_length(VALUE recv, int bop)
{
if (SPECIAL_CONST_P(recv)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cString &&
- BASIC_OP_UNREDEFINED_P(bop, STRING_REDEFINED_OP_FLAG)) {
- if (bop == BOP_EMPTY_P) {
- return LONG2NUM(RSTRING_LEN(recv));
- }
- else {
- return rb_str_length(recv);
- }
+ BASIC_OP_UNREDEFINED_P(bop, STRING_REDEFINED_OP_FLAG)) {
+ if (bop == BOP_EMPTY_P) {
+ return LONG2NUM(RSTRING_LEN(recv));
+ }
+ else {
+ return rb_str_length(recv);
+ }
}
else if (RBASIC_CLASS(recv) == rb_cArray &&
- BASIC_OP_UNREDEFINED_P(bop, ARRAY_REDEFINED_OP_FLAG)) {
- return LONG2NUM(RARRAY_LEN(recv));
+ BASIC_OP_UNREDEFINED_P(bop, ARRAY_REDEFINED_OP_FLAG)) {
+ return LONG2NUM(RARRAY_LEN(recv));
}
else if (RBASIC_CLASS(recv) == rb_cHash &&
- BASIC_OP_UNREDEFINED_P(bop, HASH_REDEFINED_OP_FLAG)) {
- return INT2FIX(RHASH_SIZE(recv));
+ BASIC_OP_UNREDEFINED_P(bop, HASH_REDEFINED_OP_FLAG)) {
+ return INT2FIX(RHASH_SIZE(recv));
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5565,18 +5565,18 @@ static VALUE
vm_opt_succ(VALUE recv)
{
if (FIXNUM_P(recv) &&
- BASIC_OP_UNREDEFINED_P(BOP_SUCC, INTEGER_REDEFINED_OP_FLAG)) {
+ BASIC_OP_UNREDEFINED_P(BOP_SUCC, INTEGER_REDEFINED_OP_FLAG)) {
return fix_succ(recv);
}
else if (SPECIAL_CONST_P(recv)) {
- return Qundef;
+ return Qundef;
}
else if (RBASIC_CLASS(recv) == rb_cString &&
- BASIC_OP_UNREDEFINED_P(BOP_SUCC, STRING_REDEFINED_OP_FLAG)) {
- return rb_str_succ(recv);
+ BASIC_OP_UNREDEFINED_P(BOP_SUCC, STRING_REDEFINED_OP_FLAG)) {
+ return rb_str_succ(recv);
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5584,10 +5584,10 @@ static VALUE
vm_opt_not(const rb_iseq_t *iseq, CALL_DATA cd, VALUE recv)
{
if (vm_method_cfunc_is(iseq, cd, recv, rb_obj_not)) {
- return RBOOL(!RTEST(recv));
+ return RBOOL(!RTEST(recv));
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5599,15 +5599,15 @@ vm_opt_regexpmatch2(VALUE recv, VALUE obj)
}
else if (RBASIC_CLASS(recv) == rb_cString &&
CLASS_OF(obj) == rb_cRegexp &&
- BASIC_OP_UNREDEFINED_P(BOP_MATCH, STRING_REDEFINED_OP_FLAG)) {
- return rb_reg_match(obj, recv);
+ BASIC_OP_UNREDEFINED_P(BOP_MATCH, STRING_REDEFINED_OP_FLAG)) {
+ return rb_reg_match(obj, recv);
}
else if (RBASIC_CLASS(recv) == rb_cRegexp &&
BASIC_OP_UNREDEFINED_P(BOP_MATCH, REGEXP_REDEFINED_OP_FLAG)) {
- return rb_reg_match(recv, obj);
+ return rb_reg_match(recv, obj);
}
else {
- return Qundef;
+ return Qundef;
}
}
@@ -5678,7 +5678,7 @@ vm_trace(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp)
return;
}
else {
- const rb_iseq_t *iseq = reg_cfp->iseq;
+ const rb_iseq_t *iseq = reg_cfp->iseq;
VALUE iseq_val = (VALUE)iseq;
size_t pos = pc - ISEQ_BODY(iseq)->iseq_encoded;
rb_event_flag_t pc_events = rb_iseq_event_flags(iseq, pos);
@@ -5706,15 +5706,15 @@ vm_trace(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp)
if ((pc_events & enabled_flags) == 0 && !bmethod_frame) {
#if 0
- /* disable trace */
+ /* disable trace */
/* TODO: incomplete */
- rb_iseq_trace_set(iseq, vm_event_flags & ISEQ_TRACE_EVENTS);
+ rb_iseq_trace_set(iseq, vm_event_flags & ISEQ_TRACE_EVENTS);
#else
- /* do not disable trace because of performance problem
- * (re-enable overhead)
- */
+ /* do not disable trace because of performance problem
+ * (re-enable overhead)
+ */
#endif
- return;
+ return;
}
else if (ec->trace_arg != NULL) {
/* already tracing */
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-14 07:50:30 +0000