Chore: more explicit namespace for memory buffer

3 files changed, 48 insertions, 43 deletions

diff --git a/include/base/memory.h b/include/base/memory.h
index d80b34c..dd00992 100644
--- a/include/base/memory.h
+++ b/include/base/memory.h
@@ -1,38 +1,49 @@
 #pragma once
 
 // ----------------------------------------------------------------------------
+// basic memory operations
+
+/* mem functions */
+int   mem·move(void *dst, uintptr size, void *src);
+int   mem·copy(void *dst, uintptr size, void *src);
+int   mem·compare(void *, uintptr size, void *);
+void *mem·findc(void *dst, uintptr len, int c);
+int   mem·set(void *dst, uintptr size, int val);
+int   mem·set64(void *dst, uintptr size, uint64 val);
+
+// ----------------------------------------------------------------------------
 // dynamic array
 
-typedef struct BufHdr
+typedef struct mem·BufHead
 {
     vlong len;
     vlong cap;
     byte  buf[];
-} BufHdr;
+} mem·BufHead;
 
-#define bufhdr(b)        ((BufHdr*)((uint8*)(b)-offsetof(BufHdr, buf)))
-#define buflen(b)        ((b) ? (bufhdr(b)->len) : 0)
-#define bufcap(b)        ((b) ? (bufhdr(b)->cap) : 0)
-#define bufend(b)        ((b) + buflen(b))
-#define bufsize(b)       ((b) ? (buflen(b) * sizeof((b)[0])) : 0)
+#define mem·bufhdr(b)        ((mem·BufHead*)((uint8*)(b)-offsetof(mem·BufHead, buf)))
+#define mem·buflen(b)        ((b) ? (mem·bufhdr(b)->len) : 0)
+#define mem·bufcap(b)        ((b) ? (mem·bufhdr(b)->cap) : 0)
+#define mem·bufend(b)        ((b) + mem·buflen(b))
+#define mem·bufsize(b)       ((b) ? (mem·buflen(b) * sizeof((b)[0])) : 0)
 
-#define buffree(b)       ((b) ? (free(bufhdr(b)), (b) = nil) : 0)
-#define buffit(b, n)     ((n) <= bufcap(b) ? 0 : ((b) = ·bufgrow((b), (n), sizeof(*(b)))))
+#define mem·buffree(b)       ((b) ? (free(mem·bufhdr(b)), (b) = nil) : 0)
+#define mem·buffit(b, n)     ((n) <= mem·bufcap(b) ? 0 : ((b) = mem·bufgrow((b), (n), sizeof(*(b)))))
 
-#define bufpush(b, ...)  (buffit((b), 1 + buflen(b)), (b)[bufhdr(b)->len++] = (__VA_ARGS__))
-#define bufaddn(b, n)    (buffit(b, buflen(b)+n), bufhdr(b)->len += n, b+bufhdr(b)->len-n)
+#define mem·bufpush(b, ...)  (mem·buffit((b), 1 + mem·buflen(b)), (b)[mem·bufhdr(b)->len++] = (__VA_ARGS__))
+#define mem·bufaddn(b, n)    (mem·buffit(b, mem·buflen(b)+n), mem·bufhdr(b)->len += n, b+mem·bufhdr(b)->len-n)
 
-#define bufpop(b)         ((b)[--bufhdr(b)->len])
-#define bufdel(b, i)      bufdeln((b), (i), 1)
-#define bufdeln(b, i, n)  (memmove((b)+(i), (b)+(i)+(n), sizeof(*(b))*(bufhdr(b)->len-(n)-(i)), bufhdr(b)->len -= (n))
-#define bufdelswap(b, i)  ((b)[i] = bufend(b)[-1], bufhdr(b)->len-=1)
+#define mem·bufpop(b)         ((b)[--mem·bufhdr(b)->len])
+#define mem·bufdel(b, i)      mem·bufdeln((b), (i), 1)
+#define mem·bufdeln(b, i, n)  (mem·move((b)+(i), (b)+(i)+(n), sizeof(*(b))*(mem·bufhdr(b)->len-(n)-(i)), mem·bufhdr(b)->len -= (n))
+#define mem·bufdelswap(b, i)  ((b)[i] = mem·bufend(b)[-1], mem·bufhdr(b)->len-=1)
 
-void* ·bufgrow(void*, vlong, vlong);
+void* mem·bufgrow(void*, vlong, vlong);
 
 // -----------------------------------------------------------------------------
 // memory allocation
 
