kingchenc
91e05e3c26
## What
Introduces `wickra-c` — a `cdylib` + `staticlib` that exposes the Rust core over a **C ABI**. This is the hub every C-capable language (C, C++, Go, C#, Java, R) links against, instead of re-wiring each indicator natively. The native Python/Node/WASM bindings are untouched; this is purely additive, for ecosystems without first-class Rust tooling.
## Scope (foundation slice)
This PR deliberately validates the **whole pipeline end to end with one indicator (SMA)** before scaling to all 514, so the CI / cross-OS / header-drift mechanics are proven green first.
- Opaque `*mut T` handles; `wickra_<ind>_{new,update,batch,reset,free}`.
- NaN sentinel for warmup / NULL handles; caller-owned batch buffers; every function NULL-safe.
- cbindgen generates and commits `bindings/c/include/wickra.h` with opaque handle typedefs.
- A C smoke example (`examples/c/`) links the header + compiled library and runs (CMake + ctest).
- A `c-abi` CI job builds the library and runs the smoke test on **Linux, macOS and Windows**, plus a header drift check on Linux.
## Notes
- The per-indicator FFI blocks are plain `#[no_mangle]` functions, **not** a macro: cbindgen cannot see macro-generated functions on stable Rust (macro expansion needs nightly), so the blocks are written literally and will be generated mechanically by the ScriptHelpers `capi` wrapper in a follow-up (same model as the committed-but-generated Node `index.js`).
- `bindings/c` cannot inherit the workspace `forbid(unsafe_code)` lint (the C boundary needs raw pointers), so it mirrors every workspace lint and only relaxes `unsafe_code`. The Rust core stays `unsafe`-forbidden.
## Follow-ups (separate PRs)
- ScriptHelpers `capi` generator + wire the scalar family (~235).
- Hand-written blocks for multi-output / custom-input / bars (~279).
- Docs consistency wave (README / docs / webpage: Python·Node·WASM·Rust → +C).
- Release wiring (native-lib matrix + header/lib GH-release assets) — gated.
37 lines
1.1 KiB
C++
37 lines
1.1 KiB
C++
// C++ smoke test for the Wickra C ABI via the optional RAII wrapper (`wickra.hpp`).
|
|
//
|
|
// Validates that the header compiles as C++ and that `wickra::Handle` constructs,
|
|
// moves, and frees correctly across the boundary.
|
|
|
|
#include "wickra.hpp"
|
|
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <utility>
|
|
|
|
int main() {
|
|
wickra::Handle<Sma, wickra_sma_free> sma(wickra_sma_new(3));
|
|
if (!sma) {
|
|
std::puts("FAIL: wickra_sma_new returned null");
|
|
return 1;
|
|
}
|
|
|
|
(void)wickra_sma_update(sma.get(), 1.0);
|
|
(void)wickra_sma_update(sma.get(), 2.0);
|
|
double value = wickra_sma_update(sma.get(), 3.0);
|
|
if (std::fabs(value - 2.0) > 1e-9) {
|
|
std::printf("FAIL: SMA(3) value %.6f, expected 2.0\n", value);
|
|
return 1;
|
|
}
|
|
|
|
// Move transfers ownership; the moved-from handle must not double-free.
|
|
wickra::Handle<Sma, wickra_sma_free> moved(std::move(sma));
|
|
if (static_cast<bool>(sma) || !static_cast<bool>(moved)) {
|
|
std::puts("FAIL: move semantics");
|
|
return 1;
|
|
}
|
|
|
|
std::puts("OK: wickra C++ RAII smoke passed (Handle construct + move + auto-free)");
|
|
return 0;
|
|
}
|