Ignore:
Timestamp:
Jul 9, 2020, 8:51:43 AM (4 years ago)
Author:
coas-nagasima
Message:

mrubyを2.1.1に更新

Location:
EcnlProtoTool/trunk/mruby-2.1.1
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/mruby-2.1.1/src/array.c

    r331 r439  
    1010#include <mruby/string.h>
    1111#include <mruby/range.h>
     12#include <mruby/proc.h>
     13#include <mruby/opcode.h>
    1214#include "value_array.h"
    1315
    … …  
    1517#define ARY_SHRINK_RATIO  5 /* must be larger than 2 */
    1618#define ARY_C_MAX_SIZE (SIZE_MAX / sizeof(mrb_value))
    17 #define ARY_MAX_SIZE ((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? (mrb_int)ARY_C_MAX_SIZE : MRB_INT_MAX-1)
     19#define ARY_MAX_SIZE ((mrb_int)((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? ARY_C_MAX_SIZE : MRB_INT_MAX-1))
    1820
    1921static struct RArray*
    … …  
    2931
    3032  a = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class);
    31   a->ptr = (mrb_value *)mrb_malloc(mrb, blen);
    32   a->aux.capa = capa;
    33   a->len = 0;
     33  if (capa <= MRB_ARY_EMBED_LEN_MAX) {
     34    ARY_SET_EMBED_LEN(a, 0);
     35  }
     36  else {
     37    a->as.heap.ptr = (mrb_value *)mrb_malloc(mrb, blen);
     38    a->as.heap.aux.capa = capa;
     39    a->as.heap.len = 0;
     40  }
    3441
    3542  return a;
    … …  
    7380}
    7481
     82static struct RArray*
     83ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals)
     84{
     85  struct RArray *a = ary_new_capa(mrb, size);
     86
     87  array_copy(ARY_PTR(a), vals, size);
     88  ARY_SET_LEN(a, size);
     89
     90  return a;
     91}
     92
    7593MRB_API mrb_value
    7694mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals)
    7795{
    78   struct RArray *a = ary_new_capa(mrb, size);
    79 
    80   array_copy(a->ptr, vals, size);
    81   a->len = size;
    82 
     96  struct RArray *a = ary_new_from_values(mrb, size, vals);
    8397  return mrb_obj_value(a);
    8498}
    … …  
    90104
    91105  a = ary_new_capa(mrb, 2);
    92   a->ptr[0] = car;
    93   a->ptr[1] = cdr;
    94   a->len = 2;
     106  ARY_PTR(a)[0] = car;
     107  ARY_PTR(a)[1] = cdr;
     108  ARY_SET_LEN(a, 2);
    95109  return mrb_obj_value(a);
    96110}
    … …  
    107121
    108122static void
     123ary_modify_check(mrb_state *mrb, struct RArray *a)
     124{
     125  mrb_check_frozen(mrb, a);
     126}
     127
     128static void
    109129ary_modify(mrb_state *mrb, struct RArray *a)
    110130{
    111   if (MRB_FROZEN_P(a)) {
    112     mrb_raise(mrb, E_RUNTIME_ERROR, "can't modify frozen array");
    113   }
     131  ary_modify_check(mrb, a);
    114132
    115133  if (ARY_SHARED_P(a)) {
    116     mrb_shared_array *shared = a->aux.shared;
    117 
    118     if (shared->refcnt == 1 && a->ptr == shared->ptr) {
    119       a->ptr = shared->ptr;
    120       a->aux.capa = a->len;
     134    mrb_shared_array *shared = a->as.heap.aux.shared;
     135
     136    if (shared->refcnt == 1 && a->as.heap.ptr == shared->ptr) {
     137      a->as.heap.ptr = shared->ptr;
     138      a->as.heap.aux.capa = a->as.heap.len;
    121139      mrb_free(mrb, shared);
    122140    }
    … …  
    125143      mrb_int len;
    126144
    127       p = a->ptr;
    128       len = a->len * sizeof(mrb_value);
     145      p = a->as.heap.ptr;
     146      len = a->as.heap.len * sizeof(mrb_value);
    129147      ptr = (mrb_value *)mrb_malloc(mrb, len);
    130148      if (p) {
    131         array_copy(ptr, p, a->len);
     149        array_copy(ptr, p, a->as.heap.len);
    132150      }
    133       a->ptr = ptr;
    134       a->aux.capa = a->len;
     151      a->as.heap.ptr = ptr;
     152      a->as.heap.aux.capa = a->as.heap.len;
    135153      mrb_ary_decref(mrb, shared);
    136154    }
    … …  
    149167ary_make_shared(mrb_state *mrb, struct RArray *a)
    150168{
    151   if (!ARY_SHARED_P(a)) {
     169  if (!ARY_SHARED_P(a) && !ARY_EMBED_P(a)) {
    152170    mrb_shared_array *shared = (mrb_shared_array *)mrb_malloc(mrb, sizeof(mrb_shared_array));
     171    mrb_value *ptr = a->as.heap.ptr;
     172    mrb_int len = a->as.heap.len;
    153173
    154174    shared->refcnt = 1;
    155     if (a->aux.capa > a->len) {
    156       a->ptr = shared->ptr = (mrb_value *)mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*a->len+1);
     175    if (a->as.heap.aux.capa > len) {
     176      a->as.heap.ptr = shared->ptr = (mrb_value *)mrb_realloc(mrb, ptr, sizeof(mrb_value)*len+1);
    157177    }
    158178    else {
    159       shared->ptr = a->ptr;
    160     }
    161     shared->len = a->len;
    162     a->aux.shared = shared;
     179      shared->ptr = ptr;
     180    }
     181    shared->len = len;
     182    a->as.heap.aux.shared = shared;
    163183    ARY_SET_SHARED_FLAG(a);
    164184  }
    … …  
    168188ary_expand_capa(mrb_state *mrb, struct RArray *a, mrb_int len)
    169189{
    170   mrb_int capa = a->aux.capa;
    171 
    172   if (len > ARY_MAX_SIZE) {
     190  mrb_int capa = ARY_CAPA(a);
     191
     192  if (len > ARY_MAX_SIZE || len < 0) {
    173193  size_error:
    174194    mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
    175195  }
    176196
    177   if (capa == 0) {
     197  if (capa < ARY_DEFAULT_LEN) {
    178198    capa = ARY_DEFAULT_LEN;
    179199  }
    … …  
    190210  }
    191211
    192   if (capa > a->aux.capa) {
    193     mrb_value *expanded_ptr = (mrb_value *)mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa);
    194 
    195     a->aux.capa = capa;
    196     a->ptr = expanded_ptr;
     212  if (ARY_EMBED_P(a)) {
     213    mrb_value *ptr = ARY_EMBED_PTR(a);
     214    mrb_int len = ARY_EMBED_LEN(a);
     215    mrb_value *expanded_ptr = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*capa);
     216
     217    ARY_UNSET_EMBED_FLAG(a);
     218    array_copy(expanded_ptr, ptr, len);
     219    a->as.heap.len = len;
     220    a->as.heap.aux.capa = capa;
     221    a->as.heap.ptr = expanded_ptr;
     222  }
     223  else if (capa > a->as.heap.aux.capa) {
     224    mrb_value *expanded_ptr = (mrb_value *)mrb_realloc(mrb, a->as.heap.ptr, sizeof(mrb_value)*capa);
     225
     226    a->as.heap.aux.capa = capa;
     227    a->as.heap.ptr = expanded_ptr;
    197228  }
    198229}
    … …  
    201232ary_shrink_capa(mrb_state *mrb, struct RArray *a)
    202233{
    203   mrb_int capa = a->aux.capa;
    204 
     234
     235  mrb_int capa;
     236
     237  if (ARY_EMBED_P(a)) return;
     238
     239  capa = a->as.heap.aux.capa;
    205240  if (capa < ARY_DEFAULT_LEN * 2) return;
    206   if (capa <= a->len * ARY_SHRINK_RATIO) return;
     241  if (capa <= a->as.heap.len * ARY_SHRINK_RATIO) return;
    207242
    208243  do {
    … …  
    212247      break;
    213248    }
    214   } while (capa > a->len * ARY_SHRINK_RATIO);
    215 
    216   if (capa > a->len && capa < a->aux.capa) {
    217     a->aux.capa = capa;
    218     a->ptr = (mrb_value *)mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*capa);
     249  } while (capa > a->as.heap.len * ARY_SHRINK_RATIO);
     250
     251  if (capa > a->as.heap.len && capa < a->as.heap.aux.capa) {
     252    a->as.heap.aux.capa = capa;
     253    a->as.heap.ptr = (mrb_value *)mrb_realloc(mrb, a->as.heap.ptr, sizeof(mrb_value)*capa);
    219254  }
    220255}
    … …  
    229264  old_len = RARRAY_LEN(ary);
    230265  if (old_len != new_len) {
    231     a->len = new_len;
    232266    if (new_len < old_len) {
    233267      ary_shrink_capa(mrb, a);
    … …  
    235269    else {
    236270      ary_expand_capa(mrb, a, new_len);
    237       ary_fill_with_nil(a->ptr + old_len, new_len - old_len);
    238     }
     271      ary_fill_with_nil(ARY_PTR(a) + old_len, new_len - old_len);
     272    }
     273    ARY_SET_LEN(a, new_len);
    239274  }
    240275
    … …  
    250285  struct RArray *a;
    251286
    252   mrb_get_args(mrb, "*", &vals, &len);
     287  mrb_get_args(mrb, "*!", &vals, &len);
    253288  ary = mrb_ary_new_from_values(mrb, len, vals);
    254289  a = mrb_ary_ptr(ary);
    … …  
    258293}
    259294
     295static void ary_replace(mrb_state*, struct RArray*, struct RArray*);
     296
    260297static void
    261298ary_concat(mrb_state *mrb, struct RArray *a, struct RArray *a2)
    … …  
    263300  mrb_int len;
    264301
    265   if (a2->len > ARY_MAX_SIZE - a->len) {
     302  if (ARY_LEN(a) == 0) {
     303    ary_replace(mrb, a, a2);
     304    return;
     305  }
     306  if (ARY_LEN(a2) > ARY_MAX_SIZE - ARY_LEN(a)) {
    266307    mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
    267308  }
    268   len = a->len + a2->len;
     309  len = ARY_LEN(a) + ARY_LEN(a2);
    269310
    270311  ary_modify(mrb, a);
    271   if (a->aux.capa < len) {
     312  if (ARY_CAPA(a) < len) {
    272313    ary_expand_capa(mrb, a, len);
    273314  }
    274   array_copy(a->ptr+a->len, a2->ptr, a2->len);
     315  array_copy(ARY_PTR(a)+ARY_LEN(a), ARY_PTR(a2), ARY_LEN(a2));
    275316  mrb_write_barrier(mrb, (struct RBasic*)a);
    276   a->len = len;
     317  ARY_SET_LEN(a, len);
    277318}
    278319
    … …  
    301342  struct RArray *a2;
    302343  mrb_value *ptr;
    303   mrb_int blen;
     344  mrb_int blen, len1;
    304345
    305346  mrb_get_args(mrb, "a", &ptr, &blen);
    306   if (ARY_MAX_SIZE - blen < a1->len) {
     347  if (ARY_MAX_SIZE - blen < ARY_LEN(a1)) {
    307348    mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
    308349  }
    309   a2 = ary_new_capa(mrb, a1->len + blen);
    310   array_copy(a2->ptr, a1->ptr, a1->len);
    311   array_copy(a2->ptr + a1->len, ptr, blen);
    312   a2->len = a1->len + blen;
     350  len1 = ARY_LEN(a1);
     351  a2 = ary_new_capa(mrb, len1 + blen);
     352  array_copy(ARY_PTR(a2), ARY_PTR(a1), len1);
     353  array_copy(ARY_PTR(a2) + len1, ptr, blen);
     354  ARY_SET_LEN(a2, len1+blen);
    313355
    314356  return mrb_obj_value(a2);
    315357}
    316358
     359#define ARY_REPLACE_SHARED_MIN 20
     360
    317361static void
    318 ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, mrb_int len)
    319 {
    320   ary_modify(mrb, a);
    321   if (a->aux.capa < len)
     362ary_replace(mrb_state *mrb, struct RArray *a, struct RArray *b)
     363{
     364  mrb_int len = ARY_LEN(b);
     365
     366  ary_modify_check(mrb, a);
     367  if (a == b) return;
     368  if (ARY_SHARED_P(a)) {
     369    mrb_ary_decref(mrb, a->as.heap.aux.shared);
     370    a->as.heap.aux.capa = 0;
     371    a->as.heap.len = 0;
     372    a->as.heap.ptr = NULL;
     373    ARY_UNSET_SHARED_FLAG(a);
     374  }
     375  if (ARY_SHARED_P(b)) {
     376  shared_b:
     377    if (ARY_EMBED_P(a)) {
     378      ARY_UNSET_EMBED_FLAG(a);
     379    }
     380    else {
     381      mrb_free(mrb, a->as.heap.ptr);
     382    }
     383    a->as.heap.ptr = b->as.heap.ptr;
     384    a->as.heap.len = len;
     385    a->as.heap.aux.shared = b->as.heap.aux.shared;
     386    a->as.heap.aux.shared->refcnt++;
     387    ARY_SET_SHARED_FLAG(a);
     388    mrb_write_barrier(mrb, (struct RBasic*)a);
     389    return;
     390  }
     391  if (!mrb_frozen_p(b) && len > ARY_REPLACE_SHARED_MIN) {
     392    ary_make_shared(mrb, b);
     393    goto shared_b;
     394  }
     395  if (ARY_CAPA(a) < len)
    322396    ary_expand_capa(mrb, a, len);
    323   array_copy(a->ptr, argv, len);
     397  array_copy(ARY_PTR(a), ARY_PTR(b), len);
    324398  mrb_write_barrier(mrb, (struct RBasic*)a);
    325   a->len = len;
     399  ARY_SET_LEN(a, len);
    326400}
    327401
    … …  
    333407
    334408  if (a1 != a2) {
    335     ary_replace(mrb, a1, a2->ptr, a2->len);
     409    ary_replace(mrb, a1, a2);
    336410  }
    337411}
    … …  
    354428  struct RArray *a2;
    355429  mrb_value *ptr;
    356   mrb_int times;
     430  mrb_int times, len1;
    357431
    358432  mrb_get_args(mrb, "i", &times);
    … …  
    361435  }
    362436  if (times == 0) return mrb_ary_new(mrb);
    363   if (ARY_MAX_SIZE / times < a1->len) {
     437  if (ARY_MAX_SIZE / times < ARY_LEN(a1)) {
    364438    mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
    365439  }
    366   a2 = ary_new_capa(mrb, a1->len * times);
    367   ptr = a2->ptr;
     440  len1 = ARY_LEN(a1);
     441  a2 = ary_new_capa(mrb, len1 * times);
     442  ARY_SET_LEN(a2, len1 * times);
     443  ptr = ARY_PTR(a2);
    368444  while (times--) {
    369     array_copy(ptr, a1->ptr, a1->len);
    370     ptr += a1->len;
    371     a2->len += a1->len;
     445    array_copy(ptr, ARY_PTR(a1), len1);
     446    ptr += len1;
    372447  }
    373448
    … …  
    379454{
    380455  struct RArray *a = mrb_ary_ptr(self);
    381 
    382   if (a->len > 1) {
     456  mrb_int len = ARY_LEN(a);
     457
     458  if (len > 1) {
    383459    mrb_value *p1, *p2;
    384460
    385461    ary_modify(mrb, a);
    386     p1 = a->ptr;
    387     p2 = a->ptr + a->len - 1;
     462    p1 = ARY_PTR(a);
     463    p2 = p1 + len - 1;
    388464
    389465    while (p1 < p2) {
    … …  
    399475mrb_ary_reverse(mrb_state *mrb, mrb_value self)
    400476{
    401   struct RArray *a = mrb_ary_ptr(self), *b = ary_new_capa(mrb, a->len);
    402 
    403   if (a->len > 0) {
     477  struct RArray *a = mrb_ary_ptr(self), *b = ary_new_capa(mrb, ARY_LEN(a));
     478  mrb_int len = ARY_LEN(a);
     479
     480  if (len > 0) {
    404481    mrb_value *p1, *p2, *e;
    405482
    406     p1 = a->ptr;
    407     e  = p1 + a->len;
    408     p2 = b->ptr + a->len - 1;
     483    p1 = ARY_PTR(a);
     484    e  = p1 + len;
     485    p2 = ARY_PTR(b) + len - 1;
    409486    while (p1 < e) {
    410487      *p2-- = *p1++;
    411488    }
    412     b->len = a->len;
     489    ARY_SET_LEN(b, len);
    413490  }
    414491  return mrb_obj_value(b);
    … …  
    419496{
    420497  struct RArray *a = mrb_ary_ptr(ary);
     498  mrb_int len = ARY_LEN(a);
    421499
    422500  ary_modify(mrb, a);
    423   if (a->len == a->aux.capa)
    424     ary_expand_capa(mrb, a, a->len + 1);
    425   a->ptr[a->len++] = elem;
     501  if (len == ARY_CAPA(a))
     502    ary_expand_capa(mrb, a, len + 1);
     503  ARY_PTR(a)[len] = elem;
     504  ARY_SET_LEN(a, len+1);
    426505  mrb_field_write_barrier_value(mrb, (struct RBasic*)a, elem);
    427506}
    … …  
    431510{
    432511  mrb_value *argv;
    433   mrb_int len;
    434 
    435   mrb_get_args(mrb, "*", &argv, &len);
    436   while (len--) {
    437     mrb_ary_push(mrb, self, *argv++);
    438   }
     512  mrb_int len, len2, alen;
     513  struct RArray *a;
     514
     515  mrb_get_args(mrb, "*!", &argv, &alen);
     516  a = mrb_ary_ptr(self);
     517  ary_modify(mrb, a);
     518  len = ARY_LEN(a);
     519  len2 = len + alen;
     520  if (ARY_CAPA(a) < len2) {
     521    ary_expand_capa(mrb, a, len2);
     522  }
     523  array_copy(ARY_PTR(a)+len, argv, alen);
     524  ARY_SET_LEN(a, len2);
     525  mrb_write_barrier(mrb, (struct RBasic*)a);
    439526
    440527  return self;
    … …  
    445532{
    446533  struct RArray *a = mrb_ary_ptr(ary);
    447 
    448   ary_modify(mrb, a);
    449   if (a->len == 0) return mrb_nil_value();
    450   return a->ptr[--a->len];
     534  mrb_int len = ARY_LEN(a);
     535
     536  ary_modify_check(mrb, a);
     537  if (len == 0) return mrb_nil_value();
     538  ARY_SET_LEN(a, len-1);
     539  return ARY_PTR(a)[len-1];
    451540}
    452541
    … …  
    457546{
    458547  struct RArray *a = mrb_ary_ptr(self);
     548  mrb_int len = ARY_LEN(a);
    459549  mrb_value val;
    460550
    461   ary_modify(mrb, a);
    462   if (a->len == 0) return mrb_nil_value();
     551  ary_modify_check(mrb, a);
     552  if (len == 0) return mrb_nil_value();
    463553  if (ARY_SHARED_P(a)) {
    464554  L_SHIFT:
    465     val = a->ptr[0];
    466     a->ptr++;
    467     a->len--;
     555    val = a->as.heap.ptr[0];
     556    a->as.heap.ptr++;
     557    a->as.heap.len--;
    468558    return val;
    469559  }
    470   if (a->len > ARY_SHIFT_SHARED_MIN) {
     560  if (len > ARY_SHIFT_SHARED_MIN) {
    471561    ary_make_shared(mrb, a);
    472562    goto L_SHIFT;
    473563  }
    474564  else {
    475     mrb_value *ptr = a->ptr;
    476     mrb_int size = a->len;
     565    mrb_value *ptr = ARY_PTR(a);
     566    mrb_int size = len;
    477567
    478568    val = *ptr;
    … …  
    481571      ++ptr;
    482572    }
    483     --a->len;
     573    ARY_SET_LEN(a, len-1);
    484574  }
    485575  return val;
    … …  
    494584{
    495585  struct RArray *a = mrb_ary_ptr(self);
     586  mrb_int len = ARY_LEN(a);
    496587
    497588  if (ARY_SHARED_P(a)
    498       && a->aux.shared->refcnt == 1 /* shared only referenced from this array */
    499       && a->ptr - a->aux.shared->ptr >= 1) /* there's room for unshifted item */ {
    500     a->ptr--;
    501     a->ptr[0] = item;
     589      && a->as.heap.aux.shared->refcnt == 1 /* shared only referenced from this array */
     590      && a->as.heap.ptr - a->as.heap.aux.shared->ptr >= 1) /* there's room for unshifted item */ {
     591    a->as.heap.ptr--;
     592    a->as.heap.ptr[0] = item;
    502593  }
    503594  else {
     595    mrb_value *ptr;
     596
    504597    ary_modify(mrb, a);
    505     if (a->aux.capa < a->len + 1)
    506       ary_expand_capa(mrb, a, a->len + 1);
    507     value_move(a->ptr + 1, a->ptr, a->len);
    508     a->ptr[0] = item;
    509   }
    510   a->len++;
     598    if (ARY_CAPA(a) < len + 1)
     599      ary_expand_capa(mrb, a, len + 1);
     600    ptr = ARY_PTR(a);
     601    value_move(ptr + 1, ptr, len);
     602    ptr[0] = item;
     603  }
     604  ARY_SET_LEN(a, len+1);
    511605  mrb_field_write_barrier_value(mrb, (struct RBasic*)a, item);
    512606
    … …  
    518612{
    519613  struct RArray *a = mrb_ary_ptr(self);
    520   mrb_value *vals;
    521   mrb_int len;
    522 
    523   mrb_get_args(mrb, "*", &vals, &len);
    524   if (len > ARY_MAX_SIZE - a->len) {
     614  mrb_value *vals, *ptr;
     615  mrb_int alen, len;
     616
     617  mrb_get_args(mrb, "*!", &vals, &alen);
     618  if (alen == 0) {
     619    ary_modify_check(mrb, a);
     620    return self;
     621  }
     622  len = ARY_LEN(a);
     623  if (alen > ARY_MAX_SIZE - len) {
    525624    mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
    526625  }
    527626  if (ARY_SHARED_P(a)
    528       && a->aux.shared->refcnt == 1 /* shared only referenced from this array */
    529       && a->ptr - a->aux.shared->ptr >= len) /* there's room for unshifted item */ {
    530     a->ptr -= len;
     627      && a->as.heap.aux.shared->refcnt == 1 /* shared only referenced from this array */
     628      && a->as.heap.ptr - a->as.heap.aux.shared->ptr >= alen) /* there's room for unshifted item */ {
     629    ary_modify_check(mrb, a);
     630    a->as.heap.ptr -= alen;
     631    ptr = a->as.heap.ptr;
    531632  }
    532633  else {
     634    mrb_bool same = vals == ARY_PTR(a);
    533635    ary_modify(mrb, a);
    534     if (len == 0) return self;
    535     if (a->aux.capa < a->len + len)
    536       ary_expand_capa(mrb, a, a->len + len);
    537     value_move(a->ptr + len, a->ptr, a->len);
    538   }
    539   array_copy(a->ptr, vals, len);
    540   a->len += len;
    541   while (len--) {
    542     mrb_field_write_barrier_value(mrb, (struct RBasic*)a, vals[len]);
     636    if (ARY_CAPA(a) < len + alen)
     637      ary_expand_capa(mrb, a, len + alen);
     638    ptr = ARY_PTR(a);
     639    value_move(ptr + alen, ptr, len);
     640    if (same) vals = ptr;
     641  }
     642  array_copy(ptr, vals, alen);
     643  ARY_SET_LEN(a, len+alen);
     644  while (alen--) {
     645    mrb_field_write_barrier_value(mrb, (struct RBasic*)a, vals[alen]);
    543646  }
    544647
    … …  
    550653{
    551654  struct RArray *a = mrb_ary_ptr(ary);
     655  mrb_int len = ARY_LEN(a);
    552656
    553657  /* range check */
    554   if (n < 0) n += a->len;
    555   if (n < 0 || a->len <= n) return mrb_nil_value();
    556 
    557   return a->ptr[n];
     658  if (n < 0) n += len;
     659  if (n < 0 || len <= n) return mrb_nil_value();
     660
     661  return ARY_PTR(a)[n];
    558662}
    559663
    … …  
    562666{
    563667  struct RArray *a = mrb_ary_ptr(ary);
     668  mrb_int len = ARY_LEN(a);
    564669
    565670  ary_modify(mrb, a);
    566671  /* range check */
    567672  if (n < 0) {
    568     n += a->len;
     673    n += len;
    569674    if (n < 0) {
    570       mrb_raisef(mrb, E_INDEX_ERROR, "index %S out of array", mrb_fixnum_value(n - a->len));
    571     }
    572   }
    573   if (a->len <= n) {
    574     if (a->aux.capa <= n)
     675      mrb_raisef(mrb, E_INDEX_ERROR, "index %i out of array", n - len);
     676    }
     677  }
     678  if (len <= n) {
     679    if (ARY_CAPA(a) <= n)
    575680      ary_expand_capa(mrb, a, n + 1);
    576     ary_fill_with_nil(a->ptr + a->len, n + 1 - a->len);
    577     a->len = n + 1;
    578   }
    579 
    580   a->ptr[n] = val;
     681    ary_fill_with_nil(ARY_PTR(a) + len, n + 1 - len);
     682    ARY_SET_LEN(a, n+1);
     683  }
     684
     685  ARY_PTR(a)[n] = val;
    581686  mrb_field_write_barrier_value(mrb, (struct RBasic*)a, val);
    582687}
    … …  
    585690ary_dup(mrb_state *mrb, struct RArray *a)
    586691{
    587   struct RArray *d = ary_new_capa(mrb, a->len);
    588 
    589   ary_replace(mrb, d, a->ptr, a->len);
    590   return d;
     692  return ary_new_from_values(mrb, ARY_LEN(a), ARY_PTR(a));
    591693}
    592694
    … …  
    595697{
    596698  struct RArray *a = mrb_ary_ptr(ary);
     699  mrb_int alen = ARY_LEN(a);
    597700  const mrb_value *argv;
    598701  mrb_int argc;
    … …  
    602705
    603706  /* len check */
    604   if (len < 0) mrb_raisef(mrb, E_INDEX_ERROR, "negative length (%S)", mrb_fixnum_value(len));
     707  if (len < 0) mrb_raisef(mrb, E_INDEX_ERROR, "negative length (%i)", len);
    605708
    606709  /* range check */
    607710  if (head < 0) {
    608     head += a->len;
     711    head += alen;
    609712    if (head < 0) {
    610713      mrb_raise(mrb, E_INDEX_ERROR, "index is out of array");
    … …  
    612715  }
    613716  tail = head + len;
    614   if (a->len < len || a->len < tail) {
    615     len = a->len - head;
     717  if (alen < len || alen < tail) {
     718    len = alen - head;
    616719  }
    617720
    … …  
    620723    argc = RARRAY_LEN(rpl);
    621724    argv = RARRAY_PTR(rpl);
    622     if (argv == a->ptr) {
     725    if (argv == ARY_PTR(a)) {
    623726      struct RArray *r;
    624727
    … …  
    627730      }
    628731      r = ary_dup(mrb, a);
    629       argv = r->ptr;
     732      argv = ARY_PTR(r);
    630733    }
    631734  }
    … …  
    634737    argv = &rpl;
    635738  }
    636   if (head >= a->len) {
     739  if (head >= alen) {
    637740    if (head > ARY_MAX_SIZE - argc) {
    638       mrb_raisef(mrb, E_INDEX_ERROR, "index %S too big", mrb_fixnum_value(head));
     741      mrb_raisef(mrb, E_INDEX_ERROR, "index %i too big", head);
    639742    }
    640743    len = head + argc;
    641     if (len > a->aux.capa) {
     744    if (len > ARY_CAPA(a)) {
    642745      ary_expand_capa(mrb, a, head + argc);
    643746    }
    644     ary_fill_with_nil(a->ptr + a->len, head - a->len);
     747    ary_fill_with_nil(ARY_PTR(a) + alen, head - alen);
    645748    if (argc > 0) {
    646       array_copy(a->ptr + head, argv, argc);
    647     }
    648     a->len = len;
     749      array_copy(ARY_PTR(a) + head, argv, argc);
     750    }
     751    ARY_SET_LEN(a, len);
    649752  }
    650753  else {
    651     mrb_int alen;
    652 
    653     if (a->len - len > ARY_MAX_SIZE - argc) {
    654       mrb_raisef(mrb, E_INDEX_ERROR, "index %S too big", mrb_fixnum_value(a->len + argc - len));
    655     }
    656     alen = a->len + argc - len;
    657     if (alen > a->aux.capa) {
    658       ary_expand_capa(mrb, a, alen);
     754    mrb_int newlen;
     755
     756    if (alen - len > ARY_MAX_SIZE - argc) {
     757      mrb_raisef(mrb, E_INDEX_ERROR, "index %i too big", alen + argc - len);
     758    }
     759    newlen = alen + argc - len;
     760    if (newlen > ARY_CAPA(a)) {
     761      ary_expand_capa(mrb, a, newlen);
    659762    }
    660763
    661764    if (len != argc) {
     765      mrb_value *ptr = ARY_PTR(a);
    662766      tail = head + len;
    663       value_move(a->ptr + head + argc, a->ptr + tail, a->len - tail);
    664       a->len = alen;
     767      value_move(ptr + head + argc, ptr + tail, alen - tail);
     768      ARY_SET_LEN(a, newlen);
    665769    }
    666770    if (argc > 0) {
    667       value_move(a->ptr + head, argv, argc);
     771      value_move(ARY_PTR(a) + head, argv, argc);
    668772    }
    669773  }
    … …  
    687791  struct RArray *b;
    688792
     793  if (!ARY_SHARED_P(a) && len <= ARY_SHIFT_SHARED_MIN) {
     794    return mrb_ary_new_from_values(mrb, len, ARY_PTR(a)+beg);
     795  }
    689796  ary_make_shared(mrb, a);
    690797  b  = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class);
    691   b->ptr = a->ptr + beg;
    692   b->len = len;
    693   b->aux.shared = a->aux.shared;
    694   b->aux.shared->refcnt++;
     798  b->as.heap.ptr = a->as.heap.ptr + beg;
     799  b->as.heap.len = len;
     800  b->as.heap.aux.shared = a->as.heap.aux.shared;
     801  b->as.heap.aux.shared->refcnt++;
    695802  ARY_SET_SHARED_FLAG(b);
    696803
    … …  
    704811    return mrb_fixnum(index);
    705812  }
     813#ifndef MRB_WITHOUT_FLOAT
    706814  else if (mrb_float_p(index)) {
    707815    return (mrb_int)mrb_float(index);
    708816  }
     817#endif
    709818  else {
    710819    mrb_int i, argc;
    711820    mrb_value *argv;
    712821
    713     mrb_get_args(mrb, "i*", &i, &argv, &argc);
     822    mrb_get_args(mrb, "i*!", &i, &argv, &argc);
    714823    return i;
    715824  }
    … …  
    747856{
    748857  struct RArray *a = mrb_ary_ptr(self);
    749   mrb_int i, len;
     858  mrb_int i, len, alen;
    750859  mrb_value index;
    751860
    … …  
    754863      /* a[n..m] */
    755864    case MRB_TT_RANGE:
    756       if (mrb_range_beg_len(mrb, index, &i, &len, a->len, TRUE) == 1) {
     865      if (mrb_range_beg_len(mrb, index, &i, &len, ARY_LEN(a), TRUE) == MRB_RANGE_OK) {
    757866        return ary_subseq(mrb, a, i, len);
    758867      }
    … …  
    768877
    769878  i = aget_index(mrb, index);
    770   if (i < 0) i += a->len;
    771   if (i < 0 || a->len < i) return mrb_nil_value();
     879  alen = ARY_LEN(a);
     880  if (i < 0) i += alen;
     881  if (i < 0 || alen < i) return mrb_nil_value();
    772882  if (len < 0) return mrb_nil_value();
    773   if (a->len == i) return mrb_ary_new(mrb);
    774   if (len > a->len - i) len = a->len - i;
     883  if (alen == i) return mrb_ary_new(mrb);
     884  if (len > alen - i) len = alen - i;
    775885
    776886  return ary_subseq(mrb, a, i, len);
    … …  
    822932    /* a[n..m] = v */
    823933    switch (mrb_range_beg_len(mrb, v1, &i, &len, RARRAY_LEN(self), FALSE)) {
    824     case 0:                   /* not range */
     934    case MRB_RANGE_TYPE_MISMATCH:
    825935      mrb_ary_set(mrb, self, aget_index(mrb, v1), v2);
    826936      break;
    827     case 1:                   /* range */
     937    case MRB_RANGE_OK:
    828938      mrb_ary_splice(mrb, self, i, len, v2);
    829939      break;
    830     case 2:                   /* out of range */
    831       mrb_raisef(mrb, E_RANGE_ERROR, "%S out of range", v1);
     940    case MRB_RANGE_OUT:
     941      mrb_raisef(mrb, E_RANGE_ERROR, "%v out of range", v1);
    832942      break;
    833943    }
    … …  
    847957  mrb_value val;
    848958  mrb_value *ptr;
    849   mrb_int len;
     959  mrb_int len, alen;
    850960
    851961  mrb_get_args(mrb, "i", &index);
    852   if (index < 0) index += a->len;
    853   if (index < 0 || a->len <= index) return mrb_nil_value();
     962  alen = ARY_LEN(a);
     963  if (index < 0) index += alen;
     964  if (index < 0 || alen <= index) return mrb_nil_value();
    854965
    855966  ary_modify(mrb, a);
    856   val = a->ptr[index];
    857 
    858   ptr = a->ptr + index;
    859   len = a->len - index;
     967  ptr = ARY_PTR(a);
     968  val = ptr[index];
     969
     970  ptr += index;
     971  len = alen - index;
    860972  while (--len) {
    861973    *ptr = *(ptr+1);
    862974    ++ptr;
    863975  }
    864   --a->len;
     976  ARY_SET_LEN(a, alen-1);
    865977
    866978  ary_shrink_capa(mrb, a);
    … …  
    873985{
    874986  struct RArray *a = mrb_ary_ptr(self);
    875   mrb_int size;
    876 
    877   if (mrb_get_args(mrb, "|i", &size) == 0) {
    878     return (a->len > 0)? a->ptr[0]: mrb_nil_value();
    879   }
     987  mrb_int size, alen;
     988
     989  if (mrb_get_argc(mrb) == 0) {
     990    return (ARY_LEN(a) > 0)? ARY_PTR(a)[0]: mrb_nil_value();
     991  }
     992  mrb_get_args(mrb, "|i", &size);
    880993  if (size < 0) {
    881994    mrb_raise(mrb, E_ARGUMENT_ERROR, "negative array size");
    882995  }
    883996
    884   if (size > a->len) size = a->len;
     997  alen = ARY_LEN(a);
     998  if (size > alen) size = alen;
    885999  if (ARY_SHARED_P(a)) {
    8861000    return ary_subseq(mrb, a, 0, size);
    8871001  }
    888   return mrb_ary_new_from_values(mrb, size, a->ptr);
     1002  return mrb_ary_new_from_values(mrb, size, ARY_PTR(a));
    8891003}
    8901004
    … …  
    8931007{
    8941008  struct RArray *a = mrb_ary_ptr(self);
    895   mrb_int size;
    896 
    897   if (mrb_get_args(mrb, "|i", &size) == 0)
    898     return (a->len > 0)? a->ptr[a->len - 1]: mrb_nil_value();
     1009  mrb_int n, size, alen;
     1010
     1011  n = mrb_get_args(mrb, "|i", &size);
     1012  alen = ARY_LEN(a);
     1013  if (n == 0) {
     1014    return (alen > 0) ? ARY_PTR(a)[alen - 1]: mrb_nil_value();
     1015  }
    8991016
    9001017  if (size < 0) {
    9011018    mrb_raise(mrb, E_ARGUMENT_ERROR, "negative array size");
    9021019  }
    903   if (size > a->len) size = a->len;
     1020  if (size > alen) size = alen;
    9041021  if (ARY_SHARED_P(a) || size > ARY_DEFAULT_LEN) {
    905     return ary_subseq(mrb, a, a->len - size, size);
    906   }
    907   return mrb_ary_new_from_values(mrb, size, a->ptr + a->len - size);
     1022    return ary_subseq(mrb, a, alen - size, size);
     1023  }
     1024  return mrb_ary_new_from_values(mrb, size, ARY_PTR(a) + alen - size);
    9081025}
    9091026
    … …  
    9441061mrb_ary_splat(mrb_state *mrb, mrb_value v)
    9451062{
    946   mrb_value a, recv_class;
     1063  mrb_value a;
    9471064
    9481065  if (mrb_array_p(v)) {
    … …  
    9551072
    9561073  a = mrb_funcall(mrb, v, "to_a", 0);
    957   if (mrb_array_p(a)) {
    958     return a;
    959   }
    960   else if (mrb_nil_p(a)) {
     1074  if (mrb_nil_p(a)) {
    9611075    return mrb_ary_new_from_values(mrb, 1, &v);
    9621076  }
    963   else {
    964     recv_class = mrb_obj_value(mrb_obj_class(mrb, v));
    965     mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %S to Array (%S#to_a gives %S)",
    966       recv_class,
    967       recv_class,
    968       mrb_obj_value(mrb_obj_class(mrb, a))
    969     );
    970     /* not reached */
    971     return mrb_undef_value();
    972   }
     1077  mrb_ensure_array_type(mrb, a);
     1078  return a;
    9731079}
    9741080
    … …  
    9781084  struct RArray *a = mrb_ary_ptr(self);
    9791085
    980   return mrb_fixnum_value(a->len);
     1086  return mrb_fixnum_value(ARY_LEN(a));
    9811087}
    9821088
    … …  
    9881094  ary_modify(mrb, a);
    9891095  if (ARY_SHARED_P(a)) {
    990     mrb_ary_decref(mrb, a->aux.shared);
     1096    mrb_ary_decref(mrb, a->as.heap.aux.shared);
    9911097    ARY_UNSET_SHARED_FLAG(a);
    9921098  }
    993   else {
    994     mrb_free(mrb, a->ptr);
    995   }
    996   a->len = 0;
    997   a->aux.capa = 0;
    998   a->ptr = 0;
     1099  else if (!ARY_EMBED_P(a)){
     1100    mrb_free(mrb, a->as.heap.ptr);
     1101  }
     1102  ARY_SET_EMBED_LEN(a, 0);
    9991103
    10001104  return self;
    … …  
    10021106
    10031107static mrb_value
     1108mrb_ary_clear_m(mrb_state *mrb, mrb_value self)
     1109{
     1110  return mrb_ary_clear(mrb, self);
     1111}
     1112
     1113static mrb_value
    10041114mrb_ary_empty_p(mrb_state *mrb, mrb_value self)
    10051115{
    10061116  struct RArray *a = mrb_ary_ptr(self);
    10071117
    1008   return mrb_bool_value(a->len == 0);
    1009 }
    1010 
    1011 MRB_API mrb_value
    1012 mrb_check_array_type(mrb_state *mrb, mrb_value ary)
    1013 {
    1014   return mrb_check_convert_type(mrb, ary, MRB_TT_ARRAY, "Array", "to_ary");
     1118  return mrb_bool_value(ARY_LEN(a) == 0);
    10151119}
    10161120
    … …  
    10211125    offset += RARRAY_LEN(ary);
    10221126  }
    1023   return ary_elt(ary, offset);
     1127  if (offset < 0 || RARRAY_LEN(ary) <= offset) {
     1128    return mrb_nil_value();
     1129  }
     1130  return RARRAY_PTR(ary)[offset];
    10241131}
    10251132
    … …  
    10391146  mrb_ary_push(mrb, list, ary);
    10401147
    1041   result = mrb_str_buf_new(mrb, 64);
     1148  result = mrb_str_new_capa(mrb, 64);
    10421149
    10431150  for (i=0; i<RARRAY_LEN(ary); i++) {
    … …  
    10651172          goto str_join;
    10661173        }
    1067         tmp = mrb_check_convert_type(mrb, val, MRB_TT_ARRAY, "Array", "to_ary");
     1174        tmp = mrb_check_array_type(mrb, val);
    10681175        if (!mrb_nil_p(tmp)) {
    10691176          val = tmp;
    … …  
    11391246}
    11401247
     1248/* internal method to convert multi-value to single value */
     1249static mrb_value
     1250mrb_ary_svalue(mrb_state *mrb, mrb_value ary)
     1251{
     1252  switch (RARRAY_LEN(ary)) {
     1253  case 0:
     1254    return mrb_nil_value();
     1255  case 1:
     1256    return RARRAY_PTR(ary)[0];
     1257  default:
     1258    return ary;
     1259  }
     1260}
     1261
     1262static const mrb_code each_iseq[] = {
     1263  OP_ENTER, 0x0, 0x00, 0x1,  /* OP_ENTER     0:0:0:0:0:0:1 */
     1264  OP_JMPIF, 0x1, 0x0, 19,    /* OP_JMPIF     R1  19 */
     1265  OP_LOADSELF, 0x3,          /* OP_LOADSELF  R3 */
     1266  OP_LOADSYM, 0x4, 0x0,      /* OP_LOADSYM   R4  :each*/
     1267  OP_SEND, 0x3, 0x1, 0x1,    /* OP_SEND      R3  :to_enum   1 */
     1268  OP_RETURN, 0x3,            /* OP_RETURN    R3 */
     1269  OP_LOADI_0, 0x2,           /* OP_LOADI_0   R2 */
     1270  OP_JMP, 0x0, 43,           /* OP_JMP       49 */
     1271  OP_MOVE, 0x3, 0x1,         /* OP_MOVE      R3  R1 */
     1272  OP_LOADSELF, 0x4,          /* OP_LOADSELF  R4 */
     1273  OP_MOVE, 0x5, 0x2,         /* OP_MOVE      R5  R2 */
     1274  OP_SEND, 0x4, 0x2, 0x1,    /* OP_SEND      R4  :[]        1 */
     1275  OP_SEND, 0x3, 0x3, 0x1,    /* OP_SEND      R3  :call      1 */
     1276  OP_ADDI, 0x2, 1,           /* OP_ADDI      R3  1 */
     1277  OP_MOVE, 0x3, 0x2,         /* OP_MOVE      R3  R2 */
     1278  OP_LOADSELF, 0x4,          /* OP_LOADSELF  R4 */
     1279  OP_SEND, 0x4, 0x4, 0x0,    /* OP_SEND      R4  :length    0 */
     1280  OP_LT, 0x3,                /* OP_LT        R3 */
     1281  OP_JMPIF, 0x3, 0x0, 24,    /* OP_JMPIF     R3  24 */
     1282  OP_RETURN, 0x0             /* OP_RETURN    R3 */
     1283};
     1284
     1285static void
     1286init_ary_each(mrb_state *mrb, struct RClass *ary)
     1287{
     1288  struct RProc *p;
     1289  mrb_method_t m;
     1290  mrb_irep *each_irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep));
     1291  static const mrb_irep mrb_irep_zero = { 0 };
     1292
     1293  *each_irep = mrb_irep_zero;
     1294  each_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*5);
     1295  each_irep->syms[0] = mrb_intern_lit(mrb, "each");
     1296  each_irep->syms[1] = mrb_intern_lit(mrb, "to_enum");
     1297  each_irep->syms[2] = mrb_intern_lit(mrb, "[]");
     1298  each_irep->syms[3] = mrb_intern_lit(mrb, "call");
     1299  each_irep->syms[4] = mrb_intern_lit(mrb, "length");
     1300  each_irep->slen = 5;
     1301  each_irep->flags = MRB_ISEQ_NO_FREE;
     1302  each_irep->iseq = each_iseq;
     1303  each_irep->ilen = sizeof(each_iseq);
     1304  each_irep->nregs = 7;
     1305  each_irep->nlocals = 3;
     1306  p = mrb_proc_new(mrb, each_irep);
     1307  p->flags |= MRB_PROC_SCOPE | MRB_PROC_STRICT;
     1308  MRB_METHOD_FROM_PROC(m, p);
     1309  mrb_define_method_raw(mrb, ary, mrb_intern_lit(mrb, "each"), m);
     1310}
     1311
    11411312void
    11421313mrb_init_array(mrb_state *mrb)
    … …  
    11441315  struct RClass *a;
    11451316
    1146   mrb->array_class = a = mrb_define_class(mrb, "Array", mrb->object_class);            /* 15.2.12 */
     1317  mrb->array_class = a = mrb_define_class(mrb, "Array", mrb->object_class);              /* 15.2.12 */
    11471318  MRB_SET_INSTANCE_TT(a, MRB_TT_ARRAY);
    11481319
    1149   mrb_define_class_method(mrb, a, "[]",        mrb_ary_s_create,     MRB_ARGS_ANY());  /* 15.2.12.4.1 */
    1150 
    1151   mrb_define_method(mrb, a, "+",               mrb_ary_plus,         MRB_ARGS_REQ(1)); /* 15.2.12.5.1  */
    1152   mrb_define_method(mrb, a, "*",               mrb_ary_times,        MRB_ARGS_REQ(1)); /* 15.2.12.5.2  */
    1153   mrb_define_method(mrb, a, "<<",              mrb_ary_push_m,       MRB_ARGS_REQ(1)); /* 15.2.12.5.3  */
    1154   mrb_define_method(mrb, a, "[]",              mrb_ary_aget,         MRB_ARGS_ANY());  /* 15.2.12.5.4  */
    1155   mrb_define_method(mrb, a, "[]=",             mrb_ary_aset,         MRB_ARGS_ANY());  /* 15.2.12.5.5  */
    1156   mrb_define_method(mrb, a, "clear",           mrb_ary_clear,        MRB_ARGS_NONE()); /* 15.2.12.5.6  */
    1157   mrb_define_method(mrb, a, "concat",          mrb_ary_concat_m,     MRB_ARGS_REQ(1)); /* 15.2.12.5.8  */
    1158   mrb_define_method(mrb, a, "delete_at",       mrb_ary_delete_at,    MRB_ARGS_REQ(1)); /* 15.2.12.5.9  */
    1159   mrb_define_method(mrb, a, "empty?",          mrb_ary_empty_p,      MRB_ARGS_NONE()); /* 15.2.12.5.12 */
    1160   mrb_define_method(mrb, a, "first",           mrb_ary_first,        MRB_ARGS_OPT(1)); /* 15.2.12.5.13 */
    1161   mrb_define_method(mrb, a, "index",           mrb_ary_index_m,      MRB_ARGS_REQ(1)); /* 15.2.12.5.14 */
    1162   mrb_define_method(mrb, a, "initialize_copy", mrb_ary_replace_m,    MRB_ARGS_REQ(1)); /* 15.2.12.5.16 */
    1163   mrb_define_method(mrb, a, "join",            mrb_ary_join_m,       MRB_ARGS_ANY());  /* 15.2.12.5.17 */
    1164   mrb_define_method(mrb, a, "last",            mrb_ary_last,         MRB_ARGS_ANY());  /* 15.2.12.5.18 */
    1165   mrb_define_method(mrb, a, "length",          mrb_ary_size,         MRB_ARGS_NONE()); /* 15.2.12.5.19 */
    1166   mrb_define_method(mrb, a, "pop",             mrb_ary_pop,          MRB_ARGS_NONE()); /* 15.2.12.5.21 */
    1167   mrb_define_method(mrb, a, "push",            mrb_ary_push_m,       MRB_ARGS_ANY());  /* 15.2.12.5.22 */
    1168   mrb_define_method(mrb, a, "append",          mrb_ary_push_m,       MRB_ARGS_ANY());
    1169   mrb_define_method(mrb, a, "replace",         mrb_ary_replace_m,    MRB_ARGS_REQ(1)); /* 15.2.12.5.23 */
    1170   mrb_define_method(mrb, a, "reverse",         mrb_ary_reverse,      MRB_ARGS_NONE()); /* 15.2.12.5.24 */
    1171   mrb_define_method(mrb, a, "reverse!",        mrb_ary_reverse_bang, MRB_ARGS_NONE()); /* 15.2.12.5.25 */
    1172   mrb_define_method(mrb, a, "rindex",          mrb_ary_rindex_m,     MRB_ARGS_REQ(1)); /* 15.2.12.5.26 */
    1173   mrb_define_method(mrb, a, "shift",           mrb_ary_shift,        MRB_ARGS_NONE()); /* 15.2.12.5.27 */
    1174   mrb_define_method(mrb, a, "size",            mrb_ary_size,         MRB_ARGS_NONE()); /* 15.2.12.5.28 */
    1175   mrb_define_method(mrb, a, "slice",           mrb_ary_aget,         MRB_ARGS_ANY());  /* 15.2.12.5.29 */
    1176   mrb_define_method(mrb, a, "unshift",         mrb_ary_unshift_m,    MRB_ARGS_ANY());  /* 15.2.12.5.30 */
    1177   mrb_define_method(mrb, a, "prepend",         mrb_ary_unshift_m,    MRB_ARGS_ANY());
     1320  mrb_define_class_method(mrb, a, "[]",        mrb_ary_s_create,     MRB_ARGS_ANY());    /* 15.2.12.4.1 */
     1321
     1322  mrb_define_method(mrb, a, "+",               mrb_ary_plus,         MRB_ARGS_REQ(1));   /* 15.2.12.5.1  */
     1323  mrb_define_method(mrb, a, "*",               mrb_ary_times,        MRB_ARGS_REQ(1));   /* 15.2.12.5.2  */
     1324  mrb_define_method(mrb, a, "<<",              mrb_ary_push_m,       MRB_ARGS_REQ(1));   /* 15.2.12.5.3  */
     1325  mrb_define_method(mrb, a, "[]",              mrb_ary_aget,         MRB_ARGS_ARG(1,1)); /* 15.2.12.5.4  */
     1326  mrb_define_method(mrb, a, "[]=",             mrb_ary_aset,         MRB_ARGS_ARG(2,1)); /* 15.2.12.5.5  */
     1327  mrb_define_method(mrb, a, "clear",           mrb_ary_clear_m,      MRB_ARGS_NONE());   /* 15.2.12.5.6  */
     1328  mrb_define_method(mrb, a, "concat",          mrb_ary_concat_m,     MRB_ARGS_REQ(1));   /* 15.2.12.5.8  */
     1329  mrb_define_method(mrb, a, "delete_at",       mrb_ary_delete_at,    MRB_ARGS_REQ(1));   /* 15.2.12.5.9  */
     1330  mrb_define_method(mrb, a, "empty?",          mrb_ary_empty_p,      MRB_ARGS_NONE());   /* 15.2.12.5.12 */
     1331  mrb_define_method(mrb, a, "first",           mrb_ary_first,        MRB_ARGS_OPT(1));   /* 15.2.12.5.13 */
     1332  mrb_define_method(mrb, a, "index",           mrb_ary_index_m,      MRB_ARGS_REQ(1));   /* 15.2.12.5.14 */
     1333  mrb_define_method(mrb, a, "initialize_copy", mrb_ary_replace_m,    MRB_ARGS_REQ(1));   /* 15.2.12.5.16 */
     1334  mrb_define_method(mrb, a, "join",            mrb_ary_join_m,       MRB_ARGS_OPT(1));   /* 15.2.12.5.17 */
     1335  mrb_define_method(mrb, a, "last",            mrb_ary_last,         MRB_ARGS_OPT(1));   /* 15.2.12.5.18 */
     1336  mrb_define_method(mrb, a, "length",          mrb_ary_size,         MRB_ARGS_NONE());   /* 15.2.12.5.19 */
     1337  mrb_define_method(mrb, a, "pop",             mrb_ary_pop,          MRB_ARGS_NONE());   /* 15.2.12.5.21 */
     1338  mrb_define_method(mrb, a, "push",            mrb_ary_push_m,       MRB_ARGS_ANY());    /* 15.2.12.5.22 */
     1339  mrb_define_method(mrb, a, "replace",         mrb_ary_replace_m,    MRB_ARGS_REQ(1));   /* 15.2.12.5.23 */
     1340  mrb_define_method(mrb, a, "reverse",         mrb_ary_reverse,      MRB_ARGS_NONE());   /* 15.2.12.5.24 */
     1341  mrb_define_method(mrb, a, "reverse!",        mrb_ary_reverse_bang, MRB_ARGS_NONE());   /* 15.2.12.5.25 */
     1342  mrb_define_method(mrb, a, "rindex",          mrb_ary_rindex_m,     MRB_ARGS_REQ(1));   /* 15.2.12.5.26 */
     1343  mrb_define_method(mrb, a, "shift",           mrb_ary_shift,        MRB_ARGS_NONE());   /* 15.2.12.5.27 */
     1344  mrb_define_method(mrb, a, "size",            mrb_ary_size,         MRB_ARGS_NONE());   /* 15.2.12.5.28 */
     1345  mrb_define_method(mrb, a, "slice",           mrb_ary_aget,         MRB_ARGS_ARG(1,1)); /* 15.2.12.5.29 */
     1346  mrb_define_method(mrb, a, "unshift",         mrb_ary_unshift_m,    MRB_ARGS_ANY());    /* 15.2.12.5.30 */
    11781347
    11791348  mrb_define_method(mrb, a, "__ary_eq",        mrb_ary_eq,           MRB_ARGS_REQ(1));
    11801349  mrb_define_method(mrb, a, "__ary_cmp",       mrb_ary_cmp,          MRB_ARGS_REQ(1));
    1181   mrb_define_method(mrb, a, "__ary_index",     mrb_ary_index_m,      MRB_ARGS_REQ(1)); /* kept for mruby-array-ext */
    1182 }
     1350  mrb_define_method(mrb, a, "__ary_index",     mrb_ary_index_m,      MRB_ARGS_REQ(1));   /* kept for mruby-array-ext */
     1351  mrb_define_method(mrb, a, "__svalue",        mrb_ary_svalue,       MRB_ARGS_NONE());
     1352
     1353  init_ary_each(mrb, a);
     1354}
Note: See TracChangeset for help on using the changeset viewer.