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

Update capn_write_ptr to handle recursive structures when copying

Browse source
This commit is contained in:
James McKaskill 2013-05-05 19:30:33 -04:00
parent 14ac488681
commit edfcaf9d34
5 changed files with 704 additions and 269 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored Normal file
View file

@ -0,0 +1,2 @@
/capn.o
/capn.so

12
Makefile Normal file
View file

@ -0,0 +1,12 @@
.PHONY: all clean
all: capn.so
clean:
rm -f *.o *.so
%.o: %.c *.h *.inc
$(CC) -Wall -Werror -g -O2 -c $< -o $@
capn.so: capn.o
$(CC) -shared -Wall -Werror -fPIC -g -O2 $^ -o $@

4
capn-list.c → capn-list.inc
View file

@ -14,7 +14,7 @@ int CAT(capn_read,SZ) (const struct CAT(capn_list,SZ) *list, int off, UINT_T *to
switch (p->type) { switch (p->type) {
case CAPN_LIST: case CAPN_LIST:
if (p->datasz == SZ/8 && !p->ptrsz && (SZ == 8 || LITTLE_ENDIAN)) { if (p->datasz == SZ/8 && !p->ptrsz && (SZ == 8 || CAPN_LITTLE)) {
memcpy(to, p->data + off, sz * (SZ/8)); memcpy(to, p->data + off, sz * (SZ/8));
return sz; return sz;
} else if (p->datasz < SZ/8) { } else if (p->datasz < SZ/8) {
@ -53,7 +53,7 @@ int CAT(capn_write,SZ) (struct CAT(capn_list,SZ) *list, int off, const UINT_T *f
switch (p->type) { switch (p->type) {
case CAPN_LIST: case CAPN_LIST:
if (p->datasz == SZ/8 && !p->ptrsz && (SZ == 8 || LITTLE_ENDIAN)) { if (p->datasz == SZ/8 && !p->ptrsz && (SZ == 8 || CAPN_LITTLE)) {
memcpy(p->data + off, from, sz * (SZ/8)); memcpy(p->data + off, from, sz * (SZ/8));
return sz; return sz;
} else if (p->datasz < SZ/8) { } else if (p->datasz < SZ/8) {

813
capn.c
View file

File diff suppressed because it is too large Load diff

142
capn.h
View file

@ -5,27 +5,49 @@
#include <stdint.h> #include <stdint.h>
typedef struct capn_segment *(*capn_create_t)(void* /*user*/, int /*sz*/); #define CAPN_SEGID_LOCAL 0xFFFFFFFF
typedef struct capn_segment *(*capn_lookup_t)(void* /*user*/, uint32_t /*id*/);
/* struct capn is a common structure shared between segments in the same /* struct capn is a common structure shared between segments in the same
* session/context so that far pointers between the segments will be created. * session/context so that far pointers between the segments will be created.
*
* lookup is used to lookup segments by id when derefencing a far pointer * lookup is used to lookup segments by id when derefencing a far pointer
*
* create is used to create or lookup an alternate segment that has at least * create is used to create or lookup an alternate segment that has at least
* sz available (ie returned seg->len + sz <= seg->cap) * sz available (ie returned seg->len + sz <= seg->cap)
* create and lookup can be NULL if you don't need multiple segments *
* create and lookup can be NULL if you don't need multiple segments and don't
* want to support copying
*
* create is also used to allocate room for the copy tree with id ==
* CAPN_SEGID_LOCAL. This data should be allocated in the local memory space
*
* seglist and copylist are linked lists which can be used to free up segments
* on cleanup
*
* lookup, create, and user can be set by the user. Other values should be
* zero initialized.
*/ */
struct capn { struct capn {
struct capn_segment *(*lookup)(void* /*user*/, uint32_t /*id */); struct capn_segment *(*lookup)(void* /*user*/, uint32_t /*id */);
struct capn_segment *(*create)(void* /*user*/, int /*sz*/); struct capn_segment *(*create)(void* /*user*/, uint32_t /*id */, int /*sz*/);
void *user; void *user;
uint32_t segnum;
struct capn_tree *copy;
struct capn_tree *segtree, *lastseg;
struct capn_segment *seglist;
struct capn_segment *copylist;
};
struct capn_tree {
struct capn_tree *left, *right, *parent;
unsigned int red : 1;
}; };
/* struct capn_segment contains the information about a single segment. /* struct capn_segment contains the information about a single segment.
* capn should point to a struct capn that is shared between segments in the * capn should point to a struct capn that is shared between segments in the
* same session * same session
* id specifies the segment id, used for far pointers * id specifies the segment id, used for far pointers
* data specifies the segment data. This should not move once. * data specifies the segment data. This should not move after creation.
* len specifies the current segment length. This should be 0 for a blank * len specifies the current segment length. This should be 0 for a blank
* segment. * segment.
* cap specifies the segment capacity. * cap specifies the segment capacity.
@ -33,8 +55,13 @@ struct capn {
* at which point a new segment will be requested via capn->create. * at which point a new segment will be requested via capn->create.
* *
* data, len, and cap must all by 8 byte aligned * data, len, and cap must all by 8 byte aligned
*
* data, len, cap, id should all set by the user. Other values should be zero
* initialized.
*/ */
struct capn_segment { struct capn_segment {
struct capn_tree hdr;
struct capn_segment *next;
struct capn *capn; struct capn *capn;
uint32_t id; uint32_t id;
char *data; char *data;
@ -47,6 +74,7 @@ enum CAPN_TYPE {
CAPN_LIST = 2, CAPN_LIST = 2,
CAPN_PTR_LIST = 3, CAPN_PTR_LIST = 3,
CAPN_BIT_LIST = 4, CAPN_BIT_LIST = 4,
CAPN_LIST_MEMBER = 5,
}; };
struct capn_ptr { struct capn_ptr {
@ -70,12 +98,32 @@ struct capn_data {
struct capn_segment *seg; struct capn_segment *seg;
}; };
union capn_iptr {
struct capn_ptr c;
uintptr_t u;
void *p;
};
struct capn_ret_vt {
void (*free)(void*);
};
struct capn_list1{struct capn_ptr p;}; struct capn_list1{struct capn_ptr p;};
struct capn_list8{struct capn_ptr p;}; struct capn_list8{struct capn_ptr p;};
struct capn_list16{struct capn_ptr p;}; struct capn_list16{struct capn_ptr p;};
struct capn_list32{struct capn_ptr p;}; struct capn_list32{struct capn_ptr p;};
struct capn_list64{struct capn_ptr p;}; struct capn_list64{struct capn_ptr p;};
/* capn_append_segment appends a segment to a session */
void capn_append_segment(struct capn*, struct capn_segment*);
/* capn_root returns a fake pointer that can be used to read/write the session
* root object using capn_(read|write)_ptr at index 0. The root is the object
* pointed to by a ptr at offset 0 in segment 0. This will allocate room for
* the root if not already.
*/
struct capn_ptr capn_root(struct capn*);
/* capn_read|write_ptr functions read/write ptrs to list/structs /* capn_read|write_ptr functions read/write ptrs to 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_write_ptr will copy the data, create far pointers, etc if the target * capn_write_ptr will copy the data, create far pointers, etc if the target
@ -95,12 +143,6 @@ struct capn_data capn_read_data(const struct capn_ptr *p, int off);
int capn_write_text(struct capn_ptr *p, int off, struct capn_text tgt); int capn_write_text(struct capn_ptr *p, int off, struct capn_text tgt);
int capn_write_data(struct capn_ptr *p, int off, struct capn_data tgt); int capn_write_data(struct capn_ptr *p, int off, struct capn_data tgt);
/* capn_copy copies data from 'from' to 'to'
* returns 0 on success, non-zero on error (type mismatch, allocation error,
* etc).
*/
int capn_copy(struct capn_ptr *to, const struct capn_ptr *from);
/* capn_read_* functions read data from a list /* capn_read_* functions read data from a list
* The length of the list is given by p->size * The length of the list is given by p->size
* off specifies how far into the list to start * off specifies how far into the list to start
@ -137,53 +179,59 @@ struct capn_ptr capn_new_bit_list(struct capn_segment *seg, int sz);
struct capn_ptr capn_new_ptr_list(struct capn_segment *seg, int sz); struct capn_ptr capn_new_ptr_list(struct capn_segment *seg, int sz);
struct capn_ptr capn_new_string(struct capn_segment *seg, const char *str, int sz); struct capn_ptr capn_new_string(struct capn_segment *seg, const char *str, int sz);
#if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
#define CAPN_INLINE inline
#else
#define CAPN_INLINE static
#endif
/* capn_get|set_* functions get/set struct values /* capn_get|set_* functions get/set struct values
* off is the offset into the structure in bytes * off is the offset into the structure in bytes
* Rarely should these be called directly, instead use the generated code. * Rarely should these be called directly, instead use the generated code.
* Data must be xored with the default value * Data must be xored with the default value
* These are static in order to be inlined. * These are inlined
*/ */
static uint8_t capn_get8(const struct capn_ptr *p, int off); CAPN_INLINE uint8_t capn_get8(const struct capn_ptr *p, int off);
static uint16_t capn_get16(const struct capn_ptr *p, int off); CAPN_INLINE uint16_t capn_get16(const struct capn_ptr *p, int off);
static uint32_t capn_get32(const struct capn_ptr *p, int off); CAPN_INLINE uint32_t capn_get32(const struct capn_ptr *p, int off);
static uint64_t capn_get64(const struct capn_ptr *p, int off); CAPN_INLINE uint64_t capn_get64(const struct capn_ptr *p, int off);
static int capn_set8(struct capn_ptr *p, int off, uint8_t val); CAPN_INLINE int capn_set8(struct capn_ptr *p, int off, uint8_t val);
static int capn_set16(struct capn_ptr *p, int off, uint16_t val); CAPN_INLINE int capn_set16(struct capn_ptr *p, int off, uint16_t val);
static int capn_set32(struct capn_ptr *p, int off, uint32_t val); CAPN_INLINE int capn_set32(struct capn_ptr *p, int off, uint32_t val);
static int capn_set64(struct capn_ptr *p, int off, uint64_t val); CAPN_INLINE int capn_set64(struct capn_ptr *p, int off, uint64_t val);
int capn_marshal_iptr(const union capn_iptr*, struct capn_ptr*, int off);
/* Inline functions */ /* Inline functions */
#define T(IDX) s.v[IDX] = (uint8_t) (v >> (8*IDX)) #define T(IDX) s.v[IDX] = (uint8_t) (v >> (8*IDX))
static uint8_t capn_flip8(uint8_t v) { CAPN_INLINE uint8_t capn_flip8(uint8_t v) {
return v; return v;
} }
static uint16_t capn_flip16(uint16_t v) { CAPN_INLINE uint16_t capn_flip16(uint16_t v) {
union { uint16_t u; uint8_t v[2]; } s; union { uint16_t u; uint8_t v[2]; } s;
T(0); T(1); T(0); T(1);
return s.u; return s.u;
} }
static uint32_t capn_flip32(uint32_t v) { CAPN_INLINE uint32_t capn_flip32(uint32_t v) {
union { uint32_t u; uint16_t v[2]; } s; union { uint32_t u; uint8_t v[4]; } s;
T(0); T(1); T(2); T(3); T(0); T(1); T(2); T(3);
return s.u; return s.u;
} }
static uint64_t capn_flip64(uint64_t v) { CAPN_INLINE uint64_t capn_flip64(uint64_t v) {
union { uint64_t u; uint32_t v[2]; } s; union { uint64_t u; uint8_t v[8]; } s;
T(0); T(1); T(2); T(3); T(4); T(5); T(6); T(7); T(0); T(1); T(2); T(3); T(4); T(5); T(6); T(7);
return s.u; return s.u;
} }
#undef T #undef T
static uint8_t capn_get8(const struct capn_ptr *p, int off) { CAPN_INLINE uint8_t capn_get8(const struct capn_ptr *p, int off) {
return (p->type == CAPN_STRUCT && off < p->datasz) ? capn_flip8(*(uint8_t*) p->data) : 0; return off < p->datasz ? capn_flip8(*(uint8_t*) p->data) : 0;
} }
static int capn_set8(struct capn_ptr *p, int off, uint8_t val) { CAPN_INLINE int capn_set8(struct capn_ptr *p, int off, uint8_t val) {
if (p->type == CAPN_STRUCT && off < p->datasz) { if (off < p->datasz) {
*(uint8_t*) p->data = capn_flip8(val); *(uint8_t*) p->data = capn_flip8(val);
return 0; return 0;
} else { } else {
@ -191,11 +239,11 @@ static int capn_set8(struct capn_ptr *p, int off, uint8_t val) {
} }
} }
static uint16_t capn_get16(const struct capn_ptr *p, int off) { CAPN_INLINE uint16_t capn_get16(const struct capn_ptr *p, int off) {
return (p->type == CAPN_STRUCT && off < p->datasz) ? capn_flip16(*(uint16_t*) p->data) : 0; return off < p->datasz ? capn_flip16(*(uint16_t*) p->data) : 0;
} }
static int capn_set16(struct capn_ptr *p, int off, uint16_t val) { CAPN_INLINE int capn_set16(struct capn_ptr *p, int off, uint16_t val) {
if (p->type == CAPN_STRUCT && off < p->datasz) { if (off < p->datasz) {
*(uint16_t*) p->data = capn_flip16(val); *(uint16_t*) p->data = capn_flip16(val);
return 0; return 0;
} else { } else {
@ -203,11 +251,11 @@ static int capn_set16(struct capn_ptr *p, int off, uint16_t val) {
} }
} }
static uint32_t capn_get32(const struct capn_ptr *p, int off) { CAPN_INLINE uint32_t capn_get32(const struct capn_ptr *p, int off) {
return (p->type == CAPN_STRUCT && off < p->datasz) ? capn_flip32(*(uint32_t*) p->data) : 0; return off < p->datasz ? capn_flip32(*(uint32_t*) p->data) : 0;
} }
static int capn_set32(struct capn_ptr *p, int off, uint32_t val) { CAPN_INLINE int capn_set32(struct capn_ptr *p, int off, uint32_t val) {
if (p->type == CAPN_STRUCT && off < p->datasz) { if (off < p->datasz) {
*(uint32_t*) p->data = capn_flip32(val); *(uint32_t*) p->data = capn_flip32(val);
return 0; return 0;
} else { } else {
@ -215,11 +263,11 @@ static int capn_set32(struct capn_ptr *p, int off, uint32_t val) {
} }
} }
static uint64_t capn_get64(const struct capn_ptr *p, int off) { CAPN_INLINE uint64_t capn_get64(const struct capn_ptr *p, int off) {
return (p->type == CAPN_STRUCT && off < p->datasz) ? capn_flip64(*(uint64_t*) p->data) : 0; return off < p->datasz ? capn_flip64(*(uint64_t*) p->data) : 0;
} }
static int capn_set64(struct capn_ptr *p, int off, uint64_t val) { CAPN_INLINE int capn_set64(struct capn_ptr *p, int off, uint64_t val) {
if (p->type == CAPN_STRUCT && off < p->datasz) { if (off < p->datasz) {
*(uint64_t*) p->data = capn_flip64(val); *(uint64_t*) p->data = capn_flip64(val);
return 0; return 0;
} else { } else {
@ -227,13 +275,13 @@ static int capn_set64(struct capn_ptr *p, int off, uint64_t val) {
} }
} }
static float capn_get_float(const struct capn_ptr *p, int off, float def) { CAPN_INLINE float capn_get_float(const struct capn_ptr *p, int off, float def) {
union { float f; uint32_t u;} u; union { float f; uint32_t u;} u;
u.f = def; u.f = def;
u.u ^= capn_get32(p, off); u.u ^= capn_get32(p, off);
return u.f; return u.f;
} }
static int capn_set_float(struct capn_ptr *p, int off, float f, float def) { CAPN_INLINE int capn_set_float(struct capn_ptr *p, int off, float f, float def) {
union { float f; uint32_t u;} u; union { float f; uint32_t u;} u;
union { float f; uint32_t u;} d; union { float f; uint32_t u;} d;
u.f = f; u.f = f;
@ -241,13 +289,13 @@ static int capn_set_float(struct capn_ptr *p, int off, float f, float def) {
return capn_set32(p, off, u.u ^ d.u); return capn_set32(p, off, u.u ^ d.u);
} }
static double capn_get_double(const struct capn_ptr *p, int off, double def) { CAPN_INLINE double capn_get_double(const struct capn_ptr *p, int off, double def) {
union { double f; uint64_t u;} u; union { double f; uint64_t u;} u;
u.f = def; u.f = def;
u.u ^= capn_get64(p, off); u.u ^= capn_get64(p, off);
return u.f; return u.f;
} }
static int capn_set_double(struct capn_ptr *p, int off, double f, double def) { CAPN_INLINE int capn_set_double(struct capn_ptr *p, int off, double f, double def) {
union { double f; uint64_t u;} u; union { double f; uint64_t u;} u;
union { double f; uint64_t u;} d; union { double f; uint64_t u;} d;
d.f = f; d.f = f;