#$@%#$%!

Ngiler SH3LL 360
: / opt / alt / ruby33 / include / ruby / internal / intern /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : array.h \| Size : 25.15 KB
#ifndef RBIMPL_INTERN_ARRAY_H /--C++--vi:se ft=cpp:/ #define RBIMPL_INTERN_ARRAY_H /** * @file * @author Ruby developers <ruby-core@ruby-lang.org> * @copyright This file is a part of the programming language Ruby. * Permission is hereby granted, to either redistribute and/or * modify this file, provided that the conditions mentioned in the * file COPYING are met. Consult the file for details. * @warning Symbols prefixed with either `RBIMPL` or `rbimpl` are * implementation details. Don't take them as canon. They could * rapidly appear then vanish. The name (path) of this header file * is also an implementation detail. Do not expect it to persist * at the place it is now. Developers are free to move it anywhere * anytime at will. * @note To ruby-core: remember that this header can be possibly * recursively included from extension libraries written in C++. * Do not expect for instance `__VA_ARGS__` is always available. * We assume C99 for ruby itself but we don't assume languages of * extension libraries. They could be written in C++98. * @brief Public APIs related to ::rb_cArray. / #include "ruby/internal/attr/noalias.h" #include "ruby/internal/attr/noexcept.h" #include "ruby/internal/attr/nonnull.h" #include "ruby/internal/attr/pure.h" #include "ruby/internal/dllexport.h" #include "ruby/internal/value.h" RBIMPL_SYMBOL_EXPORT_BEGIN() / array.c / RBIMPL_ATTR_NONNULL(()) RBIMPL_ATTR_NOALIAS() /* * Fills the memory region with a series of ::RUBY_Qnil. * * @param[out] buf Buffer to squash. * @param[in] len Number of objects of `buf`. * @post `buf` is filled with ::RUBY_Qnil. / void rb_mem_clear(VALUE buf, long len) RBIMPL_ATTR_NOEXCEPT(true) ; /** * Identical to rb_ary_new_from_values(), except it expects exactly two * parameters. * * @param[in] car Arbitrary ruby object. * @param[in] cdr Arbitrary ruby object. * @return An allocated new array, of length 2, whose contents are the * passed objects. / VALUE rb_assoc_new(VALUE car, VALUE cdr); /* * Try converting an object to its array representation using its `to_ary` * method, if any. If there is no such thing, returns ::RUBY_Qnil. * * @param[in] obj Arbitrary ruby object to convert. * @exception rb_eTypeError `obj.to_ary` returned something non-Array. * @retval RUBY_Qnil No conversion from `obj` to array defined. * @retval otherwise Converted array representation of `obj`. * @see rb_io_check_io * @see rb_check_string_type * @see rb_check_hash_type / VALUE rb_check_array_type(VALUE obj); /* * Allocates a new, empty array. * * @return An allocated new array, whose length is 0. / VALUE rb_ary_new(void); /* * Identical to rb_ary_new(), except it additionally specifies how many rooms * of objects it should allocate. This way you can create an array whose * capacity is bigger than the length of it. If you can say that an array * grows to a specific amount, this could be effective than resizing an array * over and over again and again. * * @param[in] capa Designed capacity of the generating array. * @return An empty array, whose capacity is `capa`. / VALUE rb_ary_new_capa(long capa); /* * Constructs an array from the passed objects. * * @param[in] n Number of passed objects. * @param[in] ... Arbitrary ruby objects, filled into the returning array. * @return An array of size `n`, whose contents are the passed objects. / VALUE rb_ary_new_from_args(long n, ...); /* * Identical to rb_ary_new_from_args(), except how objects are passed. * * @param[in] n Number of objects of `elts`. * @param[in] elts Arbitrary ruby objects, filled into the returning array. * @return An array of size `n`, whose contents are the passed objects. / VALUE rb_ary_new_from_values(long n, const VALUE elts); /** * Allocates a hidden (no class) empty array. * * @param[in] capa Designed capacity of the array. * @return A hidden, empty array. * @see rb_obj_hide() / VALUE rb_ary_hidden_new(long capa); #define rb_ary_tmp_new rb_ary_hidden_new /* * Destroys the given array for no reason. * * @warning DO NOT USE IT. * @warning Leave this task to our GC. * @warning It was a wrong indea at the first place to let you know about it. * * @param[out] ary The array to be executed. * @post The given array no longer exists. * @note Maybe `Array#clear` could be what you want. * * @internal * * Should have moved this to `internal/array.h`. / void rb_ary_free(VALUE ary); /* * Declares that the array is about to be modified. This for instance let the * array have a dedicated backend storage. * * @param[out] ary Array about to be modified. * @exception rb_eFrozenError `ary` is frozen. * @post Upon successful return the passed array is eligible to be * modified. / void rb_ary_modify(VALUE ary); /* @alias{rb_obj_freeze} / VALUE rb_ary_freeze(VALUE obj); RBIMPL_ATTR_PURE() /* * Queries if the passed two arrays share the same backend storage. A use-case * for knowing such property is to take a snapshot of an array (using * e.g. rb_ary_replace()), then check later if that snapshot still shares the * storage with the original. Taking a snapshot is ultra-cheap. If nothing * happens the impact shall be minimal. But if someone modifies the original, * that entity shall pay the cost of copy-on-write. You can detect that using * this API. * * @param[in] lhs Comparison LHS. * @param[in] rhs Comparison RHS. * @retval RUBY_Qtrue They share the same backend storage. * @retval RUBY_Qfalse They are distinct. * @pre Both arguments must be of ::RUBY_T_ARRAY. / VALUE rb_ary_shared_with_p(VALUE lhs, VALUE rhs); /* * Queries element(s) of an array. This is complicated! Refer `Array#slice` * document for the complete description of how it behaves. * * @param[in] argc Number of objects of `argv`. * @param[in] argv Up to 2 objects. * @param[in] ary Target array. * @exception rb_eTypeError `argv` (or its part) includes non-Integer. * @exception rb_eRangeError rb_cArithSeq is passed, and is OOB. * @return An element (if requested), or an array of elements (if * requested), or ::RUBY_Qnil (if index OOB). * * @internal * * ```rbs * # "int" is ::Integer or `#to_int`, defined in builtin.rbs * * class ::Array[unchecked out T] * def slice * : (int i) -> T? * \| (int beg, int len) -> ::Array[T]? * \| (Range[int] r) -> ::Array[T]? * \| (ArithmeticSequence as) -> ::Array[T]? # This also raises RangeError. * end * ``` / VALUE rb_ary_aref(int argc, const VALUE argv, VALUE ary); /** * Obtains a part of the passed array. * * @param[in] ary Target array. * @param[in] beg Subpart index. * @param[in] len Requested length of returning array. * @retval RUBY_Qnil Requested range out of bounds of `ary`. * @retval otherwise An allocated new array whose contents are `ary`'s * `beg` to `len`. * @note Return array can be shorter than `len` when for instance * `[0, 1, 2, 3]`'s 4th to 1,000,000,000th is requested. / VALUE rb_ary_subseq(VALUE ary, long beg, long len); /* * Destructively stores the passed value to the passed array's passed index. * It also resizes the array's backend storage so that the requested index is * not out of bounds. * * @param[out] ary Target array to modify. * @param[in] key Where to store `val`. * @param[in] val What to store at `key`. * @exception rb_eFrozenError `ary` is frozen. * @exception rb_eIndexError `key` is negative. * @post `ary`'s `key`th position is occupied with `val`. * @post Depending on `key` and previous length of `ary` this operation * can also create a series of "hole" positions inside of the * backend storage. They are filled with ::RUBY_Qnil. / void rb_ary_store(VALUE ary, long key, VALUE val); /* * Duplicates an array. * * @param[in] ary Target to duplicate. * @return An allocated new array whose contents are identical to `ary`. * * @internal * * Not sure why this has to be something different from `ary_make_shared_copy`, * which seems much efficient. / VALUE rb_ary_dup(VALUE ary); /* * I guess there is no use case of this function in extension libraries, but * this is a routine identical to rb_ary_dup(). This makes the most sense when * the passed array is formerly hidden by rb_obj_hide(). * * @param[in] ary An array, possibly hidden. * @return A duplicated new instance of ::rb_cArray. / VALUE rb_ary_resurrect(VALUE ary); /* * Force converts an object to an array. It first tries its `#to_ary` method. * Takes the result if any. Otherwise creates an array of size 1 whose sole * element is the passed object. * * @param[in] obj Arbitrary ruby object. * @return An array representation of `obj`. * @note Unlike rb_str_to_str() which is a variant of * rb_check_string_type(), rb_ary_to_ary() is not a variant of * rb_check_array_type(). / VALUE rb_ary_to_ary(VALUE obj); /* * Converts an array into a human-readable string. Historically its behaviour * changed over time. Currently it is identical to calling `inspect` method. * This behaviour is from that of python (!!) circa 2006. * * @param[in] ary Array to inspect. * @return Recursively inspected representation of `ary`. * @see `[ruby-dev:29520]` / VALUE rb_ary_to_s(VALUE ary); /* * Destructively appends multiple elements at the end of the array. * * @param[out] ary Where to push `train`. * @param[in] train Arbitrary ruby objects to push to `ary`. * @param[in] len Number of objects of `train`. * @exception rb_eIndexError `len` too large. * @exception rb_eFrozenError `ary` is frozen. * @return The passed `ary`. * @post `ary` has contents from `train` appended at its end. / VALUE rb_ary_cat(VALUE ary, const VALUE train, long len); /** * Special case of rb_ary_cat() that it adds only one element. * * @param[out] ary Where to push `elem`. * @param[in] elem Arbitrary ruby object to push. * @exception rb_eFrozenError `ary` is frozen. * @return The passed `ary`. * @post `ary` has `elem` appended at its end. / VALUE rb_ary_push(VALUE ary, VALUE elem); /* * Destructively deletes an element from the end of the passed array and * returns what was deleted. * * @param[out] ary Target array to modify. * @exception rb_eFrozenError `ary` is frozen. * @return What was at the end of `ary`, or ::RUBY_Qnil if there is * nothing to remove. * @post `ary`'s last element, if any, is removed. * @note There is no way to distinguish whether `ary` was an 1-element * array whose content was ::RUBY_Qnil, or was empty. / VALUE rb_ary_pop(VALUE ary); /* * Destructively deletes an element from the beginning of the passed array and * returns what was deleted. It can also be seen as a routine identical to * rb_ary_pop(), except which side of the array to scrub. * * @param[out] ary Target array to modify. * @exception rb_eFrozenError `ary` is frozen. * @return What was at the beginning of `ary`, or ::RUBY_Qnil if there is * nothing to remove. * @post `ary`'s first element, if any, is removed. As the name implies * everything else remaining in `ary` gets moved towards `ary`'s * beginning. * @note There is no way to distinguish whether `ary` was an 1-element * array whose content was ::RUBY_Qnil, or was empty. / VALUE rb_ary_shift(VALUE ary); /* * Destructively prepends the passed item at the beginning of the passed array. * It can also be seen as a routine identical to rb_ary_push(), except which * side of the array to modify. * * @param[out] ary Target array to modify. * @param[in] elem Arbitrary ruby object to unshift. * @exception rb_eFrozenError `ary` is frozen. * @return The passed `ary`. * @post `ary` has `elem` prepended at this beginning. / VALUE rb_ary_unshift(VALUE ary, VALUE elem); RBIMPL_ATTR_PURE() /* * Queries an element of an array. When passed offset is negative it counts * backwards. * * @param[in] ary An array to look into. * @param[in] off Offset (can be negative). * @return ::RUBY_Qnil when `off` is out of bounds of `ary`. Otherwise * what is stored at `off`-th position of `ary`. * @note `ary`'s `off`-th element can happen to be ::RUBY_Qnil. / VALUE rb_ary_entry(VALUE ary, long off); /* * Iteratively yields each element of the passed array to the implicitly passed * block if any. In case there is no block given, an enumerator that does the * thing is generated instead. * * @param[in] ary Array to iterate over. * @retval ary Passed block was evaluated. * @retval otherwise An instance of ::rb_cEnumerator for `Array#each`. / VALUE rb_ary_each(VALUE ary); /* * Recursively stringises the elements of the passed array, flattens that * result, then joins the sequence using the passed separator. * * @param[in] ary Target array to convert. * @param[in] sep Separator. Either a string, or ::RUBY_Qnil * if you want no separator. * @exception rb_eArgError Infinite recursion in `ary`. * @exception rb_eTypeError `sep` is not a string. * @exception rb_eEncCompatError Strings do not agree with their encodings. * @return An instance of ::rb_cString which concatenates stringised * contents of `ary`, using `sep` as separator. / VALUE rb_ary_join(VALUE ary, VALUE sep); /* * _Destructively_ reverses the passed array in-place. * * @warning This is `Array#reverse!`, not `Array#reverse`. * @param[out] ary Target array to modify. * @exception rb_eFrozenError `ary` is frozen. * @return Passed `ary`. * @post `ary` is reversed. / VALUE rb_ary_reverse(VALUE ary); /* * _Destructively_ rotates the passed array in-place to towards its end. The * amount can be negative. Would rotate to the opposite direction then. * * @warning This is `Array#rotate!`, not `Array#rotate`. * @param[out] ary Target array to modify. * @param[in] rot Amount of rotation. * @exception rb_eFrozenError `ary` is frozen. * @retval RUBY_Qnil Not rotated. * @retval ary Rotated. * @post `ary` is rotated. / VALUE rb_ary_rotate(VALUE ary, long rot); /* * Creates a copy of the passed array, whose elements are sorted according to * their `<=>` result. * * @param[in] ary Array to sort. * @exception rb_eArgError Comparison not defined among elements. * @exception rb_eRuntimeError Infinite recursion in `<=>`. * @return A copy of `ary`, sorted. * @note As of writing this function uses `qsort` as backend algorithm, * which means the result is unstable (in terms of sort stability). / VALUE rb_ary_sort(VALUE ary); /* * Destructively sorts the passed array in-place, according to each elements' * `<=>` result. * * @param[in] ary Target array to modify. * @exception rb_eArgError Comparison not defined among elements. * @exception rb_eRuntimeError Infinite recursion in `<=>`. * @return Passed `ary`. * @post `ary` is sorted. * @note As of writing this function uses `qsort` as backend algorithm, * which means the result is unstable (in terms of sort stability). / VALUE rb_ary_sort_bang(VALUE ary); /* * Destructively removes elements from the passed array, so that there would be * no elements inside that satisfy `==` relationship with the passed object. * Returns the last deleted element if any. But in case there was nothing to * delete it gets complicated. It checks for the implicitly passed block. If * there is a block the return value would be what the block evaluates to. * Otherwise it resorts to ::RUBY_Qnil. * * @param[out] ary Target array to modify. * @param[in] elem Template object to match against each element. * @exception rb_eFrozenError `ary` is frozen. * @return What was deleted, or what was the block returned, or * ::RUBY_Qnil (see above). * @post All elements that have `==` relationship with `elem` are purged * from `ary`. Elements shift their positions so that `ary` gets * compact. * * @internal * * Internally there also is `rb_ary_delete_same`, which compares by identity. / VALUE rb_ary_delete(VALUE ary, VALUE elem); /* * Destructively removes an element which resides at the specific index of the * passed array. Unlike rb_ary_stre() the index can be negative, which means * the index counts backwards from the array's tail. * * @param[out] ary Target array to modify. * @param[in] pos Position (can be negative). * @exception rb_eFrozenError `ary` is frozen. * @return What was deleted, or ::RUBY_Qnil in case of OOB. * @post `ary`'s `pos`-th element is deleted if any. * @note There is no way to distinguish whether `pos` is out of bound, * or `pos` did exist but stored ::RUBY_Qnil as an ordinal value. / VALUE rb_ary_delete_at(VALUE ary, long pos); /* * Destructively removes everything form an array. * * @param[out] ary Target array to modify. * @exception rb_eFrozenError `ary` is frozen. * @return The passed `ary`. * @post `ary` is an empty array. / VALUE rb_ary_clear(VALUE ary); /* * Creates a new array, concatenating the former to the latter. * * @param[in] lhs Source array #1. * @param[in] rhs Source array #2. * @exception rb_eIndexError Result array too big. * @return A new array containing `rhs` concatenated to `lhs`. * @note This operation doesn't commute. Don't get confused by the * "plus" terminology. For historical reasons there are some * noncommutative `+`s in Ruby. This is one of such things. There * has been a long discussion around `+`s in programming languages. * * @internal * * rb_ary_concat() is not a destructive version of rb_ary_plus(). They raise * different exceptions. Don't know why though. / VALUE rb_ary_plus(VALUE lhs, VALUE rhs); /* * Destructively appends the contents of latter into the end of former. * * @param[out] lhs Destination array. * @param[in] rhs Source array. * @exception rb_eFrozenError `lhs` is frozen. * @exception rb_eIndexError Result array too big. * @exception rb_eTypeError `rhs` doesn't respond to `#to_ary`. * @return The passed `lhs`. * @post `lhs` has contents of `rhs` appended to its end. / VALUE rb_ary_concat(VALUE lhs, VALUE rhs); /* * Looks up the passed key, assuming the passed array is an alist. An "alist" * here is a list of "association"s, much like that of Emacs. Emacs has * `assoc` function that behaves exactly the same as this one. * * ```ruby * # This is an example of aliist. * auto_mode_alist = [ * [ /\.[ch]\z/, :"c-mode" ], * [ /\.[ch]pp\z/, :"c++-mode" ], * [ /\.awk\z/, :"awk-mode" ], * [ /\.cs\z/, :"csharp-mode" ], * [ /\.go\z/, :"go-mode" ], * [ /\.java\z/, :"java-mode" ], * [ /\.pas\z/, :"pascal-mode" ], * [ /\.rs\z/, :"rust-mode" ], * [ /\.txt\z/, :"text-mode" ], * ] * ``` * * This function scans the passed array looking for an element, which itself is * an array, whose first element is the passed key. If no such element is * found, returns ::RUBY_Qnil. * * Although this function expects the passed array be an array of arrays, it * can happily accept non-array elements; it just ignores such things. * * @param[in] alist An array of arrays. * @param[in] key Needle. * @retval RUBY_Qnil Nothing was found. * @retval otherwise An element in `alist` whose first element is in `==` * relationship with `key`. / VALUE rb_ary_assoc(VALUE alist, VALUE key); /* * Identical to rb_ary_assoc(), except it scans the passed array from the * opposite direction. * * @param[in] alist An array of arrays. * @param[in] key Needle. * @retval RUBY_Qnil Nothing was found. * @retval otherwise An element in `alist` whose first element is in `==` * relationship with `key`. / VALUE rb_ary_rassoc(VALUE alist, VALUE key); /* * Queries if the passed array has the passed entry. * * @param[in] ary Target array to scan. * @param[in] elem Target array to find. * @retval RUBY_Qfalse No element in `ary` is in `==` relationship with * `elem`. * @retval RUBY_Qtrue There is at least one element in `ary` which is in * `==` relationship with `elem`. * * @internal * * This is the only function in the entire C API that is named using third * person singular form of a verb (except #ISASCII etc., which are not our * naming). The counterpart Ruby API of this function is `Array#include?`. / VALUE rb_ary_includes(VALUE ary, VALUE elem); /* * Recursively compares each elements of the two arrays one-by-one using `<=>`. * * @param[in] lhs Comparison LHS. * @param[in] rhs Comparison RHS. * @retval RUBY_Qnil `lhs` and `rhs` are not comparable. * @retval -1 `lhs` is less than `rhs`. * @retval 0 They are equal. * @retval 1 `rhs` is less then `lhs`. / VALUE rb_ary_cmp(VALUE lhs, VALUE rhs); /* * Replaces the contents of the former object with the contents of the latter. * * @param[out] copy Destination object. * @param[in] orig Source object. * @exception rb_eTypeError `orig` has no implicit conversion to Array. * @exception rb_eFrozenError `copy` is frozen. * @return The passed `copy`. * @post `copy`'s former components are abandoned. It now has the * identical length and contents to `orig`. / VALUE rb_ary_replace(VALUE copy, VALUE orig); /* * This _was_ a generalisation of `Array#values_at`, `Struct#values_at`, and * `MatchData#values_at`. It begun its life as a refactoring effort. However * as Ruby evolves over time, as of writing none of aforementioned methods * share their implementations at all. This function is not deprecated; still * works as it has been. But it is now kind of like a rudimentum. * * This function takes an object, which is a receiver, and a series of * "indices", which are either integers, or ranges of integers. Calls the * passed callback for each of those indices, along with the receiver. This * callback is expected to do something like rb_ary_aref(), rb_struct_aref(), * etc. In case of a range index rb_range_beg_len() expands the range. * Finally return values of the callback are gathered as an array, then * returned. * * @param[in] obj Arbitrary ruby object. * @param[in] olen "Length" of `obj`. * @param[in] argc Number of objects of `argv`. * @param[in] argv List of "indices", described above. * @param[in] func Callback function. * @return A new instance of ::rb_cArray gathering `func`outputs. * * @internal * * `Array#values_at` no longer uses this function. There is no reason apart * from historical ones to list this function here. / VALUE rb_get_values_at(VALUE obj, long olen, int argc, const VALUE argv, VALUE (func)(VALUE obj, long oidx)); /* * Expands or shrinks the passed array to the passed length. * * @param[out] ary An array to modify. * @param[in] len Desired length of `ary`. * @exception rb_eFrozenError `ary` is frozen. * @exception rb_eIndexError `len` too long. * @return The passed `ary`. * @post `ary`'s length is `len`. * @post Depending on `len` and previous length of `ary` this operation * can also create a series of "hole" positions inside of the * backend storage. They are filled with ::RUBY_Qnil. * * @internal * * `len` is signed. Intentional or...? / VALUE rb_ary_resize(VALUE ary, long len); #define rb_ary_new2 rb_ary_new_capa /< @old{rb_ary_new_capa} / #define rb_ary_new3 rb_ary_new_from_args /*< @old{rb_ary_new_from_args} / #define rb_ary_new4 rb_ary_new_from_values /*< @old{rb_ary_new_from_values} / RBIMPL_SYMBOL_EXPORT_END() #endif /* RBIMPL_INTERN_ARRAY_H */ Back

