From 98773f433a97dce170f10d773f2dcbffef7e8363 Mon Sep 17 00:00:00 2001 From: Spencer Brower Date: Wed, 8 Jul 2026 11:21:29 -0400 Subject: [PATCH] refactor(zmq): Fixed style errors. --- main.odin | 68 +++++++++++++++++++++++++------------------------ zmq/zmq.odin | 72 +++++++++++++++++++++++++++++++--------------------- 2 files changed, 78 insertions(+), 62 deletions(-) diff --git a/main.odin b/main.odin index 0b6c294..c8d163e 100644 --- a/main.odin +++ b/main.odin @@ -2,23 +2,41 @@ package main import "core:bufio" import "core:fmt" +import "core:log" import "core:os" -import zmq "zmq" +import "zmq" main :: proc() { + context.logger = log.create_console_logger(.Debug, {}) + major, minor, patch := zmq.version() - fmt.printfln("zmq echo (libzmq %d.%d.%d) over inproc; type lines, Ctrl-D to quit", major, minor, patch) + log.infof( + "zmq echo (libzmq %d.%d.%d) over inproc; type lines, Ctrl-D to quit", + major, + minor, + patch, + ) - ctx := zmq.new_context() - defer zmq.term(ctx) + ctx := zmq.ctx_new() + defer zmq.ctx_term(ctx) - rep := must_socket(ctx, .REP, "rep socket") + rep, serr := zmq.socket(ctx, .REP) + if serr != nil { + log.panic(zmq.strerror(serr)) + } defer zmq.close(rep) - must(zmq.bind(rep, "inproc://echo"), "bind") + if err := zmq.bind(rep, "inproc://echo"); err != nil { + log.panic(zmq.strerror(err)) + } - req := must_socket(ctx, .REQ, "req socket") + req, cerr := zmq.socket(ctx, .REQ) + if cerr != nil { + log.panic(zmq.strerror(cerr)) + } defer zmq.close(req) - must(zmq.connect(req, "inproc://echo"), "connect") + if err := zmq.connect(req, "inproc://echo"); err != nil { + log.panic(zmq.strerror(err)) + } echo(req, rep) } @@ -28,47 +46,31 @@ echo :: proc(req, rep: zmq.Socket) { bufio.scanner_init(&scanner, os.to_reader(os.stdin)) defer bufio.scanner_destroy(&scanner) - buf: [1024]u8 + buf: [255]u8 for bufio.scan(&scanner) { line := bufio.scanner_text(&scanner) if len(line) == 0 { continue } - if _, err := zmq.send(req, transmute([]u8)line); !zmq.is_ok(err) { - fmt.eprintfln("send: %s", zmq.error_string(err)) + if _, err := zmq.send(req, transmute([]u8)line); err != nil { + fmt.eprintfln("send: %s", zmq.strerror(err)) return } n, rerr := zmq.recv(rep, buf[:]) - if !zmq.is_ok(rerr) { - fmt.eprintfln("rep recv: %s", zmq.error_string(rerr)) + if rerr != nil { + fmt.eprintfln("rep recv: %s", zmq.strerror(rerr)) return } - if _, werr := zmq.send(rep, buf[:n]); !zmq.is_ok(werr) { - fmt.eprintfln("rep send: %s", zmq.error_string(werr)) + if _, werr := zmq.send(rep, buf[:n]); werr != nil { + fmt.eprintfln("rep send: %s", zmq.strerror(werr)) return } m, qerr := zmq.recv(req, buf[:]) - if !zmq.is_ok(qerr) { - fmt.eprintfln("req recv: %s", zmq.error_string(qerr)) + if qerr != nil { + fmt.eprintfln("req recv: %s", zmq.strerror(qerr)) return } fmt.println(string(buf[:m])) } } -must :: proc(err: zmq.Error, at: string) { - if !zmq.is_ok(err) { - fatal(at, err) - } -} - -must_socket :: proc(ctx: zmq.Context, type: zmq.Socket_Type, at: string) -> zmq.Socket { - s, err := zmq.socket(ctx, type) - must(err, at) - return s -} - -fatal :: proc(at: string, err: zmq.Error) { - fmt.eprintfln("%s: %s", at, zmq.error_string(err)) - os.exit(1) -} diff --git a/zmq/zmq.odin b/zmq/zmq.odin index a54f156..acd5bd8 100644 --- a/zmq/zmq.odin +++ b/zmq/zmq.odin @@ -6,21 +6,32 @@ foreign import lib "system:zmq" @(default_calling_convention = "c") foreign lib { - @(link_name = "zmq_ctx_new") _ctx_new :: proc() -> rawptr --- - @(link_name = "zmq_ctx_term") _ctx_term :: proc(ctx: rawptr) -> c.int --- - @(link_name = "zmq_socket") _socket :: proc(ctx: rawptr, type: Socket_Type) -> rawptr --- - @(link_name = "zmq_close") _close :: proc(s: rawptr) -> c.int --- - @(link_name = "zmq_bind") _bind :: proc(s: rawptr, addr: cstring) -> c.int --- - @(link_name = "zmq_connect") _connect :: proc(s: rawptr, addr: cstring) -> c.int --- - @(link_name = "zmq_send") _send :: proc(s: rawptr, buf: rawptr, len: c.size_t, flags: c.int) -> 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 --- - @(link_name = "zmq_strerror") _strerror :: proc(errnum: c.int) -> cstring --- - @(link_name = "zmq_version") _version :: proc(major, minor, patch: ^c.int) --- + @(link_name = "zmq_ctx_new") + _ctx_new :: proc() -> rawptr --- + @(link_name = "zmq_ctx_term") + _ctx_term :: proc(ctx: rawptr) -> c.int --- + @(link_name = "zmq_socket") + _socket :: proc(ctx: rawptr, type: Socket_Type) -> rawptr --- + @(link_name = "zmq_close") + _close :: proc(s: rawptr) -> c.int --- + @(link_name = "zmq_bind") + _bind :: proc(s: rawptr, addr: cstring) -> c.int --- + @(link_name = "zmq_connect") + _connect :: proc(s: rawptr, addr: cstring) -> c.int --- + @(link_name = "zmq_send") + _send :: proc(s: rawptr, buf: rawptr, len: c.size_t, flags: c.int) -> 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 --- + @(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 :: distinct rawptr Socket_Type :: enum c.int { PAIR = 0, @@ -42,21 +53,19 @@ Flag :: enum c.int { SNDMORE = 2, } -Flags :: bit_set[Flag; c.int] +Flags :: bit_set[Flag;c.int] NoBlock :: Flags{.DONTWAIT} -Error :: distinct c.int +Error :: enum c.int { + Ok, +} -OK :: Error(0) - -is_ok :: proc(e: Error) -> bool { return c.int(e) == 0 } - -error_string :: proc(e: Error) -> string { +strerror :: proc(e: Error) -> string { return string(_strerror(c.int(e))) } -last_error :: proc() -> Error { return Error(_errno()) } +last_error :: proc() -> Error {return Error(_errno())} version :: proc() -> (major, minor, patch: int) { ma, mi, pa: c.int = 0, 0, 0 @@ -64,12 +73,12 @@ version :: proc() -> (major, minor, patch: int) { return int(ma), int(mi), int(pa) } -new_context :: proc() -> Context { +ctx_new :: proc() -> Context { return Context(_ctx_new()) } -term :: proc(ctx: Context) -> Error { - return _ctx_term(rawptr(ctx)) == 0 ? OK : last_error() +ctx_term :: proc(ctx: Context) -> Error { + return _ctx_term(rawptr(ctx)) == 0 ? .Ok : last_error() } socket :: proc(ctx: Context, type: Socket_Type) -> (Socket, Error) { @@ -77,11 +86,11 @@ socket :: proc(ctx: Context, type: Socket_Type) -> (Socket, Error) { if s == nil { return nil, last_error() } - return Socket(s), OK + return Socket(s), .Ok } close :: proc(s: Socket) -> Error { - return _close(rawptr(s)) == 0 ? OK : last_error() + return _close(rawptr(s)) == 0 ? .Ok : last_error() } bind :: proc(s: Socket, addr: string) -> Error { @@ -97,7 +106,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), .Ok } recv :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) { @@ -105,15 +114,20 @@ recv :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) { if n < 0 { return -1, last_error() } - return int(n), OK + return int(n), .Ok } -endpoint :: proc(s: rawptr, addr: string, f: proc "c" (s: rawptr, addr: cstring) -> c.int) -> Error { +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 f(s, cstring(rawptr(&buf[0]))) == 0 ? .Ok : last_error() } +