+/* Raises an ArgumentError when array size exceeds limits */

+/* Checks if array size would exceed limits and raises error if so */

+/* Creates a new RArray with specified capacity */

+/**

+ * Creates a new array with a specified initial capacity.

+ *

+ * This function allocates an array that can hold at least `capa` elements

+ * without needing to immediately reallocate memory. If `capa` is 0,

+ * it may still allocate a small default capacity.

+ *

+ * @param mrb The mruby state.

+ * @param capa The initial capacity desired for the array.

+ * @return A new mrb_value representing the created array.

+ */

+/**

+ * Creates a new, empty array.

+ *

+ * This function is equivalent to calling `mrb_ary_new_capa` with a capacity of 0.

+ * The array will dynamically resize as elements are added.

+ *

+ * @param mrb The mruby state.

+ * @return A new mrb_value representing the created empty array.

+ */

+/* Portable array copy function to avoid memcpy issues on some platforms */

+/* Creates a new RArray initialized with values from an array */

+/**

+ * Creates a new array initialized with a given sequence of values.

+ *

+ * This function allocates an array and copies `size` elements from the `vals`

+ * pointer into the new array.

+ *

+ * @param mrb The mruby state.

+ * @param size The number of values to initialize the array with.

+ * @param vals A pointer to an array of `mrb_value`s to copy into the new array.

+ * @return A new mrb_value representing the created array.

+ */

+/**

+ * Creates a new array of size 2, typically used to represent an association (key-value pair).

+ *

+ * The first element of the array is `car` (often the key), and the second element

+ * is `cdr` (often the value).

+ *

+ * @param mrb The mruby state.

+ * @param car The first value to be placed in the array.

+ * @param cdr The second value to be placed in the array.

+ * @return A new mrb_value representing the created 2-element array.

+ */

+/* Fills array elements with nil values */

+/* Prepares array for modification, handling shared arrays and frozen check */

+/**

+ * Prepares an array for modification.

+ *

+ * This function ensures that the array is not frozen and is not shared.

+ * If the array is shared and has multiple references, this function will

+ * duplicate the array data to ensure that modifications do not affect

+ * other references. It also triggers a write barrier for the garbage collector.

+ *

+ * @param mrb The mruby state.

+ * @param a A pointer to the RArray structure to modify.

+ */

+/* Converts array to shared representation for copy-on-write semantics */

+/* Creates a shared copy of array for temporary GC protection.

+ * Frozen arrays are returned as-is (cannot be modified).

+ * Embedded arrays get full copy (cannot be shared).

+ * Heap arrays get zero-copy shared reference.

+ */

+MRB_API mrb_value

+mrb_ary_make_shared_copy(mrb_state *mrb, mrb_value ary)

+{

+ struct RArray *orig = mrb_ary_ptr(ary);

+

+ // Frozen arrays don't need protection

+ if (mrb_frozen_p(orig)) {

+ return ary;

+ }

+

+ // Embedded arrays can't be shared - make full copy

+ if (ARY_EMBED_P(orig)) {

+ return mrb_ary_dup(mrb, ary);

+ }

+

+ // Make original array shared if not already

+ if (!ARY_SHARED_P(orig)) {

+ ary_make_shared(mrb, orig);

+ }

+

+ // Create new array that shares the buffer

+ struct RArray *shared = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class);

+

+ shared->as.heap.ptr = orig->as.heap.ptr;

+ shared->as.heap.len = orig->as.heap.len;

+ shared->as.heap.aux.shared = orig->as.heap.aux.shared;

+ shared->as.heap.aux.shared->refcnt++;

+ ARY_SET_SHARED_FLAG(shared);

+ mrb_write_barrier(mrb, (struct RBasic*)shared);

+

+ return mrb_obj_value(shared);

+}

+

+/* Expands array capacity to accommodate at least len elements */

+/* Shrinks array capacity to save memory when array becomes much smaller */

+/**

+ * Resizes an array to a new length.

+ *

+ * If `new_len` is smaller than the current length, the array is truncated.

+ * If `new_len` is larger than the current length, the array is expanded,

+ * and new elements are filled with `nil`.

+ * This function modifies the array in place.

+ *

+ * @param mrb The mruby state.

+ * @param ary The array (mrb_value) to resize.

+ * @param new_len The desired new length of the array.

+ * @return The resized array (the same mrb_value as `ary`).

+ */