Edit File : array.h | Size : 25.15 KB

#ifndef RBIMPL_INTERN_ARRAY_H                        /*-*-C++-*-vi:se ft=cpp:*/
#define RBIMPL_INTERN_ARRAY_H
/**
 * @file
 * @author     Ruby developers <ruby-core@ruby-lang.org>
 * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
 *             Permission  is hereby  granted,  to  either redistribute  and/or
 *             modify this file, provided that  the conditions mentioned in the
 *             file COPYING are met.  Consult the file for details.
 * @warning    Symbols   prefixed  with   either  `RBIMPL`   or  `rbimpl`   are
 *             implementation details.   Don't take  them as canon.  They could
 *             rapidly appear then vanish.  The name (path) of this header file
 *             is also an  implementation detail.  Do not expect  it to persist
 *             at the place it is now.  Developers are free to move it anywhere
 *             anytime at will.
 * @note       To  ruby-core:  remember  that   this  header  can  be  possibly
 *             recursively included  from extension  libraries written  in C++.
 *             Do not  expect for  instance `__VA_ARGS__` is  always available.
 *             We assume C99  for ruby itself but we don't  assume languages of
 *             extension libraries.  They could be written in C++98.
 * @brief      Public APIs related to ::rb_cArray.
 */
#include "ruby/internal/attr/noalias.h"
#include "ruby/internal/attr/noexcept.h"
#include "ruby/internal/attr/nonnull.h"
#include "ruby/internal/attr/pure.h"
#include "ruby/internal/dllexport.h"
#include "ruby/internal/value.h"

