From aabb2b86debd83d13a63dadad500c174788533cd Mon Sep 17 00:00:00 2001
From: Eduardo Bart <edub4rt@gmail.com>
Date: Fri, 31 Jan 2020 14:57:23 -0300
Subject: [PATCH] Implement low level memory management APIs

---
 lib/memory.nelua        | 267 +++++++++++++++++++++++++++++++++-------
 tests/memory_test.nelua | 255 +++++++++++++++++++++++++++++++++++---
 2 files changed, 465 insertions(+), 57 deletions(-)

diff --git a/lib/memory.nelua b/lib/memory.nelua
index fbf58bd1..96573661 100644
--- a/lib/memory.nelua
+++ b/lib/memory.nelua
@@ -2,70 +2,251 @@
 ## modname = 'nelua'
 ## nohashcodenames = true
 
-## cinclude '<stdlib.h>'
-## cinclude '<string.h>'
+local function memcpy(dest: pointer, src: pointer, n: csize): pointer <cimport'memcpy',cinclude'<string.h>',nodecl> end
+local function memmove(dest: pointer, src: pointer, n: csize): pointer <cimport'memmove',cinclude'<string.h>',nodecl> end
+local function memset(s: pointer, c: cint, n: csize): pointer <cimport'memset',cinclude'<string.h>',nodecl> end
+local function memcmp(s1: pointer, s2: pointer, n: csize): cint <cimport'memcmp',cinclude'<string.h>',nodecl> end
+local function memchr(s: pointer, c: cint, n: csize): pointer <cimport'memchr',cinclude'<string.h>',nodecl> end
 
-local function memcpy(dest: pointer, src: pointer, n: csize): pointer <cimport'memcpy',nodecl> end
-local function memmove(dest: pointer, src: pointer, n: csize): pointer <cimport'memmove',nodecl> end
-local function memset(s: pointer, c: cint, n: csize): pointer <cimport'memset',nodecl> end
-
-local function malloc(size: csize): pointer <cimport'malloc',nodecl> end
-local function calloc(nmemb: csize, size: csize): pointer <cimport'calloc',nodecl> end
-local function realloc(ptr: pointer, size: csize): pointer <cimport'realloc',nodecl> end
-local function free(ptr: pointer): void <cimport'free',nodecl> end
+local function malloc(size: csize): pointer <cimport'malloc',cinclude'<stdlib.h>',nodecl> end
+local function calloc(nmemb: csize, size: csize): pointer <cimport'calloc',cinclude'<stdlib.h>',nodecl> end
+local function realloc(ptr: pointer, size: csize): pointer <cimport'realloc',cinclude'<stdlib.h>',nodecl> end
+local function free(ptr: pointer): void <cimport'free',cinclude'<stdlib.h>',nodecl> end
 
 global memory = @record{}
 
-function memory.allocnoinit(size: usize): span(byte)
-  assert(size > 0)
-  local data = (@byte*)(malloc(size))
-  assert(data)
-  return (@span(byte)) { data, size }
+--------------------------------------------------------------------------------
+-- raw pointer functions
+
+function memory.alloc(size: usize): pointer
+  check(size > 0_u, 'memory.alloc: size cannot be zero')
+  local p: pointer = malloc(size)
+  check(p, 'memory.alloc: allocation fail')
+  return p
 end
 
-function memory.alloc(size: usize): span(byte)
-  assert(size > 0)
-  local data = (@byte*)(calloc(1, size))
-  assert(data)
-  return (@span(byte)) { data, size }
+function memory.alloc0(size: usize): pointer
+  check(size > 0_u, 'memory.alloc0: size must be greater than 0')
+  local p: pointer = calloc(size, 1)
+  check(p, 'memory.alloc0: allocation fail')
+  return p
 end
 