+/*

+ * call-seq:

+ * Array[obj, ...] -> new_array

+ *

+ * Creates a new Array containing the given objects:

+ *

+ * Array[1, 'a', /^A/] # => [1, "a", /^A/]

+ * Array[1, 2, 3] # => [1, 2, 3]

+ * Array[] # => []

+ */

+/*

+ * call-seq:

+ * Array.new(size=0, default=nil) -> new_array

+ * Array.new(array) -> new_array

+ * Array.new(size) {|index| ... } -> new_array

+ *

+ * Returns a new Array.

+ *

+ * With no block and no arguments, returns a new empty Array object.

+ *

+ * With no block and a single `size` argument, returns a new Array object

+ * of the given size whose elements are all `nil`:

+ *

+ * a = Array.new(3)

+ * a # => [nil, nil, nil]

+ * a.size # => 3

+ *

+ * With no block and arguments `size` and `default`, returns an Array object

+ * of the given size; each element is the same `default` object:

+ *

+ * a = Array.new(3, 'x')

+ * a # => ['x', 'x', 'x']

+ *

+ * With a block and argument `size`, returns an Array object of the given size;

+ * the block is called with each successive integer `index`;

+ * the element for that `index` is the return value from the block:

+ *

+ * a = Array.new(3) {|index| "Element #{index}" }

+ * a # => ["Element 0", "Element 1", "Element 2"]

+ *

+ * With a single Array argument `array`, returns a new Array formed from `array`:

+ *

+ * a = Array.new([:foo, 'bar', 2])

+ * a.class # => Array

+ * a # => [:foo, "bar", 2]

+ */

+/* Internal helper to concatenate two arrays */

+/**

+ * Concatenates one array to another.

+ *

+ * Appends all elements from the `other` array to the `self` array.

+ * This function modifies the `self` array in place.

+ *

+ * @param mrb The mruby state.

+ * @param self The array (mrb_value) to which elements will be added.

+ * @param other The array (mrb_value) whose elements will be appended.

+ */

+ * Adds to `array` all elements from each \Array in `other_arrays`; returns `self`:

+/*

+ * call-seq:

+ * array + other_array -> new_array

+ *

+ * Returns a new Array containing all elements of `array`

+ * followed by all elements of `other_array`:

+ *

+ * a = [0, 1] + [2, 3]

+ * a # => [0, 1, 2, 3]

+ */

+/* Internal helper to replace array contents with another array */

+/**

+ * Replaces the contents of an array with the contents of another array.

+ *

+ * After this operation, the `self` array will contain the same elements

+ * as the `other` array. This function modifies the `self` array in place.

+ *

+ * @param mrb The mruby state.

+ * @param self The array (mrb_value) whose contents will be replaced.

+ * @param other The array (mrb_value) from which to copy the elements.

+ */

+/*

+ * call-seq:

+ * array.replace(other_array) -> self

+ * array.initialize_copy(other_array) -> self

+ *

+ * Replaces the contents of `self` with the contents of `other_array`;

+ * returns `self`:

+ *

+ * a = [0, 1, 2]

+ * a.replace(['foo', 'bar']) # => ["foo", "bar"]

+ * a # => ["foo", "bar"]

+ */

+/*

+ * call-seq:

+ * array * int -> new_array

+ * array * str -> new_string

+ *

+ * When the argument is an Integer `n`,

+ * returns a new Array built by concatenating `n` copies of `self`:

+ *

+ * a = ['x', 'y']

+ * a * 3 # => ["x", "y", "x", "y", "x", "y"]

+ *

+ * When the argument is a String `separator`,

+ * equivalent to `array.join(separator)`:

+ *

+ * [1, 2, 3] * '|' # => "1|2|3"

+ */

+/*

+ * call-seq:

+ * array.reverse! -> self

+ *

+ * Reverses `self` in place:

+ *

+ * a = ['foo', 'bar', 'two']

+ * a.reverse! # => ["two", "bar", "foo"]

+ * a # => ["two", "bar", "foo"]

+ */

+/*

+ * call-seq:

+ * array.reverse -> new_array

+ *

+ * Returns a new Array with the elements of `self` in reverse order:

+ *

+ * a = ['foo', 'bar', 'two']

+ * a1 = a.reverse

+ * a1 # => ["two", "bar", "foo"]

+ * a # => ["foo", "bar", "two"]

+ */

