Backport #8328 ยป backport_fix_shift.diff
| hash.c | ||
|---|---|---|
|
};
|
||
|
static int
|
||
|
shift_i(VALUE key, VALUE value, VALUE arg)
|
||
|
{
|
||
|
struct shift_var *var = (struct shift_var *)arg;
|
||
|
if (key == Qundef) return ST_CONTINUE;
|
||
|
if (var->key != Qundef) return ST_STOP;
|
||
|
var->key = key;
|
||
|
var->val = value;
|
||
|
return ST_DELETE;
|
||
|
}
|
||
|
static int
|
||
|
shift_i_safe(VALUE key, VALUE value, VALUE arg)
|
||
|
{
|
||
|
struct shift_var *var = (struct shift_var *)arg;
|
||
| ... | ... | |
|
rb_hash_modify(hash);
|
||
|
var.key = Qundef;
|
||
|
rb_hash_foreach(hash, RHASH(hash)->iter_lev > 0 ? shift_i_safe : shift_i,
|
||
|
(VALUE)&var);
|
||
|
if (RHASH(hash)->iter_lev == 0) {
|
||
|
if (st_shift(RHASH(hash)->ntbl, &var.key, &var.val)) {
|
||
|
return rb_assoc_new(var.key, var.val);
|
||
|
}
|
||
|
}
|
||
|
else {
|
||
|
rb_hash_foreach(hash, shift_i_safe, (VALUE)&var);
|
||
|
if (var.key != Qundef) {
|
||
|
if (RHASH(hash)->iter_lev > 0) {
|
||
|
if (var.key != Qundef) {
|
||
|
rb_hash_delete_key(hash, var.key);
|
||
|
return rb_assoc_new(var.key, var.val);
|
||
|
}
|
||
|
return rb_assoc_new(var.key, var.val);
|
||
|
}
|
||
|
else if (FL_TEST(hash, HASH_PROC_DEFAULT)) {
|
||
|
if (FL_TEST(hash, HASH_PROC_DEFAULT)) {
|
||
|
return rb_funcall(RHASH_IFNONE(hash), id_yield, 2, hash, Qnil);
|
||
|
}
|
||
|
else {
|
||
| include/ruby/st.h | ||
|---|---|---|
|
st_table *st_init_strcasetable_with_size(st_index_t);
|
||
|
int st_delete(st_table *, st_data_t *, st_data_t *); /* returns 0:notfound 1:deleted */
|
||
|
int st_delete_safe(st_table *, st_data_t *, st_data_t *, st_data_t);
|
||
|
int st_shift(st_table *, st_data_t *, st_data_t *); /* returns 0:notfound 1:deleted */
|
||
|
int st_insert(st_table *, st_data_t, st_data_t);
|
||
|
int st_insert2(st_table *, st_data_t, st_data_t, st_data_t (*)(st_data_t));
|
||
|
int st_lookup(st_table *, st_data_t, st_data_t *);
|
||
| st.c | ||
|---|---|---|
|
return 0;
|
||
|
}
|
||
|
int
|
||
|
st_shift(register st_table *table, register st_data_t *key, st_data_t *value)
|
||
|
{
|
||
|
st_index_t hash_val;
|
||
|
st_table_entry **prev;
|
||
|
register st_table_entry *ptr;
|
||
|
if (table->num_entries == 0) {
|
||
|
if (value != 0) *value = 0;
|
||
|
return 0;
|
||
|
}
|
||
|
if (table->entries_packed) {
|
||
|
if (value != 0) *value = (st_data_t)table->bins[1];
|
||
|
*key = (st_data_t)table->bins[0];
|
||
|
table->num_entries--;
|
||
|
memmove(&table->bins[0], &table->bins[2],
|
||
|
sizeof(struct st_table_entry*) * 2*table->num_entries);
|
||
|
return 1;
|
||
|
}
|
||
|
hash_val = do_hash_bin(table->head->key, table);
|
||
|
prev = &table->bins[hash_val];
|
||
|
for (;(ptr = *prev) != 0; prev = &ptr->next) {
|
||
|
if (ptr == table->head) {
|
||
|
*prev = ptr->next;
|
||
|
REMOVE_ENTRY(table, ptr);
|
||
|
if (value != 0) *value = ptr->record;
|
||
|
*key = ptr->key;
|
||
|
free(ptr);
|
||
|
return 1;
|
||
|
}
|
||
|
}
|
||
|
/* if hash is not consistent and need to be rehashed */
|
||
|
if (value != 0) *value = 0;
|
||
|
return 0;
|
||
|
}
|
||
|
void
|
||
|
st_cleanup_safe(st_table *table, st_data_t never)
|
||
|
{
|
||