#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);
void *mem·rfindc(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 mem·BufHead
{
    vlong len;
    vlong cap;
    byte  buf[];
} mem·BufHead;

#define mem·buffer(x)        x*
#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 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 mem·bufreset(b)      ((b) ? (mem·bufhdr(b)->len=0) : 0)

#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 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* mem·bufgrow(void*, vlong, vlong);

// -----------------------------------------------------------------------------
// memory allocation

/* interfaces */
typedef struct mem·Pool  mem·Pool;
typedef struct mem·Arena mem·Arena;

typedef struct mem·Allocator {
    void *(*alloc)(void *heap, uintptr n, uintptr size);
    void *(*realloc)(void *heap, void *ptr, uintptr n, uintptr size);
    void  (*free)(void *heap, void *ptr);
} mem·Allocator;

/* standard allocator */
extern mem·Allocator base·Memory;

/* pool allocator (manages free list) */
mem·Pool  *mem·makepool(mem·Allocator from, void*, char *name, int flags, intptr maxsize, intptr mincore);
void       mem·freepool(mem·Pool *);

void      *mem·poolalloc(mem·Pool *, long n, uintptr size);
void      *mem·poolrealloc(mem·Pool *, void *, long n, uintptr size);
void       mem·poolfree(mem·Pool *, void *);

/* simple arena allocator (heterogeneous bump) */
mem·Arena *mem·makearena(mem·Allocator from, void*);
void      *mem·arenaalloc(mem·Arena *A, long n, ulong size); 
void       mem·freearena(mem·Arena *A);

extern mem·Allocator mem·ArenaAllocator;