+/**

+ * Pushes an element onto the end of an array.

+ *

+ * This function appends `elem` to the `ary` array, increasing its length by one.

+ * The array capacity may be expanded if necessary.

+ * This function modifies the array in place.

+ *

+ * @param mrb The mruby state.

+ * @param ary The array (mrb_value) to push the element onto.

+ * @param elem The mrb_value to append to the array.

+ */

+/*

+ * call-seq:

+ * array.push(*objects) -> self

+ * array << object -> self

+ *

+ * Appends trailing elements.

+ *

+ * Appends each argument in `objects` to `self`; returns `self`:

+ *

+ * a = [:foo, 'bar', 2]

+ * a.push(:baz, :bat) # => [:foo, "bar", 2, :baz, :bat]

+ *

+ * Appends `object` to `self`; returns `self`:

+ *

+ * a = [:foo, 'bar', 2]

+ * a << :baz # => [:foo, "bar", 2, :baz]

+ */

+/**

+ * Removes and returns the last element from an array.

+ *

+ * If the array is empty, returns `nil`.

+ * This function modifies the array in place.

+ *

+ * @param mrb The mruby state.

+ * @param ary The array (mrb_value) from which to pop the element.

+ * @return The last element of the array, or `nil` if the array is empty.

+ */

+/**

+ * Removes and returns the first element from an array.

+ *

+ * If the array is empty, returns `nil`.

+ * All other elements are shifted down by one index.

+ * This function modifies the array in place.

+ *

+ * @param mrb The mruby state.

+ * @param self The array (mrb_value) from which to shift the element.

+ * @return The first element of the array, or `nil` if the array is empty.

+ */

+/*

+ * call-seq:

+ * array.shift -> object or nil

+ * array.shift(n) -> new_array

+ *

+ * Removes and returns leading elements.

+ *

+ * When no argument is given, removes and returns the first element:

+ *

+ * a = [:foo, 'bar', 2]

+ * a.shift # => :foo

+ * a # => ["bar", 2]

+ *

+ * Returns `nil` if `self` is empty.

+ *

+ * When argument `n` is given, removes and returns the first `n` elements in a new Array:

+ *

+ * a = [:foo, 'bar', 2]

+ * a.shift(2) # => [:foo, "bar"]

+ * a # => [2]

+ */

+/**

+ * Prepends an element to the beginning of an array.

+ *

+ * This function adds `item` to the front of the `self` array,

+ * shifting all existing elements up by one index.

+ * The array capacity may be expanded if necessary.

+ * This function modifies the array in place.

+ *

+ * @param mrb The mruby state.

+ * @param self The array (mrb_value) to unshift the element onto.

+ * @param item The mrb_value to prepend to the array.

+ * @return The modified array (the same mrb_value as `self`).

+ */

+ * Prepends the given `objects` to `self`:

+/**

+ * Sets the element at a given index in an array.

+ *

+ * If `n` is within the current bounds of the array, the element at that index

+ * is replaced with `val`.

+ * If `n` is beyond the current bounds, the array is expanded to accommodate

+ * the new element, and any intermediate elements are filled with `nil`.

+ * If `n` is negative, it counts from the end of the array.

+ * An IndexError is raised if a negative index points past the beginning of the array.

+ * This function modifies the array in place.

+ *

+ * @param mrb The mruby state.

+ * @param ary The array (mrb_value) to modify.

+ * @param n The index at which to set the element.

+ * @param val The mrb_value to set at the specified index.

+ */

+/* Creates a duplicate of an array */

+mrb_ary_dup(mrb_state *mrb, mrb_value ary)

+{

+ return mrb_obj_value(ary_dup(mrb, mrb_ary_ptr(ary)));

+}

+

+/**

+ * Replaces a portion of an array with elements from another array or a single value.

+ *

+ * Removes `len` elements from `ary` starting at `head` index, and inserts

+ * the elements from `rpl` (if `rpl` is an array) or `rpl` itself (if it's not an array)

+ * at that position.

+ * If `head` is negative, it counts from the end of the array.

+ * If `len` is negative, an IndexError is raised.

+ * If `rpl` is `mrb_undef_p()`, then the elements are removed without replacement.

+ * This function modifies the `ary` array in place.

+ *

+ * @param mrb The mruby state.

+ * @param ary The array (mrb_value) to modify.

+ * @param head The starting index for the splice operation.

+ * @param len The number of elements to remove.

+ * @param rpl The mrb_value to insert (can be an array or a single value, or mrb_undef_p()).

+ * @return The modified array (the same mrb_value as `ary`).

+ */

