int
dict_find(const ref * pdref, const ref * pkey, ref ** ppvalue)
{
dict *pdict = pdref->value.pdict;
int code = real_dict_find(pdref, pkey, ppvalue);
stats_dict.lookups++;
if (r_has_type(pkey, t_name) && dict_is_packed(pdict)) {
uint nidx = name_index(dict_mem(pdict), pkey);
uint hash =
dict_hash_mod(dict_name_index_hash(nidx), npairs(pdict)) + 1;
if (pdict->keys.value.packed[hash] ==
pt_tag(pt_literal_name) + nidx
)
stats_dict.probe1++;
else if (pdict->keys.value.packed[hash - 1] ==
pt_tag(pt_literal_name) + nidx
)
stats_dict.probe2++;
}
/* Do the cheap flag test before the expensive remainder test. */
if (gs_debug_c('d') && !(stats_dict.lookups % 1000))
dlprintf3("[d]lookups=%ld probe1=%ld probe2=%ld\n",
stats_dict.lookups, stats_dict.probe1, stats_dict.probe2);
return code;
}
/*
* Ensure that a dictionary uses the unpacked representation for keys.
* We can't just use dict_resize, because the values slots mustn't move.
*/
int
dict_unpack(ref * pdref, dict_stack_t *pds)
{
dict *pdict = pdref->value.pdict;
if (!dict_is_packed(pdict))
return 0; /* nothing to do */
{
gs_ref_memory_t *mem = dict_memory(pdict);
uint count = nslots(pdict);
const ref_packed *okp = pdict->keys.value.packed;
ref old_keys;
int code;
ref *nkp;
old_keys = pdict->keys;
if (ref_must_save_in(mem, &old_keys))
ref_do_save_in(mem, pdref, &pdict->keys, "dict_unpack(keys)");
code = dict_create_unpacked_keys(count, pdref);
if (code < 0)
return code;
for (nkp = pdict->keys.value.refs; count--; okp++, nkp++)
if (r_packed_is_name(okp)) {
packed_get((const gs_memory_t *)mem, okp, nkp);
ref_mark_new_in(mem, nkp);
} else if (*okp == packed_key_deleted)
r_set_attrs(nkp, a_executable);
if (!ref_must_save_in(mem, &old_keys))
gs_free_ref_array(mem, &old_keys, "dict_unpack(old keys)");
if (pds)
dstack_set_top(pds); /* just in case */
}
return 0;
}
ref *
dstack_find_name_by_index(dict_stack_t * pds, uint nidx)
{
ref *pvalue = real_dstack_find_name_by_index(pds, nidx);
dict *pdict = pds->stack.p->value.pdict;
INCR(lookups);
if (dict_is_packed(pdict)) {
uint hash =
dict_hash_mod(dict_name_index_hash(nidx), npairs(pdict)) + 1;
if (pdict->keys.value.packed[hash] ==
pt_tag(pt_literal_name) + nidx
)
INCR(probes[0]);
else if (pdict->keys.value.packed[hash - 1] ==
pt_tag(pt_literal_name) + nidx
)
INCR(probes[1]);
}
if (gs_debug_c('d') && !(stats_dstack.lookups % 1000))
dlprintf3("[d]lookups=%ld probe1=%ld probe2=%ld\n",
stats_dstack.lookups, stats_dstack.probes[0],
stats_dstack.probes[1]);
return pvalue;
}
/* If the index designates an unoccupied entry, return gs_error_undefined. */
int
dict_index_entry(const ref * pdref, int index, ref * eltp /* ref eltp[2] */ )
{
const dict *pdict = pdref->value.pdict;
array_get(dict_mem(pdict), &pdict->keys, (long)(index + 1), eltp);
if (r_has_type(eltp, t_name) ||
(!dict_is_packed(pdict) && !r_has_type(eltp, t_null))
) {
eltp[1] = pdict->values.value.refs[index + 1];
return 0;
}
return gs_error_undefined;
}
/* Enumerate the next element of a dictionary. */
int
dict_next(const ref * pdref, int index, ref * eltp /* ref eltp[2] */ )
{
dict *pdict = pdref->value.pdict;
ref *vp = pdict->values.value.refs + index;
while (vp--, --index >= 0) {
array_get(dict_mem(pdict), &pdict->keys, (long)index, eltp);
/* Make sure this is a valid entry. */
if (r_has_type(eltp, t_name) ||
(!dict_is_packed(pdict) && !r_has_type(eltp, t_null))
) {
eltp[1] = *vp;
if_debug6m('d', dict_mem(pdict), "[d]0x%lx: index %d: %lx %lx, %lx %lx\n",
(ulong) pdict, index,
((ulong *) eltp)[0], ((ulong *) eltp)[1],
((ulong *) vp)[0], ((ulong *) vp)[1]);
return index;
}
}
return -1; /* no more elements */
}
/* Resize a dictionary. */
int
dict_resize(ref * pdref, uint new_size, dict_stack_t *pds)
{
dict *pdict = pdref->value.pdict;
gs_ref_memory_t *mem = dict_memory(pdict);
uint new_mask = imemory_new_mask(mem);
ushort orig_attrs = r_type_attrs(&pdict->values) & (a_all | a_executable);
dict dnew;
ref drto;
int code;
if (new_size < d_length(pdict)) {
if (!mem->gs_lib_ctx->dict_auto_expand)
return_error(gs_error_dictfull);
new_size = d_length(pdict);
}
make_tav(&drto, t_dictionary, r_space(pdref) | a_all | new_mask,
pdict, &dnew);
dnew.memory = pdict->memory;
if ((code = dict_create_contents(new_size, &drto, dict_is_packed(pdict))) < 0)
return code;
/*
* We must suppress the store check, in case we are expanding
* systemdict or another global dictionary that is allowed
* to reference local objects.
*/
r_set_space(&drto, avm_local);
/*
* If we are expanding a permanent dictionary, we must make sure that
* dict_put doesn't think this is a second definition for any
* single-definition names. This in turn requires that
* dstack_dict_is_permanent must be true for the second ("to")
* argument of dict_copy_elements, which requires temporarily
* setting *pdref = drto.
*/
if (CAN_SET_PVALUE_CACHE(pds, pdref, mem)) {
ref drfrom;
drfrom = *pdref;
*pdref = drto;
dict_copy_elements(&drfrom, pdref, COPY_FOR_RESIZE, pds);
*pdref = drfrom;
} else {
dict_copy_elements(pdref, &drto, 0, pds);
}
/* Save or free the old dictionary. */
if (ref_must_save_in(mem, &pdict->values))
ref_do_save_in(mem, pdref, &pdict->values, "dict_resize(values)");
else
gs_free_ref_array(mem, &pdict->values, "dict_resize(old values)");
if (ref_must_save_in(mem, &pdict->keys))
ref_do_save_in(mem, pdref, &pdict->keys, "dict_resize(keys)");
else
gs_free_ref_array(mem, &pdict->keys, "dict_resize(old keys)");
ref_assign(&pdict->keys, &dnew.keys);
ref_assign(&pdict->values, &dnew.values);
r_store_attrs(&pdict->values, a_all | a_executable, orig_attrs);
ref_save_in(dict_memory(pdict), pdref, &pdict->maxlength,
"dict_resize(maxlength)");
d_set_maxlength(pdict, new_size);
if (pds)
dstack_set_top(pds); /* just in case this is the top dict */
return 0;
}
/* Remove an element from a dictionary. */
int
dict_undef(ref * pdref, const ref * pkey, dict_stack_t *pds)
{
gs_ref_memory_t *mem;
ref *pvslot;
dict *pdict;
uint index;
int code = dict_find(pdref, pkey, &pvslot);
switch (code) {
case 0:
case gs_error_dictfull:
return_error(gs_error_undefined);
case 1:
break;
default: /* other error */
return code;
}
/* Remove the entry from the dictionary. */
pdict = pdref->value.pdict;
index = pvslot - pdict->values.value.refs;
mem = dict_memory(pdict);
if (dict_is_packed(pdict)) {
ref_packed *pkp = pdict->keys.value.writable_packed + index;
bool must_save = ref_must_save_in(mem, &pdict->keys);
if_debug3m('d', (const gs_memory_t *)mem,
"[d]0x%lx: removing key at 0%lx: 0x%x\n",
(ulong)pdict, (ulong)pkp, (uint)*pkp);
/* See the initial comment for why it is safe not to save */
/* the change if the keys array itself is new. */
if (must_save)
ref_do_save_in(mem, &pdict->keys, pkp, "dict_undef(key)");
/*
* Accumulating deleted entries slows down lookup.
* Detect the easy case where we can use an empty entry
* rather than a deleted one, namely, when the next entry
* in the probe order is empty.
*/
if (pkp[-1] == packed_key_empty) {
/*
* In this case we can replace any preceding deleted keys with
* empty ones as well.
*/
uint end = nslots(pdict);
*pkp = packed_key_empty;
if (must_save) {
while (++index < end && *++pkp == packed_key_deleted) {
ref_do_save_in(mem, &pdict->keys, pkp, "dict_undef(key)");
*pkp = packed_key_empty;
}
} else {
while (++index < end && *++pkp == packed_key_deleted)
*pkp = packed_key_empty;
}
} else
*pkp = packed_key_deleted;
} else { /* not packed */
ref *kp = pdict->keys.value.refs + index;
if_debug4m('d', (const gs_memory_t *)mem,
"[d]0x%lx: removing key at 0%lx: 0x%lx 0x%lx\n",
(ulong)pdict, (ulong)kp, ((ulong *)kp)[0], ((ulong *)kp)[1]);
make_null_old_in(mem, &pdict->keys, kp, "dict_undef(key)");
/*
* Accumulating deleted entries slows down lookup.
* Detect the easy case where we can use an empty entry
* rather than a deleted one, namely, when the next entry
* in the probe order is empty.
*/
if (!r_has_type(kp - 1, t_null) || /* full entry */
r_has_attr(kp - 1, a_executable) /* deleted or wraparound */
)
r_set_attrs(kp, a_executable); /* mark as deleted */
}
ref_save_in(mem, pdref, &pdict->count, "dict_undef(count)");
pdict->count.value.intval--;
/* If the key is a name, update its 1-element cache. */
if (r_has_type(pkey, t_name)) {
name *pname = pkey->value.pname;
if (pv_valid(pname->pvalue)) {
#ifdef DEBUG
/* Check the the cache is correct. */
if (!(pds && dstack_dict_is_permanent(pds, pdref)))
lprintf1("dict_undef: cached name value pointer 0x%lx is incorrect!\n",
(ulong) pname->pvalue);
#endif
/* Clear the cache */
pname->pvalue = pv_no_defn;
}
}
make_null_old_in(mem, &pdict->values, pvslot, "dict_undef(value)");
return 0;
}
/*
* Enter a key-value pair in a dictionary.
* See idict.h for the possible return values.
*/
int
dict_put(ref * pdref /* t_dictionary */ , const ref * pkey, const ref * pvalue,
dict_stack_t *pds)
{
dict *pdict = pdref->value.pdict;
gs_ref_memory_t *mem = dict_memory(pdict);
gs_memory_t *pmem = dict_mem(pdict);
int rcode = 0;
int code;
ref *pvslot, kname;
/* Check the value. */
store_check_dest(pdref, pvalue);
top:if ((code = dict_find(pdref, pkey, &pvslot)) <= 0) { /* not found *//* Check for overflow */
uint index;
switch (code) {
case 0:
break;
case gs_error_dictfull:
if (!pmem->gs_lib_ctx->dict_auto_expand)
return_error(gs_error_dictfull);
code = dict_grow(pdref, pds);
if (code < 0)
return code;
goto top; /* keep things simple */
default: /* gs_error_typecheck */
return code;
}
index = pvslot - pdict->values.value.refs;
/* If the key is a string, convert it to a name. */
if (r_has_type(pkey, t_string)) {
int code;
if (!r_has_attr(pkey, a_read))
return_error(gs_error_invalidaccess);
code = name_from_string(pmem, pkey, &kname);
if (code < 0)
return code;
pkey = &kname;
}
if (dict_is_packed(pdict)) {
ref_packed *kp;
if (!r_has_type(pkey, t_name) ||
name_index(pmem, pkey) > packed_name_max_index
) { /* Change to unpacked representation. */
int code = dict_unpack(pdref, pds);
if (code < 0)
return code;
goto top;
}
kp = pdict->keys.value.writable_packed + index;
if (ref_must_save_in(mem, &pdict->keys)) { /* See initial comment for why it is safe */
/* not to save the change if the keys */
/* array itself is new. */
ref_do_save_in(mem, &pdict->keys, kp, "dict_put(key)");
}
*kp = pt_tag(pt_literal_name) + name_index(pmem, pkey);
} else {
ref *kp = pdict->keys.value.refs + index;
if_debug2m('d', (const gs_memory_t *)mem, "[d]0x%lx: fill key at 0x%lx\n",
(ulong) pdict, (ulong) kp);
store_check_dest(pdref, pkey);
ref_assign_old_in(mem, &pdict->keys, kp, pkey,
"dict_put(key)"); /* set key of pair */
}
ref_save_in(mem, pdref, &pdict->count, "dict_put(count)");
pdict->count.value.intval++;
/* If the key is a name, update its 1-element cache. */
if (r_has_type(pkey, t_name)) {
name *pname = pkey->value.pname;
if (pname->pvalue == pv_no_defn &&
CAN_SET_PVALUE_CACHE(pds, pdref, mem)
) { /* Set the cache. */
if_debug0m('d', (const gs_memory_t *)mem, "[d]set cache\n");
pname->pvalue = pvslot;
} else { /* The cache can't be used. */
if_debug0m('d', (const gs_memory_t *)mem, "[d]no cache\n");
pname->pvalue = pv_other;
}
}
rcode = 1;
}
if_debug8m('d', (const gs_memory_t *)mem,
"[d]0x%lx: put key 0x%lx 0x%lx\n value at 0x%lx: old 0x%lx 0x%lx, new 0x%lx 0x%lx\n",
(ulong) pdref->value.pdict,
((const ulong *)pkey)[0], ((const ulong *)pkey)[1],
(ulong) pvslot,
((const ulong *)pvslot)[0], ((const ulong *)pvslot)[1],
((const ulong *)pvalue)[0], ((const ulong *)pvalue)[1]);
ref_assign_old_in(mem, &pdref->value.pdict->values, pvslot, pvalue,
"dict_put(value)");
return rcode;
}
/*
* Look up a key in a dictionary. Store a pointer to the value slot
* where found, or to the (value) slot for inserting.
* See idict.h for the possible return values.
*/
int
dict_find(const ref * pdref, const ref * pkey,
ref ** ppvalue /* result is stored here */ )
{
dict *pdict = pdref->value.pdict;
uint size = npairs(pdict);
register int etype;
uint nidx;
ref_packed kpack;
uint hash;
int ktype;
const gs_memory_t *mem = dict_mem(pdict);
/* Compute hash. The only types we bother with are strings, */
/* names, and (unlikely, but worth checking for) integers. */
switch (r_type(pkey)) {
case t_name:
nidx = name_index(mem, pkey);
nh:
hash = dict_name_index_hash(nidx);
kpack = packed_name_key(nidx);
ktype = t_name;
break;
case t_string: /* convert to a name first */
{
ref nref;
int code;
if (!r_has_attr(pkey, a_read))
return_error(gs_error_invalidaccess);
code = name_ref(mem, pkey->value.bytes, r_size(pkey), &nref, 1);
if (code < 0)
return code;
nidx = name_index(mem, &nref);
}
goto nh;
case t_real:
/*
* Make sure that equal reals and integers hash the same.
*/
{
int expt, i;
double mant = frexp(pkey->value.realval, &expt);
/*
* The value is mant * 2^expt, where 0.5 <= mant < 1,
* or else expt == mant == 0.
*/
if (expt < sizeof(long) * 8 || pkey->value.realval == min_long)
i = (int)pkey->value.realval;
else
i = (int)(mant * min_long); /* MSVC 6.00.8168.0 cannot compile this */
hash = (uint)i * 30503; /* with -O2 as a single expression */
}
goto ih;
case t_integer:
hash = (uint)pkey->value.intval * 30503;
ih:
kpack = packed_key_impossible;
ktype = -1;
nidx = 0; /* only to pacify gcc */
break;
case t_null: /* not allowed as a key */
return_error(gs_error_typecheck);
default:
hash = r_btype(pkey) * 99; /* yech */
kpack = packed_key_impossible;
ktype = -1;
nidx = 0; /* only to pacify gcc */
}
/* Search the dictionary */
if (dict_is_packed(pdict)) {
const ref_packed *pslot = 0;
# define found *ppvalue = packed_search_value_pointer; return 1
# define deleted if (pslot == 0) pslot = kp
# define missing goto miss
# include "idicttpl.h"
# undef missing
# undef deleted
# undef found
/*
* Double wraparound, dict is full.
* Note that even if there was an empty slot (pslot != 0),
* we must return dictfull if length = maxlength.
*/
if (pslot == 0 || d_length(pdict) == d_maxlength(pdict))
return_error(gs_error_dictfull);
*ppvalue = pdict->values.value.refs + (pslot - kbot);
return 0;
miss: /* Key is missing, not double wrap. See above re dictfull. */
if (d_length(pdict) == d_maxlength(pdict))
return_error(gs_error_dictfull);
if (pslot == 0)
pslot = kp;
*ppvalue = pdict->values.value.refs + (pslot - kbot);
return 0;
} else {
ref *kbot = pdict->keys.value.refs;
register ref *kp;
ref *pslot = 0;
int wrap = 0;
for (kp = kbot + dict_hash_mod(hash, size) + 2;;) {
--kp;
if ((etype = r_type(kp)) == ktype) { /* Fast comparison if both keys are names */
if (name_index(mem, kp) == nidx) {
*ppvalue = pdict->values.value.refs + (kp - kbot);
return 1;
}
} else if (etype == t_null) { /* Empty, deleted, or wraparound. */
/* Figure out which. */
if (kp == kbot) { /* wrap */
if (wrap++) { /* wrapped twice */
if (pslot == 0)
return_error(gs_error_dictfull);
break;
}
kp += size + 1;
} else if (r_has_attr(kp, a_executable)) { /* Deleted entry, save the slot. */
if (pslot == 0)
pslot = kp;
} else /* key not found */
break;
} else {
if (obj_eq(mem, kp, pkey)) {
*ppvalue = pdict->values.value.refs + (kp - kbot);
return 1;
}
}
}
if (d_length(pdict) == d_maxlength(pdict))
return_error(gs_error_dictfull);
*ppvalue = pdict->values.value.refs +
((pslot != 0 ? pslot : kp) - kbot);
return 0;
}
}