RBIMPL_SYMBOL_EXPORT_BEGIN()

/* array.c */

RBIMPL_ATTR_NONNULL(())
RBIMPL_ATTR_NOALIAS()
/**
 * Fills the memory region with a series of ::RUBY_Qnil.
 *
 * @param[out]  buf  Buffer to squash.
 * @param[in]   len  Number of objects of `buf`.
 * @post        `buf` is filled with ::RUBY_Qnil.
 */
void rb_mem_clear(VALUE *buf, long len)
    RBIMPL_ATTR_NOEXCEPT(true)
    ;

/**
 * Identical  to  rb_ary_new_from_values(),  except   it  expects  exactly  two
 * parameters.
 *
 * @param[in]  car  Arbitrary ruby object.
 * @param[in]  cdr  Arbitrary ruby object.
 * @return     An  allocated new  array, of  length 2,  whose contents  are the
 *             passed objects.
 */
VALUE rb_assoc_new(VALUE car, VALUE cdr);

/**
 * Try  converting an  object to  its array  representation using  its `to_ary`
 * method, if any.  If there is no such thing, returns ::RUBY_Qnil.
 *
 * @param[in]  obj            Arbitrary ruby object to convert.
 * @exception  rb_eTypeError  `obj.to_ary` returned something non-Array.
 * @retval     RUBY_Qnil      No conversion from `obj` to array defined.
 * @retval     otherwise      Converted array representation of `obj`.
 * @see        rb_io_check_io
 * @see        rb_check_string_type
 * @see        rb_check_hash_type
 */
