Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | ** array.c - Array class |
3 | | ** |
4 | | ** See Copyright Notice in mruby.h |
5 | | */ |
6 | | |
7 | | #include <mruby.h> |
8 | | #include <mruby/array.h> |
9 | | #include <mruby/class.h> |
10 | | #include <mruby/string.h> |
11 | | #include <mruby/range.h> |
12 | | #include <mruby/proc.h> |
13 | | #include <mruby/internal.h> |
14 | | #include <mruby/presym.h> |
15 | | #include "value_array.h" |
16 | | |
17 | 17.7k | #define ARY_DEFAULT_LEN 4 |
18 | 0 | #define ARY_SHRINK_RATIO 5 /* must be larger than 2 */ |
19 | 541k | #define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value)) |
20 | | #ifndef MRB_ARY_LENGTH_MAX |
21 | 228k | #define MRB_ARY_LENGTH_MAX 131072 |
22 | | #endif |
23 | 270k | #define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1)) |
24 | | |
25 | | static void |
26 | | ary_too_big(mrb_state *mrb) |
27 | 0 | { |
28 | 0 | mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big"); |
29 | 0 | } |
30 | | |
31 | | static inline void |
32 | | ary_check_too_big(mrb_state *mrb, mrb_int a, mrb_int b) |
33 | 228k | { |
34 | 228k | if (a > ARY_MAX_SIZE - b || a < 0) |
35 | 0 | ary_too_big(mrb); |
36 | 228k | #if MRB_ARY_LENGTH_MAX != 0 |
37 | 228k | if (a > MRB_ARY_LENGTH_MAX - b || a < 0) |
38 | 0 | ary_too_big(mrb); |
39 | 228k | #endif |
40 | 228k | } |
41 | | |
42 | | static struct RArray* |
43 | | ary_new_capa(mrb_state *mrb, mrb_int capa) |
44 | 193k | { |
45 | 193k | struct RArray *a; |
46 | 193k | size_t blen; |
47 | | |
48 | 193k | ary_check_too_big(mrb, capa, 0); |
49 | 193k | blen = capa * sizeof(mrb_value); |
50 | | |
51 | 193k | a = MRB_OBJ_ALLOC(mrb, MRB_TT_ARRAY, mrb->array_class); |
52 | 193k | if (capa <= MRB_ARY_EMBED_LEN_MAX) { |
53 | 191k | ARY_SET_EMBED_LEN(a, 0); |
54 | 191k | } |
55 | 2.57k | else { |
56 | 2.57k | a->as.heap.ptr = (mrb_value *)mrb_malloc(mrb, blen); |
57 | 2.57k | a->as.heap.aux.capa = capa; |
58 | 2.57k | a->as.heap.len = 0; |
59 | 2.57k | } |
60 | | |
61 | 193k | return a; |
62 | 193k | } |
63 | | |
64 | | MRB_API mrb_value |
65 | | mrb_ary_new_capa(mrb_state *mrb, mrb_int capa) |
66 | 3.88k | { |
67 | 3.88k | struct RArray *a = ary_new_capa(mrb, capa); |
68 | 3.88k | return mrb_obj_value(a); |
69 | 3.88k | } |
70 | | |
71 | | MRB_API mrb_value |
72 | | mrb_ary_new(mrb_state *mrb) |
73 | 1.37k | { |
74 | 1.37k | return mrb_ary_new_capa(mrb, 0); |
75 | 1.37k | } |
76 | | |
77 | | /* |
78 | | * To copy array, use this instead of memcpy because of portability |
79 | | * * gcc on ARM may fail optimization of memcpy |
80 | | * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56620 |
81 | | * * gcc on MIPS also fail |
82 | | * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=39755 |
83 | | * * memcpy doesn't exist on freestanding environment |
84 | | * |
85 | | * If you optimize for binary size, use memcpy instead of this at your own risk |
86 | | * of above portability issue. |
87 | | * |
88 | | * See also https://togetter.com/li/462898 (Japanese) |
89 | | */ |
90 | | static inline void |
91 | | array_copy(mrb_value *dst, const mrb_value *src, mrb_int size) |
92 | 220k | { |
93 | 583k | for (mrb_int i = 0; i < size; i++) { |
94 | 362k | dst[i] = src[i]; |
95 | 362k | } |
96 | 220k | } |
97 | | |
98 | | static struct RArray* |
99 | | ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals) |
100 | 189k | { |
101 | 189k | struct RArray *a = ary_new_capa(mrb, size); |
102 | | |
103 | 189k | array_copy(ARY_PTR(a), vals, size); |
104 | 189k | ARY_SET_LEN(a, size); |
105 | | |
106 | 189k | return a; |
107 | 189k | } |
108 | | |
109 | | MRB_API mrb_value |
110 | | mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals) |
111 | 159k | { |
112 | 159k | struct RArray *a = ary_new_from_values(mrb, size, vals); |
113 | 159k | return mrb_obj_value(a); |
114 | 159k | } |
115 | | |
116 | | MRB_API mrb_value |
117 | | mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr) |
118 | 0 | { |
119 | 0 | struct RArray *a; |
120 | 0 | mrb_value *p; |
121 | |
|
122 | 0 | a = ary_new_capa(mrb, 2); |
123 | 0 | p = ARY_PTR(a); |
124 | 0 | p[0] = car; |
125 | 0 | p[1] = cdr; |
126 | 0 | ARY_SET_LEN(a, 2); |
127 | 0 | return mrb_obj_value(a); |
128 | 0 | } |
129 | | |
130 | | static void |
131 | | ary_fill_with_nil(mrb_value *ptr, mrb_int size) |
132 | 625 | { |
133 | 625 | mrb_value nil = mrb_nil_value(); |
134 | | |
135 | 2.41k | while (size--) { |
136 | 1.79k | *ptr++ = nil; |
137 | 1.79k | } |
138 | 625 | } |
139 | | |
140 | 170k | #define ary_modify_check(mrb, a) mrb_check_frozen((mrb), (a)) |
141 | | |
142 | | static void |
143 | | ary_modify(mrb_state *mrb, struct RArray *a) |
144 | 164k | { |
145 | 164k | ary_modify_check(mrb, a); |
146 | | |
147 | 164k | if (ARY_SHARED_P(a)) { |
148 | 0 | mrb_shared_array *shared = a->as.heap.aux.shared; |
149 | |
|
150 | 0 | if (shared->refcnt == 1 && a->as.heap.ptr == shared->ptr) { |
151 | 0 | a->as.heap.ptr = shared->ptr; |
152 | 0 | a->as.heap.aux.capa = a->as.heap.len; |
153 | 0 | mrb_free(mrb, shared); |
154 | 0 | } |
155 | 0 | else { |
156 | 0 | mrb_value *ptr, *p; |
157 | 0 | mrb_int len; |
158 | |
|
159 | 0 | p = a->as.heap.ptr; |
160 | 0 | len = a->as.heap.len * sizeof(mrb_value); |
161 | 0 | ptr = (mrb_value*)mrb_malloc(mrb, len); |
162 | 0 | if (p) { |
163 | 0 | array_copy(ptr, p, a->as.heap.len); |
164 | 0 | } |
165 | 0 | a->as.heap.ptr = ptr; |
166 | 0 | a->as.heap.aux.capa = a->as.heap.len; |
167 | 0 | mrb_ary_decref(mrb, shared); |
168 | 0 | } |
169 | 0 | ARY_UNSET_SHARED_FLAG(a); |
170 | 0 | } |
171 | 164k | } |
172 | | |
173 | | MRB_API void |
174 | | mrb_ary_modify(mrb_state *mrb, struct RArray* a) |
175 | 1.15k | { |
176 | 1.15k | mrb_write_barrier(mrb, (struct RBasic*)a); |
177 | 1.15k | ary_modify(mrb, a); |
178 | 1.15k | } |
179 | | |
180 | | static void |
181 | | ary_make_shared(mrb_state *mrb, struct RArray *a) |
182 | 521 | { |
183 | 521 | if (!ARY_SHARED_P(a) && !ARY_EMBED_P(a)) { |
184 | 521 | mrb_shared_array *shared = (mrb_shared_array*)mrb_malloc(mrb, sizeof(mrb_shared_array)); |
185 | 521 | mrb_value *ptr = a->as.heap.ptr; |
186 | 521 | mrb_int len = a->as.heap.len; |
187 | | |
188 | 521 | shared->refcnt = 1; |
189 | 521 | if (a->as.heap.aux.capa > len) { |
190 | 290 | a->as.heap.ptr = shared->ptr = (mrb_value*)mrb_realloc(mrb, ptr, sizeof(mrb_value)*len+1); |
191 | 290 | } |
192 | 231 | else { |
193 | 231 | shared->ptr = ptr; |
194 | 231 | } |
195 | 521 | shared->len = len; |
196 | 521 | a->as.heap.aux.shared = shared; |
197 | 521 | ARY_SET_SHARED_FLAG(a); |
198 | 521 | } |
199 | 521 | } |
200 | | |
201 | | static void |
202 | | ary_expand_capa(mrb_state *mrb, struct RArray *a, mrb_int len) |
203 | 10.6k | { |
204 | 10.6k | mrb_int capa = ARY_CAPA(a); |
205 | | |
206 | 10.6k | ary_check_too_big(mrb, len, 0); |
207 | 10.6k | if (capa < ARY_DEFAULT_LEN) { |
208 | 7.12k | capa = ARY_DEFAULT_LEN; |
209 | 7.12k | } |
210 | 14.7k | while (capa < len) { |
211 | 4.10k | if (capa <= ARY_MAX_SIZE / 2) { |
212 | 4.10k | capa *= 2; |
213 | 4.10k | } |
214 | 0 | else { |
215 | 0 | capa = len; |
216 | 0 | } |
217 | 4.10k | } |
218 | 10.6k | if (capa < len || capa > ARY_MAX_SIZE) { |
219 | 0 | ary_too_big(mrb); |
220 | 0 | } |
221 | | |
222 | 10.6k | if (ARY_EMBED_P(a)) { |
223 | 1.64k | mrb_value *ptr = ARY_EMBED_PTR(a); |
224 | 1.64k | mrb_int len = ARY_EMBED_LEN(a); |
225 | 1.64k | mrb_value *expanded_ptr = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value)*capa); |
226 | | |
227 | 1.64k | ARY_UNSET_EMBED_FLAG(a); |
228 | 1.64k | array_copy(expanded_ptr, ptr, len); |
229 | 1.64k | a->as.heap.len = len; |
230 | 1.64k | a->as.heap.aux.capa = capa; |
231 | 1.64k | a->as.heap.ptr = expanded_ptr; |
232 | 1.64k | } |
233 | 9.00k | else if (capa > a->as.heap.aux.capa) { |
234 | 9.00k | mrb_value *expanded_ptr = (mrb_value*)mrb_realloc(mrb, a->as.heap.ptr, sizeof(mrb_value)*capa); |
235 | | |
236 | 9.00k | a->as.heap.aux.capa = capa; |
237 | 9.00k | a->as.heap.ptr = expanded_ptr; |
238 | 9.00k | } |
239 | 10.6k | } |
240 | | |
241 | | static void |
242 | | ary_shrink_capa(mrb_state *mrb, struct RArray *a) |
243 | 0 | { |
244 | |
|
245 | 0 | mrb_int capa; |
246 | |
|
247 | 0 | if (ARY_EMBED_P(a)) return; |
248 | | |
249 | 0 | capa = a->as.heap.aux.capa; |
250 | 0 | if (capa < ARY_DEFAULT_LEN * 2) return; |
251 | 0 | if (capa <= a->as.heap.len * ARY_SHRINK_RATIO) return; |
252 | | |
253 | 0 | do { |
254 | 0 | capa /= 2; |
255 | 0 | if (capa < ARY_DEFAULT_LEN) { |
256 | 0 | capa = ARY_DEFAULT_LEN; |
257 | 0 | break; |
258 | 0 | } |
259 | 0 | } while (capa > a->as.heap.len * ARY_SHRINK_RATIO); |
260 | | |
261 | 0 | if (capa > a->as.heap.len && capa < a->as.heap.aux.capa) { |
262 | 0 | a->as.heap.aux.capa = capa; |
263 | 0 | a->as.heap.ptr = (mrb_value*)mrb_realloc(mrb, a->as.heap.ptr, sizeof(mrb_value)*capa); |
264 | 0 | } |
265 | 0 | } |
266 | | |
267 | | MRB_API mrb_value |
268 | | mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len) |
269 | 0 | { |
270 | 0 | mrb_int old_len; |
271 | 0 | struct RArray *a = mrb_ary_ptr(ary); |
272 | |
|
273 | 0 | ary_modify(mrb, a); |
274 | 0 | old_len = RARRAY_LEN(ary); |
275 | 0 | if (old_len != new_len) { |
276 | 0 | if (new_len < old_len) { |
277 | 0 | ary_shrink_capa(mrb, a); |
278 | 0 | } |
279 | 0 | else { |
280 | 0 | ary_expand_capa(mrb, a, new_len); |
281 | 0 | ary_fill_with_nil(ARY_PTR(a) + old_len, new_len - old_len); |
282 | 0 | } |
283 | 0 | ARY_SET_LEN(a, new_len); |
284 | 0 | } |
285 | |
|
286 | 0 | return ary; |
287 | 0 | } |
288 | | |
289 | | static mrb_value |
290 | | mrb_ary_s_create(mrb_state *mrb, mrb_value klass) |
291 | 0 | { |
292 | 0 | mrb_value ary; |
293 | 0 | const mrb_value *vals; |
294 | 0 | mrb_int len; |
295 | 0 | struct RArray *a; |
296 | |
|
297 | 0 | mrb_get_args(mrb, "*!", &vals, &len); |
298 | 0 | ary = mrb_ary_new_from_values(mrb, len, vals); |
299 | 0 | a = mrb_ary_ptr(ary); |
300 | 0 | a->c = mrb_class_ptr(klass); |
301 | |
|
302 | 0 | return ary; |
303 | 0 | } |
304 | | |
305 | | static void ary_replace(mrb_state*, struct RArray*, struct RArray*); |
306 | | |
307 | | static void |
308 | | ary_concat(mrb_state *mrb, struct RArray *a, struct RArray *a2) |
309 | 23.8k | { |
310 | 23.8k | mrb_int len; |
311 | | |
312 | 23.8k | if (ARY_LEN(a) == 0) { |
313 | 0 | ary_replace(mrb, a, a2); |
314 | 0 | return; |
315 | 0 | } |
316 | 23.8k | ary_check_too_big(mrb, ARY_LEN(a2), ARY_LEN(a)); |
317 | 23.8k | len = ARY_LEN(a) + ARY_LEN(a2); |
318 | | |
319 | 23.8k | ary_modify(mrb, a); |
320 | 23.8k | if (ARY_CAPA(a) < len) { |
321 | 0 | ary_expand_capa(mrb, a, len); |
322 | 0 | } |
323 | 23.8k | array_copy(ARY_PTR(a)+ARY_LEN(a), ARY_PTR(a2), ARY_LEN(a2)); |
324 | 23.8k | mrb_write_barrier(mrb, (struct RBasic*)a); |
325 | 23.8k | ARY_SET_LEN(a, len); |
326 | 23.8k | } |
327 | | |
328 | | MRB_API void |
329 | | mrb_ary_concat(mrb_state *mrb, mrb_value self, mrb_value other) |
330 | 23.8k | { |
331 | 23.8k | struct RArray *a2 = mrb_ary_ptr(other); |
332 | | |
333 | 23.8k | ary_concat(mrb, mrb_ary_ptr(self), a2); |
334 | 23.8k | } |
335 | | |
336 | | /* |
337 | | * call-seq: |
338 | | * array.concat(*other_arrays) -> self |
339 | | * |
340 | | * Adds to +array+ all elements from each \Array in +other_arrays+; returns +self+: |
341 | | * |
342 | | * a = [0, 1] |
343 | | * a.concat([2, 3], [4, 5]) # => [0, 1, 2, 3, 4, 5] |
344 | | */ |
345 | | |
346 | | static mrb_value |
347 | | mrb_ary_concat_m(mrb_state *mrb, mrb_value self) |
348 | 0 | { |
349 | 0 | mrb_value *args; |
350 | 0 | mrb_int len; |
351 | |
|
352 | 0 | mrb_get_args(mrb, "*!", &args, &len); |
353 | 0 | for (int i=0; i<len; i++) { |
354 | 0 | mrb_ensure_array_type(mrb, args[i]); |
355 | 0 | } |
356 | 0 | for (int i=0; i<len; i++) { |
357 | 0 | mrb_ary_concat(mrb, self, args[i]); |
358 | 0 | } |
359 | 0 | return self; |
360 | 0 | } |
361 | | |
362 | | static mrb_value |
363 | | mrb_ary_plus(mrb_state *mrb, mrb_value self) |
364 | 0 | { |
365 | 0 | struct RArray *a1 = mrb_ary_ptr(self); |
366 | 0 | struct RArray *a2; |
367 | 0 | const mrb_value *ptr; |
368 | 0 | mrb_int blen, len1; |
369 | |
|
370 | 0 | mrb_get_args(mrb, "a", &ptr, &blen); |
371 | 0 | ary_check_too_big(mrb, ARY_LEN(a1), blen); |
372 | 0 | len1 = ARY_LEN(a1); |
373 | 0 | a2 = ary_new_capa(mrb, len1 + blen); |
374 | 0 | array_copy(ARY_PTR(a2), ARY_PTR(a1), len1); |
375 | 0 | array_copy(ARY_PTR(a2) + len1, ptr, blen); |
376 | 0 | ARY_SET_LEN(a2, len1+blen); |
377 | |
|
378 | 0 | return mrb_obj_value(a2); |
379 | 0 | } |
380 | | |
381 | 5.99k | #define ARY_REPLACE_SHARED_MIN 20 |
382 | | |
383 | | static void |
384 | | ary_replace(mrb_state *mrb, struct RArray *a, struct RArray *b) |
385 | 5.99k | { |
386 | 5.99k | mrb_int len = ARY_LEN(b); |
387 | | |
388 | 5.99k | ary_modify_check(mrb, a); |
389 | 5.99k | if (a == b) return; |
390 | 5.99k | if (ARY_SHARED_P(a)) { |
391 | 0 | mrb_ary_decref(mrb, a->as.heap.aux.shared); |
392 | 0 | a->as.heap.aux.capa = 0; |
393 | 0 | a->as.heap.len = 0; |
394 | 0 | a->as.heap.ptr = NULL; |
395 | 0 | ARY_UNSET_SHARED_FLAG(a); |
396 | 0 | } |
397 | 5.99k | if (ARY_SHARED_P(b)) { |
398 | 521 | shared_b: |
399 | 521 | if (ARY_EMBED_P(a)) { |
400 | 0 | ARY_UNSET_EMBED_FLAG(a); |
401 | 0 | } |
402 | 521 | else { |
403 | 521 | mrb_free(mrb, a->as.heap.ptr); |
404 | 521 | } |
405 | 521 | a->as.heap.ptr = b->as.heap.ptr; |
406 | 521 | a->as.heap.len = len; |
407 | 521 | a->as.heap.aux.shared = b->as.heap.aux.shared; |
408 | 521 | a->as.heap.aux.shared->refcnt++; |
409 | 521 | ARY_SET_SHARED_FLAG(a); |
410 | 521 | mrb_write_barrier(mrb, (struct RBasic*)a); |
411 | 521 | return; |
412 | 0 | } |
413 | 5.99k | if (!mrb_frozen_p(b) && len > ARY_REPLACE_SHARED_MIN) { |
414 | 521 | ary_make_shared(mrb, b); |
415 | 521 | goto shared_b; |
416 | 521 | } |
417 | 5.47k | if (ARY_CAPA(a) < len) |
418 | 5.47k | ary_expand_capa(mrb, a, len); |
419 | 5.47k | array_copy(ARY_PTR(a), ARY_PTR(b), len); |
420 | 5.47k | mrb_write_barrier(mrb, (struct RBasic*)a); |
421 | 5.47k | ARY_SET_LEN(a, len); |
422 | 5.47k | } |
423 | | |
424 | | MRB_API void |
425 | | mrb_ary_replace(mrb_state *mrb, mrb_value self, mrb_value other) |
426 | 5.99k | { |
427 | 5.99k | struct RArray *a1 = mrb_ary_ptr(self); |
428 | 5.99k | struct RArray *a2 = mrb_ary_ptr(other); |
429 | | |
430 | 5.99k | if (a1 != a2) { |
431 | 5.99k | ary_replace(mrb, a1, a2); |
432 | 5.99k | } |
433 | 5.99k | } |
434 | | |
435 | | static mrb_value |
436 | | mrb_ary_replace_m(mrb_state *mrb, mrb_value self) |
437 | 5.99k | { |
438 | 5.99k | mrb_value other; |
439 | | |
440 | 5.99k | mrb_get_args(mrb, "A", &other); |
441 | 5.99k | mrb_ary_replace(mrb, self, other); |
442 | | |
443 | 5.99k | return self; |
444 | 5.99k | } |
445 | | |
446 | | static mrb_value |
447 | | mrb_ary_times(mrb_state *mrb, mrb_value self) |
448 | 0 | { |
449 | 0 | struct RArray *a1 = mrb_ary_ptr(self); |
450 | 0 | struct RArray *a2; |
451 | 0 | mrb_value *ptr, arg, tmp; |
452 | 0 | mrb_int times, len1; |
453 | |
|
454 | 0 | arg = mrb_get_arg1(mrb); |
455 | 0 | tmp = mrb_check_string_type(mrb, arg); |
456 | 0 | if (!mrb_nil_p(tmp)) { |
457 | 0 | return mrb_ary_join(mrb, self, tmp); |
458 | 0 | } |
459 | | |
460 | 0 | times = mrb_as_int(mrb, arg); |
461 | 0 | if (times < 0) { |
462 | 0 | mrb_raise(mrb, E_ARGUMENT_ERROR, "negative argument"); |
463 | 0 | } |
464 | 0 | if (times == 0) return mrb_ary_new(mrb); |
465 | 0 | if (ARY_MAX_SIZE / times < ARY_LEN(a1)) { |
466 | 0 | ary_too_big(mrb); |
467 | 0 | } |
468 | 0 | len1 = ARY_LEN(a1); |
469 | 0 | a2 = ary_new_capa(mrb, len1 * times); |
470 | 0 | ARY_SET_LEN(a2, len1 * times); |
471 | 0 | ptr = ARY_PTR(a2); |
472 | 0 | while (times--) { |
473 | 0 | array_copy(ptr, ARY_PTR(a1), len1); |
474 | 0 | ptr += len1; |
475 | 0 | } |
476 | |
|
477 | 0 | return mrb_obj_value(a2); |
478 | 0 | } |
479 | | |
480 | | static mrb_value |
481 | | mrb_ary_reverse_bang(mrb_state *mrb, mrb_value self) |
482 | 5.71k | { |
483 | 5.71k | struct RArray *a = mrb_ary_ptr(self); |
484 | 5.71k | mrb_int len = ARY_LEN(a); |
485 | | |
486 | 5.71k | if (len > 1) { |
487 | 0 | mrb_value *p1, *p2; |
488 | |
|
489 | 0 | ary_modify(mrb, a); |
490 | 0 | p1 = ARY_PTR(a); |
491 | 0 | p2 = p1 + len - 1; |
492 | |
|
493 | 0 | while (p1 < p2) { |
494 | 0 | mrb_value tmp = *p1; |
495 | 0 | *p1++ = *p2; |
496 | 0 | *p2-- = tmp; |
497 | 0 | } |
498 | 0 | } |
499 | 5.71k | return self; |
500 | 5.71k | } |
501 | | |
502 | | static mrb_value |
503 | | mrb_ary_reverse(mrb_state *mrb, mrb_value self) |
504 | 0 | { |
505 | 0 | struct RArray *a = mrb_ary_ptr(self), *b = ary_new_capa(mrb, ARY_LEN(a)); |
506 | 0 | mrb_int len = ARY_LEN(a); |
507 | |
|
508 | 0 | if (len > 0) { |
509 | 0 | mrb_value *p1, *p2, *e; |
510 | |
|
511 | 0 | p1 = ARY_PTR(a); |
512 | 0 | e = p1 + len; |
513 | 0 | p2 = ARY_PTR(b) + len - 1; |
514 | 0 | while (p1 < e) { |
515 | 0 | *p2-- = *p1++; |
516 | 0 | } |
517 | 0 | ARY_SET_LEN(b, len); |
518 | 0 | } |
519 | 0 | return mrb_obj_value(b); |
520 | 0 | } |
521 | | |
522 | | MRB_API void |
523 | | mrb_ary_push(mrb_state *mrb, mrb_value ary, mrb_value elem) |
524 | 112k | { |
525 | 112k | struct RArray *a = mrb_ary_ptr(ary); |
526 | 112k | mrb_int len = ARY_LEN(a); |
527 | | |
528 | 112k | ary_modify(mrb, a); |
529 | 112k | if (len == ARY_CAPA(a)) |
530 | 4.99k | ary_expand_capa(mrb, a, len + 1); |
531 | 112k | ARY_PTR(a)[len] = elem; |
532 | 112k | ARY_SET_LEN(a, len+1); |
533 | 112k | mrb_field_write_barrier_value(mrb, (struct RBasic*)a, elem); |
534 | 112k | } |
535 | | |
536 | | static mrb_value |
537 | | mrb_ary_push_m(mrb_state *mrb, mrb_value self) |
538 | 52.9k | { |
539 | 52.9k | mrb_int argc; |
540 | 52.9k | const mrb_value *argv; |
541 | 52.9k | mrb_int len, len2; |
542 | 52.9k | struct RArray *a; |
543 | | |
544 | 52.9k | argc = mrb_get_argc(mrb); |
545 | 52.9k | if (argc == 1) { |
546 | 52.9k | mrb_ary_push(mrb, self, mrb_get_argv(mrb)[0]); |
547 | 52.9k | return self; |
548 | 52.9k | } |
549 | 0 | a = mrb_ary_ptr(self); |
550 | 0 | ary_modify(mrb, a); |
551 | 0 | len = ARY_LEN(a); |
552 | 0 | len2 = len + argc; |
553 | 0 | if (ARY_CAPA(a) < len2) { |
554 | 0 | ary_expand_capa(mrb, a, len2); |
555 | 0 | } |
556 | 0 | argv = mrb_get_argv(mrb); |
557 | 0 | array_copy(ARY_PTR(a)+len, argv, argc); |
558 | 0 | ARY_SET_LEN(a, len2); |
559 | 0 | while (argc--) { |
560 | 0 | mrb_field_write_barrier_value(mrb, (struct RBasic*)a, *argv); |
561 | 0 | argv++; |
562 | 0 | } |
563 | 0 | return self; |
564 | 52.9k | } |
565 | | |
566 | | MRB_API mrb_value |
567 | | mrb_ary_pop(mrb_state *mrb, mrb_value ary) |
568 | 0 | { |
569 | 0 | struct RArray *a = mrb_ary_ptr(ary); |
570 | 0 | mrb_int len = ARY_LEN(a); |
571 | |
|
572 | 0 | ary_modify_check(mrb, a); |
573 | 0 | if (len == 0) return mrb_nil_value(); |
574 | 0 | ARY_SET_LEN(a, len-1); |
575 | 0 | return ARY_PTR(a)[len-1]; |
576 | 0 | } |
577 | | |
578 | 0 | #define ARY_SHIFT_SHARED_MIN 10 |
579 | | |
580 | | MRB_API mrb_value |
581 | | mrb_ary_shift(mrb_state *mrb, mrb_value self) |
582 | 0 | { |
583 | 0 | struct RArray *a = mrb_ary_ptr(self); |
584 | 0 | mrb_int len = ARY_LEN(a); |
585 | 0 | mrb_value val; |
586 | |
|
587 | 0 | ary_modify_check(mrb, a); |
588 | 0 | if (len == 0) return mrb_nil_value(); |
589 | 0 | if (ARY_SHARED_P(a)) { |
590 | 0 | L_SHIFT: |
591 | 0 | val = a->as.heap.ptr[0]; |
592 | 0 | a->as.heap.ptr++; |
593 | 0 | a->as.heap.len--; |
594 | 0 | return val; |
595 | 0 | } |
596 | 0 | if (len > ARY_SHIFT_SHARED_MIN) { |
597 | 0 | ary_make_shared(mrb, a); |
598 | 0 | goto L_SHIFT; |
599 | 0 | } |
600 | 0 | else { |
601 | 0 | mrb_value *ptr = ARY_PTR(a); |
602 | 0 | mrb_int size = len; |
603 | |
|
604 | 0 | val = *ptr; |
605 | 0 | while (--size) { |
606 | 0 | *ptr = *(ptr+1); |
607 | 0 | ptr++; |
608 | 0 | } |
609 | 0 | ARY_SET_LEN(a, len-1); |
610 | 0 | } |
611 | 0 | return val; |
612 | 0 | } |
613 | | |
614 | | static mrb_value |
615 | | mrb_ary_shift_m(mrb_state *mrb, mrb_value self) |
616 | 0 | { |
617 | |
|
618 | 0 | if (mrb_get_argc(mrb) == 0) { |
619 | 0 | return mrb_ary_shift(mrb, self); |
620 | 0 | } |
621 | | |
622 | 0 | mrb_int n = mrb_as_int(mrb, mrb_get_arg1(mrb)); |
623 | 0 | struct RArray *a = mrb_ary_ptr(self); |
624 | 0 | mrb_int len = ARY_LEN(a); |
625 | 0 | mrb_value val; |
626 | |
|
627 | 0 | ary_modify_check(mrb, a); |
628 | 0 | if (len == 0 || n == 0) return mrb_ary_new(mrb); |
629 | 0 | if (n < 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "negative array shift"); |
630 | 0 | if (n > len) n = len; |
631 | 0 | val = mrb_ary_new_from_values(mrb, n, ARY_PTR(a)); |
632 | 0 | if (ARY_SHARED_P(a)) { |
633 | 0 | L_SHIFT: |
634 | 0 | a->as.heap.ptr+=n; |
635 | 0 | a->as.heap.len-=n; |
636 | 0 | return val; |
637 | 0 | } |
638 | 0 | if (len > ARY_SHIFT_SHARED_MIN) { |
639 | 0 | ary_make_shared(mrb, a); |
640 | 0 | goto L_SHIFT; |
641 | 0 | } |
642 | 0 | else if (len == n) { |
643 | 0 | ARY_SET_LEN(a, 0); |
644 | 0 | } |
645 | 0 | else { |
646 | 0 | mrb_value *ptr = ARY_PTR(a); |
647 | 0 | mrb_int size = len-n; |
648 | |
|
649 | 0 | while (size--) { |
650 | 0 | *ptr = *(ptr+n); |
651 | 0 | ptr++; |
652 | 0 | } |
653 | 0 | ARY_SET_LEN(a, len-n); |
654 | 0 | } |
655 | 0 | return val; |
656 | 0 | } |
657 | | |
658 | | /* self = [1,2,3] |
659 | | item = 0 |
660 | | self.unshift item |
661 | | p self #=> [0, 1, 2, 3] */ |
662 | | MRB_API mrb_value |
663 | | mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item) |
664 | 0 | { |
665 | 0 | struct RArray *a = mrb_ary_ptr(self); |
666 | 0 | mrb_int len = ARY_LEN(a); |
667 | |
|
668 | 0 | if (ARY_SHARED_P(a) |
669 | 0 | && a->as.heap.aux.shared->refcnt == 1 /* shared only referenced from this array */ |
670 | 0 | && a->as.heap.ptr - a->as.heap.aux.shared->ptr >= 1) /* there's room for unshifted item */ { |
671 | 0 | a->as.heap.ptr--; |
672 | 0 | a->as.heap.ptr[0] = item; |
673 | 0 | } |
674 | 0 | else { |
675 | 0 | mrb_value *ptr; |
676 | |
|
677 | 0 | ary_modify(mrb, a); |
678 | 0 | if (ARY_CAPA(a) < len + 1) |
679 | 0 | ary_expand_capa(mrb, a, len + 1); |
680 | 0 | ptr = ARY_PTR(a); |
681 | 0 | value_move(ptr + 1, ptr, len); |
682 | 0 | ptr[0] = item; |
683 | 0 | } |
684 | 0 | ARY_SET_LEN(a, len+1); |
685 | 0 | mrb_field_write_barrier_value(mrb, (struct RBasic*)a, item); |
686 | |
|
687 | 0 | return self; |
688 | 0 | } |
689 | | |
690 | | /* |
691 | | * call-seq: |
692 | | * array.unshift(*objects) -> self |
693 | | * |
694 | | * Prepends the given +objects+ to +self+: |
695 | | * |
696 | | * a = [:foo, 'bar', 2] |
697 | | * a.unshift(:bam, :bat) # => [:bam, :bat, :foo, "bar", 2] |
698 | | * |
699 | | * Array#prepend is an alias for Array#unshift. |
700 | | * |
701 | | * Related: #push, #pop, #shift. |
702 | | */ |
703 | | |
704 | | static mrb_value |
705 | | mrb_ary_unshift_m(mrb_state *mrb, mrb_value self) |
706 | 0 | { |
707 | 0 | struct RArray *a = mrb_ary_ptr(self); |
708 | 0 | const mrb_value *vals; |
709 | 0 | mrb_value *ptr; |
710 | 0 | mrb_int alen, len; |
711 | |
|
712 | 0 | alen = mrb_get_argc(mrb); |
713 | 0 | vals = mrb_get_argv(mrb); |
714 | 0 | if (alen == 0) { |
715 | 0 | ary_modify_check(mrb, a); |
716 | 0 | return self; |
717 | 0 | } |
718 | 0 | len = ARY_LEN(a); |
719 | 0 | if (alen > ARY_MAX_SIZE - len) { |
720 | 0 | ary_too_big(mrb); |
721 | 0 | } |
722 | 0 | if (ARY_SHARED_P(a) |
723 | 0 | && a->as.heap.aux.shared->refcnt == 1 /* shared only referenced from this array */ |
724 | 0 | && a->as.heap.ptr - a->as.heap.aux.shared->ptr >= alen) /* there's room for unshifted item */ { |
725 | 0 | ary_modify_check(mrb, a); |
726 | 0 | a->as.heap.ptr -= alen; |
727 | 0 | ptr = a->as.heap.ptr; |
728 | 0 | } |
729 | 0 | else { |
730 | 0 | mrb_bool same = vals == ARY_PTR(a); |
731 | 0 | ary_modify(mrb, a); |
732 | 0 | if (ARY_CAPA(a) < len + alen) |
733 | 0 | ary_expand_capa(mrb, a, len + alen); |
734 | 0 | ptr = ARY_PTR(a); |
735 | 0 | value_move(ptr + alen, ptr, len); |
736 | 0 | if (same) vals = ptr; |
737 | 0 | } |
738 | 0 | array_copy(ptr, vals, alen); |
739 | 0 | ARY_SET_LEN(a, len+alen); |
740 | 0 | while (alen--) { |
741 | 0 | mrb_field_write_barrier_value(mrb, (struct RBasic*)a, vals[alen]); |
742 | 0 | } |
743 | |
|
744 | 0 | return self; |
745 | 0 | } |
746 | | |
747 | | MRB_API void |
748 | | mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val) |
749 | 25.5k | { |
750 | 25.5k | struct RArray *a = mrb_ary_ptr(ary); |
751 | 25.5k | mrb_int len = ARY_LEN(a); |
752 | | |
753 | 25.5k | ary_modify(mrb, a); |
754 | | /* range check */ |
755 | 25.5k | if (n < 0) { |
756 | 0 | n += len; |
757 | 0 | if (n < 0) { |
758 | 0 | mrb_raisef(mrb, E_INDEX_ERROR, "index %i out of array", n - len); |
759 | 0 | } |
760 | 0 | } |
761 | 25.5k | if (n >= ARY_MAX_SIZE) { |
762 | 0 | mrb_raise(mrb, E_INDEX_ERROR, "index too big"); |
763 | 0 | } |
764 | 25.5k | if (len <= n) { |
765 | 0 | if (ARY_CAPA(a) <= n) |
766 | 0 | ary_expand_capa(mrb, a, n + 1); |
767 | 0 | ary_fill_with_nil(ARY_PTR(a) + len, n + 1 - len); |
768 | 0 | ARY_SET_LEN(a, n+1); |
769 | 0 | } |
770 | | |
771 | 25.5k | ARY_PTR(a)[n] = val; |
772 | 25.5k | mrb_field_write_barrier_value(mrb, (struct RBasic*)a, val); |
773 | 25.5k | } |
774 | | |
775 | | static struct RArray* |
776 | | ary_dup(mrb_state *mrb, struct RArray *a) |
777 | 30.0k | { |
778 | 30.0k | return ary_new_from_values(mrb, ARY_LEN(a), ARY_PTR(a)); |
779 | 30.0k | } |
780 | | |
781 | | MRB_API mrb_value |
782 | | mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_value rpl) |
783 | 1.15k | { |
784 | 1.15k | struct RArray *a = mrb_ary_ptr(ary); |
785 | 1.15k | mrb_int alen = ARY_LEN(a); |
786 | 1.15k | const mrb_value *argv; |
787 | 1.15k | mrb_int argc; |
788 | 1.15k | mrb_int tail; |
789 | | |
790 | 1.15k | ary_modify(mrb, a); |
791 | | |
792 | | /* len check */ |
793 | 1.15k | if (len < 0) mrb_raisef(mrb, E_INDEX_ERROR, "negative length (%i)", len); |
794 | | |
795 | | /* range check */ |
796 | 1.15k | if (head < 0) { |
797 | 458 | head += alen; |
798 | 458 | if (head < 0) goto out_of_range; |
799 | 458 | } |
800 | 1.15k | if (head > ARY_MAX_SIZE - len) { |
801 | 0 | out_of_range: |
802 | 0 | mrb_raisef(mrb, E_INDEX_ERROR, "index %i is out of array", head); |
803 | 0 | } |
804 | 1.15k | tail = head + len; |
805 | 1.15k | if (alen < len || alen < tail) { |
806 | 186 | len = alen - head; |
807 | 186 | tail = head + len; |
808 | 186 | } |
809 | | |
810 | | /* size check */ |
811 | 1.15k | if (mrb_array_p(rpl)) { |
812 | 1.15k | argc = RARRAY_LEN(rpl); |
813 | 1.15k | argv = RARRAY_PTR(rpl); |
814 | 1.15k | if (argv == ARY_PTR(a)) { |
815 | 0 | struct RArray *r; |
816 | |
|
817 | 0 | if (argc > 32767) { |
818 | 0 | mrb_raise(mrb, E_ARGUMENT_ERROR, "too big recursive splice"); |
819 | 0 | } |
820 | 0 | r = ary_dup(mrb, a); |
821 | 0 | argv = ARY_PTR(r); |
822 | 0 | } |
823 | 1.15k | } |
824 | 0 | else if (mrb_undef_p(rpl)) { |
825 | 0 | argc = 0; |
826 | 0 | argv = NULL; |
827 | 0 | } |
828 | 0 | else { |
829 | 0 | argc = 1; |
830 | 0 | argv = &rpl; |
831 | 0 | } |
832 | 1.15k | if (head >= alen) { |
833 | 625 | if (head > ARY_MAX_SIZE - argc) goto out_of_range; |
834 | 625 | len = head + argc; |
835 | 625 | if (len > ARY_CAPA(a)) { |
836 | 184 | ary_expand_capa(mrb, a, len); |
837 | 184 | } |
838 | 625 | ary_fill_with_nil(ARY_PTR(a) + alen, head - alen); |
839 | 625 | if (argc > 0) { |
840 | 0 | array_copy(ARY_PTR(a) + head, argv, argc); |
841 | 0 | } |
842 | 625 | ARY_SET_LEN(a, len); |
843 | 625 | } |
844 | 525 | else { |
845 | 525 | mrb_int newlen; |
846 | | |
847 | 525 | if (alen - len > ARY_MAX_SIZE - argc) { |
848 | 0 | head = alen + argc - len; |
849 | 0 | goto out_of_range; |
850 | 0 | } |
851 | 525 | newlen = alen + argc - len; |
852 | 525 | if (newlen > ARY_CAPA(a)) { |
853 | 0 | ary_expand_capa(mrb, a, newlen); |
854 | 0 | } |
855 | | |
856 | 525 | if (len != argc) { |
857 | 0 | mrb_value *ptr = ARY_PTR(a); |
858 | 0 | value_move(ptr + head + argc, ptr + tail, alen - tail); |
859 | 0 | ARY_SET_LEN(a, newlen); |
860 | 0 | } |
861 | 525 | if (argc > 0) { |
862 | 0 | value_move(ARY_PTR(a) + head, argv, argc); |
863 | 0 | } |
864 | 525 | } |
865 | 1.15k | mrb_write_barrier(mrb, (struct RBasic*)a); |
866 | 1.15k | return ary; |
867 | 1.15k | } |
868 | | |
869 | | void |
870 | | mrb_ary_decref(mrb_state *mrb, mrb_shared_array *shared) |
871 | 1.04k | { |
872 | 1.04k | shared->refcnt--; |
873 | 1.04k | if (shared->refcnt == 0) { |
874 | 521 | mrb_free(mrb, shared->ptr); |
875 | 521 | mrb_free(mrb, shared); |
876 | 521 | } |
877 | 1.04k | } |
878 | | |
879 | | static mrb_value |
880 | | ary_subseq(mrb_state *mrb, struct RArray *a, mrb_int beg, mrb_int len) |
881 | 0 | { |
882 | 0 | struct RArray *b; |
883 | |
|
884 | 0 | if (!ARY_SHARED_P(a) && len <= ARY_SHIFT_SHARED_MIN) { |
885 | 0 | return mrb_ary_new_from_values(mrb, len, ARY_PTR(a)+beg); |
886 | 0 | } |
887 | 0 | ary_make_shared(mrb, a); |
888 | 0 | b = MRB_OBJ_ALLOC(mrb, MRB_TT_ARRAY, mrb->array_class); |
889 | 0 | b->as.heap.ptr = a->as.heap.ptr + beg; |
890 | 0 | b->as.heap.len = len; |
891 | 0 | b->as.heap.aux.shared = a->as.heap.aux.shared; |
892 | 0 | b->as.heap.aux.shared->refcnt++; |
893 | 0 | ARY_SET_SHARED_FLAG(b); |
894 | |
|
895 | 0 | return mrb_obj_value(b); |
896 | 0 | } |
897 | | |
898 | | mrb_value |
899 | | mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len) |
900 | 0 | { |
901 | 0 | struct RArray *a = mrb_ary_ptr(ary); |
902 | 0 | return ary_subseq(mrb, a, beg, len); |
903 | 0 | } |
904 | | |
905 | | static mrb_int |
906 | | aget_index(mrb_state *mrb, mrb_value index) |
907 | 28.0k | { |
908 | 28.0k | if (mrb_integer_p(index)) { |
909 | 27.8k | return mrb_integer(index); |
910 | 27.8k | } |
911 | 270 | #ifndef MRB_NO_FLOAT |
912 | 270 | else if (mrb_float_p(index)) { |
913 | 270 | return (mrb_int)mrb_float(index); |
914 | 270 | } |
915 | 0 | #endif |
916 | 0 | else { |
917 | 0 | mrb_int i, argc; |
918 | 0 | const mrb_value *argv; |
919 | |
|
920 | 0 | mrb_get_args(mrb, "i*!", &i, &argv, &argc); |
921 | 0 | return i; |
922 | 0 | } |
923 | 28.0k | } |
924 | | |
925 | | /* |
926 | | * call-seq: |
927 | | * ary[index] -> obj or nil |
928 | | * ary[start, length] -> new_ary or nil |
929 | | * ary[range] -> new_ary or nil |
930 | | * ary.slice(index) -> obj or nil |
931 | | * ary.slice(start, length) -> new_ary or nil |
932 | | * ary.slice(range) -> new_ary or nil |
933 | | * |
934 | | * Element Reference --- Returns the element at +index+, or returns a |
935 | | * subarray starting at the +start+ index and continuing for +length+ |
936 | | * elements, or returns a subarray specified by +range+ of indices. |
937 | | * |
938 | | * Negative indices count backward from the end of the array (-1 is the last |
939 | | * element). For +start+ and +range+ cases the starting index is just before |
940 | | * an element. Additionally, an empty array is returned when the starting |
941 | | * index for an element range is at the end of the array. |
942 | | * |
943 | | * Returns +nil+ if the index (or starting index) are out of range. |
944 | | * |
945 | | * a = [ "a", "b", "c", "d", "e" ] |
946 | | * a[1] => "b" |
947 | | * a[1,2] => ["b", "c"] |
948 | | * a[1..-2] => ["b", "c", "d"] |
949 | | * |
950 | | */ |
951 | | |
952 | | static mrb_value |
953 | | mrb_ary_aget(mrb_state *mrb, mrb_value self) |
954 | 1.28k | { |
955 | 1.28k | struct RArray *a = mrb_ary_ptr(self); |
956 | 1.28k | mrb_int i; |
957 | 1.28k | mrb_int len, alen; |
958 | 1.28k | mrb_value index; |
959 | | |
960 | 1.28k | if (mrb_get_argc(mrb) == 1) { |
961 | 1.28k | index = mrb_get_arg1(mrb); |
962 | 1.28k | switch (mrb_type(index)) { |
963 | | /* a[n..m] */ |
964 | 0 | case MRB_TT_RANGE: |
965 | 0 | if (mrb_range_beg_len(mrb, index, &i, &len, ARY_LEN(a), TRUE) == MRB_RANGE_OK) { |
966 | 0 | return ary_subseq(mrb, a, i, len); |
967 | 0 | } |
968 | 0 | else { |
969 | 0 | return mrb_nil_value(); |
970 | 0 | } |
971 | 1.02k | case MRB_TT_INTEGER: |
972 | 1.02k | return mrb_ary_ref(mrb, self, mrb_integer(index)); |
973 | 258 | default: |
974 | 258 | return mrb_ary_ref(mrb, self, aget_index(mrb, index)); |
975 | 1.28k | } |
976 | 1.28k | } |
977 | | |
978 | 0 | mrb_get_args(mrb, "oi", &index, &len); |
979 | 0 | i = aget_index(mrb, index); |
980 | 0 | alen = ARY_LEN(a); |
981 | 0 | if (i < 0) i += alen; |
982 | 0 | if (i < 0 || alen < i) return mrb_nil_value(); |
983 | 0 | if (len < 0) return mrb_nil_value(); |
984 | 0 | if (alen == i) return mrb_ary_new(mrb); |
985 | 0 | if (len > alen - i) len = alen - i; |
986 | |
|
987 | 0 | return ary_subseq(mrb, a, i, len); |
988 | 0 | } |
989 | | |
990 | | /* |
991 | | * call-seq: |
992 | | * ary[index] = obj -> obj |
993 | | * ary[start, length] = obj or other_ary or nil -> obj or other_ary or nil |
994 | | * ary[range] = obj or other_ary or nil -> obj or other_ary or nil |
995 | | * |
996 | | * Element Assignment --- Sets the element at +index+, or replaces a subarray |
997 | | * from the +start+ index for +length+ elements, or replaces a subarray |
998 | | * specified by the +range+ of indices. |
999 | | * |
1000 | | * If indices are greater than the current capacity of the array, the array |
1001 | | * grows automatically. Elements are inserted into the array at +start+ if |
1002 | | * +length+ is zero. |
1003 | | * |
1004 | | * Negative indices will count backward from the end of the array. For |
1005 | | * +start+ and +range+ cases the starting index is just before an element. |
1006 | | * |
1007 | | * An IndexError is raised if a negative index points past the beginning of |
1008 | | * the array. |
1009 | | * |
1010 | | * See also Array#push, and Array#unshift. |
1011 | | * |
1012 | | * a = Array.new |
1013 | | * a[4] = "4"; #=> [nil, nil, nil, nil, "4"] |
1014 | | * a[0, 3] = [ 'a', 'b', 'c' ] #=> ["a", "b", "c", nil, "4"] |
1015 | | * a[1..2] = [ 1, 2 ] #=> ["a", 1, 2, nil, "4"] |
1016 | | * a[0, 2] = "?" #=> ["?", 2, nil, "4"] |
1017 | | * a[0..2] = "A" #=> ["A", "4"] |
1018 | | * a[-1] = "Z" #=> ["A", "Z"] |
1019 | | * a[1..-1] = nil #=> ["A", nil] |
1020 | | * a[1..-1] = [] #=> ["A"] |
1021 | | * a[0, 0] = [ 1, 2 ] #=> [1, 2, "A"] |
1022 | | * a[3, 0] = "B" #=> [1, 2, "A", "B"] |
1023 | | */ |
1024 | | |
1025 | | static mrb_value |
1026 | | mrb_ary_aset(mrb_state *mrb, mrb_value self) |
1027 | 26.6k | { |
1028 | 26.6k | mrb_value v1, v2, v3; |
1029 | 26.6k | mrb_int i, len; |
1030 | | |
1031 | 26.6k | if (mrb_get_argc(mrb) == 2) { |
1032 | 25.5k | const mrb_value *vs = mrb_get_argv(mrb); |
1033 | 25.5k | v1 = vs[0]; v2 = vs[1]; |
1034 | | |
1035 | | /* a[n..m] = v */ |
1036 | 25.5k | switch (mrb_range_beg_len(mrb, v1, &i, &len, RARRAY_LEN(self), FALSE)) { |
1037 | 25.5k | case MRB_RANGE_TYPE_MISMATCH: |
1038 | 25.5k | mrb_ary_set(mrb, self, aget_index(mrb, v1), v2); |
1039 | 25.5k | break; |
1040 | 0 | case MRB_RANGE_OK: |
1041 | 0 | mrb_ary_splice(mrb, self, i, len, v2); |
1042 | 0 | break; |
1043 | 0 | case MRB_RANGE_OUT: |
1044 | 0 | mrb_raisef(mrb, E_RANGE_ERROR, "%v out of range", v1); |
1045 | 0 | break; |
1046 | 25.5k | } |
1047 | 25.5k | return v2; |
1048 | 25.5k | } |
1049 | | |
1050 | 1.15k | mrb_get_args(mrb, "ooo", &v1, &v2, &v3); |
1051 | | /* a[n,m] = v */ |
1052 | 1.15k | mrb_ary_splice(mrb, self, aget_index(mrb, v1), aget_index(mrb, v2), v3); |
1053 | 1.15k | return v3; |
1054 | 26.6k | } |
1055 | | |
1056 | | mrb_value |
1057 | | mrb_ary_delete_at(mrb_state *mrb, mrb_value self) |
1058 | 0 | { |
1059 | 0 | struct RArray *a = mrb_ary_ptr(self); |
1060 | 0 | mrb_int index; |
1061 | 0 | mrb_value val; |
1062 | 0 | mrb_value *ptr; |
1063 | 0 | mrb_int len, alen; |
1064 | |
|
1065 | 0 | index = mrb_as_int(mrb, mrb_get_arg1(mrb)); |
1066 | 0 | alen = ARY_LEN(a); |
1067 | 0 | if (index < 0) index += alen; |
1068 | 0 | if (index < 0 || alen <= index) return mrb_nil_value(); |
1069 | | |
1070 | 0 | ary_modify(mrb, a); |
1071 | 0 | ptr = ARY_PTR(a); |
1072 | 0 | val = ptr[index]; |
1073 | |
|
1074 | 0 | ptr += index; |
1075 | 0 | len = alen - index; |
1076 | 0 | while (--len) { |
1077 | 0 | *ptr = *(ptr+1); |
1078 | 0 | ptr++; |
1079 | 0 | } |
1080 | 0 | ARY_SET_LEN(a, alen-1); |
1081 | |
|
1082 | 0 | ary_shrink_capa(mrb, a); |
1083 | |
|
1084 | 0 | return val; |
1085 | 0 | } |
1086 | | |
1087 | | static mrb_value |
1088 | | mrb_ary_first(mrb_state *mrb, mrb_value self) |
1089 | 0 | { |
1090 | 0 | struct RArray *a = mrb_ary_ptr(self); |
1091 | 0 | mrb_int size, alen; |
1092 | |
|
1093 | 0 | if (mrb_get_argc(mrb) == 0) { |
1094 | 0 | return (ARY_LEN(a) > 0)? ARY_PTR(a)[0]: mrb_nil_value(); |
1095 | 0 | } |
1096 | 0 | mrb_get_args(mrb, "|i", &size); |
1097 | 0 | if (size < 0) { |
1098 | 0 | mrb_raise(mrb, E_ARGUMENT_ERROR, "negative array size"); |
1099 | 0 | } |
1100 | | |
1101 | 0 | alen = ARY_LEN(a); |
1102 | 0 | if (size > alen) size = alen; |
1103 | 0 | if (ARY_SHARED_P(a)) { |
1104 | 0 | return ary_subseq(mrb, a, 0, size); |
1105 | 0 | } |
1106 | 0 | return mrb_ary_new_from_values(mrb, size, ARY_PTR(a)); |
1107 | 0 | } |
1108 | | |
1109 | | static mrb_value |
1110 | | mrb_ary_last(mrb_state *mrb, mrb_value self) |
1111 | 0 | { |
1112 | 0 | struct RArray *a = mrb_ary_ptr(self); |
1113 | 0 | mrb_int n, size, alen; |
1114 | |
|
1115 | 0 | n = mrb_get_args(mrb, "|i", &size); |
1116 | 0 | alen = ARY_LEN(a); |
1117 | 0 | if (n == 0) { |
1118 | 0 | return (alen > 0) ? ARY_PTR(a)[alen - 1]: mrb_nil_value(); |
1119 | 0 | } |
1120 | | |
1121 | 0 | if (size < 0) { |
1122 | 0 | mrb_raise(mrb, E_ARGUMENT_ERROR, "negative array size"); |
1123 | 0 | } |
1124 | 0 | if (size > alen) size = alen; |
1125 | 0 | if (ARY_SHARED_P(a) || size > ARY_DEFAULT_LEN) { |
1126 | 0 | return ary_subseq(mrb, a, alen - size, size); |
1127 | 0 | } |
1128 | 0 | return mrb_ary_new_from_values(mrb, size, ARY_PTR(a) + alen - size); |
1129 | 0 | } |
1130 | | |
1131 | | static mrb_value |
1132 | | mrb_ary_index_m(mrb_state *mrb, mrb_value self) |
1133 | 1.47k | { |
1134 | 1.47k | mrb_value obj = mrb_get_arg1(mrb); |
1135 | | |
1136 | 6.55k | for (mrb_int i = 0; i < RARRAY_LEN(self); i++) { |
1137 | 5.89k | if (mrb_equal(mrb, RARRAY_PTR(self)[i], obj)) { |
1138 | 812 | return mrb_int_value(mrb, i); |
1139 | 812 | } |
1140 | 5.89k | } |
1141 | 658 | return mrb_nil_value(); |
1142 | 1.47k | } |
1143 | | |
1144 | | static mrb_value |
1145 | | mrb_ary_rindex_m(mrb_state *mrb, mrb_value self) |
1146 | 0 | { |
1147 | 0 | mrb_value obj = mrb_get_arg1(mrb); |
1148 | |
|
1149 | 0 | for (mrb_int i = RARRAY_LEN(self) - 1; i >= 0; i--) { |
1150 | 0 | mrb_int len; |
1151 | |
|
1152 | 0 | if (mrb_equal(mrb, RARRAY_PTR(self)[i], obj)) { |
1153 | 0 | return mrb_int_value(mrb, i); |
1154 | 0 | } |
1155 | 0 | if (i > (len = RARRAY_LEN(self))) { |
1156 | 0 | i = len; |
1157 | 0 | } |
1158 | 0 | } |
1159 | 0 | return mrb_nil_value(); |
1160 | 0 | } |
1161 | | |
1162 | | MRB_API mrb_value |
1163 | | mrb_ary_splat(mrb_state *mrb, mrb_value v) |
1164 | 30.0k | { |
1165 | 30.0k | mrb_value ary; |
1166 | 30.0k | struct RArray *a; |
1167 | | |
1168 | 30.0k | if (mrb_array_p(v)) { |
1169 | 30.0k | a = ary_dup(mrb, mrb_ary_ptr(v)); |
1170 | 30.0k | return mrb_obj_value(a); |
1171 | 30.0k | } |
1172 | | |
1173 | 0 | if (!mrb_respond_to(mrb, v, MRB_SYM(to_a))) { |
1174 | 0 | return mrb_ary_new_from_values(mrb, 1, &v); |
1175 | 0 | } |
1176 | | |
1177 | 0 | ary = mrb_funcall_argv(mrb, v, MRB_SYM(to_a), 0, NULL); |
1178 | 0 | if (mrb_nil_p(ary)) { |
1179 | 0 | return mrb_ary_new_from_values(mrb, 1, &v); |
1180 | 0 | } |
1181 | 0 | mrb_ensure_array_type(mrb, ary); |
1182 | 0 | a = mrb_ary_ptr(ary); |
1183 | 0 | a = ary_dup(mrb, a); |
1184 | 0 | return mrb_obj_value(a); |
1185 | 0 | } |
1186 | | |
1187 | | static mrb_value |
1188 | | mrb_ary_size(mrb_state *mrb, mrb_value self) |
1189 | 21.1k | { |
1190 | 21.1k | struct RArray *a = mrb_ary_ptr(self); |
1191 | | |
1192 | 21.1k | return mrb_int_value(mrb, ARY_LEN(a)); |
1193 | 21.1k | } |
1194 | | |
1195 | | MRB_API mrb_value |
1196 | | mrb_ary_clear(mrb_state *mrb, mrb_value self) |
1197 | 0 | { |
1198 | 0 | struct RArray *a = mrb_ary_ptr(self); |
1199 | |
|
1200 | 0 | ary_modify(mrb, a); |
1201 | 0 | if (ARY_SHARED_P(a)) { |
1202 | 0 | mrb_ary_decref(mrb, a->as.heap.aux.shared); |
1203 | 0 | ARY_UNSET_SHARED_FLAG(a); |
1204 | 0 | } |
1205 | 0 | else if (!ARY_EMBED_P(a)){ |
1206 | 0 | mrb_free(mrb, a->as.heap.ptr); |
1207 | 0 | } |
1208 | 0 | if (MRB_ARY_EMBED_LEN_MAX > 0) { |
1209 | 0 | ARY_SET_EMBED_LEN(a, 0); |
1210 | 0 | } |
1211 | 0 | else { |
1212 | 0 | a->as.heap.ptr = NULL; |
1213 | 0 | a->as.heap.aux.capa = 0; |
1214 | 0 | ARY_SET_LEN(a, 0); |
1215 | 0 | } |
1216 | 0 | return self; |
1217 | 0 | } |
1218 | | |
1219 | | static mrb_value |
1220 | | mrb_ary_clear_m(mrb_state *mrb, mrb_value self) |
1221 | 0 | { |
1222 | 0 | return mrb_ary_clear(mrb, self); |
1223 | 0 | } |
1224 | | |
1225 | | static mrb_value |
1226 | | mrb_ary_empty_p(mrb_state *mrb, mrb_value self) |
1227 | 0 | { |
1228 | 0 | struct RArray *a = mrb_ary_ptr(self); |
1229 | |
|
1230 | 0 | return mrb_bool_value(ARY_LEN(a) == 0); |
1231 | 0 | } |
1232 | | |
1233 | | MRB_API mrb_value |
1234 | | mrb_ary_entry(mrb_value ary, mrb_int n) |
1235 | 2.64k | { |
1236 | 2.64k | struct RArray *a = mrb_ary_ptr(ary); |
1237 | 2.64k | mrb_int len = ARY_LEN(a); |
1238 | | |
1239 | | /* range check */ |
1240 | 2.64k | if (n < 0) n += len; |
1241 | 2.64k | if (n < 0 || len <= n) return mrb_nil_value(); |
1242 | | |
1243 | 590 | return ARY_PTR(a)[n]; |
1244 | 2.64k | } |
1245 | | |
1246 | | static mrb_value |
1247 | | join_ary(mrb_state *mrb, mrb_value ary, mrb_value sep, mrb_value list) |
1248 | 0 | { |
1249 | 0 | mrb_value result, val, tmp; |
1250 | | |
1251 | | /* check recursive */ |
1252 | 0 | for (mrb_int i=0; i<RARRAY_LEN(list); i++) { |
1253 | 0 | if (mrb_obj_equal(mrb, ary, RARRAY_PTR(list)[i])) { |
1254 | 0 | mrb_raise(mrb, E_ARGUMENT_ERROR, "recursive array join"); |
1255 | 0 | } |
1256 | 0 | } |
1257 | | |
1258 | 0 | mrb_ary_push(mrb, list, ary); |
1259 | |
|
1260 | 0 | result = mrb_str_new_capa(mrb, 64); |
1261 | |
|
1262 | 0 | for (mrb_int i=0; i<RARRAY_LEN(ary); i++) { |
1263 | 0 | if (i > 0 && !mrb_nil_p(sep)) { |
1264 | 0 | mrb_str_cat_str(mrb, result, sep); |
1265 | 0 | } |
1266 | |
|
1267 | 0 | val = RARRAY_PTR(ary)[i]; |
1268 | 0 | switch (mrb_type(val)) { |
1269 | 0 | case MRB_TT_ARRAY: |
1270 | 0 | ary_join: |
1271 | 0 | val = join_ary(mrb, val, sep, list); |
1272 | | /* fall through */ |
1273 | |
|
1274 | 0 | case MRB_TT_STRING: |
1275 | 0 | str_join: |
1276 | 0 | mrb_str_cat_str(mrb, result, val); |
1277 | 0 | break; |
1278 | | |
1279 | 0 | default: |
1280 | 0 | if (!mrb_immediate_p(val)) { |
1281 | 0 | tmp = mrb_check_string_type(mrb, val); |
1282 | 0 | if (!mrb_nil_p(tmp)) { |
1283 | 0 | val = tmp; |
1284 | 0 | goto str_join; |
1285 | 0 | } |
1286 | 0 | tmp = mrb_check_array_type(mrb, val); |
1287 | 0 | if (!mrb_nil_p(tmp)) { |
1288 | 0 | val = tmp; |
1289 | 0 | goto ary_join; |
1290 | 0 | } |
1291 | 0 | } |
1292 | 0 | val = mrb_obj_as_string(mrb, val); |
1293 | 0 | goto str_join; |
1294 | 0 | } |
1295 | 0 | } |
1296 | | |
1297 | 0 | mrb_ary_pop(mrb, list); |
1298 | |
|
1299 | 0 | return result; |
1300 | 0 | } |
1301 | | |
1302 | | MRB_API mrb_value |
1303 | | mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep) |
1304 | 0 | { |
1305 | 0 | if (!mrb_nil_p(sep)) { |
1306 | 0 | sep = mrb_obj_as_string(mrb, sep); |
1307 | 0 | } |
1308 | 0 | return join_ary(mrb, ary, sep, mrb_ary_new(mrb)); |
1309 | 0 | } |
1310 | | |
1311 | | /* |
1312 | | * call-seq: |
1313 | | * ary.join(sep="") -> str |
1314 | | * |
1315 | | * Returns a string created by converting each element of the array to |
1316 | | * a string, separated by <i>sep</i>. |
1317 | | * |
1318 | | * [ "a", "b", "c" ].join #=> "abc" |
1319 | | * [ "a", "b", "c" ].join("-") #=> "a-b-c" |
1320 | | */ |
1321 | | |
1322 | | static mrb_value |
1323 | | mrb_ary_join_m(mrb_state *mrb, mrb_value ary) |
1324 | 0 | { |
1325 | 0 | mrb_value sep = mrb_nil_value(); |
1326 | |
|
1327 | 0 | mrb_get_args(mrb, "|S!", &sep); |
1328 | 0 | return mrb_ary_join(mrb, ary, sep); |
1329 | 0 | } |
1330 | | |
1331 | | /* |
1332 | | * call-seq: |
1333 | | * ary.to_s -> string |
1334 | | * ary.inspect -> string |
1335 | | * |
1336 | | * Return the contents of this array as a string. |
1337 | | */ |
1338 | | static mrb_value |
1339 | | mrb_ary_to_s(mrb_state *mrb, mrb_value self) |
1340 | 0 | { |
1341 | 0 | mrb->c->ci->mid = MRB_SYM(inspect); |
1342 | 0 | mrb_value ret = mrb_str_new_lit(mrb, "["); |
1343 | 0 | int ai = mrb_gc_arena_save(mrb); |
1344 | 0 | if (mrb_inspect_recursive_p(mrb, self)) { |
1345 | 0 | mrb_str_cat_lit(mrb, ret, "...]"); |
1346 | 0 | return ret; |
1347 | 0 | } |
1348 | 0 | for (mrb_int i=0; i<RARRAY_LEN(self); i++) { |
1349 | 0 | if (i>0) mrb_str_cat_lit(mrb, ret, ", "); |
1350 | 0 | mrb_str_cat_str(mrb, ret, mrb_inspect(mrb, RARRAY_PTR(self)[i])); |
1351 | 0 | mrb_gc_arena_restore(mrb, ai); |
1352 | 0 | } |
1353 | 0 | mrb_str_cat_lit(mrb, ret, "]"); |
1354 | |
|
1355 | 0 | return ret; |
1356 | 0 | } |
1357 | | |
1358 | | static mrb_value |
1359 | | mrb_ary_eq(mrb_state *mrb, mrb_value ary1) |
1360 | 23.8k | { |
1361 | 23.8k | mrb_value ary2 = mrb_get_arg1(mrb); |
1362 | | |
1363 | 23.8k | mrb->c->ci->mid = 0; |
1364 | 23.8k | if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_true_value(); |
1365 | 23.8k | if (!mrb_array_p(ary2)) { |
1366 | 23.8k | return mrb_false_value(); |
1367 | 23.8k | } |
1368 | 0 | if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return mrb_false_value(); |
1369 | | |
1370 | 0 | return ary2; |
1371 | 0 | } |
1372 | | |
1373 | | static mrb_value |
1374 | | mrb_ary_cmp(mrb_state *mrb, mrb_value ary1) |
1375 | 0 | { |
1376 | 0 | mrb_value ary2 = mrb_get_arg1(mrb); |
1377 | |
|
1378 | 0 | mrb->c->ci->mid = 0; |
1379 | 0 | if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_fixnum_value(0); |
1380 | 0 | if (!mrb_array_p(ary2)) { |
1381 | 0 | return mrb_nil_value(); |
1382 | 0 | } |
1383 | | |
1384 | 0 | return ary2; |
1385 | 0 | } |
1386 | | |
1387 | | /* internal method to convert multi-value to single value */ |
1388 | | static mrb_value |
1389 | | mrb_ary_svalue(mrb_state *mrb, mrb_value ary) |
1390 | 0 | { |
1391 | 0 | switch (RARRAY_LEN(ary)) { |
1392 | 0 | case 0: |
1393 | 0 | return mrb_nil_value(); |
1394 | 0 | case 1: |
1395 | 0 | return RARRAY_PTR(ary)[0]; |
1396 | 0 | default: |
1397 | 0 | return ary; |
1398 | 0 | } |
1399 | 0 | } |
1400 | | |
1401 | | void |
1402 | | mrb_init_array(mrb_state *mrb) |
1403 | 476 | { |
1404 | 476 | struct RClass *a; |
1405 | | |
1406 | 476 | mrb->array_class = a = mrb_define_class(mrb, "Array", mrb->object_class); /* 15.2.12 */ |
1407 | 476 | MRB_SET_INSTANCE_TT(a, MRB_TT_ARRAY); |
1408 | | |
1409 | 476 | mrb_define_class_method(mrb, a, "[]", mrb_ary_s_create, MRB_ARGS_ANY()); /* 15.2.12.4.1 */ |
1410 | | |
1411 | 476 | mrb_define_method(mrb, a, "+", mrb_ary_plus, MRB_ARGS_REQ(1)); /* 15.2.12.5.1 */ |
1412 | 476 | mrb_define_method(mrb, a, "*", mrb_ary_times, MRB_ARGS_REQ(1)); /* 15.2.12.5.2 */ |
1413 | 476 | mrb_define_method(mrb, a, "<<", mrb_ary_push_m, MRB_ARGS_REQ(1)); /* 15.2.12.5.3 */ |
1414 | 476 | mrb_define_method(mrb, a, "[]", mrb_ary_aget, MRB_ARGS_ARG(1,1)); /* 15.2.12.5.4 */ |
1415 | 476 | mrb_define_method(mrb, a, "[]=", mrb_ary_aset, MRB_ARGS_ARG(2,1)); /* 15.2.12.5.5 */ |
1416 | 476 | mrb_define_method(mrb, a, "clear", mrb_ary_clear_m, MRB_ARGS_NONE()); /* 15.2.12.5.6 */ |
1417 | 476 | mrb_define_method(mrb, a, "concat", mrb_ary_concat_m, MRB_ARGS_REQ(1)); /* 15.2.12.5.8 */ |
1418 | 476 | mrb_define_method(mrb, a, "delete_at", mrb_ary_delete_at, MRB_ARGS_REQ(1)); /* 15.2.12.5.9 */ |
1419 | 476 | mrb_define_method(mrb, a, "empty?", mrb_ary_empty_p, MRB_ARGS_NONE()); /* 15.2.12.5.12 */ |
1420 | 476 | mrb_define_method(mrb, a, "first", mrb_ary_first, MRB_ARGS_OPT(1)); /* 15.2.12.5.13 */ |
1421 | 476 | mrb_define_method(mrb, a, "index", mrb_ary_index_m, MRB_ARGS_REQ(1)); /* 15.2.12.5.14 */ |
1422 | 476 | mrb_define_method(mrb, a, "initialize_copy", mrb_ary_replace_m, MRB_ARGS_REQ(1)); /* 15.2.12.5.16 */ |
1423 | 476 | mrb_define_method(mrb, a, "join", mrb_ary_join_m, MRB_ARGS_OPT(1)); /* 15.2.12.5.17 */ |
1424 | 476 | mrb_define_method(mrb, a, "last", mrb_ary_last, MRB_ARGS_OPT(1)); /* 15.2.12.5.18 */ |
1425 | 476 | mrb_define_method(mrb, a, "length", mrb_ary_size, MRB_ARGS_NONE()); /* 15.2.12.5.19 */ |
1426 | 476 | mrb_define_method(mrb, a, "pop", mrb_ary_pop, MRB_ARGS_NONE()); /* 15.2.12.5.21 */ |
1427 | 476 | mrb_define_method(mrb, a, "push", mrb_ary_push_m, MRB_ARGS_ANY()); /* 15.2.12.5.22 */ |
1428 | 476 | mrb_define_method(mrb, a, "replace", mrb_ary_replace_m, MRB_ARGS_REQ(1)); /* 15.2.12.5.23 */ |
1429 | 476 | mrb_define_method(mrb, a, "reverse", mrb_ary_reverse, MRB_ARGS_NONE()); /* 15.2.12.5.24 */ |
1430 | 476 | mrb_define_method(mrb, a, "reverse!", mrb_ary_reverse_bang, MRB_ARGS_NONE()); /* 15.2.12.5.25 */ |
1431 | 476 | mrb_define_method(mrb, a, "rindex", mrb_ary_rindex_m, MRB_ARGS_REQ(1)); /* 15.2.12.5.26 */ |
1432 | 476 | mrb_define_method(mrb, a, "shift", mrb_ary_shift_m, MRB_ARGS_OPT(1)); /* 15.2.12.5.27 */ |
1433 | 476 | mrb_define_method(mrb, a, "size", mrb_ary_size, MRB_ARGS_NONE()); /* 15.2.12.5.28 */ |
1434 | 476 | mrb_define_method(mrb, a, "slice", mrb_ary_aget, MRB_ARGS_ARG(1,1)); /* 15.2.12.5.29 */ |
1435 | 476 | mrb_define_method(mrb, a, "unshift", mrb_ary_unshift_m, MRB_ARGS_ANY()); /* 15.2.12.5.30 */ |
1436 | 476 | mrb_define_method(mrb, a, "to_s", mrb_ary_to_s, MRB_ARGS_NONE()); |
1437 | 476 | mrb_define_method(mrb, a, "inspect", mrb_ary_to_s, MRB_ARGS_NONE()); |
1438 | | |
1439 | 476 | mrb_define_method(mrb, a, "__ary_eq", mrb_ary_eq, MRB_ARGS_REQ(1)); |
1440 | 476 | mrb_define_method(mrb, a, "__ary_cmp", mrb_ary_cmp, MRB_ARGS_REQ(1)); |
1441 | 476 | mrb_define_method(mrb, a, "__ary_index", mrb_ary_index_m, MRB_ARGS_REQ(1)); /* kept for mruby-array-ext */ |
1442 | 476 | mrb_define_method(mrb, a, "__svalue", mrb_ary_svalue, MRB_ARGS_NONE()); |
1443 | 476 | } |