feat: improved interface of map macro

3 files changed, 63 insertions, 51 deletions

diff --git a/include/libbio.h b/include/libbio.h
index b3d0426..f84b081 100644
--- a/include/libbio.h
+++ b/include/libbio.h
@@ -53,7 +53,7 @@ typedef struct bio·SeqReader bio·SeqReader;
 
 typedef struct bio·Seq
 {
-    int  len;
+    vlong len;
     char *name;
     char *s;
     char *q;
diff --git a/include/libn.h b/include/libn.h
index 5d557ce..2cf29c7 100644
--- a/include/libn.h
+++ b/include/libn.h
@@ -57,7 +57,7 @@ typedef struct mem·Allocator {
     void *(*alloc)(void *heap, uint n, ulong size);
     void  (*free)(void *heap, void *ptr);
 } mem·Allocator;
-extern mem·Allocator sys·Memory; 
+extern mem·Allocator sys·Memory;
 
 typedef struct mem·Reallocator {
     void *(*alloc)(void *iface, uint n, ulong size);
@@ -159,6 +159,7 @@ enum SeekPos
     seek·end = SEEK_END
 };
 
+/* XXX: change casing */
 enum
 {
     ReadOK  = R_OK,
@@ -180,6 +181,7 @@ int        io·putstring(io·Stream *s, string str);
 int        io·write(io·Stream *s, int sz, int n, void *buf);
 int        io·flush(io·Stream *s);
 int        io·seek(io·Stream *s, long off, enum SeekPos whence);
+long       io·tell(io·Stream *s);
 
 /* basic os helpers */
 int     os·exists(byte *path, int flag);
@@ -193,13 +195,6 @@ typedef struct io·Reader
 } io·Reader;
 extern io·Reader sys·Reader;
 
-/*
-typedef struct io·LineReader
-{
-    int (*readln)(void*, int n, void *buf);
-} io·LineReader;
-*/
-
 typedef struct io·Peeker
 {
     byte  (*get)(void*);
@@ -207,12 +202,26 @@ typedef struct io·Peeker
 } io·Peeker;
 extern io·Peeker sys·Peeker;
 
-typedef struct io·FullReader
+typedef struct io·Seeker
+{
+    int        (*seek)(void *skr, long off, enum SeekPos whence);
+    long       (*tell)(void *skr);
+} io·Seeker;
+extern io·Seeker sys·Seeker;
+
+typedef struct io·SeekReader
+{
+    io·Seeker;
+    io·Reader;
+} io·SeekReader;
+extern io·SeekReader sys·SeekReader;
+
+typedef struct io·PeekReader
 {
     io·Reader;
     io·Peeker;
-} io·FullReader;
-extern io·FullReader sys·FullReader;
+} io·PeekReader;
+extern io·PeekReader sys·PeekReader;
 
 typedef struct io·Writer
 {
@@ -227,12 +236,12 @@ typedef struct io·Putter
 } io·Putter;
 extern io·Putter sys·Putter;
 