VALUE rb_check_array_type(VALUE obj);

/**
 * Allocates a new, empty array.
 *
 * @return  An allocated new array, whose length is 0.
 */
VALUE rb_ary_new(void);

/**
 * Identical to rb_ary_new(),  except it additionally specifies  how many rooms
 * of  objects it  should allocate.   This way  you can  create an  array whose
 * capacity is  bigger than the  length of  it.  If you  can say that  an array
 * grows to a  specific amount, this could be effective  than resizing an array
 * over and over again and again.
 *
 * @param[in]  capa  Designed capacity of the generating array.
 * @return     An empty array, whose capacity is `capa`.
 */
VALUE rb_ary_new_capa(long capa);

/**
 * Constructs an array from the passed objects.
 *
 * @param[in]  n    Number of passed objects.
 * @param[in]  ...  Arbitrary ruby objects, filled into the returning array.
 * @return     An array of size `n`, whose contents are the passed objects.
 */
VALUE rb_ary_new_from_args(long n, ...);

/**
 * Identical to rb_ary_new_from_args(), except how objects are passed.
 *
 * @param[in]  n     Number of objects of `elts`.
 * @param[in]  elts  Arbitrary ruby objects, filled into the returning array.
 * @return     An array of size `n`, whose contents are the passed objects.
 */
