From 923393d543f28868569474b8e844f317d10f4024 Mon Sep 17 00:00:00 2001 From: James McKaskill Date: Wed, 8 May 2013 22:38:07 -0400 Subject: [PATCH] size -> len and add capn_list* back in --- capn-list.inc | 26 ++++--- capn-test.cpp | 98 +++++++++++++------------ capn.c | 155 ++++++++++++++++++++++----------------- capn.h | 103 +++++++++++++++++--------- compiler/schema-test.cpp | 2 +- compiler/schema.c | 2 +- compiler/schema.h | 2 +- 7 files changed, 225 insertions(+), 163 deletions(-) diff --git a/capn-list.inc b/capn-list.inc index 55062da..7302df2 100644 --- a/capn-list.inc +++ b/capn-list.inc @@ -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) { diff --git a/capn-test.cpp b/capn-test.cpp index 941a86c..491593d 100644 --- a/capn-test.cpp +++ b/capn-test.cpp @@ -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)); } diff --git a/capn.c b/capn.c index f428bca..3ba75ce 100644 --- a/capn.c +++ b/capn.c @@ -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); diff --git a/capn.h b/capn.h index 7078f99..0af17db 100644 --- a/capn.h +++ b/capn.h @@ -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 diff --git a/compiler/schema-test.cpp b/compiler/schema-test.cpp index c4259e8..0117cec 100644 --- a/compiler/schema-test.cpp +++ b/compiler/schema-test.cpp @@ -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++) { } } diff --git a/compiler/schema.c b/compiler/schema.c index 3a9c19c..9919cd4 100644 --- a/compiler/schema.c +++ b/compiler/schema.c @@ -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); } diff --git a/compiler/schema.h b/compiler/schema.h index 06afa76..ff1f027 100644 --- a/compiler/schema.h +++ b/compiler/schema.h @@ -325,7 +325,7 @@ struct AnnotationNode { struct CodeGeneratorRequest { Node_list nodes; - capn_ptr requestedFiles; /* List(uint64_t) */ + capn_list64 requestedFiles; }; #ifdef __cplusplus