admin/mruby-mruby
1
0
Fork 0
mirror of https://github.com/mruby/mruby synced 2026-06-08 16:11:16 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
95bfa861609794fa9092465d18d3830bec2ee619
mruby-mruby/src/hash.c
T
Yukihiro "Matz" Matsumoto 8956c5abb5 mruby.h: include mruby/presym.h for all source files 
Since presym is now mandatory, mruby.h includes presym.h so that
MRB_SYM() macros are available everywhere without explicit include.
Remove redundant #include <mruby/presym.h> from all source files.

Co-authored-by: Claude <noreply@anthropic.com>
2026-03-09 16:50:58 +09:00

2355 lines
68 KiB
C
Raw Blame History

/*
** hash.c - Hash class
**
** See Copyright Notice in mruby.h
*/
#include <string.h>
#include <mruby.h>
#include <mruby/array.h>
#include <mruby/class.h>
#include <mruby/hash.h>
#include <mruby/string.h>
#include <mruby/variable.h>
#include <mruby/proc.h>
#include <mruby/internal.h>
/*
* === Glossary
*
* [EA]
* Entry Array. Store `Hash' entries in insertion order.
*
* [AR]
* Array Table Implementation. The structure of `Hash` that doesn't have a
* hash table and linearly searches EA. It is used when `Hash` size <= 16.
*
* [IB]
* Index Buckets. The buckets of hash table, where the bucket value is EA
* index. The index is represented by variable length bits according to
* the capacity.
*
* [HT]
* Hash Table Implementation. The structure of `Hash` that has IB and is
* searched by hash table algorithm. It is used when `Hash` size > 16.
* Collision resolution strategy is open addressing method.
*
* [size]
* The number of `Hash` entries (value of `Hash#size`).
*
* [slot]
* The generic term for EA or IB elements.
*
* [active]
* The state in which a slot is recognized as a `Hash` entry.
*
* [deleted]
* The state in which a slot is marked as deleted.
*
* [used]
* The state in which a slot is active or deleted.
*
* [empty]
* The state in which a slot is not used. Capacity is equal to the sum of
* the number of used slots and the number of empty slots.
*/
#define EA_N_RESERVED_INDICES 2 /* empty and deleted */
#define EA_MAX_INCREASE UINT16_MAX
#define EA_MAX_CAPA U32(lesser(IB_MAX_CAPA - EA_N_RESERVED_INDICES, MRB_INT_MAX))
#define IB_MAX_CAPA (U32(1) << IB_MAX_BIT)
#define IB_TYPE_BIT 32
#define IB_INIT_BIT ( \
ib_upper_bound_for(32) <= AR_MAX_SIZE ? 6 : \
ib_upper_bound_for(16) <= AR_MAX_SIZE ? 5 : \
4 \
)
#define IB_MAX_BIT (IB_TYPE_BIT - 1)
#define AR_DEFAULT_CAPA 4
#define AR_MAX_SIZE 16
#define H_MAX_SIZE EA_MAX_CAPA
mrb_static_assert(offsetof(struct RHash, iv) == offsetof(struct RObject, iv));
mrb_static_assert(AR_MAX_SIZE < (1 << MRB_HASH_AR_EA_CAPA_BIT));
typedef struct hash_entry {
mrb_value key;
mrb_value val;
} hash_entry;
typedef struct hash_table {
hash_entry *ea;
#ifdef MRB_32BIT
uint32_t ea_capa;
uint32_t ea_n_used;
#endif
uint32_t ib[];
} hash_table;
typedef struct index_buckets_iter {
struct RHash *h;
uint32_t bit;
uint32_t mask;
uint32_t initial_pos;
uint32_t pos;
uint32_t ary_index;
uint32_t ea_index;
uint32_t shift1;
uint32_t shift2;
uint32_t step;
} index_buckets_iter;
/*
* `c_` :: receiver class (category)
* `n_` :: attribute name
* `t_` :: attribute type
* `p_` :: struct member path
* `k_` :: macro key
*/
#define DEFINE_GETTER(c_, n_, t_, p_) \
MRB_INLINE t_ c_##_##n_(const struct RHash *h) {return h->p_;}
#define DEFINE_SETTER(c_, n_, t_, p_) \
MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) {h->p_ = v;}
#define DEFINE_ACCESSOR(c_, n_, t_, p_) \
DEFINE_GETTER(c_, n_, t_, p_) \
DEFINE_SETTER(c_, n_, t_, p_)
#define DEFINE_FLAG_GETTER(c_, n_, t_, k_) \
MRB_INLINE t_ c_##_##n_(const struct RHash *h) { \
return (t_)((h->flags & MRB_HASH_##k_##_MASK) >> MRB_HASH_##k_##_SHIFT); \
}
#define DEFINE_FLAG_SETTER(c_, n_, t_, k_) \
MRB_INLINE void c_##_set_##n_(struct RHash *h, t_ v) { \
h->flags &= ~MRB_HASH_##k_##_MASK; \
h->flags |= v << MRB_HASH_##k_##_SHIFT; \
}
#define DEFINE_FLAG_ACCESSOR(c_, n_, t_, k_) \
DEFINE_FLAG_GETTER(c_, n_, t_, k_) \
DEFINE_FLAG_SETTER(c_, n_, t_, k_)
#define DEFINE_INCREMENTER(c_, n_) \
MRB_INLINE void c_##_inc_##n_(struct RHash *h) { \
c_##_set_##n_(h, c_##_##n_(h) + 1); \
}
#define DEFINE_DECREMENTER(c_, n_) \
MRB_INLINE void c_##_dec_##n_(struct RHash *h) { \
c_##_set_##n_(h, c_##_##n_(h) - 1); \
}
#define DEFINE_SWITCHER(n_, k_) \
MRB_INLINE void h_##n_##_on(struct RHash *h) { \
h->flags |= MRB_HASH_##k_; \
} \
MRB_INLINE void h_##n_##_off(struct RHash *h) { \
h->flags &= ~MRB_HASH_##k_; \
} \
MRB_INLINE mrb_bool h_##n_##_p(const struct RHash *h) { \
return (h->flags & MRB_HASH_##k_) == MRB_HASH_##k_; \
}
#ifdef MRB_64BIT
DEFINE_ACCESSOR(ar, ea_capa, uint32_t, ea_capa) /* ar_ea_capa ar_set_ea_capa */
DEFINE_ACCESSOR(ar, ea_n_used, uint32_t, ea_n_used) /* ar_ea_n_used ar_set_ea_n_used */
DEFINE_ACCESSOR(ht, ea_capa, uint32_t, ea_capa) /* ht_ea_capa ht_set_ea_capa */
DEFINE_ACCESSOR(ht, ea_n_used, uint32_t, ea_n_used) /* ht_ea_n_used ht_set_ea_n_used */
#else
DEFINE_FLAG_ACCESSOR(ar, ea_capa, uint32_t, AR_EA_CAPA) /* ar_ea_capa ar_set_ea_capa */
DEFINE_FLAG_ACCESSOR(ar, ea_n_used, uint32_t, AR_EA_N_USED) /* ar_ea_n_used ar_set_ea_n_used */
DEFINE_ACCESSOR(ht, ea_capa, uint32_t, hsh.ht->ea_capa) /* ht_ea_capa ht_set_ea_capa */
DEFINE_ACCESSOR(ht, ea_n_used, uint32_t, hsh.ht->ea_n_used) /* ht_ea_n_used ht_set_ea_n_used */
#endif
DEFINE_FLAG_ACCESSOR(ib, bit, uint32_t, IB_BIT) /* ib_bit ib_set_bit */
DEFINE_ACCESSOR(ar, size, uint32_t, size) /* ar_size ar_set_size */
DEFINE_ACCESSOR(ar, ea, hash_entry*, hsh.ea) /* ar_ea ar_set_ea */
DEFINE_DECREMENTER(ar, size) /* ar_dec_size */
DEFINE_ACCESSOR(ht, size, uint32_t, size) /* ht_size ht_set_size */
DEFINE_ACCESSOR(ht, ea, hash_entry*, hsh.ht->ea) /* ht_ea ht_set_ea */
DEFINE_GETTER(ht, ib, uint32_t*, hsh.ht->ib) /* ht_ib */
DEFINE_INCREMENTER(ht, size) /* ht_inc_size */
DEFINE_DECREMENTER(ht, size) /* ht_dec_size */
DEFINE_GETTER(h, size, uint32_t, size) /* h_size */
DEFINE_ACCESSOR(h, ht, hash_table*, hsh.ht) /* h_ht h_set_ht */
DEFINE_SWITCHER(ht, HT) /* h_ht_on h_ht_off h_ht_p */
#define EA_EACH_USED(ea, n_used, entry_var) \
for (hash_entry *entry_var = (ea), *ea_end__ = (entry_var) + (n_used); \
entry_var < ea_end__; \
entry_var++)
#define EA_EACH(ea, size, entry_var) \
for (uint32_t ea_size__ = (size); ea_size__; ea_size__ = 0) \
for (hash_entry *entry_var = (ea); \
ea_size__ && (entry_var = entry_skip_deleted(entry_var), TRUE); \
entry_var++, ea_size__--)
#define IB_CYCLE_BY_KEY(mrb, h, key, it_var) \
for (index_buckets_iter it_var[1] = { ib_it_init(mrb, h, key) }; \
(ib_it_next(it_var), TRUE); \
/* do nothing */)
#define IB_FIND_BY_KEY(mrb, h, key, it_var) \
for (index_buckets_iter it_var[1] = { ib_it_init(mrb, h, key) }; \
ib_it_find_by_key(mrb, it_var, key); \
it_var[0].h = NULL)
#define H_EACH(h, entry_var) \
EA_EACH((h_ar_p(h) ? ar_ea(h) : ht_ea(h)), \
(h_ar_p(h) ? ar_size(h) : ht_size(h)), \
entry_var)
/*
* In `H_CHECK_MODIFIED()`, in the case of `MRB_NO_BOXING`, `ht_ea()` or
* `ht_ea_capa()` for AR may read uninitialized area (#5332). Therefore, do
* not use those macros for AR in `MRB_NO_BOXING` (but in the case of
* `MRB_64BIT`, `ht_ea_capa()` is the same as `ar_ea_capa()`, so use it).
*/
#ifdef MRB_NO_BOXING
# define H_CHECK_MODIFIED_USE_HT_EA_FOR_AR FALSE
# ifdef MRB_64BIT
# define H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR TRUE
# else
# define H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR FALSE
# endif /* MRB_64BIT */
#else
# define H_CHECK_MODIFIED_USE_HT_EA_FOR_AR TRUE
# define H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR TRUE
/*
* `H_CHECK_MODIFIED` raises an exception when a dangerous modification is
* made to `h` by executing `code`.
*
* `H_CHECK_MODIFIED` macro is not called if `h->hsh.ht` (`h->hsh.ea`) is `NULL`
* (`Hash` size is zero). And because the `hash_entry` is rather large,
* `h->hsh.ht->ea` and `h->hsh.ht->ea_capa` are able to be safely accessed even for
* AR. This nature is used to eliminate branch of AR or HT.
*
* `HT_ASSERT_SAFE_READ` checks if members can be accessed according to its
* assumptions.
*/
# define HT_ASSERT_SAFE_READ(attr_name) \
mrb_static_assert( \
offsetof(hash_table, attr_name) + sizeof(((hash_table*)0)->attr_name) <= \
sizeof(hash_entry))
HT_ASSERT_SAFE_READ(ea);
# ifdef MRB_32BIT
HT_ASSERT_SAFE_READ(ea_capa);
# endif
# undef HT_ASSERT_SAFE_READ
#endif /* MRB_NO_BOXING */
/*
* `H_CHECK_MODIFIED` raises an exception when a dangerous modification is
* made to `h` by executing code block.
*/
#define H_CHECK_MODIFIED(mrb, h) \
for (struct h_check_modified h_checker__ = h_check_modified_init(mrb, h); \
h_checker__.tbl; \
h_check_modified_validate(mrb, &h_checker__, h), h_checker__.tbl = NULL)
#define U32(v) ((uint32_t)(v))
#define h_ar_p(h) (!h_ht_p(h))
#define h_ar_on(h) h_ht_off(h)
#define lesser(a, b) ((a) < (b) ? (a) : (b))
#define RHASH_IFNONE(hash) mrb_iv_get(mrb, (hash), MRB_SYM(ifnone))
#define RHASH_PROCDEFAULT(hash) RHASH_IFNONE(hash)
static uint32_t ib_upper_bound_for(uint32_t capa);
static uint32_t ib_bit_to_capa(uint32_t bit);
static hash_entry *ib_it_entry(index_buckets_iter *it);
static void ht_init(
mrb_state *mrb, struct RHash *h, uint32_t size,
hash_entry *ea, uint32_t ea_capa, hash_table *ht, uint32_t ib_bit);
static void ht_set(mrb_state *mrb, struct RHash *h, mrb_value key, mrb_value val);
static uint32_t
next_power2(uint32_t v)
{
mrb_assert(v != 0);
#ifdef __GNUC__
return U32(1) << ((sizeof(unsigned) * CHAR_BIT) - __builtin_clz(v));
#else
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v++;
return v;
#endif
}
struct h_check_modified {
uint32_t flags;
void *tbl;
uint32_t ht_ea_capa;
hash_entry *ht_ea;
};
#define H_CHECK_MODIFIED_FLAGS_MASK (MRB_HASH_HT | MRB_HASH_IB_BIT_MASK | MRB_HASH_AR_EA_CAPA_MASK)
static struct h_check_modified
h_check_modified_init(mrb_state *mrb, struct RHash *h)
{
mrb_assert(h->hsh.ht);
struct h_check_modified checker;
checker.flags = h->flags & H_CHECK_MODIFIED_FLAGS_MASK;
checker.tbl = h->hsh.ht;
checker.ht_ea_capa = (H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR || h_ht_p(h)) ? ht_ea_capa(h) : 0;
checker.ht_ea = (H_CHECK_MODIFIED_USE_HT_EA_FOR_AR || h_ht_p(h)) ? ht_ea(h) : NULL;
return checker;
}
static void
h_check_modified_validate(mrb_state *mrb, struct h_check_modified *checker, struct RHash *h)
{
if (checker->flags != (h->flags & H_CHECK_MODIFIED_FLAGS_MASK) ||
checker->tbl != h->hsh.ht ||
((H_CHECK_MODIFIED_USE_HT_EA_CAPA_FOR_AR || h_ht_p(h)) &&
checker->ht_ea_capa != ht_ea_capa(h)) ||
((H_CHECK_MODIFIED_USE_HT_EA_FOR_AR || h_ht_p(h)) &&
checker->ht_ea != ht_ea(h))) {
mrb_raise(mrb, E_RUNTIME_ERROR, "hash modified");
}
}
#ifndef MRB_NO_FLOAT
static uint32_t
float_hash_code(mrb_float f)
{
if (f == 0.0) return 0;
/* normalize -0.0 to 0.0 */
if (f == -0.0) f = 0.0;
return mrb_byte_hash((const uint8_t*)&f, sizeof(f));
}
#endif
uint32_t
mrb_obj_hash_code(mrb_state *mrb, mrb_value key)
{
enum mrb_vtype tt = mrb_type(key);
uint32_t hash_code;
mrb_value hash_code_obj;
switch (tt) {
case MRB_TT_STRING:
hash_code = mrb_str_hash(mrb, key);
break;
case MRB_TT_TRUE:
case MRB_TT_FALSE:
case MRB_TT_SYMBOL:
hash_code = U32(mrb_fixnum(key));
break;
case MRB_TT_INTEGER:
if (mrb_fixnum_p(key)) {
hash_code = U32(mrb_fixnum(key));
}
else {
#ifdef MRB_USE_BIGINT
hash_code = U32(mrb_integer(mrb_bint_hash(mrb, key)));
#else
/* This path should not be reached if bignum is not configured.
* Hashing object_id is a fallback to avoid uninitialized value. */
hash_code = U32(mrb_obj_id(key));
#endif
}
break;
#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
hash_code = float_hash_code(mrb_float(key));
break;
#endif
default:
hash_code_obj = mrb_funcall_argv(mrb, key, MRB_SYM(hash), 0, NULL);
hash_code = U32(tt) ^ U32(mrb_integer(hash_code_obj));
break;
}
return hash_code ^ (hash_code << 2) ^ (hash_code >> 2);
}
static uint32_t
obj_hash_code(mrb_state *mrb, mrb_value key, struct RHash *h)
{
uint32_t hash_code = 0;
H_CHECK_MODIFIED(mrb, h) {
hash_code = mrb_obj_hash_code(mrb, key);
}
return hash_code;
}
static mrb_bool
obj_eql(mrb_state *mrb, mrb_value a, mrb_value b, struct RHash *h)
{
mrb_bool eql = FALSE;
switch (mrb_type(a)) {
case MRB_TT_STRING:
return mrb_str_equal(mrb, a, b);
case MRB_TT_SYMBOL:
if (!mrb_symbol_p(b)) return FALSE;
return mrb_symbol(a) == mrb_symbol(b);
case MRB_TT_INTEGER:
if (!mrb_integer_p(b)) return FALSE;
return mrb_integer(a) == mrb_integer(b);
#ifndef MRB_NO_FLOAT
case MRB_TT_FLOAT:
if (!mrb_float_p(b)) return FALSE;
return mrb_float(a) == mrb_float(b);
#endif
default:
H_CHECK_MODIFIED(mrb, h) {eql = mrb_eql(mrb, a, b);}
return eql;
}
}
static inline mrb_bool
entry_deleted_p(const hash_entry* entry)
{
return mrb_undef_p(entry->key);
}
static void
entry_delete(hash_entry* entry)
{
entry->key = mrb_undef_value();
}
static hash_entry*
entry_skip_deleted(hash_entry *e)
{
for (; entry_deleted_p(e); e++)
;
return e;
}
static uint32_t
ea_next_capa_for(uint32_t size, uint32_t max_capa)
{
if (size < AR_DEFAULT_CAPA) {
return AR_DEFAULT_CAPA;
}
else {
/*
* For 32-bit CPU, the theoretical value of maximum EA capacity is
* `UINT32_MAX / sizeof (hash_entry)`. At this time, if
* `EA_INCREASE_RATIO` is the current value, 32-bit range will not be
* exceeded during the calculation of `capa`, so `size_t` is used.
*/
size_t capa = ((size_t)size * 6) / 5 + 6;
size_t inc = capa - size;
if (EA_MAX_INCREASE < inc) capa = size + EA_MAX_INCREASE;
return capa <= max_capa ? U32(capa) : max_capa;
}
}
static hash_entry*
ea_resize(mrb_state *mrb, hash_entry *ea, uint32_t capa)
{
return (hash_entry*)mrb_realloc(mrb, ea, sizeof(hash_entry) * capa);
}
static void
ea_compress(hash_entry *ea, uint32_t n_used)
{
hash_entry *w_entry = ea;
EA_EACH_USED(ea, n_used, r_entry) {
if (entry_deleted_p(r_entry)) continue;
if (r_entry != w_entry) *w_entry = *r_entry;
w_entry++;
}
}
/*
* Increase or decrease capacity of `ea` to a standard size that can
* accommodate `*capap + 1` entries (but, not exceed `max_capa`). Set the
* changed capacity to `*capap` and return a pointer to `mrb_realloc`ed EA.
*/
static hash_entry*
ea_adjust(mrb_state *mrb, hash_entry *ea, uint32_t *capap, uint32_t max_capa)
{
*capap = ea_next_capa_for(*capap, max_capa);
return ea_resize(mrb, ea, *capap);
}
static hash_entry*
ea_dup(mrb_state *mrb, const hash_entry *ea, uint32_t capa)
{
size_t byte_size = sizeof(hash_entry) * capa;
hash_entry *new_ea = (hash_entry*)mrb_malloc(mrb, byte_size);
return (hash_entry*)memcpy(new_ea, ea, byte_size);
}
static hash_entry*
ea_get_by_key(mrb_state *mrb, hash_entry *ea, uint32_t size, mrb_value key,
struct RHash *h)
{
EA_EACH(ea, size, entry) {
if (obj_eql(mrb, key, entry->key, h)) return entry;
}
return NULL;
}
static hash_entry*
ea_get(hash_entry *ea, uint32_t index)
{
return &ea[index];
}
static void
ea_set(hash_entry *ea, uint32_t index, mrb_value key, mrb_value val)
{
ea[index].key = key;
ea[index].val = val;
}
static void
ar_init(struct RHash *h, uint32_t size,
hash_entry *ea, uint32_t ea_capa, uint32_t ea_n_used)
{
h_ar_on(h);
ar_set_size(h, size);
ar_set_ea(h, ea);
ar_set_ea_capa(h, ea_capa);
ar_set_ea_n_used(h, ea_n_used);
}
static void
ar_free(mrb_state *mrb, struct RHash *h)
{
mrb_free(mrb, ar_ea(h));
}
static void
ar_adjust_ea(mrb_state *mrb, struct RHash *h, uint32_t size, uint32_t max_ea_capa)
{
uint32_t ea_capa = size;
hash_entry *ea = ea_adjust(mrb, ar_ea(h), &ea_capa, max_ea_capa);
ar_set_ea(h, ea);
ar_set_ea_capa(h, ea_capa);
}
static void
ar_compress(mrb_state *mrb, struct RHash *h)
{
uint32_t size = ar_size(h);
ea_compress(ar_ea(h), ar_ea_n_used(h));
ar_set_ea_n_used(h, size);
ar_adjust_ea(mrb, h, size, lesser(ar_ea_capa(h), AR_MAX_SIZE));
}
static mrb_bool
ar_get(mrb_state *mrb, struct RHash *h, mrb_value key, mrb_value *valp)
{
EA_EACH(ar_ea(h), ar_size(h), entry) {
if (!obj_eql(mrb, key, entry->key, h)) continue;
*valp = entry->val;
return TRUE;
}
return FALSE;
}
static void
ar_set(mrb_state *mrb, struct RHash *h, mrb_value key, mrb_value val)
{
uint32_t size = ar_size(h);
hash_entry *entry;
if ((entry = ea_get_by_key(mrb, ar_ea(h), size, key, h))) {
entry->val = val;
}
else {
uint32_t ea_capa = ar_ea_capa(h), ea_n_used = ar_ea_n_used(h);
if (ea_capa == ea_n_used) {
if (size == ea_n_used) {
if (size == AR_MAX_SIZE) {
ht_init(mrb, h, size, ar_ea(h), ea_capa, NULL, IB_INIT_BIT);
ht_set(mrb, h, key, val);
return;
}
else {
ar_adjust_ea(mrb, h, size, AR_MAX_SIZE);
}
}
else {
ar_compress(mrb, h);
ea_n_used = size;
}
}
ea_set(ar_ea(h), ea_n_used, key, val);
ar_set_size(h, ++size);
ar_set_ea_n_used(h, ++ea_n_used);
}
}
static mrb_bool
ar_delete(mrb_state *mrb, struct RHash *h, mrb_value key, mrb_value *valp)
{
hash_entry *entry = ea_get_by_key(mrb, ar_ea(h), ar_size(h), key, h);
if (!entry) return FALSE;
*valp = entry->val;
entry_delete(entry);
ar_dec_size(h);
return TRUE;
}
static void
ar_shift(mrb_state *mrb, struct RHash *h, mrb_value *keyp, mrb_value *valp)
{
uint32_t size = ar_size(h);
EA_EACH(ar_ea(h), size, entry) {
*keyp = entry->key;
*valp = entry->val;
entry_delete(entry);
ar_set_size(h, --size);
return;
}
}
static void
ar_rehash(mrb_state *mrb, struct RHash *h)
{
/* see comments in `h_rehash` */
uint32_t size = ar_size(h), w_size = 0, ea_capa = ar_ea_capa(h);
hash_entry *ea = ar_ea(h), *w_entry;
EA_EACH(ea, size, r_entry) {
if ((w_entry = ea_get_by_key(mrb, ea, w_size, r_entry->key, h))) {
w_entry->val = r_entry->val;
ar_set_size(h, --size);
entry_delete(r_entry);
}
else {
if (w_size != U32(r_entry - ea)) {
ea_set(ea, w_size, r_entry->key, r_entry->val);
entry_delete(r_entry);
}
w_size++;
}
}
mrb_assert(size == w_size);
ar_set_ea_n_used(h, size);
ar_adjust_ea(mrb, h, size, ea_capa);
}
static uint32_t
ib_it_pos_for(index_buckets_iter *it, uint32_t v)
{
return v & it->mask;
}
static uint32_t
ib_it_empty_value(const index_buckets_iter *it)
{
return it->mask;
}
static uint32_t
ib_it_deleted_value(const index_buckets_iter *it)
{
return it->mask - 1;
}
static mrb_bool
ib_it_empty_p(const index_buckets_iter *it)
{
return it->ea_index == ib_it_empty_value(it);
}
static mrb_bool
ib_it_deleted_p(const index_buckets_iter *it)
{
return it->ea_index == ib_it_deleted_value(it);
}
static mrb_bool
ib_it_active_p(const index_buckets_iter *it)
{
return it->ea_index < ib_it_deleted_value(it);
}
static index_buckets_iter
ib_it_init(mrb_state *mrb, struct RHash *h, mrb_value key)
{
index_buckets_iter it;
it.h = h;
it.bit = ib_bit(h);
it.mask = ib_bit_to_capa(it.bit) - 1;
it.initial_pos = ib_it_pos_for(&it, obj_hash_code(mrb, key, h));
it.pos = it.initial_pos;
it.step = 0;
return it;
}
static void
ib_it_next(index_buckets_iter *it)
{
/*
* [IB image]
*
* ary_index(1) --.
* \ .-- shift1(3) .-- shift2(29)
* pos(6) --. \ / /
* View | \ \ <-o-> <----------o---------->
* -------- +---------------------\----\--+-----------------------------+-----
* array | 0 `--. `-|--- o 1 | ...
* +---------+---------+-----+\--+-----+---------+---------+---+-----
* buckets | 0 | 1 | ... | o 6 | 7 | 8 | ...
* +---------+---------+-----+=========+---------+---------+---------
* bit set |1 1 1 0 0|0 0 0 1 1| ... |0 1 0 1 1|0 1 1 1 0|0 1 0 1 0| ...
* +---------+---------+-----+========*+---------+---------+---------
* <---o---> \
* \ `-- bit_pos(34)
* `-- bit(5)
*/
/* Slide to handle as `capa == 32` to avoid 64-bit operations */
uint32_t slid_pos = it->pos & (IB_TYPE_BIT - 1);
uint32_t slid_bit_pos = it->bit * (slid_pos + 1) - 1;
uint32_t slid_ary_index = slid_bit_pos / IB_TYPE_BIT;
it->ary_index = slid_ary_index + it->pos / IB_TYPE_BIT * it->bit;
it->shift2 = (slid_ary_index + 1) * IB_TYPE_BIT - slid_bit_pos - 1;
it->ea_index = (ht_ib(it->h)[it->ary_index] >> it->shift2) & it->mask;
if (IB_TYPE_BIT - it->bit < it->shift2) {
it->shift1 = IB_TYPE_BIT - it->shift2;
it->ea_index |= (ht_ib(it->h)[it->ary_index - 1] << it->shift1) & it->mask;
}
else {
it->shift1 = 0;
}
it->step++;
it->pos = ib_it_pos_for(it, it->initial_pos + (it->step * it->step + it->step) / 2);
}
static mrb_bool
ib_it_find_by_key(mrb_state *mrb, index_buckets_iter *it, mrb_value key)
{
if (!it->h) return FALSE;
for (;;) {
ib_it_next(it);
if (ib_it_empty_p(it)) return FALSE;
if (!ib_it_deleted_p(it) &&
obj_eql(mrb, key, ib_it_entry(it)->key, it->h)) {
return TRUE;
}
}
}
static uint32_t
ib_it_get(const index_buckets_iter *it)
{
return it->ea_index;
}
static void
ib_it_set(index_buckets_iter *it, uint32_t ea_index)
{
uint32_t mask, i;
it->ea_index = ea_index;
if (it->shift1) {
i = it->ary_index - 1;
mask = it->mask >> it->shift1;
ht_ib(it->h)[i] = (ht_ib(it->h)[i] & ~mask) | (ea_index >> it->shift1);
}
i = it->ary_index;
mask = it->mask << it->shift2;
ht_ib(it->h)[i] = (ht_ib(it->h)[i] & ~mask) | (ea_index << it->shift2);
}
static void
ib_it_delete(index_buckets_iter *it)
{
ib_it_set(it, ib_it_deleted_value(it));
}
static hash_entry*
ib_it_entry(index_buckets_iter *it)
{
return ea_get(ht_ea(it->h), it->ea_index);
}
static uint32_t
ib_capa_to_bit(uint32_t capa)
{
#ifdef __GNUC__
return U32(__builtin_ctz(capa));
#else
/* http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn */
static const uint32_t MultiplyDeBruijnBitPosition2[] = {
0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
};
return MultiplyDeBruijnBitPosition2[U32(capa * 0x077CB531U) >> 27];
#endif
}
static uint32_t
ib_bit_to_capa(uint32_t bit)
{
return U32(1) << bit;
}
static uint32_t
ib_upper_bound_for(uint32_t capa)
{
return (capa >> 2) | (capa >> 1); /* 3/4 */
}
static uint32_t
ib_bit_for(uint32_t size)
{
uint32_t capa = next_power2(size);
if (capa != IB_MAX_CAPA && ib_upper_bound_for(capa) < size) capa *= 2;
return ib_capa_to_bit(capa);
}
static uint32_t
ib_byte_size_for(uint32_t ib_bit)
{
mrb_assert(IB_INIT_BIT <= ib_bit);
uint32_t ary_size = IB_INIT_BIT == 4 ?
ib_bit_to_capa(ib_bit) * 2 / IB_TYPE_BIT * ib_bit / 2 :
ib_bit_to_capa(ib_bit) / IB_TYPE_BIT * ib_bit;
return U32(sizeof(uint32_t) * ary_size);
}
static void
ib_init(mrb_state *mrb, struct RHash *h, uint32_t ib_bit, size_t ib_byte_size)
{
hash_entry *ea = ht_ea(h);
memset(ht_ib(h), 0xff, ib_byte_size);
ib_set_bit(h, ib_bit);
EA_EACH_USED(ea, ht_ea_n_used(h), entry) {
IB_CYCLE_BY_KEY(mrb, h, entry->key, it) {
if (!ib_it_empty_p(it)) continue;
ib_it_set(it, U32(entry - ea));
break;
}
}
}
static void
ht_init(mrb_state *mrb, struct RHash *h, uint32_t size,
hash_entry *ea, uint32_t ea_capa, hash_table *ht, uint32_t ib_bit)
{
size_t ib_byte_size = ib_byte_size_for(ib_bit);
size_t ht_byte_size = sizeof(hash_table) + ib_byte_size;
ht = (hash_table*)mrb_realloc(mrb, ht, ht_byte_size);
h_ht_on(h);
h_set_ht(h, ht);
ht_set_size(h, size);
ht_set_ea(h, ea);
ht_set_ea_capa(h, ea_capa);
ht_set_ea_n_used(h, size);
ib_init(mrb, h, ib_bit, ib_byte_size);
}
static void
ht_free(mrb_state *mrb, struct RHash *h)
{
mrb_free(mrb, ht_ea(h));
mrb_free(mrb, h_ht(h));
}
static hash_table*
ht_dup(mrb_state *mrb, const struct RHash *h)
{
size_t ib_byte_size = ib_byte_size_for(ib_bit(h));
size_t ht_byte_size = sizeof(hash_table) + ib_byte_size;
hash_table *new_ht = (hash_table*)mrb_malloc(mrb, ht_byte_size);
return (hash_table*)memcpy(new_ht, h_ht(h), ht_byte_size);
}
static void
ht_adjust_ea(mrb_state *mrb, struct RHash *h, uint32_t size, uint32_t max_ea_capa)
{
uint32_t ea_capa = size;
hash_entry *ea = ea_adjust(mrb, ht_ea(h), &ea_capa, max_ea_capa);
ht_set_ea(h, ea);
ht_set_ea_capa(h, ea_capa);
}
static void
ht_to_ar(mrb_state *mrb, struct RHash *h)
{
uint32_t size = ht_size(h), ea_capa = size;
hash_entry *ea = ht_ea(h);
ea_compress(ea, ht_ea_n_used(h));
ea = ea_adjust(mrb, ea, &ea_capa, AR_MAX_SIZE);
mrb_free(mrb, h_ht(h));
ar_init(h, size, ea, ea_capa, size);
}
static mrb_bool
ht_get(mrb_state *mrb, struct RHash *h, mrb_value key, mrb_value *valp)
{
IB_FIND_BY_KEY(mrb, h, key, it) {
*valp = ib_it_entry(it)->val;
return TRUE;
}
return FALSE;
}
static void
ht_set_as_ar(mrb_state *mrb, struct RHash *h, mrb_value key, mrb_value val)
{
ht_to_ar(mrb, h);
ar_set(mrb, h, key, val);
}
static void
ht_set(mrb_state *mrb, struct RHash *h, mrb_value key, mrb_value val)
{
uint32_t size = ht_size(h);
uint32_t ib_bit_width = ib_bit(h), ib_capa = ib_bit_to_capa(ib_bit_width);
if (ib_upper_bound_for(ib_capa) <= size) {
if (size != ht_ea_n_used(h)) ea_compress(ht_ea(h), ht_ea_n_used(h));
ht_init(mrb, h, size, ht_ea(h), ht_ea_capa(h), h_ht(h), ++ib_bit_width);
}
else if (size != ht_ea_n_used(h)) {
if (ib_capa - EA_N_RESERVED_INDICES <= ht_ea_n_used(h)) goto compress;
if (ht_ea_capa(h) == ht_ea_n_used(h)) {
if (size <= AR_MAX_SIZE) {
ht_set_as_ar(mrb, h, key, val);
return;
}
if (ea_next_capa_for(size, EA_MAX_CAPA) <= ht_ea_capa(h)) {
compress:
ea_compress(ht_ea(h), ht_ea_n_used(h));
ht_adjust_ea(mrb, h, size, ht_ea_capa(h));
ht_init(mrb, h, size, ht_ea(h), ht_ea_capa(h), h_ht(h), ib_bit_width);
}
}
}
mrb_assert(ht_size(h) < ib_bit_to_capa(ib_bit(h)));
IB_CYCLE_BY_KEY(mrb, h, key, it) {
if (ib_it_active_p(it)) {
if (!obj_eql(mrb, key, ib_it_entry(it)->key, h)) continue;
ib_it_entry(it)->val = val;
}
else if (ib_it_deleted_p(it)) {
continue;
}
else {
uint32_t ea_n_used = ht_ea_n_used(h);
if (ea_n_used == H_MAX_SIZE) {
mrb_assert(ht_size(h) == ea_n_used);
mrb_raise(mrb, E_ARGUMENT_ERROR, "hash too big");
}
if (ea_n_used == ht_ea_capa(h)) ht_adjust_ea(mrb, h, ea_n_used, EA_MAX_CAPA);
ib_it_set(it, ea_n_used);
ea_set(ht_ea(h), ea_n_used, key, val);
ht_inc_size(h);
ht_set_ea_n_used(h, ++ea_n_used);
}
return;
}
}
static mrb_bool
ht_delete(mrb_state *mrb, struct RHash *h, mrb_value key, mrb_value *valp)
{
IB_FIND_BY_KEY(mrb, h, key, it) {
hash_entry *entry = ib_it_entry(it);
*valp = entry->val;
ib_it_delete(it);
entry_delete(entry);
ht_dec_size(h);
return TRUE;
}
return FALSE;
}
static void
ht_shift(mrb_state *mrb, struct RHash *h, mrb_value *keyp, mrb_value *valp)
{
hash_entry *ea = ht_ea(h);
EA_EACH(ea, ht_size(h), entry) {
IB_CYCLE_BY_KEY(mrb, h, entry->key, it) {
if (ib_it_get(it) != U32(entry - ea)) continue;
*keyp = entry->key;
*valp = entry->val;
ib_it_delete(it);
entry_delete(entry);
ht_dec_size(h);
return;
}
}
}
static void
ht_rehash(mrb_state *mrb, struct RHash *h)
{
/* see comments in `h_rehash` */
uint32_t size = ht_size(h);
if (size <= AR_MAX_SIZE) {
ht_to_ar(mrb, h);
ar_rehash(mrb, h);
return;
}
uint32_t w_size = 0, ea_capa = ht_ea_capa(h);
hash_entry *ea = ht_ea(h);
ht_init(mrb, h, 0, ea, ea_capa, h_ht(h), ib_bit_for(size));
ht_set_size(h, size);
ht_set_ea_n_used(h, ht_ea_n_used(h));
EA_EACH(ea, size, r_entry) {
IB_CYCLE_BY_KEY(mrb, h, r_entry->key, it) {
if (ib_it_active_p(it)) {
if (!obj_eql(mrb, r_entry->key, ib_it_entry(it)->key, h)) continue;
ib_it_entry(it)->val = r_entry->val;
ht_set_size(h, --size);
entry_delete(r_entry);
}
else {
if (w_size != U32(r_entry - ea)) {
ea_set(ea, w_size, r_entry->key, r_entry->val);
entry_delete(r_entry);
}
ib_it_set(it, w_size++);
}
break;
}
}
mrb_assert(size == w_size);
ht_set_ea_n_used(h, size);
size <= AR_MAX_SIZE ? ht_to_ar(mrb, h) : ht_adjust_ea(mrb, h, size, ea_capa);
}
static mrb_value
h_key_for(mrb_state *mrb, mrb_value key)
{
if (mrb_string_p(key) && !mrb_frozen_p(mrb_str_ptr(key))) {
key = mrb_str_dup(mrb, key);
mrb_str_ptr(key)->frozen = 1;
}
return key;
}
static struct RHash*
h_alloc(mrb_state *mrb)
{
return MRB_OBJ_ALLOC(mrb, MRB_TT_HASH, mrb->hash_class);
}
static void
h_init(struct RHash *h)
{
ar_init(h, 0, NULL, 0, 0);
}
static void
h_free_table(mrb_state *mrb, struct RHash *h)
{
(h_ar_p(h) ? ar_free : ht_free)(mrb, h);
}
static void
h_clear(mrb_state *mrb, struct RHash *h)
{
h_free_table(mrb, h);
h_init(h);
}
static mrb_bool
h_get(mrb_state *mrb, struct RHash *h, mrb_value key, mrb_value *valp)
{
return (h_ar_p(h) ? ar_get : ht_get)(mrb, h, key, valp);
}
static void
h_set(mrb_state *mrb, struct RHash *h, mrb_value key, mrb_value val)
{
(h_ar_p(h) ? ar_set : ht_set)(mrb, h, key, val);
}
static mrb_bool
h_delete(mrb_state *mrb, struct RHash *h, mrb_value key, mrb_value *valp)
{
return (h_ar_p(h) ? ar_delete : ht_delete)(mrb, h, key, valp);
}
/* find first element in the table, and remove it. */
static void
h_shift(mrb_state *mrb, struct RHash *h, mrb_value *keyp, mrb_value *valp)
{
(h_ar_p(h) ? ar_shift : ht_shift)(mrb, h, keyp, valp);
}
static void
h_rehash(mrb_state *mrb, struct RHash *h)
{
/*
* ==== Comments common to `ar_rehash` and `ht_rehash`
*
* - Because reindex (such as elimination of duplicate keys) must be
* guaranteed, it is necessary to set one by one.
*
* - To prevent EA from breaking if an exception occurs in the middle,
* delete the slot before moving when moving the entry, and update size
* at any time when overwriting.
*/
(h_size(h) == 0 ? h_clear : h_ar_p(h) ? ar_rehash : ht_rehash)(mrb, h);
}
static void
h_replace(mrb_state *mrb, struct RHash *h, struct RHash *orig_h)
{
uint32_t size = h_size(orig_h);
if (size == 0) {
h_clear(mrb, h);
}
else if (h_ar_p(orig_h)) {
uint32_t ea_capa = ar_ea_capa(orig_h);
hash_entry *ea = ea_dup(mrb, ar_ea(orig_h), ea_capa);
h_free_table(mrb, h);
ar_init(h, size, ea, ea_capa, ar_ea_n_used(orig_h));
}
else { /* HT */
uint32_t ea_capa = ht_ea_capa(orig_h);
hash_entry *ea = ea_dup(mrb, ht_ea(orig_h), ea_capa);
hash_table *ht = ht_dup(mrb, orig_h);
h_free_table(mrb, h);
h_ht_on(h);
h_set_ht(h, ht);
ht_set_size(h, size);
ht_set_ea(h, ea);
#ifdef MRB_64BIT
ht_set_ea_capa(h, ea_capa);
ht_set_ea_n_used(h, ht_ea_n_used(orig_h));
#endif
ib_set_bit(h, ib_bit(orig_h));
}
}
size_t
mrb_gc_mark_hash(mrb_state *mrb, struct RHash *h)
{
H_EACH(h, entry) {
mrb_gc_mark_value(mrb, entry->key);
mrb_gc_mark_value(mrb, entry->val);
}
return h_size(h) * 2;
}
void
mrb_gc_free_hash(mrb_state *mrb, struct RHash *h)
{
h_free_table(mrb, h);
}
size_t
mrb_hash_memsize(mrb_value self)
{
struct RHash *h = mrb_hash_ptr(self);
return mrb_obj_iv_tbl_memsize(self) +
(h_ar_p(h) ? (ar_ea_capa(h) * sizeof(hash_entry)) :
(ht_ea_capa(h) * sizeof(hash_entry) +
sizeof(hash_table) +
ib_byte_size_for(ib_bit(h))));
}
/**
* Iterates over each key-value pair in the given hash.
*
* This function calls the provided callback function `func` for each entry
* in the hash `h`. The iteration order is the insertion order.
*
* The callback function `func` has the signature:
* `int callback(mrb_state *mrb, mrb_value key, mrb_value value, void *data)`
* - `mrb`: The mruby state.
* - `key`: The key of the current hash entry.
* - `value`: The value of the current hash entry.
* - `data`: The user-supplied data pointer passed to `mrb_hash_foreach`.
*
* If the callback function returns a non-zero value, the iteration stops.
*
* Important: Modifying the hash `h` within the callback function can lead
* to undefined behavior if not handled carefully (e.g., using `H_CHECK_MODIFIED`
* as done internally for Ruby methods, though direct C API users must be cautious).
* The `H_CHECK_MODIFIED` macro within this function is for internal safety
* when this function is used to implement Ruby methods that might call
* arbitrary Ruby code during iteration.
*
* @param mrb The mruby state.
* @param h A pointer to the RHash structure to iterate over.
* @param func The callback function to be called for each key-value pair.
* @param data A void pointer that will be passed to the callback function.
*/
MRB_API void
mrb_hash_foreach(mrb_state *mrb, struct RHash *h, mrb_hash_foreach_func *func, void *data)
{
H_EACH(h, entry) {
int n;
H_CHECK_MODIFIED(mrb, h) {
n = func(mrb, entry->key, entry->val, data);
}
if (n != 0) return;
}
}
mrb_value
mrb_hash_first_key(mrb_state *mrb, mrb_value h)
{
H_EACH(mrb_hash_ptr(h), entry) {
return entry->key;
}
return mrb_nil_value();
}
/**
* Creates a new, empty hash.
*
* This function allocates and initializes a new hash object.
* The returned hash is empty and ready to have elements added to it.
*
* @param mrb The mruby state.
* @return An mrb_value representing the new empty hash.
*/
MRB_API mrb_value
mrb_hash_new(mrb_state *mrb)
{
struct RHash *h = h_alloc(mrb);
return mrb_obj_value(h);
}
/**
* Creates a new, empty hash with a specified initial capacity.
*
* This function allocates and initializes a new hash object, pre-allocating
* internal structures to hold at least `capa` elements. This can be an
* optimization if the number of elements to be stored is known in advance,
* as it can prevent reallocations.
*
* If `capa` is 0, it behaves like `mrb_hash_new()`.
* An error will be raised if `capa` is negative or excessively large.
*
* @param mrb The mruby state.
* @param capa The initial capacity (number of elements) the hash should be
* able to hold without needing to resize.
* @return An mrb_value representing the new empty hash with preallocated capacity.
*/
MRB_API mrb_value
mrb_hash_new_capa(mrb_state *mrb, mrb_int capa)
{
if (capa < 0 || EA_MAX_CAPA < capa) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "hash too big");
return mrb_nil_value(); /* not reached */
}
else if (capa == 0) {
return mrb_hash_new(mrb);
}
else {
uint32_t size = U32(capa);
struct RHash *h = h_alloc(mrb);
hash_entry *ea = ea_resize(mrb, NULL, size);
if (size <= AR_MAX_SIZE) {
ar_init(h, 0, ea, size, 0);
}
else {
ht_init(mrb, h, 0, ea, size, NULL, ib_bit_for(size));
}
return mrb_obj_value(h);
}
}
static mrb_value mrb_hash_default(mrb_state *mrb, mrb_value hash);
static void
hash_modify(mrb_state *mrb, mrb_value hash)
{
mrb_check_frozen(mrb, mrb_hash_ptr(hash));
}
static mrb_value
hash_default(mrb_state *mrb, mrb_value hash, mrb_value key)
{
if (MRB_RHASH_DEFAULT_P(hash)) {
if (MRB_RHASH_PROCDEFAULT_P(hash)) {
return mrb_funcall_id(mrb, RHASH_PROCDEFAULT(hash), MRB_SYM(call), 2, hash, key);
}
else {
return RHASH_IFNONE(hash);
}
}
return mrb_nil_value();
}
static void
hash_replace(mrb_state *mrb, mrb_value self, mrb_value orig)
{
struct RHash *h = mrb_hash_ptr(self), *orig_h = mrb_hash_ptr(orig);
uint32_t mask = MRB_HASH_DEFAULT | MRB_HASH_PROC_DEFAULT;
mrb_sym name;
h_replace(mrb, h, orig_h);
name = MRB_SYM(ifnone);
if (orig_h->flags & MRB_HASH_DEFAULT) {
mrb_iv_set(mrb, self, name, mrb_iv_get(mrb, orig, name));
}
else {
mrb_iv_remove(mrb, self, name);
}
h->flags &= ~mask;
h->flags |= orig_h->flags & mask;
}
static mrb_value
mrb_hash_init_copy(mrb_state *mrb, mrb_value self)
{
mrb_value orig;
mrb_get_args(mrb, "H", &orig);
hash_modify(mrb, self);
if (mrb_hash_ptr(self) != mrb_hash_ptr(orig)) hash_replace(mrb, self, orig);
return self;
}
/**
* Creates a new hash that is a duplicate of the given hash.
*
* This function creates a shallow copy of the original hash `self`.
* The keys and values themselves are not duplicated, but the internal
* structure of the hash (entry array, hash table, default values/procs)
* is copied.
*
* @param mrb The mruby state.
* @param self The hash object (mrb_value) to duplicate.
* @return An mrb_value representing the new duplicated hash.
*/
MRB_API mrb_value
mrb_hash_dup(mrb_state *mrb, mrb_value self)
{
struct RHash* copy_h = h_alloc(mrb);
mrb_value copy = mrb_obj_value(copy_h);
copy_h->c = mrb_hash_ptr(self)->c;
hash_replace(mrb, copy, self);
return copy;
}
/**
* Retrieves the value associated with a given key from the hash.
*
* If the key is found in the hash, its corresponding value is returned.
* If the key is not found, this function considers the hash's default settings:
* - If a default proc is set for the hash, it is called with the hash and key,
* and its result is returned.
* - If a default value is set, that value is returned.
* - Otherwise (no key found and no default settings), nil is returned.
* This function may also invoke a user-defined `default` method on the hash
* if it has been overridden and no basic default proc/value handles the lookup.
*
* @param mrb The mruby state.
* @param hash The hash object (mrb_value) to search.
* @param key The key (mrb_value) to look up.
* @return The associated mrb_value, or the result of the default proc,
* or the default value, or nil if not found and no defaults apply.
*/
MRB_API mrb_value
mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
{
mrb_value val;
mrb_sym mid;
if (h_get(mrb, mrb_hash_ptr(hash), key, &val)) {
return val;
}
mid = MRB_SYM(default);
if (mrb_func_basic_p(mrb, hash, mid, mrb_hash_default)) {
return hash_default(mrb, hash, key);
}
/* xxx mrb_funcall_tailcall(mrb, hash, "default", 1, key); */
return mrb_funcall_argv(mrb, hash, mid, 1, &key);
}
/**
* Retrieves the value associated with a given key from the hash,
* returning a C-provided default value if the key is not found.
*
* If the `key` is found in the `hash`, its corresponding value is returned.
* If the `key` is not found, the `def` mrb_value provided to this function
* is returned. This function does *not* use the hash's own default proc
* or default value.
*
* @param mrb The mruby state.
* @param hash The hash object (mrb_value) to search.
* @param key The key (mrb_value) to look up.
* @param def The default mrb_value to return if the key is not found.
* @return The associated mrb_value if the key is found, otherwise `def`.
*/
MRB_API mrb_value
mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def)
{
mrb_value val;
if (h_get(mrb, mrb_hash_ptr(hash), key, &val)) {
return val;
}
/* not found */
return def;
}
/**
* Sets or updates a key-value pair in the hash.
*
* Associates `val` with `key` in the `hash`. If `key` already exists,
* its value is updated. If `key` does not exist, a new entry is created.
* The hash is modified in place.
*
* If the `key` is a `MRB_TT_STRING` and not frozen, it will be duplicated
* and the duplicate will be frozen before use.
* Write barriers are triggered for garbage collection purposes for the key and value.
*
* @param mrb The mruby state.
* @param hash The hash object (mrb_value) to modify.
* @param key The key (mrb_value) for the entry.
* @param val The value (mrb_value) to associate with the key.
*/
MRB_API void
mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val)
{
hash_modify(mrb, hash);
key = h_key_for(mrb, key);
h_set(mrb, mrb_hash_ptr(hash), key, val);
mrb_field_write_barrier_value(mrb, mrb_basic_ptr(hash), key);
mrb_field_write_barrier_value(mrb, mrb_basic_ptr(hash), val);
}
static void
hash_set_default_proc(mrb_state *mrb, mrb_value hash, mrb_value proc)
{
struct RProc *p = mrb_proc_ptr(proc);
if (MRB_PROC_STRICT_P(p)) {
mrb_int n = mrb_proc_arity(p);
if (n != 2 && (n >= 0 || n < -3)) {
if (n < 0) n = -n-1;
mrb_raisef(mrb, E_TYPE_ERROR, "default_proc takes two arguments (2 for %d)", n);
}
}
mrb_iv_set(mrb, hash, MRB_SYM(ifnone), proc);
RHASH(hash)->flags |= MRB_HASH_PROC_DEFAULT;
RHASH(hash)->flags |= MRB_HASH_DEFAULT;
}
/* 15.2.13.4.16 */
/*
* call-seq:
* Hash.new -> new_hash
* Hash.new(obj) -> new_hash
* Hash.new {|hash, key| block } -> new_hash
*
* Returns a new, empty hash. If this hash is subsequently accessed by
* a key that doesn't correspond to a hash entry, the value returned
* depends on the style of `new` used to create the hash. In
* the first form, the access returns `nil`. If
* `obj` is specified, this single object will be used for
* all default values. If a block is specified, it will be
* called with the hash object and the key, and should return the
* default value. It is the block's responsibility to store the value
* in the hash if required.
*
* h = Hash.new("Go Fish")
* h["a"] = 100
* h["b"] = 200
* h["a"] #=> 100
* h["c"] #=> "Go Fish"
* # The following alters the single default object
* h["c"].upcase! #=> "GO FISH"
* h["d"] #=> "GO FISH"
* h.keys #=> ["a", "b"]
*
* # While this creates a new default object each time
* h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
* h["c"] #=> "Go Fish: c"
* h["c"].upcase! #=> "GO FISH: C"
* h["d"] #=> "Go Fish: d"
* h.keys #=> ["c", "d"]
*
*/
static mrb_value
mrb_hash_init(mrb_state *mrb, mrb_value hash)
{
mrb_value block, ifnone;
mrb_bool ifnone_p;
ifnone = mrb_nil_value();
mrb_get_args(mrb, "&|o?", &block, &ifnone, &ifnone_p);
hash_modify(mrb, hash);
if (!mrb_nil_p(block)) {
if (ifnone_p) {
mrb_argnum_error(mrb, 1, 0, 0);
}
hash_set_default_proc(mrb, hash, block);
return hash;
}
if (ifnone_p && !mrb_nil_p(ifnone)) {
RHASH(hash)->flags |= MRB_HASH_DEFAULT;
mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone);
}
return hash;
}
/* 15.2.13.4.2 */
/*
* call-seq:
* hsh[key] -> value
*
* Element Reference---Retrieves the `value` object corresponding
* to the `key` object. If not found, returns the default value (see
* `Hash::new` for details).
*
* h = { "a" => 100, "b" => 200 }
* h["a"] #=> 100
* h["c"] #=> nil
*
*/
static mrb_value
mrb_hash_aget(mrb_state *mrb, mrb_value self)
{
mrb_value key = mrb_get_arg1(mrb);
return mrb_hash_get(mrb, self, key);
}
/* 15.2.13.4.5 */
/*
* call-seq:
* hsh.default(key=nil) -> obj
*
* Returns the default value, the value that would be returned by
* `hsh`[`key`] if `key` did not exist in `hsh`.
* See also `Hash::new` and `Hash#default=`.
*
* h = Hash.new #=> {}
* h.default #=> nil
* h.default(2) #=> nil
*
* h = Hash.new("cat") #=> {}
* h.default #=> "cat"
* h.default(2) #=> "cat"
*
* h = Hash.new {|h,k| h[k] = k.to_i*10} #=> {}
* h.default #=> nil
* h.default(2) #=> 20
*/
static mrb_value
mrb_hash_default(mrb_state *mrb, mrb_value hash)
{
mrb_value key;
mrb_bool given;
mrb_get_args(mrb, "|o?", &key, &given);
if (MRB_RHASH_DEFAULT_P(hash)) {
if (MRB_RHASH_PROCDEFAULT_P(hash)) {
if (!given) return mrb_nil_value();
return mrb_funcall_id(mrb, RHASH_PROCDEFAULT(hash), MRB_SYM(call), 2, hash, key);
}
else {
return RHASH_IFNONE(hash);
}
}
return mrb_nil_value();
}
/* 15.2.13.4.6 */
/*
* call-seq:
* hsh.default = obj -> obj
*
* Sets the default value, the value returned for a key that does not
* exist in the hash. It is not possible to set the default to a
* `Proc` that will be executed on each key lookup.
*
* h = { "a" => 100, "b" => 200 }
* h.default = "Go fish"
* h["a"] #=> 100
* h["z"] #=> "Go fish"
* # This doesn't do what you might hope...
* h.default = proc do |hash, key|
* hash[key] = key + key
* end
* h[2] #=> #<Proc:0x401b3948@-:6>
* h["cat"] #=> #<Proc:0x401b3948@-:6>
*/
static mrb_value
mrb_hash_set_default(mrb_state *mrb, mrb_value hash)
{
mrb_value ifnone = mrb_get_arg1(mrb);
hash_modify(mrb, hash);
mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone);
RHASH(hash)->flags &= ~MRB_HASH_PROC_DEFAULT;
if (!mrb_nil_p(ifnone)) {
RHASH(hash)->flags |= MRB_HASH_DEFAULT;
}
else {
RHASH(hash)->flags &= ~MRB_HASH_DEFAULT;
}
return ifnone;
}
/* 15.2.13.4.7 */
/*
* call-seq:
* hsh.default_proc -> anObject
*
* If `Hash::new` was invoked with a block, return that
* block, otherwise return `nil`.
*
* h = Hash.new {|h,k| h[k] = k*k } #=> {}
* p = h.default_proc #=> #<Proc:0x401b3d08@-:1>
* a = [] #=> []
* p.call(a, 2)
* a #=> [nil, nil, 4]
*/
static mrb_value
mrb_hash_default_proc(mrb_state *mrb, mrb_value hash)
{
if (MRB_RHASH_PROCDEFAULT_P(hash)) {
return RHASH_PROCDEFAULT(hash);
}
return mrb_nil_value();
}
/*
* call-seq:
* hsh.default_proc = proc_obj -> proc_obj
*
* Sets the default proc to be executed on each key lookup.
*
* h.default_proc = proc do |hash, key|
* hash[key] = key + key
* end
* h[2] #=> 4
* h["cat"] #=> "catcat"
*/
static mrb_value
mrb_hash_set_default_proc(mrb_state *mrb, mrb_value hash)
{
mrb_value ifnone = mrb_get_arg1(mrb);
hash_modify(mrb, hash);
mrb_bool has_ifnone = !mrb_nil_p(ifnone);
if (has_ifnone) {
mrb_check_type(mrb, ifnone, MRB_TT_PROC);
}
mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone);
if (has_ifnone) {
hash_set_default_proc(mrb, hash, ifnone);
}
else {
RHASH(hash)->flags &= ~MRB_HASH_DEFAULT;
RHASH(hash)->flags &= ~MRB_HASH_PROC_DEFAULT;
}
return ifnone;
}
/**
* Deletes a key-value pair from the hash.
*
* Removes the entry associated with `key` from the `hash`.
* The hash is modified in place.
*
* @param mrb The mruby state.
* @param hash The hash object (mrb_value) to modify.
* @param key The key (mrb_value) of the entry to delete.
* @return The value associated with the deleted key if found, otherwise nil.
*/
MRB_API mrb_value
mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key)
{
mrb_value del_val;
hash_modify(mrb, hash);
if (h_delete(mrb, mrb_hash_ptr(hash), key, &del_val)) {
return del_val;
}
/* not found */
return mrb_nil_value();
}
static mrb_value
mrb_hash_delete(mrb_state *mrb, mrb_value self)
{
mrb_value key = mrb_get_arg1(mrb);
mrb->c->ci->mid = 0;
return mrb_hash_delete_key(mrb, self, key);
}
/* 15.2.13.4.24 */
/*
* call-seq:
* hsh.shift -> anArray or obj
*
* Removes a key-value pair from `hsh` and returns it as the
* two-item array [ `key`, `value` ], or
* the hash's default value if the hash is empty.
*
* h = { 1 => "a", 2 => "b", 3 => "c" }
* h.shift #=> [1, "a"]
* h #=> {2=>"b", 3=>"c"}
*/
static mrb_value
mrb_hash_shift(mrb_state *mrb, mrb_value hash)
{
struct RHash *h = mrb_hash_ptr(hash);
hash_modify(mrb, hash);
if (h_size(h) == 0) {
return mrb_nil_value();
}
else {
mrb_value del_key, del_val;
h_shift(mrb, h, &del_key, &del_val);
mrb_gc_protect(mrb, del_key);
mrb_gc_protect(mrb, del_val);
return mrb_assoc_new(mrb, del_key, del_val);
}
}
/* 15.2.13.4.4 */
/*
* call-seq:
* hsh.clear -> hsh
*
* Removes all key-value pairs from `hsh`.
*
* h = { "a" => 100, "b" => 200 } #=> {"a"=>100, "b"=>200}
* h.clear #=> {}
*
*/
MRB_API mrb_value
mrb_hash_clear(mrb_state *mrb, mrb_value hash)
{
hash_modify(mrb, hash);
h_clear(mrb, mrb_hash_ptr(hash));
return hash;
}
/* 15.2.13.4.3 */
/* 15.2.13.4.26 */
/*
* call-seq:
* hsh[key] = value -> value
* hsh.store(key, value) -> value
*
* Element Assignment---Associates the value given by
* `value` with the key given by `key`.
* `key` should not have its value changed while it is in
* use as a key (a `String` passed as a key will be
* duplicated and frozen).
*
* h = { "a" => 100, "b" => 200 }
* h["a"] = 9
* h["c"] = 4
* h #=> {"a"=>9, "b"=>200, "c"=>4}
*
*/
static mrb_value
mrb_hash_aset(mrb_state *mrb, mrb_value self)
{
mrb_int argc = mrb_get_argc(mrb);
if (argc != 2) {
mrb_argnum_error(mrb, argc, 2, 2);
}
const mrb_value *argv = mrb_get_argv(mrb);
mrb_value key = argv[0];
mrb_value val = argv[1];
mrb_hash_set(mrb, self, key, val);
return val;
}
/**
* Returns the number of key-value pairs in the hash.
*
* @param mrb The mruby state (unused in the current implementation, but part of MRB_API convention).
* @param hash The hash object (mrb_value) to get the size of.
* @return An mrb_int representing the number of entries in the hash.
*/
MRB_API mrb_int
mrb_hash_size(mrb_state *mrb, mrb_value hash)
{
return (mrb_int)h_size(mrb_hash_ptr(hash));
}
/* 15.2.13.4.20 */
/* 15.2.13.4.25 */
/*
* call-seq:
* hsh.length -> integer
* hsh.size -> integer
*
* Returns the number of key-value pairs in the hash.
*
* h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
* h.length #=> 4
* h.delete("a") #=> 200
* h.length #=> 3
*/
static mrb_value
mrb_hash_size_m(mrb_state *mrb, mrb_value self)
{
mrb_int size = mrb_hash_size(mrb, self);
return mrb_int_value(mrb, size);
}
MRB_API mrb_bool
mrb_hash_empty_p(mrb_state *mrb, mrb_value self)
{
return h_size(mrb_hash_ptr(self)) == 0;
}
/* 15.2.13.4.12 */
/*
* call-seq:
* hsh.empty? -> true or false
*
* Returns `true` if `hsh` contains no key-value pairs.
*
* {}.empty? #=> true
*
*/
static mrb_value
mrb_hash_empty_m(mrb_state *mrb, mrb_value self)
{
return mrb_bool_value(mrb_hash_empty_p(mrb, self));
}
/* 15.2.13.4.19 */
/*
* call-seq:
* hsh.keys -> array
*
* Returns a new array populated with the keys from this hash. See also
* `Hash#values`.
*
* h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
* h.keys #=> ["a", "b", "c", "d"]
*
*/
MRB_API mrb_value
mrb_hash_keys(mrb_state *mrb, mrb_value hash)
{
struct RHash *h = mrb_hash_ptr(hash);
mrb_value ary = mrb_ary_new_capa(mrb, (mrb_int)h_size(h));
H_EACH(h, entry) {
mrb_ary_push(mrb, ary, entry->key);
}
return ary;
}
/* 15.2.13.4.28 */
/*
* call-seq:
* hsh.values -> array
*
* Returns a new array populated with the values from `hsh`. See
* also `Hash#keys`.
*
* h = { "a" => 100, "b" => 200, "c" => 300 }
* h.values #=> [100, 200, 300]
*
*/
MRB_API mrb_value
mrb_hash_values(mrb_state *mrb, mrb_value hash)
{
struct RHash *h = mrb_hash_ptr(hash);
mrb_value ary = mrb_ary_new_capa(mrb, (mrb_int)h_size(h));
H_EACH(h, entry) {
mrb_ary_push(mrb, ary, entry->val);
}
return ary;
}
/* 15.2.13.4.13 */
/* 15.2.13.4.15 */
/* 15.2.13.4.18 */
/* 15.2.13.4.21 */
/*
* call-seq:
* hsh.has_key?(key) -> true or false
* hsh.include?(key) -> true or false
* hsh.key?(key) -> true or false
* hsh.member?(key) -> true or false
*
* Returns `true` if the given key is present in `hsh`.
*
* h = { "a" => 100, "b" => 200 }
* h.has_key?("a") #=> true
* h.has_key?("z") #=> false
*
*/
MRB_API mrb_bool
mrb_hash_key_p(mrb_state *mrb, mrb_value hash, mrb_value key)
{
mrb_value val;
return h_get(mrb, mrb_hash_ptr(hash), key, &val);
}
static mrb_value
mrb_hash_has_key(mrb_state *mrb, mrb_value hash)
{
mrb_value key = mrb_get_arg1(mrb);
mrb_bool key_p;
key_p = mrb_hash_key_p(mrb, hash, key);
return mrb_bool_value(key_p);
}
/* 15.2.13.4.14 */
/* 15.2.13.4.27 */
/*
* call-seq:
* hsh.has_value?(value) -> true or false
* hsh.value?(value) -> true or false
*
* Returns `true` if the given value is present for some key
* in `hsh`.
*
* h = { "a" => 100, "b" => 200 }
* h.has_value?(100) #=> true
* h.has_value?(999) #=> false
*/
static mrb_value
mrb_hash_has_value(mrb_state *mrb, mrb_value hash)
{
mrb_value val = mrb_get_arg1(mrb);
struct RHash *h = mrb_hash_ptr(hash);
H_EACH(h, entry) {
H_CHECK_MODIFIED(mrb, h) {
if (mrb_equal(mrb, val, entry->val)) return mrb_true_value();
}
}
return mrb_false_value();
}
/**
* Merges the contents of `hash2` into `hash1`.
*
* Iterates over `hash2` and for each key-value pair, sets it in `hash1`.
* If a key from `hash2` already exists in `hash1`, its value in `hash1`
* will be overwritten. `hash1` is modified in place.
*
* - `hash1` must not be frozen.
* - `hash2` must be a hash.
* - If `hash1` and `hash2` are the same object, or if `hash2` is empty,
* the function returns without doing anything.
* - Write barriers are triggered for keys and values from `hash2` as they
* are inserted into `hash1`.
*
* @param mrb The mruby state.
* @param hash1 The hash object (mrb_value) to be modified.
* @param hash2 The hash object (mrb_value) whose contents will be merged into `hash1`.
*/
MRB_API void
mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2)
{
struct RHash *h1, *h2;
hash_modify(mrb, hash1);
mrb_ensure_hash_type(mrb, hash2);
h1 = mrb_hash_ptr(hash1);
h2 = mrb_hash_ptr(hash2);
if (h1 == h2) return;
if (h_size(h2) == 0) return;
H_EACH(h2, entry) {
H_CHECK_MODIFIED(mrb, h2) {h_set(mrb, h1, entry->key, entry->val);}
mrb_field_write_barrier_value(mrb, (struct RBasic*)h1, entry->key);
mrb_field_write_barrier_value(mrb, (struct RBasic*)h1, entry->val);
}
}
static mrb_value
mrb_hash_merge_m(mrb_state *mrb, mrb_value hash)
{
mrb_int argc;
mrb_value *argv;
mrb_get_args(mrb, "*", &argv, &argc);
while (argc--) {
mrb_hash_merge(mrb, hash, *argv++);
}
return hash;
}
/*
* call-seq:
* hsh.rehash -> hsh
*
* Rebuilds the hash based on the current hash values for each key. If
* values of key objects have changed since they were inserted, this
* method will reindex `hsh`.
*
* keys = (1..17).map{|n| [n]}
* k = keys[0]
* h = {}
* keys.each{|key| h[key] = key[0]}
* h #=> { [1]=>1, [2]=>2, ... [16]=>16, [17]=>17}
* h[k] #=> 1
* k[0] = keys.size + 1
* h #=> {[18]=>1, [2]=>2, ... [16]=>16, [17]=>17}
* h[k] #=> nil
* h.rehash
* h[k] #=> 1
*/
static mrb_value
mrb_hash_rehash(mrb_state *mrb, mrb_value self)
{
hash_modify(mrb, self);
h_rehash(mrb, mrb_hash_ptr(self));
return self;
}
static mrb_value
mrb_hash_compact(mrb_state *mrb, mrb_value hash)
{
struct RHash *h = mrb_hash_ptr(hash);
mrb_bool ht_p = h_ht_p(h);
uint32_t size = ht_p ? ht_size(h) : ar_size(h);
uint32_t dec = 0;
hash_modify(mrb, hash);
H_EACH(h, entry) {
if (mrb_nil_p(entry->val)) {
entry_delete(entry);
dec++;
}
}
if (dec == 0) return mrb_nil_value();
size -= dec;
if (ht_p) {
ht_set_size(h, size);
}
else {
ar_set_size(h, size);
}
return hash;
}
/*
* Internal method for pattern matching key check + value extraction.
* Returns an array of values if all keys exist, false otherwise.
*
* {a: 1, b: 2}.__pat_values([:a, :b]) #=> [1, 2]
* {a: 1}.__pat_values([:a, :b]) #=> false
*/
static mrb_value
mrb_hash_pat_values(mrb_state *mrb, mrb_value hash)
{
mrb_value keys;
mrb_get_args(mrb, "A", &keys);
const mrb_value *ary = RARRAY_PTR(keys);
mrb_int klen = RARRAY_LEN(keys);
struct RHash *h = mrb_hash_ptr(hash);
mrb_value result = mrb_ary_new_capa(mrb, klen);
int ai = mrb_gc_arena_save(mrb);
for (mrb_int i = 0; i < klen; i++) {
mrb_value val;
if (!h_get(mrb, h, ary[i], &val)) {
return mrb_false_value();
}
mrb_ary_push(mrb, result, val);
mrb_gc_arena_restore(mrb, ai);
}
return result;
}
/*
* Internal method for pattern matching **rest.
* Returns a new hash excluding keys in the given array.
*
* {a: 1, b: 2, c: 3}.__except([:a, :c]) #=> {b: 2}
*/
static mrb_value
mrb_hash_except_keys(mrb_state *mrb, mrb_value hash)
{
mrb_value keys;
mrb_get_args(mrb, "A", &keys);
const mrb_value *ary = RARRAY_PTR(keys);
mrb_int klen = RARRAY_LEN(keys);
mrb_value result = mrb_hash_new(mrb);
struct RHash *h = mrb_hash_ptr(hash);
int ai = mrb_gc_arena_save(mrb);
H_EACH(h, entry) {
mrb_bool found = FALSE;
for (mrb_int i = 0; i < klen; i++) {
if (mrb_equal(mrb, entry->key, ary[i])) {
found = TRUE;
break;
}
}
if (!found) {
mrb_hash_set(mrb, result, entry->key, entry->val);
}
mrb_gc_arena_restore(mrb, ai);
}
return result;
}
/*
* call-seq:
* hash.to_s -> string
* hash.inspect -> string
*
* Return the contents of this hash as a string.
*/
static mrb_value
mrb_hash_to_s(mrb_state *mrb, mrb_value self)
{
mrb->c->ci->mid = MRB_SYM(inspect);
mrb_value ret = mrb_str_new_lit(mrb, "{");
int ai = mrb_gc_arena_save(mrb);
if (MRB_RECURSIVE_UNARY_P(mrb, MRB_SYM(inspect), self)) {
mrb_str_cat_lit(mrb, ret, "...}");
return ret;
}
mrb_int i = 0;
struct RHash *h = mrb_hash_ptr(self);
H_EACH(h, entry) {
if (i++ > 0) mrb_str_cat_lit(mrb, ret, ", ");
if (mrb_symbol_p(entry->key)) {
mrb_str_cat_str(mrb, ret, mrb_obj_as_string(mrb, entry->key));
mrb_gc_arena_restore(mrb, ai);
mrb_str_cat_lit(mrb, ret, ": ");
}
else {
H_CHECK_MODIFIED(mrb, h) {
mrb_str_cat_str(mrb, ret, mrb_inspect(mrb, entry->key));
}
mrb_gc_arena_restore(mrb, ai);
mrb_str_cat_lit(mrb, ret, " => ");
}
H_CHECK_MODIFIED(mrb, h) {
mrb_str_cat_str(mrb, ret, mrb_inspect(mrb, entry->val));
}
mrb_gc_arena_restore(mrb, ai);
}
mrb_str_cat_lit(mrb, ret, "}");
return ret;
}
/*
* call-seq:
* hash.to_hash -> self
*
* Returns self.
*/
static mrb_value
mrb_hash_to_hash(mrb_state *mrb, mrb_value self)
{
return self;
}
/*
* call-seq:
* hash.assoc(key) -> new_array or nil
*
* If the given key is found, returns a 2-element Array containing that key
* and its value:
*
* h = {foo: 0, bar: 1, baz: 2}
* h.assoc(:bar) # => [:bar, 1]
*
* Returns nil if key key is not found.
*/
static mrb_value
mrb_hash_assoc(mrb_state *mrb, mrb_value hash)
{
mrb_value key = mrb_get_arg1(mrb);
struct RHash *h = mrb_hash_ptr(hash);
H_EACH(h, entry) {
if (obj_eql(mrb, entry->key, key, h)) {
return mrb_assoc_new(mrb, entry->key, entry->val);
}
}
return mrb_nil_value();
}
/*
* call-seq:
* hash.rassoc(value) -> new_array or nil
*
* Returns a new 2-element Array consisting of the key and value of the
* first-found entry whose value is == to value.
*
* h = {foo: 0, bar: 1, baz: 1}
* h.rassoc(1) # => [:bar, 1]
*
* Returns nil if no such value found.
*/
static mrb_value
mrb_hash_rassoc(mrb_state *mrb, mrb_value hash)
{
mrb_value value = mrb_get_arg1(mrb);
struct RHash *h = mrb_hash_ptr(hash);
H_EACH(h, entry) {
if (obj_eql(mrb, entry->val, value, h)) {
return mrb_assoc_new(mrb, entry->key, entry->val);
}
}
return mrb_nil_value();
}
/* 15.2.13.4.1 */
static mrb_value
mrb_hash_equal(mrb_state *mrb, mrb_value hash)
{
mrb_value hash2 = mrb_get_arg1(mrb);
if (mrb_obj_equal(mrb, hash, hash2)) return mrb_true_value();
if (!mrb_hash_p(hash2)) {
return mrb_false_value();
}
if (mrb_hash_size(mrb, hash) != mrb_hash_size(mrb, hash2)) {
return mrb_false_value();
}
/* Check for recursion */
if (MRB_RECURSIVE_BINARY_FUNC_P(mrb, MRB_OPSYM(eq), hash, hash2)) {
return mrb_false_value();
}
struct RHash *h1 = mrb_hash_ptr(hash);
struct RHash *h2 = mrb_hash_ptr(hash2);
H_EACH(h1, entry) {
mrb_value val2;
mrb_bool found;
H_CHECK_MODIFIED(mrb, h1) {
found = h_get(mrb, h2, entry->key, &val2);
}
if (!found) {
return mrb_false_value();
}
H_CHECK_MODIFIED(mrb, h1) {
if (!mrb_equal(mrb, entry->val, val2)) {
return mrb_false_value();
}
}
}
return mrb_true_value();
}
/*
* call-seq:
* hash.eql?(other) -> true or false
*
* Returns true if hash and other are both hashes with the same content
* compared by eql?.
*/
static mrb_value
mrb_hash_eql(mrb_state *mrb, mrb_value hash)
{
mrb_value hash2 = mrb_get_arg1(mrb);
if (mrb_obj_equal(mrb, hash, hash2)) return mrb_true_value();
if (!mrb_hash_p(hash2)) {
return mrb_false_value();
}
if (mrb_hash_size(mrb, hash) != mrb_hash_size(mrb, hash2)) {
return mrb_false_value();
}
/* Check for recursion */
if (MRB_RECURSIVE_BINARY_FUNC_P(mrb, MRB_SYM_Q(eql), hash, hash2)) {
return mrb_false_value();
}
struct RHash *h1 = mrb_hash_ptr(hash);
struct RHash *h2 = mrb_hash_ptr(hash2);
H_EACH(h1, entry) {
mrb_value val2;
mrb_bool found;
H_CHECK_MODIFIED(mrb, h1) {
found = h_get(mrb, h2, entry->key, &val2);
}
if (!found) {
return mrb_false_value();
}
H_CHECK_MODIFIED(mrb, h1) {
if (!mrb_eql(mrb, entry->val, val2)) {
return mrb_false_value();
}
}
}
return mrb_true_value();
}
/* ---------------------------*/
static const mrb_mt_entry hash_rom_entries[] = {
MRB_MT_ENTRY(mrb_hash_equal, MRB_OPSYM(eq), MRB_ARGS_REQ(1)), /* 15.2.13.4.1 */
MRB_MT_ENTRY(mrb_hash_aget, MRB_OPSYM(aref), MRB_ARGS_REQ(1)), /* 15.2.13.4.2 */
MRB_MT_ENTRY(mrb_hash_aset, MRB_OPSYM(aset), MRB_ARGS_REQ(2)), /* 15.2.13.4.3 */
MRB_MT_ENTRY(mrb_hash_clear, MRB_SYM(clear), MRB_ARGS_NONE()), /* 15.2.13.4.4 */
MRB_MT_ENTRY(mrb_hash_default, MRB_SYM(default), MRB_ARGS_OPT(1)), /* 15.2.13.4.5 */
MRB_MT_ENTRY(mrb_hash_set_default, MRB_SYM_E(default), MRB_ARGS_REQ(1)), /* 15.2.13.4.6 */
MRB_MT_ENTRY(mrb_hash_default_proc, MRB_SYM(default_proc), MRB_ARGS_NONE()), /* 15.2.13.4.7 */
MRB_MT_ENTRY(mrb_hash_set_default_proc, MRB_SYM_E(default_proc), MRB_ARGS_REQ(1)), /* 15.2.13.4.7 */
MRB_MT_ENTRY(mrb_hash_delete, MRB_SYM(__delete), MRB_ARGS_REQ(1)), /* core of 15.2.13.4.8 */
MRB_MT_ENTRY(mrb_hash_eql, MRB_SYM_Q(eql), MRB_ARGS_REQ(1)), /* Hash#eql? */
MRB_MT_ENTRY(mrb_hash_empty_m, MRB_SYM_Q(empty), MRB_ARGS_NONE()), /* 15.2.13.4.12 */
MRB_MT_ENTRY(mrb_hash_has_key, MRB_SYM_Q(has_key), MRB_ARGS_REQ(1)), /* 15.2.13.4.13 */
MRB_MT_ENTRY(mrb_hash_has_value, MRB_SYM_Q(has_value), MRB_ARGS_REQ(1)), /* 15.2.13.4.14 */
MRB_MT_ENTRY(mrb_hash_has_key, MRB_SYM_Q(include), MRB_ARGS_REQ(1)), /* 15.2.13.4.15 */
MRB_MT_ENTRY(mrb_hash_init, MRB_SYM(initialize), MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK() | MRB_MT_PRIVATE), /* 15.2.13.4.16 */
MRB_MT_ENTRY(mrb_hash_init_copy, MRB_SYM(initialize_copy), MRB_ARGS_REQ(1) | MRB_MT_PRIVATE), /* 15.2.13.4.17 */
MRB_MT_ENTRY(mrb_hash_has_key, MRB_SYM_Q(key), MRB_ARGS_REQ(1)), /* 15.2.13.4.18 */
MRB_MT_ENTRY(mrb_hash_keys, MRB_SYM(keys), MRB_ARGS_NONE()), /* 15.2.13.4.19 */
MRB_MT_ENTRY(mrb_hash_size_m, MRB_SYM(length), MRB_ARGS_NONE()), /* 15.2.13.4.20 */
MRB_MT_ENTRY(mrb_hash_has_key, MRB_SYM_Q(member), MRB_ARGS_REQ(1)), /* 15.2.13.4.21 */
MRB_MT_ENTRY(mrb_hash_init_copy, MRB_SYM(replace), MRB_ARGS_REQ(1)), /* 15.2.13.4.23 */
MRB_MT_ENTRY(mrb_hash_shift, MRB_SYM(shift), MRB_ARGS_NONE()), /* 15.2.13.4.24 */
MRB_MT_ENTRY(mrb_hash_size_m, MRB_SYM(size), MRB_ARGS_NONE()), /* 15.2.13.4.25 */
MRB_MT_ENTRY(mrb_hash_aset, MRB_SYM(store), MRB_ARGS_REQ(2)), /* 15.2.13.4.26 */
MRB_MT_ENTRY(mrb_hash_has_value, MRB_SYM_Q(value), MRB_ARGS_REQ(1)), /* 15.2.13.4.27 */
MRB_MT_ENTRY(mrb_hash_values, MRB_SYM(values), MRB_ARGS_NONE()), /* 15.2.13.4.28 */
MRB_MT_ENTRY(mrb_hash_to_s, MRB_SYM(to_s), MRB_ARGS_NONE()),
MRB_MT_ENTRY(mrb_hash_to_s, MRB_SYM(inspect), MRB_ARGS_NONE()),
MRB_MT_ENTRY(mrb_hash_rehash, MRB_SYM(rehash), MRB_ARGS_NONE()),
MRB_MT_ENTRY(mrb_hash_to_hash, MRB_SYM(to_hash), MRB_ARGS_NONE()),
MRB_MT_ENTRY(mrb_hash_assoc, MRB_SYM(assoc), MRB_ARGS_REQ(1)),
MRB_MT_ENTRY(mrb_hash_rassoc, MRB_SYM(rassoc), MRB_ARGS_REQ(1)),
MRB_MT_ENTRY(mrb_hash_merge_m, MRB_SYM(__merge), MRB_ARGS_ANY()),
MRB_MT_ENTRY(mrb_hash_compact, MRB_SYM(__compact), MRB_ARGS_NONE()), /* implementation of Hash#compact! */
MRB_MT_ENTRY(mrb_hash_pat_values, MRB_SYM(__pat_values), MRB_ARGS_REQ(1)), /* for pattern matching keys */
MRB_MT_ENTRY(mrb_hash_except_keys, MRB_SYM(__except), MRB_ARGS_REQ(1)), /* for pattern matching **rest */
};
void
mrb_init_hash(mrb_state *mrb)
{
struct RClass *h;
mrb->hash_class = h = mrb_define_class_id(mrb, MRB_SYM(Hash), mrb->object_class); /* 15.2.13 */
MRB_SET_INSTANCE_TT(h, MRB_TT_HASH);
MRB_MT_INIT_ROM(mrb, h, hash_rom_entries);
}
#undef lesser
Reference in New Issue View Git Blame Copy Permalink