+MRB_API mrb_value

+

+ mrb_int tail = head + len;

+/* Creates a subsequence array, using shared storage when appropriate */

+/**

+ * Creates a new array that is a subsequence of an existing array.

+ *

+ * The new array contains `len` elements, starting from index `beg` of the

+ * original `ary`.

+ * This function attempts to create a shared array if appropriate for efficiency.

+ *

+ * @param mrb The mruby state.

+ * @param ary The original array (mrb_value).

+ * @param beg The starting index of the subsequence.

+ * @param len The length of the subsequence.

+ * @return A new mrb_value representing the subsequence array.

+ */

+/* Converts various types to array index integer */

+ * Element Reference --- Returns the element at `index`, or returns a

+ * subarray starting at the `start` index and continuing for `length`

+ * elements, or returns a subarray specified by `range` of indices.

+ * element). For `start` and `range` cases the starting index is just before

+ * Returns `nil` if the index (or starting index) are out of range.

+ * Element Assignment --- Sets the element at `index`, or replaces a subarray

+ * from the `start` index for `length` elements, or replaces a subarray

+ * specified by the `range` of indices.

+ * grows automatically. Elements are inserted into the array at `start` if

+ * `length` is zero.

+ * `start` and `range` cases the starting index is just before an element.

+/*

+ * call-seq:

+ * array.first -> object or nil

+ * array.first(n) -> new_array

+ *

+ * Returns elements from the beginning of `self`.

+ *

+ * When no argument is given, returns the first element:

+ *

+ * a = [:foo, 'bar', 2]

+ * a.first # => :foo

+ * a # => [:foo, "bar", 2]

+ *

+ * If `self` is empty, returns `nil`.

+ *

+ * When non-negative Integer argument `n` is given,

+ * returns the first `n` elements in a new Array:

+ *

+ * a = [:foo, 'bar', 2]

+ * a.first(2) # => [:foo, "bar"]

+ */

+/*

+ * call-seq:

+ * array.last -> object or nil

+ * array.last(n) -> new_array

+ *

+ * Returns elements from the end of `self`.

+ *

+ * When no argument is given, returns the last element:

+ *

+ * a = [:foo, 'bar', 2]

+ * a.last # => 2

+ * a # => [:foo, "bar", 2]

+ *

+ * If `self` is empty, returns `nil`.

+ *

+ * When non-negative Integer argument `n` is given,

+ * returns the last `n` elements in a new Array:

+ *

+ * a = [:foo, 'bar', 2]

+ * a.last(2) # => ["bar", 2]

+ */

+ * Returns the _index_ of the first object in `ary` such that the object is

+ * `==` to `obj`.

+ * first object for which the block returns `true`. Returns `nil` if no

+ * Returns the _index_ of the first object in `ary` such that the object is

+ * `==` to `obj`.

+ * first object for which the block returns `true`. Returns `nil` if no

+/**

+ * Creates a new array from a given value, performing a "splat" operation.

+ *

+ * If `v` is already an array, a duplicate of `v` is returned.

+ * If `v` responds to `to_a`, it is called, and if the result is an array,

+ * a duplicate of that result is returned. If `to_a` returns `nil` or something

+ * other than an array, `v` itself is wrapped in a new, single-element array.

+ * Otherwise (if `v` is not an array and does not respond to `to_a`),

+ * `v` itself is wrapped in a new, single-element array.

+ *

+ * @param mrb The mruby state.

+ * @param v The mrb_value to convert into an array.

+ * @return A new mrb_value representing the "splatted" array.

+ */

+/*

+ * call-seq:

+ * array.size -> integer

+ * array.length -> integer

+ *

+ * Returns the count of elements in `self`:

+ *

+ * [0, 1, 2].size # => 3

+ * [].size # => 0

+ */

+/**

+ * Removes all elements from an array, making it empty.

+ *

+ * This function modifies the array in place.

+ *

+ * @param mrb The mruby state.

+ * @param self The array (mrb_value) to clear.

+ * @return The cleared (now empty) array (the same mrb_value as `self`).

+ */

