feat(zmq): Simplified bindings.

zmq/zmq.odin

@@ -6,35 +6,35 @@ import "core:strings"
 
 foreign import lib "system:zmq"
 
-@(default_calling_convention = "c")
+Context :: distinct rawptr
+Socket :: distinct rawptr
+
+@(default_calling_convention = "c", link_prefix = "zmq_")
 foreign lib {
-	@(link_name = "zmq_ctx_new")
-	_ctx_new :: proc() -> rawptr ---
+	// TODO: Try to access errno directly
+	errno :: proc() -> c.int ---
+
+	ctx_new :: proc() -> Context ---
 	@(link_name = "zmq_ctx_term")
-	_ctx_term :: proc(ctx: rawptr) -> c.int ---
+	_ctx_term :: proc(ctx: Context) -> c.int ---
 	@(link_name = "zmq_socket")
-	_socket :: proc(ctx: rawptr, type: Socket_Type) -> rawptr ---
+	_socket :: proc(ctx: Context, type: Socket_Type) -> Socket ---
 	@(link_name = "zmq_close")
-	_close :: proc(s: rawptr) -> c.int ---
+	_close :: proc(s: Socket) -> c.int ---
 	@(link_name = "zmq_bind")
-	_bind :: proc(s: rawptr, addr: cstring) -> c.int ---
+	_bind :: proc(s: Socket, addr: cstring) -> c.int ---
 	@(link_name = "zmq_connect")
-	_connect :: proc(s: rawptr, addr: cstring) -> c.int ---
+	_connect :: proc(s: Socket, addr: cstring) -> c.int ---
 	@(link_name = "zmq_send")
-	_send :: proc(s: rawptr, buf: rawptr, len: c.size_t, flags: c.int) -> c.int ---
+	_send :: proc(s: Socket, buf: rawptr, len: c.size_t, flags: Flags) -> c.int ---
 	@(link_name = "zmq_recv")
-	_recv :: proc(s: rawptr, buf: rawptr, len: c.size_t, flags: c.int) -> c.int ---
-	@(link_name = "zmq_errno")
-	_errno :: proc() -> c.int ---
+	_recv :: proc(s: Socket, buf: rawptr, len: c.size_t, flags: Flags) -> c.int ---
 	@(link_name = "zmq_strerror")
 	_strerror :: proc(errnum: c.int) -> cstring ---
 	@(link_name = "zmq_version")
 	_version :: proc(major, minor, patch: ^c.int) ---
 }
 
-Context :: distinct rawptr
-Socket :: distinct rawptr
-
 Socket_Type :: enum c.int {
 	PAIR   = 0,
 	PUB    = 1,
@@ -73,23 +73,23 @@ Error :: union #shared_nil {
 	ZMQ_Error,
 }
 
-from_errno :: proc(raw: c.int) -> Error {
+last_error :: proc() -> Error {
+	raw := errno()
+
 	if raw >= HAUSNUMERO {
 		return ZMQ_Error(raw)
 	}
 	return os.Platform_Error(raw)
 }
 
-last_error :: proc() -> Error {return from_errno(_errno())}
-
-strerror :: proc(e: Error) -> string {
+strerror :: proc(e: Error) -> cstring {
 	switch v in e {
 	case os.Platform_Error:
-		return string(_strerror(c.int(v)))
+		return _strerror(c.int(v))
 	case ZMQ_Error:
-		return string(_strerror(c.int(v)))
+		return _strerror(c.int(v))
 	case:
-		return ""
+		return _strerror(0)
 	}
 }
 
@@ -99,46 +99,53 @@ version :: proc() -> (major, minor, patch: int) {
 	return int(ma), int(mi), int(pa)
 }
 
-ctx_new :: proc() -> Context {
-	return Context(_ctx_new())
-}
-
 ctx_term :: proc(ctx: Context) -> Error {
-	return _ctx_term(rawptr(ctx)) == 0 ? nil : last_error()
+	return _ctx_term(ctx) == 0 ? nil : last_error()
 }
 
-socket :: proc(ctx: Context, type: Socket_Type) -> (Socket, Error) {
-	s := _socket(rawptr(ctx), type)
+socket :: proc(ctx: Context, type: Socket_Type) -> (s: Socket, err: Error) {
+	s = _socket(ctx, type)
+
 	if s == nil {
-		return nil, last_error()
+		err = last_error()
 	}
-	return Socket(s), nil
+
+	return s, err
 }
 
 close :: proc(s: Socket) -> Error {
-	return _close(rawptr(s)) == 0 ? nil : last_error()
+	return _close(s) == 0 ? nil : last_error()
 }
 
 bind :: proc(s: Socket, addr: string, allocator := context.temp_allocator) -> Error {
 	c := strings.clone_to_cstring(addr, allocator)
-	return _bind(rawptr(s), c) == 0 ? nil : last_error()
+	return _bind(s, c) == 0 ? nil : last_error()
 }
 
 connect :: proc(s: Socket, addr: string, allocator := context.temp_allocator) -> Error {
 	c := strings.clone_to_cstring(addr, allocator)
-	return _connect(rawptr(s), c) == 0 ? nil : last_error()
+	return _connect(s, c) == 0 ? nil : last_error()
 }
 
-send :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) {
-	n := _send(rawptr(s), rawptr(&buf[0]), c.size_t(len(buf)), transmute(c.int)flags)
+send :: proc {
+	send_bytes,
+	send_string,
+}
+
+send_bytes :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) {
+	n := _send(s, rawptr(&buf[0]), c.size_t(len(buf)), flags)
 	if n < 0 {
 		return -1, last_error()
 	}
-	return int(n), nil
+	return int(n), Error{}
+}
+
+send_string :: proc(s: Socket, buf: string, flags: Flags = Flags{}) -> (int, Error) {
+	return send_bytes(s, transmute([]u8)buf, flags)
 }
 
 recv :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) {
-	n := _recv(rawptr(s), rawptr(&buf[0]), c.size_t(len(buf)), transmute(c.int)flags)
+	n := _recv(s, rawptr(&buf[0]), c.size_t(len(buf)), flags)
 	if n < 0 {
 		return -1, last_error()
 	}