-function memory.reallocnoinit(s: span(byte)*, size: usize)
-  assert(size > 0)
-  s.data = (@byte*)(realloc(s.data, size))
-  assert(s.data)
-  s.size = size
+function memory.realloc(p: pointer, size: usize): pointer
+  check(size > 0_u, 'memory.realloc: size must be greater than 0')
+  p = realloc(p, size)
+  check(size == 0 or p, 'memory.realloc: allocation fail')
+  return p
 end
 
-function memory.realloc(s: span(byte)*, size: usize)
-  assert(size > 0)
-  s.data = (@byte*)(realloc(s.data, size))
-  assert(s.data)
-  if size > s.size then
-    memset(&s[s.size], 0, size - s.size)
+function memory.realloc0(p: pointer, newsize: usize, oldsize: usize): pointer
+  check(newsize > 0_u, 'memory.realloc0: size must be greater than 0')
+  p = realloc(p, newsize)
+  check(newsize == 0_u or p, 'memory.realloc0: allocation fail')
+  if likely(newsize > oldsize) then
+    memset(&(@byte[0]*)(p)[oldsize], 0, newsize - oldsize)
   end
-  s.size = size
+  return p
+end
+
+function memory.dealloc(p: pointer)
+  free(p)
+end
+
+function memory.copy(dest: pointer, src: pointer, size: usize)
+  check(dest and src, 'memory.copy: invalid pointer')
+  memcpy(dest, src, size)
+end
+
+function memory.move(dest: pointer, src: pointer, size: usize)
+  check(dest and src, 'memory.move: invalid pointer')
+  memmove(dest, src, size)
+end
+
+function memory.set(dest: pointer, x: byte, size: usize)
+  check(dest, 'memory.set: invalid pointer')
+  memset(dest, x, size)
+end
+
+function memory.compare(a: pointer, b: pointer, size: usize): int32
+  check(a and b, 'memory.move: invalid pointer')
+  return memcmp(a, b, size)
+end
+
+function memory.equals(a: pointer, b: pointer, size: usize): boolean
+  check(a and b, 'memory.equals: invalid pointer')
+  return memcmp(a, b, size) == 0
 end
 
