rshen/c-capnproto
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

size -> len and add capn_list* back in

Browse source
This commit is contained in:
James McKaskill 2013-05-08 22:38:07 -04:00
parent f99af86cb3
commit 923393d543
7 changed files with 225 additions and 163 deletions
Download patch file Download diff file Expand all files Collapse all files

26
capn-list.inc
View file

@ -4,9 +4,10 @@
#define UINT_T CAT(CAT(uint, SZ), _t)
#define FLIP CAT(capn_flip, SZ)
UINT_T CAT(capn_get,SZ) (capn_ptr p, int off) {
UINT_T CAT(capn_get,SZ) (CAT(capn_list,SZ) l, int off) {
char *d;
if (off >= p.size) {
capn_ptr p = l.p;
if (off >= p.len) {
return 0;
}
@ -30,11 +31,11 @@ UINT_T CAT(capn_get,SZ) (capn_ptr p, int off) {
}
}
int CAT(capn_getv,SZ) (capn_ptr p, int off, UINT_T *to, int sz) {
int CAT(capn_getv,SZ) (CAT(capn_list,SZ) l, int off, UINT_T *to, int sz) {
int i;
if (off + sz > p.size) {
sz = p.size - off;
capn_ptr p = l.p;
if (off + sz > p.len) {
sz = p.len - off;
}
switch (p.type) {
@ -68,9 +69,10 @@ int CAT(capn_getv,SZ) (capn_ptr p, int off, UINT_T *to, int sz) {
}
}
int CAT(capn_set,SZ) (capn_ptr p, int off, UINT_T v) {
int CAT(capn_set,SZ) (CAT(capn_list,SZ) l, int off, UINT_T v) {
char *d;
if (off >= p.size) {
capn_ptr p = l.p;
if (off >= p.len) {
return -1;
}
@ -95,11 +97,11 @@ int CAT(capn_set,SZ) (capn_ptr p, int off, UINT_T v) {
}
}
int CAT(capn_setv,SZ) (capn_ptr p, int off, const UINT_T *from, int sz) {
int CAT(capn_setv,SZ) (CAT(capn_list,SZ) l, int off, const UINT_T *from, int sz) {
int i;
if (off + sz > p.size) {
sz = p.size - off;
capn_ptr p = l.p;
if (off + sz > p.len) {
sz = p.len - off;
}
switch (p.type) {

98
capn-test.cpp
View file

@ -70,7 +70,7 @@ static const AlignedData<2> STRUCTLIST_ELEMENT_SUBSTRUCT_DEFAULT =
static void setupStruct(struct capn *ctx) {
struct capn_ptr root = capn_new_root(ctx);
ASSERT_EQ(CAPN_PTR_LIST, root.type);
ASSERT_EQ(1, root.size);
ASSERT_EQ(1, root.len);
struct capn_ptr ptr = capn_new_struct(root.seg, 16, 4);
ASSERT_EQ(CAPN_STRUCT, ptr.type);
@ -84,7 +84,7 @@ static void setupStruct(struct capn *ctx) {
EXPECT_EQ(0, capn_write8(ptr, 14, 0x40));
EXPECT_EQ(0, capn_write8(ptr, 15, (1 << 6) | (1 << 5) | (1 << 4) | (1 << 2)));
struct capn_ptr subStruct = capn_new_struct(ptr.seg, 8, 0);
capn_ptr subStruct = capn_new_struct(ptr.seg, 8, 0);
ASSERT_EQ(CAPN_STRUCT, subStruct.type);
EXPECT_EQ(8, subStruct.datasz);
EXPECT_EQ(0, subStruct.ptrsz);
@ -92,32 +92,33 @@ static void setupStruct(struct capn *ctx) {
EXPECT_NE(0, capn_write32(subStruct, 8, 124));
EXPECT_EQ(0, capn_setp(ptr, 0, subStruct));
struct capn_ptr list = capn_new_list(ptr.seg, 3, 4, 0);
ASSERT_EQ(CAPN_LIST, list.type);
EXPECT_EQ(3, list.size);
EXPECT_EQ(4, list.datasz);
EXPECT_EQ(0, capn_set32(list, 0, 200));
EXPECT_EQ(0, capn_set32(list, 1, 201));
EXPECT_EQ(0, capn_set32(list, 2, 202));
EXPECT_NE(0, capn_set32(list, 3, 203));
EXPECT_NE(0, capn_set64(list, 0, 405));
EXPECT_EQ(0, capn_setp(ptr, 1, list));
capn_list32 list32 = capn_new_list32(ptr.seg, 3);
capn_list64 list64 = {list32.p};
ASSERT_EQ(CAPN_LIST, list32.p.type);
EXPECT_EQ(3, list32.p.len);
EXPECT_EQ(4, list32.p.datasz);
EXPECT_EQ(0, capn_set32(list32, 0, 200));
EXPECT_EQ(0, capn_set32(list32, 1, 201));
EXPECT_EQ(0, capn_set32(list32, 2, 202));
EXPECT_NE(0, capn_set32(list32, 3, 203));
EXPECT_NE(0, capn_set64(list64, 0, 405));
EXPECT_EQ(0, capn_setp(ptr, 1, list32.p));
list = capn_new_list(ptr.seg, 4, 4, 1);
capn_ptr list = capn_new_list(ptr.seg, 4, 4, 1);
ASSERT_EQ(CAPN_LIST, list.type);
EXPECT_EQ(4, list.size);
EXPECT_EQ(4, list.len);
EXPECT_EQ(8, list.datasz);
EXPECT_EQ(8, list.ptrsz);
EXPECT_EQ(0, capn_setp(ptr, 2, list));
for (int i = 0; i < 4; i++) {
struct capn_ptr element = capn_getp(list, i);
capn_ptr element = capn_getp(list, i);
ASSERT_EQ(CAPN_STRUCT, element.type);
EXPECT_EQ(1, element.is_list_member);
EXPECT_EQ(8, element.datasz);
EXPECT_EQ(8, element.ptrsz);
EXPECT_EQ(0, capn_write32(element, 0, 300+i));
struct capn_ptr subelement = capn_new_struct(element.seg, 8, 0);
capn_ptr subelement = capn_new_struct(element.seg, 8, 0);
ASSERT_EQ(CAPN_STRUCT, subelement.type);
EXPECT_EQ(8, subelement.datasz);
EXPECT_EQ(0, subelement.ptrsz);
@ -127,15 +128,15 @@ static void setupStruct(struct capn *ctx) {
list = capn_new_ptr_list(ptr.seg, 5);
ASSERT_EQ(CAPN_PTR_LIST, list.type);
EXPECT_EQ(5, list.size);
EXPECT_EQ(5, list.len);
EXPECT_EQ(0, capn_setp(ptr, 3, list));
for (int i = 0; i < 5; i++) {
struct capn_ptr element = capn_new_list(list.seg, i+1, 2, 0);
ASSERT_EQ(CAPN_LIST, element.type);
EXPECT_EQ(i+1, element.size);
EXPECT_EQ(2, element.datasz);
EXPECT_EQ(0, element.ptrsz);
EXPECT_EQ(0, capn_setp(list, i, element));
capn_list16 element = capn_new_list16(list.seg, i+1);
ASSERT_EQ(CAPN_LIST, element.p.type);
EXPECT_EQ(i+1, element.p.len);
EXPECT_EQ(2, element.p.datasz);
EXPECT_EQ(0, element.p.ptrsz);
EXPECT_EQ(0, capn_setp(list, i, element.p));
for (int j = 0; j <= i; j++) {
EXPECT_EQ(0, capn_set16(element, j, 500+j));
}
@ -143,7 +144,7 @@ static void setupStruct(struct capn *ctx) {
}
static void checkStruct(struct capn *ctx) {
struct capn_ptr ptr = capn_get_root(ctx);
capn_ptr ptr = capn_get_root(ctx);
EXPECT_EQ(CAPN_STRUCT, ptr.type);
EXPECT_EQ(16, ptr.datasz);
EXPECT_EQ(32, ptr.ptrsz);
@ -153,40 +154,43 @@ static void checkStruct(struct capn *ctx) {
EXPECT_EQ(0x40, capn_read8(ptr, 14));
EXPECT_EQ((1 << 6) | (1 << 5) | (1 << 4) | (1 << 2), capn_read8(ptr, 15));
struct capn_ptr subStruct = capn_getp(ptr, 0);
capn_ptr subStruct = capn_getp(ptr, 0);
EXPECT_EQ(CAPN_STRUCT, subStruct.type);
EXPECT_EQ(8, subStruct.datasz);
EXPECT_EQ(0, subStruct.ptrsz);
EXPECT_EQ(123, capn_read32(subStruct, 0));
struct capn_ptr list = capn_getp(ptr, 1);
EXPECT_EQ(CAPN_LIST, list.type);
EXPECT_EQ(3, list.size);
EXPECT_EQ(4, list.datasz);
EXPECT_EQ(0, list.ptrsz);
EXPECT_EQ(200, capn_get32(list, 0));
EXPECT_EQ(201, capn_get32(list, 1));
EXPECT_EQ(202, capn_get32(list, 2));
EXPECT_EQ(0, capn_get32(list, 3));
EXPECT_EQ(0, capn_get64(list, 0));
EXPECT_EQ(201, capn_get8(list, 1));
EXPECT_EQ(202, capn_get16(list, 2));
capn_list32 list32 = {capn_getp(ptr, 1)};
capn_list8 list8 = {list32.p};
capn_list16 list16 = {list32.p};
capn_list64 list64 = {list32.p};
EXPECT_EQ(CAPN_LIST, list32.p.type);
EXPECT_EQ(3, list32.p.len);
EXPECT_EQ(4, list32.p.datasz);
EXPECT_EQ(0, list32.p.ptrsz);
EXPECT_EQ(200, capn_get32(list32, 0));
EXPECT_EQ(201, capn_get32(list32, 1));
EXPECT_EQ(202, capn_get32(list32, 2));
EXPECT_EQ(0, capn_get32(list32, 3));
EXPECT_EQ(0, capn_get64(list64, 0));
EXPECT_EQ(201, capn_get8(list8, 1));
EXPECT_EQ(202, capn_get16(list16, 2));
list = capn_getp(ptr, 2);
capn_ptr list = capn_getp(ptr, 2);
EXPECT_EQ(CAPN_LIST, list.type);
EXPECT_EQ(4, list.size);
EXPECT_EQ(4, list.len);
EXPECT_EQ(8, list.datasz);
EXPECT_EQ(8, list.ptrsz);
for (int i = 0; i < 4; i++) {
struct capn_ptr element = capn_getp(list, i);
capn_ptr element = capn_getp(list, i);
EXPECT_EQ(CAPN_STRUCT, element.type);
EXPECT_EQ(1, element.is_list_member);
EXPECT_EQ(8, element.datasz);
EXPECT_EQ(8, element.ptrsz);
EXPECT_EQ(300+i, capn_read32(element,0));
struct capn_ptr subelement = capn_getp(element, 0);
capn_ptr subelement = capn_getp(element, 0);
EXPECT_EQ(CAPN_STRUCT, subelement.type);
EXPECT_EQ(8, subelement.datasz);
EXPECT_EQ(0, subelement.ptrsz);
@ -195,13 +199,13 @@ static void checkStruct(struct capn *ctx) {
list = capn_getp(ptr, 3);
EXPECT_EQ(CAPN_PTR_LIST, list.type);
EXPECT_EQ(5, list.size);
EXPECT_EQ(5, list.len);
for (int i = 0; i < 5; i++) {
struct capn_ptr element = capn_getp(list, i);
EXPECT_EQ(CAPN_LIST, element.type);
EXPECT_EQ(i+1, element.size);
EXPECT_EQ(2, element.datasz);
EXPECT_EQ(0, element.ptrsz);
capn_list16 element = {capn_getp(list, i)};
EXPECT_EQ(CAPN_LIST, element.p.type);
EXPECT_EQ(i+1, element.p.len);
EXPECT_EQ(2, element.p.datasz);
EXPECT_EQ(0, element.p.ptrsz);
for (int j = 0; j <= i; j++) {
EXPECT_EQ(500+j, capn_get16(element, j));
}

155
capn.c
View file

@ -330,10 +330,10 @@ static capn_ptr read_ptr(struct capn_segment *s, char *d) {
ret.type = CAPN_STRUCT;
ret.datasz = U32(U16(val >> 32)) * 8;
ret.ptrsz = U32(U16(val >> 48)) * 8;
e = d + ret.size * (ret.datasz + ret.ptrsz);
e = d + ret.len * (ret.datasz + ret.ptrsz);
} else {
ret.type = CAPN_LIST;
ret.size = val >> 35;
ret.len = val >> 35;
switch ((val >> 32) & 7) {
case VOID_LIST:
@ -341,28 +341,28 @@ static capn_ptr read_ptr(struct capn_segment *s, char *d) {
break;
case BIT_1_LIST:
ret.type = CAPN_BIT_LIST;
ret.datasz = (ret.size+7)/8;
ret.datasz = (ret.len+7)/8;
e = d + ret.datasz;
break;
case BYTE_1_LIST:
ret.datasz = 1;
e = d + ret.size;
e = d + ret.len;
break;
case BYTE_2_LIST:
ret.datasz = 2;
e = d + ret.size * 2;
e = d + ret.len * 2;
break;
case BYTE_4_LIST:
ret.datasz = 4;
e = d + ret.size * 4;
e = d + ret.len * 4;
break;
case BYTE_8_LIST:
ret.datasz = 8;
e = d + ret.size * 8;
e = d + ret.len * 8;
break;
case PTR_LIST:
ret.type = CAPN_PTR_LIST;
e = d + ret.size * 8;
e = d + ret.len * 8;
break;
case COMPOSITE_LIST:
if (d+8-s->data > s->len) {
@ -372,14 +372,14 @@ static capn_ptr read_ptr(struct capn_segment *s, char *d) {
val = capn_flip64(*(uint64_t*) d);
d += 8;
e = d + ret.size * 8;
e = d + ret.len * 8;
ret.datasz = U32(U16(val >> 32)) * 8;
ret.ptrsz = U32(U16(val >> 48)) * 8;
ret.size = U32(val) >> 2;
ret.len = U32(val) >> 2;
ret.has_composite_tag = 1;
if ((ret.datasz + ret.ptrsz) * ret.size != e - d) {
if ((ret.datasz + ret.ptrsz) * ret.len != e - d) {
goto err;
}
break;
@ -401,7 +401,7 @@ capn_ptr capn_getp(capn_ptr p, int off) {
switch (p.type) {
case CAPN_LIST:
/* Return an inner pointer */
if (off < p.size) {
if (off < p.len) {
capn_ptr ret = {CAPN_NULL};
ret.type = CAPN_STRUCT;
ret.is_list_member = 1;
@ -423,7 +423,7 @@ capn_ptr capn_getp(capn_ptr p, int off) {
return read_ptr(p.seg, p.data + p.datasz + off);
case CAPN_PTR_LIST:
if (off >= p.size) {
if (off >= p.len) {
goto err;
}
@ -448,26 +448,26 @@ static uint64_t ptr_value(capn_ptr p, int off) {
case CAPN_LIST:
if (p.has_composite_tag) {
val |= LIST_PTR | (U64(COMPOSITE_LIST) << 32) | (U64(p.size * (p.datasz + p.ptrsz)/8) << 35);
val |= LIST_PTR | (U64(COMPOSITE_LIST) << 32) | (U64(p.len * (p.datasz + p.ptrsz)/8) << 35);
} else if (p.datasz == 8) {
val |= LIST_PTR | (U64(BYTE_8_LIST) << 32) | (U64(p.size) << 35);
val |= LIST_PTR | (U64(BYTE_8_LIST) << 32) | (U64(p.len) << 35);
} else if (p.datasz == 4) {
val |= LIST_PTR | (U64(BYTE_4_LIST) << 32) | (U64(p.size) << 35);
val |= LIST_PTR | (U64(BYTE_4_LIST) << 32) | (U64(p.len) << 35);
} else if (p.datasz == 2) {
val |= LIST_PTR | (U64(BYTE_2_LIST) << 32) | (U64(p.size) << 35);
val |= LIST_PTR | (U64(BYTE_2_LIST) << 32) | (U64(p.len) << 35);
} else if (p.datasz == 1) {
val |= LIST_PTR | (U64(BYTE_1_LIST) << 32) | (U64(p.size) << 35);
val |= LIST_PTR | (U64(BYTE_1_LIST) << 32) | (U64(p.len) << 35);
} else {
val |= LIST_PTR | (U64(VOID_LIST) << 32) | (U64(p.size) << 35);
val |= LIST_PTR | (U64(VOID_LIST) << 32) | (U64(p.len) << 35);
}
break;
case CAPN_BIT_LIST:
val |= LIST_PTR | (U64(BIT_1_LIST) << 32) | (U64(p.size) << 35);
val |= LIST_PTR | (U64(BIT_1_LIST) << 32) | (U64(p.len) << 35);
break;
case CAPN_PTR_LIST:
val |= LIST_PTR | (U64(PTR_LIST) << 32) | (U64(p.size) << 35);
val |= LIST_PTR | (U64(PTR_LIST) << 32) | (U64(p.len) << 35);
break;
default:
@ -565,11 +565,11 @@ static int data_size(const struct capn_ptr *p) {
case CAPN_BIT_LIST:
return p->datasz;
case CAPN_PTR_LIST:
return p->size*8;
return p->len*8;
case CAPN_STRUCT:
return p->datasz + p->ptrsz;
case CAPN_LIST:
return p->size * (p->datasz + p->ptrsz);
return p->len * (p->datasz + p->ptrsz);
default:
return 0;
}
@ -580,11 +580,11 @@ static capn_ptr new_clone(struct capn_segment *s, capn_ptr p) {
case CAPN_STRUCT:
return capn_new_struct(s, p.datasz, p.ptrsz);
case CAPN_PTR_LIST:
return capn_new_ptr_list(s, p.size);
return capn_new_ptr_list(s, p.len);
case CAPN_BIT_LIST:
return capn_new_bit_list(s, p.size);
return capn_new_list1(s, p.len).p;
case CAPN_LIST:
return capn_new_list(s, p.size, p.datasz, p.ptrsz);
return capn_new_list(s, p.len, p.datasz, p.ptrsz);
default:
return p;
}
@ -594,7 +594,7 @@ static capn_ptr new_clone(struct capn_segment *s, capn_ptr p) {
static int is_ptr_equal(const struct capn_ptr *a, const struct capn_ptr *b) {
return a->data == b->data
&& a->type == b->type
&& a->size == b->size
&& a->len == b->len
&& a->datasz == b->datasz
&& a->ptrsz == b->ptrsz
&& a->has_composite_tag == b->has_composite_tag;
@ -669,7 +669,7 @@ static int write_copy(struct capn_segment *seg, char *data, struct capn_ptr *t,
/* minimize the number of types the main copy routine has to
* deal with to just CAPN_LIST and CAPN_PTR_LIST. ptr list only
* needs t->type, t->size, t->data, t->seg, f->data, f->seg to
* needs t->type, t->len, t->data, t->seg, f->data, f->seg to
* be valid */
switch (t->type) {
case CAPN_STRUCT:
@ -680,7 +680,7 @@ static int write_copy(struct capn_segment *seg, char *data, struct capn_ptr *t,
}
if (t->ptrsz) {
t->type = CAPN_PTR_LIST;
t->size = t->ptrsz/8;
t->len = t->ptrsz/8;
(*dep)++;
}
return 0;
@ -690,21 +690,21 @@ static int write_copy(struct capn_segment *seg, char *data, struct capn_ptr *t,
return 0;
case CAPN_LIST:
if (!t->size) {
if (!t->len) {
/* empty list - nothing to copy */
} else if (t->ptrsz && t->datasz) {
(*dep)++;
} else if (t->datasz) {
memcpy(t->data, f->data, t->size * t->datasz);
memcpy(t->data, f->data, t->len * t->datasz);
} else if (t->ptrsz) {
t->type = CAPN_PTR_LIST;
t->size *= t->ptrsz/8;
t->len *= t->ptrsz/8;
(*dep)++;
}
return 0;
case CAPN_PTR_LIST:
if (t->size) {
if (t->len) {
(*dep)++;
}
return 0;
@ -723,7 +723,7 @@ int write_ptr(capn_ptr p, int off, struct capn_ptr tgt, int zeros) {
switch (p.type) {
case CAPN_LIST:
if (off < p.size && tgt.type == CAPN_STRUCT) {
if (off < p.len && tgt.type == CAPN_STRUCT) {
struct capn_ptr *f, *t;
char *d;
int sz;
@ -751,7 +751,7 @@ int write_ptr(capn_ptr p, int off, struct capn_ptr tgt, int zeros) {
t = &to[0];
t->type = CAPN_PTR_LIST;
t->data = d;
t->size = sz/8;
t->len = sz/8;
t->seg = p.seg;
goto copy_loop;
@ -760,7 +760,7 @@ int write_ptr(capn_ptr p, int off, struct capn_ptr tgt, int zeros) {
}
case CAPN_PTR_LIST:
if (off >= p.size)
if (off >= p.len)
return -1;
data = p.data + off * 8;
break;
@ -803,7 +803,7 @@ copy_loop:
return -1;
}
if (!tc->size) {
if (!tc->len) {
dep--;
continue;
}
@ -814,14 +814,14 @@ copy_loop:
*tn = *tc;
fn->type = tn->type = CAPN_STRUCT;
fn->is_list_member = tn->is_list_member = 1;
fn->size = tn->size = 0;
fn->len = tn->len = 0;
if (write_copy(tc->seg, tc->data, tn, fn, &dep, 0))
return -1;
fc->data += tc->datasz + tc->ptrsz;
tc->data += tc->datasz + tc->ptrsz;
tc->size--;
tc->len--;
break;
case CAPN_PTR_LIST:
@ -833,7 +833,7 @@ copy_loop:
fc->data += 8;
tc->data += 8;
tc->size--;
tc->len--;
break;
}
}
@ -845,9 +845,27 @@ int capn_setp(capn_ptr p, int off, capn_ptr tgt) {
return write_ptr(p, off, tgt, 0);
}
int capn_read1(capn_ptr p, int off, uint8_t *data, int sz) {
int capn_get1(capn_list1 l, int off) {
return l.p.type == CAPN_BIT_LIST
&& off < l.p.len
&& (l.p.data[off/8] & (1 << (off%8))) != 0;
}
int capn_set1(capn_list1 l, int off, int val) {
if (l.p.type != CAPN_BIT_LIST || off >= l.p.len)
return -1;
if (val) {
l.p.data[off/8] |= 1 << (off%8);
} else {
l.p.data[off/8] &= ~(1 << (off%8));
}
return 0;
}
int capn_getv1(capn_list1 l, int off, uint8_t *data, int sz) {
/* Note we only support aligned reads */
int bsz;
capn_ptr p = l.p;
if (p.type != CAPN_BIT_LIST || (off & 7) != 0)
return -1;
@ -856,16 +874,17 @@ int capn_read1(capn_ptr p, int off, uint8_t *data, int sz) {
if (off + sz > p.datasz) {
memcpy(data, p.data + off, p.datasz - off);
return p.size - off*8;
return p.len - off*8;
} else {
memcpy(data, p.data + off, bsz);
return sz;
}
}
int capn_write1(capn_ptr p, int off, const uint8_t *data, int sz) {
int capn_setv1(capn_list1 l, int off, const uint8_t *data, int sz) {
/* Note we only support aligned writes */
int bsz;
capn_ptr p = l.p;
if (p.type != CAPN_BIT_LIST || (off & 7) != 0)
return -1;
@ -874,7 +893,7 @@ int capn_write1(capn_ptr p, int off, const uint8_t *data, int sz) {
if (off + sz > p.datasz) {
memcpy(p.data + off, data, p.datasz - off);
return p.size - off*8;
return p.len - off*8;
} else {
memcpy(p.data + off, data, bsz);
return sz;
@ -948,7 +967,7 @@ capn_ptr capn_new_root(struct capn *c) {
if ((s || new_data(c, 8, &s) != NULL) && s->len >= 8) {
p.seg = s;
p.data = p.seg->data;
p.size = 1;
p.len = 1;
p.type = CAPN_PTR_LIST;
}
@ -969,47 +988,47 @@ capn_ptr capn_new_list(struct capn_segment *seg, int sz, int datasz, int ptrs) {
capn_ptr p = {CAPN_NULL};
p.seg = seg;
p.type = CAPN_LIST;
p.size = sz;
p.len = sz;
if (ptrs || datasz > 8) {
p.datasz = (datasz + 7) & ~7;
p.ptrsz = ptrs*8;
p.has_composite_tag = 1;
new_object(&p, p.size * (p.datasz + p.ptrsz) + 8);
new_object(&p, p.len * (p.datasz + p.ptrsz) + 8);
if (p.data) {
uint64_t hdr = STRUCT_PTR | (U64(p.size) << 2) | (U64(p.datasz/8) << 32) | (U64(ptrs) << 48);
uint64_t hdr = STRUCT_PTR | (U64(p.len) << 2) | (U64(p.datasz/8) << 32) | (U64(ptrs) << 48);
*(uint64_t*) p.data = capn_flip64(hdr);
p.data += 8;
}
} else if (datasz > 4) {
p.datasz = 8;
new_object(&p, p.size * 8);
new_object(&p, p.len * 8);
} else if (datasz > 2) {
p.datasz = 4;
new_object(&p, p.size * 4);
new_object(&p, p.len * 4);
} else {
p.datasz = datasz;
new_object(&p, p.size * datasz);
new_object(&p, p.len * datasz);
}
return p;
}
capn_ptr capn_new_bit_list(struct capn_segment *seg, int sz) {
capn_ptr p = {CAPN_NULL};
p.seg = seg;
p.type = CAPN_BIT_LIST;
p.datasz = (sz+7)/8;
p.size = sz;
new_object(&p, p.datasz);
return p;
capn_list1 capn_new_list1(struct capn_segment *seg, int sz) {
capn_list1 l = {{CAPN_NULL}};
l.p.seg = seg;
l.p.type = CAPN_BIT_LIST;
l.p.datasz = (sz+7)/8;
l.p.len = sz;
new_object(&l.p, l.p.datasz);
return l;
}
capn_ptr capn_new_ptr_list(struct capn_segment *seg, int sz) {
capn_ptr p = {CAPN_NULL};
p.seg = seg;
p.type = CAPN_PTR_LIST;
p.size = sz;
p.len = sz;
p.ptrsz = 0;
p.datasz = 0;
new_object(&p, sz*8);
@ -1020,11 +1039,11 @@ capn_ptr capn_new_string(struct capn_segment *seg, const char *str, int sz) {
capn_ptr p = {CAPN_NULL};
p.seg = seg;
p.type = CAPN_LIST;
p.size = ((sz >= 0) ? sz : strlen(str)) + 1;
p.len = ((sz >= 0) ? sz : strlen(str)) + 1;
p.datasz = 1;
new_object(&p, p.size);
new_object(&p, p.len);
if (p.data) {
memcpy(p.data, str, p.size-1);
memcpy(p.data, str, p.len-1);
}
return p;
}
@ -1032,10 +1051,10 @@ capn_ptr capn_new_string(struct capn_segment *seg, const char *str, int sz) {
capn_text capn_get_text(capn_ptr p, int off) {
capn_ptr m = capn_getp(p, off);
capn_text ret = {CAPN_NULL};
if (m.type == CAPN_LIST && m.datasz == 1 && m.size && m.data[m.size - 1] == 0) {
if (m.type == CAPN_LIST && m.datasz == 1 && m.len && m.data[m.len - 1] == 0) {
ret.seg = m.seg;
ret.str = m.data;
ret.size = m.size - 1;
ret.len = m.len - 1;
}
return ret;
}
@ -1046,7 +1065,7 @@ capn_data capn_get_data(capn_ptr p, int off) {
if (m.type == CAPN_LIST && m.datasz == 1) {
ret.seg = m.seg;
ret.data = (uint8_t*) m.data;
ret.size = m.size;
ret.len = m.len;
}
return ret;
}
@ -1057,7 +1076,7 @@ int capn_set_text(capn_ptr p, int off, capn_text tgt) {
m.type = CAPN_LIST;
m.seg = tgt.seg;
m.data = (char*)tgt.str;
m.size = (tgt.size >= 0 ? tgt.size : strlen(tgt.str)) + 1;
m.len = (tgt.len >= 0 ? tgt.len : strlen(tgt.str)) + 1;
m.datasz = 1;
}
/* in the case that the size is specified we need to be careful
@ -1073,7 +1092,7 @@ int capn_set_data(capn_ptr p, int off, capn_data tgt) {
m.type = CAPN_LIST;
m.seg = tgt.seg;
m.data = (char*)tgt.data;
m.size = tgt.size;
m.len = tgt.len;
m.datasz = 1;
}
return write_ptr(p, off, m, 0);

103
capn.h
View file

@ -12,6 +12,12 @@ extern "C" {
#define CAPN_SEGID_LOCAL 0xFFFFFFFF
#if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
#define CAPN_INLINE static inline
#else
#define CAPN_INLINE static
#endif
/* struct capn is a common structure shared between segments in the same
* session/context so that far pointers between the segments will be created.
*
@ -91,19 +97,19 @@ struct capn_ptr {
unsigned int has_composite_tag : 1;
unsigned int datasz : 19;
unsigned int ptrsz : 19;
int size;
int len;
char *data;
struct capn_segment *seg;
};
struct capn_text {
int size;
int len;
const char *str;
struct capn_segment *seg;
};
struct capn_data {
int size;
int len;
const uint8_t *data;
struct capn_segment *seg;
};
@ -111,6 +117,11 @@ struct capn_data {
typedef struct capn_ptr capn_ptr;
typedef struct capn_text capn_text;
typedef struct capn_data capn_data;
typedef struct {capn_ptr p;} capn_list1;
typedef struct {capn_ptr p;} capn_list8;
typedef struct {capn_ptr p;} capn_list16;
typedef struct {capn_ptr p;} capn_list32;
typedef struct {capn_ptr p;} capn_list64;
/* capn_append_segment appends a segment to a session */
void capn_append_segment(struct capn*, struct capn_segment*);
@ -138,16 +149,16 @@ int capn_set_data(capn_ptr p, int off, capn_data tgt);
* The function returns the number of elements read or -1 on an error.
* off must be byte aligned for capn_get1v
*/
int capn_get1(capn_ptr p, int off);
uint8_t capn_get8(capn_ptr p, int off);
uint16_t capn_get16(capn_ptr p, int off);
uint32_t capn_get32(capn_ptr p, int off);
uint64_t capn_get64(capn_ptr p, int off);
int capn_getv1(capn_ptr p, int off, uint8_t *data, int sz);
int capn_getv8(capn_ptr p, int off, uint8_t *data, int sz);
int capn_getv16(capn_ptr p, int off, uint16_t *data, int sz);
int capn_getv32(capn_ptr p, int off, uint32_t *data, int sz);
int capn_getv64(capn_ptr p, int off, uint64_t *data, int sz);
int capn_get1(capn_list1 p, int off);
uint8_t capn_get8(capn_list8 p, int off);
uint16_t capn_get16(capn_list16 p, int off);
uint32_t capn_get32(capn_list32 p, int off);
uint64_t capn_get64(capn_list64 p, int off);
int capn_getv1(capn_list1 p, int off, uint8_t *data, int sz);
int capn_getv8(capn_list8 p, int off, uint8_t *data, int sz);
int capn_getv16(capn_list16 p, int off, uint16_t *data, int sz);
int capn_getv32(capn_list32 p, int off, uint32_t *data, int sz);
int capn_getv64(capn_list64 p, int off, uint64_t *data, int sz);
/* capn_set_* function set data in a list
* off specifies how far into the list to start
@ -155,34 +166,30 @@ int capn_getv64(capn_ptr p, int off, uint64_t *data, int sz);
* The function returns the number of elemnts written or -1 on an error.
* off must be byte aligned for capn_set1v
*/
int capn_set1(capn_ptr p, int off, int v);
int capn_set8(capn_ptr p, int off, uint8_t v);
int capn_set16(capn_ptr p, int off, uint16_t v);
int capn_set32(capn_ptr p, int off, uint32_t v);
int capn_set64(capn_ptr p, int off, uint64_t v);
int capn_setv1(capn_ptr p, int off, const uint8_t *data, int sz);
int capn_setv8(capn_ptr p, int off, const uint8_t *data, int sz);
int capn_setv16(capn_ptr p, int off, const uint16_t *data, int sz);
int capn_setv32(capn_ptr p, int off, const uint32_t *data, int sz);
int capn_setv64(capn_ptr p, int off, const uint64_t *data, int sz);
int capn_set1(capn_list1 p, int off, int v);
int capn_set8(capn_list8 p, int off, uint8_t v);
int capn_set16(capn_list16 p, int off, uint16_t v);
int capn_set32(capn_list32 p, int off, uint32_t v);
int capn_set64(capn_list64 p, int off, uint64_t v);
int capn_setv1(capn_list1 p, int off, const uint8_t *data, int sz);
int capn_setv8(capn_list8 p, int off, const uint8_t *data, int sz);
int capn_setv16(capn_list16 p, int off, const uint16_t *data, int sz);
int capn_setv32(capn_list32 p, int off, const uint32_t *data, int sz);
int capn_setv64(capn_list64 p, int off, const uint64_t *data, int sz);
/* capn_new_* functions create a new object
* datasz is in bytes, ptrs is # of pointers, sz is # of elements in the list
* If capn_new_string sz < 0, strlen is used to compute the string length
* On an error a CAPN_NULL pointer is returned
*/
capn_ptr capn_new_root(struct capn*);
capn_ptr capn_new_struct(struct capn_segment *seg, int datasz, int ptrs);
capn_ptr capn_new_list(struct capn_segment *seg, int sz, int datasz, int ptrs);
capn_ptr capn_new_bit_list(struct capn_segment *seg, int sz);
capn_list1 capn_new_list1(struct capn_segment *seg, int sz);
capn_ptr capn_new_ptr_list(struct capn_segment *seg, int sz);
capn_ptr capn_new_string(struct capn_segment *seg, const char *str, int sz);
capn_ptr capn_new_root(struct capn*);
#if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
#define CAPN_INLINE static inline
#else
#define CAPN_INLINE static
#endif
CAPN_INLINE capn_list8 capn_new_list8(struct capn_segment *seg, int sz);
CAPN_INLINE capn_list16 capn_new_list16(struct capn_segment *seg, int sz);
CAPN_INLINE capn_list32 capn_new_list32(struct capn_segment *seg, int sz);
CAPN_INLINE capn_list64 capn_new_list64(struct capn_segment *seg, int sz);
/* capn_read|write_* functions read/write struct values
* off is the offset into the structure in bytes
@ -194,6 +201,7 @@ CAPN_INLINE uint8_t capn_read8(capn_ptr p, int off);
CAPN_INLINE uint16_t capn_read16(capn_ptr p, int off);
CAPN_INLINE uint32_t capn_read32(capn_ptr p, int off);
CAPN_INLINE uint64_t capn_read64(capn_ptr p, int off);
CAPN_INLINE int capn_write1(capn_ptr p, int off, int val);
CAPN_INLINE int capn_write8(capn_ptr p, int off, uint8_t val);
CAPN_INLINE int capn_write16(capn_ptr p, int off, uint16_t val);
CAPN_INLINE int capn_write32(capn_ptr p, int off, uint32_t val);
@ -272,6 +280,18 @@ CAPN_INLINE uint64_t capn_flip64(uint64_t v) {
}
#undef T
CAPN_INLINE int capn_write1(capn_ptr p, int off, int val) {
if (off >= p.datasz*8) {
return -1;
} else if (val) {
((uint8_t*)p.data)[off/8] |= 1 << (off%8);
return 0;
} else {
((uint8_t*)p.data)[off/8] &= ~(1 << (off%8));
return 0;
}
}
CAPN_INLINE uint8_t capn_read8(capn_ptr p, int off) {
return off+1 <= p.datasz ? capn_flip8(*(uint8_t*) (p.data+off)) : 0;
}
@ -348,6 +368,23 @@ CAPN_INLINE int capn_write_double(capn_ptr p, int off, double f, double def) {
return capn_write64(p, off, u.u ^ d.u);
}
CAPN_INLINE capn_list8 capn_new_list8(struct capn_segment *seg, int sz) {
capn_list8 p = {capn_new_list(seg, sz, 1, 0)};
return p;
}
CAPN_INLINE capn_list16 capn_new_list16(struct capn_segment *seg, int sz) {
capn_list16 p = {capn_new_list(seg, sz, 2, 0)};
return p;
}
CAPN_INLINE capn_list32 capn_new_list32(struct capn_segment *seg, int sz) {
capn_list32 p = {capn_new_list(seg, sz, 4, 0)};
return p;
}
CAPN_INLINE capn_list64 capn_new_list64(struct capn_segment *seg, int sz) {
capn_list64 p = {capn_new_list(seg, sz, 8, 0)};
return p;
}
#ifdef __cplusplus
}
#endif

2
compiler/schema-test.cpp
View file

@ -189,7 +189,7 @@ TEST(Schema, ReadSimple) {
struct CodeGeneratorRequest req;
read_CodeGeneratorRequest(&req, root);
for (size_t i = 0; i < req.nodes.p.size; i++) {
for (size_t i = 0; i < req.nodes.p.len; i++) {
}
}

2
compiler/schema.c
View file

@ -314,6 +314,6 @@ void read_AnnotationNode(struct AnnotationNode *s, AnnotationNode_ptr p) {
void read_CodeGeneratorRequest(struct CodeGeneratorRequest *s, CodeGeneratorRequest_ptr p) {
s->nodes.p = capn_getp(p.p, 0);
s->requestedFiles = capn_getp(p.p, 1);
s->requestedFiles.p = capn_getp(p.p, 1);
}

2
compiler/schema.h
View file

@ -325,7 +325,7 @@ struct AnnotationNode {
struct CodeGeneratorRequest {
Node_list nodes;
capn_ptr requestedFiles; /* List(uint64_t) */
capn_list64 requestedFiles;
};
#ifdef __cplusplus