-typedef struct io·FullWriter
+typedef struct io·PutWriter
 {
     io·Writer;
     io·Putter;
-} io·FullWriter;
-extern io·FullWriter sys·FullWriter;
+} io·PutWriter;
+extern io·PutWriter sys·PutWriter;
 
 typedef struct io·ReadWriter
 {
@@ -348,13 +357,15 @@ typedef void gz·Stream;
 /* interfaces */
 extern io·Reader     gz·Reader;
 extern io·Peeker     gz·Peeker;
-extern io·FullReader gz·FullReader;
+extern io·Seeker     gz·Seeker;
+extern io·SeekReader gz·SeekReader;
+extern io·PeekReader gz·PeekReader;
 
 extern io·Writer     gz·Writer;
 extern io·Putter     gz·Putter;
-extern io·FullWriter gz·FullWriter;
+extern io·PutWriter  gz·PutWriter;
 extern io·ReadWriter gz·ReadWriter;
-                                
+
 gz·Stream *gz·open(byte *path, byte *mode);
 error      gz·close(gz·Stream* s);
 int        gz·read(gz·Stream *s, int sz, int n, void* buf);
@@ -366,7 +377,8 @@ error      gz·putbyte(gz·Stream *s, byte str);
 error      gz·putstring(gz·Stream *s, byte *str);
 int        gz·printf(gz·Stream *s, byte *fmt, ...);
 error      gz·flush(gz·Stream *s);
-vlong      gz·seek(gz·Stream *s, long off, enum SeekPos whence);
+int        gz·seek(gz·Stream *s, long off, enum SeekPos whence);
+long       gz·tell(gz·Stream *s);
 
 // -----------------------------------------------------------------------------
 // libjson
diff --git a/include/libn/macro/map.h b/include/libn/macro/map.h
index 0743c1b..7c2f7ae 100644
--- a/include/libn/macro/map.h
+++ b/include/libn/macro/map.h
@@ -35,11 +35,11 @@ static const double __ac_HASH_UPPER = 0.77;
   map = alloc((h), 1, sizeof(*map));                                           \
   return map
 
-#define MAP_FREE(map, free, h)                                                 \
-  free(h, map->keys);                                                          \
-  free(h, map->flags);                                                         \
-  free(h, map->vals);                                                          \
-  free(h, 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);
 
 #define MAP_RESET(map)                                                         \
   if (map && map->flags) {                                                     \
@@ -72,7 +72,7 @@ static const double __ac_HASH_UPPER = 0.77;
   } else                                                                       \
     i = 0;
 
-#define MAP_GROW(map, key_t, val_t, new_n_buckets, hashfunc, alloc, free, h)   \
+#define MAP_GROW(map, key_t, val_t, new_n_buckets, hashfunc, mem, heap)        \
   int32 *new_flags = nil;                                                      \
   int32 j = 1;                                                                 \
   {                                                                            \
@@ -82,25 +82,25 @@ static const double __ac_HASH_UPPER = 0.77;
     if (map->size >= (int32)(new_n_buckets * __ac_HASH_UPPER + 0.5))           \
       j = 0;                                                                   \
     else {                                                                     \
-      new_flags = alloc(h, __ac_fsize(new_n_buckets), sizeof(int32));          \
+      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 = alloc(h, new_n_buckets, sizeof(key_t));              \
+        key_t *new_keys = mem.alloc(heap, new_n_buckets, sizeof(key_t));       \
         if (!new_keys) {                                                       \
-          free(h, new_flags);                                                  \
+          mem.free(heap, new_flags);                                           \
           return -1;                                                           \
         }                                                                      \
         memcpy(new_keys, map->keys, sizeof(key_t) * map->n_buckets);           \
-        free(h, map->keys);                                                    \
+        mem.free(heap, map->keys);                                             \
         map->keys = new_keys;                                                  \
-        val_t *new_vals = alloc(h, new_n_buckets, sizeof(val_t));              \
+        val_t *new_vals = mem.alloc(heap, new_n_buckets, sizeof(val_t));       \
         if (!new_vals) {                                                       \
-          free(h, new_flags);                                                  \
+          mem.free(heap, new_flags);                                           \
           return -1;                                                           \
         }                                                                      \
         memcpy(new_vals, map->vals, sizeof(val_t) * map->n_buckets);           \
-        free(h, map->vals);                                                    \
+        mem.free(heap, map->vals);                                             \
         map->vals = new_vals;                                                  \
       }                                                                        \
     }                                                                          \
@@ -142,17 +142,17 @@ static const double __ac_HASH_UPPER = 0.77;
       }                                                                        \
     }                                                                          \
     if (map->n_buckets > new_n_buckets) { /* shrink the hash table */          \
-      key_t *new_keys = alloc(h, new_n_buckets, sizeof(key_t));                \
+      key_t *new_keys = mem.alloc(heap, new_n_buckets, sizeof(key_t));         \
       memcpy(new_keys, map->keys, sizeof(key_t) * map->n_buckets);             \
-      free(h, map->keys);                                                      \
+      mem.free(heap, map->keys);                                               \
       map->keys = new_keys;                                                    \
                                                                                \
-      val_t *new_vals = alloc(h, new_n_buckets, sizeof(val_t));                \
+      val_t *new_vals = mem.alloc(heap, new_n_buckets, sizeof(val_t));         \
       memcpy(new_vals, map->vals, sizeof(val_t) * map->n_buckets);             \
-      free(h, map->vals);                                                      \
+      mem.free(heap, map->vals);                                               \
       map->vals = new_vals;                                                    \
     }                                                                          \
