diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..443bddc --- /dev/null +++ b/Makefile @@ -0,0 +1,4 @@ +.PHONY: libsds + +libsds: + nim c --app:lib --mm:refc --outdir:build library/libsds.nim \ No newline at end of file diff --git a/bindings/generated/libbindings.dylib b/bindings/generated/libbindings.dylib deleted file mode 100755 index 8fb1999..0000000 Binary files a/bindings/generated/libbindings.dylib and /dev/null differ diff --git a/bindings/bindings.h b/library/libsds.h similarity index 100% rename from bindings/bindings.h rename to library/libsds.h diff --git a/bindings/bindings.nim b/library/libsds.nim similarity index 73% rename from bindings/bindings.nim rename to library/libsds.nim index 04a0a44..4d7c9e5 100644 --- a/bindings/bindings.nim +++ b/library/libsds.nim @@ -3,29 +3,34 @@ import chronos import results import ../src/[reliability, reliability_utils, message] -type - CReliabilityManagerHandle* = pointer +type CReliabilityManagerHandle* = pointer type # Callback Types (Imported from C Header) - CEventType* {.importc: "CEventType", header: "bindings.h", pure.} = enum - EVENT_MESSAGE_READY = 1, - EVENT_MESSAGE_SENT = 2, - EVENT_MISSING_DEPENDENCIES = 3, + CEventType* {.importc: "CEventType", header: "libsds.h", pure.} = enum + EVENT_MESSAGE_READY = 1 + EVENT_MESSAGE_SENT = 2 + EVENT_MISSING_DEPENDENCIES = 3 EVENT_PERIODIC_SYNC = 4 - CEventCallback* = proc(handle: pointer, eventType: CEventType, data1: pointer, data2: pointer, data3: csize_t) {.cdecl.} # Use csize_t + CEventCallback* = proc( + handle: pointer, + eventType: CEventType, + data1: pointer, + data2: pointer, + data3: csize_t, + ) {.cdecl.} # Use csize_t - CResult* {.importc: "CResult", header: "bindings.h", bycopy.} = object + CResult* {.importc: "CResult", header: "libsds.h", bycopy.} = object is_ok*: bool error_message*: cstring - CWrapResult* {.importc: "CWrapResult", header: "bindings.h", bycopy.} = object + CWrapResult* {.importc: "CWrapResult", header: "libsds.h", bycopy.} = object base_result*: CResult message*: pointer message_len*: csize_t - CUnwrapResult* {.importc: "CUnwrapResult", header: "bindings.h", bycopy.} = object + CUnwrapResult* {.importc: "CUnwrapResult", header: "libsds.h", bycopy.} = object base_result*: CResult message*: pointer message_len*: csize_t @@ -33,8 +38,7 @@ type missing_deps_count*: csize_t # --- Callback Registry --- -type - CallbackRegistry = Table[CReliabilityManagerHandle, CEventCallback] +type CallbackRegistry = Table[CReliabilityManagerHandle, CEventCallback] var callbackRegistry: CallbackRegistry @@ -45,41 +49,48 @@ initLock(registryLock) # --- Memory Management Helpers --- proc allocCString*(s: string): cstring {.inline, gcsafe.} = - if s.len == 0: return nil + if s.len == 0: + return nil result = cast[cstring](allocShared(s.len + 1)) copyMem(result, s.cstring, s.len + 1) proc allocSeqByte*(s: seq[byte]): (pointer, csize_t) {.inline, gcsafe.} = - if s.len == 0: return (nil, 0) + if s.len == 0: + return (nil, 0) let len = s.len let bufferPtr = allocShared(len) if len > 0: copyMem(bufferPtr, cast[pointer](s[0].unsafeAddr), len.Natural) return (bufferPtr, len.csize_t) -proc allocSeqCString*(s: seq[string]): (ptr cstring, csize_t) {.inline, gcsafe, cdecl.} = - if s.len == 0: return (nil, 0) +proc allocSeqCString*( + s: seq[string] +): (ptr cstring, csize_t) {.inline, gcsafe, cdecl.} = + if s.len == 0: + return (nil, 0) let count = s.len # Allocate memory for 'count' cstring pointers, cast to ptr UncheckedArray let arrPtr = cast[ptr UncheckedArray[cstring]](allocShared(count * sizeof(cstring))) - for i in 0.. 0: - return CWrapResult(base_result: toCResultErrStr("Message pointer is NULL but length > 0")) + return CWrapResult( + base_result: toCResultErrStr("Message pointer is NULL but length > 0") + ) if messageIdCStr == nil: - return CWrapResult(base_result: toCResultErrStr("Message ID pointer is NULL")) + return CWrapResult(base_result: toCResultErrStr("Message ID pointer is NULL")) let messageId = $messageIdCStr var messageNim: seq[byte] @@ -228,20 +266,23 @@ proc WrapOutgoingMessage*(handle: CReliabilityManagerHandle, messageC: pointer, if wrapResult.isOk: let (wrappedDataPtr, wrappedDataLen) = allocSeqByte(wrapResult.get()) return CWrapResult( - base_result: toCResultOk(), - message: wrappedDataPtr, - message_len: wrappedDataLen + base_result: toCResultOk(), message: wrappedDataPtr, message_len: wrappedDataLen ) else: return CWrapResult(base_result: toCResultErr(wrapResult.error)) -proc UnwrapReceivedMessage*(handle: CReliabilityManagerHandle, messageC: pointer, messageLen: csize_t): CUnwrapResult {.exportc, dynlib, cdecl.} = # Keep non-gcsafe +proc UnwrapReceivedMessage*( + handle: CReliabilityManagerHandle, messageC: pointer, messageLen: csize_t +): CUnwrapResult {.exportc, dynlib, cdecl.} = # Keep non-gcsafe if handle == nil: - return CUnwrapResult(base_result: toCResultErrStr("ReliabilityManager handle is NULL")) + return + CUnwrapResult(base_result: toCResultErrStr("ReliabilityManager handle is NULL")) let rm = cast[ReliabilityManager](handle) if messageC == nil and messageLen > 0: - return CUnwrapResult(base_result: toCResultErrStr("Message pointer is NULL but length > 0")) + return CUnwrapResult( + base_result: toCResultErrStr("Message pointer is NULL but length > 0") + ) var messageNim: seq[byte] if messageLen > 0: @@ -260,12 +301,14 @@ proc UnwrapReceivedMessage*(handle: CReliabilityManagerHandle, messageC: pointer message: contentPtr, message_len: contentLen, missing_deps: depsPtr, - missing_deps_count: depsCount + missing_deps_count: depsCount, ) else: return CUnwrapResult(base_result: toCResultErr(unwrapResult.error)) -proc MarkDependenciesMet*(handle: CReliabilityManagerHandle, messageIDsC: ptr cstring, count: csize_t): CResult {.exportc, dynlib, cdecl.} = # Keep non-gcsafe +proc MarkDependenciesMet*( + handle: CReliabilityManagerHandle, messageIDsC: ptr cstring, count: csize_t +): CResult {.exportc, dynlib, cdecl.} = # Keep non-gcsafe if handle == nil: return toCResultErrStr("ReliabilityManager handle is NULL") let rm = cast[ReliabilityManager](handle) @@ -276,7 +319,7 @@ proc MarkDependenciesMet*(handle: CReliabilityManagerHandle, messageIDsC: ptr cs var messageIDsNim = newSeq[string](count) # Cast to ptr UncheckedArray for indexing let messageIDsCArray = cast[ptr UncheckedArray[cstring]](messageIDsC) - for i in 0.. // For C.free -#include "bindings/bindings.h" // Update include path +#include "library/libsds.h" // Update include path // Forward declaration for the single Go callback relay function extern void globalCallbackRelay(void* handle, CEventType eventType, void* data1, void* data2, size_t data3); @@ -229,6 +229,7 @@ func StartPeriodicTasks(handle ReliabilityManagerHandle) error { // globalCallbackRelay is called by Nim for all events. // It uses the handle to find the correct Go Callbacks struct and dispatch the call. +// //export globalCallbackRelay func globalCallbackRelay(handle unsafe.Pointer, eventType C.CEventType, data1 unsafe.Pointer, data2 unsafe.Pointer, data3 C.size_t) { goHandle := ReliabilityManagerHandle(handle)