feat(zmq): Improved the error bindings.

zmq/zmq.odin

@@ -1,6 +1,8 @@
 package zmq
 
 import "core:c"
+import "core:os"
+import "core:strings"
 
 foreign import lib "system:zmq"
 
@@ -57,15 +59,39 @@ Flags :: bit_set[Flag;c.int]
 
 NoBlock :: Flags{.DONTWAIT}
 
-Error :: enum c.int {
-	Ok,
+HAUSNUMERO :: 156384712
+
+ZMQ_Error :: enum c.int {
+	EFSM           = HAUSNUMERO + 51,
+	ENOCOMPATPROTO = HAUSNUMERO + 52,
+	ETERM          = HAUSNUMERO + 53,
+	EMTHREAD       = HAUSNUMERO + 54,
 }
 
+Error :: union #shared_nil {
+	os.Platform_Error,
+	ZMQ_Error,
+}
+
+from_errno :: proc(raw: c.int) -> Error {
+	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 {
-	return string(_strerror(c.int(e)))
+	switch v in e {
+	case os.Platform_Error:
+		return string(_strerror(c.int(v)))
+	case ZMQ_Error:
+		return string(_strerror(c.int(v)))
+	case:
+		return ""
+	}
 }
-
-last_error :: proc() -> Error {return Error(_errno())}
 
 version :: proc() -> (major, minor, patch: int) {
 	ma, mi, pa: c.int = 0, 0, 0
@@ -78,7 +104,7 @@ ctx_new :: proc() -> Context {
 }
 
 ctx_term :: proc(ctx: Context) -> Error {
-	return _ctx_term(rawptr(ctx)) == 0 ? .Ok : last_error()
+	return _ctx_term(rawptr(ctx)) == 0 ? nil : last_error()
 }
 
 socket :: proc(ctx: Context, type: Socket_Type) -> (Socket, Error) {
@@ -86,19 +112,21 @@ socket :: proc(ctx: Context, type: Socket_Type) -> (Socket, Error) {
 	if s == nil {
 		return nil, last_error()
 	}
-	return Socket(s), .Ok
+	return Socket(s), nil
 }
 
 close :: proc(s: Socket) -> Error {
-	return _close(rawptr(s)) == 0 ? .Ok : last_error()
+	return _close(rawptr(s)) == 0 ? nil : last_error()
 }
 
-bind :: proc(s: Socket, addr: string) -> Error {
-	return endpoint(rawptr(s), addr, _bind)
+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()
 }
 
-connect :: proc(s: Socket, addr: string) -> Error {
-	return endpoint(rawptr(s), addr, _connect)
+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()
 }
 
 send :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) {
@@ -106,7 +134,7 @@ send :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) {
 	if n < 0 {
 		return -1, last_error()
 	}
-	return int(n), .Ok
+	return int(n), nil
 }
 
 recv :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) {
@@ -114,20 +142,6 @@ recv :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) {
 	if n < 0 {
 		return -1, last_error()
 	}
-	return int(n), .Ok
-}
-
-endpoint :: proc(
-	s: rawptr,
-	addr: string,
-	f: proc "c" (s: rawptr, addr: cstring) -> c.int,
-) -> Error {
-	buf: [256]u8
-	n := copy(buf[:], addr)
-	if n >= len(buf) {
-		return Error(7)
-	}
-	buf[n] = 0
-	return f(s, cstring(rawptr(&buf[0]))) == 0 ? .Ok : last_error()
+	return int(n), nil
 }