+/*

+ * call-seq:

+ * array.empty? -> true or false

+ *

+ * Returns `true` if the count of elements in `self` is zero,

+ * `false` otherwise:

+ *

+ * [].empty? # => true

+ * [0].empty? # => false

+ */

+/**

+ * Retrieves an element from an array at a specific index.

+ * This is a direct (unsafe) equivalent of `RARRAY_PTR(ary)[n]`.

+ *

+ * If `n` is negative, it counts from the end of the array.

+ * Returns `nil` if the index is out of bounds.

+ * This function does not perform a bounds check before accessing the element if the index is positive.

+ * Prefer using `mrb_ary_ref` for safe access or ensure `n` is within bounds.

+ *

+ * @param ary The array (mrb_value) from which to retrieve the element.

+ * @param n The index of the element to retrieve.

+ * @return The mrb_value at the specified index, or `nil` if out of bounds.

+ */

+/**

+ * Joins the elements of an array into a string, separated by a given separator.

+ *

+ * Each element of `ary` is converted to a string. These strings are then

+ * concatenated, with the string representation of `sep` inserted between

+ * adjacent elements.

+ * If `sep` is `nil`, no separator is used.

+ * This function handles recursive array joins by raising an E_ARGUMENT_ERROR.

+ *

+ * @param mrb The mruby state.

+ * @param ary The array (mrb_value) whose elements are to be joined.

+ * @param sep The separator (mrb_value) to use between elements. Can be `nil`.

+ * @return A new mrb_value string representing the joined array elements.

+ */

+ * a string, separated by *sep*.

+ if (MRB_RECURSIVE_UNARY_P(mrb, MRB_SYM(inspect), self)) {

+/* check array equality: 1=equal,0=not_equal,-1=need_elements_check */

+ /* Check for recursion */

+ if (MRB_RECURSIVE_BINARY_FUNC_P(mrb, MRB_OPSYM(eq), ary1, ary2)) {

+ return mrb_false_value();

+ }

+

+ * Returns `true` if `self` and _other_ are the same object,

+ /* Check for recursion */

+ if (MRB_RECURSIVE_BINARY_FUNC_P(mrb, MRB_SYM_Q(eql), ary1, ary2)) {

+ return mrb_false_value();

+ }

+

+ * if this array is less than, equal to, or greater than *other_ary*.

+ * "equal" according to `Array#<=>` if and only if they have

+

+#define SMALL_ARRAY_SORT_THRESHOLD 16

+

+sort_cmp(mrb_state *mrb, mrb_value ary, mrb_value a_val, mrb_value b_val, mrb_value blk)

+ mrb_value *p = RARRAY_PTR(ary);

+ mrb_int n = RARRAY_LEN(ary);

+

+ int ai = mrb_gc_arena_save(mrb);

+ enum mrb_vtype type_a = mrb_type(a_val);

+ enum mrb_vtype type_b = mrb_type(b_val);

+

+ if (type_a == type_b) {

+ switch (type_a) {

+ case MRB_TT_FIXNUM:

+ cmp = (mrb_fixnum(a_val) > mrb_fixnum(b_val)) ? 1 : (mrb_fixnum(a_val) < mrb_fixnum(b_val)) ? -1 : 0;

+ break;

+#ifndef MRB_NO_FLOAT

+ case MRB_TT_FLOAT:

+ cmp = (mrb_float(a_val) > mrb_float(b_val)) ? 1 : (mrb_float(a_val) < mrb_float(b_val)) ? -1 : 0;

+ break;

+#endif

+ case MRB_TT_STRING:

+ cmp = mrb_str_cmp(mrb, a_val, b_val);

+ break;

+ default:

+ cmp = mrb_cmp(mrb, a_val, b_val);

+ break;

+ }

+ }

+ else {

+ cmp = mrb_cmp(mrb, a_val, b_val);

+ }

+ mrb_value args[2] = {a_val, b_val};

+ cmp = -2;

+ else {

+ cmp = mrb_fixnum(c);

+ }

+ }

+ mrb_gc_arena_restore(mrb, ai);

