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

remove CAPN_COMPOSITE_LIST and add capn_len

Browse source
This commit is contained in:
James McKaskill 2013-09-16 16:53:33 -04:00
parent 59f827e93d
commit ff44e4df26
6 changed files with 165 additions and 180 deletions
Download patch file Download diff file Expand all files Collapse all files

4
capn-list.inc
View file

@ -14,7 +14,6 @@ UINT_T CAT(capn_get,SZ) (LIST_T l, int off) {
switch (p.type) { switch (p.type) {
case CAPN_LIST: case CAPN_LIST:
case CAPN_COMPOSITE_LIST:
if (p.datasz < SZ/8) if (p.datasz < SZ/8)
return 0; return 0;
d = p.data + off * (p.datasz + 8*p.ptrs); d = p.data + off * (p.datasz + 8*p.ptrs);
@ -42,7 +41,6 @@ int CAT(capn_getv,SZ) (LIST_T l, int off, UINT_T *to, int sz) {
switch (p.type) { switch (p.type) {
case CAPN_LIST: case CAPN_LIST:
case CAPN_COMPOSITE_LIST:
if (p.datasz == SZ/8 && !p.ptrs && (SZ == 8 || CAPN_LITTLE)) { if (p.datasz == SZ/8 && !p.ptrs && (SZ == 8 || CAPN_LITTLE)) {
memcpy(to, p.data + off, sz * (SZ/8)); memcpy(to, p.data + off, sz * (SZ/8));
return sz; return sz;
@ -81,7 +79,6 @@ int CAT(capn_set,SZ) (LIST_T l, int off, UINT_T v) {
switch (p.type) { switch (p.type) {
case CAPN_LIST: case CAPN_LIST:
case CAPN_COMPOSITE_LIST:
if (p.datasz < SZ/8) if (p.datasz < SZ/8)
return -1; return -1;
d = p.data + off * (p.datasz + 8*p.ptrs); d = p.data + off * (p.datasz + 8*p.ptrs);
@ -110,7 +107,6 @@ int CAT(capn_setv,SZ) (LIST_T l, int off, const UINT_T *from, int sz) {
switch (p.type) { switch (p.type) {
case CAPN_LIST: case CAPN_LIST:
case CAPN_COMPOSITE_LIST:
if (p.datasz == SZ/8 && !p.ptrs && (SZ == 8 || CAPN_LITTLE)) { if (p.datasz == SZ/8 && !p.ptrs && (SZ == 8 || CAPN_LITTLE)) {
memcpy(p.data + off, from, sz * (SZ/8)); memcpy(p.data + off, from, sz * (SZ/8));
return sz; return sz;

12
capn-test.cpp
View file

@ -105,14 +105,16 @@ static void setupStruct(struct capn *ctx) {
EXPECT_EQ(0, capn_setp(ptr, 1, list32.p)); EXPECT_EQ(0, capn_setp(ptr, 1, list32.p));
capn_ptr list = capn_new_list(ptr.seg, 4, 4, 1); capn_ptr list = capn_new_list(ptr.seg, 4, 4, 1);
ASSERT_EQ(CAPN_COMPOSITE_LIST, list.type); ASSERT_EQ(CAPN_LIST, list.type);
ASSERT_EQ(1, list.is_composite_list);
EXPECT_EQ(4, list.len); EXPECT_EQ(4, list.len);
EXPECT_EQ(8, list.datasz); EXPECT_EQ(8, list.datasz);
EXPECT_EQ(1, list.ptrs); EXPECT_EQ(1, list.ptrs);
EXPECT_EQ(0, capn_setp(ptr, 2, list)); EXPECT_EQ(0, capn_setp(ptr, 2, list));
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
capn_ptr element = capn_getp(list, i, 1); capn_ptr element = capn_getp(list, i, 1);
ASSERT_EQ(CAPN_LIST_MEMBER, element.type); ASSERT_EQ(CAPN_STRUCT, element.type);
EXPECT_EQ(1, element.is_list_member);
EXPECT_EQ(8, element.datasz); EXPECT_EQ(8, element.datasz);
EXPECT_EQ(1, element.ptrs); EXPECT_EQ(1, element.ptrs);
EXPECT_EQ(0, capn_write32(element, 0, 300+i)); EXPECT_EQ(0, capn_write32(element, 0, 300+i));
@ -184,14 +186,16 @@ static void checkStruct(struct capn *ctx) {
EXPECT_EQ(202, capn_get16(list16, 2)); EXPECT_EQ(202, capn_get16(list16, 2));
capn_ptr list = capn_getp(ptr, 2, 1); capn_ptr list = capn_getp(ptr, 2, 1);
EXPECT_EQ(CAPN_COMPOSITE_LIST, list.type); EXPECT_EQ(CAPN_LIST, list.type);
EXPECT_EQ(1, list.is_composite_list);
EXPECT_EQ(4, list.len); EXPECT_EQ(4, list.len);
EXPECT_EQ(8, list.datasz); EXPECT_EQ(8, list.datasz);
EXPECT_EQ(1, list.ptrs); EXPECT_EQ(1, list.ptrs);
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
capn_ptr element = capn_getp(list, i, 1); capn_ptr element = capn_getp(list, i, 1);
EXPECT_EQ(CAPN_LIST_MEMBER, element.type); EXPECT_EQ(CAPN_STRUCT, element.type);
EXPECT_EQ(1, element.is_list_member);
EXPECT_EQ(8, element.datasz); EXPECT_EQ(8, element.datasz);
EXPECT_EQ(1, element.ptrs); EXPECT_EQ(1, element.ptrs);
EXPECT_EQ(300+i, capn_read32(element,0)); EXPECT_EQ(300+i, capn_read32(element,0));

76
capn.c
View file

@ -383,7 +383,7 @@ static capn_ptr read_ptr(struct capn_segment *s, char *d) {
ret.datasz = U32(U16(val >> 32)) * 8; ret.datasz = U32(U16(val >> 32)) * 8;
ret.ptrs = U32(U16(val >> 48)); ret.ptrs = U32(U16(val >> 48));
ret.len = U32(val) >> 2; ret.len = U32(val) >> 2;
ret.type = CAPN_COMPOSITE_LIST; ret.is_composite_list = 1;
if ((ret.datasz + 8*ret.ptrs) * ret.len != e - d) { if ((ret.datasz + 8*ret.ptrs) * ret.len != e - d) {
goto err; goto err;
@ -408,9 +408,10 @@ err:
} }
void capn_resolve(capn_ptr *p) { void capn_resolve(capn_ptr *p) {
if (p->type == CAPN_FAR_POINTER) if (p->type == CAPN_FAR_POINTER) {
*p = read_ptr(p->seg, p->data); *p = read_ptr(p->seg, p->data);
} }
}
capn_ptr capn_getp(capn_ptr p, int off, int resolve) { capn_ptr capn_getp(capn_ptr p, int off, int resolve) {
capn_ptr ret = {CAPN_FAR_POINTER}; capn_ptr ret = {CAPN_FAR_POINTER};
@ -419,11 +420,11 @@ capn_ptr capn_getp(capn_ptr p, int off, int resolve) {
capn_resolve(&p); capn_resolve(&p);
switch (p.type) { switch (p.type) {
case CAPN_COMPOSITE_LIST:
case CAPN_LIST: case CAPN_LIST:
/* Return an inner pointer */ /* Return an inner pointer */
if (off < p.len) { if (off < p.len) {
capn_ptr ret = {CAPN_LIST_MEMBER}; capn_ptr ret = {CAPN_STRUCT};
ret.is_list_member = 1;
ret.data = p.data + off * (p.datasz + 8*p.ptrs); ret.data = p.data + off * (p.datasz + 8*p.ptrs);
ret.seg = p.seg; ret.seg = p.seg;
ret.datasz = p.datasz; ret.datasz = p.datasz;
@ -433,7 +434,6 @@ capn_ptr capn_getp(capn_ptr p, int off, int resolve) {
goto err; goto err;
} }
case CAPN_LIST_MEMBER:
case CAPN_STRUCT: case CAPN_STRUCT:
if (off >= p.ptrs) { if (off >= p.ptrs) {
goto err; goto err;
@ -463,23 +463,6 @@ err:
return p; return p;
} }
static int data_size(struct capn_ptr p) {
switch (p.type) {
case CAPN_BIT_LIST:
return p.datasz;
case CAPN_PTR_LIST:
return p.len*8;
case CAPN_STRUCT:
return p.datasz + 8*p.ptrs;
case CAPN_COMPOSITE_LIST:
return p.len * (p.datasz + 8*p.ptrs) + 8;
case CAPN_LIST:
return p.len * (p.datasz + 8*p.ptrs);
default:
return 0;
}
}
static void write_ptr_tag(char *d, capn_ptr p, int off) { static void write_ptr_tag(char *d, capn_ptr p, int off) {
uint64_t val = U64(U32(I32(off/8) << 2)); uint64_t val = U64(U32(I32(off/8) << 2));
@ -488,11 +471,10 @@ static void write_ptr_tag(char *d, capn_ptr p, int off) {
val |= STRUCT_PTR | (U64(p.datasz/8) << 32) | (U64(p.ptrs) << 48); val |= STRUCT_PTR | (U64(p.datasz/8) << 32) | (U64(p.ptrs) << 48);
break; break;
case CAPN_COMPOSITE_LIST:
val |= LIST_PTR | (U64(COMPOSITE_LIST) << 32) | (U64(p.len * (p.datasz/8 + p.ptrs)) << 35);
break;
case CAPN_LIST: case CAPN_LIST:
if (p.is_composite_list) {
val |= LIST_PTR | (U64(COMPOSITE_LIST) << 32) | (U64(p.len * (p.datasz/8 + p.ptrs)) << 35);
} else {
val |= LIST_PTR | (U64(p.len) << 35); val |= LIST_PTR | (U64(p.len) << 35);
if (p.datasz == 8) { if (p.datasz == 8) {
@ -506,6 +488,7 @@ static void write_ptr_tag(char *d, capn_ptr p, int off) {
} else { } else {
val |= (U64(VOID_LIST) << 32); val |= (U64(VOID_LIST) << 32);
} }
}
break; break;
case CAPN_BIT_LIST: case CAPN_BIT_LIST:
@ -536,13 +519,13 @@ static void write_double_far(char *d, struct capn_segment *s, char *tgt) {
static int write_ptr(struct capn_segment *s, char *d, capn_ptr p) { static int write_ptr(struct capn_segment *s, char *d, capn_ptr p) {
/* note p.seg can be NULL if its a ptr to static data */ /* note p.seg can be NULL if its a ptr to static data */
char *pdata = p.data - (p.type == CAPN_COMPOSITE_LIST ? 8 : 0); char *pdata = p.data - 8*p.is_composite_list;
if (data_size(p) == 0) { if (p.type == CAPN_NULL || (p.type == CAPN_STRUCT && p.datasz == 0 && p.ptrs == 0)) {
write_ptr_tag(d, p, 0); write_ptr_tag(d, p, 0);
return 0; return 0;
} else if (!p.seg || p.seg->capn != s->capn || p.type == CAPN_LIST_MEMBER) { } else if (!p.seg || p.seg->capn != s->capn || p.is_list_member) {
return NEED_TO_COPY; return NEED_TO_COPY;
} else if (p.seg == s) { } else if (p.seg == s) {
@ -600,14 +583,12 @@ struct copy {
static capn_ptr new_clone(struct capn_segment *s, capn_ptr p) { static capn_ptr new_clone(struct capn_segment *s, capn_ptr p) {
switch (p.type) { switch (p.type) {
case CAPN_STRUCT: case CAPN_STRUCT:
case CAPN_LIST_MEMBER:
return capn_new_struct(s, p.datasz, p.ptrs); return capn_new_struct(s, p.datasz, p.ptrs);
case CAPN_PTR_LIST: case CAPN_PTR_LIST:
return capn_new_ptr_list(s, p.len); return capn_new_ptr_list(s, p.len);
case CAPN_BIT_LIST: case CAPN_BIT_LIST:
return capn_new_list1(s, p.len).p; return capn_new_list1(s, p.len).p;
case CAPN_LIST: case CAPN_LIST:
case CAPN_COMPOSITE_LIST:
return capn_new_list(s, p.len, p.datasz, p.ptrs); return capn_new_list(s, p.len, p.datasz, p.ptrs);
default: default:
return p; return p;
@ -622,12 +603,28 @@ static int is_ptr_equal(const struct capn_ptr *a, const struct capn_ptr *b) {
&& a->ptrs == b->ptrs; && a->ptrs == b->ptrs;
} }
static int data_size(struct capn_ptr p) {
switch (p.type) {
case CAPN_BIT_LIST:
return p.datasz;
case CAPN_PTR_LIST:
return p.len*8;
case CAPN_STRUCT:
return p.datasz + 8*p.ptrs;
case CAPN_LIST:
return p.len * (p.datasz + 8*p.ptrs) + 8*p.is_composite_list;
default:
return 0;
}
}
static int copy_ptr(struct capn_segment *seg, char *data, struct capn_ptr *t, struct capn_ptr *f, int *dep) { static int copy_ptr(struct capn_segment *seg, char *data, struct capn_ptr *t, struct capn_ptr *f, int *dep) {
struct capn *c = seg->capn; struct capn *c = seg->capn;
struct copy *cp = NULL; struct copy *cp = NULL;
struct capn_tree **xcp; struct capn_tree **xcp;
char *fbegin = f->data - (f->type == CAPN_COMPOSITE_LIST ? 8 : 0); char *fbegin = f->data - 8*f->is_composite_list;
char *fend = fbegin + data_size(*f); char *fend = fbegin + data_size(*f);
int zero_sized = (fend == fbegin);
/* We always copy list members as it would otherwise be an /* We always copy list members as it would otherwise be an
* overlapped pointer (the data is owned by the enclosing list). * overlapped pointer (the data is owned by the enclosing list).
@ -638,7 +635,7 @@ static int copy_ptr(struct capn_segment *seg, char *data, struct capn_ptr *t, st
*/ */
xcp = &c->copy; xcp = &c->copy;
while (*xcp && fend > fbegin) { while (*xcp && !zero_sized) {
cp = (struct copy*) *xcp; cp = (struct copy*) *xcp;
if (fend <= cp->fbegin) { if (fend <= cp->fbegin) {
xcp = &cp->hdr.link[0]; xcp = &cp->hdr.link[0];
@ -661,7 +658,7 @@ static int copy_ptr(struct capn_segment *seg, char *data, struct capn_ptr *t, st
/* add the copy to the copy tree so we can look for overlapping /* add the copy to the copy tree so we can look for overlapping
* source pointers and handle recursive structures */ * source pointers and handle recursive structures */
if (fend > fbegin) { if (!zero_sized) {
struct copy *n; struct copy *n;
struct capn_segment *cs = c->copylist; struct capn_segment *cs = c->copylist;
@ -713,7 +710,6 @@ static int copy_ptr(struct capn_segment *seg, char *data, struct capn_ptr *t, st
return 0; return 0;
case CAPN_LIST: case CAPN_LIST:
case CAPN_COMPOSITE_LIST:
if (!t->len) { if (!t->len) {
/* empty list - nothing to copy */ /* empty list - nothing to copy */
} else if (t->ptrs && t->datasz) { } else if (t->ptrs && t->datasz) {
@ -779,8 +775,7 @@ int capn_setp(capn_ptr p, int off, capn_ptr tgt) {
switch (p.type) { switch (p.type) {
case CAPN_LIST: case CAPN_LIST:
case CAPN_COMPOSITE_LIST: if (off >= p.len || tgt.type != CAPN_STRUCT)
if (off >= p.len || (tgt.type != CAPN_STRUCT && tgt.type != CAPN_LIST_MEMBER))
return -1; return -1;
to[0] = p; to[0] = p;
@ -796,7 +791,6 @@ int capn_setp(capn_ptr p, int off, capn_ptr tgt) {
goto copy_ptr; goto copy_ptr;
case CAPN_STRUCT: case CAPN_STRUCT:
case CAPN_LIST_MEMBER:
if (off >= p.ptrs) if (off >= p.ptrs)
return -1; return -1;
data = p.data + p.datasz + 8*off; data = p.data + p.datasz + 8*off;
@ -837,7 +831,7 @@ int capn_setp(capn_ptr p, int off, capn_ptr tgt) {
continue; continue;
} }
if (tc->type == CAPN_COMPOSITE_LIST) { if (tc->type == CAPN_LIST) {
*fn = capn_getp(*fc, 0, 1); *fn = capn_getp(*fc, 0, 1);
*tn = capn_getp(*tc, 0, 1); *tn = capn_getp(*tc, 0, 1);
@ -862,6 +856,8 @@ int capn_setp(capn_ptr p, int off, capn_ptr tgt) {
return 0; return 0;
} }
/* TODO: handle CAPN_LIST, CAPN_PTR_LIST for bit lists */
int capn_get1(capn_list1 l, int off) { int capn_get1(capn_list1 l, int off) {
return l.p.type == CAPN_BIT_LIST return l.p.type == CAPN_BIT_LIST
&& off < l.p.len && off < l.p.len
@ -990,7 +986,7 @@ capn_ptr capn_new_list(struct capn_segment *seg, int sz, int datasz, int ptrs) {
if (!sz) { if (!sz) {
/* empty lists may as well be a len=0 void list */ /* empty lists may as well be a len=0 void list */
} else if (ptrs || datasz > 8) { } else if (ptrs || datasz > 8) {
p.type = CAPN_COMPOSITE_LIST; p.is_composite_list = 1;
p.datasz = (datasz + 7) & ~7; p.datasz = (datasz + 7) & ~7;
p.ptrs = ptrs; p.ptrs = ptrs;
new_object(&p, p.len * (p.datasz + 8*p.ptrs) + 8); new_object(&p, p.len * (p.datasz + 8*p.ptrs) + 8);

6
capn.h
View file

@ -105,13 +105,13 @@ enum CAPN_TYPE {
CAPN_PTR_LIST = 3, CAPN_PTR_LIST = 3,
CAPN_BIT_LIST = 4, CAPN_BIT_LIST = 4,
CAPN_FAR_POINTER = 5, CAPN_FAR_POINTER = 5,
CAPN_LIST_MEMBER = 6,
CAPN_COMPOSITE_LIST = 7
}; };
struct capn_ptr { struct capn_ptr {
unsigned int type : 4; unsigned int type : 4;
unsigned int has_ptr_tag : 1; unsigned int has_ptr_tag : 1;
unsigned int is_list_member : 1;
unsigned int is_composite_list : 1;
unsigned int datasz : 19; unsigned int datasz : 19;
unsigned int ptrs : 16; unsigned int ptrs : 16;
int len; int len;
@ -147,6 +147,8 @@ void capn_append_segment(struct capn*, struct capn_segment*);
capn_ptr capn_root(struct capn *c); capn_ptr capn_root(struct capn *c);
void capn_resolve(capn_ptr *p); void capn_resolve(capn_ptr *p);
#define capn_len(list) ((list).p.type == CAPN_FAR_POINTER ? (capn_resolve(&(list).p), (list).p.len) : (list).p.len)
/* capn_getp|setp functions get/set ptrs in list/structs /* capn_getp|setp functions get/set ptrs in list/structs
* off is the list index or pointer index in a struct * off is the list index or pointer index in a struct
* capn_setp will copy the data, create far pointers, etc if the target * capn_setp will copy the data, create far pointers, etc if the target

43
compiler/capnpc-c.c
View file

@ -68,16 +68,14 @@ static void resolve_names(struct str *b, struct node *n, capn_text name, struct
str_add(&n->name, b->str, b->len); str_add(&n->name, b->str, b->len);
str_add(b, "_", 1); str_add(b, "_", 1);
capn_resolve(&n->n.nestedNodes.p); for (i = capn_len(n->n.nestedNodes)-1; i >= 0; i--) {
for (i = n->n.nestedNodes.p.len-1; i >= 0; i--) {
struct Node_NestedNode nest; struct Node_NestedNode nest;
get_Node_NestedNode(&nest, n->n.nestedNodes, i); get_Node_NestedNode(&nest, n->n.nestedNodes, i);
resolve_names(b, find_node(nest.id), nest.name, file); resolve_names(b, find_node(nest.id), nest.name, file);
} }
if (n->n.which == Node__struct) { if (n->n.which == Node__struct) {
for (i = n->n._struct.fields.p.len-1; i >= 0; i--) { for (i = capn_len(n->n._struct.fields)-1; i >= 0; i--) {
if (n->fields[i].group) { if (n->fields[i].group) {
resolve_names(b, n->fields[i].group, n->fields[i].f.name, file); resolve_names(b, n->fields[i].group, n->fields[i].f.name, file);
} }
@ -95,9 +93,8 @@ static void resolve_names(struct str *b, struct node *n, capn_text name, struct
static void define_enum(struct node *n) { static void define_enum(struct node *n) {
int i; int i;
capn_resolve(&n->n._enum.enumerants.p);
str_addf(&HDR, "\nenum %s {", n->name.str); str_addf(&HDR, "\nenum %s {", n->name.str);
for (i = 0; i < n->n._enum.enumerants.p.len; i++) { for (i = 0; i < capn_len(n->n._enum.enumerants); i++) {
struct Enumerant e; struct Enumerant e;
get_Enumerant(&e, n->n._enum.enumerants, i); get_Enumerant(&e, n->n._enum.enumerants, i);
if (i) { if (i) {
@ -285,9 +282,11 @@ static void decode_value(struct value* v, Type_ptr type, Value_ptr value, const
if (strcmp(v->tname, "capn_ptr")) if (strcmp(v->tname, "capn_ptr"))
str_addf(&SRC, "{"); str_addf(&SRC, "{");
str_addf(&SRC, "%d,%d,%d,%d,%d,(char*)&capn_buf[%d],(struct capn_segment*)&capn_seg", str_addf(&SRC, "%d,%d,%d,%d,%d,%d,%d,(char*)&capn_buf[%d],(struct capn_segment*)&capn_seg",
p.type, p.type,
p.has_ptr_tag, p.has_ptr_tag,
p.is_list_member,
p.is_composite_list,
p.datasz, p.datasz,
p.ptrs, p.ptrs,
p.len, p.len,
@ -381,8 +380,8 @@ static void decode_field(struct field *fields, Field_list l, int i) {
memset(&f, 0, sizeof(f)); memset(&f, 0, sizeof(f));
get_Field(&f.f, l, i); get_Field(&f.f, l, i);
if (f.f.codeOrder >= l.p.len) { if (f.f.codeOrder >= capn_len(l)) {
fprintf(stderr, "unexpectedly large code order %d >= %d\n", f.f.codeOrder, l.p.len); fprintf(stderr, "unexpectedly large code order %d >= %d\n", f.f.codeOrder, capn_len(l));
exit(3); exit(3);
} }
@ -660,7 +659,7 @@ static int in_union(struct field *f) {
static void union_cases(struct strings *s, struct node *n, struct field *first_field, int mask) { static void union_cases(struct strings *s, struct node *n, struct field *first_field, int mask) {
struct field *f, *u = NULL; struct field *f, *u = NULL;
for (f = first_field; f < n->fields + n->n._struct.fields.p.len && in_union(f); f++) { for (f = first_field; f < n->fields + capn_len(n->n._struct.fields) && in_union(f); f++) {
if (f->f.which != Field_slot) if (f->f.which != Field_slot)
continue; continue;
@ -735,7 +734,7 @@ static void do_union(struct strings *s, struct node *n, struct field *first_fiel
str_add(&s->dtab, "\t", -1); str_add(&s->dtab, "\t", -1);
/* when we have defaults or groups we have to emit each case seperately */ /* when we have defaults or groups we have to emit each case seperately */
for (f = first_field; f < n->fields + n->n._struct.fields.p.len && in_union(f); f++) { for (f = first_field; f < n->fields + capn_len(n->n._struct.fields) && in_union(f); f++) {
if (f > first_field) { if (f > first_field) {
str_addf(&enums, ","); str_addf(&enums, ",");
} }
@ -801,7 +800,7 @@ static void define_field(struct strings *s, struct field *f) {
static void define_group(struct strings *s, struct node *n, const char *group_name) { static void define_group(struct strings *s, struct node *n, const char *group_name) {
struct field *f; struct field *f;
int flen = n->n._struct.fields.p.len; int flen = capn_len(n->n._struct.fields);
int ulen = n->n._struct.discriminantCount; int ulen = n->n._struct.discriminantCount;
/* named union is where all group members are in the union */ /* named union is where all group members are in the union */
int named_union = (group_name && ulen == flen && ulen > 0); int named_union = (group_name && ulen == flen && ulen > 0);
@ -1084,9 +1083,7 @@ int main() {
root.p = capn_getp(capn_root(&capn), 0, 1); root.p = capn_getp(capn_root(&capn), 0, 1);
read_CodeGeneratorRequest(&req, root); read_CodeGeneratorRequest(&req, root);
capn_resolve(&req.nodes.p); for (i = 0; i < capn_len(req.nodes); i++) {
for (i = 0; i < req.nodes.p.len; i++) {
n = calloc(1, sizeof(*n)); n = calloc(1, sizeof(*n));
get_Node(&n->n, req.nodes, i); get_Node(&n->n, req.nodes, i);
insert_node(n); insert_node(n);
@ -1098,7 +1095,6 @@ int main() {
break; break;
case Node__struct: case Node__struct:
capn_resolve(&n->n._struct.fields.p);
n->next = all_structs; n->next = all_structs;
all_structs = n; all_structs = n;
break; break;
@ -1109,17 +1105,16 @@ int main() {
} }
for (n = all_structs; n != NULL; n = n->next) { for (n = all_structs; n != NULL; n = n->next) {
n->fields = calloc(n->n._struct.fields.p.len, sizeof(n->fields[0])); n->fields = calloc(capn_len(n->n._struct.fields), sizeof(n->fields[0]));
for (j = 0; j < n->n._struct.fields.p.len; j++) { for (j = 0; j < capn_len(n->n._struct.fields); j++) {
decode_field(n->fields, n->n._struct.fields, j); decode_field(n->fields, n->n._struct.fields, j);
} }
} }
for (n = all_files; n != NULL; n = n->next) { for (n = all_files; n != NULL; n = n->next) {
struct str b = STR_INIT; struct str b = STR_INIT;
capn_resolve(&n->n.nestedNodes.p);
for (i = n->n.nestedNodes.p.len-1; i >= 0; i--) { for (i = capn_len(n->n.nestedNodes)-1; i >= 0; i--) {
struct Node_NestedNode nest; struct Node_NestedNode nest;
get_Node_NestedNode(&nest, n->n.nestedNodes, i); get_Node_NestedNode(&nest, n->n.nestedNodes, i);
resolve_names(&b, find_node(nest.id), nest.name, n); resolve_names(&b, find_node(nest.id), nest.name, n);
@ -1128,9 +1123,7 @@ int main() {
str_release(&b); str_release(&b);
} }
capn_resolve(&req.requestedFiles.p); for (i = 0; i < capn_len(req.requestedFiles); i++) {
for (i = 0; i < req.requestedFiles.p.len; i++) {
struct CodeGeneratorRequest_RequestedFile file_req; struct CodeGeneratorRequest_RequestedFile file_req;
static struct str b = STR_INIT; static struct str b = STR_INIT;
char *p; char *p;
@ -1157,9 +1150,7 @@ int main() {
str_addf(&HDR, "#error \"version mismatch between capn.h and generated code\"\n"); str_addf(&HDR, "#error \"version mismatch between capn.h and generated code\"\n");
str_addf(&HDR, "#endif\n\n"); str_addf(&HDR, "#endif\n\n");
capn_resolve(&file_req.imports.p); for (j = 0; j < capn_len(file_req.imports); j++) {
for (j = 0; j < file_req.imports.p.len; j++) {
struct CodeGeneratorRequest_RequestedFile_Import im; struct CodeGeneratorRequest_RequestedFile_Import im;
get_CodeGeneratorRequest_RequestedFile_Import(&im, file_req.imports, j); get_CodeGeneratorRequest_RequestedFile_Import(&im, file_req.imports, j);
str_addf(&HDR, "#include \"%s.h\"\n", im.name.str); str_addf(&HDR, "#include \"%s.h\"\n", im.name.str);

182
compiler/test.capnp.c
View file

@ -14,7 +14,7 @@ static const uint8_t capn_buf[8168] = {
77,0,0,0,34,0,0,0, 77,0,0,0,34,0,0,0,
77,0,0,0,26,0,0,0, 77,0,0,0,26,0,0,0,
76,0,0,0,6,0,20,0, 76,0,0,0,6,0,20,0,
1,0,0,0,24,0,0,0, 205,207,62,235,24,0,0,0,
33,1,0,0,41,0,0,0, 33,1,0,0,41,0,0,0,
33,1,0,0,34,0,0,0, 33,1,0,0,34,0,0,0,
33,1,0,0,35,0,0,0, 33,1,0,0,35,0,0,0,
@ -390,7 +390,7 @@ static const uint8_t capn_buf[8168] = {
77,0,0,0,34,0,0,0, 77,0,0,0,34,0,0,0,
77,0,0,0,26,0,0,0, 77,0,0,0,26,0,0,0,
76,0,0,0,6,0,20,0, 76,0,0,0,6,0,20,0,
1,0,0,0,24,0,0,0, 237,201,62,235,24,0,0,0,
33,1,0,0,41,0,0,0, 33,1,0,0,41,0,0,0,
33,1,0,0,34,0,0,0, 33,1,0,0,34,0,0,0,
33,1,0,0,35,0,0,0, 33,1,0,0,35,0,0,0,
@ -685,7 +685,7 @@ static const uint8_t capn_buf[8168] = {
77,0,0,0,34,0,0,0, 77,0,0,0,34,0,0,0,
77,0,0,0,26,0,0,0, 77,0,0,0,26,0,0,0,
76,0,0,0,6,0,20,0, 76,0,0,0,6,0,20,0,
1,0,0,0,24,0,0,0, 81,197,62,235,24,0,0,0,
33,1,0,0,41,0,0,0, 33,1,0,0,41,0,0,0,
33,1,0,0,34,0,0,0, 33,1,0,0,34,0,0,0,
33,1,0,0,35,0,0,0, 33,1,0,0,35,0,0,0,
@ -1038,29 +1038,29 @@ uint64_t TestConstants_uint64Const = ((uint64_t) 0xab54a98cu << 32) | 0xeb1f0ad2
union capn_conv_f32 TestConstants_float32Const = {0x449a5000u}; union capn_conv_f32 TestConstants_float32Const = {0x449a5000u};
union capn_conv_f64 TestConstants_float64Const = {((uint64_t) 0xc9b58b82u << 32) | 0xc0e0bb00u}; union capn_conv_f64 TestConstants_float64Const = {((uint64_t) 0xc9b58b82u << 32) | 0xc0e0bb00u};
capn_text TestConstants_textConst = {3,(char*)&capn_buf[0],(struct capn_segment*)&capn_seg}; capn_text TestConstants_textConst = {3,(char*)&capn_buf[0],(struct capn_segment*)&capn_seg};
capn_data TestConstants_dataConst = {{2,0,1,0,3,(char*)&capn_buf[8],(struct capn_segment*)&capn_seg}}; capn_data TestConstants_dataConst = {{2,0,0,0,1,0,3,(char*)&capn_buf[8],(struct capn_segment*)&capn_seg}};
TestAllTypes_ptr TestConstants_structConst = {{1,0,48,160,0,(char*)&capn_buf[16],(struct capn_segment*)&capn_seg}}; TestAllTypes_ptr TestConstants_structConst = {{1,0,0,0,48,20,0,(char*)&capn_buf[16],(struct capn_segment*)&capn_seg}};
enum TestEnum TestConstants_enumConst = (enum TestEnum) 5u; enum TestEnum TestConstants_enumConst = (enum TestEnum) 5u;
capn_ptr TestConstants_voidListConst = {2,0,0,0,6,(char*)&capn_buf[0],(struct capn_segment*)&capn_seg}; capn_ptr TestConstants_voidListConst;
capn_list1 TestConstants_boolListConst = {{4,0,1,0,4,(char*)&capn_buf[1672],(struct capn_segment*)&capn_seg}}; capn_list1 TestConstants_boolListConst = {{4,0,0,0,1,0,4,(char*)&capn_buf[1672],(struct capn_segment*)&capn_seg}};
capn_list8 TestConstants_int8ListConst = {{2,0,1,0,2,(char*)&capn_buf[1680],(struct capn_segment*)&capn_seg}}; capn_list8 TestConstants_int8ListConst = {{2,0,0,0,1,0,2,(char*)&capn_buf[1680],(struct capn_segment*)&capn_seg}};
capn_list16 TestConstants_int16ListConst = {{2,0,2,0,2,(char*)&capn_buf[1688],(struct capn_segment*)&capn_seg}}; capn_list16 TestConstants_int16ListConst = {{2,0,0,0,2,0,2,(char*)&capn_buf[1688],(struct capn_segment*)&capn_seg}};
capn_list32 TestConstants_int32ListConst = {{2,0,4,0,2,(char*)&capn_buf[1696],(struct capn_segment*)&capn_seg}}; capn_list32 TestConstants_int32ListConst = {{2,0,0,0,4,0,2,(char*)&capn_buf[1696],(struct capn_segment*)&capn_seg}};
capn_list64 TestConstants_int64ListConst = {{2,0,8,0,2,(char*)&capn_buf[1704],(struct capn_segment*)&capn_seg}}; capn_list64 TestConstants_int64ListConst = {{2,0,0,0,8,0,2,(char*)&capn_buf[1704],(struct capn_segment*)&capn_seg}};
capn_list8 TestConstants_uint8ListConst = {{2,0,1,0,2,(char*)&capn_buf[1720],(struct capn_segment*)&capn_seg}}; capn_list8 TestConstants_uint8ListConst = {{2,0,0,0,1,0,2,(char*)&capn_buf[1720],(struct capn_segment*)&capn_seg}};
capn_list16 TestConstants_uint16ListConst = {{2,0,2,0,2,(char*)&capn_buf[1728],(struct capn_segment*)&capn_seg}}; capn_list16 TestConstants_uint16ListConst = {{2,0,0,0,2,0,2,(char*)&capn_buf[1728],(struct capn_segment*)&capn_seg}};
capn_list32 TestConstants_uint32ListConst = {{2,0,4,0,1,(char*)&capn_buf[1736],(struct capn_segment*)&capn_seg}}; capn_list32 TestConstants_uint32ListConst = {{2,0,0,0,4,0,1,(char*)&capn_buf[1736],(struct capn_segment*)&capn_seg}};
capn_list64 TestConstants_uint64ListConst = {{2,0,8,0,1,(char*)&capn_buf[1744],(struct capn_segment*)&capn_seg}}; capn_list64 TestConstants_uint64ListConst = {{2,0,0,0,8,0,1,(char*)&capn_buf[1744],(struct capn_segment*)&capn_seg}};
capn_list32 TestConstants_float32ListConst = {{2,0,4,0,4,(char*)&capn_buf[1752],(struct capn_segment*)&capn_seg}}; capn_list32 TestConstants_float32ListConst = {{2,0,0,0,4,0,4,(char*)&capn_buf[1752],(struct capn_segment*)&capn_seg}};
capn_list64 TestConstants_float64ListConst = {{2,0,8,0,4,(char*)&capn_buf[1768],(struct capn_segment*)&capn_seg}}; capn_list64 TestConstants_float64ListConst = {{2,0,0,0,8,0,4,(char*)&capn_buf[1768],(struct capn_segment*)&capn_seg}};
capn_ptr TestConstants_textListConst = {3,0,0,0,3,(char*)&capn_buf[1800],(struct capn_segment*)&capn_seg}; capn_ptr TestConstants_textListConst = {3,0,0,0,0,0,3,(char*)&capn_buf[1800],(struct capn_segment*)&capn_seg};
capn_ptr TestConstants_dataListConst = {3,0,0,0,3,(char*)&capn_buf[1848],(struct capn_segment*)&capn_seg}; capn_ptr TestConstants_dataListConst = {3,0,0,0,0,0,3,(char*)&capn_buf[1848],(struct capn_segment*)&capn_seg};
TestAllTypes_list TestConstants_structListConst = {{7,0,48,160,3,(char*)&capn_buf[1912],(struct capn_segment*)&capn_seg}}; TestAllTypes_list TestConstants_structListConst = {{2,0,0,1,48,20,3,(char*)&capn_buf[1912],(struct capn_segment*)&capn_seg}};
capn_list16 TestConstants_enumListConst = {{2,0,2,0,2,(char*)&capn_buf[2584],(struct capn_segment*)&capn_seg}}; capn_list16 TestConstants_enumListConst = {{2,0,0,0,2,0,2,(char*)&capn_buf[2584],(struct capn_segment*)&capn_seg}};
uint32_t globalInt = 12345u; uint32_t globalInt = 12345u;
capn_text globalText = {6,(char*)&capn_buf[2592],(struct capn_segment*)&capn_seg}; capn_text globalText = {6,(char*)&capn_buf[2592],(struct capn_segment*)&capn_seg};
TestAllTypes_ptr globalStruct = {{1,0,48,160,0,(char*)&capn_buf[2600],(struct capn_segment*)&capn_seg}}; TestAllTypes_ptr globalStruct = {{1,0,0,0,48,20,0,(char*)&capn_buf[2600],(struct capn_segment*)&capn_seg}};
TestAllTypes_ptr derivedConstant = {{1,0,48,160,0,(char*)&capn_buf[2808],(struct capn_segment*)&capn_seg}}; TestAllTypes_ptr derivedConstant = {{1,0,0,0,48,20,0,(char*)&capn_buf[2808],(struct capn_segment*)&capn_seg}};
TestAllTypes_ptr new_TestAllTypes(struct capn_segment *s) { TestAllTypes_ptr new_TestAllTypes(struct capn_segment *s) {
TestAllTypes_ptr p; TestAllTypes_ptr p;
@ -1153,24 +1153,23 @@ void set_TestAllTypes(const struct TestAllTypes *s, TestAllTypes_list l, int i)
write_TestAllTypes(s, p); write_TestAllTypes(s, p);
} }
capn_text capn_val1 = {3,(char*)&capn_buf[5368],(struct capn_segment*)&capn_seg}; capn_text capn_val1 = {3,(char*)&capn_buf[5368],(struct capn_segment*)&capn_seg};
capn_data capn_val2 = {{2,0,1,0,3,(char*)&capn_buf[5376],(struct capn_segment*)&capn_seg}}; capn_data capn_val2 = {{2,0,0,0,1,0,3,(char*)&capn_buf[5376],(struct capn_segment*)&capn_seg}};
TestAllTypes_ptr capn_val3 = {{1,0,48,160,0,(char*)&capn_buf[5384],(struct capn_segment*)&capn_seg}}; TestAllTypes_ptr capn_val3 = {{1,0,0,0,48,20,0,(char*)&capn_buf[5384],(struct capn_segment*)&capn_seg}};
capn_ptr capn_val4 = {2,0,0,0,6,(char*)&capn_buf[0],(struct capn_segment*)&capn_seg}; capn_list1 capn_val4 = {{4,0,0,0,1,0,4,(char*)&capn_buf[7040],(struct capn_segment*)&capn_seg}};
capn_list1 capn_val5 = {{4,0,1,0,4,(char*)&capn_buf[7040],(struct capn_segment*)&capn_seg}}; capn_list8 capn_val5 = {{2,0,0,0,1,0,2,(char*)&capn_buf[7048],(struct capn_segment*)&capn_seg}};
capn_list8 capn_val6 = {{2,0,1,0,2,(char*)&capn_buf[7048],(struct capn_segment*)&capn_seg}}; capn_list16 capn_val6 = {{2,0,0,0,2,0,2,(char*)&capn_buf[7056],(struct capn_segment*)&capn_seg}};
capn_list16 capn_val7 = {{2,0,2,0,2,(char*)&capn_buf[7056],(struct capn_segment*)&capn_seg}}; capn_list32 capn_val7 = {{2,0,0,0,4,0,2,(char*)&capn_buf[7064],(struct capn_segment*)&capn_seg}};
capn_list32 capn_val8 = {{2,0,4,0,2,(char*)&capn_buf[7064],(struct capn_segment*)&capn_seg}}; capn_list64 capn_val8 = {{2,0,0,0,8,0,2,(char*)&capn_buf[7072],(struct capn_segment*)&capn_seg}};
capn_list64 capn_val9 = {{2,0,8,0,2,(char*)&capn_buf[7072],(struct capn_segment*)&capn_seg}}; capn_list8 capn_val9 = {{2,0,0,0,1,0,2,(char*)&capn_buf[7088],(struct capn_segment*)&capn_seg}};
capn_list8 capn_val10 = {{2,0,1,0,2,(char*)&capn_buf[7088],(struct capn_segment*)&capn_seg}}; capn_list16 capn_val10 = {{2,0,0,0,2,0,2,(char*)&capn_buf[7096],(struct capn_segment*)&capn_seg}};
capn_list16 capn_val11 = {{2,0,2,0,2,(char*)&capn_buf[7096],(struct capn_segment*)&capn_seg}}; capn_list32 capn_val11 = {{2,0,0,0,4,0,1,(char*)&capn_buf[7104],(struct capn_segment*)&capn_seg}};
capn_list32 capn_val12 = {{2,0,4,0,1,(char*)&capn_buf[7104],(struct capn_segment*)&capn_seg}}; capn_list64 capn_val12 = {{2,0,0,0,8,0,1,(char*)&capn_buf[7112],(struct capn_segment*)&capn_seg}};
capn_list64 capn_val13 = {{2,0,8,0,1,(char*)&capn_buf[7112],(struct capn_segment*)&capn_seg}}; capn_list32 capn_val13 = {{2,0,0,0,4,0,4,(char*)&capn_buf[7120],(struct capn_segment*)&capn_seg}};
capn_list32 capn_val14 = {{2,0,4,0,4,(char*)&capn_buf[7120],(struct capn_segment*)&capn_seg}}; capn_list64 capn_val14 = {{2,0,0,0,8,0,4,(char*)&capn_buf[7136],(struct capn_segment*)&capn_seg}};
capn_list64 capn_val15 = {{2,0,8,0,4,(char*)&capn_buf[7136],(struct capn_segment*)&capn_seg}}; capn_ptr capn_val15 = {3,0,0,0,0,0,3,(char*)&capn_buf[7168],(struct capn_segment*)&capn_seg};
capn_ptr capn_val16 = {3,0,0,0,3,(char*)&capn_buf[7168],(struct capn_segment*)&capn_seg}; capn_ptr capn_val16 = {3,0,0,0,0,0,3,(char*)&capn_buf[7216],(struct capn_segment*)&capn_seg};
capn_ptr capn_val17 = {3,0,0,0,3,(char*)&capn_buf[7216],(struct capn_segment*)&capn_seg}; TestAllTypes_list capn_val17 = {{2,0,0,1,48,20,3,(char*)&capn_buf[7280],(struct capn_segment*)&capn_seg}};
TestAllTypes_list capn_val18 = {{7,0,48,160,3,(char*)&capn_buf[7280],(struct capn_segment*)&capn_seg}}; capn_list16 capn_val18 = {{2,0,0,0,2,0,2,(char*)&capn_buf[7952],(struct capn_segment*)&capn_seg}};
capn_list16 capn_val19 = {{2,0,2,0,2,(char*)&capn_buf[7952],(struct capn_segment*)&capn_seg}};
TestDefaults_ptr new_TestDefaults(struct capn_segment *s) { TestDefaults_ptr new_TestDefaults(struct capn_segment *s) {
TestDefaults_ptr p; TestDefaults_ptr p;
@ -1206,68 +1205,65 @@ void read_TestDefaults(struct TestDefaults *s, TestDefaults_ptr p) {
} }
s->enumField = (enum TestEnum) capn_read16(p.p, 36) ^ 5u; s->enumField = (enum TestEnum) capn_read16(p.p, 36) ^ 5u;
s->voidList = capn_getp(p.p, 3, 0); s->voidList = capn_getp(p.p, 3, 0);
if (!s->voidList.type) {
s->voidList = capn_val4;
}
s->boolList.p = capn_getp(p.p, 4, 0); s->boolList.p = capn_getp(p.p, 4, 0);
if (!s->boolList.p.type) { if (!s->boolList.p.type) {
s->boolList = capn_val5; s->boolList = capn_val4;
} }
s->int8List.p = capn_getp(p.p, 5, 0); s->int8List.p = capn_getp(p.p, 5, 0);
if (!s->int8List.p.type) { if (!s->int8List.p.type) {
s->int8List = capn_val6; s->int8List = capn_val5;
} }
s->int16List.p = capn_getp(p.p, 6, 0); s->int16List.p = capn_getp(p.p, 6, 0);
if (!s->int16List.p.type) { if (!s->int16List.p.type) {
s->int16List = capn_val7; s->int16List = capn_val6;
} }
s->int32List.p = capn_getp(p.p, 7, 0); s->int32List.p = capn_getp(p.p, 7, 0);
if (!s->int32List.p.type) { if (!s->int32List.p.type) {
s->int32List = capn_val8; s->int32List = capn_val7;
} }
s->int64List.p = capn_getp(p.p, 8, 0); s->int64List.p = capn_getp(p.p, 8, 0);
if (!s->int64List.p.type) { if (!s->int64List.p.type) {
s->int64List = capn_val9; s->int64List = capn_val8;
} }
s->uInt8List.p = capn_getp(p.p, 9, 0); s->uInt8List.p = capn_getp(p.p, 9, 0);
if (!s->uInt8List.p.type) { if (!s->uInt8List.p.type) {
s->uInt8List = capn_val10; s->uInt8List = capn_val9;
} }
s->uInt16List.p = capn_getp(p.p, 10, 0); s->uInt16List.p = capn_getp(p.p, 10, 0);
if (!s->uInt16List.p.type) { if (!s->uInt16List.p.type) {
s->uInt16List = capn_val11; s->uInt16List = capn_val10;
} }
s->uInt32List.p = capn_getp(p.p, 11, 0); s->uInt32List.p = capn_getp(p.p, 11, 0);
if (!s->uInt32List.p.type) { if (!s->uInt32List.p.type) {
s->uInt32List = capn_val12; s->uInt32List = capn_val11;
} }
s->uInt64List.p = capn_getp(p.p, 12, 0); s->uInt64List.p = capn_getp(p.p, 12, 0);
if (!s->uInt64List.p.type) { if (!s->uInt64List.p.type) {
s->uInt64List = capn_val13; s->uInt64List = capn_val12;
} }
s->float32List.p = capn_getp(p.p, 13, 0); s->float32List.p = capn_getp(p.p, 13, 0);
if (!s->float32List.p.type) { if (!s->float32List.p.type) {
s->float32List = capn_val14; s->float32List = capn_val13;
} }
s->float64List.p = capn_getp(p.p, 14, 0); s->float64List.p = capn_getp(p.p, 14, 0);
if (!s->float64List.p.type) { if (!s->float64List.p.type) {
s->float64List = capn_val15; s->float64List = capn_val14;
} }
s->textList = capn_getp(p.p, 15, 0); s->textList = capn_getp(p.p, 15, 0);
if (!s->textList.type) { if (!s->textList.type) {
s->textList = capn_val16; s->textList = capn_val15;
} }
s->dataList = capn_getp(p.p, 16, 0); s->dataList = capn_getp(p.p, 16, 0);
if (!s->dataList.type) { if (!s->dataList.type) {
s->dataList = capn_val17; s->dataList = capn_val16;
} }
s->structList.p = capn_getp(p.p, 17, 0); s->structList.p = capn_getp(p.p, 17, 0);
if (!s->structList.p.type) { if (!s->structList.p.type) {
s->structList = capn_val18; s->structList = capn_val17;
} }
s->enumList.p = capn_getp(p.p, 18, 0); s->enumList.p = capn_getp(p.p, 18, 0);
if (!s->enumList.p.type) { if (!s->enumList.p.type) {
s->enumList = capn_val19; s->enumList = capn_val18;
} }
s->interfaceList = capn_getp(p.p, 19, 0); s->interfaceList = capn_getp(p.p, 19, 0);
} }
@ -1288,22 +1284,22 @@ void write_TestDefaults(const struct TestDefaults *s, TestDefaults_ptr p) {
capn_setp(p.p, 1, (s->dataField.p.data != capn_val2.p.data) ? s->dataField.p : capn_null); capn_setp(p.p, 1, (s->dataField.p.data != capn_val2.p.data) ? s->dataField.p : capn_null);
capn_setp(p.p, 2, (s->structField.p.data != capn_val3.p.data) ? s->structField.p : capn_null); capn_setp(p.p, 2, (s->structField.p.data != capn_val3.p.data) ? s->structField.p : capn_null);
capn_write16(p.p, 36, (uint16_t) s->enumField ^ 5u); capn_write16(p.p, 36, (uint16_t) s->enumField ^ 5u);
capn_setp(p.p, 3, (s->voidList.data != capn_val4.data) ? s->voidList : capn_null); capn_setp(p.p, 3, s->voidList);
capn_setp(p.p, 4, (s->boolList.p.data != capn_val5.p.data) ? s->boolList.p : capn_null); capn_setp(p.p, 4, (s->boolList.p.data != capn_val4.p.data) ? s->boolList.p : capn_null);
capn_setp(p.p, 5, (s->int8List.p.data != capn_val6.p.data) ? s->int8List.p : capn_null); capn_setp(p.p, 5, (s->int8List.p.data != capn_val5.p.data) ? s->int8List.p : capn_null);
capn_setp(p.p, 6, (s->int16List.p.data != capn_val7.p.data) ? s->int16List.p : capn_null); capn_setp(p.p, 6, (s->int16List.p.data != capn_val6.p.data) ? s->int16List.p : capn_null);
capn_setp(p.p, 7, (s->int32List.p.data != capn_val8.p.data) ? s->int32List.p : capn_null); capn_setp(p.p, 7, (s->int32List.p.data != capn_val7.p.data) ? s->int32List.p : capn_null);
capn_setp(p.p, 8, (s->int64List.p.data != capn_val9.p.data) ? s->int64List.p : capn_null); capn_setp(p.p, 8, (s->int64List.p.data != capn_val8.p.data) ? s->int64List.p : capn_null);
capn_setp(p.p, 9, (s->uInt8List.p.data != capn_val10.p.data) ? s->uInt8List.p : capn_null); capn_setp(p.p, 9, (s->uInt8List.p.data != capn_val9.p.data) ? s->uInt8List.p : capn_null);
capn_setp(p.p, 10, (s->uInt16List.p.data != capn_val11.p.data) ? s->uInt16List.p : capn_null); capn_setp(p.p, 10, (s->uInt16List.p.data != capn_val10.p.data) ? s->uInt16List.p : capn_null);
capn_setp(p.p, 11, (s->uInt32List.p.data != capn_val12.p.data) ? s->uInt32List.p : capn_null); capn_setp(p.p, 11, (s->uInt32List.p.data != capn_val11.p.data) ? s->uInt32List.p : capn_null);
capn_setp(p.p, 12, (s->uInt64List.p.data != capn_val13.p.data) ? s->uInt64List.p : capn_null); capn_setp(p.p, 12, (s->uInt64List.p.data != capn_val12.p.data) ? s->uInt64List.p : capn_null);
capn_setp(p.p, 13, (s->float32List.p.data != capn_val14.p.data) ? s->float32List.p : capn_null); capn_setp(p.p, 13, (s->float32List.p.data != capn_val13.p.data) ? s->float32List.p : capn_null);
capn_setp(p.p, 14, (s->float64List.p.data != capn_val15.p.data) ? s->float64List.p : capn_null); capn_setp(p.p, 14, (s->float64List.p.data != capn_val14.p.data) ? s->float64List.p : capn_null);
capn_setp(p.p, 15, (s->textList.data != capn_val16.data) ? s->textList : capn_null); capn_setp(p.p, 15, (s->textList.data != capn_val15.data) ? s->textList : capn_null);
capn_setp(p.p, 16, (s->dataList.data != capn_val17.data) ? s->dataList : capn_null); capn_setp(p.p, 16, (s->dataList.data != capn_val16.data) ? s->dataList : capn_null);
capn_setp(p.p, 17, (s->structList.p.data != capn_val18.p.data) ? s->structList.p : capn_null); capn_setp(p.p, 17, (s->structList.p.data != capn_val17.p.data) ? s->structList.p : capn_null);
capn_setp(p.p, 18, (s->enumList.p.data != capn_val19.p.data) ? s->enumList.p : capn_null); capn_setp(p.p, 18, (s->enumList.p.data != capn_val18.p.data) ? s->enumList.p : capn_null);
capn_setp(p.p, 19, s->interfaceList); capn_setp(p.p, 19, s->interfaceList);
} }
void get_TestDefaults(struct TestDefaults *s, TestDefaults_list l, int i) { void get_TestDefaults(struct TestDefaults *s, TestDefaults_list l, int i) {
@ -1935,10 +1931,10 @@ void set_TestInterleavedGroups(const struct TestInterleavedGroups *s, TestInterl
p.p = capn_getp(l.p, i, 0); p.p = capn_getp(l.p, i, 0);
write_TestInterleavedGroups(s, p); write_TestInterleavedGroups(s, p);
} }
TestUnion_ptr capn_val20 = {{1,0,64,16,0,(char*)&capn_buf[7960],(struct capn_segment*)&capn_seg}}; TestUnion_ptr capn_val19 = {{1,0,0,0,64,2,0,(char*)&capn_buf[7960],(struct capn_segment*)&capn_seg}};
TestUnion_ptr capn_val21 = {{1,0,64,16,0,(char*)&capn_buf[8040],(struct capn_segment*)&capn_seg}}; TestUnion_ptr capn_val20 = {{1,0,0,0,64,2,0,(char*)&capn_buf[8040],(struct capn_segment*)&capn_seg}};
TestUnnamedUnion_ptr capn_val22 = {{1,0,16,16,0,(char*)&capn_buf[8128],(struct capn_segment*)&capn_seg}}; TestUnnamedUnion_ptr capn_val21 = {{1,0,0,0,16,2,0,(char*)&capn_buf[8128],(struct capn_segment*)&capn_seg}};
TestUnnamedUnion_ptr capn_val23 = {{1,1,16,16,0,(char*)&capn_buf[0],(struct capn_segment*)&capn_seg}}; TestUnnamedUnion_ptr capn_val22 = {{1,1,0,0,16,2,0,(char*)&capn_buf[0],(struct capn_segment*)&capn_seg}};
TestUnionDefaults_ptr new_TestUnionDefaults(struct capn_segment *s) { TestUnionDefaults_ptr new_TestUnionDefaults(struct capn_segment *s) {
TestUnionDefaults_ptr p; TestUnionDefaults_ptr p;
@ -1954,27 +1950,27 @@ void read_TestUnionDefaults(struct TestUnionDefaults *s, TestUnionDefaults_ptr p
capn_resolve(&p.p); capn_resolve(&p.p);
s->s16s8s64s8Set.p = capn_getp(p.p, 0, 0); s->s16s8s64s8Set.p = capn_getp(p.p, 0, 0);
if (!s->s16s8s64s8Set.p.type) { if (!s->s16s8s64s8Set.p.type) {
s->s16s8s64s8Set = capn_val20; s->s16s8s64s8Set = capn_val19;
} }
s->s0sps1s32Set.p = capn_getp(p.p, 1, 0); s->s0sps1s32Set.p = capn_getp(p.p, 1, 0);
if (!s->s0sps1s32Set.p.type) { if (!s->s0sps1s32Set.p.type) {
s->s0sps1s32Set = capn_val21; s->s0sps1s32Set = capn_val20;
} }
s->unnamed1.p = capn_getp(p.p, 2, 0); s->unnamed1.p = capn_getp(p.p, 2, 0);
if (!s->unnamed1.p.type) { if (!s->unnamed1.p.type) {
s->unnamed1 = capn_val22; s->unnamed1 = capn_val21;
} }
s->unnamed2.p = capn_getp(p.p, 3, 0); s->unnamed2.p = capn_getp(p.p, 3, 0);
if (!s->unnamed2.p.type) { if (!s->unnamed2.p.type) {
s->unnamed2 = capn_val23; s->unnamed2 = capn_val22;
} }
} }
void write_TestUnionDefaults(const struct TestUnionDefaults *s, TestUnionDefaults_ptr p) { void write_TestUnionDefaults(const struct TestUnionDefaults *s, TestUnionDefaults_ptr p) {
capn_resolve(&p.p); capn_resolve(&p.p);
capn_setp(p.p, 0, (s->s16s8s64s8Set.p.data != capn_val20.p.data) ? s->s16s8s64s8Set.p : capn_null); capn_setp(p.p, 0, (s->s16s8s64s8Set.p.data != capn_val19.p.data) ? s->s16s8s64s8Set.p : capn_null);
capn_setp(p.p, 1, (s->s0sps1s32Set.p.data != capn_val21.p.data) ? s->s0sps1s32Set.p : capn_null); capn_setp(p.p, 1, (s->s0sps1s32Set.p.data != capn_val20.p.data) ? s->s0sps1s32Set.p : capn_null);
capn_setp(p.p, 2, (s->unnamed1.p.data != capn_val22.p.data) ? s->unnamed1.p : capn_null); capn_setp(p.p, 2, (s->unnamed1.p.data != capn_val21.p.data) ? s->unnamed1.p : capn_null);
capn_setp(p.p, 3, (s->unnamed2.p.data != capn_val23.p.data) ? s->unnamed2.p : capn_null); capn_setp(p.p, 3, (s->unnamed2.p.data != capn_val22.p.data) ? s->unnamed2.p : capn_null);
} }
void get_TestUnionDefaults(struct TestUnionDefaults *s, TestUnionDefaults_list l, int i) { void get_TestUnionDefaults(struct TestUnionDefaults *s, TestUnionDefaults_list l, int i) {
TestUnionDefaults_ptr p; TestUnionDefaults_ptr p;
@ -2577,7 +2573,7 @@ void set_TestFieldZeroIsBit(const struct TestFieldZeroIsBit *s, TestFieldZeroIsB
p.p = capn_getp(l.p, i, 0); p.p = capn_getp(l.p, i, 0);
write_TestFieldZeroIsBit(s, p); write_TestFieldZeroIsBit(s, p);
} }
TestLists_ptr capn_val24 = {{1,1,0,80,0,(char*)&capn_buf[56],(struct capn_segment*)&capn_seg}}; TestLists_ptr capn_val23 = {{1,1,0,0,0,10,0,(char*)&capn_buf[56],(struct capn_segment*)&capn_seg}};
TestListDefaults_ptr new_TestListDefaults(struct capn_segment *s) { TestListDefaults_ptr new_TestListDefaults(struct capn_segment *s) {
TestListDefaults_ptr p; TestListDefaults_ptr p;
@ -2593,12 +2589,12 @@ void read_TestListDefaults(struct TestListDefaults *s, TestListDefaults_ptr p) {
capn_resolve(&p.p); capn_resolve(&p.p);
s->lists.p = capn_getp(p.p, 0, 0); s->lists.p = capn_getp(p.p, 0, 0);
if (!s->lists.p.type) { if (!s->lists.p.type) {
s->lists = capn_val24; s->lists = capn_val23;
} }
} }
void write_TestListDefaults(const struct TestListDefaults *s, TestListDefaults_ptr p) { void write_TestListDefaults(const struct TestListDefaults *s, TestListDefaults_ptr p) {
capn_resolve(&p.p); capn_resolve(&p.p);
capn_setp(p.p, 0, (s->lists.p.data != capn_val24.p.data) ? s->lists.p : capn_null); capn_setp(p.p, 0, (s->lists.p.data != capn_val23.p.data) ? s->lists.p : capn_null);
} }
void get_TestListDefaults(struct TestListDefaults *s, TestListDefaults_list l, int i) { void get_TestListDefaults(struct TestListDefaults *s, TestListDefaults_list l, int i) {
TestListDefaults_ptr p; TestListDefaults_ptr p;
@ -2732,7 +2728,7 @@ void set_TestOldVersion(const struct TestOldVersion *s, TestOldVersion_list l, i
p.p = capn_getp(l.p, i, 0); p.p = capn_getp(l.p, i, 0);
write_TestOldVersion(s, p); write_TestOldVersion(s, p);
} }
capn_text capn_val25 = {3,(char*)&capn_buf[8160],(struct capn_segment*)&capn_seg}; capn_text capn_val24 = {3,(char*)&capn_buf[8160],(struct capn_segment*)&capn_seg};
TestNewVersion_ptr new_TestNewVersion(struct capn_segment *s) { TestNewVersion_ptr new_TestNewVersion(struct capn_segment *s) {
TestNewVersion_ptr p; TestNewVersion_ptr p;
@ -2750,7 +2746,7 @@ void read_TestNewVersion(struct TestNewVersion *s, TestNewVersion_ptr p) {
s->old2 = capn_get_text(p.p, 0, capn_val0); s->old2 = capn_get_text(p.p, 0, capn_val0);
s->old3.p = capn_getp(p.p, 1, 0); s->old3.p = capn_getp(p.p, 1, 0);
s->new1 = (int64_t) capn_read64(p.p, 8) ^ ((uint64_t) 0u << 32) ^ 0x3dbu; s->new1 = (int64_t) capn_read64(p.p, 8) ^ ((uint64_t) 0u << 32) ^ 0x3dbu;
s->new2 = capn_get_text(p.p, 2, capn_val25); s->new2 = capn_get_text(p.p, 2, capn_val24);
} }
void write_TestNewVersion(const struct TestNewVersion *s, TestNewVersion_ptr p) { void write_TestNewVersion(const struct TestNewVersion *s, TestNewVersion_ptr p) {
capn_resolve(&p.p); capn_resolve(&p.p);
@ -2758,7 +2754,7 @@ void write_TestNewVersion(const struct TestNewVersion *s, TestNewVersion_ptr p)
capn_set_text(p.p, 0, s->old2); capn_set_text(p.p, 0, s->old2);
capn_setp(p.p, 1, s->old3.p); capn_setp(p.p, 1, s->old3.p);
capn_write64(p.p, 8, (uint64_t) s->new1 ^ ((uint64_t) 0u << 32) ^ 0x3dbu); capn_write64(p.p, 8, (uint64_t) s->new1 ^ ((uint64_t) 0u << 32) ^ 0x3dbu);
capn_set_text(p.p, 2, (s->new2.str != capn_val25.str) ? s->new2 : capn_val0); capn_set_text(p.p, 2, (s->new2.str != capn_val24.str) ? s->new2 : capn_val0);
} }
void get_TestNewVersion(struct TestNewVersion *s, TestNewVersion_list l, int i) { void get_TestNewVersion(struct TestNewVersion *s, TestNewVersion_list l, int i) {
TestNewVersion_ptr p; TestNewVersion_ptr p;