VALUE rb_ary_new_from_values(long n, const VALUE *elts);

/**
 * Allocates a hidden (no class) empty array.
 *
 * @param[in]  capa  Designed capacity of the array.
 * @return     A hidden, empty array.
 * @see        rb_obj_hide()
 */
VALUE rb_ary_hidden_new(long capa);
#define rb_ary_tmp_new rb_ary_hidden_new

/**
 * Destroys the given array for no reason.
 *
 * @warning  DO NOT USE IT.
 * @warning  Leave this task to our GC.
 * @warning  It was a wrong indea at the first place to let you know about it.
 *
 * @param[out]  ary  The array to be executed.
 * @post        The given array no longer exists.
 * @note        Maybe `Array#clear` could be what you want.
 *
 * @internal
 *
 * Should have moved this to `internal/array.h`.
 */
void rb_ary_free(VALUE ary);

/**
 * Declares that the array is about to  be modified.  This for instance let the
 * array have a dedicated backend storage.
 *
 * @param[out]  ary               Array about to be modified.
 * @exception   rb_eFrozenError   `ary` is frozen.
 * @post        Upon  successful return  the  passed array  is  eligible to  be
 *              modified.
 */
void rb_ary_modify(VALUE ary);

/** @alias{rb_obj_freeze} */
VALUE rb_ary_freeze(VALUE obj);

RBIMPL_ATTR_PURE()
/**
 * Queries if the passed two arrays share the same backend storage.  A use-case
 * for  knowing  such  property is  to  take  a  snapshot  of an  array  (using
 * e.g. rb_ary_replace()), then  check later if that snapshot  still shares the
 * storage with  the original.  Taking  a snapshot is ultra-cheap.   If nothing
 * happens the impact shall be minimal.   But if someone modifies the original,
 * that entity shall pay the cost  of copy-on-write.  You can detect that using
 * this API.
 *
 * @param[in]  lhs          Comparison LHS.
 * @param[in]  rhs          Comparison RHS.
 * @retval     RUBY_Qtrue   They share the same backend storage.
 * @retval     RUBY_Qfalse  They are distinct.
 * @pre        Both arguments must be of ::RUBY_T_ARRAY.
 */
VALUE rb_ary_shared_with_p(VALUE lhs, VALUE rhs);

/**
 * Queries element(s) of  an array.  This is  complicated!  Refer `Array#slice`
 * document for the complete description of how it behaves.
 *
 * @param[in]  argc            Number of objects of `argv`.
 * @param[in]  argv            Up to 2 objects.
 * @param[in]  ary             Target array.
 * @exception  rb_eTypeError   `argv` (or its part) includes non-Integer.
 * @exception  rb_eRangeError  rb_cArithSeq is passed, and is OOB.
 * @return     An  element  (if  requested),  or   an  array  of  elements  (if
 *             requested), or ::RUBY_Qnil (if index OOB).
 *
 * @internal
 *
 * ```rbs
 * # "int" is ::Integer or `#to_int`, defined in builtin.rbs
 *
 * class ::Array[unchecked out T]
 *   def slice
 *     : (int i)                 -> T?
 *     | (int beg, int len)      -> ::Array[T]?
 *     | (Range[int] r)          -> ::Array[T]?
 *     | (ArithmeticSequence as) -> ::Array[T]? # This also raises RangeError.
 * end
 * ```
 */
VALUE rb_ary_aref(int argc, const VALUE *argv, VALUE ary);

/**
 * Obtains a part of the passed array.
 *
 * @param[in]  ary        Target array.
 * @param[in]  beg        Subpart index.
 * @param[in]  len        Requested length of returning array.
 * @retval     RUBY_Qnil  Requested range out of bounds of `ary`.
 * @retval     otherwise  An  allocated new  array whose  contents are  `ary`'s
 *                        `beg` to `len`.
 * @note       Return  array  can  be  shorter than  `len`  when  for  instance
 *             `[0, 1, 2, 3]`'s 4th to 1,000,000,000th is requested.
 */
VALUE rb_ary_subseq(VALUE ary, long beg, long len);

