* ErlAtom is now distinct string

* ErlCharlist is now represented with seq[char]
* ErlBinary is now represented with seq[byte]

Author: wltsmrz

nimler/bindings/erl_nif.nim

@@ -1,3 +1,4 @@
+import std/hashes
 import ../erl_sys_info
 
 const dep_header_name = "erl_nif.h"
@@ -279,14 +280,26 @@ func enif_now_time*(a1: ptr ErlNifEnv): ErlNifTerm {.c_dep_proc, min_nif_version
 func enif_fprintf*(a1: File; a2: cstring): bool {.varargs, c_dep_proc.}
 func enif_snprintf*(a1: ptr char, a2: cuint; a3: cstring): bool {.varargs, c_dep_proc, min_nif_version(2, 11).}
 
-proc `==`*(a, b: ErlNifTerm): bool {.borrow.}
-
-func `$`*(x: ErlNifTerm): string =
+proc `==`*(a, b: ErlNifTerm): bool =
+  enif_is_identical(a, b)
+proc hash*(x: ErlNifTerm): Hash {.borrow.}
+proc `$`*(x: ErlNifTerm): string =
   when (nifMajor, nifMinor) >= (2, 11):
-    let str_len = 100.cuint
+    let str_len = 100
     result = newString(str_len)
-    if not enif_snprintf(result[0].addr, str_len, "ErlNifTerm:%T", x):
-      result = "ErlNifTerm"
+    if enif_snprintf(result[0].addr, str_len.cuint, "ErlNifTerm:%T", x):
+      var i = 0
+      while result[i] != '\0': inc(i)
+      result.setLen(i)
+      if result.len == str_len.int - 1:
+        result[^3 ..< result.len] = "..."
   else:
     result = "ErlNifTerm"
 
+type ErlAtom* = distinct string
+
+proc `$`*(x: ErlAtom): string {.borrow.}
+proc `==`*(a: ErlAtom, b: ErlAtom): bool {.borrow.}
+proc hash*(x: ErlAtom): Hash {.borrow.}
+proc len*(x: ErlAtom): int {.borrow.}
+

nimler/codec.nim

@@ -1,7 +1,6 @@
 import std/macros
 import std/typetraits
 import std/tables
-import std/hashes
 import bindings/erl_nif
 
 import std/options
@@ -11,17 +10,10 @@ using
   env: ptr ErlNifEnv
   term: ErlNifTerm
 
-type
-  ErlAtom* = object
-    val*: string
-  ErlCharlist* = seq[char]
-  ErlBinary* = ErlNifBinary
-
-const AtomOk* = ErlAtom(val: "ok")
-const AtomError* = ErlAtom(val: "error")
-const AtomTrue* = ErlAtom(val: "true")
-const AtomFalse* = ErlAtom(val: "false")
-const AtomMapEncodeException = ErlAtom(val: "nimler: fail to encode map")
+const AtomOk* = ErlAtom("ok")
+const AtomError* = ErlAtom("error")
+const AtomTrue* = ErlAtom("true")
+const AtomFalse* = ErlAtom("false")
 
 macro generic_params(T: typedesc): untyped =
   result = newNimNode(nnkTupleConstr)
@@ -43,10 +35,6 @@ macro generic_params(T: typedesc): untyped =
       else:
         error "wrong kind: " & $impl.kind
 
-func hash*(a: ErlAtom): Hash {.inline.} =
-  result = a.val.hash
-  result = !$result
-
 # int
 func from_term*(env; term; T: typedesc[int]): Option[T] {.inline.} =
   var res: int
@@ -115,27 +103,27 @@ func from_term*(env; term; T: typedesc[ErlAtom]): Option[T] {.inline.} =
   var atom_len: cuint
   if enif_get_atom_length(env, term, addr(atom_len), ERL_NIF_LATIN1):
     let buf_len = atom_len + 1
-    var atom = ErlAtom(val: newString(atom_len))
-    if enif_get_atom(env, term, addr(atom.val[0]), buf_len, ERL_NIF_LATIN1) == cint(buf_len):
-      result = some(atom)
+    var atom = newString(atom_len)
+    if enif_get_atom(env, term, addr(atom[0]), buf_len, ERL_NIF_LATIN1) == cint(buf_len):
+      result = some(ErlAtom(atom))
 
 func to_term*(env; V: ErlAtom): ErlNifTerm {.inline.} =
   var res: ErlNifTerm
-  if enif_make_existing_atom_len(env, V.val, len(V.val).csize_t, addr(res)):
+  if enif_make_existing_atom_len(env, V.cstring, len(V).csize_t, addr(res)):
     result = res
   else:
-    result = enif_make_atom_len(env, V.val, len(V.val).csize_t)
+    result = enif_make_atom_len(env, V.cstring, len(V).csize_t)
 
 # charlist
-func from_term*(env; term; T: typedesc[ErlCharlist]): Option[T] {.inline.} =
+func from_term*(env; term; T: typedesc[seq[char]]): Option[T] {.inline.} =
   var string_len: cuint
   if enif_get_list_length(env, term, addr(string_len)):
     let buf_len = string_len + 1
     var string_buf = newSeq[char](string_len)
     if enif_get_string(env, term, addr(string_buf[0]), buf_len, ERL_NIF_LATIN1) == cint(buf_len):
       result = some(string_buf)
 
-func to_term*(env; V: ErlCharlist): ErlNifTerm {.inline.} =
+func to_term*(env; V: seq[char]): ErlNifTerm {.inline.} =
   enif_make_string_len(env, V, ERL_NIF_LATIN1)
 
 # string
@@ -155,16 +143,21 @@ func to_term*(env; V: string): ErlNifTerm {.inline.} =
   result = term
 
 # binary
-func from_term*(env; term; T: typedesc[ErlBinary]): Option[T] {.inline.} =
-  var bin: ErlNifBinary
-  if enif_inspect_binary(env, term, addr(bin)):
+func from_term*(env; term; T: typedesc[seq[byte]]): Option[T] {.inline.} =
+  var erl_bin: ErlNifBinary
+  if enif_inspect_binary(env, term, addr(erl_bin)):
+    var bin = newSeq[byte](erl_bin.size)
+    copyMem(addr(bin[0]), erl_bin.data, erl_bin.size)
     result = some(bin)
 
-func to_term*(env; V: ErlBinary): ErlNifTerm {.inline.} =
-  enif_make_binary(env, unsafeAddr(V))
+func to_term*(env; V: seq[byte]): ErlNifTerm {.inline.} =
+  var term: ErlNifTerm
+  var bin = cast[ptr byte](enif_make_new_binary(env, len(V).csize_t, term.addr))
+  copyMem(bin, unsafeAddr(V[0]), len(V))
+  result = term
 
 # list
-func from_term*(env; term; T: typedesc[seq]): Option[T] {.inline.} =
+func from_term*(env; term; T: typedesc[seq]): Option[T] =
   if not enif_is_list(env, term):
     return none(T)
   var res: T
@@ -179,7 +172,7 @@ func from_term*(env; term; T: typedesc[seq]): Option[T] {.inline.} =
     cursor = tail
   return some(res)
 
-func to_term*(env; V: seq): ErlNifTerm {.inline.} =
+func to_term*(env; V: seq): ErlNifTerm =
   var v = newSeqOfCap[ErlNifTerm](V.len)
   for el in V:
     v.add(env.to_term(el))
@@ -204,19 +197,17 @@ func from_term*(env; term; T: typedesc[tuple]): Option[T] =
   return some(res)
 
 macro to_term*(env: typed; V: tuple): untyped =
-  case V.kind:
-    of nnkSym:
-      let tup_len = V.getTypeImpl().len
-      result = newCall("enif_make_tuple", env, newLit(tup_len))
-      for i in 0 ..< tup_len:
-        let v = quote do: `V`[`i`]
-        result.add(newCall("to_term", env, v))
-    of nnkTupleConstr:
-      result = quote do:
-        let erl_tup = `V`
-        to_term(env, erl_tup)
-    else:
-      error "wrong kind: " & $V.kind
+  expectKind(V, {nnkSym, nnkTupleConstr})
+  if V.kind == nnkSym:
+    let tup_len = V.getTypeImpl().len
+    result = newCall("enif_make_tuple", env, newLit(tup_len))
+    for i in 0 ..< tup_len:
+      let v = quote do: `V`[`i`]
+      result.add(newCall("to_term", env, v))
+  elif V.kind == nnkTupleConstr:
+    result = quote do:
+      let erl_tup = `V`
+      to_term(env, erl_tup)
 
 # map/table
 func from_term*(env; term; T: typedesc[Table]): Option[T] =
@@ -243,10 +234,10 @@ func to_term*(env; V: Table): ErlNifTerm =
   for k, v in V:
     keys.add(env.to_term(k))
     vals.add(env.to_term(v))
-  var map: ErlNifTerm
-  if not enif_make_map_from_arrays(env, addr(keys[0]), addr(vals[0]), cuint(keys.len), addr(map)):
-    return enif_raise_exception(env, env.to_term(AtomMapEncodeException))
-  return map
+  var res: ErlNifTerm
+  if not enif_make_map_from_arrays(env, addr(keys[0]), addr(vals[0]), cuint(keys.len), addr(res)):
+    return enif_raise_exception(env, env.to_term(ErlAtom("fail to encode map")))
+  return res
 
 # result
 template result_tuple*(env; res_type: ErlnifTerm; terms: varargs[ErlNifTerm]): untyped =
@@ -256,3 +247,4 @@ template ok*(env; terms: varargs[ErlNifTerm]): untyped =
   result_tuple(env, env.to_term(AtomOk), terms)
 
 template error*(env; terms: varargs[ErlNifTerm]): untyped =
+  result_tuple(env, env.to_term(AtomError), terms)

tests/codec/nif.nim

@@ -47,13 +47,13 @@ func codec_double(env; argc; argv): ErlNifTerm {.nif, arity: 1.} =
 
 func codec_atom(env, argc, argv): ErlNifTerm {.nif, arity: 1.} =
   let a1 = env.from_term(argv[0], ErlAtom).get()
-  doAssert(a1 == ErlAtom(val: "test"))
+  doAssert(a1 == ErlAtom("test"))
   return env.to_term(a1)
 
 func codec_charlist(env, argc, argv): ErlNifTerm {.nif, arity: 1.} =
-  let a1 = env.from_term(argv[0], ErlCharlist).get()
+  let a1 = env.from_term(argv[0], seq[char]).get()
   doAssert(a1 == @"test")
-  doAssert(env.from_term(env.to_term(@"test2"), ErlCharlist).get() == @"test2")
+  doAssert(env.from_term(env.to_term(@"test2"), seq[char]).get() == @"test2")
   return env.to_term(a1)
 
 func codec_string(env, argc, argv): ErlNifTerm {.nif, arity: 1.} =
@@ -63,8 +63,8 @@ func codec_string(env, argc, argv): ErlNifTerm {.nif, arity: 1.} =
   return env.to_term(a1)
 
 func codec_binary(env, argc, argv): ErlNifTerm {.nif, arity: 1.} =
-  let a1 = env.from_term(argv[0], ErlBinary).get()
-  doAssert(cast[cstring](a1.data) == "test".cstring)
+  let a1 = env.from_term(argv[0], seq[byte]).get()
+  doAssert(a1 == @[116.byte, 101, 115, 116, 0])
   return env.to_term(a1)
 
 func codec_list_int(env, argc, argv): ErlNifTerm {.nif, arity: 1.} =
@@ -85,7 +85,7 @@ func codec_tuple(env, argc, argv): ErlNifTerm {.nif, arity: 1.} =
   return env.to_term(a1)
 
 func codec_map(env, argc, argv): ErlNifTerm {.nif, arity: 3.} =
-  let a1 = env.from_term(argv[0], Table[ErlCharlist, int]).get()
+  let a1 = env.from_term(argv[0], Table[seq[char], int]).get()
   let a2 = env.from_term(argv[1], Table[string, int]).get()
   let a3 = env.from_term(argv[2], Table[ErlAtom, string]).get()
   return env.to_term((a1, a2, a3))

tests/message/NimlerWrapper.ex

@@ -4,4 +4,4 @@ defmodule NimlerMessage do
 
   def send_message(_,_), do: exit(:nif_library_not_loaded)
   def send_message_caller(_), do: exit(:nif_library_not_loaded)
-end
+end