mirror of
https://github.com/zap-proto/c.git
synced 2026-10-30 15:05:52 +00:00
zeekay
a84cf7189d
Finish the capnp->ZAP rebrand for the shared runtime and make the build
configure and pass on a clean checkout.
Runtime file rename (history-preserving git mv) + every reference updated
in one pass:
lib/capn.c -> lib/zap.c
lib/capn-malloc.c -> lib/zap-malloc.c
lib/capn-stream.c -> lib/zap-stream.c
lib/capn-list.inc -> lib/zap-list.inc
tests/capn-test.cpp -> tests/zap-test.cpp
tests/capn-stream-test.cpp -> tests/zap-stream-test.cpp
Updated #include directives (zap.c's 4 SZ-templated zap-list.inc includes,
the two unity-build test includes), file banner comments, and the
meson/autotools targets (test target capn-test -> zap-test, with the
matching automake zap_test_* variables and the libzap source list).
The upstream `capn_`/`CAPN_` C ABI (struct capn, capn_get, ...) is left
intact: it is the original MIT library's neutral symbol prefix, not a
capnp/Cap'n Proto brand token, and renaming it would break the generated
*.zap.c/*.zap.h and the runtime shared into the lua binding.
Build fixes:
- example-test.cpp wrote to a fixed relative path ("tests/...out"), which
fails under `meson test` (cwd is the build dir). Use tmpfile() so the
test is cwd-independent and leaves no artifact.
- CI workflow: trigger on main (default branch was renamed master->main),
run the renamed zap-test binary, drop EOL ubuntu-20.04, pin checkout@v4.
Dependency bump (in-major): gtest wrap 1.13.0-1 -> 1.17.0-4. gtest >=1.14
requires C++17, so bump the test C++ standard c++14 -> c++17 in meson.build
and Makefile.am (the runtime stays c99; C++ is test-only).
Verified: meson setup build && ninja builds libzap + zapc-c + zap-test
clean; zap-test passes 24/24; `meson test` green (1/1). autoreconf
generates configure and automake accepts the renamed targets.
163 lines
2.9 KiB
C++
163 lines
2.9 KiB
C++
/* zap-list.inc
|
|
*
|
|
* Copyright (C) 2013 James McKaskill
|
|
*
|
|
* This software may be modified and distributed under the terms
|
|
* of the MIT license. See the LICENSE file for details.
|
|
*/
|
|
|
|
#define CAT2(A,B) A ## B
|
|
#define CAT(A,B) CAT2(A, B)
|
|
#define UINT_T CAT(CAT(uint, SZ), _t)
|
|
#define LIST_T CAT(capn_list, SZ)
|
|
#define FLIP CAT(capn_flip, SZ)
|
|
|
|
UINT_T CAT(capn_get,SZ) (LIST_T l, int off) {
|
|
char *d;
|
|
capn_ptr p = l.p;
|
|
if (off >= p.len) {
|
|
return 0;
|
|
}
|
|
|
|
switch (p.type) {
|
|
case CAPN_LIST:
|
|
if (p.datasz < SZ/8)
|
|
return 0;
|
|
d = p.data + off * (p.datasz + 8*p.ptrs);
|
|
return FLIP(*(UINT_T*)d);
|
|
|
|
case CAPN_PTR_LIST:
|
|
d = struct_ptr(p.seg, p.data + 8*off, SZ/8);
|
|
if (d) {
|
|
return FLIP(*(UINT_T*)d);
|
|
} else {
|
|
return 0;
|
|
}
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int CAT(capn_getv,SZ) (LIST_T l, int off, UINT_T *to, int sz) {
|
|
int i;
|
|
capn_ptr p;
|
|
capn_resolve(&l.p);
|
|
p = l.p;
|
|
if (off + sz > p.len) {
|
|
sz = p.len - off;
|
|
}
|
|
|
|
switch (p.type) {
|
|
case CAPN_LIST:
|
|
if (p.datasz == SZ/8 && !p.ptrs && (SZ == 8 || CAPN_LITTLE)) {
|
|
memcpy(to, p.data + off, sz * (SZ/8));
|
|
return sz;
|
|
} else if (p.datasz < SZ/8) {
|
|
return -1;
|
|
}
|
|
|
|
for (i = 0; i < sz; i++) {
|
|
char *d = p.data + (i + off) * (p.datasz + 8*p.ptrs);
|
|
to[i] = FLIP(*(UINT_T*)d);
|
|
}
|
|
return sz;
|
|
|
|
case CAPN_PTR_LIST:
|
|
for (i = 0; i < sz; i++) {
|
|
char *d = struct_ptr(p.seg, p.data + 8*(i+off), SZ/8);
|
|
if (d) {
|
|
to[i] = FLIP(*(UINT_T*)d);
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
return sz;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int CAT(capn_set,SZ) (LIST_T l, int off, UINT_T v) {
|
|
char *d;
|
|
capn_ptr p = l.p;
|
|
if (off >= p.len) {
|
|
return -1;
|
|
}
|
|
|
|
switch (p.type) {
|
|
case CAPN_LIST:
|
|
if (p.datasz < SZ/8)
|
|
return -1;
|
|
d = p.data + off * (p.datasz + 8*p.ptrs);
|
|
*(UINT_T*) d = FLIP(v);
|
|
return 0;
|
|
|
|
case CAPN_PTR_LIST:
|
|
d = struct_ptr(p.seg, p.data + 8*off, SZ/8);
|
|
if (!d) {
|
|
return -1;
|
|
}
|
|
*(UINT_T*) d = FLIP(v);
|
|
return 0;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int CAT(capn_setv,SZ) (LIST_T l, int off, const UINT_T *from, int sz) {
|
|
int i;
|
|
capn_ptr p = l.p;
|
|
if (off + sz > p.len) {
|
|
sz = p.len - off;
|
|
}
|
|
|
|
switch (p.type) {
|
|
case CAPN_LIST:
|
|
if (p.datasz == SZ/8 && !p.ptrs && (SZ == 8 || CAPN_LITTLE)) {
|
|
memcpy(p.data + off, from, sz * (SZ/8));
|
|
return sz;
|
|
} else if (p.datasz < SZ/8) {
|
|
return -1;
|
|
}
|
|
|
|
for (i = 0; i < sz; i++) {
|
|
char *d = p.data + (i + off) * (p.datasz + 8*p.ptrs);
|
|
*(UINT_T*) d = FLIP(from[i]);
|
|
}
|
|
return sz;
|
|
|
|
case CAPN_PTR_LIST:
|
|
for (i = 0; i < sz; i++) {
|
|
char *d = struct_ptr(p.seg, p.data + 8*(i+off), SZ/8);
|
|
if (d) {
|
|
*(UINT_T*) d = FLIP(from[i]);
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
return sz;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
LIST_T CAT(capn_new_list,SZ) (struct capn_segment *seg, int sz) {
|
|
LIST_T l = {{CAPN_LIST}};
|
|
l.p.seg = seg;
|
|
l.p.len = sz;
|
|
l.p.datasz = SZ/8;
|
|
new_object(&l.p, sz*(SZ/8));
|
|
return l;
|
|
}
|
|
|
|
#undef CAT2
|
|
#undef CAT
|
|
#undef UINT_T
|
|
#undef LIST_T
|
|
#undef FLIP
|
|
|