/**
 * Destructively stores  the passed value  to the passed array's  passed index.
 * It also resizes  the array's backend storage so that  the requested index is
 * not out of bounds.
 *
 * @param[out]  ary              Target array to modify.
 * @param[in]   key              Where to store `val`.
 * @param[in]   val              What to store at `key`.
 * @exception   rb_eFrozenError  `ary` is frozen.
 * @exception   rb_eIndexError   `key` is negative.
 * @post        `ary`'s `key`th position is occupied with `val`.
 * @post        Depending on `key` and previous  length of `ary` this operation
 *              can  also create  a series  of "hole"  positions inside  of the
 *              backend storage.  They are filled with ::RUBY_Qnil.
 */
void rb_ary_store(VALUE ary, long key, VALUE val);

/**
 * Duplicates an array.
 *
 * @param[in]  ary  Target to duplicate.
 * @return     An allocated new array whose contents are identical to `ary`.
 *
 * @internal
 *
 * Not sure why this has to be something different from `ary_make_shared_copy`,
 * which seems much efficient.
 */
VALUE rb_ary_dup(VALUE ary);

/**
 * I guess there  is no use case  of this function in  extension libraries, but
 * this is a routine identical to rb_ary_dup().  This makes the most sense when
 * the passed array is formerly hidden by rb_obj_hide().
 *
 * @param[in]  ary  An array, possibly hidden.
 * @return     A duplicated new instance of ::rb_cArray.
 */
VALUE rb_ary_resurrect(VALUE ary);

/**
 * Force converts an object to an  array.  It first tries its `#to_ary` method.
 * Takes the result  if any.  Otherwise creates  an array of size  1 whose sole
 * element is the passed object.
 *
 * @param[in]  obj  Arbitrary ruby object.
 * @return     An array representation of `obj`.
 * @note       Unlike    rb_str_to_str()     which    is    a     variant    of
 *             rb_check_string_type(),  rb_ary_to_ary()  is  not a  variant  of
 *             rb_check_array_type().
 */
VALUE rb_ary_to_ary(VALUE obj);

/**
 * Converts an array into a  human-readable string.  Historically its behaviour
 * changed over time.   Currently it is identical to  calling `inspect` method.
 * This behaviour is from that of python (!!) circa 2006.
 *
 * @param[in]  ary  Array to inspect.
 * @return     Recursively inspected representation of `ary`.
 * @see        `[ruby-dev:29520]`
 */
VALUE rb_ary_to_s(VALUE ary);

/**
 * Destructively appends multiple elements at the end of the array.
 *
 * @param[out]  ary              Where to push `train`.
 * @param[in]   train            Arbitrary ruby objects to push to `ary`.
 * @param[in]   len              Number of objects of `train`.
 * @exception   rb_eIndexError   `len` too large.
 * @exception   rb_eFrozenError  `ary` is frozen.
 * @return      The passed `ary`.
 * @post        `ary` has contents from `train` appended at its end.
 */
VALUE rb_ary_cat(VALUE ary, const VALUE *train, long len);

/**
 * Special case of rb_ary_cat() that it adds only one element.
 *
 * @param[out]  ary              Where to push `elem`.
 * @param[in]   elem             Arbitrary ruby object to push.
 * @exception   rb_eFrozenError  `ary` is frozen.
 * @return      The passed `ary`.
 * @post        `ary` has `elem` appended at its end.
 */
VALUE rb_ary_push(VALUE ary, VALUE elem);

/**
 * Destructively  deletes an  element  from the  end of  the  passed array  and
 * returns what was deleted.
 *
 * @param[out]  ary              Target array to modify.
 * @exception   rb_eFrozenError  `ary` is frozen.
 * @return      What  was at  the  end of  `ary`, or  ::RUBY_Qnil  if there  is
 *              nothing to remove.
 * @post        `ary`'s last element, if any, is removed.
 * @note        There is no  way to distinguish whether `ary`  was an 1-element
 *              array whose content was ::RUBY_Qnil, or was empty.
 */
VALUE rb_ary_pop(VALUE ary);

/**
 * Destructively deletes an element from the  beginning of the passed array and
 * returns what  was deleted.  It  can also be seen  as a routine  identical to
 * rb_ary_pop(), except which side of the array to scrub.
 *
 * @param[out]  ary              Target array to modify.
 * @exception   rb_eFrozenError  `ary` is frozen.
 * @return      What was at the beginning of  `ary`, or ::RUBY_Qnil if there is
 *              nothing to remove.
 * @post        `ary`'s first element, if any, is removed.  As the name implies
 *              everything else  remaining in `ary` gets  moved towards `ary`'s
 *              beginning.
 * @note        There is no  way to distinguish whether `ary`  was an 1-element
 *              array whose content was ::RUBY_Qnil, or was empty.
 */
VALUE rb_ary_shift(VALUE ary);

/**
 * Destructively prepends the passed item at the beginning of the passed array.
 * It can  also be seen as  a routine identical to  rb_ary_push(), except which
 * side of the array to modify.
 *
 * @param[out]  ary              Target array to modify.
 * @param[in]   elem             Arbitrary ruby object to unshift.
 * @exception   rb_eFrozenError  `ary` is frozen.
 * @return      The passed `ary`.
 * @post        `ary` has `elem` prepended at this beginning.
 */
VALUE rb_ary_unshift(VALUE ary, VALUE elem);

RBIMPL_ATTR_PURE()
/**
 * Queries an  element of an array.   When passed offset is  negative it counts
 * backwards.
 *
 * @param[in]  ary  An array to look into.
 * @param[in]  off  Offset (can be negative).
 * @return     ::RUBY_Qnil when  `off` is  out of  bounds of  `ary`.  Otherwise
 *             what is stored at `off`-th position of `ary`.
 * @note       `ary`'s `off`-th element can happen to be ::RUBY_Qnil.
 */
VALUE rb_ary_entry(VALUE ary, long off);

/**
 * Iteratively yields each element of the passed array to the implicitly passed
 * block if any.  In case there is  no block given, an enumerator that does the
 * thing is generated instead.
 *
 * @param[in]  ary  Array to iterate over.
 * @retval     ary  Passed block was evaluated.
 * @retval     otherwise  An instance of ::rb_cEnumerator for `Array#each`.
 */
VALUE rb_ary_each(VALUE ary);