-function memory.dealloc(s: span(byte)*)
-  if s.size == 0 then
-    return
+function memory.scan(p: pointer, x: byte, size: usize): pointer
+  check(p, 'memory.scan: invalid pointer')
+  return memchr(p, x, size)
+end
+
+function memory.contains(p: pointer, x: byte, size: usize): boolean
+  check(p, 'memory.contains: invalid pointer')
+  return memchr(p, x, size) ~= nilptr
+end
+
+--------------------------------------------------------------------------------
+-- compile time checks utilities
+
+##[[
+local function check_ptrspan_subtype(v)
+  staticassert(v.type:is_pointer() and v.type.subtype:is_span(),
+    "in argument '%s': expected 'span(T)*' but got type '%s'",
+    v.name, v.type)
+  return v.type.subtype.subtype
+end
+
+local function check_span(v)
+  local stype = v.type:is_pointer() and v.type.subtype or v.type
+  staticassert(stype:is_span(),
+    "in argument '%s': expected 'span(T)' or 'span(T)*' but got type '%s'",
+    v.name, v.type)
+  return stype
+end
+
+local function check_type_match(a, b)
+  staticassert(a.type == b.type,
+    "argument '%s' type '%s' differs from argument '%s' type '%s",
+    a.name, b.name, a.type, b.type)
+end
+
+local function check_span_subtype_match(s, x)
+  local stype = check_span(s)
+  staticassert(stype.subtype == x.type,
+    "in argument '%s': type '%s' differs from argument '%s' type '%s",
+    s.name, x.name, stype.subtype, x.type)
+end
+]]
+
+--------------------------------------------------------------------------------
+-- span functions
+
+function memory.spanalloc(T: type, size: usize)
+  local s: span(T)
+  if likely(size > 0_u) then
+    s.data = (@T*)(malloc(size * #T))
+    check(s.data, 'memory.spanalloc: allocation fail')
+    s.size = size
   end
+  return s
+end
+
+function memory.spanalloc0(T: type, size: usize)
+  local s: span(T)
+  if likely(size > 0_u) then
+    s.data = (@T*)(calloc(size, #T))
+    check(s.data, 'memory.spanalloc0: allocation fail')
+    s.size = size
+  end
+  return s
+end
+
+function memory.spanrealloc(s: auto, size: usize)
+  local T: type = #[check_ptrspan_subtype(s)]#
+  if unlikely(size == 0) then
+    free(s.data)
+    s.data = nilptr
+    s.size = 0
+  else
+    s.data = (@T*)(realloc(s.data, size * #T))
+    check(s.data, 'memory.spanrealloc0: allocation fail')
+    s.size = size
+  end
+end
+
+function memory.spanrealloc0(s: auto, size: usize)
+  local T: type = #[check_ptrspan_subtype(s)]#
+  if unlikely(size == 0) then
+    free(s.data)
+    s.data = nilptr
+    s.size = 0
+  else
+    s.data = (@T*)(realloc(s.data, size * #T))
+    check(s.data, 'memory.spanrealloc0: allocation fail')
+    if likely(size > s.size) then
+      memset(&s[s.size], 0, (size - s.size) * #T)
+    end
+    s.size = size
+  end
+end
+
+function memory.spandealloc(s: auto)
+  ## check_ptrspan_subtype(s)
   free(s.data)
   s.data = nilptr
   s.size = 0
 end
 
-function memory.copy(dest: span(byte), src: span(byte))
-  assert(dest.size >= src.size)
-  memcpy(dest.data, src.data, src.size)
+function memory.spancopy(dest: auto, src: auto)
+  local T: type = #[check_span(dest).subtype]#
+  ## check_type_match(dest, src)
+  check(dest.size == src.size, 'memory.spancopy: span sizes must be equal')
+  if likely(src.size > 0_u) then
+    memcpy(dest.data, src.data, src.size * #T)
+  end
 end
 
-function memory.move(dest: span(byte), src: span(byte))
-  assert(dest.size >= src.size)
-  memcpy(dest.data, src.data, src.size)
+function memory.spanmove(dest: auto, src: auto)
+  local T: type = #[check_span(dest).subtype]#
+  ## check_type_match(dest, src)
+  check(dest.size == src.size, 'memory.spanmove: span sizes must be equal')
+  if likely(src.size > 0_u) then
+    memmove(dest.data, src.data, src.size * #T)
+  end
 end
 
-function memory.set(dest: span(byte), x: byte)
-  memset(dest.data, x, dest.size)
+function memory.spanset(dest: auto, x: auto)
+  ## check_span_subtype_match(dest, x)
+  if likely(dest.size > 0_u) then
+    for i:usize=0,<dest.size do
+      dest[i] = x
+    end
+  end
+end
+
+function memory.spancompare(a: auto, b: auto): int32
+  ## check_span(a) check_type_match(a, b)
+  local size: usize = a.size < b.size and a.size or b.size
+  local ret: int32
+  if likely(size > 0_u) then
+    ret = memcmp(a.data, b.data, size)
+  end
+  if ret == 0 and a.size ~= b.size then
+    ret = a.size < b.size and -1_i32 or 1_i32
+  end
+  return ret
+end
+
+function memory.spanequals(a: auto, b: auto): boolean
+  ## check_span(a) check_type_match(a, b)
+  local ret: boolean = a.size == b.size
+  if ret and likely(a.size > 0_u) then
+    ret = memcmp(a.data, b.data, a.size) == 0
+  end
+  return ret
+end
+
+function memory.spanscan(s: auto, x: auto): integer
+  ## check_span_subtype_match(s, x)
+  local T: type = #[x.type]#
+  for i:usize=0,<s.size do
+    if memcmp(&s[i], &x, #T) == 0 then
+      return (@integer)(i)
+    end
+  end
+  return -1
+end
+
+function memory.spancontains(s: auto, x: auto): boolean
+  ## check_span_subtype_match(s, x)
+  local T: type = #[x.type]#
+  for i:usize=0,<s.size do
+    if memcmp(&s[i], &x, #T) == 0 then
+      return true
+    end
+  end
+  return false
 end
diff --git a/tests/memory_test.nelua b/tests/memory_test.nelua
index 3e963500..d28d7131 100644
--- a/tests/memory_test.nelua
+++ b/tests/memory_test.nelua
@@ -1,23 +1,250 @@
 ## strict = true
+## modname = 'test'
+## nohashcodenames = true
+--## cflags '-fsanitize=address -fsanitize=undefined -fsanitize=leak'
 
 require 'memory'
 
-local function assertmem(s: span(byte), x: byte)
-  for i=0_usize,<s.size do
-    assert(s[i] == x)
-  end
+-- utilities
+local vec2 = @record{x: integer, y: integer}
+
+--------------------------------------------------------------------------------
+-- raw pointers
+
+do -- alloc and dealloc
+  local p = memory.alloc(4)
+  assert(p)
+  memory.dealloc(p)
+  p = nilptr
+  memory.dealloc(p)
+end
+
+do -- alloc0
+  local p = (@vec2*)(memory.alloc0(#@vec2))
+  assert(p)
+  assert(p.x == 0 and p.y == 0)
+  memory.dealloc(p)
 end
 
-local mem = memory.alloc(4)
-assert(mem.size == 4)
-assertmem(mem, 0)
+do -- realloc
+  local p = memory.alloc(1)
+  assert(p)
+  p = memory.realloc(p, 4)
+  assert(p)
+  p = memory.realloc(p, 1)
+  memory.dealloc(p)
+end
 
-memory.realloc(mem, 8)
-assert(mem.size == 8)
-assertmem(mem, 0)
+do -- realloc0
+  local p = (@vec2[0]*)(memory.alloc0(#@vec2))
+  assert(p)
+  assert(p[0].x == 0 and p[0].y == 0)
+  p[0] = vec2{x=1, y=2}
+  p = (@vec2[0]*)(memory.realloc0(p, 2*#@vec2, #@vec2))
+  assert(p)
+  assert(p[0].x == 1 and p[0].y == 2)
+  assert(p[1].x == 0 and p[1].y == 0)
+  p = (@vec2[0]*)(memory.realloc0(p, #@vec2, #@vec2))
+  assert(p)
+  assert(p[0].x == 1 and p[0].y == 2)
+  p = (@vec2[0]*)(memory.realloc0(p, #@vec2, 0))
+  assert(p)
+  assert(p[0].x == 0 and p[0].y == 0)
+  memory.dealloc(p)
+end
 
-memory.set(mem, 0xff)
-assertmem(mem, 0xff)
+do -- copy
+  local pa = (@vec2*)(memory.alloc0(#@vec2))
+  local pb = (@vec2*)(memory.alloc0(#@vec2))
+  $pa = {x=1,y=2}
+  memory.copy(pb, pa, #@vec2)
+  assert(pb.x == 1 and pb.y == 2)
+  memory.dealloc(pa)
+  memory.dealloc(pb)
+end
+
+do -- move
+  local p = (@vec2[0]*)(memory.alloc0(2*#@vec2))
+  local pa, pb = &p[0], &p[1]
+  $pa, $pb = {x=1,y=2}, {x=3,y=4}
+  memory.move(&((@integer[0]*)(p))[1], p, 3 * #@integer)
+  assert(pa.x == 1 and pa.y == 1 and pb.x == 2 and pb.y == 3)
+  memory.dealloc(p)
+end
+
+do -- set
+  local p = (@vec2*)(memory.alloc0(#@vec2))
+  memory.set(p, 0xff, #@vec2)
+  assert(p.x == 0xffffffffffffffff and p.y == 0xffffffffffffffff)
+  memory.dealloc(p)
+end
 
-memory.dealloc(mem)
-assert(mem.size == 0)
\ No newline at end of file
+do -- compare
+  local pa = (@vec2*)(memory.alloc0(#@vec2))
+  local pb = (@vec2*)(memory.alloc0(#@vec2))
+  assert(memory.compare(pa, pb, #@vec2) == 0)
+  pa.x = 1 pb.x = 2
+  assert(memory.compare(pa, pb, #@vec2) == -1)
+  pa.x = 2 pb.x = 1
+  assert(memory.compare(pa, pb, #@vec2) == 1)
+  pa.x = 2 pb.x = 2
+  assert(memory.compare(pa, pb, #@vec2) == 0)
+  memory.dealloc(pa)
+  memory.dealloc(pb)
+end
+
+do -- equals
+  local pa = (@vec2*)(memory.alloc0(#@vec2))
+  local pb = (@vec2*)(memory.alloc0(#@vec2))
+  assert(memory.equals(pa, pb, #@vec2))
+  pa.x = 1
+  assert(not memory.equals(pa, pb, #@vec2))
+  memory.dealloc(pa)
+  memory.dealloc(pb)
+end
+
+do -- scan
+  local p = (@vec2*)(memory.alloc0(#@vec2))
+  p.x = 1 p.y = 2
+  assert(memory.scan(p, 1, #@vec2) == &p.x)
+  assert(memory.scan(p, 2, #@vec2) == &p.y)
+  assert(memory.scan(p, 3, #@vec2) == nilptr)
+  memory.dealloc(p)
+end
+
+do -- contains
+  local p = (@vec2*)(memory.alloc0(#@vec2))
+  p.x = 1 p.y = 2
+  assert(memory.contains(p, 0, #@vec2))
+  assert(memory.contains(p, 1, #@vec2))
+  assert(memory.contains(p, 2, #@vec2))
+  assert(not memory.contains(p, 3, #@vec2))
+  memory.dealloc(p)
+end
+
+--------------------------------------------------------------------------------
+-- span
+
+do -- spanalloc and spandealloc
+  local p = memory.spanalloc(@vec2, 2)
+  assert(p.data ~= nilptr and p.size == 2)
+  memory.spandealloc(&p)
+  assert(p.data == nilptr and p.size == 0)
+  memory.spandealloc(&p)
+  assert(p.data == nilptr and p.size == 0)
+  p = memory.spanalloc(@vec2, 0)
+  assert(p.data == nilptr and p.size == 0)
+end
+
+do -- spanalloc0
+  local p = memory.spanalloc0(@vec2, 2)
+  assert(p.data ~= nilptr and p.size == 2)
+  assert(p[0].x == 0 and p[0].y == 0)
+  assert(p[1].x == 0 and p[1].y == 0)
+  memory.spandealloc(&p)
+  p = memory.spanalloc0(@vec2, 0)
+  assert(p.data == nilptr and p.size == 0)
+end
+
+do -- spanrealloc
+  local p = memory.spanalloc(@vec2, 1)
+  assert(p.data ~= nilptr and p.size == 1)
+  memory.spanrealloc(&p, 4)
+  assert(p.data ~= nilptr and p.size == 4)
+  memory.spanrealloc(&p, 1)
+  assert(p.data ~= nilptr and p.size == 1)
+  memory.spanrealloc(&p, 0)
+  assert(p.data == nilptr and p.size == 0)
+  memory.spandealloc(&p)
+  assert(p.data == nilptr and p.size == 0)
+end
+
+do -- spanrealloc0
+  local p = memory.spanalloc0(@vec2, 1)
+  assert(p.data ~= nilptr and p.size == 1)
+  assert(p[0].x == 0 and p[0].y == 0)
+  p[0] = vec2{x=1, y=2}
+  memory.spanrealloc0(&p, 2)
+  assert(p.data ~= nilptr and p.size == 2)
+  assert(p[0].x == 1 and p[0].y == 2)
+  assert(p[1].x == 0 and p[1].y == 0)
+  memory.spanrealloc0(&p, 1)
+  assert(p.data ~= nilptr and p.size == 1)
+  assert(p[0].x == 1 and p[0].y == 2)
+  memory.spanrealloc0(&p, 0)
+  assert(p.data == nilptr and p.size == 0)
+  memory.spandealloc(&p)
+end
+
+do -- spancopy
+  local pa = memory.spanalloc0(@vec2, 1)
+  local pb = memory.spanalloc0(@vec2, 1)
+  pa[0] = {x=1,y=2}
+  memory.spancopy(pb, pa)
+  assert(pb[0].x == 1 and pb[0].y == 2)
+  memory.spandealloc(&pa)
+  memory.spandealloc(&pb)
+end
+
+do -- spanmove
+  local p = memory.spanalloc0(@vec2, 2)
+  local pa, pb = &p[0], &p[1]
+  $pa, $pb = {x=1,y=2}, {x=3,y=4}
+  local sb = (@span(integer))({ data=&(((@integer[0]*)(p.data))[0]), size=3 })
+  local db = (@span(integer))({ data=&(((@integer[0]*)(p.data))[1]), size=3 })
+  memory.spanmove(db, sb)
+  --assert(pa.x == 1 and pa.y == 1 and pb.x == 2 and pb.y == 3)
+  memory.spandealloc(&p)
+end
+
+do -- spanset
+  local p = memory.spanalloc0(@vec2, 2)
+  memory.spanset(p, (@vec2){x=1,y=2})
+  assert(p[0].x == 1 and p[0].y == 2)
+  assert(p[1].x == 1 and p[1].y == 2)
+  memory.spandealloc(&p)
+end
+
+do -- spancompare
+  local pa = memory.spanalloc0(@vec2, 1)
+  local pb = memory.spanalloc0(@vec2, 1)
+  assert(memory.spancompare(pa, pb) == 0)
+  pa[0].x = 1 pb[0].x = 2
+  assert(memory.spancompare(pa, pb) == -1)
+  pa[0].x = 2 pb[0].x = 1
+  assert(memory.spancompare(pa, pb) == 1)
+  pa[0].x = 2 pb[0].x = 2
+  assert(memory.spancompare(pa, pb) == 0)
+  memory.spandealloc(&pa)
+  memory.spandealloc(&pb)
+end
+
+do -- spanequals
+  local pa = memory.spanalloc0(@vec2, 1)
+  local pb = memory.spanalloc0(@vec2, 1)
+  assert(memory.spanequals(pa, pb))
+  pa[0].x = 1
+  assert(not memory.spanequals(pa, pb))
+  memory.spandealloc(&pa)
+  memory.spandealloc(&pb)
+end
+
+do -- spanscan
+  local p = memory.spanalloc0(@vec2, 2)
+  p[0].x = 1 p[0].y = 2
+  p[1].x = 3 p[1].y = 4
+  assert(memory.spanscan(p, (@vec2){1,2}) == 0)
+  assert(memory.spanscan(p, (@vec2){3,4}) == 1)
+  assert(memory.spanscan(p, (@vec2){5,6}) == -1)
+  memory.spandealloc(&p)
+end
+
+do -- spancontains
+  local p = memory.spanalloc0(@vec2, 2)
+  p[0].x = 1 p[0].y = 2
+  p[1].x = 3 p[1].y = 4
+  assert(memory.spancontains(p, (@vec2){1,2}))
+  assert(memory.spancontains(p, (@vec2){3,4}))
+  assert(not memory.spancontains(p, (@vec2){5,6}))
+  memory.spandealloc(&p)
+end