From f74534b42ac9ac8b0ff496cb0da83f1201bbf8da Mon Sep 17 00:00:00 2001 From: Joshua Haberman Date: Sun, 8 May 2011 13:05:12 -0700 Subject: Decoder redesign in preparation for packed fields and start/endseq. --- src/upb_decoder.c | 463 +++++++++++++++++++++++++++--------------------------- 1 file changed, 232 insertions(+), 231 deletions(-) (limited to 'src/upb_decoder.c') diff --git a/src/upb_decoder.c b/src/upb_decoder.c index d952954..a10c0ba 100644 --- a/src/upb_decoder.c +++ b/src/upb_decoder.c @@ -19,44 +19,50 @@ #include "upb_decoder_x86.h" #endif -/* Decoding/Buffering of individual values ************************************/ +// A group continues until an END_GROUP tag is seen. +#define UPB_GROUPEND UINT32_MAX +// A non-packed repeated field ends when a diff. field is seen (or submsg end). +#define UPB_REPEATEDEND (UINT32_MAX-1) -// Performs zig-zag decoding, which is used by sint32 and sint64. -INLINE int32_t upb_zzdec_32(uint32_t n) { return (n >> 1) ^ -(int32_t)(n & 1); } -INLINE int64_t upb_zzdec_64(uint64_t n) { return (n >> 1) ^ -(int64_t)(n & 1); } +// It's unfortunate that we have to micro-manage the compiler this way, +// especially since this tuning is necessarily specific to one hardware +// configuration. But emperically on a Core i7, performance increases 30-50% +// with these annotations. Every instance where these appear, gcc 4.2.1 made +// the wrong decision and degraded performance in benchmarks. +#define FORCEINLINE static __attribute__((always_inline)) +#define NOINLINE static __attribute__((noinline)) + +static void upb_decoder_exit(upb_decoder *d) { siglongjmp(d->exitjmp, 1); } + +/* Decoding/Buffering of wire types *******************************************/ #define UPB_MAX_VARINT_ENCODED_SIZE 10 -INLINE void upb_decoder_advance(upb_decoder *d, size_t len) { - d->ptr += len; -} +static void upb_decoder_advance(upb_decoder *d, size_t len) { d->ptr += len; } +static size_t upb_decoder_bufleft(upb_decoder *d) { return d->end - d->ptr; } -INLINE size_t upb_decoder_offset(upb_decoder *d) { +size_t upb_decoder_offset(upb_decoder *d) { size_t offset = d->buf_stream_offset; if (d->buf) offset += (d->ptr - d->buf); return offset; } -INLINE size_t upb_decoder_bufleft(upb_decoder *d) { - return d->end - d->ptr; -} - -INLINE void upb_dstate_setmsgend(upb_decoder *d) { - uint32_t end_offset = d->dispatcher.top->end_offset; - d->submsg_end = (end_offset == UINT32_MAX) ? - (void*)UINTPTR_MAX : d->buf + end_offset; +static void upb_decoder_setmsgend(upb_decoder *d) { + uint32_t end = d->dispatcher.top->end_offset; + d->submsg_end = (end == UINT32_MAX) ? (void*)UINTPTR_MAX : d->buf + end; } // Pulls the next buffer from the bytesrc. Should be called only when the // current buffer is completely empty. -static bool upb_pullbuf(upb_decoder *d) { +static void upb_pullbuf(upb_decoder *d, bool need) { assert(upb_decoder_bufleft(d) == 0); int32_t last_buf_len = d->buf ? upb_string_len(d->bufstr) : -1; upb_string_recycle(&d->bufstr); if (!upb_bytesrc_getstr(d->bytesrc, d->bufstr, d->status)) { d->buf = NULL; d->end = NULL; - return false; + if (need) upb_seterr(d->status, UPB_ERROR, "Unexpected EOF."); + upb_decoder_exit(d); } if (last_buf_len != -1) { d->buf_stream_offset += last_buf_len; @@ -70,290 +76,256 @@ static bool upb_pullbuf(upb_decoder *d) { d->jit_end = d->end - 20; upb_string_recycle(&d->tmp); upb_string_substr(d->tmp, d->bufstr, 0, 0); - upb_dstate_setmsgend(d); - return true; + upb_decoder_setmsgend(d); } // Called only from the slow path, this function copies the next "len" bytes -// from the stream to "data", adjusting the dstate appropriately. -static bool upb_getbuf(upb_decoder *d, void *data, size_t bytes_wanted) { +// from the stream to "data", adjusting the decoder state appropriately. +static void upb_getbuf(upb_decoder *d, void *data, size_t bytes, bool need) { while (1) { - size_t to_copy = UPB_MIN(bytes_wanted, upb_decoder_bufleft(d)); + size_t to_copy = UPB_MIN(bytes, upb_decoder_bufleft(d)); memcpy(data, d->ptr, to_copy); upb_decoder_advance(d, to_copy); - bytes_wanted -= to_copy; - if (bytes_wanted == 0) return true; - if (!upb_pullbuf(d)) return false; + bytes -= to_copy; + if (bytes == 0) return; + upb_pullbuf(d, need); } } -// We use this path when we don't have UPB_MAX_VARINT_ENCODED_SIZE contiguous -// bytes available in our current buffer. We don't inline this because we -// accept that it will be slow and we don't want to pay for two copies of it. -static bool upb_decode_varint_slow(upb_decoder *d, upb_value *val) { - char byte = 0x80; - uint64_t val64 = 0; +NOINLINE uint64_t upb_decode_varint_slow(upb_decoder *d, bool need) { + uint8_t byte = 0x80; + uint64_t u64 = 0; int bitpos; - for(bitpos = 0; - bitpos < 70 && (byte & 0x80) && upb_getbuf(d, &byte, 1); - bitpos += 7) - val64 |= ((uint64_t)byte & 0x7F) << bitpos; - - if(bitpos == 70) { - upb_seterr(d->status, UPB_ERROR, - "Varint was unterminated after 10 bytes.\n"); - return false; - } else if (d->status->code == UPB_EOF && bitpos == 0) { - // Regular EOF. - return false; - } else if (d->status->code == UPB_EOF && (byte & 0x80)) { - upb_seterr(d->status, UPB_ERROR, - "Provided data ended in the middle of a varint.\n"); - return false; - } else { - // Success. - upb_value_setraw(val, val64); - return true; + for(bitpos = 0; bitpos < 70 && (byte & 0x80); bitpos += 7) { + upb_getbuf(d, &byte, 1, need); + u64 |= ((uint64_t)byte & 0x7F) << bitpos; } -} -typedef struct { - upb_wire_type_t wire_type; - upb_field_number_t field_number; -} upb_tag; + if(bitpos == 70 && (byte & 0x80)) { + upb_seterr(d->status, UPB_ERROR, "Unterminated varint.\n"); + upb_decoder_exit(d); + } + return u64; +} -INLINE bool upb_decode_tag(upb_decoder *d, uint32_t *tag) { +// For tags and delimited lengths, which must be <=32bit and are usually small. +FORCEINLINE uint32_t upb_decode_varint32(upb_decoder *d, bool need) { const char *p = d->ptr; - upb_value val; - // Nearly all tag varints will be either 1 byte (1-16) or 2 bytes (17-2048). + uint32_t ret; + uint64_t u64; + // Nearly all will be either 1 byte (1-16) or 2 bytes (17-2048). if (upb_decoder_bufleft(d) < 2) goto slow; // unlikely. - *tag = *p & 0x7f; + ret = *p & 0x7f; if ((*(p++) & 0x80) == 0) goto done; // predictable if fields are in order - *tag |= (*p & 0x7f) << 7; + ret |= (*p & 0x7f) << 7; if ((*(p++) & 0x80) == 0) goto done; // likely slow: - // Decode a full varint starting over from ptr. - if (!upb_decode_varint_slow(d, &val)) return false; - *tag = upb_value_getint64(val); - p = d->ptr; // Trick the next line into not overwriting us. + u64 = upb_decode_varint_slow(d, need); + if (u64 > 0xffffffff) { + upb_seterr(d->status, UPB_ERROR, "Unterminated 32-bit varint.\n"); + upb_decoder_exit(d); + } + ret = (uint32_t)u64; + p = d->ptr; // Turn the next line into a nop. done: upb_decoder_advance(d, p - d->ptr); - return true; + return ret; } -INLINE bool upb_decode_varint(upb_decoder *d, upb_value *val) { +FORCEINLINE uint64_t upb_decode_varint(upb_decoder *d) { if (upb_decoder_bufleft(d) >= 16) { // Common (fast) case. upb_decoderet r = upb_vdecode_fast(d->ptr); if (r.p == NULL) { upb_seterr(d->status, UPB_ERROR, "Unterminated varint.\n"); - return false; + upb_decoder_exit(d); } - upb_value_setraw(val, r.val); upb_decoder_advance(d, r.p - d->ptr); - return true; + return r.val; } else { - return upb_decode_varint_slow(d, val); + return upb_decode_varint_slow(d, true); } } -INLINE bool upb_decode_fixed(upb_decoder *d, size_t bytes, upb_value *val) { +FORCEINLINE void upb_decode_fixed(upb_decoder *d, void *val, size_t bytes) { if (upb_decoder_bufleft(d) >= bytes) { // Common (fast) case. memcpy(val, d->ptr, bytes); upb_decoder_advance(d, bytes); } else { - if (!upb_getbuf(d, val, bytes)) return false; + upb_getbuf(d, val, bytes, true); } - return true; } -// "val" initially holds the length of the string, this is replaced by the -// contents of the string. -INLINE bool upb_decode_string(upb_decoder *d, upb_value *val, - upb_string **str) { - upb_string_recycle(str); - uint32_t strlen = upb_value_getint32(*val); +FORCEINLINE uint32_t upb_decode_fixed32(upb_decoder *d) { + uint32_t u32; + upb_decode_fixed(d, &u32, sizeof(uint32_t)); + return u32; +} +FORCEINLINE uint64_t upb_decode_fixed64(upb_decoder *d) { + uint64_t u64; + upb_decode_fixed(d, &u64, sizeof(uint64_t)); + return u64; +} + +INLINE upb_string *upb_decode_string(upb_decoder *d) { + upb_string_recycle(&d->tmp); + uint32_t strlen = upb_decode_varint32(d, true); if (upb_decoder_bufleft(d) >= strlen) { // Common (fast) case. - upb_string_substr(*str, d->bufstr, d->ptr - d->buf, strlen); + upb_string_substr(d->tmp, d->bufstr, d->ptr - d->buf, strlen); upb_decoder_advance(d, strlen); } else { - if (!upb_getbuf(d, upb_string_getrwbuf(*str, strlen), strlen)) - return false; + upb_getbuf(d, upb_string_getrwbuf(d->tmp, strlen), strlen, true); } - upb_value_setstr(val, *str); - return true; + return d->tmp; } - -/* The main decoding loop *****************************************************/ - -extern upb_wire_type_t upb_expected_wire_types[]; -// Returns true if wt is the correct on-the-wire type for ft. -INLINE bool upb_check_type(upb_wire_type_t wt, upb_fieldtype_t ft) { - // This doesn't currently support packed arrays. - return upb_types[ft].native_wire_type == wt; +INLINE void upb_pop(upb_decoder *d) { + //if (d->dispatcher.top->end_offset == UPB_REPEATEDEND) + // upb_dispatch_endseq(&d->dispatcher); + d->f = d->dispatcher.top->f; + upb_dispatch_endsubmsg(&d->dispatcher); + upb_decoder_setmsgend(d); } -static upb_flow_t upb_pop(upb_decoder *d) { - upb_flow_t ret = upb_dispatch_endsubmsg(&d->dispatcher); - upb_dstate_setmsgend(d); - return ret; +INLINE void upb_push(upb_decoder *d, upb_fieldent *f, uint32_t end) { + upb_dispatch_startsubmsg(&d->dispatcher, f, end); + upb_decoder_setmsgend(d); } -static upb_flow_t upb_decoder_skipsubmsg(upb_decoder *d) { - if (d->dispatcher.top->f->type == UPB_TYPE(GROUP)) { - fprintf(stderr, "upb_decoder: Can't skip groups yet.\n"); - abort(); - } - upb_decoder_advance(d, d->dispatcher.top->end_offset - (d->ptr - d->buf)); + +/* Decoding of .proto types ***************************************************/ + +// Technically, we are losing data if we see a 32-bit varint that is not +// properly sign-extended. We could detect this and error about the data loss, +// but proto2 does not do this, so we pass. + +#define T(type, wt, valtype, convfunc) \ + INLINE void upb_decode_ ## type(upb_decoder *d, upb_fieldent *f) { \ + upb_value val; \ + upb_value_set ## valtype(&val, (convfunc)(upb_decode_ ## wt(d))); \ + upb_dispatch_value(&d->dispatcher, f, val); \ + } \ + +static double upb_asdouble(uint64_t n) { return *(double*)&n; } +static float upb_asfloat(uint32_t n) { return *(float*)&n; } +static int32_t upb_zzdec_32(uint32_t n) { return (n >> 1) ^ -(int32_t)(n & 1); } +static int64_t upb_zzdec_64(uint64_t n) { return (n >> 1) ^ -(int64_t)(n & 1); } + +T(INT32, varint, int32, int32_t) +T(INT64, varint, int64, int64_t) +T(UINT32, varint, uint32, uint32_t) +T(UINT64, varint, uint64, uint64_t) +T(FIXED32, fixed32, uint32, uint32_t) +T(FIXED64, fixed64, uint64, uint64_t) +T(SFIXED32, fixed32, int32, int32_t) +T(SFIXED64, fixed64, int64, int64_t) +T(BOOL, varint, bool, bool) +T(ENUM, varint, int32, int32_t) +T(DOUBLE, fixed64, double, upb_asdouble) +T(FLOAT, fixed32, float, upb_asfloat) +T(SINT32, varint, int32, upb_zzdec_32) +T(SINT64, varint, int64, upb_zzdec_64) +T(STRING, string, str, upb_string*) + +static void upb_decode_GROUP(upb_decoder *d, upb_fieldent *f) { + upb_push(d, f, UPB_GROUPEND); +} +static void upb_endgroup(upb_decoder *d, upb_fieldent *f) { + (void)f; upb_pop(d); - return UPB_CONTINUE; } - -static upb_flow_t upb_push(upb_decoder *d, upb_handlers_fieldent *f, - uint32_t end_offset) { - upb_flow_t flow = upb_dispatch_startsubmsg(&d->dispatcher, f, end_offset); - upb_dstate_setmsgend(d); - return flow; +static void upb_decode_MESSAGE(upb_decoder *d, upb_fieldent *f) { + upb_push(d, f, upb_decode_varint32(d, true) + (d->ptr - d->buf)); } -void upb_decoder_decode(upb_decoder *d, upb_status *status) { - d->status = status; -#define CHECK_FLOW(expr) \ - switch (expr) { \ - case UPB_BREAK: goto callback_err; \ - case UPB_SKIPSUBMSG: upb_decoder_skipsubmsg(d); continue; \ - default: break; /* continue normally. */ \ - } -#define CHECK(expr) if (!expr) { assert(!upb_ok(status)); goto err; } - - CHECK(upb_pullbuf(d)); - if (upb_dispatch_startmsg(&d->dispatcher) != UPB_CONTINUE) goto err; - - // Main loop: executed once per tag/field pair. - while(1) { - // Check for end-of-submessage. - while (d->ptr >= d->submsg_end) { - if (d->ptr > d->submsg_end) { - upb_seterr(d->status, UPB_ERROR, "Bad submessage end."); - goto err; - } - CHECK_FLOW(upb_pop(d)); - } +/* The main decoding loop *****************************************************/ + +static void upb_unwind(upb_decoder *d) { + // TODO. + (void)d; +} + +static void upb_delimend(upb_decoder *d) { + if (d->ptr > d->submsg_end) { + upb_seterr(d->status, UPB_ERROR, "Bad submessage end."); + upb_decoder_exit(d); + } + upb_pop(d); +} +static void upb_decoder_enterjit(upb_decoder *d) { + (void)d; +#ifdef UPB_USE_JIT_X64 + if (d->jit_code && d->dispatcher.top == d->dispatcher.stack && d->ptr < d->jit_end) { // Decodes as many fields as possible, updating d->ptr appropriately, // before falling through to the slow(er) path. -#ifdef UPB_USE_JIT_X64 void (*upb_jit_decode)(upb_decoder *d) = (void*)d->jit_code; - if (d->jit_code && d->dispatcher.top == d->dispatcher.stack && d->ptr < d->jit_end) { - //const char *before = d->ptr; - //fprintf(stderr, "Entering JIT, JIT bytes left: %zd\n", d->jit_end - d->ptr); - upb_jit_decode(d); - //fprintf(stderr, "Exiting JIT, parsed %zd bytes\n", d->ptr - before); - //fprintf(stderr, "ptr: %p, effective_end: %p, jit_end: %p, effective_end-ptr=%d\n", - // d->ptr, d->effective_end, d->jit_end, d->effective_end - d->ptr); - } + upb_jit_decode(d); + } #endif +} - // Parse/handle tag. - uint32_t tag; - if (!upb_decode_tag(d, &tag)) { - if (status->code == UPB_EOF && upb_dispatcher_stackempty(&d->dispatcher)) { - // Normal end-of-file. - upb_clearerr(status); - upb_dispatch_endmsg(&d->dispatcher, status); - return; - } else { - if (status->code == UPB_EOF) { - upb_seterr(status, UPB_ERROR, - "Input ended in the middle of a submessage."); - } - goto err; - } +INLINE upb_fieldent *upb_decode_tag(upb_decoder *d) { + while (1) { + uint32_t tag = upb_decode_varint32(d, false); + upb_fieldent *f = upb_dispatcher_lookup(&d->dispatcher, tag); + if (f) { + d->f = f; + return f; } - - // Decode wire data. Hopefully this branch will predict pretty well - // since most types will read a varint here. - upb_value val; - uint8_t wire_type = tag & 0x7; - switch (wire_type) { - case UPB_WIRE_TYPE_START_GROUP: - break; // Nothing to do now, below we will push appropriately. - case UPB_WIRE_TYPE_END_GROUP: - // Strictly speaking we should also check the field number here. - if(d->dispatcher.top->f->type != UPB_TYPE(GROUP)) { - upb_seterr(status, UPB_ERROR, "Unexpected END_GROUP tag."); - goto err; - } - CHECK_FLOW(upb_pop(d)); - continue; // We have no value to dispatch. - case UPB_WIRE_TYPE_VARINT: + switch (tag & 0x7) { + case UPB_WIRE_TYPE_VARINT: upb_decode_varint(d); break; + case UPB_WIRE_TYPE_32BIT: upb_decoder_advance(d, 4); break; + case UPB_WIRE_TYPE_64BIT: upb_decoder_advance(d, 8); break; case UPB_WIRE_TYPE_DELIMITED: - // For the delimited case we are parsing the length. - CHECK(upb_decode_varint(d, &val)); - break; - case UPB_WIRE_TYPE_32BIT: - CHECK(upb_decode_fixed(d, 4, &val)); - break; - case UPB_WIRE_TYPE_64BIT: - CHECK(upb_decode_fixed(d, 8, &val)); + upb_decoder_advance(d, upb_decode_varint32(d, true)); break; } + // TODO: deliver to unknown field callback. + while (d->ptr >= d->submsg_end) upb_delimend(d); + } - // Look up field by tag number. - upb_dispatcher_field *f = upb_dispatcher_lookup(&d->dispatcher, tag); - - if (!f) { - if (wire_type == UPB_WIRE_TYPE_DELIMITED) - CHECK(upb_decode_string(d, &val, &d->tmp)); - // TODO. - CHECK_FLOW(upb_dispatch_unknownval(&d->dispatcher, 0, UPB_NO_VALUE)); - continue; - } + // Have to handle both packed and non-packed sequences of primitives. + //if (d->dispatcher.top->end_offset == UPB_REPEATEDEND && d->f != f) { + // upb_dispatch_endseq(&d->dispatcher); + //} else if (f->is_repeated_primitive) { + // if ((tag & 0x7) == UPB_WIRE_TYPE_DELIMITED) { + // upb_pushseq(d, f, upb_decode_varint32(d, true) + (d->ptr - d->buf)); + // } else if (d->f != f) { + // upb_dispatch_startseq(d, f, UPB_REPEATEDEND); + // } + //} +} - // Perform any further massaging of the data now that we have the field's - // type. Now we can distinguish strings from submessages, and we know - // about zig-zag-encoded types. - // TODO: handle packed encoding. - // TODO: if we were being paranoid, we could check for 32-bit-varint types - // that the top 32 bits all match the highest bit of the low 32 bits. - // If this is not true we are losing data. But the main protobuf library - // doesn't check this, and it would slow us down, so pass for now. - switch (f->type) { - case UPB_TYPE(GROUP): - CHECK_FLOW(upb_push(d, f, UINT32_MAX)); - continue; // We have no value to dispatch. - case UPB_TYPE(MESSAGE): - CHECK_FLOW(upb_push(d, f, upb_value_getuint32(val) + (d->ptr - d->buf))); - continue; // We have no value to dispatch. - case UPB_TYPE(STRING): - case UPB_TYPE(BYTES): - CHECK(upb_decode_string(d, &val, &d->tmp)); - break; - case UPB_TYPE(SINT32): - upb_value_setint32(&val, upb_zzdec_32(upb_value_getint32(val))); - break; - case UPB_TYPE(SINT64): - upb_value_setint64(&val, upb_zzdec_64(upb_value_getint64(val))); - break; - default: -#ifndef NDEBUG - val.type = upb_types[f->type].inmemory_type; -#endif - break; // Other types need no further processing at this point. - } - CHECK_FLOW(upb_dispatch_value(&d->dispatcher, f, val)); +void upb_decoder_onexit(upb_decoder *d) { + if (d->status->code == UPB_EOF && upb_dispatcher_stackempty(&d->dispatcher)) { + // Normal end-of-file. + upb_clearerr(d->status); + upb_dispatch_endmsg(&d->dispatcher, d->status); + } else { + if (d->status->code == UPB_EOF) + upb_seterr(d->status, UPB_ERROR, "Input ended mid-submessage."); } +} -callback_err: - if (upb_ok(status)) { - upb_seterr(status, UPB_ERROR, "Callback returned UPB_BREAK"); +void upb_decoder_decode(upb_decoder *d, upb_status *status) { + if (sigsetjmp(d->exitjmp, 0)) { + upb_decoder_onexit(d); + return; + } + d->status = status; + upb_pullbuf(d, true); + upb_dispatch_startmsg(&d->dispatcher); + while(1) { // Main loop: executed once per tag/field pair. + while (d->ptr >= d->submsg_end) upb_delimend(d); + upb_decoder_enterjit(d); + // if (!d->dispatcher.top->is_packed) + upb_fieldent *f = upb_decode_tag(d); + f->decode(d, f); } -err: - assert(!upb_ok(status)); } void upb_decoder_init(upb_decoder *d, upb_handlers *handlers) { @@ -363,9 +335,38 @@ void upb_decoder_init(upb_decoder *d, upb_handlers *handlers) { if (d->dispatcher.handlers->should_jit) upb_decoder_makejit(d); #endif d->bufstr = NULL; - d->buf = NULL; d->tmp = NULL; upb_string_recycle(&d->tmp); + + // Set function pointers for each field's decode function. + for (int i = 0; i < handlers->msgs_len; i++) { + upb_msgent *m = &handlers->msgs[i]; + for(upb_inttable_iter i = upb_inttable_begin(&m->fieldtab); !upb_inttable_done(i); + i = upb_inttable_next(&m->fieldtab, i)) { + upb_fieldent *f = upb_inttable_iter_value(i); + switch (f->type) { + case UPB_TYPE(INT32): f->decode = &upb_decode_INT32; break; + case UPB_TYPE(INT64): f->decode = &upb_decode_INT64; break; + case UPB_TYPE(UINT32): f->decode = &upb_decode_UINT32; break; + case UPB_TYPE(UINT64): f->decode = &upb_decode_UINT64; break; + case UPB_TYPE(FIXED32): f->decode = &upb_decode_FIXED32; break; + case UPB_TYPE(FIXED64): f->decode = &upb_decode_FIXED64; break; + case UPB_TYPE(SFIXED32): f->decode = &upb_decode_SFIXED32; break; + case UPB_TYPE(SFIXED64): f->decode = &upb_decode_SFIXED64; break; + case UPB_TYPE(BOOL): f->decode = &upb_decode_BOOL; break; + case UPB_TYPE(ENUM): f->decode = &upb_decode_ENUM; break; + case UPB_TYPE(DOUBLE): f->decode = &upb_decode_DOUBLE; break; + case UPB_TYPE(FLOAT): f->decode = &upb_decode_FLOAT; break; + case UPB_TYPE(SINT32): f->decode = &upb_decode_SINT32; break; + case UPB_TYPE(SINT64): f->decode = &upb_decode_SINT64; break; + case UPB_TYPE(STRING): f->decode = &upb_decode_STRING; break; + case UPB_TYPE(BYTES): f->decode = &upb_decode_STRING; break; + case UPB_TYPE(GROUP): f->decode = &upb_decode_GROUP; break; + case UPB_TYPE(MESSAGE): f->decode = &upb_decode_MESSAGE; break; + case UPB_TYPE_ENDGROUP: f->decode = &upb_endgroup; break; + } + } + } } void upb_decoder_reset(upb_decoder *d, upb_bytesrc *bytesrc, void *closure) { -- cgit v1.2.3