From 158d9b84f14457136379f42e7c071eb79d87ee6b Mon Sep 17 00:00:00 2001 From: Nicholas Noll Date: Sun, 5 Dec 2021 06:53:03 -0800 Subject: Feat: libbase partitioning. Cleaned up hash map macros. Additionally, fixed varargs cleanup when done with fmt.write. Some system constants were added to allow for directory walking. --- include/base/macro/map.h | 434 +++++++++++++++++++++++------------------------ 1 file changed, 216 insertions(+), 218 deletions(-) (limited to 'include/base/macro') diff --git a/include/base/macro/map.h b/include/base/macro/map.h index 7c2f7ae..d7b9e89 100644 --- a/include/base/macro/map.h +++ b/include/base/macro/map.h @@ -5,396 +5,394 @@ * Modified to make control more granular and similar to QSORT */ -static const double __ac_HASH_UPPER = 0.77; +static const double HASHFILL = 0.77; -#define _roundup32(x) \ - (--(x), (x) |= (x) >> 1, (x) |= (x) >> 2, (x) |= (x) >> 4, (x) |= (x) >> 8, \ +#define ROUNDUP32(x) \ + (--(x), (x) |= (x) >> 1, (x) |= (x) >> 2, (x) |= (x) >> 4, (x) |= (x) >> 8, \ (x) |= (x) >> 16, ++(x)) -#define __ac_isempty(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 2) -#define __ac_isdel(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 1) -#define __ac_iseither(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 3) -#define __ac_set_isdel_false(flag, i) \ +#define map·isempty(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 2) +#define map·isdelete(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 1) +#define map·iseither(flag, i) ((flag[i >> 4] >> ((i & 0xfU) << 1)) & 3) +#define map·setnodelete(flag, i) \ (flag[i >> 4] &= ~(1ul << ((i & 0xfU) << 1))) -#define __ac_set_isempty_false(flag, i) \ +#define map·setnoteither(flag, i) \ (flag[i >> 4] &= ~(2ul << ((i & 0xfU) << 1))) -#define __ac_set_isboth_false(flag, i) \ +#define map·setnotboth(flag, i) \ (flag[i >> 4] &= ~(3ul << ((i & 0xfU) << 1))) -#define __ac_set_isdel_true(flag, i) (flag[i >> 4] |= 1ul << ((i & 0xfU) << 1)) +#define map·setdelete(flag, i) (flag[i >> 4] |= 1ul << ((i & 0xfU) << 1)) -#define __ac_fsize(m) ((m) < 16 ? 1 : (m) >> 4) +#define map·flagsize(m) ((m) < 16 ? 1 : (m) >> 4) +#define map·fill(m, x) (!map·iseither((m)->flag, (x))) +/* map types */ #define MAP_STRUCT_BODY(key_t, val_t) \ - int32 n_buckets, size, n_occupied, upper_bound; \ - int32 *flags; \ - key_t *keys; \ - val_t *vals; + int32 cap, len, occ, fill; \ + int32 *flag; \ + key_t *key; \ + val_t *val #define MAP_MAKE(type, h, alloc) \ - type *map; \ - map = alloc((h), 1, sizeof(*map)); \ + type *map = alloc((h), 1, sizeof(*map)); \ return map #define MAP_FREE(map, mem, heap) \ - mem.free(heap, map->keys); \ - mem.free(heap, map->flags); \ - mem.free(heap, map->vals); \ - mem.free(heap, map); + (mem).free((heap), (map)->key); \ + (mem).free((heap), (map)->flag); \ + (mem).free((heap), (map)->val); \ + (mem).free((heap), (map)); #define MAP_RESET(map) \ - if (map && map->flags) { \ - memset(map->flags, 0xaa, __ac_fsize(map->n_buckets) * sizeof(int32)); \ - map->size = map->n_occupied = 0; \ + if((map) && (map)->flag){ \ + memset((map)->flag, 0xAA, map·flagsize((map)->cap)*sizeof(int32)); \ + (map)->len = (map)->occ = 0; \ } -#define MAP_GET(i, map, key, hashfunc, equalfunc ) \ +#define MAP_GET(i, map, key, hashfunc, equalfunc) \ int32 k, last, mask, step; \ - if (map->n_buckets) { \ + if((map)->cap){ \ k = 0; \ i = 0; \ last = 0; \ mask = 0; \ step = 0; \ - mask = map->n_buckets - 1; \ - k = hashfunc(key); \ + mask = (map)->cap - 1; \ + k = hashfunc((key)); \ i = k & mask; \ last = i; \ - while (!__ac_isempty(map->flags, i) && \ - (__ac_isdel(map->flags, i) || !equalfunc(map->keys[i], key))) { \ + while(!map·isempty((map)->flag, i) && \ + (map·isdelete((map)->flag, i) || !equalfunc((map)->key[i], (key)))){ \ i = (i + (++step)) & mask; \ - if (i == last) { \ - i = map->n_buckets; \ + if(i == last){ \ + i = (map)->cap; \ break; \ } \ } \ - if (i < map->n_buckets && __ac_iseither(map->flags, i)) \ - i = map->n_buckets; \ - } else \ + if(i < (map)->cap && map·iseither((map)->flag, i)) \ + i = (map)->cap; \ + }else \ i = 0; -#define MAP_GROW(map, key_t, val_t, new_n_buckets, hashfunc, mem, heap) \ +#define MAP_GROW(map, key_t, val_t, newcap, hashfunc, mem, heap) \ int32 *new_flags = nil; \ int32 j = 1; \ { \ - _roundup32(new_n_buckets); \ - if (new_n_buckets < 4) \ - new_n_buckets = 4; \ - if (map->size >= (int32)(new_n_buckets * __ac_HASH_UPPER + 0.5)) \ + ROUNDUP32(newcap); \ + if(newcap < 4) \ + newcap = 4; \ + if((map)->len >= (int32)(newcap * HASHFILL + 0.5)) \ j = 0; \ - else { \ - new_flags = mem.alloc(heap, __ac_fsize(new_n_buckets), sizeof(int32)); \ - if (!new_flags) return -1; \ - memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(int32)); \ - if (map->n_buckets < new_n_buckets) { /* expand */ \ - key_t *new_keys = mem.alloc(heap, new_n_buckets, sizeof(key_t)); \ - if (!new_keys) { \ - mem.free(heap, new_flags); \ + else{ \ + new_flags = (mem).alloc((heap), map·flagsize(newcap), sizeof(int32)); \ + if(!new_flags) return -1; \ + memset(new_flags, 0xaa, map·flagsize(newcap) * sizeof(int32)); \ + if((map)->cap < newcap){ /* expand */ \ + key_t *new_keys = (mem).alloc((heap), newcap, sizeof(key_t)); \ + if(!new_keys){ \ + (mem).free((heap), new_flags); \ return -1; \ } \ - memcpy(new_keys, map->keys, sizeof(key_t) * map->n_buckets); \ - mem.free(heap, map->keys); \ - map->keys = new_keys; \ - val_t *new_vals = mem.alloc(heap, new_n_buckets, sizeof(val_t)); \ - if (!new_vals) { \ - mem.free(heap, new_flags); \ + memcpy(new_keys, (map)->key, sizeof(key_t) * (map)->cap); \ + (mem).free((heap), (map)->key); \ + (map)->key = new_keys; \ + val_t *new_vals = (mem).alloc((heap), newcap, sizeof(val_t)); \ + if(!new_vals){ \ + (mem).free((heap), new_flags); \ return -1; \ } \ - memcpy(new_vals, map->vals, sizeof(val_t) * map->n_buckets); \ - mem.free(heap, map->vals); \ - map->vals = new_vals; \ + memcpy(new_vals, (map)->val, sizeof(val_t) * (map)->cap); \ + (mem).free((heap), (map)->val); \ + (map)->val = new_vals; \ } \ } \ } \ - if (j) { /* rehashing is needed */ \ - for (j = 0; j != map->n_buckets; ++j) { \ - if (__ac_iseither(map->flags, j) == 0) { \ - key_t key = map->keys[j]; \ + if(j){ /* rehashing is needed */ \ + for(j = 0; j != (map)->cap; ++j){ \ + if(map·iseither((map)->flag, j) == 0){ \ + key_t key = (map)->key[j]; \ val_t val; \ int32 new_mask; \ - new_mask = new_n_buckets - 1; \ - val = map->vals[j]; \ - __ac_set_isdel_true(map->flags, j); \ - while (1) { \ + new_mask = newcap - 1; \ + val = (map)->val[j]; \ + map·setdelete((map)->flag, j); \ + while(1){ \ int32 k, i, step = 0; \ k = hashfunc(key); \ i = k & new_mask; \ - while (!__ac_isempty(new_flags, i)) \ + while (!map·isempty(new_flags, i)) \ i = (i + (++step)) & new_mask; \ - __ac_set_isempty_false(new_flags, i); \ - if (i < map->n_buckets && __ac_iseither(map->flags, i) == 0) { \ + map·setnoteither(new_flags, i); \ + if(i < (map)->cap && map·iseither((map)->flag, i) == 0) { \ { \ - key_t tmp = map->keys[i]; \ - map->keys[i] = key; \ + key_t tmp = (map)->key[i]; \ + (map)->key[i] = key; \ key = tmp; \ } \ { \ - val_t tmp = map->vals[i]; \ - map->vals[i] = val; \ + val_t tmp = (map)->val[i]; \ + (map)->val[i] = val; \ val = tmp; \ } \ - __ac_set_isdel_true(map->flags, i); \ - } else { \ - map->keys[i] = key; \ - map->vals[i] = val; \ + map·setdelete((map)->flag, i); \ + }else{ \ + (map)->key[i] = key; \ + (map)->val[i] = val; \ break; \ } \ } \ } \ } \ - if (map->n_buckets > new_n_buckets) { /* shrink the hash table */ \ - key_t *new_keys = mem.alloc(heap, new_n_buckets, sizeof(key_t)); \ - memcpy(new_keys, map->keys, sizeof(key_t) * map->n_buckets); \ - mem.free(heap, map->keys); \ - map->keys = new_keys; \ + if((map)->cap > newcap){ /* shrink the hash table */ \ + key_t *new_keys = (mem).alloc((heap), newcap, sizeof(key_t)); \ + memcpy(new_keys, (map)->key, sizeof(key_t) * (map)->cap); \ + (mem).free((heap), (map)->key); \ + (map)->key = new_keys; \ \ - val_t *new_vals = mem.alloc(heap, new_n_buckets, sizeof(val_t)); \ - memcpy(new_vals, map->vals, sizeof(val_t) * map->n_buckets); \ - mem.free(heap, map->vals); \ - map->vals = new_vals; \ + val_t *new_vals = (mem).alloc((heap), newcap, sizeof(val_t)); \ + memcpy(new_vals, (map)->val, sizeof(val_t) * (map)->cap); \ + (mem).free((heap), (map)->val); \ + (map)->val = new_vals; \ } \ - mem.free(heap, map->flags); /* free the working space */ \ - map->flags = new_flags; \ - map->n_buckets = new_n_buckets; \ - map->n_occupied = map->size; \ - map->upper_bound = (int32)(map->n_buckets * __ac_HASH_UPPER + 0.5); \ + (mem).free((heap), (map)->flag); /* free the working space */ \ + (map)->flag = new_flags; \ + (map)->cap = newcap; \ + (map)->occ = (map)->len; \ + (map)->fill = (int32)((map)->cap * HASHFILL + 0.5); \ } \ return 0; -#define MAP_PUT(map, key, val, hashfunc, equalfunc, resizefunc, err) \ +#define MAP_PUT(map, key, hashfunc, equalfunc, resizefunc, err) \ int32 x = 0; \ - if (map->n_occupied >= map->upper_bound) { \ - if (map->n_buckets > (map->size << 1)) { \ - if (resizefunc(map, map->n_buckets - 1) < 0) { \ + if(map->occ >= map->fill){ \ + if(map->cap > (map->len << 1)){ \ + if(resizefunc(map, map->cap - 1) < 0){ \ *err = -1; \ - return map->n_buckets; \ + return map->cap; \ } \ - } else if (resizefunc(map, map->n_buckets + 1) < 0) { \ + }else if(resizefunc(map, map->cap + 1) < 0){ \ *err = -1; \ - return map->n_buckets; \ + return map->cap; \ } \ } \ \ { \ - int32 k, i, site, last, mask = map->n_buckets - 1, step = 0; \ - x = site = map->n_buckets; \ - k = hashfunc(key); \ + int32 k, i, site, last, mask = map->cap - 1, step = 0; \ + x = site = map->cap; \ + k = hashfunc((key)); \ i = k & mask; \ - if (__ac_isempty(map->flags, i)) \ + if(map·isempty(map->flag, i)) \ x = i; /* for speed up */ \ - else { \ + else{ \ last = i; \ - while (!__ac_isempty(map->flags, i) && \ - (__ac_isdel(map->flags, i) || !equalfunc(map->keys[i], key))) { \ - if (__ac_isdel(map->flags, i)) \ + while(!map·isempty(map->flag, i) && \ + (map·isdelete(map->flag, i) || !equalfunc(map->key[i], (key)))){ \ + if(map·isdelete(map->flag, i)) \ site = i; \ i = (i + (++step)) & mask; \ - if (i == last) { \ + if(i == last){ \ x = site; \ break; \ } \ } \ - if (x == map->n_buckets) { \ - if (__ac_isempty(map->flags, i) && site != map->n_buckets) \ + if(x == map->cap){ \ + if(map·isempty(map->flag, i) && site != map->cap) \ x = site; \ else \ x = i; \ } \ } \ } \ - if (__ac_isempty(map->flags, x)) { /* not present at all */ \ - map->keys[x] = key; \ - __ac_set_isboth_false(map->flags, x); \ - ++map->size; \ - ++map->n_occupied; \ + if(map·isempty(map->flag, x)){ /* not present at all */ \ + map->key[x] = (key); \ + map·setnotboth(map->flag, x); \ + ++map->len; \ + ++map->occ; \ *err = 1; \ - } else if (__ac_isdel(map->flags, x)) { /* deleted */ \ - map->keys[x] = key; \ - __ac_set_isboth_false(map->flags, x); \ - ++map->size; \ - } else \ + }else if(map·isdelete(map->flag, x)){ /* deleted */ \ + map->key[x] = (key); \ + map·setnotboth(map->flag, x); \ + ++map->len; \ + }else \ *err = 0; \ - return x; + return x; #define MAP_DEL(map, x) \ - if (x != map->n_buckets && !__ac_iseither(map->flags, x)) { \ - __ac_set_isdel_true(map->flags, x); \ - --map->size; \ - } - -#define KEY_EXIST(m, x) (!__ac_iseither((m)->flags, (x))) + if(x != map->cap && !map·iseither(map->flag, x)){ \ + map·setdelete(map->flag, x); \ + --map->len; \ + } /* set macro */ #define SET_STRUCT_BODY(key_t) \ - int32 n_buckets, size, n_occupied, upper_bound; \ - int32 *flags; \ - key_t *keys \ + int32 cap, len, occ, fill; \ + int32 *flag; \ + key_t *key \ #define SET_MAKE(type, h, alloc) \ - type *set; \ - set = alloc((h), 1, sizeof(*set)); \ + type *set = alloc((h), 1, sizeof(*set)); \ return set -#define SET_FREE(set, mem, heap) \ - mem.free(heap, set->keys); \ - mem.free(heap, set->flags); \ - mem.free(heap, set) +#define SET_FREE(set, mem, heap) \ + (mem).free((heap), (set)->key); \ + (mem).free((heap), (set)->flag); \ + (mem).free((heap), (set)) #define SET_RESET(set) \ - if (set && set->flags) { \ - memset(set->flags, 0xaa, __ac_fsize(set->n_buckets) * sizeof(int32)); \ - set->size = set->n_occupied = 0; \ + if ((set) && (set)->flag) { \ + memset((set)->flag, 0xAA, map·flagsize((set)->cap) * sizeof(int32)); \ + (set)->len = (set)->occ = 0; \ } #define SET_GET(i, set, key, hashfunc, equalfunc ) \ int32 k, last, mask, step; \ - if (set->n_buckets) { \ + if((set)->cap){ \ k = 0; \ i = 0; \ last = 0; \ mask = 0; \ step = 0; \ - mask = set->n_buckets - 1; \ - k = hashfunc(key); \ + mask = (set)->cap - 1; \ + k = hashfunc((key)); \ i = k & mask; \ last = i; \ - while (!__ac_isempty(set->flags, i) && \ - (__ac_isdel(set->flags, i) || !equalfunc(set->keys[i], key))) { \ + while(!map·isempty((set)->flag, i) && \ + (map·isdelete((set)->flag, i) || !equalfunc((set)->key[i], (key)))){ \ i = (i + (++step)) & mask; \ - if (i == last) { \ - i = set->n_buckets; \ + if(i == last){ \ + i = (set)->cap; \ break; \ } \ } \ - if (i < set->n_buckets && __ac_iseither(set->flags, i)) \ - i = set->n_buckets; \ - } else \ + if(i < (set)->cap && map·iseither((set)->flag, i)) \ + i = (set)->cap; \ + }else \ i = 0; -#define SET_GROW(set, key_t, new_n_buckets, hashfunc, mem, heap) \ +#define SET_GROW(set, key_t, newcap, hashfunc, mem, heap) \ int32 *new_flags = nil; \ int32 j = 1; \ { \ - _roundup32(new_n_buckets); \ - if (new_n_buckets < 4) \ - new_n_buckets = 4; \ - if (set->size >= (int32)(new_n_buckets * __ac_HASH_UPPER + 0.5)) \ + ROUNDUP32(newcap); \ + if(newcap < 4) \ + newcap = 4; \ + if((set)->len >= (int32)(newcap * HASHFILL + 0.5)) \ j = 0; \ - else { \ - new_flags = mem.alloc(heap, __ac_fsize(new_n_buckets), sizeof(int32)); \ - if (!new_flags) return -1; \ - memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(int32)); \ - if (set->n_buckets < new_n_buckets) { /* expand */ \ - key_t *new_keys = mem.alloc(heap, new_n_buckets, sizeof(key_t)); \ - if (!new_keys) { \ - mem.free(heap, new_flags); \ + else{ \ + new_flags = mem.alloc((heap), map·flagsize(newcap), sizeof(int32)); \ + if(!new_flags) return -1; \ + memset(new_flags, 0xaa, map·flagsize(newcap) * sizeof(int32)); \ + if((set)->cap < newcap) { /* expand */ \ + key_t *new_keys = mem.alloc((heap), newcap, sizeof(key_t)); \ + if(!new_keys){ \ + mem.free((heap), new_flags); \ return -1; \ } \ - memcpy(new_keys, set->keys, sizeof(key_t) * set->n_buckets); \ - mem.free(heap, set->keys); \ - set->keys = new_keys; \ + memcpy(new_keys, (set)->key, sizeof(key_t) * (set)->cap); \ + mem.free((heap), (set)->key); \ + (set)->key = new_keys; \ } \ } \ } \ - if (j) { /* rehashing is needed */ \ - for (j = 0; j != set->n_buckets; ++j) { \ - if (__ac_iseither(set->flags, j) == 0) { \ - key_t key = set->keys[j]; \ + if(j){ /* rehashing is needed */ \ + for(j = 0; j != (set)->cap; ++j) { \ + if(map·iseither((set)->flag, j) == 0) { \ + key_t key = (set)->key[j]; \ int32 new_mask; \ - new_mask = new_n_buckets - 1; \ - __ac_set_isdel_true(set->flags, j); \ - while (1) { \ + new_mask = newcap - 1; \ + map·setdelete((set)->flag, j); \ + while(1){ \ int32 k, i, step = 0; \ k = hashfunc(key); \ i = k & new_mask; \ - while (!__ac_isempty(new_flags, i)) \ + while(!map·isempty(new_flags, i)) \ i = (i + (++step)) & new_mask; \ - __ac_set_isempty_false(new_flags, i); \ - if (i < set->n_buckets && __ac_iseither(set->flags, i) == 0) { \ + map·setnoteither(new_flags, i); \ + if(i < (set)->cap && map·iseither((set)->flag, i) == 0) { \ { \ - key_t tmp = set->keys[i]; \ - set->keys[i] = key; \ + key_t tmp = (set)->key[i]; \ + (set)->key[i] = key; \ key = tmp; \ } \ - __ac_set_isdel_true(set->flags, i); \ - } else { \ - set->keys[i] = key; \ + map·setdelete((set)->flag, i); \ + }else{ \ + (set)->key[i] = key; \ break; \ } \ } \ } \ } \ - if (set->n_buckets > new_n_buckets) { /* shrink the hash table */ \ - key_t *new_keys = mem.alloc(heap, new_n_buckets, sizeof(key_t)); \ - memcpy(new_keys, set->keys, sizeof(key_t) * set->n_buckets); \ - mem.free(heap, set->keys); \ - set->keys = new_keys; \ + if((set)->cap > newcap) { /* shrink the hash table */ \ + key_t *new_keys = mem.alloc((heap), newcap, sizeof(key_t)); \ + memcpy(new_keys, (set)->key, sizeof(key_t) * (set)->cap); \ + mem.free((heap), (set)->key); \ + (set)->key = new_keys; \ } \ - mem.free(heap, set->flags); /* free the working space */ \ - set->flags = new_flags; \ - set->n_buckets = new_n_buckets; \ - set->n_occupied = set->size; \ - set->upper_bound = (int32)(set->n_buckets * __ac_HASH_UPPER + 0.5); \ + mem.free((heap), (set)->flag); /* free the working space */ \ + (set)->flag = new_flags; \ + (set)->cap = newcap; \ + (set)->occ = (set)->len; \ + (set)->fill = (int32)((set)->cap * HASHFILL + 0.5); \ } \ return 0; #define SET_PUT(set, key, hashfunc, equalfunc, resizefunc, err) \ int32 x = 0; \ - if (set->n_occupied >= set->upper_bound) { \ - if (set->n_buckets > (set->size << 1)) { \ - if (resizefunc(set, set->n_buckets - 1) < 0) { \ + if((set)->occ >= (set)->fill){ \ + if((set)->cap > ((set)->len << 1)){ \ + if(resizefunc((set), (set)->cap - 1) < 0){ \ *err = -1; \ - return set->n_buckets; \ + return (set)->cap; \ } \ - } else if (resizefunc(set, set->n_buckets + 1) < 0) { \ + }else if(resizefunc((set), (set)->cap + 1) < 0){ \ *err = -1; \ - return set->n_buckets; \ + return (set)->cap; \ } \ } \ \ { \ - int32 k, i, site, last, mask = set->n_buckets - 1, step = 0; \ - x = site = set->n_buckets; \ - k = hashfunc(key); \ + int32 k, i, site, last, mask = (set)->cap - 1, step = 0; \ + x = site = (set)->cap; \ + k = hashfunc((key)); \ i = k & mask; \ - if (__ac_isempty(set->flags, i)) \ + if(map·isempty((set)->flag, i)) \ x = i; /* for speed up */ \ - else { \ + else{ \ last = i; \ - while (!__ac_isempty(set->flags, i) && \ - (__ac_isdel(set->flags, i) || !equalfunc(set->keys[i], key))) { \ - if (__ac_isdel(set->flags, i)) \ + while(!map·isempty((set)->flag, i) && \ + (map·isdelete((set)->flag, i) || !equalfunc((set)->key[i], (key)))){\ + if(map·isdelete((set)->flag, i)) \ site = i; \ i = (i + (++step)) & mask; \ - if (i == last) { \ + if(i == last) { \ x = site; \ break; \ } \ } \ - if (x == set->n_buckets) { \ - if (__ac_isempty(set->flags, i) && site != set->n_buckets) \ + if(x == (set)->cap){ \ + if(map·isempty((set)->flag, i) && site != (set)->cap) \ x = site; \ else \ x = i; \ } \ } \ } \ - if (__ac_isempty(set->flags, x)) { /* not present at all */ \ - set->keys[x] = key; \ - __ac_set_isboth_false(set->flags, x); \ - ++set->size; \ - ++set->n_occupied; \ + if(map·isempty((set)->flag, x)) { /* not present at all */ \ + (set)->key[x] = (key); \ + map·setnotboth((set)->flag, x); \ + ++(set)->len; \ + ++(set)->occ; \ *err = 1; \ - } else if (__ac_isdel(set->flags, x)) { /* deleted */ \ - set->keys[x] = key; \ - __ac_set_isboth_false(set->flags, x); \ - ++set->size; \ - } else \ + }else if(map·isdelete((set)->flag, x)){ /* deleted */ \ + (set)->key[x] = (key); \ + map·setnotboth((set)->flag, x); \ + ++(set)->len; \ + }else \ *err = 0; \ return x #define SET_DEL(set, x) \ - if (x != set->n_buckets && !__ac_iseither(set->flags, x)) { \ - __ac_set_isdel_true(set->flags, x); \ - --set->size; \ + if(x != (set)->cap && !map·iseither((set)->flag, x)) { \ + map·setdelete((set)->flag, x); \ + --(set)->len; \ } -- cgit v1.2.1