spencer/zomq
1
0
Fork 0
mirror of https://github.com/sbrow/zomq.git synced 2026-08-26 10:53:32 -04:00
Code Issues Packages Projects Releases Wiki Activity

refactor(zmq): Fixed style errors.

Browse Source
This commit is contained in:
Spencer Brower
2026-07-08 11:21:29 -04:00
parent 50bf65bbdc
commit 98773f433a
2 changed files with 78 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files
main.odin
+35 -33
View File
@@ -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)
}
zmq/zmq.odin
+43 -29
View File
@@ -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()
}