+ if (cmp == -2) {

+ mrb_raise(mrb, E_ARGUMENT_ERROR, "comparison failed");

+ if (RARRAY_PTR(ary) != p || RARRAY_LEN(ary) != n) {

+ /* Iterative heapify to avoid stack overflow on memory-constrained devices */

+ while (1) {

+ mrb_int max = index;

+ mrb_int left_index = 2 * index + 1;

+ mrb_int right_index = left_index + 1;

+

+ if (left_index < size && sort_cmp(mrb, ary, a[left_index], a[max], blk)) {

+ max = left_index;

+ }

+ if (right_index < size && sort_cmp(mrb, ary, a[right_index], a[max], blk)) {

+ max = right_index;

+ }

+

+ if (max == index) {

+ /* Heap property satisfied, no more swaps needed */

+ break;

+ }

+

+ /* Swap elements and continue heapifying down the affected subtree */

+

+ /* Continue with the affected child subtree */

+ index = max;

+ }

+}

+

+static void

+insertion_sort(mrb_state *mrb, mrb_value ary, mrb_value *a, mrb_int size, mrb_value blk)

+{

+ int ai = mrb_gc_arena_save(mrb);

+ for (mrb_int i = 1; i < size; i++) {

+ mrb_value key = a[i];

+ mrb_int j = i - 1;

+

+ /* Protect key from GC - it's temporarily out of the array during sort */

+ mrb_gc_protect(mrb, key);

+

+ /* Move elements that are greater than key to one position ahead */

+ while (j >= 0 && sort_cmp(mrb, ary, a[j], key, blk)) {

+ a[j + 1] = a[j];

+ j--;

+ }

+ a[j + 1] = key;

+ mrb_gc_arena_restore(mrb, ai);

+ * Sort all elements and replace `self` with these

+

+ /* Algorithm selection based on array size */

+ if (n <= SMALL_ARRAY_SORT_THRESHOLD) {

+ /* Use insertion sort for small arrays */

+ insertion_sort(mrb, ary, a, n, blk);

+ else {

+ /* Use heap sort for larger arrays */

+ for (mrb_int i = n / 2 - 1; i >= 0; i--) {

+ heapify(mrb, ary, a, i, n, blk);

+ }

+ for (mrb_int i = n - 1; i > 0; i--) {

+ mrb_value tmp = a[0];

+ a[0] = a[i];

+ a[i] = tmp;

+ heapify(mrb, ary, a, 0, i, blk);

+ }

+/*

+ * call-seq:

+ * array.to_a -> self

+ *

+ * Returns self. If called on a subclass of Array, converts

+ * the receiver to an Array object.

+ */

+static mrb_value

+mrb_ary_to_a(mrb_state *mrb, mrb_value self)

+{

+ if (mrb_obj_class(mrb, self) != mrb->array_class) {

+ /* Convert subclass to Array */

+ return mrb_ary_dup(mrb, self);

+ }

+ return self;

+}

+

+/* ---------------------------*/

+static const mrb_mt_entry array_rom_entries[] = {

+ MRB_MT_ENTRY(mrb_ary_plus, MRB_OPSYM(add), MRB_ARGS_REQ(1)), /* 15.2.12.5.1 */

+ MRB_MT_ENTRY(mrb_ary_times, MRB_OPSYM(mul), MRB_ARGS_REQ(1)), /* 15.2.12.5.2 */

+ MRB_MT_ENTRY(mrb_ary_push_m, MRB_OPSYM(lshift), MRB_ARGS_REQ(1)), /* 15.2.12.5.3 */

+ MRB_MT_ENTRY(mrb_ary_aget, MRB_OPSYM(aref), MRB_ARGS_ARG(1,1)), /* 15.2.12.5.4 */

+ MRB_MT_ENTRY(mrb_ary_aset, MRB_OPSYM(aset), MRB_ARGS_ARG(2,1)), /* 15.2.12.5.5 */

+ MRB_MT_ENTRY(mrb_ary_clear, MRB_SYM(clear), MRB_ARGS_NONE()), /* 15.2.12.5.6 */

+ MRB_MT_ENTRY(mrb_ary_cmp, MRB_OPSYM(cmp), MRB_ARGS_REQ(1)),

+ MRB_MT_ENTRY(mrb_ary_concat_m, MRB_SYM(concat), MRB_ARGS_REQ(1)), /* 15.2.12.5.8 */

+ MRB_MT_ENTRY(mrb_ary_delete, MRB_SYM(delete), MRB_ARGS_REQ(1)),

+ MRB_MT_ENTRY(mrb_ary_delete_at, MRB_SYM(delete_at), MRB_ARGS_REQ(1)), /* 15.2.12.5.9 */

+ MRB_MT_ENTRY(mrb_ary_empty_p, MRB_SYM_Q(empty), MRB_ARGS_NONE()), /* 15.2.12.5.12 */

+ MRB_MT_ENTRY(mrb_ary_eq, MRB_OPSYM(eq), MRB_ARGS_REQ(1)),

+ MRB_MT_ENTRY(mrb_ary_eql, MRB_SYM_Q(eql), MRB_ARGS_REQ(1)),

+ MRB_MT_ENTRY(mrb_ary_first, MRB_SYM(first), MRB_ARGS_OPT(1)), /* 15.2.12.5.13 */

+ MRB_MT_ENTRY(mrb_ary_index_m, MRB_SYM(index), MRB_ARGS_OPT(1)), /* 15.2.12.5.14 */

+ MRB_MT_ENTRY(mrb_ary_init, MRB_SYM(initialize), MRB_ARGS_OPT(2) | MRB_MT_PRIVATE), /* 15.2.12.5.15 */

+ MRB_MT_ENTRY(mrb_ary_replace_m, MRB_SYM(initialize_copy), MRB_ARGS_REQ(1) | MRB_MT_PRIVATE), /* 15.2.12.5.16 */

+ MRB_MT_ENTRY(mrb_ary_join_m, MRB_SYM(join), MRB_ARGS_OPT(1)), /* 15.2.12.5.17 */

+ MRB_MT_ENTRY(mrb_ary_last, MRB_SYM(last), MRB_ARGS_OPT(1)), /* 15.2.12.5.18 */

+ MRB_MT_ENTRY(mrb_ary_size, MRB_SYM(length), MRB_ARGS_NONE()), /* 15.2.12.5.19 */

+ MRB_MT_ENTRY(mrb_ary_pop, MRB_SYM(pop), MRB_ARGS_NONE()), /* 15.2.12.5.21 */

+ MRB_MT_ENTRY(mrb_ary_push_m, MRB_SYM(push), MRB_ARGS_ANY()), /* 15.2.12.5.22 */

+ MRB_MT_ENTRY(mrb_ary_replace_m, MRB_SYM(replace), MRB_ARGS_REQ(1)), /* 15.2.12.5.23 */

+ MRB_MT_ENTRY(mrb_ary_reverse, MRB_SYM(reverse), MRB_ARGS_NONE()), /* 15.2.12.5.24 */

+ MRB_MT_ENTRY(mrb_ary_reverse_bang, MRB_SYM_B(reverse), MRB_ARGS_NONE()), /* 15.2.12.5.25 */

+ MRB_MT_ENTRY(mrb_ary_rindex_m, MRB_SYM(rindex), MRB_ARGS_OPT(1)), /* 15.2.12.5.26 */

+ MRB_MT_ENTRY(mrb_ary_shift_m, MRB_SYM(shift), MRB_ARGS_OPT(1)), /* 15.2.12.5.27 */

+ MRB_MT_ENTRY(mrb_ary_size, MRB_SYM(size), MRB_ARGS_NONE()), /* 15.2.12.5.28 */

+ MRB_MT_ENTRY(mrb_ary_aget, MRB_SYM(slice), MRB_ARGS_ARG(1,1)), /* 15.2.12.5.29 */

+ MRB_MT_ENTRY(mrb_ary_unshift_m, MRB_SYM(unshift), MRB_ARGS_ANY()), /* 15.2.12.5.30 */

+ MRB_MT_ENTRY(mrb_ary_to_a, MRB_SYM(to_a), MRB_ARGS_NONE()),

+ MRB_MT_ENTRY(mrb_ary_to_a, MRB_SYM(entries), MRB_ARGS_NONE()),

+ MRB_MT_ENTRY(mrb_ary_to_s, MRB_SYM(to_s), MRB_ARGS_NONE()),

+ MRB_MT_ENTRY(mrb_ary_to_s, MRB_SYM(inspect), MRB_ARGS_NONE()),

+ MRB_MT_ENTRY(mrb_ary_sort_bang, MRB_SYM_B(sort), MRB_ARGS_NONE()),

+ MRB_MT_ENTRY(mrb_ary_svalue, MRB_SYM(__svalue), MRB_ARGS_NONE()),

+};

+

+ MRB_MT_INIT_ROM(mrb, a, array_rom_entries);