mirror of
https://github.com/logos-messaging/nim-ffi.git
synced 2026-06-21 00:40:16 +00:00
2302e5fb7d
Extends the native C++ marshalling to sequences and optionals: a C++ field maps to std::vector<T> / std::optional<T>, and `toC` returns a holder that owns the C-array backing (move/NRVO-safe std::vectors) while string pointers borrow the C++ argument — valid for the call, which the library deep-copies. `fromC` reads seq/Option back out of the C-POD. Unblocks the timer's complex (seq-of-structs / seq-of-strings / two optionals) and schedule (three struct params) methods — they now generate and round-trip typed results. Verified end-to-end and ASAN-clean. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
390 lines
14 KiB
Nim
390 lines
14 KiB
Nim
## Native (zero-serialization) C++ binding generator.
|
|
##
|
|
## Emits `<lib>.hpp`: an idiomatic C++ wrapper over the *native* C ABI (the
|
|
## `<name>` entry points + flat C structs declared in `<lib>.h`). Each `{.ffi.}`
|
|
## type is mirrored as a C++ struct with `toC` / `fromC` converters to the C-POD
|
|
## layout, and methods marshal typed args in / read typed struct returns out —
|
|
## no CBOR. Companion to the CBOR generator in `cpp.nim` (`<lib>_cbor.hpp`).
|
|
##
|
|
## Commit 1 covers scalar / string / bool / nested-struct fields and the procs
|
|
## that use only those (the timer's create / version / echo). Sequences,
|
|
## optionals and native events are layered on next.
|
|
|
|
import std/[os, strutils]
|
|
import ./meta, ./string_helpers
|
|
import ./c as cgen
|
|
|
|
proc isSeqT(t: string): bool =
|
|
t.strip().startsWith("seq[") and t.strip().endsWith("]")
|
|
|
|
proc isOptT(t: string): bool =
|
|
let s = t.strip()
|
|
(s.startsWith("Option[") or s.startsWith("Maybe[")) and s.endsWith("]")
|
|
|
|
proc seqElem(t: string): string =
|
|
t.strip()["seq[".len .. ^2].strip()
|
|
|
|
proc optElem(t: string): string =
|
|
let s = t.strip()
|
|
let p = if s.startsWith("Maybe["): "Maybe[".len else: "Option[".len
|
|
s[p .. ^2].strip()
|
|
|
|
proc isStringT(t: string): bool =
|
|
t.strip() in ["string", "cstring"]
|
|
|
|
proc isStructT(t: string, types: seq[FFITypeMeta]): bool =
|
|
for ty in types:
|
|
if ty.name == t.strip():
|
|
return true
|
|
false
|
|
|
|
proc scalarCpp(t: string): string =
|
|
case t.strip()
|
|
of "int", "int64", "clong": "int64_t"
|
|
of "int32", "cint": "int32_t"
|
|
of "int16": "int16_t"
|
|
of "int8": "int8_t"
|
|
of "uint", "uint64", "csize_t": "uint64_t"
|
|
of "uint32", "cuint": "uint32_t"
|
|
of "uint16": "uint16_t"
|
|
of "uint8", "byte": "uint8_t"
|
|
of "bool": "bool"
|
|
of "float", "float32": "float"
|
|
of "float64": "double"
|
|
else: t.strip() # nested struct -> its C++ name
|
|
|
|
proc cppType(t: string): string =
|
|
## Idiomatic C++ type for an `{.ffi.}` field / param.
|
|
let s = t.strip()
|
|
if isSeqT(s): "std::vector<" & cppType(seqElem(s)) & ">"
|
|
elif isOptT(s): "std::optional<" & cppType(optElem(s)) & ">"
|
|
elif isStringT(s): "std::string"
|
|
else: scalarCpp(s)
|
|
|
|
proc cElemCpp(t: string, types: seq[FFITypeMeta]): string =
|
|
## The C type used for one seq element / option payload (matches emitCStructs).
|
|
let s = t.strip()
|
|
if isStringT(s): "const char*"
|
|
elif isStructT(s, types): "::" & s
|
|
elif s == "bool": "int"
|
|
else: scalarCpp(s)
|
|
|
|
# Element-granular converters. `src` yields one element on the source side.
|
|
proc toCElem(t, src: string, types: seq[FFITypeMeta]): string =
|
|
let s = t.strip()
|
|
if isStringT(s): src & ".c_str()"
|
|
elif s == "bool": "(" & src & " ? 1 : 0)"
|
|
elif isStructT(s, types): "toC(" & src & ").c"
|
|
else: src
|
|
|
|
proc fromCElem(t, src: string, types: seq[FFITypeMeta]): string =
|
|
let s = t.strip()
|
|
if isStringT(s): "(" & src & " ? std::string(" & src & ") : std::string())"
|
|
elif s == "bool": "(" & src & " != 0)"
|
|
elif isStructT(s, types): "fromC(" & src & ")"
|
|
else: src
|
|
|
|
proc emitTypes(types: seq[FFITypeMeta]): seq[string] =
|
|
var L: seq[string] = @[]
|
|
for t in types:
|
|
# C++ struct.
|
|
L.add("struct " & t.name & " {")
|
|
for f in t.fields:
|
|
L.add(" " & cppType(f.typeName) & " " & f.name & "{};")
|
|
L.add("};")
|
|
|
|
# Holder: owns the backing storage for any seq fields and exposes the C-POD
|
|
# struct. Returned by value from `toC`; the std::vector buffers survive the
|
|
# move/NRVO, and string pointers borrow the source `v` (kept alive by the
|
|
# caller for the duration of the call).
|
|
L.add("struct " & t.name & "C {")
|
|
L.add(" ::" & t.name & " c{};")
|
|
for f in t.fields:
|
|
if isSeqT(f.typeName):
|
|
L.add(" std::vector<" & cElemCpp(seqElem(f.typeName), types) & "> _" &
|
|
f.name & ";")
|
|
if isStructT(seqElem(f.typeName), types):
|
|
L.add(" std::vector<" & cppType(seqElem(f.typeName)) & "C> _" &
|
|
f.name & "H;")
|
|
L.add("};")
|
|
|
|
L.add("inline " & t.name & "C toC(const " & t.name & "& v) {")
|
|
L.add(" " & t.name & "C h;")
|
|
for f in t.fields:
|
|
let ft = f.typeName.strip()
|
|
if isSeqT(ft):
|
|
let e = seqElem(ft)
|
|
L.add(" for (const auto& it : v." & f.name & ") {")
|
|
if isStructT(e, types):
|
|
# Keep element holders alive, then collect their C structs.
|
|
L.add(" h._" & f.name & "H.push_back(toC(it));")
|
|
else:
|
|
L.add(" h._" & f.name & ".push_back(" & toCElem(e, "it", types) & ");")
|
|
L.add(" }")
|
|
if isStructT(e, types):
|
|
L.add(" for (const auto& hh : h._" & f.name & "H) h._" & f.name &
|
|
".push_back(hh.c);")
|
|
L.add(" h.c." & f.name & " = h._" & f.name & ".empty() ? nullptr : h._" &
|
|
f.name & ".data();")
|
|
L.add(" h.c." & f.name & "_len = h._" & f.name & ".size();")
|
|
elif isOptT(ft):
|
|
let e = optElem(ft)
|
|
L.add(" if (v." & f.name & ".has_value()) {")
|
|
L.add(" h.c." & f.name & "_present = 1;")
|
|
L.add(" h.c." & f.name & " = " & toCElem(e, "(*v." & f.name & ")", types) & ";")
|
|
L.add(" }")
|
|
elif isStringT(ft):
|
|
L.add(" h.c." & f.name & " = v." & f.name & ".c_str();")
|
|
elif ft == "bool":
|
|
L.add(" h.c." & f.name & " = v." & f.name & " ? 1 : 0;")
|
|
elif isStructT(ft, types):
|
|
L.add(" h.c." & f.name & " = toC(v." & f.name & ").c;")
|
|
else:
|
|
L.add(" h.c." & f.name & " = v." & f.name & ";")
|
|
L.add(" return h;")
|
|
L.add("}")
|
|
|
|
L.add("inline " & t.name & " fromC(const ::" & t.name & "& c) {")
|
|
L.add(" " & t.name & " v{};")
|
|
for f in t.fields:
|
|
let ft = f.typeName.strip()
|
|
if isSeqT(ft):
|
|
let e = seqElem(ft)
|
|
L.add(" for (std::size_t i = 0; i < c." & f.name & "_len; i++)")
|
|
L.add(" v." & f.name & ".push_back(" &
|
|
fromCElem(e, "c." & f.name & "[i]", types) & ");")
|
|
elif isOptT(ft):
|
|
let e = optElem(ft)
|
|
L.add(" if (c." & f.name & "_present)")
|
|
L.add(" v." & f.name & " = " &
|
|
fromCElem(e, "c." & f.name, types) & ";")
|
|
elif isStringT(ft):
|
|
L.add(" v." & f.name & " = c." & f.name & " ? std::string(c." & f.name &
|
|
") : std::string();")
|
|
elif ft == "bool":
|
|
L.add(" v." & f.name & " = c." & f.name & " != 0;")
|
|
elif isStructT(ft, types):
|
|
L.add(" v." & f.name & " = fromC(c." & f.name & ");")
|
|
else:
|
|
L.add(" v." & f.name & " = c." & f.name & ";")
|
|
L.add(" return v;")
|
|
L.add("}")
|
|
L.add("")
|
|
return L
|
|
|
|
proc methodName(procName, libName: string): string =
|
|
let prefix = libName & "_"
|
|
let bare =
|
|
if procName.startsWith(prefix):
|
|
procName[prefix.len .. ^1]
|
|
else:
|
|
procName
|
|
capitalizeFirstLetter(snakeToPascalCase(bare))
|
|
|
|
proc procSupported(p: FFIProcMeta, types: seq[FFITypeMeta]): bool =
|
|
## Scalar / string / `{.ffi.}`-struct params are supported (structs may carry
|
|
## seq/Option fields now). Bare seq/Option top-level params and raw pointers
|
|
## are not (the native ABI doesn't expose them either).
|
|
for ep in p.extraParams:
|
|
let t = ep.typeName.strip()
|
|
if ep.isPtr or isSeqT(t) or isOptT(t):
|
|
return false
|
|
true
|
|
|
|
proc generateCppNativeHeader*(
|
|
procs: seq[FFIProcMeta],
|
|
types: seq[FFITypeMeta],
|
|
libName: string,
|
|
events: seq[FFIEventMeta] = @[],
|
|
): string =
|
|
let guard = "NIM_FFI_GEN_" & libName.toUpper() & "_NATIVE_HPP"
|
|
let nodeT = capitalizeFirstLetter(libName) & "Node"
|
|
var L: seq[string] = @[]
|
|
L.add("// Generated by nim-ffi native C++ codegen. Do not edit by hand.")
|
|
L.add("//")
|
|
L.add("// Native (zero-serialization) wrapper over the C ABI in \"" & libName &
|
|
".h\". Struct params/returns cross as flat C-POD structs — no CBOR. For the")
|
|
L.add("// inter-process path use the CBOR header (" & libName & "_cbor.hpp).")
|
|
L.add("#ifndef " & guard)
|
|
L.add("#define " & guard)
|
|
L.add("")
|
|
L.add("#include \"" & libName & ".h\"")
|
|
L.add("#include <cstdint>")
|
|
L.add("#include <future>")
|
|
L.add("#include <optional>")
|
|
L.add("#include <stdexcept>")
|
|
L.add("#include <string>")
|
|
L.add("#include <vector>")
|
|
L.add("")
|
|
L.add("namespace " & libName & " {")
|
|
L.add("")
|
|
|
|
for line in emitTypes(types):
|
|
L.add(line)
|
|
|
|
# Per-call blocking capture, parameterised by the C++ return type.
|
|
L.add("namespace detail {")
|
|
L.add("template <typename T> struct Capture {")
|
|
L.add(" int ret = RET_ERR;")
|
|
L.add(" T value{};")
|
|
L.add(" std::string err;")
|
|
L.add(" std::promise<void> done;")
|
|
L.add("};")
|
|
L.add("struct AckCapture {")
|
|
L.add(" int ret = RET_ERR;")
|
|
L.add(" std::string err;")
|
|
L.add(" std::promise<void> done;")
|
|
L.add("};")
|
|
L.add("inline std::string rawText(const char* msg, std::size_t len) {")
|
|
L.add(" return (msg && len) ? std::string(msg, len) : std::string();")
|
|
L.add("}")
|
|
L.add("} // namespace detail")
|
|
L.add("")
|
|
|
|
# Find ctor / dtor.
|
|
var ctor, dtor: FFIProcMeta
|
|
var haveCtor, haveDtor = false
|
|
for p in procs:
|
|
if p.kind == FFIKind.CTOR:
|
|
(ctor, haveCtor) = (p, true)
|
|
elif p.kind == FFIKind.DTOR:
|
|
(dtor, haveDtor) = (p, true)
|
|
|
|
# Exported C callbacks (one per struct-returning method + shared ack/string).
|
|
L.add("extern \"C\" {")
|
|
L.add("inline void " & libName &
|
|
"_native_ack(int ret, const char* msg, std::size_t len, void* ud) {")
|
|
L.add(" auto* c = static_cast<detail::AckCapture*>(ud);")
|
|
L.add(" c->ret = ret;")
|
|
L.add(" if (ret == RET_ERR) c->err = detail::rawText(msg, len);")
|
|
L.add(" c->done.set_value();")
|
|
L.add("}")
|
|
L.add("inline void " & libName &
|
|
"_native_str(int ret, const char* msg, std::size_t len, void* ud) {")
|
|
L.add(" auto* c = static_cast<detail::Capture<std::string>*>(ud);")
|
|
L.add(" c->ret = ret;")
|
|
L.add(" if (ret == RET_OK) c->value = detail::rawText(msg, len);")
|
|
L.add(" else c->err = detail::rawText(msg, len);")
|
|
L.add(" c->done.set_value();")
|
|
L.add("}")
|
|
for p in procs:
|
|
if p.kind != FFIKind.FFI or not procSupported(p, types):
|
|
continue
|
|
if not isStructT(p.returnTypeName, types):
|
|
continue
|
|
let rt = p.returnTypeName
|
|
L.add("inline void " & libName & "_native_" & p.procName &
|
|
"(int ret, const char* msg, std::size_t len, void* ud) {")
|
|
L.add(" auto* c = static_cast<detail::Capture<" & rt & ">*>(ud);")
|
|
L.add(" c->ret = ret;")
|
|
L.add(" if (ret == RET_OK) c->value = fromC(*reinterpret_cast<const ::" &
|
|
rt & "*>(msg));")
|
|
L.add(" else c->err = detail::rawText(msg, len);")
|
|
L.add(" c->done.set_value();")
|
|
L.add("}")
|
|
L.add("} // extern \"C\"")
|
|
L.add("")
|
|
|
|
# The node class.
|
|
L.add("class " & nodeT & " {")
|
|
L.add(" public:")
|
|
if haveCtor:
|
|
var params: seq[string] = @[]
|
|
var conv: seq[string] = @[]
|
|
var args: seq[string] = @[]
|
|
for ep in ctor.extraParams:
|
|
params.add("const " & cppType(ep.typeName) & "& " & ep.name)
|
|
if isStructT(ep.typeName, types):
|
|
conv.add(" auto c_" & ep.name & " = toC(" & ep.name & ");")
|
|
args.add("c_" & ep.name & ".c")
|
|
else:
|
|
args.add(ep.name)
|
|
let argsStr = if args.len > 0: args.join(", ") & ", " else: ""
|
|
L.add(" explicit " & nodeT & "(" & params.join(", ") & ") {")
|
|
L.add(" detail::AckCapture cap;")
|
|
L.add(" auto fut = cap.done.get_future();")
|
|
for c in conv:
|
|
L.add(c)
|
|
L.add(" ctx_ = " & ctor.procName & "(" & argsStr &
|
|
libName & "_native_ack, &cap);")
|
|
L.add(" if (!ctx_) throw std::runtime_error(\"" & ctor.procName &
|
|
" returned null\");")
|
|
L.add(" fut.wait();")
|
|
L.add(" if (cap.ret != RET_OK) throw std::runtime_error(cap.err);")
|
|
L.add(" }")
|
|
L.add("")
|
|
|
|
for p in procs:
|
|
if p.kind != FFIKind.FFI:
|
|
continue
|
|
if not procSupported(p, types):
|
|
L.add(" // SKIPPED " & p.procName &
|
|
": seq/Option/multi-struct params not yet supported by native C++ codegen")
|
|
continue
|
|
let mName = methodName(p.procName, libName)
|
|
var params: seq[string] = @[]
|
|
var conv: seq[string] = @[]
|
|
var args: seq[string] = @[]
|
|
for ep in p.extraParams:
|
|
params.add("const " & cppType(ep.typeName) & "& " & ep.name)
|
|
if isStructT(ep.typeName, types):
|
|
conv.add(" auto c_" & ep.name & " = toC(" & ep.name & ");")
|
|
args.add("c_" & ep.name & ".c")
|
|
else:
|
|
args.add(ep.name)
|
|
let argsStr = if args.len > 0: ", " & args.join(", ") else: ""
|
|
let structRet = isStructT(p.returnTypeName, types)
|
|
let retT = if structRet: p.returnTypeName else: "std::string"
|
|
let capT = if structRet: p.returnTypeName else: "std::string"
|
|
let cbName =
|
|
if structRet: libName & "_native_" & p.procName else: libName & "_native_str"
|
|
L.add(" " & retT & " " & mName & "(" & params.join(", ") & ") {")
|
|
L.add(" detail::Capture<" & capT & "> cap;")
|
|
L.add(" auto fut = cap.done.get_future();")
|
|
for c in conv:
|
|
L.add(c)
|
|
L.add(" if (" & p.procName & "(ctx_, " & cbName & ", &cap" & argsStr &
|
|
") != RET_OK)")
|
|
L.add(" throw std::runtime_error(\"" & p.procName &
|
|
" dispatch failed\");")
|
|
L.add(" fut.wait();")
|
|
L.add(" if (cap.ret != RET_OK) throw std::runtime_error(cap.err);")
|
|
L.add(" return cap.value;")
|
|
L.add(" }")
|
|
L.add("")
|
|
|
|
if haveDtor:
|
|
L.add(" ~" & nodeT & "() { if (ctx_) " & dtor.procName & "(ctx_); }")
|
|
L.add(" " & nodeT & "(const " & nodeT & "&) = delete;")
|
|
L.add(" " & nodeT & "& operator=(const " & nodeT & "&) = delete;")
|
|
L.add("")
|
|
L.add(" private:")
|
|
L.add(" void* ctx_ = nullptr;")
|
|
L.add("};")
|
|
L.add("")
|
|
L.add("} // namespace " & libName)
|
|
L.add("")
|
|
L.add("#endif // " & guard)
|
|
return L.join("\n")
|
|
|
|
proc generateCppNativeBindings*(
|
|
procs: seq[FFIProcMeta],
|
|
types: seq[FFITypeMeta],
|
|
libName: string,
|
|
outputDir: string,
|
|
nimSrcRelPath: string,
|
|
events: seq[FFIEventMeta] = @[],
|
|
) =
|
|
# `<lib>_native.hpp` for now so it coexists with the CBOR `<lib>.hpp`; the
|
|
# native-bare / `_cbor` rename (matching C) is a follow-up. Emit the native C
|
|
# header too (the structs + entry points the .hpp includes), so the binding is
|
|
# self-contained.
|
|
writeFile(
|
|
outputDir / (libName & ".h"),
|
|
cgen.generateCHeader(procs, types, libName, events),
|
|
)
|
|
writeFile(
|
|
outputDir / (libName & "_native.hpp"),
|
|
generateCppNativeHeader(procs, types, libName, events),
|
|
)
|