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.

8 files changed, 268 insertions, 243 deletions

diff --git a/include/base/fs.h b/include/base/fs.h
index b2d61c3..dc6ef9e 100644
--- a/include/base/fs.h
+++ b/include/base/fs.h
@@ -9,9 +9,16 @@ enum
 };
 #undef iota
 
-typedef struct fs·Walker  fs·Walker;
-typedef struct fs·History fs·History;
+typedef struct fs·Walker    fs·Walker;
+typedef struct fs·History   fs·History;
 
+typedef sys·DirEntry  fs·DirEntry;
+typedef sys·Directory fs·Directory;
+
+/* node in filesystem */
+
+// XXX: simplify with our newer code
+/* walk a filesystem hierarchy */
 struct fs·Walker
 {
     int fd, lev, max, err;
@@ -28,6 +35,7 @@ int  fs·init(fs·Walker *, char *path);
 void fs·fini(fs·Walker *);
 void fs·walk(fs·Walker *);
 
+/* small utilities */
 int     fs·exists(byte *path, int flag);
 byte   *fs·dirname(byte *path);
 byte   *fs·basename(byte *path);
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;                                                            \
     }
diff --git a/src/base/fmt/write.c b/src/base/fmt/write.c
index 9a77223..339b391 100644
--- a/src/base/fmt/write.c
+++ b/src/base/fmt/write.c
@@ -16,6 +16,9 @@ fmt·write(fmt·State *io, char *fmt, ...)
     va_end(io->args);
 
     io->flag = io->width = io->prec = 0;
+    va_copy(io->args, args);
+    va_end(args);
+
     if(n >= 0)
         return 0;
     return n;
diff --git a/src/base/fs/walker.c b/src/base/fs/walker.c
index 65ff391..4ef35cf 100644
--- a/src/base/fs/walker.c
+++ b/src/base/fs/walker.c
@@ -1,7 +1,6 @@
 #include "internal.h"
 
