summaryrefslogtreecommitdiff
path: root/vm_args.c
diff options
context:
space:
mode:
Diffstat (limited to 'vm_args.c')
-rw-r--r--vm_args.c951
1 files changed, 538 insertions, 413 deletions
diff --git a/vm_args.c b/vm_args.c
index 9ee2832ad1..9df175eaa9 100644
--- a/vm_args.c
+++ b/vm_args.c
@@ -14,9 +14,6 @@ NORETURN(static void argument_kw_error(rb_execution_context_t *ec, const rb_iseq
VALUE rb_keyword_error_new(const char *error, VALUE keys); /* class.c */
static VALUE method_missing(rb_execution_context_t *ec, VALUE obj, ID id, int argc, const VALUE *argv,
enum method_missing_reason call_status, int kw_splat);
-#if !defined(_MSC_VER) || !defined(MJIT_HEADER)
-MJIT_FUNC_EXPORTED
-#endif
const rb_callable_method_entry_t *rb_resolve_refined_method_callable(VALUE refinements, const rb_callable_method_entry_t *me);
struct args_info {
@@ -50,10 +47,10 @@ static inline int
args_argc(struct args_info *args)
{
if (args->rest == Qfalse) {
- return args->argc;
+ return args->argc;
}
else {
- return args->argc + RARRAY_LENINT(args->rest) - args->rest_index;
+ return args->argc + RARRAY_LENINT(args->rest) - args->rest_index;
}
}
@@ -64,15 +61,15 @@ args_extend(struct args_info *args, const int min_argc)
if (args->rest) {
arg_rest_dup(args);
- VM_ASSERT(args->rest_index == 0);
- for (i=args->argc + RARRAY_LENINT(args->rest); i<min_argc; i++) {
- rb_ary_push(args->rest, Qnil);
- }
+ VM_ASSERT(args->rest_index == 0);
+ for (i=args->argc + RARRAY_LENINT(args->rest); i<min_argc; i++) {
+ rb_ary_push(args->rest, Qnil);
+ }
}
else {
- for (i=args->argc; i<min_argc; i++) {
- args->argv[args->argc++] = Qnil;
- }
+ for (i=args->argc; i<min_argc; i++) {
+ args->argv[args->argc++] = Qnil;
+ }
}
}
@@ -80,17 +77,17 @@ static inline void
args_reduce(struct args_info *args, int over_argc)
{
if (args->rest) {
- const long len = RARRAY_LEN(args->rest);
+ const long len = RARRAY_LEN(args->rest);
- if (len > over_argc) {
- arg_rest_dup(args);
- rb_ary_resize(args->rest, len - over_argc);
- return;
- }
- else {
- args->rest = Qfalse;
- over_argc -= len;
- }
+ if (len > over_argc) {
+ arg_rest_dup(args);
+ rb_ary_resize(args->rest, len - over_argc);
+ return;
+ }
+ else {
+ args->rest = Qfalse;
+ over_argc -= len;
+ }
}
VM_ASSERT(args->argc >= over_argc);
@@ -103,20 +100,20 @@ args_check_block_arg0(struct args_info *args)
VALUE ary = Qnil;
if (args->rest && RARRAY_LEN(args->rest) == 1) {
- VALUE arg0 = RARRAY_AREF(args->rest, 0);
- ary = rb_check_array_type(arg0);
+ VALUE arg0 = RARRAY_AREF(args->rest, 0);
+ ary = rb_check_array_type(arg0);
}
else if (args->argc == 1) {
- VALUE arg0 = args->argv[0];
- ary = rb_check_array_type(arg0);
- args->argv[0] = arg0; /* see: https://bugs.ruby-lang.org/issues/8484 */
+ VALUE arg0 = args->argv[0];
+ ary = rb_check_array_type(arg0);
+ args->argv[0] = arg0; /* see: https://bugs.ruby-lang.org/issues/8484 */
}
if (!NIL_P(ary)) {
- args->rest = ary;
- args->rest_index = 0;
- args->argc = 0;
- return TRUE;
+ args->rest = ary;
+ args->rest_index = 0;
+ args->argc = 0;
+ return TRUE;
}
return FALSE;
@@ -126,49 +123,49 @@ static inline void
args_copy(struct args_info *args)
{
if (args->rest != Qfalse) {
- int argc = args->argc;
- args->argc = 0;
+ int argc = args->argc;
+ args->argc = 0;
arg_rest_dup(args);
- /*
- * argv: [m0, m1, m2, m3]
- * rest: [a0, a1, a2, a3, a4, a5]
- * ^
- * rest_index
- *
- * #=> first loop
- *
- * argv: [m0, m1]
- * rest: [m2, m3, a2, a3, a4, a5]
- * ^
- * rest_index
- *
- * #=> 2nd loop
- *
- * argv: [] (argc == 0)
- * rest: [m0, m1, m2, m3, a2, a3, a4, a5]
- * ^
- * rest_index
- */
- while (args->rest_index > 0 && argc > 0) {
- RARRAY_ASET(args->rest, --args->rest_index, args->argv[--argc]);
- }
- while (argc > 0) {
- rb_ary_unshift(args->rest, args->argv[--argc]);
- }
+ /*
+ * argv: [m0, m1, m2, m3]
+ * rest: [a0, a1, a2, a3, a4, a5]
+ * ^
+ * rest_index
+ *
+ * #=> first loop
+ *
+ * argv: [m0, m1]
+ * rest: [m2, m3, a2, a3, a4, a5]
+ * ^
+ * rest_index
+ *
+ * #=> 2nd loop
+ *
+ * argv: [] (argc == 0)
+ * rest: [m0, m1, m2, m3, a2, a3, a4, a5]
+ * ^
+ * rest_index
+ */
+ while (args->rest_index > 0 && argc > 0) {
+ RARRAY_ASET(args->rest, --args->rest_index, args->argv[--argc]);
+ }
+ while (argc > 0) {
+ rb_ary_unshift(args->rest, args->argv[--argc]);
+ }
}
else if (args->argc > 0) {
- args->rest = rb_ary_new_from_values(args->argc, args->argv);
- args->rest_index = 0;
+ args->rest = rb_ary_new_from_values(args->argc, args->argv);
+ args->rest_index = 0;
args->rest_dupped = TRUE;
- args->argc = 0;
+ args->argc = 0;
}
}
static inline const VALUE *
args_rest_argv(struct args_info *args)
{
- return RARRAY_CONST_PTR_TRANSIENT(args->rest) + args->rest_index;
+ return RARRAY_CONST_PTR(args->rest) + args->rest_index;
}
static inline VALUE
@@ -179,10 +176,10 @@ args_rest_array(struct args_info *args)
if (args->rest) {
ary = rb_ary_behead(args->rest, args->rest_index);
args->rest_index = 0;
- args->rest = 0;
+ args->rest = 0;
}
else {
- ary = rb_ary_new();
+ ary = rb_ary_new();
}
return ary;
}
@@ -200,7 +197,7 @@ args_kw_argv_to_hash(struct args_info *args)
args->argc = kw_start + 1;
for (i=0; i<kw_len; i++) {
- rb_hash_aset(h, passed_keywords[i], kw_argv[i]);
+ rb_hash_aset(h, passed_keywords[i], kw_argv[i]);
}
args->argv[args->argc - 1] = h;
@@ -212,19 +209,19 @@ static inline void
args_setup_lead_parameters(struct args_info *args, int argc, VALUE *locals)
{
if (args->argc >= argc) {
- /* do noting */
- args->argc -= argc;
- args->argv += argc;
+ /* do noting */
+ args->argc -= argc;
+ args->argv += argc;
}
else {
- int i, j;
- const VALUE *argv = args_rest_argv(args);
+ int i, j;
+ const VALUE *argv = args_rest_argv(args);
- for (i=args->argc, j=0; i<argc; i++, j++) {
- locals[i] = argv[j];
- }
- args->rest_index += argc - args->argc;
- args->argc = 0;
+ for (i=args->argc, j=0; i<argc; i++, j++) {
+ locals[i] = argv[j];
+ }
+ args->rest_index += argc - args->argc;
+ args->argc = 0;
}
}
@@ -233,7 +230,7 @@ args_setup_post_parameters(struct args_info *args, int argc, VALUE *locals)
{
long len;
len = RARRAY_LEN(args->rest);
- MEMCPY(locals, RARRAY_CONST_PTR_TRANSIENT(args->rest) + len - argc, VALUE, argc);
+ MEMCPY(locals, RARRAY_CONST_PTR(args->rest) + len - argc, VALUE, argc);
rb_ary_resize(args->rest, len - argc);
}
@@ -243,28 +240,28 @@ args_setup_opt_parameters(struct args_info *args, int opt_max, VALUE *locals)
int i;
if (args->argc >= opt_max) {
- args->argc -= opt_max;
- args->argv += opt_max;
- i = opt_max;
+ args->argc -= opt_max;
+ args->argv += opt_max;
+ i = opt_max;
}
else {
- int j;
- i = args->argc;
- args->argc = 0;
+ int j;
+ i = args->argc;
+ args->argc = 0;
- if (args->rest) {
+ if (args->rest) {
int len = RARRAY_LENINT(args->rest);
- const VALUE *argv = RARRAY_CONST_PTR_TRANSIENT(args->rest);
+ const VALUE *argv = RARRAY_CONST_PTR(args->rest);
for (; i<opt_max && args->rest_index < len; i++, args->rest_index++) {
locals[i] = argv[args->rest_index];
}
}
- /* initialize by nil */
- for (j=i; j<opt_max; j++) {
- locals[j] = Qnil;
- }
+ /* initialize by nil */
+ for (j=i; j<opt_max; j++) {
+ locals[j] = Qnil;
+ }
}
return i;
@@ -280,12 +277,12 @@ static VALUE
make_unknown_kw_hash(const VALUE *passed_keywords, int passed_keyword_len, const VALUE *kw_argv)
{
int i;
- VALUE obj = rb_ary_tmp_new(1);
+ VALUE obj = rb_ary_hidden_new(1);
for (i=0; i<passed_keyword_len; i++) {
- if (kw_argv[i] != Qundef) {
- rb_ary_push(obj, passed_keywords[i]);
- }
+ if (!UNDEF_P(kw_argv[i])) {
+ rb_ary_push(obj, passed_keywords[i]);
+ }
}
return obj;
}
@@ -297,9 +294,9 @@ make_rest_kw_hash(const VALUE *passed_keywords, int passed_keyword_len, const VA
VALUE obj = rb_hash_new_with_size(passed_keyword_len);
for (i=0; i<passed_keyword_len; i++) {
- if (kw_argv[i] != Qundef) {
- rb_hash_aset(obj, passed_keywords[i], kw_argv[i]);
- }
+ if (!UNDEF_P(kw_argv[i])) {
+ rb_hash_aset(obj, passed_keywords[i], kw_argv[i]);
+ }
}
return obj;
}
@@ -311,11 +308,11 @@ args_setup_kw_parameters_lookup(const ID key, VALUE *ptr, const VALUE *const pas
const VALUE keyname = ID2SYM(key);
for (i=0; i<passed_keyword_len; i++) {
- if (keyname == passed_keywords[i]) {
- *ptr = passed_values[i];
- passed_values[i] = Qundef;
- return TRUE;
- }
+ if (keyname == passed_keywords[i]) {
+ *ptr = passed_values[i];
+ passed_values[i] = Qundef;
+ return TRUE;
+ }
}
return FALSE;
@@ -325,85 +322,190 @@ args_setup_kw_parameters_lookup(const ID key, VALUE *ptr, const VALUE *const pas
static void
args_setup_kw_parameters(rb_execution_context_t *const ec, const rb_iseq_t *const iseq,
- VALUE *const passed_values, const int passed_keyword_len, const VALUE *const passed_keywords,
- VALUE *const locals)
+ VALUE *const passed_values, const int passed_keyword_len, const VALUE *const passed_keywords,
+ VALUE *const locals)
{
- const ID *acceptable_keywords = iseq->body->param.keyword->table;
- const int req_key_num = iseq->body->param.keyword->required_num;
- const int key_num = iseq->body->param.keyword->num;
- const VALUE * const default_values = iseq->body->param.keyword->default_values;
+ const ID *acceptable_keywords = ISEQ_BODY(iseq)->param.keyword->table;
+ const int req_key_num = ISEQ_BODY(iseq)->param.keyword->required_num;
+ const int key_num = ISEQ_BODY(iseq)->param.keyword->num;
+ const VALUE * const default_values = ISEQ_BODY(iseq)->param.keyword->default_values;
VALUE missing = 0;
int i, di, found = 0;
int unspecified_bits = 0;
VALUE unspecified_bits_value = Qnil;
for (i=0; i<req_key_num; i++) {
- ID key = acceptable_keywords[i];
- if (args_setup_kw_parameters_lookup(key, &locals[i], passed_keywords, passed_values, passed_keyword_len)) {
- found++;
- }
- else {
- if (!missing) missing = rb_ary_tmp_new(1);
- rb_ary_push(missing, ID2SYM(key));
- }
+ ID key = acceptable_keywords[i];
+ if (args_setup_kw_parameters_lookup(key, &locals[i], passed_keywords, passed_values, passed_keyword_len)) {
+ found++;
+ }
+ else {
+ if (!missing) missing = rb_ary_hidden_new(1);
+ rb_ary_push(missing, ID2SYM(key));
+ }
}
if (missing) argument_kw_error(ec, iseq, "missing", missing);
for (di=0; i<key_num; i++, di++) {
- if (args_setup_kw_parameters_lookup(acceptable_keywords[i], &locals[i], passed_keywords, passed_values, passed_keyword_len)) {
- found++;
- }
- else {
- if (default_values[di] == Qundef) {
- locals[i] = Qnil;
-
- if (LIKELY(i < KW_SPECIFIED_BITS_MAX)) {
- unspecified_bits |= 0x01 << di;
- }
- else {
- if (NIL_P(unspecified_bits_value)) {
- /* fixnum -> hash */
- int j;
- unspecified_bits_value = rb_hash_new();
-
- for (j=0; j<KW_SPECIFIED_BITS_MAX; j++) {
- if (unspecified_bits & (0x01 << j)) {
- rb_hash_aset(unspecified_bits_value, INT2FIX(j), Qtrue);
- }
- }
- }
- rb_hash_aset(unspecified_bits_value, INT2FIX(di), Qtrue);
- }
- }
- else {
- locals[i] = default_values[di];
- }
- }
- }
-
- if (iseq->body->param.flags.has_kwrest) {
- const int rest_hash_index = key_num + 1;
- locals[rest_hash_index] = make_rest_kw_hash(passed_keywords, passed_keyword_len, passed_values);
+ if (args_setup_kw_parameters_lookup(acceptable_keywords[i], &locals[i], passed_keywords, passed_values, passed_keyword_len)) {
+ found++;
+ }
+ else {
+ if (UNDEF_P(default_values[di])) {
+ locals[i] = Qnil;
+
+ if (LIKELY(i < KW_SPECIFIED_BITS_MAX)) {
+ unspecified_bits |= 0x01 << di;
+ }
+ else {
+ if (NIL_P(unspecified_bits_value)) {
+ /* fixnum -> hash */
+ int j;
+ unspecified_bits_value = rb_hash_new();
+
+ for (j=0; j<KW_SPECIFIED_BITS_MAX; j++) {
+ if (unspecified_bits & (0x01 << j)) {
+ rb_hash_aset(unspecified_bits_value, INT2FIX(j), Qtrue);
+ }
+ }
+ }
+ rb_hash_aset(unspecified_bits_value, INT2FIX(di), Qtrue);
+ }
+ }
+ else {
+ locals[i] = default_values[di];
+ }
+ }
+ }
+
+ if (ISEQ_BODY(iseq)->param.flags.has_kwrest) {
+ const int rest_hash_index = key_num + 1;
+ locals[rest_hash_index] = make_rest_kw_hash(passed_keywords, passed_keyword_len, passed_values);
}
else {
- if (found != passed_keyword_len) {
- VALUE keys = make_unknown_kw_hash(passed_keywords, passed_keyword_len, passed_values);
- argument_kw_error(ec, iseq, "unknown", keys);
- }
+ if (found != passed_keyword_len) {
+ VALUE keys = make_unknown_kw_hash(passed_keywords, passed_keyword_len, passed_values);
+ argument_kw_error(ec, iseq, "unknown", keys);
+ }
}
if (NIL_P(unspecified_bits_value)) {
- unspecified_bits_value = INT2FIX(unspecified_bits);
+ unspecified_bits_value = INT2FIX(unspecified_bits);
+ }
+ locals[key_num] = unspecified_bits_value;
+}
+
+static void
+args_setup_kw_parameters_from_kwsplat(rb_execution_context_t *const ec, const rb_iseq_t *const iseq,
+ VALUE keyword_hash, VALUE *const locals, bool remove_hash_value)
+{
+ const ID *acceptable_keywords = ISEQ_BODY(iseq)->param.keyword->table;
+ const int req_key_num = ISEQ_BODY(iseq)->param.keyword->required_num;
+ const int key_num = ISEQ_BODY(iseq)->param.keyword->num;
+ const VALUE * const default_values = ISEQ_BODY(iseq)->param.keyword->default_values;
+ VALUE missing = 0;
+ int i, di;
+ int unspecified_bits = 0;
+ size_t keyword_size = RHASH_SIZE(keyword_hash);
+ VALUE unspecified_bits_value = Qnil;
+
+ for (i=0; i<req_key_num; i++) {
+ VALUE key = ID2SYM(acceptable_keywords[i]);
+ VALUE value;
+ if (remove_hash_value) {
+ value = rb_hash_delete_entry(keyword_hash, key);
+ }
+ else {
+ value = rb_hash_lookup2(keyword_hash, key, Qundef);
+ }
+
+ if (!UNDEF_P(value)) {
+ keyword_size--;
+ locals[i] = value;
+ }
+ else {
+ if (!missing) missing = rb_ary_hidden_new(1);
+ rb_ary_push(missing, key);
+ }
+ }
+
+ if (missing) argument_kw_error(ec, iseq, "missing", missing);
+
+ for (di=0; i<key_num; i++, di++) {
+ VALUE key = ID2SYM(acceptable_keywords[i]);
+ VALUE value;
+ if (remove_hash_value) {
+ value = rb_hash_delete_entry(keyword_hash, key);
+ }
+ else {
+ value = rb_hash_lookup2(keyword_hash, key, Qundef);
+ }
+
+ if (!UNDEF_P(value)) {
+ keyword_size--;
+ locals[i] = value;
+ }
+ else {
+ if (UNDEF_P(default_values[di])) {
+ locals[i] = Qnil;
+
+ if (LIKELY(i < KW_SPECIFIED_BITS_MAX)) {
+ unspecified_bits |= 0x01 << di;
+ }
+ else {
+ if (NIL_P(unspecified_bits_value)) {
+ /* fixnum -> hash */
+ int j;
+ unspecified_bits_value = rb_hash_new();
+
+ for (j=0; j<KW_SPECIFIED_BITS_MAX; j++) {
+ if (unspecified_bits & (0x01 << j)) {
+ rb_hash_aset(unspecified_bits_value, INT2FIX(j), Qtrue);
+ }
+ }
+ }
+ rb_hash_aset(unspecified_bits_value, INT2FIX(di), Qtrue);
+ }
+ }
+ else {
+ locals[i] = default_values[di];
+ }
+ }
+ }
+
+ if (ISEQ_BODY(iseq)->param.flags.has_kwrest) {
+ const int rest_hash_index = key_num + 1;
+ locals[rest_hash_index] = keyword_hash;
+ }
+ else {
+ if (!remove_hash_value) {
+ if (keyword_size != 0) {
+ /* Recurse with duplicated keyword hash in remove mode.
+ * This is simpler than writing code to check which entries in the hash do not match.
+ * This will raise an exception, so the additional performance impact shouldn't be material.
+ */
+ args_setup_kw_parameters_from_kwsplat(ec, iseq, rb_hash_dup(keyword_hash), locals, true);
+ }
+ }
+ else if (!RHASH_EMPTY_P(keyword_hash)) {
+ argument_kw_error(ec, iseq, "unknown", rb_hash_keys(keyword_hash));
+ }
+ }
+
+ if (NIL_P(unspecified_bits_value)) {
+ unspecified_bits_value = INT2FIX(unspecified_bits);
}
locals[key_num] = unspecified_bits_value;
}
static inline void
-args_setup_kw_rest_parameter(VALUE keyword_hash, VALUE *locals, int kw_flag)
+args_setup_kw_rest_parameter(VALUE keyword_hash, VALUE *locals, int kw_flag, bool anon_kwrest)
{
if (NIL_P(keyword_hash)) {
- keyword_hash = rb_hash_new();
+ if (!anon_kwrest) {
+ keyword_hash = rb_hash_new();
+ }
}
else if (!(kw_flag & VM_CALL_KW_SPLAT_MUT)) {
keyword_hash = rb_hash_dup(keyword_hash);
@@ -418,57 +520,66 @@ args_setup_block_parameter(const rb_execution_context_t *ec, struct rb_calling_i
*locals = rb_vm_bh_to_procval(ec, block_handler);
}
-struct fill_values_arg {
- VALUE *keys;
- VALUE *vals;
- int argc;
-};
-
-static int
-fill_keys_values(st_data_t key, st_data_t val, st_data_t ptr)
-{
- struct fill_values_arg *arg = (struct fill_values_arg *)ptr;
- int i = arg->argc++;
- arg->keys[i] = (VALUE)key;
- arg->vals[i] = (VALUE)val;
- return ST_CONTINUE;
-}
-
static inline int
ignore_keyword_hash_p(VALUE keyword_hash, const rb_iseq_t * const iseq, unsigned int * kw_flag, VALUE * converted_keyword_hash)
{
+ if (keyword_hash == Qnil) {
+ return 1;
+ }
+
if (!RB_TYPE_P(keyword_hash, T_HASH)) {
keyword_hash = rb_to_hash_type(keyword_hash);
}
+ else if (UNLIKELY(ISEQ_BODY(iseq)->param.flags.anon_kwrest)) {
+ if (!ISEQ_BODY(iseq)->param.flags.has_kw) {
+ *kw_flag |= VM_CALL_KW_SPLAT_MUT;
+ }
+ }
+
if (!(*kw_flag & VM_CALL_KW_SPLAT_MUT) &&
- (iseq->body->param.flags.has_kwrest ||
- iseq->body->param.flags.ruby2_keywords)) {
+ (ISEQ_BODY(iseq)->param.flags.has_kwrest ||
+ ISEQ_BODY(iseq)->param.flags.ruby2_keywords)) {
*kw_flag |= VM_CALL_KW_SPLAT_MUT;
keyword_hash = rb_hash_dup(keyword_hash);
}
*converted_keyword_hash = keyword_hash;
- return !(iseq->body->param.flags.has_kw) &&
- !(iseq->body->param.flags.has_kwrest) &&
+ return !(ISEQ_BODY(iseq)->param.flags.has_kw) &&
+ !(ISEQ_BODY(iseq)->param.flags.has_kwrest) &&
RHASH_EMPTY_P(keyword_hash);
}
+static VALUE
+check_kwrestarg(VALUE keyword_hash, unsigned int *kw_flag)
+{
+ if (!(*kw_flag & VM_CALL_KW_SPLAT_MUT)) {
+ *kw_flag |= VM_CALL_KW_SPLAT_MUT;
+ return rb_hash_dup(keyword_hash);
+ }
+ else {
+ return keyword_hash;
+ }
+}
+
static int
setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * const iseq,
- struct rb_calling_info *const calling,
+ struct rb_calling_info *const calling,
const struct rb_callinfo *ci,
VALUE * const locals, const enum arg_setup_type arg_setup_type)
{
- const int min_argc = iseq->body->param.lead_num + iseq->body->param.post_num;
- const int max_argc = (iseq->body->param.flags.has_rest == FALSE) ? min_argc + iseq->body->param.opt_num : UNLIMITED_ARGUMENTS;
+ const int min_argc = ISEQ_BODY(iseq)->param.lead_num + ISEQ_BODY(iseq)->param.post_num;
+ const int max_argc = (ISEQ_BODY(iseq)->param.flags.has_rest == FALSE) ? min_argc + ISEQ_BODY(iseq)->param.opt_num : UNLIMITED_ARGUMENTS;
int given_argc;
- unsigned int kw_flag = vm_ci_flag(ci) & (VM_CALL_KWARG | VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT);
+ unsigned int ci_flag = vm_ci_flag(ci);
+ unsigned int kw_flag = ci_flag & (VM_CALL_KWARG | VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT);
int opt_pc = 0, allow_autosplat = !kw_flag;
struct args_info args_body, *args;
VALUE keyword_hash = Qnil;
VALUE * const orig_sp = ec->cfp->sp;
unsigned int i;
VALUE flag_keyword_hash = 0;
+ VALUE splat_flagged_keyword_hash = 0;
VALUE converted_keyword_hash = 0;
+ VALUE rest_last = 0;
vm_check_canary(ec, orig_sp);
/*
@@ -476,17 +587,17 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co
*
* [pushed values] [uninitialized values]
* <- ci->argc -->
- * <- iseq->body->param.size------------>
+ * <- ISEQ_BODY(iseq)->param.size------------>
* ^ locals ^ sp
*
* =>
* [pushed values] [initialized values ]
* <- ci->argc -->
- * <- iseq->body->param.size------------>
+ * <- ISEQ_BODY(iseq)->param.size------------>
* ^ locals ^ sp
*/
- for (i=calling->argc; i<iseq->body->param.size; i++) {
- locals[i] = Qnil;
+ for (i=calling->argc; i<ISEQ_BODY(iseq)->param.size; i++) {
+ locals[i] = Qnil;
}
ec->cfp->sp = &locals[i];
@@ -494,124 +605,175 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co
args = &args_body;
given_argc = args->argc = calling->argc;
args->argv = locals;
- args->rest_dupped = FALSE;
+ args->rest_dupped = ci_flag & VM_CALL_ARGS_SPLAT_MUT;
+
+ if (UNLIKELY(ISEQ_BODY(iseq)->param.flags.anon_rest)) {
+ if ((ci_flag & VM_CALL_ARGS_SPLAT) &&
+ given_argc == ISEQ_BODY(iseq)->param.lead_num + (kw_flag ? 2 : 1) &&
+ !ISEQ_BODY(iseq)->param.flags.has_opt &&
+ !ISEQ_BODY(iseq)->param.flags.has_post &&
+ !ISEQ_BODY(iseq)->param.flags.ruby2_keywords &&
+ (!kw_flag ||
+ !ISEQ_BODY(iseq)->param.flags.has_kw ||
+ !ISEQ_BODY(iseq)->param.flags.has_kwrest ||
+ !ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg)) {
+ args->rest_dupped = true;
+ }
+ }
if (kw_flag & VM_CALL_KWARG) {
- args->kw_arg = vm_ci_kwarg(ci);
-
- if (iseq->body->param.flags.has_kw) {
- int kw_len = args->kw_arg->keyword_len;
- /* copy kw_argv */
- args->kw_argv = ALLOCA_N(VALUE, kw_len);
- args->argc -= kw_len;
- given_argc -= kw_len;
- MEMCPY(args->kw_argv, locals + args->argc, VALUE, kw_len);
- }
- else {
- args->kw_argv = NULL;
- given_argc = args_kw_argv_to_hash(args);
+ args->kw_arg = vm_ci_kwarg(ci);
+
+ if (ISEQ_BODY(iseq)->param.flags.has_kw) {
+ int kw_len = args->kw_arg->keyword_len;
+ /* copy kw_argv */
+ args->kw_argv = ALLOCA_N(VALUE, kw_len);
+ args->argc -= kw_len;
+ given_argc -= kw_len;
+ MEMCPY(args->kw_argv, locals + args->argc, VALUE, kw_len);
+ }
+ else {
+ args->kw_argv = NULL;
+ given_argc = args_kw_argv_to_hash(args);
kw_flag |= VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT;
- }
+ }
}
else {
- args->kw_arg = NULL;
- args->kw_argv = NULL;
+ args->kw_arg = NULL;
+ args->kw_argv = NULL;
}
- if (vm_ci_flag(ci) & VM_CALL_ARGS_SPLAT) {
- VALUE rest_last = 0;
- int len;
- args->rest = locals[--args->argc];
- args->rest_index = 0;
- len = RARRAY_LENINT(args->rest);
+ if ((ci_flag & VM_CALL_ARGS_SPLAT) && (ci_flag & VM_CALL_KW_SPLAT)) {
+ // f(*a, **kw)
+ args->rest_index = 0;
+ keyword_hash = locals[--args->argc];
+ args->rest = locals[--args->argc];
+
+ if (ignore_keyword_hash_p(keyword_hash, iseq, &kw_flag, &converted_keyword_hash)) {
+ keyword_hash = Qnil;
+ }
+ else if (UNLIKELY(ISEQ_BODY(iseq)->param.flags.ruby2_keywords)) {
+ converted_keyword_hash = check_kwrestarg(converted_keyword_hash, &kw_flag);
+ flag_keyword_hash = converted_keyword_hash;
+ arg_rest_dup(args);
+ rb_ary_push(args->rest, converted_keyword_hash);
+ keyword_hash = Qnil;
+ }
+ else if (!ISEQ_BODY(iseq)->param.flags.has_kwrest && !ISEQ_BODY(iseq)->param.flags.has_kw) {
+ converted_keyword_hash = check_kwrestarg(converted_keyword_hash, &kw_flag);
+ arg_rest_dup(args);
+ rb_ary_push(args->rest, converted_keyword_hash);
+ keyword_hash = Qnil;
+ }
+ else {
+ keyword_hash = converted_keyword_hash;
+ }
+
+ int len = RARRAY_LENINT(args->rest);
+ given_argc += len - 2;
+ }
+ else if (ci_flag & VM_CALL_ARGS_SPLAT) {
+ // f(*a)
+ args->rest_index = 0;
+ args->rest = locals[--args->argc];
+ int len = RARRAY_LENINT(args->rest);
given_argc += len - 1;
- rest_last = RARRAY_AREF(args->rest, len - 1);
if (!kw_flag && len > 0) {
- if (RB_TYPE_P(rest_last, T_HASH) &&
- (((struct RHash *)rest_last)->basic.flags & RHASH_PASS_AS_KEYWORDS)) {
+ rest_last = RARRAY_AREF(args->rest, len - 1);
+ if (RB_TYPE_P(rest_last, T_HASH) && FL_TEST_RAW(rest_last, RHASH_PASS_AS_KEYWORDS)) {
+ // def f(**kw); a = [..., kw]; g(*a)
+ splat_flagged_keyword_hash = rest_last;
rest_last = rb_hash_dup(rest_last);
kw_flag |= VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT;
- }
- else {
- rest_last = 0;
- }
- }
- if (kw_flag & VM_CALL_KW_SPLAT) {
- if (ignore_keyword_hash_p(rest_last, iseq, &kw_flag, &converted_keyword_hash)) {
- arg_rest_dup(args);
- rb_ary_pop(args->rest);
- given_argc--;
- kw_flag &= ~(VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT);
- }
- else {
- if (rest_last != converted_keyword_hash) {
- rest_last = converted_keyword_hash;
- arg_rest_dup(args);
- RARRAY_ASET(args->rest, len - 1, rest_last);
- }
+ // Unset rest_dupped set by anon_rest as we may need to modify splat in this case
+ args->rest_dupped = false;
- if (iseq->body->param.flags.ruby2_keywords && rest_last) {
- flag_keyword_hash = rest_last;
- }
- else if (iseq->body->param.flags.has_kw || iseq->body->param.flags.has_kwrest) {
+ if (ignore_keyword_hash_p(rest_last, iseq, &kw_flag, &converted_keyword_hash)) {
arg_rest_dup(args);
rb_ary_pop(args->rest);
given_argc--;
- keyword_hash = rest_last;
+ kw_flag &= ~(VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT);
+ }
+ else {
+ if (rest_last != converted_keyword_hash) {
+ rest_last = converted_keyword_hash;
+ arg_rest_dup(args);
+ RARRAY_ASET(args->rest, len - 1, rest_last);
+ }
+
+ if (ISEQ_BODY(iseq)->param.flags.ruby2_keywords && rest_last) {
+ flag_keyword_hash = rest_last;
+ }
+ else if (ISEQ_BODY(iseq)->param.flags.has_kw || ISEQ_BODY(iseq)->param.flags.has_kwrest) {
+ arg_rest_dup(args);
+ rb_ary_pop(args->rest);
+ given_argc--;
+ keyword_hash = rest_last;
+ }
}
}
}
}
else {
- if (kw_flag & VM_CALL_KW_SPLAT) {
+ args->rest = Qfalse;
+
+ if (args->argc > 0 && (kw_flag & VM_CALL_KW_SPLAT)) {
+ // f(**kw)
VALUE last_arg = args->argv[args->argc-1];
if (ignore_keyword_hash_p(last_arg, iseq, &kw_flag, &converted_keyword_hash)) {
args->argc--;
given_argc--;
kw_flag &= ~(VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT);
- }
+ }
else {
+ if (!(kw_flag & VM_CALL_KW_SPLAT_MUT) && !ISEQ_BODY(iseq)->param.flags.has_kw) {
+ converted_keyword_hash = rb_hash_dup(converted_keyword_hash);
+ kw_flag |= VM_CALL_KW_SPLAT_MUT;
+ }
+
if (last_arg != converted_keyword_hash) {
last_arg = converted_keyword_hash;
args->argv[args->argc-1] = last_arg;
}
- if (iseq->body->param.flags.ruby2_keywords) {
+ if (ISEQ_BODY(iseq)->param.flags.ruby2_keywords) {
flag_keyword_hash = last_arg;
}
- else if (iseq->body->param.flags.has_kw || iseq->body->param.flags.has_kwrest) {
+ else if (ISEQ_BODY(iseq)->param.flags.has_kw || ISEQ_BODY(iseq)->param.flags.has_kwrest) {
args->argc--;
given_argc--;
keyword_hash = last_arg;
}
}
}
- args->rest = Qfalse;
}
- if (flag_keyword_hash && RB_TYPE_P(flag_keyword_hash, T_HASH)) {
- ((struct RHash *)flag_keyword_hash)->basic.flags |= RHASH_PASS_AS_KEYWORDS;
+ if (flag_keyword_hash) {
+ FL_SET_RAW(flag_keyword_hash, RHASH_PASS_AS_KEYWORDS);
}
- if (kw_flag && iseq->body->param.flags.accepts_no_kwarg) {
- rb_raise(rb_eArgError, "no keywords accepted");
+ if (kw_flag && ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg) {
+ rb_raise(rb_eArgError, "no keywords accepted");
}
-
switch (arg_setup_type) {
case arg_setup_method:
- break; /* do nothing special */
+ break; /* do nothing special */
case arg_setup_block:
- if (given_argc == (keyword_hash == Qnil ? 1 : 2) &&
+ if (given_argc == 1 &&
allow_autosplat &&
- (min_argc > 0 || iseq->body->param.opt_num > 1) &&
- !iseq->body->param.flags.ambiguous_param0 &&
- args_check_block_arg0(args)) {
- given_argc = RARRAY_LENINT(args->rest);
- }
- break;
+ !splat_flagged_keyword_hash &&
+ (min_argc > 0 || ISEQ_BODY(iseq)->param.opt_num > 1) &&
+ !ISEQ_BODY(iseq)->param.flags.ambiguous_param0 &&
+ !((ISEQ_BODY(iseq)->param.flags.has_kw ||
+ ISEQ_BODY(iseq)->param.flags.has_kwrest)
+ && max_argc == 1) &&
+ args_check_block_arg0(args)) {
+ given_argc = RARRAY_LENINT(args->rest);
+ }
+ break;
}
/* argc check */
@@ -627,82 +789,90 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co
}
if (given_argc > max_argc && max_argc != UNLIMITED_ARGUMENTS) {
- if (arg_setup_type == arg_setup_block) {
- /* truncate */
- args_reduce(args, given_argc - max_argc);
- given_argc = max_argc;
- }
- else {
- argument_arity_error(ec, iseq, given_argc, min_argc, max_argc);
- }
+ if (arg_setup_type == arg_setup_block) {
+ /* truncate */
+ args_reduce(args, given_argc - max_argc);
+ given_argc = max_argc;
+ }
+ else {
+ argument_arity_error(ec, iseq, given_argc, min_argc, max_argc);
+ }
}
- if (iseq->body->param.flags.has_lead) {
- args_setup_lead_parameters(args, iseq->body->param.lead_num, locals + 0);
+ if (ISEQ_BODY(iseq)->param.flags.has_lead) {
+ args_setup_lead_parameters(args, ISEQ_BODY(iseq)->param.lead_num, locals + 0);
}
- if (iseq->body->param.flags.has_rest || iseq->body->param.flags.has_post){
+ if (ISEQ_BODY(iseq)->param.flags.has_rest || ISEQ_BODY(iseq)->param.flags.has_post){
args_copy(args);
}
- if (iseq->body->param.flags.has_post) {
- args_setup_post_parameters(args, iseq->body->param.post_num, locals + iseq->body->param.post_start);
+ if (ISEQ_BODY(iseq)->param.flags.has_post) {
+ args_setup_post_parameters(args, ISEQ_BODY(iseq)->param.post_num, locals + ISEQ_BODY(iseq)->param.post_start);
}
- if (iseq->body->param.flags.has_opt) {
- int opt = args_setup_opt_parameters(args, iseq->body->param.opt_num, locals + iseq->body->param.lead_num);
- opt_pc = (int)iseq->body->param.opt_table[opt];
+ if (ISEQ_BODY(iseq)->param.flags.has_opt) {
+ int opt = args_setup_opt_parameters(args, ISEQ_BODY(iseq)->param.opt_num, locals + ISEQ_BODY(iseq)->param.lead_num);
+ opt_pc = (int)ISEQ_BODY(iseq)->param.opt_table[opt];
}
- if (iseq->body->param.flags.has_rest) {
- args_setup_rest_parameter(args, locals + iseq->body->param.rest_start);
+ if (ISEQ_BODY(iseq)->param.flags.has_rest) {
+ args_setup_rest_parameter(args, locals + ISEQ_BODY(iseq)->param.rest_start);
+ VALUE ary = *(locals + ISEQ_BODY(iseq)->param.rest_start);
+ VALUE index = RARRAY_LEN(ary) - 1;
+ if (splat_flagged_keyword_hash &&
+ !ISEQ_BODY(iseq)->param.flags.ruby2_keywords &&
+ !ISEQ_BODY(iseq)->param.flags.has_kw &&
+ !ISEQ_BODY(iseq)->param.flags.has_kwrest &&
+ RARRAY_AREF(ary, index) == splat_flagged_keyword_hash) {
+ ((struct RHash *)rest_last)->basic.flags &= ~RHASH_PASS_AS_KEYWORDS;
+ RARRAY_ASET(ary, index, rest_last);
+ }
}
- if (iseq->body->param.flags.has_kw) {
- VALUE * const klocals = locals + iseq->body->param.keyword->bits_start - iseq->body->param.keyword->num;
+ if (ISEQ_BODY(iseq)->param.flags.has_kw) {
+ VALUE * const klocals = locals + ISEQ_BODY(iseq)->param.keyword->bits_start - ISEQ_BODY(iseq)->param.keyword->num;
- if (args->kw_argv != NULL) {
- const struct rb_callinfo_kwarg *kw_arg = args->kw_arg;
- args_setup_kw_parameters(ec, iseq, args->kw_argv, kw_arg->keyword_len, kw_arg->keywords, klocals);
- }
- else if (!NIL_P(keyword_hash)) {
- int kw_len = rb_long2int(RHASH_SIZE(keyword_hash));
- struct fill_values_arg arg;
- /* copy kw_argv */
- arg.keys = args->kw_argv = ALLOCA_N(VALUE, kw_len * 2);
- arg.vals = arg.keys + kw_len;
- arg.argc = 0;
- rb_hash_foreach(keyword_hash, fill_keys_values, (VALUE)&arg);
- VM_ASSERT(arg.argc == kw_len);
- args_setup_kw_parameters(ec, iseq, arg.vals, kw_len, arg.keys, klocals);
- }
- else {
- VM_ASSERT(args_argc(args) == 0);
- args_setup_kw_parameters(ec, iseq, NULL, 0, NULL, klocals);
- }
+ if (args->kw_argv != NULL) {
+ const struct rb_callinfo_kwarg *kw_arg = args->kw_arg;
+ args_setup_kw_parameters(ec, iseq, args->kw_argv, kw_arg->keyword_len, kw_arg->keywords, klocals);
+ }
+ else if (!NIL_P(keyword_hash)) {
+ bool remove_hash_value = false;
+ if (ISEQ_BODY(iseq)->param.flags.has_kwrest) {
+ keyword_hash = check_kwrestarg(keyword_hash, &kw_flag);
+ remove_hash_value = true;
+ }
+ args_setup_kw_parameters_from_kwsplat(ec, iseq, keyword_hash, klocals, remove_hash_value);
+ }
+ else {
+ VM_ASSERT(args_argc(args) == 0);
+ args_setup_kw_parameters(ec, iseq, NULL, 0, NULL, klocals);
+ }
}
- else if (iseq->body->param.flags.has_kwrest) {
- args_setup_kw_rest_parameter(keyword_hash, locals + iseq->body->param.keyword->rest_start, kw_flag);
+ else if (ISEQ_BODY(iseq)->param.flags.has_kwrest) {
+ args_setup_kw_rest_parameter(keyword_hash, locals + ISEQ_BODY(iseq)->param.keyword->rest_start,
+ kw_flag, ISEQ_BODY(iseq)->param.flags.anon_kwrest);
}
else if (!NIL_P(keyword_hash) && RHASH_SIZE(keyword_hash) > 0 && arg_setup_type == arg_setup_method) {
- argument_kw_error(ec, iseq, "unknown", rb_hash_keys(keyword_hash));
+ argument_kw_error(ec, iseq, "unknown", rb_hash_keys(keyword_hash));
}
- if (iseq->body->param.flags.has_block) {
- if (iseq->body->local_iseq == iseq) {
- /* Do nothing */
- }
- else {
- args_setup_block_parameter(ec, calling, locals + iseq->body->param.block_start);
- }
+ if (ISEQ_BODY(iseq)->param.flags.has_block) {
+ if (ISEQ_BODY(iseq)->local_iseq == iseq) {
+ /* Do nothing */
+ }
+ else {
+ args_setup_block_parameter(ec, calling, locals + ISEQ_BODY(iseq)->param.block_start);
+ }
}
#if 0
{
- int i;
- for (i=0; i<iseq->body->param.size; i++) {
- fprintf(stderr, "local[%d] = %p\n", i, (void *)locals[i]);
- }
+ int i;
+ for (i=0; i<ISEQ_BODY(iseq)->param.size; i++) {
+ ruby_debug_printf("local[%d] = %p\n", i, (void *)locals[i]);
+ }
}
#endif
@@ -716,16 +886,16 @@ raise_argument_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const VA
VALUE at;
if (iseq) {
- vm_push_frame(ec, iseq, VM_FRAME_MAGIC_DUMMY | VM_ENV_FLAG_LOCAL, Qnil /* self */,
- VM_BLOCK_HANDLER_NONE /* specval*/, Qfalse /* me or cref */,
- iseq->body->iseq_encoded,
- ec->cfp->sp, 0, 0 /* stack_max */);
- at = rb_ec_backtrace_object(ec);
- rb_backtrace_use_iseq_first_lineno_for_last_location(at);
- rb_vm_pop_frame(ec);
+ vm_push_frame(ec, iseq, VM_FRAME_MAGIC_DUMMY | VM_ENV_FLAG_LOCAL, Qnil /* self */,
+ VM_BLOCK_HANDLER_NONE /* specval*/, Qfalse /* me or cref */,
+ ISEQ_BODY(iseq)->iseq_encoded,
+ ec->cfp->sp, 0, 0 /* stack_max */);
+ at = rb_ec_backtrace_object(ec);
+ rb_backtrace_use_iseq_first_lineno_for_last_location(at);
+ rb_vm_pop_frame(ec);
}
else {
- at = rb_ec_backtrace_object(ec);
+ at = rb_ec_backtrace_object(ec);
}
rb_ivar_set(exc, idBt_locations, at);
@@ -737,23 +907,23 @@ static void
argument_arity_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const int miss_argc, const int min_argc, const int max_argc)
{
VALUE exc = rb_arity_error_new(miss_argc, min_argc, max_argc);
- if (iseq->body->param.flags.has_kw) {
- const struct rb_iseq_param_keyword *const kw = iseq->body->param.keyword;
- const ID *keywords = kw->table;
- int req_key_num = kw->required_num;
- if (req_key_num > 0) {
- static const char required[] = "; required keywords";
- VALUE mesg = rb_attr_get(exc, idMesg);
- rb_str_resize(mesg, RSTRING_LEN(mesg)-1);
- rb_str_cat(mesg, required, sizeof(required) - 1 - (req_key_num == 1));
- rb_str_cat_cstr(mesg, ":");
- do {
- rb_str_cat_cstr(mesg, " ");
- rb_str_append(mesg, rb_id2str(*keywords++));
- rb_str_cat_cstr(mesg, ",");
- } while (--req_key_num);
- RSTRING_PTR(mesg)[RSTRING_LEN(mesg)-1] = ')';
- }
+ if (ISEQ_BODY(iseq)->param.flags.has_kw) {
+ const struct rb_iseq_param_keyword *const kw = ISEQ_BODY(iseq)->param.keyword;
+ const ID *keywords = kw->table;
+ int req_key_num = kw->required_num;
+ if (req_key_num > 0) {
+ static const char required[] = "; required keywords";
+ VALUE mesg = rb_attr_get(exc, idMesg);
+ rb_str_resize(mesg, RSTRING_LEN(mesg)-1);
+ rb_str_cat(mesg, required, sizeof(required) - 1 - (req_key_num == 1));
+ rb_str_cat_cstr(mesg, ":");
+ do {
+ rb_str_cat_cstr(mesg, " ");
+ rb_str_append(mesg, rb_id2str(*keywords++));
+ rb_str_cat_cstr(mesg, ",");
+ } while (--req_key_num);
+ RSTRING_PTR(mesg)[RSTRING_LEN(mesg)-1] = ')';
+ }
}
raise_argument_error(ec, iseq, exc);
}
@@ -764,73 +934,31 @@ argument_kw_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const char
raise_argument_error(ec, iseq, rb_keyword_error_new(error, keys));
}
-static inline void
-vm_caller_setup_arg_splat(rb_control_frame_t *cfp, struct rb_calling_info *calling)
-{
- int argc = calling->argc;
- VALUE *argv = cfp->sp - argc;
- VALUE ary = argv[argc-1];
-
- vm_check_canary(GET_EC(), cfp->sp);
- cfp->sp--;
-
- if (!NIL_P(ary)) {
- const VALUE *ptr = RARRAY_CONST_PTR_TRANSIENT(ary);
- long len = RARRAY_LEN(ary), i;
-
- CHECK_VM_STACK_OVERFLOW(cfp, len);
-
- for (i = 0; i < len; i++) {
- *cfp->sp++ = ptr[i];
- }
- calling->argc += i - 1;
- }
-}
-
-static inline void
-vm_caller_setup_arg_kw(rb_control_frame_t *cfp, struct rb_calling_info *calling, const struct rb_callinfo *ci)
-{
- const VALUE *const passed_keywords = vm_ci_kwarg(ci)->keywords;
- const int kw_len = vm_ci_kwarg(ci)->keyword_len;
- const VALUE h = rb_hash_new_with_size(kw_len);
- VALUE *sp = cfp->sp;
- int i;
-
- for (i=0; i<kw_len; i++) {
- rb_hash_aset(h, passed_keywords[i], (sp - kw_len)[i]);
- }
- (sp-kw_len)[0] = h;
-
- cfp->sp -= kw_len - 1;
- calling->argc -= kw_len - 1;
- calling->kw_splat = 1;
-}
-
static VALUE
vm_to_proc(VALUE proc)
{
if (UNLIKELY(!rb_obj_is_proc(proc))) {
- VALUE b;
- const rb_callable_method_entry_t *me =
- rb_callable_method_entry_with_refinements(CLASS_OF(proc), idTo_proc, NULL);
+ VALUE b;
+ const rb_callable_method_entry_t *me =
+ rb_callable_method_entry_with_refinements(CLASS_OF(proc), idTo_proc, NULL);
- if (me) {
+ if (me) {
b = rb_vm_call0(GET_EC(), proc, idTo_proc, 0, NULL, me, RB_NO_KEYWORDS);
- }
- else {
- /* NOTE: calling method_missing */
- b = rb_check_convert_type_with_id(proc, T_DATA, "Proc", idTo_proc);
- }
-
- if (NIL_P(b) || !rb_obj_is_proc(b)) {
- rb_raise(rb_eTypeError,
- "wrong argument type %s (expected Proc)",
- rb_obj_classname(proc));
- }
- return b;
+ }
+ else {
+ /* NOTE: calling method_missing */
+ b = rb_check_convert_type_with_id(proc, T_DATA, "Proc", idTo_proc);
+ }
+
+ if (NIL_P(b) || !rb_obj_is_proc(b)) {
+ rb_raise(rb_eTypeError,
+ "wrong argument type %s (expected Proc)",
+ rb_obj_classname(proc));
+ }
+ return b;
}
else {
- return proc;
+ return proc;
}
}
@@ -847,7 +975,7 @@ refine_sym_proc_call(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
VALUE klass;
if (argc-- < 1) {
- rb_raise(rb_eArgError, "no receiver given");
+ rb_raise(rb_eArgError, "no receiver given");
}
obj = *argv++;
@@ -862,7 +990,7 @@ refine_sym_proc_call(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
ec = GET_EC();
if (!NIL_P(blockarg)) {
- vm_passed_block_handler_set(ec, blockarg);
+ vm_passed_block_handler_set(ec, blockarg);
}
if (!me) {
return method_missing(ec, obj, mid, argc, argv, MISSING_NOENTRY, kw_splat);
@@ -875,33 +1003,30 @@ vm_caller_setup_arg_block(const rb_execution_context_t *ec, rb_control_frame_t *
const struct rb_callinfo *ci, const rb_iseq_t *blockiseq, const int is_super)
{
if (vm_ci_flag(ci) & VM_CALL_ARGS_BLOCKARG) {
- VALUE block_code = *(--reg_cfp->sp);
+ VALUE block_code = *(--reg_cfp->sp);
- if (NIL_P(block_code)) {
+ if (NIL_P(block_code)) {
return VM_BLOCK_HANDLER_NONE;
}
- else if (block_code == rb_block_param_proxy) {
- VM_ASSERT(!VM_CFP_IN_HEAP_P(GET_EC(), reg_cfp));
- VALUE handler = VM_CF_BLOCK_HANDLER(reg_cfp);
- reg_cfp->block_code = (const void *) handler;
- return handler;
- }
- else if (SYMBOL_P(block_code) && rb_method_basic_definition_p(rb_cSymbol, idTo_proc)) {
- const rb_cref_t *cref = vm_env_cref(reg_cfp->ep);
- if (cref && !NIL_P(cref->refinements)) {
- VALUE ref = cref->refinements;
- VALUE func = rb_hash_lookup(ref, block_code);
- if (NIL_P(func)) {
- /* TODO: limit cached funcs */
- VALUE callback_arg = rb_ary_tmp_new(2);
+ else if (block_code == rb_block_param_proxy) {
+ return VM_CF_BLOCK_HANDLER(reg_cfp);
+ }
+ else if (SYMBOL_P(block_code) && rb_method_basic_definition_p(rb_cSymbol, idTo_proc)) {
+ const rb_cref_t *cref = vm_env_cref(reg_cfp->ep);
+ if (cref && !NIL_P(cref->refinements)) {
+ VALUE ref = cref->refinements;
+ VALUE func = rb_hash_lookup(ref, block_code);
+ if (NIL_P(func)) {
+ /* TODO: limit cached funcs */
+ VALUE callback_arg = rb_ary_hidden_new(2);
rb_ary_push(callback_arg, block_code);
rb_ary_push(callback_arg, ref);
OBJ_FREEZE_RAW(callback_arg);
func = rb_func_lambda_new(refine_sym_proc_call, callback_arg, 1, UNLIMITED_ARGUMENTS);
- rb_hash_aset(ref, block_code, func);
- }
- block_code = func;
- }
+ rb_hash_aset(ref, block_code, func);
+ }
+ block_code = func;
+ }
return block_code;
}
else {
@@ -909,12 +1034,12 @@ vm_caller_setup_arg_block(const rb_execution_context_t *ec, rb_control_frame_t *
}
}
else if (blockiseq != NULL) { /* likely */
- struct rb_captured_block *captured = VM_CFP_TO_CAPTURED_BLOCK(reg_cfp);
- captured->code.iseq = blockiseq;
+ struct rb_captured_block *captured = VM_CFP_TO_CAPTURED_BLOCK(reg_cfp);
+ captured->code.iseq = blockiseq;
return VM_BH_FROM_ISEQ_BLOCK(captured);
}
else {
- if (is_super) {
+ if (is_super) {
return GET_BLOCK_HANDLER();
}
else {