/*
* if key exists, set the new value.else add a pair of 'key => value' to dict
*/
void dict_set(dict_t *dict, char *keyarg, void *value)
{
//if need resize
char *key = strToHeap(keyarg);
if (prime_array[dict->size_pos] - dict->ele_num <= 1) dict_resize(dict);
//get index by hash function
int index = get_index(dict, key), flag = 0; //flag for if find the key
//get its bucket's head node's pointer
bucket_t *first = (dict->bucket)[index], *temp = first;
for (; temp; temp = temp->next)
if (strcmp(temp->key, key) == 0){
//free the old value
free(temp->value);
temp->value = value;
flag = 1;
}
if (!flag){//not find key, new a node , and append it to the list
bucket_t *node = (bucket_t *)malloc(sizeof(bucket_t));
node->key = key;
node->value = value;
node->next = NULL;
if (!first) (dict->bucket)[index] = node;
else{
for (; first->next; first = first->next);
first->next = node;
}
dict->ele_num += 1;
}
}
//creates a new, empty dict
LispObject *new_dict() {
Dict *out = alloc(sizeof(*out));
out->type = &DictType;
out->array_size = 0;
out->primei = -1;
out->keys = NULL;
out->values = NULL;
dict_resize(out);
return (LispObject*)out;
}
/* Grow a dictionary for dict_put. */
int
dict_grow(ref * pdref, dict_stack_t *pds)
{
dict *pdict = pdref->value.pdict;
/* We might have maxlength < npairs, if */
/* dict_round_size increased the size. */
ulong new_size = (ulong) d_maxlength(pdict);
/* Adobe does this */
if (new_size < 20)
new_size += 10;
else if (new_size < 200)
new_size *= 2;
else
new_size += new_size / 2;
#if ARCH_SIZEOF_INT < ARCH_SIZEOF_LONG
if (new_size > max_uint)
new_size = max_uint;
#endif
if (new_size > npairs(pdict)) {
int code = dict_resize(pdref, (uint) new_size, pds);
if (code >= 0)
return code;
/* new_size was too big. */
if (npairs(pdict) < dict_max_size) {
code = dict_resize(pdref, dict_max_size, pds);
if (code >= 0)
return code;
}
if (npairs(pdict) == d_maxlength(pdict)) { /* Can't do it. */
return code;
}
/* We can't grow to new_size, but we can grow to npairs. */
new_size = npairs(pdict);
}
/* maxlength < npairs, we can grow in place */
ref_save_in(dict_memory(pdict), pdref, &pdict->maxlength,
"dict_put(maxlength)");
d_set_maxlength(pdict, new_size);
return 0;
}
//sets the value for key key to value in d
void dict_setitem(Dict *d, LispObject *key, LispObject *value) {
int i;
if(dict_find_index(d, key, &i))
d->values[i] = value;
else if (i >= 0) {
d->keys[i] = key;
d->values[i] = value;
d->size++;
if(d->size > d->array_size / 2)
dict_resize(d);
} else
error("dict full somehow\n");
}
void dict_set(struct dict *dict, const char *key, void *data)
{
if (dict->length + 1 >= dict->resize_threshold) {
dict_resize(dict);
}
dict->length++;
uint32_t hash = lookup3_hash(key);
uint32_t pos = hash % dict->capacity;
uint32_t probe_dist, dist = 0;
const char *temp_key;
uint32_t temp_hash;
void *temp_data;
struct bucket *cur_bucket;
while (1) {
if (!dict->buckets[pos].setted) {
set_bucket(&dict->buckets[pos], hash, (char*)key, data);
return;
}
probe_dist = probe_distance(dict, dict->buckets[pos].hash, pos);
if (probe_dist < dist) {
if (dict->buckets[pos].deleted) {
set_bucket(&dict->buckets[pos], hash, (char*)key, data);
return;
}
cur_bucket = &dict->buckets[pos];
temp_hash = cur_bucket->hash;
cur_bucket->hash = hash;
hash = temp_hash;
temp_key = cur_bucket->key;
cur_bucket->key = (char*)key;
key = temp_key;
temp_data = cur_bucket->data;
cur_bucket->data = data;
data = temp_data;
dist = probe_dist;
}
pos = (pos + 1) % dict->capacity;
++dist;
}
}
/* Set a key into dict. */
int
dict_iset(struct dict *dict, char *key, size_t len, void *val)
{
assert(dict != NULL);
if ((dict_table_sizes[dict->idx] * DICT_LOAD_LIMIT < dict->len + 1) &&
dict_resize(dict) != DICT_OK)
return DICT_ENOMEM;
size_t index = dict_table_idx(dict->idx, key, len);
struct dict_node *node = (dict->table)[index];
/* try to find this key. */
while (node != NULL) {
if (dict_key_equals(node->key, node->len, key, len)) {
node->key = key;
node->len = len;
node->val = val;
return DICT_OK;
}
node = node->next;
}
/* create node if not found */
struct dict_node *new_node = dict_node_new(key, len, val);
if (new_node == NULL)
return DICT_ENOMEM;
/* rewind to list head */
node = (dict->table)[index];
if (node == NULL) {
/* if list is empty, set as head node */
(dict->table)[index] = new_node;
} else {
/* else append as tail node */
while (node->next != NULL)
node = node->next;
node->next = new_node;
}
dict->len += 1;
return DICT_OK;
}
static void parse_group(PrintDest *pd, ppd_group_t *group)
{
int i, j; /* Looping vars */
ppd_option_t *option; /* Current option */
ppd_choice_t *choice; /* Current choice */
ppd_group_t *subgroup; /* Current subgroup */
PrintOptGroup *og;
PrintOption *po;
pd->ogroups = xrealloc(pd->ogroups, (pd->nogroups + 1)*sizeof(PrintOptGroup));
if (!pd->ogroups) {
return;
}
og = &pd->ogroups[pd->nogroups];
pd->nogroups++;
og->name = copy_string(NULL, group->name);
og->text = copy_string(NULL, group->text);
og->opts = xcalloc(group->num_options, sizeof(PrintOption));
if (!og->opts) {
return;
}
og->nopts = 0;
for (i = 0, option = group->options, po = og->opts; i < group->num_options; i++, option++) {
po->name = copy_string(NULL, option->keyword);
po->text = copy_string(NULL, option->text);
po->choices = dict_new();
po->selected = -1;
dict_resize(po->choices, option->num_choices);
for (j = 0, choice = option->choices; j < option->num_choices; j++, choice++) {
DictEntry de;
de.key = j;
de.name = choice->choice;
de.descr = choice->text;
dict_entry_copy(&po->choices->entries[j], &de);
if (choice->marked) {
po->selected = de.key;
dict_entry_copy(&po->choices->defaults, &de);
}
}
if (po->selected != -1) {
og->nopts++;
po++;
pd->nopts++;
} else {
xfree(po->name);
xfree(po->text);
dict_free(po->choices);
}
}
for (i = 0, subgroup = group->subgroups; i < group->num_subgroups; i++, subgroup++) {
parse_group(pd, subgroup);
}
}