-static
-void
+static void
 delete(fs·History *h)
 {
     SET_FREE(h, sys·Memory, nil);
diff --git a/src/cmd/cc/cc.c b/src/cmd/cc/cc.c
index 8ad0022..2f136cb 100644
--- a/src/cmd/cc/cc.c
+++ b/src/cmd/cc/cc.c
@@ -43,15 +43,14 @@ streq(byte *s, byte *t)
 
 #define HASH(s)      hash_string(s)
 #define EQUAL(s, t) (streq(s, t))
-static
-int
+static int
 getstr(string key, int *ok)
 {
     int idx;
     MAP_GET(idx, (&C.strs), key, HASH, EQUAL);
 
     *ok = idx < C.strs.n_buckets;
-    return idx; 
+    return idx;
 }
 
 static 
diff --git a/sys/linux/port/os/constants.h b/sys/linux/port/os/constants.h
index ffe8610..f994a93 100644
--- a/sys/linux/port/os/constants.h
+++ b/sys/linux/port/os/constants.h
@@ -69,19 +69,37 @@
 #define sys·InfoForceSync  0x2000
 #define sys·InfoNoSync     0x4000
 
-// masks
-#define  sys·InfoType        0x00000001u  /*  want/got stx_mode & s_ifmt */
-#define  sys·InfoMode        0x00000002u  /*  want/got stx_mode & ~s_ifmt */
-#define  sys·InfoNLink       0x00000004u  /*  want/got stx_nlink */
-#define  sys·InfoUid         0x00000008u  /*  want/got stx_uid */
-#define  sys·InfoGid         0x00000010u  /*  want/got stx_gid */
-#define  sys·InfoAccessTime  0x00000020u  /*  want/got stx_atime */
-#define  sys·InfoModifyTime  0x00000040u  /*  want/got stx_mtime */
-#define  sys·InfoChangeTime  0x00000080u  /*  want/got stx_ctime */
-#define  sys·InfoInode       0x00000100u  /*  want/got stx_ino */
-#define  sys·InfoSize        0x00000200u  /*  want/got stx_size */
-#define  sys·InfoBlocks      0x00000400u  /*  want/got stx_blocks */
-#define  sys·InfoBasic       0x000007ffu  /*  the stuff in the normal stat struct*/
-#define  sys·InfoCreateTime  0x00000800u  /*  want/got stx_btime   */
-#define  sys·InfoMntId       0x00001000u  /*  got stx_mnt_id  */
-#define  sys·InfoAll        (sys·InfoBasic|sys·InfoCreateTime)
+// mode masks
+#define  sys·InfoWantType        0x00000001u  /*  want/got stx_mode & s_ifmt */
+#define  sys·InfoWantMode        0x00000002u  /*  want/got stx_mode & ~s_ifmt */
+#define  sys·InfoWantNLink       0x00000004u  /*  want/got stx_nlink */
+#define  sys·InfoWantUid         0x00000008u  /*  want/got stx_uid */
+#define  sys·InfoWantGid         0x00000010u  /*  want/got stx_gid */
+#define  sys·InfoWantAccessTime  0x00000020u  /*  want/got stx_atime */
+#define  sys·InfoWantModifyTime  0x00000040u  /*  want/got stx_mtime */
+#define  sys·InfoWantChangeTime  0x00000080u  /*  want/got stx_ctime */
+#define  sys·InfoWantInode       0x00000100u  /*  want/got stx_ino */
+#define  sys·InfoWantSize        0x00000200u  /*  want/got stx_size */
+#define  sys·InfoWantBlocks      0x00000400u  /*  want/got stx_blocks */
+#define  sys·InfoWantBasic       0x000007ffu  /*  the stuff in the normal stat struct*/
+#define  sys·InfoWantCreateTime  0x00000800u  /*  want/got stx_btime   */
+#define  sys·InfoWantMntId       0x00001000u  /*  got stx_mnt_id  */
+#define  sys·InfoWantAll        (sys·InfoWantBasic|sys·InfoWantCreateTime)
+
+// helpers
+#define  sys·InfoMaskType     0170000
+#define  sys·InfoDirType      0040000
+#define  sys·InfoCharType     0020000
+#define  sys·InfoBlockType    0060000
+#define  sys·InfoFileType     0100000
+#define  sys·InfoFifoType     0010000
+#define  sys·InfoLinkType     0120000
+#define  sys·InfoSocketType   0140000
+
+#define  sys·InfoIsDir(mode)     (((mode)  &  sys·InfoMaskType)  ==  sys·InfoDirType)
+#define  sys·InfoIsChar(mode)    (((mode)  &  sys·InfoMaskType)  ==  sys·InfoCharType)
+#define  sys·InfoIsBlock(mode)   (((mode)  &  sys·InfoMaskType)  ==  sys·InfoBlockType)
+#define  sys·InfoIsFile(mode)    (((mode)  &  sys·InfoMaskType)  ==  sys·InfoFileType)
+#define  sys·InfoIsFifo(mode)    (((mode)  &  sys·InfoMaskType)  ==  sys·InfoFifoType)
+#define  sys·InfoIsLink(mode)    (((mode)  &  sys·InfoMaskType)  ==  sys·InfoLinkType)
+#define  sys·InfoIsSocket(mode)  (((mode)  &  sys·InfoMaskType)  ==  sys·InfoSocketType)
diff --git a/sys/linux/src/info.c b/sys/linux/src/info.c
index 60f32a0..81b85b9 100644
--- a/sys/linux/src/info.c
+++ b/sys/linux/src/info.c
@@ -3,5 +3,5 @@
 int
 sys·info(char *path, sys·Info *file)
 {
-    return sys·infoat(sys·FdCwd, path, 0, sys·InfoAll, file);
+    return sys·infoat(sys·FdCwd, path, 0, sys·InfoWantAll, file);
 }
diff --git a/sys/linux/src/infofd.c b/sys/linux/src/infofd.c
index 770009a..2c22c72 100644
--- a/sys/linux/src/infofd.c
+++ b/sys/linux/src/infofd.c
@@ -5,5 +5,5 @@ sys·infofd(int fd, sys·Info *file)
 {
     if(fd < 0)
         return sys·ErrorBadFd;
-    return sys·infoat(fd, "", sys·AtEmptyPath, sys·InfoAll, file);
+    return sys·infoat(fd, "", sys·AtEmptyPath, sys·InfoWantAll, file);
 }