-    free(h, map->flags); /* free the working space */                          \
+    mem.free(heap, map->flags); /* free the working space */                   \
     map->flags      = new_flags;                                               \
     map->n_buckets  = new_n_buckets;                                           \
     map->n_occupied = map->size;                                               \
@@ -235,10 +235,10 @@ static const double __ac_HASH_UPPER = 0.77;
   set = alloc((h), 1, sizeof(*set));                                           \
   return set
 
-#define SET_FREE(set, free, h)                                                 \
-  free(h, set->keys);                                                          \
-  free(h, set->flags);                                                         \
-  free(h, set)
+#define SET_FREE(set, mem, heap)                                                \
+  mem.free(heap, set->keys);                                                    \
+  mem.free(heap, set->flags);                                                   \
+  mem.free(heap, set)
 
 #define SET_RESET(set)                                                         \
   if (set && set->flags) {                                                     \
@@ -271,7 +271,7 @@ static const double __ac_HASH_UPPER = 0.77;
   } else                                                                       \
     i = 0;
 
-#define SET_GROW(set, key_t, new_n_buckets, hashfunc, alloc, free, h)          \
+#define SET_GROW(set, key_t, new_n_buckets, hashfunc, mem, heap)               \
   int32 *new_flags = nil;                                                      \
   int32 j = 1;                                                                 \
   {                                                                            \
@@ -281,17 +281,17 @@ static const double __ac_HASH_UPPER = 0.77;
     if (set->size >= (int32)(new_n_buckets * __ac_HASH_UPPER + 0.5))           \
       j = 0;                                                                   \
     else {                                                                     \
-      new_flags = alloc(h, __ac_fsize(new_n_buckets), sizeof(int32));          \
+      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 = alloc(h, new_n_buckets, sizeof(key_t));              \
+        key_t *new_keys = mem.alloc(heap, new_n_buckets, sizeof(key_t));       \
         if (!new_keys) {                                                       \
-          free(h, new_flags);                                                  \
+          mem.free(heap, new_flags);                                           \
           return -1;                                                           \
         }                                                                      \
         memcpy(new_keys, set->keys, sizeof(key_t) * set->n_buckets);           \
-        free(h, set->keys);                                                    \
+        mem.free(heap, set->keys);                                             \
         set->keys = new_keys;                                                  \
       }                                                                        \
     }                                                                          \
@@ -325,12 +325,12 @@ static const double __ac_HASH_UPPER = 0.77;
       }                                                                        \
     }                                                                          \
     if (set->n_buckets > new_n_buckets) { /* shrink the hash table */          \
-      key_t *new_keys = alloc(h, new_n_buckets, sizeof(key_t));                \
+      key_t *new_keys = mem.alloc(heap, new_n_buckets, sizeof(key_t));         \
       memcpy(new_keys, set->keys, sizeof(key_t) * set->n_buckets);             \
-      free(h, set->keys);                                                      \
+      mem.free(heap, set->keys);                                               \
       set->keys = new_keys;                                                    \
     }                                                                          \
-    free(h, set->flags); /* free the working space */                          \
+    mem.free(heap, set->flags); /* free the working space */                   \
     set->flags      = new_flags;                                               \
     set->n_buckets  = new_n_buckets;                                           \
     set->n_occupied = set->size;                                               \
@@ -391,10 +391,10 @@ static const double __ac_HASH_UPPER = 0.77;
       ++set->size;                                                             \
     } else                                                                     \
       *err = 0;                                                                \
-    return x                                                                  
+    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;                                                             \
-    }                                                                          
+    }