/**
 * Recursively  stringises the  elements  of the  passed  array, flattens  that
 * result, then joins the sequence using the passed separator.
 *
 * @param[in]  ary                 Target array to convert.
 * @param[in]  sep                 Separator.  Either a  string, or ::RUBY_Qnil
 *                                 if you want no separator.
 * @exception  rb_eArgError        Infinite recursion in `ary`.
 * @exception  rb_eTypeError      `sep` is not a string.
 * @exception  rb_eEncCompatError  Strings do not agree with their encodings.
 * @return     An  instance  of   ::rb_cString  which  concatenates  stringised
 *             contents of `ary`, using `sep` as separator.
 */
VALUE rb_ary_join(VALUE ary, VALUE sep);

/**
 * _Destructively_ reverses the passed array in-place.
 *
 * @warning     This is `Array#reverse!`, not `Array#reverse`.
 * @param[out]  ary              Target array to modify.
 * @exception   rb_eFrozenError  `ary` is frozen.
 * @return      Passed `ary`.
 * @post        `ary` is reversed.
 */
VALUE rb_ary_reverse(VALUE ary);

/**
 * _Destructively_ rotates the  passed array in-place to towards  its end.  The
 * amount can be negative.  Would rotate to the opposite direction then.
 *
 * @warning     This is `Array#rotate!`, not `Array#rotate`.
 * @param[out]  ary              Target array to modify.
 * @param[in]   rot              Amount of rotation.
 * @exception   rb_eFrozenError  `ary` is frozen.
 * @retval      RUBY_Qnil        Not rotated.
 * @retval      ary              Rotated.
 * @post        `ary` is rotated.
 */
VALUE rb_ary_rotate(VALUE ary, long rot);

/**
 * Creates a copy  of the passed array, whose elements  are sorted according to
 * their `<=>` result.
 *
 * @param[in]  ary               Array to sort.
 * @exception  rb_eArgError      Comparison not defined among elements.
 * @exception  rb_eRuntimeError  Infinite recursion in `<=>`.
 * @return     A copy of `ary`, sorted.
 * @note       As of writing  this function uses `qsort`  as backend algorithm,
 *             which means the result is unstable (in terms of sort stability).
 */
VALUE rb_ary_sort(VALUE ary);

/**
 * Destructively sorts the  passed array in-place, according  to each elements'
 * `<=>` result.
 *
 * @param[in]  ary               Target array to modify.
 * @exception  rb_eArgError      Comparison not defined among elements.
 * @exception  rb_eRuntimeError  Infinite recursion in `<=>`.
 * @return     Passed `ary`.
 * @post       `ary` is sorted.
 * @note       As of writing  this function uses `qsort`  as backend algorithm,
 *             which means the result is unstable (in terms of sort stability).
 */
VALUE rb_ary_sort_bang(VALUE ary);

/**
 * Destructively removes elements from the passed array, so that there would be
 * no elements  inside that satisfy  `==` relationship with the  passed object.
 * Returns the last deleted  element if any.  But in case  there was nothing to
 * delete it gets complicated.  It checks  for the implicitly passed block.  If
 * there is  a block  the return value  would be what  the block  evaluates to.
 * Otherwise it resorts to ::RUBY_Qnil.
 *
 * @param[out]  ary              Target array to modify.
 * @param[in]   elem             Template object to match against each element.
 * @exception   rb_eFrozenError  `ary` is frozen.
 * @return      What  was  deleted,   or  what  was  the   block  returned,  or
 *              ::RUBY_Qnil (see above).
 * @post        All elements that have `==` relationship with `elem` are purged
 *              from `ary`.  Elements shift their  positions so that `ary` gets
 *              compact.
 *
 * @internal
 *
 * Internally there also is `rb_ary_delete_same`, which compares by identity.
 */
VALUE rb_ary_delete(VALUE ary, VALUE elem);

/**
 * Destructively removes an element which resides  at the specific index of the
 * passed array.  Unlike  rb_ary_stre() the index can be  negative, which means
 * the index counts backwards from the array's tail.
 *
 * @param[out]  ary  Target array to modify.
 * @param[in]   pos  Position (can be negative).
 * @exception   rb_eFrozenError `ary` is frozen.
 * @return      What was deleted, or ::RUBY_Qnil in case of OOB.
 * @post        `ary`'s `pos`-th element is deleted if any.
 * @note        There is no  way to distinguish whether `pos` is  out of bound,
 *              or `pos` did exist but stored ::RUBY_Qnil as an ordinal value.
 */
VALUE rb_ary_delete_at(VALUE ary, long pos);

/**
 * Destructively removes everything form an array.
 *
 * @param[out]  ary              Target array to modify.
 * @exception   rb_eFrozenError  `ary` is frozen.
 * @return      The passed `ary`.
 * @post        `ary` is an empty array.
 */
VALUE rb_ary_clear(VALUE ary);

/**
 * Creates a new array, concatenating the former to the latter.
 *
 * @param[in]  lhs             Source array #1.
 * @param[in]  rhs             Source array #2.
 * @exception  rb_eIndexError  Result array too big.
 * @return     A new array containing `rhs` concatenated to `lhs`.
 * @note       This  operation  doesn't commute.   Don't  get  confused by  the
 *             "plus"  terminology.   For  historical reasons  there  are  some
 *             noncommutative `+`s in Ruby.  This is one of such things.  There
 *             has been a long discussion around `+`s in programming languages.
 *
 * @internal
 *
 * rb_ary_concat() is not  a destructive version of  rb_ary_plus().  They raise
 * different exceptions.  Don't know why though.
 */
VALUE rb_ary_plus(VALUE lhs, VALUE rhs);

/**
 * Destructively appends the contents of latter into the end of former.
 *
 * @param[out]  lhs              Destination array.
 * @param[in]   rhs              Source array.
 * @exception   rb_eFrozenError  `lhs` is frozen.
 * @exception   rb_eIndexError   Result array too big.
 * @exception   rb_eTypeError    `rhs` doesn't respond to `#to_ary`.
 * @return      The passed `lhs`.
 * @post        `lhs` has contents of `rhs` appended to its end.
 */
VALUE rb_ary_concat(VALUE lhs, VALUE rhs);