-/* allocator interface */
+/* interfaces */
 typedef struct mem·Allocator {
     void *(*alloc)(void *heap, uint n, ulong size);
     void  (*free)(void *heap, void *ptr);
@@ -56,11 +67,3 @@ void      *mem·arenaalloc(mem·Arena *A, uint n, ulong size);
 void       mem·freearena(mem·Arena *A);
 
 extern mem·Allocator mem·ArenaAllocator;
-
-/* mem functions */
-int   mem·move(void *dst, uintptr size, void *src);
-int   mem·copy(void *dst, uintptr size, void *src);
-int   mem·compare(void *, uintptr size, void *);
-void *mem·findc(void *dst, uintptr len, int c);
-int   mem·set(void *dst, uintptr size, int val);
-int   mem·set64(void *dst, uintptr size, uint64 val);
diff --git a/src/base/mem/buffer.c b/src/base/mem/buffer.c
index b684d35..448f41b 100644
--- a/src/base/mem/buffer.c
+++ b/src/base/mem/buffer.c
@@ -2,23 +2,23 @@
 
 /* Grow to particular size */
 void*
-·bufgrow(void* buf, vlong newLen, vlong eltsize)
+mem·bufgrow(void* buf, vlong newLen, vlong eltsize)
 {
-    assert(bufcap(buf) <= (SIZE_MAX - 1) / 2);
+    assert(mem·bufcap(buf) <= (SIZE_MAX - 1) / 2);
 
-    vlong newCap = MAX(16, MAX(1 + 2 * bufcap(buf), newLen));
+    vlong newCap = MAX(16, MAX(1 + 2 * mem·bufcap(buf), newLen));
 
     assert(newLen <= newCap);
-    assert(newCap <= (SIZE_MAX - offsetof(BufHdr, buf)) / eltsize);
+    assert(newCap <= (SIZE_MAX - offsetof(mem·BufHead, buf)) / eltsize);
 
-    vlong newSize = offsetof(BufHdr, buf) + newCap * eltsize;
+    vlong newSize = offsetof(mem·BufHead, buf) + newCap * eltsize;
 
-    BufHdr* newHdr;
+    mem·BufHead* newHdr;
     if (buf) {
-        newHdr = bufhdr(buf);
-        newHdr = (BufHdr*)realloc((void*)newHdr, newSize);
+        newHdr = mem·bufhdr(buf);
+        newHdr = (mem·BufHead*)realloc((void*)newHdr, newSize);
     } else {
-        newHdr      = (BufHdr*)malloc(newSize);
+        newHdr      = (mem·BufHead*)malloc(newSize);
         newHdr->len = 0;
     }
 
@@ -27,8 +27,9 @@ void*
 }
 
 /* Pop out a value */
+#if 0
 void
-·bufdel(void *buf, int i, vlong eltsize)
+mem·bufdel(void *buf, int i, vlong eltsize)
 {
     int n;
     byte *b;
@@ -36,10 +37,11 @@ void
     assert(eltsize < sizeof(stk));
 
     b = (byte*)buf;
-    if(n = buflen(buf), i < n) {
+    if(n = mem·buflen(buf), i < n) {
         memcpy(stk, b+eltsize*i, eltsize);
         memcpy(b+eltsize*i, b+eltsize*(i+1), eltsize*(n-i-1));
         memcpy(b+eltsize*(n-1), stk, eltsize);
     } 
-    bufhdr(buf)->len--;
+    mem·bufhdr(buf)->len--;
 }
+#endif
diff --git a/src/base/string/split.c b/src/base/string/split.c
index 9d5d440..6b0a9fd 100644
--- a/src/base/string/split.c
+++ b/src/base/string/split.c
@@ -14,26 +14,26 @@ string·split(string s, byte* tok)
     if(sL == 0 || tokL == 0)
         return nil;
 
-    buffit(fields, 5);
+    mem·buffit(fields, 5);
 
     for(vlong i = 0; i < sL - tokL; i++){
         if((tokL == 1 && s[i] == tokL) || !memcmp(s + i, tok, tokL)){
-            bufpush(fields, string·makelen(s + start, i - start));
-            if(fields[buflen(fields) - 1] == nil) goto cleanup;
+            mem·bufpush(fields, string·makelen(s + start, i - start));
+            if(fields[mem·buflen(fields) - 1] == nil) goto cleanup;
 
             start = i + tokL;
             i += tokL - 1;
         }
     }
 
-    bufpush(fields, string·makelen(s + start, sL - start));
+    mem·bufpush(fields, string·makelen(s + start, sL - start));
 
     return fields;
 
 cleanup:
-    for(vlong i = 0; i < buflen(fields); i++)
+    for(vlong i = 0; i < mem·buflen(fields); i++)
         string·free(fields[i]);
 
-    buffree(fields);
+    mem·buffree(fields);
     return nil;
 }