|
|
|
|
@ -33,21 +33,13 @@ struct upb_type_info upb_type_info[] = { |
|
|
|
|
TYPE_INFO(GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_BYTES, UPB_WIRE_TYPE_DELIMITED, struct upb_string*) |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
/* Lowest-level functions -- these read integers from the input buffer. */ |
|
|
|
|
|
|
|
|
|
inline |
|
|
|
|
static upb_status_t get_v_uint64_t(uint8_t *restrict buf, uint8_t *end, |
|
|
|
|
uint64_t *restrict val, uint8_t **outbuf) |
|
|
|
|
/* This is called by the inline version of the function if the varint turns out
|
|
|
|
|
* to be >= 2 bytes. */ |
|
|
|
|
upb_status_t upb_get_v_uint64_t_full(uint8_t *restrict buf, uint8_t *end, |
|
|
|
|
uint64_t *restrict val, |
|
|
|
|
uint8_t **outbuf) |
|
|
|
|
{ |
|
|
|
|
if((*buf & 0x80) == 0) { |
|
|
|
|
/* Single-byte varint -- very common case. */ |
|
|
|
|
*val = *buf & 0x7f; |
|
|
|
|
*outbuf = buf + 1; |
|
|
|
|
} else if(buf <= end && (*(buf+1) & 0x80) == 0) { |
|
|
|
|
/* Two-byte varint. */ |
|
|
|
|
*val = (buf[0] & 0x7f) | ((buf[1] & 0x7f) << 7); |
|
|
|
|
*outbuf = buf + 2; |
|
|
|
|
} else if(buf + 10 <= end) { |
|
|
|
|
if(buf + 10 <= end) { |
|
|
|
|
/* >2-byte varint, fast path. */ |
|
|
|
|
uint64_t cont = *(uint64_t*)(buf+2) | 0x7f7f7f7f7f7f7f7fULL; |
|
|
|
|
int num_bytes = __builtin_ffsll(~cont) / 8; |
|
|
|
|
@ -95,49 +87,6 @@ static upb_status_t skip_v_uint64_t(uint8_t *buf, uint8_t *end, uint8_t **outbuf |
|
|
|
|
return UPB_STATUS_OK; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static upb_status_t get_v_uint32_t(uint8_t *restrict buf, uint8_t *end, |
|
|
|
|
uint32_t *restrict val, uint8_t **outbuf) |
|
|
|
|
{ |
|
|
|
|
uint64_t val64; |
|
|
|
|
UPB_CHECK(get_v_uint64_t(buf, end, &val64, outbuf)); |
|
|
|
|
/* TODO: should we throw an error if any of the high bits in val64 are set? */ |
|
|
|
|
*val = (uint32_t)val64; |
|
|
|
|
return UPB_STATUS_OK; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static upb_status_t get_f_uint32_t(uint8_t *restrict buf, uint8_t *end, |
|
|
|
|
uint32_t *restrict val, uint8_t **outbuf) |
|
|
|
|
{ |
|
|
|
|
uint8_t *uint32_end = buf + sizeof(uint32_t); |
|
|
|
|
if(uint32_end > end) return UPB_STATUS_NEED_MORE_DATA; |
|
|
|
|
#if UPB_UNALIGNED_READS_OK |
|
|
|
|
*val = *(uint32_t*)buf; |
|
|
|
|
#else |
|
|
|
|
#define SHL(val, bits) ((uint32_t)val << bits) |
|
|
|
|
*val = SHL(b[0], 0) | SHL(b[1], 8) | SHL(b[2], 16) | SHL(b[3], 24); |
|
|
|
|
#undef SHL |
|
|
|
|
#endif |
|
|
|
|
*outbuf = uint32_end; |
|
|
|
|
return UPB_STATUS_OK; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static upb_status_t get_f_uint64_t(uint8_t *restrict buf, uint8_t *end, |
|
|
|
|
uint64_t *restrict val, uint8_t **outbuf) |
|
|
|
|
{ |
|
|
|
|
uint8_t *uint64_end = buf + sizeof(uint64_t); |
|
|
|
|
if(uint64_end > end) return UPB_STATUS_NEED_MORE_DATA; |
|
|
|
|
#if UPB_UNALIGNED_READS_OK |
|
|
|
|
*val = *(uint64_t*)buf; |
|
|
|
|
#else |
|
|
|
|
#define SHL(val, bits) ((uint64_t)val << bits) |
|
|
|
|
*val = SHL(b[0], 0) | SHL(b[1], 8) | SHL(b[2], 16) | SHL(b[3], 24) | |
|
|
|
|
SHL(b[4], 32) | SHL(b[5], 40) | SHL(b[6], 48) | SHL(b[7], 56) | |
|
|
|
|
#undef SHL |
|
|
|
|
#endif |
|
|
|
|
*outbuf = uint64_end; |
|
|
|
|
return UPB_STATUS_OK; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static upb_status_t skip_f_uint32_t(uint8_t *buf, uint8_t *end, uint8_t **outbuf) |
|
|
|
|
{ |
|
|
|
|
uint8_t *uint32_end = buf + sizeof(uint32_t); |
|
|
|
|
@ -154,62 +103,13 @@ static upb_status_t skip_f_uint64_t(uint8_t *buf, uint8_t *end, uint8_t **outbuf |
|
|
|
|
return UPB_STATUS_OK; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static int32_t zz_decode_32(uint32_t n) { return (n >> 1) ^ -(int32_t)(n & 1); } |
|
|
|
|
static int64_t zz_decode_64(uint64_t n) { return (n >> 1) ^ -(int64_t)(n & 1); } |
|
|
|
|
|
|
|
|
|
/* Functions for reading wire values and converting them to values. These
|
|
|
|
|
* are generated with macros because they follow a higly consistent pattern. */ |
|
|
|
|
|
|
|
|
|
#define WVTOV(type, wire_t, val_t) \ |
|
|
|
|
static void wvtov_ ## type(wire_t s, val_t *d) |
|
|
|
|
|
|
|
|
|
#define GET(type, v_or_f, wire_t, val_t, member_name) \ |
|
|
|
|
static upb_status_t get_ ## type(uint8_t *buf, uint8_t *end, val_t *d, uint8_t **outbuf) { \
|
|
|
|
|
wire_t tmp; \
|
|
|
|
|
UPB_CHECK(get_ ## v_or_f ## _ ## wire_t(buf, end, &tmp, outbuf)); \
|
|
|
|
|
wvtov_ ## type(tmp, d); \
|
|
|
|
|
return UPB_STATUS_OK; \
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#define T(type, v_or_f, wire_t, val_t, member_name) \ |
|
|
|
|
WVTOV(type, wire_t, val_t); /* prototype for GET below */ \
|
|
|
|
|
GET(type, v_or_f, wire_t, val_t, member_name) \
|
|
|
|
|
WVTOV(type, wire_t, val_t) |
|
|
|
|
|
|
|
|
|
T(DOUBLE, f, uint64_t, double, _double) { memcpy(d, &s, sizeof(double)); } |
|
|
|
|
T(FLOAT, f, uint32_t, float, _float) { memcpy(d, &s, sizeof(float)); } |
|
|
|
|
T(INT32, v, uint32_t, int32_t, int32) { *d = (int32_t)s; } |
|
|
|
|
T(INT64, v, uint64_t, int64_t, int64) { *d = (int64_t)s; } |
|
|
|
|
T(UINT32, v, uint32_t, uint32_t, uint32) { *d = s; } |
|
|
|
|
T(UINT64, v, uint64_t, uint64_t, uint64) { *d = s; } |
|
|
|
|
T(SINT32, v, uint32_t, int32_t, int32) { *d = zz_decode_32(s); } |
|
|
|
|
T(SINT64, v, uint64_t, int64_t, int64) { *d = zz_decode_64(s); } |
|
|
|
|
T(FIXED32, f, uint32_t, uint32_t, uint32) { *d = s; } |
|
|
|
|
T(FIXED64, f, uint64_t, uint64_t, uint64) { *d = s; } |
|
|
|
|
T(SFIXED32, f, uint32_t, int32_t, int32) { *d = (int32_t)s; } |
|
|
|
|
T(SFIXED64, f, uint64_t, int64_t, int64) { *d = (int64_t)s; } |
|
|
|
|
T(BOOL, v, uint32_t, bool, _bool) { *d = (bool)s; } |
|
|
|
|
T(ENUM, v, uint32_t, int32_t, int32) { *d = (int32_t)s; } |
|
|
|
|
#undef WVTOV |
|
|
|
|
#undef GET |
|
|
|
|
#undef T |
|
|
|
|
|
|
|
|
|
static upb_status_t parse_tag(uint8_t *buf, uint8_t *end, struct upb_tag *tag, uint8_t **outbuf) |
|
|
|
|
{ |
|
|
|
|
uint32_t tag_int; |
|
|
|
|
UPB_CHECK(get_v_uint32_t(buf, end, &tag_int, outbuf)); |
|
|
|
|
tag->wire_type = (upb_wire_type_t)(tag_int & 0x07); |
|
|
|
|
tag->field_number = tag_int >> 3; |
|
|
|
|
return UPB_STATUS_OK; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
upb_status_t upb_parse_wire_value(uint8_t *buf, uint8_t *end, upb_wire_type_t wt, |
|
|
|
|
union upb_wire_value *wv, uint8_t **outbuf) |
|
|
|
|
{ |
|
|
|
|
switch(wt) { |
|
|
|
|
case UPB_WIRE_TYPE_VARINT: return get_v_uint64_t(buf, end, &wv->varint, outbuf); |
|
|
|
|
case UPB_WIRE_TYPE_64BIT: return get_f_uint64_t(buf, end, &wv->_64bit, outbuf); |
|
|
|
|
case UPB_WIRE_TYPE_32BIT: return get_f_uint32_t(buf, end, &wv->_32bit, outbuf); |
|
|
|
|
case UPB_WIRE_TYPE_VARINT: return upb_get_v_uint64_t(buf, end, &wv->varint, outbuf); |
|
|
|
|
case UPB_WIRE_TYPE_64BIT: return upb_get_f_uint64_t(buf, end, &wv->_64bit, outbuf); |
|
|
|
|
case UPB_WIRE_TYPE_32BIT: return upb_get_f_uint32_t(buf, end, &wv->_32bit, outbuf); |
|
|
|
|
default: return UPB_ERROR_ILLEGAL; /* Doesn't handle delimited, groups. */ |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
@ -232,7 +132,7 @@ upb_status_t upb_parse_value(uint8_t *buf, uint8_t *end, upb_field_type_t ft, |
|
|
|
|
{ |
|
|
|
|
#define CASE(t, member_name) \ |
|
|
|
|
case GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_ ## t: \
|
|
|
|
|
return get_ ## t(buf, end, v.member_name, outbuf); |
|
|
|
|
return upb_get_ ## t(buf, end, v.member_name, outbuf); |
|
|
|
|
switch(ft) { |
|
|
|
|
CASE(DOUBLE, _double) |
|
|
|
|
CASE(FLOAT, _float) |
|
|
|
|
@ -324,7 +224,7 @@ upb_status_t upb_parse(struct upb_parse_state *s, void *_buf, size_t len, |
|
|
|
|
upb_field_type_t ft = tag_cb(udata, &tag, &user_field_desc); |
|
|
|
|
if(tag.wire_type == UPB_WIRE_TYPE_DELIMITED) { |
|
|
|
|
int32_t delim_len; |
|
|
|
|
UPB_CHECK(get_INT32(buf, end, &delim_len, &buf)); |
|
|
|
|
UPB_CHECK(upb_get_INT32(buf, end, &delim_len, &buf)); |
|
|
|
|
uint8_t *delim_end = buf + delim_len; |
|
|
|
|
|
|
|
|
|
if(delim_end > end) { /* String ends beyond the data we have. */ |
|
|
|
|
|
Joshua Haberman
16 years ago