/**
 * Looks up the passed key, assuming the  passed array is an alist.  An "alist"
 * here  is a  list of  "association"s,  much like  that of  Emacs.  Emacs  has
 * `assoc` function that behaves exactly the same as this one.
 *
 * ```ruby
 * # This is an example of aliist.
 * auto_mode_alist = [
 *   [ /\.[ch]\z/, :"c-mode" ],
 *   [ /\.[ch]pp\z/, :"c++-mode" ],
 *   [ /\.awk\z/, :"awk-mode" ],
 *   [ /\.cs\z/, :"csharp-mode" ],
 *   [ /\.go\z/, :"go-mode" ],
 *   [ /\.java\z/, :"java-mode" ],
 *   [ /\.pas\z/, :"pascal-mode" ],
 *   [ /\.rs\z/, :"rust-mode" ],
 *   [ /\.txt\z/, :"text-mode" ],
 * ]
 * ```
 *
 * This function scans the passed array looking for an element, which itself is
 * an array,  whose first  element is the  passed key.  If  no such  element is
 * found, returns ::RUBY_Qnil.
 *
 * Although this  function expects the passed  array be an array  of arrays, it
 * can happily accept non-array elements; it just ignores such things.
 *
 * @param[in]  alist      An array of arrays.
 * @param[in]  key        Needle.
 * @retval     RUBY_Qnil  Nothing was found.
 * @retval     otherwise  An element in `alist` whose  first element is in `==`
 *                        relationship with `key`.
 */
VALUE rb_ary_assoc(VALUE alist, VALUE key);

/**
 * Identical  to rb_ary_assoc(),  except it  scans  the passed  array from  the
 * opposite direction.
 *
 * @param[in]  alist      An array of arrays.
 * @param[in]  key        Needle.
 * @retval     RUBY_Qnil  Nothing was found.
 * @retval     otherwise  An element in `alist` whose  first element is in `==`
 *                        relationship with `key`.
 */
VALUE rb_ary_rassoc(VALUE alist, VALUE key);

/**
 * Queries if the passed array has the passed entry.
 *
 * @param[in]  ary          Target array to scan.
 * @param[in]  elem         Target array to find.
 * @retval     RUBY_Qfalse  No element  in `ary`  is in `==`  relationship with
 *                          `elem`.
 * @retval     RUBY_Qtrue   There is at least one  element in `ary` which is in
 *                          `==` relationship with `elem`.
 *
 * @internal
 *
 * This is  the only function  in the  entire C API  that is named  using third
 * person singular  form of  a verb  (except #ISASCII etc.,  which are  not our
 * naming).  The counterpart Ruby API of this function is `Array#include?`.
 */
VALUE rb_ary_includes(VALUE ary, VALUE elem);

/**
 * Recursively compares each elements of the two arrays one-by-one using `<=>`.
 *
 * @param[in]  lhs        Comparison LHS.
 * @param[in]  rhs        Comparison RHS.
 * @retval     RUBY_Qnil  `lhs` and `rhs` are not comparable.
 * @retval     -1         `lhs` is less than `rhs`.
 * @retval      0         They are equal.
 * @retval      1         `rhs` is less then `lhs`.
 */
VALUE rb_ary_cmp(VALUE lhs, VALUE rhs);

/**
 * Replaces the contents of the former object with the contents of the latter.
 *
 * @param[out]  copy               Destination object.
 * @param[in]   orig               Source object.
 * @exception   rb_eTypeError     `orig` has no implicit conversion to Array.
 * @exception   rb_eFrozenError   `copy` is frozen.
 * @return      The passed `copy`.
 * @post        `copy`'s  former  components are  abandoned.   It  now has  the
 *              identical length and contents to `orig`.
 */
VALUE rb_ary_replace(VALUE copy, VALUE orig);

/**
 * This _was_  a generalisation  of `Array#values_at`,  `Struct#values_at`, and
 * `MatchData#values_at`.  It begun its life  as a refactoring effort.  However
 * as Ruby  evolves over  time, as  of writing  none of  aforementioned methods
 * share their implementations at all.   This function is not deprecated; still
 * works as it has been.  But it is now kind of like a rudimentum.
 *
 * This  function  takes an  object,  which  is a  receiver,  and  a series  of
 * "indices",  which are  either integers,  or ranges  of integers.   Calls the
 * passed callback  for each of those  indices, along with the  receiver.  This
 * callback is  expected to do something  like rb_ary_aref(), rb_struct_aref(),
 * etc.   In  case of  a  range  index  rb_range_beg_len() expands  the  range.
 * Finally  return values  of  the  callback are  gathered  as  an array,  then
 * returned.
 *
 * @param[in]  obj   Arbitrary ruby object.
 * @param[in]  olen  "Length" of `obj`.
 * @param[in]  argc  Number of objects of `argv`.
 * @param[in]  argv  List of "indices", described above.
 * @param[in]  func  Callback function.
 * @return     A new instance of ::rb_cArray gathering `func`outputs.
 *
 * @internal
 *
 * `Array#values_at` no  longer uses this  function.  There is no  reason apart
 * from historical ones to list this function here.
 */
VALUE rb_get_values_at(VALUE obj, long olen, int argc, const VALUE *argv, VALUE (*func)(VALUE obj, long oidx));

/**
 * Expands or shrinks the passed array to the passed length.
 *
 * @param[out]  ary              An array to modify.
 * @param[in]   len              Desired length of `ary`.
 * @exception   rb_eFrozenError  `ary`  is frozen.
 * @exception   rb_eIndexError   `len` too long.
 * @return      The passed `ary`.
 * @post        `ary`'s length is `len`.
 * @post        Depending on `len` and previous  length of `ary` this operation
 *              can  also create  a series  of "hole"  positions inside  of the
 *              backend storage.  They are filled with ::RUBY_Qnil.
 *
 * @internal
 *
 * `len` is signed.  Intentional or...?
 */
VALUE rb_ary_resize(VALUE ary, long len);

#define rb_ary_new2 rb_ary_new_capa         /**< @old{rb_ary_new_capa} */
#define rb_ary_new3 rb_ary_new_from_args    /**< @old{rb_ary_new_from_args} */
#define rb_ary_new4 rb_ary_new_from_values  /**< @old{rb_ary_new_from_values} */

RBIMPL_SYMBOL_EXPORT_END()

#endif /* RBIMPL_INTERN_ARRAY_H */

Back