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; }
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; }
/* * 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; } }