Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Vastly improved/simplified the upb_handlers API.

Browse Source
pull/13171/head
Joshua Haberman 14 years ago
parent ea2a80840e
commit 3231fd0fdd
13 changed files with 378 additions and 441 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      benchmarks/parsestream.upb_table.c
  2. 4
      benchmarks/parsetostruct.upb_table.c
  3. 2
      src/upb_decoder.c
  4. 204
      src/upb_def.c
  5. 3
      src/upb_def.h
  6. 10
      src/upb_glue.c
  7. 271
      src/upb_handlers.c
  8. 198
      src/upb_handlers.h
  9. 22
      src/upb_msg.c
  10. 6
      src/upb_msg.h
  11. 7
      src/upb_textprinter.c
  12. 2
      src/upb_textprinter.h
  13. 5
      tests/tests.c

5
benchmarks/parsestream.upb_table.c
Unescape View File

@ -61,9 +61,10 @@ static bool initialize()
return false; return false;
} }
upb_handlers_init(&handlers, def); upb_handlers_init(&handlers);
// Cause all messages to be read, but do nothing when they are. // Cause all messages to be read, but do nothing when they are.
upb_register_all(&handlers, NULL, NULL, value, startsubmsg, NULL); upb_handlerset hset = {NULL, NULL, value, startsubmsg, NULL};
upb_handlers_reghandlerset(&handlers, def, &hset);
upb_decoder_init(&decoder, &handlers); upb_decoder_init(&decoder, &handlers);
upb_stringsrc_init(&stringsrc); upb_stringsrc_init(&stringsrc);
return true; return true;

4
benchmarks/parsetostruct.upb_table.c
Unescape View File

@ -53,8 +53,8 @@ static bool initialize()
msg = upb_msg_new(def); msg = upb_msg_new(def);
upb_stringsrc_init(&strsrc); upb_stringsrc_init(&strsrc);
upb_handlers_init(&h, def); upb_handlers_init(&h);
upb_msg_regdhandlers(&h); upb_msg_reghandlers(&h, def);
upb_decoder_init(&d, &h); upb_decoder_init(&d, &h);
if (!BYREF) { if (!BYREF) {

2
src/upb_decoder.c
Unescape View File

@ -341,7 +341,7 @@ void upb_decoder_init(upb_decoder *d, upb_handlers *handlers) {
// Set function pointers for each field's decode function. // Set function pointers for each field's decode function.
for (int i = 0; i < handlers->msgs_len; i++) { for (int i = 0; i < handlers->msgs_len; i++) {
upb_mhandlers *m = &handlers->msgs[i]; upb_mhandlers *m = handlers->msgs[i];
for(upb_inttable_iter i = upb_inttable_begin(&m->fieldtab); !upb_inttable_done(i); for(upb_inttable_iter i = upb_inttable_begin(&m->fieldtab); !upb_inttable_done(i);
i = upb_inttable_next(&m->fieldtab, i)) { i = upb_inttable_next(&m->fieldtab, i)) {
upb_fhandlers *f = upb_inttable_iter_value(i); upb_fhandlers *f = upb_inttable_iter_value(i);

204
src/upb_def.c
Unescape View File

@ -264,8 +264,8 @@ struct _upb_defbuilder {
}; };
// Forward declares for top-level file descriptors. // Forward declares for top-level file descriptors.
static void upb_msgdef_register_DescriptorProto(upb_handlers *h); static upb_mhandlers *upb_msgdef_register_DescriptorProto(upb_handlers *h);
static void upb_enumdef_register_EnumDescriptorProto(upb_handlers *h); static upb_mhandlers * upb_enumdef_register_EnumDescriptorProto(upb_handlers *h);
upb_defbuilder *upb_defbuilder_new(upb_symtab *s) { upb_defbuilder *upb_defbuilder_new(upb_symtab *s) {
upb_defbuilder *b = malloc(sizeof(*b)); upb_defbuilder *b = malloc(sizeof(*b));
@ -344,28 +344,27 @@ static upb_flow_t upb_defbuilder_FileDescriptorProto_package(void *_b,
return UPB_CONTINUE; return UPB_CONTINUE;
} }
static void upb_defbuilder_register_FileDescriptorProto(upb_handlers *h) { static upb_mhandlers *upb_defbuilder_register_FileDescriptorProto(
upb_register_startend(h, upb_defbuilder_FileDescriptorProto_startmsg, upb_handlers *h) {
upb_defbuilder_FileDescriptorProto_endmsg); upb_mhandlers *m = upb_handlers_newmsg(h);
upb_register_typed_value(h, upb_mhandlers_setstartmsg(m, &upb_defbuilder_FileDescriptorProto_startmsg);
GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PACKAGE__FIELDNUM, upb_mhandlers_setendmsg(m, &upb_defbuilder_FileDescriptorProto_endmsg);
GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_PACKAGE__FIELDTYPE, false,
&upb_defbuilder_FileDescriptorProto_package, UPB_NO_VALUE);
upb_handlers_typed_push(h, #define FNUM(field) GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ ## field ## __FIELDNUM
GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_MESSAGE_TYPE__FIELDNUM, #define FTYPE(field) GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ ## field ## __FIELDTYPE
GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_MESSAGE_TYPE__FIELDTYPE, true); upb_fhandlers *f =
upb_msgdef_register_DescriptorProto(h); upb_mhandlers_newfield(m, FNUM(PACKAGE), FTYPE(PACKAGE), false);
upb_handlers_typed_pop(h); upb_fhandlers_setvalue(f, &upb_defbuilder_FileDescriptorProto_package);
upb_handlers_typed_push(h, upb_mhandlers_newsubmsgfield(m, FNUM(MESSAGE_TYPE), FTYPE(MESSAGE_TYPE), true,
GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ENUM_TYPE__FIELDNUM, upb_msgdef_register_DescriptorProto(h));
GOOGLE_PROTOBUF_FILEDESCRIPTORPROTO_ENUM_TYPE__FIELDTYPE, true); upb_mhandlers_newsubmsgfield(m, FNUM(ENUM_TYPE), FTYPE(ENUM_TYPE), true,
upb_enumdef_register_EnumDescriptorProto(h); upb_enumdef_register_EnumDescriptorProto(h));
upb_handlers_typed_pop(h); // TODO: services, extensions
return m;
// TODO: services and extensions.
} }
#undef FNUM
#undef FTYPE
// Handlers for google.protobuf.FileDescriptorSet. // Handlers for google.protobuf.FileDescriptorSet.
static bool upb_symtab_add_defs(upb_symtab *s, upb_def **defs, int num_defs, static bool upb_symtab_add_defs(upb_symtab *s, upb_def **defs, int num_defs,
@ -379,17 +378,22 @@ static void upb_defbuilder_FileDescriptorSet_onendmsg(void *_b,
upb_defbuilder_free(b); upb_defbuilder_free(b);
} }
static void upb_defbuilder_register_FileDescriptorSet(upb_handlers *h) { static upb_mhandlers *upb_defbuilder_register_FileDescriptorSet(upb_handlers *h) {
upb_register_startend(h, NULL, upb_defbuilder_FileDescriptorSet_onendmsg); upb_mhandlers *m = upb_handlers_newmsg(h);
upb_handlers_typed_push(h, upb_mhandlers_setendmsg(m, upb_defbuilder_FileDescriptorSet_onendmsg);
GOOGLE_PROTOBUF_FILEDESCRIPTORSET_FILE__FIELDNUM,
GOOGLE_PROTOBUF_FILEDESCRIPTORSET_FILE__FIELDTYPE, true); #define FNUM(field) GOOGLE_PROTOBUF_FILEDESCRIPTORSET_ ## field ## __FIELDNUM
upb_defbuilder_register_FileDescriptorProto(h); #define FTYPE(field) GOOGLE_PROTOBUF_FILEDESCRIPTORSET_ ## field ## __FIELDTYPE
upb_handlers_typed_pop(h); upb_mhandlers_newsubmsgfield(m, FNUM(FILE), FTYPE(FILE), true,
upb_defbuilder_register_FileDescriptorProto(h));
return m;
} }
void upb_defbuilder_reghandlers(upb_handlers *h) { #undef FNUM
upb_defbuilder_register_FileDescriptorSet(h); #undef FTYPE
upb_mhandlers *upb_defbuilder_reghandlers(upb_handlers *h) {
h->should_jit = false; h->should_jit = false;
return upb_defbuilder_register_FileDescriptorSet(h);
} }
@ -488,18 +492,24 @@ static void upb_enumdef_EnumValueDescriptorProto_endmsg(void *_b,
b->name = NULL; b->name = NULL;
} }
static void upb_enumdef_register_EnumValueDescriptorProto(upb_handlers *h) { static upb_mhandlers *upb_enumdef_register_EnumValueDescriptorProto(
upb_register_startend(h, upb_enumdef_EnumValueDescriptorProto_startmsg, upb_handlers *h) {
upb_enumdef_EnumValueDescriptorProto_endmsg); upb_mhandlers *m = upb_handlers_newmsg(h);
upb_register_typed_value(h, upb_mhandlers_setstartmsg(m, &upb_enumdef_EnumValueDescriptorProto_startmsg);
GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NAME__FIELDNUM, upb_mhandlers_setendmsg(m, &upb_enumdef_EnumValueDescriptorProto_endmsg);
GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NAME__FIELDTYPE, false,
&upb_enumdef_EnumValueDescriptorProto_name, UPB_NO_VALUE); #define FNUM(f) GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_ ## f ## __FIELDNUM
upb_register_typed_value(h, #define FTYPE(f) GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_ ## f ## __FIELDTYPE
GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NUMBER__FIELDNUM, upb_fhandlers *f;
GOOGLE_PROTOBUF_ENUMVALUEDESCRIPTORPROTO_NUMBER__FIELDTYPE, false, f = upb_mhandlers_newfield(m, FNUM(NAME), FTYPE(NAME), false);
&upb_enumdef_EnumValueDescriptorProto_number, UPB_NO_VALUE); upb_fhandlers_setvalue(f, &upb_enumdef_EnumValueDescriptorProto_name);
f = upb_mhandlers_newfield(m, FNUM(NUMBER), FTYPE(NUMBER), false);
upb_fhandlers_setvalue(f, &upb_enumdef_EnumValueDescriptorProto_number);
return m;
} }
#undef FNUM
#undef FTYPE
// google.protobuf.EnumDescriptorProto. // google.protobuf.EnumDescriptorProto.
static upb_flow_t upb_enumdef_EnumDescriptorProto_startmsg(void *_b) { static upb_flow_t upb_enumdef_EnumDescriptorProto_startmsg(void *_b) {
@ -536,20 +546,22 @@ static upb_flow_t upb_enumdef_EnumDescriptorProto_name(void *_b,
return UPB_CONTINUE; return UPB_CONTINUE;
} }
static void upb_enumdef_register_EnumDescriptorProto(upb_handlers *h) { static upb_mhandlers *upb_enumdef_register_EnumDescriptorProto(upb_handlers *h) {
upb_register_startend(h, &upb_enumdef_EnumDescriptorProto_startmsg, upb_mhandlers *m = upb_handlers_newmsg(h);
&upb_enumdef_EnumDescriptorProto_endmsg); upb_mhandlers_setstartmsg(m, &upb_enumdef_EnumDescriptorProto_startmsg);
upb_register_typed_value(h, upb_mhandlers_setendmsg(m, &upb_enumdef_EnumDescriptorProto_endmsg);
GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_NAME__FIELDNUM,
GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_NAME__FIELDTYPE, false,
&upb_enumdef_EnumDescriptorProto_name, UPB_NO_VALUE);
upb_handlers_typed_push(h, #define FNUM(f) GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_ ## f ## __FIELDNUM
GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_VALUE__FIELDNUM, #define FTYPE(f) GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_ ## f ## __FIELDTYPE
GOOGLE_PROTOBUF_ENUMDESCRIPTORPROTO_VALUE__FIELDTYPE, true); upb_fhandlers *f = upb_mhandlers_newfield(m, FNUM(NAME), FTYPE(NAME), false);
upb_enumdef_register_EnumValueDescriptorProto(h); upb_fhandlers_setvalue(f, &upb_enumdef_EnumDescriptorProto_name);
upb_handlers_typed_pop(h);
upb_mhandlers_newsubmsgfield(m, FNUM(VALUE), FTYPE(VALUE), true,
upb_enumdef_register_EnumValueDescriptorProto(h));
return m;
} }
#undef FNUM
#undef FTYPE
upb_enum_iter upb_enum_begin(upb_enumdef *e) { upb_enum_iter upb_enum_begin(upb_enumdef *e) {
// We could iterate over either table here; the choice is arbitrary. // We could iterate over either table here; the choice is arbitrary.
@ -810,33 +822,29 @@ static upb_flow_t upb_fielddef_ondefaultval(void *_b, upb_value fval,
return UPB_CONTINUE; return UPB_CONTINUE;
} }
static void upb_fielddef_register_FieldDescriptorProto(upb_handlers *h) { static upb_mhandlers *upb_fielddef_register_FieldDescriptorProto(
upb_register_startend(h, upb_fielddef_startmsg, upb_fielddef_endmsg); upb_handlers *h) {
upb_register_typed_value(h, upb_mhandlers *m = upb_handlers_newmsg(h);
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE__FIELDNUM, upb_mhandlers_setstartmsg(m, &upb_fielddef_startmsg);
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE__FIELDTYPE, false, upb_mhandlers_setendmsg(m, &upb_fielddef_endmsg);
&upb_fielddef_ontype, UPB_NO_VALUE);
upb_register_typed_value(h, #define FIELD(name, handler) \
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL__FIELDNUM, upb_fhandlers_setvalue( \
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL__FIELDTYPE, false, upb_mhandlers_newfield(m, \
&upb_fielddef_onlabel, UPB_NO_VALUE); GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_ ## name ## __FIELDNUM, \
upb_register_typed_value(h, GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_ ## name ## __FIELDTYPE, \
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NUMBER__FIELDNUM, false), \
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NUMBER__FIELDTYPE, false, handler);
&upb_fielddef_onnumber, UPB_NO_VALUE); FIELD(TYPE, &upb_fielddef_ontype);
upb_register_typed_value(h, FIELD(LABEL, &upb_fielddef_onlabel);
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NAME__FIELDNUM, FIELD(NUMBER, &upb_fielddef_onnumber);
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_NAME__FIELDTYPE, false, FIELD(NAME, &upb_fielddef_onname);
&upb_fielddef_onname, UPB_NO_VALUE); FIELD(TYPE_NAME, &upb_fielddef_ontypename);
upb_register_typed_value(h, FIELD(DEFAULT_VALUE, &upb_fielddef_ondefaultval);
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_NAME__FIELDNUM, return m;
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_TYPE_NAME__FIELDTYPE, false,
&upb_fielddef_ontypename, UPB_NO_VALUE);
upb_register_typed_value(h,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_DEFAULT_VALUE__FIELDNUM,
GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_DEFAULT_VALUE__FIELDTYPE, false,
&upb_fielddef_ondefaultval, UPB_NO_VALUE);
} }
#undef FNUM
#undef FTYPE
/* upb_msgdef *****************************************************************/ /* upb_msgdef *****************************************************************/
@ -951,32 +959,30 @@ static upb_flow_t upb_msgdef_onname(void *_b, upb_value fval, upb_value val) {
return UPB_CONTINUE; return UPB_CONTINUE;
} }
static void upb_msgdef_register_DescriptorProto(upb_handlers *h) { static upb_mhandlers *upb_msgdef_register_DescriptorProto(upb_handlers *h) {
upb_register_startend(h, &upb_msgdef_startmsg, &upb_msgdef_endmsg); upb_mhandlers *m = upb_handlers_newmsg(h);
upb_register_typed_value(h, upb_mhandlers_setstartmsg(m, &upb_msgdef_startmsg);
GOOGLE_PROTOBUF_DESCRIPTORPROTO_NAME__FIELDNUM, upb_mhandlers_setendmsg(m, &upb_msgdef_endmsg);
GOOGLE_PROTOBUF_DESCRIPTORPROTO_NAME__FIELDTYPE, false,
&upb_msgdef_onname, UPB_NO_VALUE);
upb_handlers_typed_push(h, #define FNUM(f) GOOGLE_PROTOBUF_DESCRIPTORPROTO_ ## f ## __FIELDNUM
GOOGLE_PROTOBUF_DESCRIPTORPROTO_FIELD__FIELDNUM, #define FTYPE(f) GOOGLE_PROTOBUF_DESCRIPTORPROTO_ ## f ## __FIELDTYPE
GOOGLE_PROTOBUF_DESCRIPTORPROTO_FIELD__FIELDTYPE, true); upb_fhandlers *f = upb_mhandlers_newfield(m, FNUM(NAME), FTYPE(NAME), false);
upb_fielddef_register_FieldDescriptorProto(h); upb_fhandlers_setvalue(f, &upb_msgdef_onname);
upb_handlers_typed_pop(h);
// DescriptorProto is self-recursive, so we must link the definition. upb_mhandlers_newsubmsgfield(m, FNUM(FIELD), FTYPE(FIELD), true,
upb_handlers_typed_link(h, upb_fielddef_register_FieldDescriptorProto(h));
GOOGLE_PROTOBUF_DESCRIPTORPROTO_NESTED_TYPE__FIELDNUM, upb_mhandlers_newsubmsgfield(m, FNUM(ENUM_TYPE), FTYPE(ENUM_TYPE), true,
GOOGLE_PROTOBUF_DESCRIPTORPROTO_NESTED_TYPE__FIELDTYPE, true, 0); upb_enumdef_register_EnumDescriptorProto(h));
upb_handlers_typed_push(h, // DescriptorProto is self-recursive, so we must link the definition.
GOOGLE_PROTOBUF_DESCRIPTORPROTO_ENUM_TYPE__FIELDNUM, upb_mhandlers_newsubmsgfield(
GOOGLE_PROTOBUF_DESCRIPTORPROTO_ENUM_TYPE__FIELDTYPE, true); m, FNUM(NESTED_TYPE), FTYPE(NESTED_TYPE), true, m);
upb_enumdef_register_EnumDescriptorProto(h);
upb_handlers_typed_pop(h);
// TODO: extensions. // TODO: extensions.
return m;
} }
#undef FNUM
#undef FTYPE
static void upb_msgdef_free(upb_msgdef *m) static void upb_msgdef_free(upb_msgdef *m)
{ {

3
src/upb_def.h
Unescape View File

@ -328,6 +328,7 @@ upb_def **upb_symtab_getdefs(upb_symtab *s, int *count, upb_deftype_t type);
struct _upb_defbuilder; struct _upb_defbuilder;
typedef struct _upb_defbuilder upb_defbuilder; typedef struct _upb_defbuilder upb_defbuilder;
struct _upb_handlers; struct _upb_handlers;
struct _upb_handlers;
// Allocates a new defbuilder that will add defs to the given symtab. // Allocates a new defbuilder that will add defs to the given symtab.
upb_defbuilder *upb_defbuilder_new(upb_symtab *s); upb_defbuilder *upb_defbuilder_new(upb_symtab *s);
@ -337,7 +338,7 @@ upb_defbuilder *upb_defbuilder_new(upb_symtab *s);
// //
// TODO: should this allow redefinition? Either is possible, but which is // TODO: should this allow redefinition? Either is possible, but which is
// more useful? Maybe it should be an option. // more useful? Maybe it should be an option.
void upb_defbuilder_reghandlers(struct _upb_handlers *h); struct _upb_mhandlers *upb_defbuilder_reghandlers(struct _upb_handlers *h);
/* upb_def casts **************************************************************/ /* upb_def casts **************************************************************/

10
src/upb_glue.c
Unescape View File

@ -18,8 +18,8 @@ void upb_strtomsg(upb_string *str, upb_msg *msg, upb_msgdef *md,
upb_stringsrc_reset(&strsrc, str); upb_stringsrc_reset(&strsrc, str);
upb_handlers h; upb_handlers h;
upb_handlers_init(&h, md); upb_handlers_init(&h);
upb_msg_regdhandlers(&h); upb_msg_reghandlers(&h, md);
upb_decoder d; upb_decoder d;
upb_decoder_init(&d, &h); upb_decoder_init(&d, &h);
@ -39,8 +39,8 @@ void upb_msgtotext(upb_string *str, upb_msg *msg, upb_msgdef *md,
upb_textprinter *p = upb_textprinter_new(); upb_textprinter *p = upb_textprinter_new();
upb_handlers h; upb_handlers h;
upb_handlers_init(&h, md); upb_handlers_init(&h);
upb_textprinter_reghandlers(&h); upb_textprinter_reghandlers(&h, md);
upb_textprinter_reset(p, upb_stringsink_bytesink(&strsink), single_line); upb_textprinter_reset(p, upb_stringsink_bytesink(&strsink), single_line);
upb_status status = UPB_STATUS_INIT; upb_status status = UPB_STATUS_INIT;
@ -60,7 +60,7 @@ void upb_parsedesc(upb_symtab *symtab, upb_string *str, upb_status *status) {
upb_stringsrc_reset(&strsrc, str); upb_stringsrc_reset(&strsrc, str);
upb_handlers h; upb_handlers h;
upb_handlers_init(&h, NULL); upb_handlers_init(&h);
upb_defbuilder_reghandlers(&h); upb_defbuilder_reghandlers(&h);
upb_decoder d; upb_decoder d;

271
src/upb_handlers.c
Unescape View File

@ -9,8 +9,6 @@
#include "upb_handlers.h" #include "upb_handlers.h"
/* upb_handlers ***************************************************************/
upb_flow_t upb_startmsg_nop(void *closure) { upb_flow_t upb_startmsg_nop(void *closure) {
(void)closure; (void)closure;
return UPB_CONTINUE; return UPB_CONTINUE;
@ -39,220 +37,162 @@ upb_flow_t upb_endsubmsg_nop(void *closure, upb_value fval) {
return UPB_CONTINUE; return UPB_CONTINUE;
} }
upb_flow_t upb_unknownval_nop(void *closure, upb_field_number_t fieldnum,
upb_value val) {
(void)closure;
(void)fieldnum;
(void)val;
return UPB_CONTINUE;
}
static void upb_msgent_init(upb_mhandlers *e) { /* upb_mhandlers **************************************************************/
upb_inttable_init(&e->fieldtab, 8, sizeof(upb_fhandlers));
e->startmsg = &upb_startmsg_nop;
e->endmsg = &upb_endmsg_nop;
e->tablearray = NULL;
e->is_group = false;
}
void upb_handlers_init(upb_handlers *h, upb_msgdef *md) {
h->msgs_len = 1;
h->msgs_size = 4;
h->msgs = malloc(h->msgs_size * sizeof(*h->msgs));
h->top = &h->stack[0];
h->limit = &h->stack[UPB_MAX_TYPE_DEPTH];
h->toplevel_msgdef = md;
h->should_jit = true;
if (md) upb_msgdef_ref(md);
h->top->msgent_index = 0;
h->top->msgdef = md;
h->msgent = &h->msgs[0];
upb_msgent_init(h->msgent);
}
void upb_handlers_uninit(upb_handlers *h) { static upb_mhandlers *upb_mhandlers_new() {
for (int i = 0; i < h->msgs_len; i++) { upb_mhandlers *m = malloc(sizeof(*m));
upb_inttable_free(&h->msgs[i].fieldtab); upb_inttable_init(&m->fieldtab, 8, sizeof(upb_fhandlers));
free(h->msgs[i].tablearray); m->startmsg = &upb_startmsg_nop;
} m->endmsg = &upb_endmsg_nop;
free(h->msgs); m->tablearray = NULL;
upb_msgdef_unref(h->toplevel_msgdef); m->is_group = false;
return m;
} }
static upb_fhandlers *upb_handlers_getorcreate_without_fval( static upb_fhandlers *_upb_mhandlers_newfield(upb_mhandlers *m, uint32_t n,
upb_handlers *h, upb_field_number_t fieldnum, upb_fieldtype_t type, bool repeated) { upb_fieldtype_t type,
uint32_t tag = fieldnum << 3 | upb_types[type].native_wire_type; bool repeated) {
upb_fhandlers *f = upb_inttable_lookup(&h->msgent->fieldtab, tag); uint32_t tag = n << 3 | upb_types[type].native_wire_type;
if (!f) { upb_fhandlers *f = upb_inttable_lookup(&m->fieldtab, tag);
if (f) abort();
upb_fhandlers new_f = {false, type, repeated, upb_fhandlers new_f = {false, type, repeated,
repeated && upb_isprimitivetype(type), fieldnum, -1, UPB_NO_VALUE, repeated && upb_isprimitivetype(type), n, NULL, UPB_NO_VALUE,
{&upb_value_nop}, &upb_endsubmsg_nop, 0, 0, 0, NULL}; &upb_value_nop, &upb_startsubmsg_nop, &upb_endsubmsg_nop, 0, 0, 0, NULL};
if (upb_issubmsgtype(type)) new_f.cb.startsubmsg = &upb_startsubmsg_nop; if (upb_issubmsgtype(type)) new_f.startsubmsg = &upb_startsubmsg_nop;
upb_inttable_insert(&h->msgent->fieldtab, tag, &new_f); upb_inttable_insert(&m->fieldtab, tag, &new_f);
f = upb_inttable_lookup(&m->fieldtab, tag);
f = upb_inttable_lookup(&h->msgent->fieldtab, tag);
assert(f); assert(f);
}
assert(f->type == type); assert(f->type == type);
return f; return f;
} }
static upb_fhandlers *upb_handlers_getorcreate( upb_fhandlers *upb_mhandlers_newfield(upb_mhandlers *m, uint32_t n,
upb_handlers *h, upb_field_number_t fieldnum, upb_fieldtype_t type, bool repeated) {
upb_fieldtype_t type, bool repeated, upb_value fval) { assert(type != UPB_TYPE(MESSAGE));
upb_fhandlers *f = assert(type != UPB_TYPE(GROUP));
upb_handlers_getorcreate_without_fval(h, fieldnum, type, repeated); return _upb_mhandlers_newfield(m, n, type, repeated);
f->fval = fval;
return f;
} }
void upb_register_startend(upb_handlers *h, upb_startmsg_handler *startmsg, upb_fhandlers *upb_mhandlers_newsubmsgfield(upb_mhandlers *m, uint32_t n,
upb_endmsg_handler *endmsg) { upb_fieldtype_t type, bool repeated,
h->msgent->startmsg = startmsg ? startmsg : &upb_startmsg_nop; upb_mhandlers *subm) {
h->msgent->endmsg = endmsg ? endmsg : &upb_endmsg_nop; assert(type == UPB_TYPE(MESSAGE) || type == UPB_TYPE(GROUP));
assert(subm);
upb_fhandlers *f = _upb_mhandlers_newfield(m, n, type, repeated);
f->submsg = subm;
if (type == UPB_TYPE(GROUP))
_upb_mhandlers_newfield(subm, n, UPB_TYPE_ENDGROUP, false);
return f;
} }
// TODO: typedef struct {
// void upb_register_unknownval(upb_handlers *h, upb_strtable_entry e;
// upb_unknownval_handler *unknown); upb_mhandlers *mh;
// bool upb_handlers_link(upb_handlers *h, upb_fielddef *f); } upb_mtab_ent;
// void upb_register_path_value(upb_handlers *h, const char *path,
// upb_value_handler *value, upb_value fval); static upb_mhandlers *upb_regmsg_dfs(upb_handlers *h, upb_msgdef *m,
upb_onmsgreg *msgreg_cb,
void upb_register_all(upb_handlers *h, upb_startmsg_handler *start, upb_onfieldreg *fieldreg_cb,
upb_endmsg_handler *end, void *closure, upb_strtable *mtab) {
upb_value_handler *value, upb_mhandlers *mh = upb_handlers_newmsg(h);
upb_startsubmsg_handler *startsubmsg, upb_mtab_ent e = {{m->base.fqname, 0}, mh};
upb_endsubmsg_handler *endsubmsg) { printf("Inserting: " UPB_STRFMT "\n", UPB_STRARG(m->base.fqname));
upb_register_startend(h, start, end); upb_strtable_insert(mtab, &e.e);
//upb_register_unknownval(h, unknown); if (msgreg_cb) msgreg_cb(closure, mh, m);
upb_msgdef *m = h->top->msgdef;
upb_msg_iter i; upb_msg_iter i;
for(i = upb_msg_begin(m); !upb_msg_done(i); i = upb_msg_next(m, i)) { for(i = upb_msg_begin(m); !upb_msg_done(i); i = upb_msg_next(m, i)) {
upb_fielddef *f = upb_msg_iter_field(i); upb_fielddef *f = upb_msg_iter_field(i);
upb_value fval; upb_fhandlers *fh;
upb_value_setfielddef(&fval, f);
if (upb_issubmsg(f)) { if (upb_issubmsg(f)) {
upb_handlers_push(h, f, startsubmsg, endsubmsg, fval, false); upb_mhandlers *sub_mh;
upb_register_all(h, start, end, value, startsubmsg, endsubmsg); upb_mtab_ent *subm_ent;
upb_handlers_pop(h, f); // The table lookup is necessary to break the DFS for type cycles.
printf("Testing: " UPB_STRFMT "\n", UPB_STRARG(f->def->fqname));
if ((subm_ent = upb_strtable_lookup(mtab, f->def->fqname)) != NULL) {
sub_mh = subm_ent->mh;
} else { } else {
upb_register_value(h, f, value, fval); sub_mh = upb_regmsg_dfs(h, upb_downcast_msgdef(f->def), msgreg_cb,
fieldreg_cb, closure, mtab);
} }
fh = upb_mhandlers_newsubmsgfield(
mh, f->number, f->type, upb_isarray(f), sub_mh);
} else {
fh = upb_mhandlers_newfield(mh, f->number, f->type, upb_isarray(f));
} }
if (fieldreg_cb) fieldreg_cb(closure, fh, f);
} }
return mh;
void upb_register_typed_value(upb_handlers *h, upb_field_number_t fieldnum,
upb_fieldtype_t type, bool repeated,
upb_value_handler *value, upb_value fval) {
upb_handlers_getorcreate(h, fieldnum, type, repeated, fval)->cb.value =
value ? value : &upb_value_nop;
} }
void upb_register_value(upb_handlers *h, upb_fielddef *f, upb_mhandlers *upb_handlers_regmsgdef(upb_handlers *h, upb_msgdef *m,
upb_value_handler *value, upb_value fval) { upb_onmsgreg *msgreg_cb,
assert(f->msgdef == h->top->msgdef); upb_onfieldreg *fieldreg_cb,
upb_register_typed_value(h, f->number, f->type, upb_isarray(f), value, fval); void *closure) {
upb_strtable mtab;
upb_strtable_init(&mtab, 8, sizeof(upb_mtab_ent));
upb_mhandlers *ret =
upb_regmsg_dfs(h, m, msgreg_cb, fieldreg_cb, closure, &mtab);
upb_strtable_free(&mtab);
return ret;
} }
void upb_register_typed_submsg(upb_handlers *h, upb_field_number_t fieldnum,
upb_fieldtype_t type, bool repeated,
upb_startsubmsg_handler *start,
upb_endsubmsg_handler *end,
upb_value fval) {
upb_fhandlers *f = upb_handlers_getorcreate(h, fieldnum, type, repeated, fval);
f->cb.startsubmsg = start ? start : &upb_startsubmsg_nop;
f->endsubmsg = end ? end : &upb_endsubmsg_nop;
}
void upb_handlers_typed_link(upb_handlers *h, upb_field_number_t fieldnum, /* upb_handlers ***************************************************************/
upb_fieldtype_t type, bool repeated, int frames) {
assert(frames <= (h->top - h->stack));
upb_fhandlers *f =
upb_handlers_getorcreate_without_fval(h, fieldnum, type, repeated);
f->msgent_index = (h->top - frames)->msgent_index;
}
void upb_handlers_typed_push(upb_handlers *h, upb_field_number_t fieldnum, void upb_handlers_init(upb_handlers *h) {
upb_fieldtype_t type, bool repeated) { h->msgs_len = 0;
upb_fhandlers *f = h->msgs_size = 4;
upb_handlers_getorcreate_without_fval(h, fieldnum, type, repeated); h->msgs = malloc(h->msgs_size * sizeof(*h->msgs));
if (h->top == h->limit) abort(); // TODO: make growable. h->should_jit = true;
++h->top;
if (f->msgent_index == -1) {
// Need to push a new msgent.
if (h->msgs_size == h->msgs_len) {
h->msgs_size *= 2;
h->msgs = realloc(h->msgs, h->msgs_size * sizeof(*h->msgs));
}
f->msgent_index = h->msgs_len++;
h->msgent = &h->msgs[f->msgent_index];
upb_msgent_init(h->msgent);
} else {
h->msgent = &h->msgs[f->msgent_index];
}
h->top->msgent_index = f->msgent_index;
if (h->toplevel_msgdef) {
upb_fielddef *f = upb_msgdef_itof((h->top - 1)->msgdef, fieldnum);
assert(f);
h->top->msgdef = upb_downcast_msgdef(f->def);
} }
if (type == UPB_TYPE(GROUP)) {
// Insert a fieldent for ENDGROUP so we can easily dispatch endgroup when void upb_handlers_uninit(upb_handlers *h) {
// we see it in the submessage. for (int i = 0; i < h->msgs_len; i++) {
// TODO: assert that no other fields in the group are registered with the upb_mhandlers *mh = h->msgs[i];
// same name or number. upb_inttable_free(&mh->fieldtab);
upb_register_typed_submsg(h, fieldnum, UPB_TYPE_ENDGROUP, false, NULL, NULL, free(mh->tablearray);
UPB_NO_VALUE); free(mh);
h->msgent->is_group = true;
} }
free(h->msgs);
} }
void upb_handlers_push(upb_handlers *h, upb_fielddef *f, upb_mhandlers *upb_handlers_newmsg(upb_handlers *h) {
upb_startsubmsg_handler *start, if (h->msgs_len == h->msgs_size) {
upb_endsubmsg_handler *end, upb_value fval, h->msgs_size *= 2;
bool delegate) { h->msgs = realloc(h->msgs, h->msgs_size * sizeof(*h->msgs));
assert(f->msgdef == h->top->msgdef);
(void)delegate; // TODO
upb_register_typed_submsg(h, f->number, f->type, upb_isarray(f), start, end, fval);
upb_handlers_typed_push(h, f->number, f->type, upb_isarray(f));
} }
upb_mhandlers *mh = upb_mhandlers_new();
void upb_handlers_typed_pop(upb_handlers *h) { h->msgs[h->msgs_len++] = mh;
assert(h->top > h->stack); return mh;
--h->top;
h->msgent = &h->msgs[h->top->msgent_index];
} }
void upb_handlers_pop(upb_handlers *h, upb_fielddef *f) {
(void)f; // TODO: Check that this matches the corresponding push.
upb_handlers_typed_pop(h);
}
/* upb_dispatcher *************************************************************/ /* upb_dispatcher *************************************************************/
static upb_fhandlers toplevel_f = { static upb_fhandlers toplevel_f = {
false, UPB_TYPE(GROUP), false, false, 0, false, UPB_TYPE(GROUP), false, false, 0,
0, // msgent_index NULL, // submsg
#ifdef NDEBUG #ifdef NDEBUG
{{0}}, {{0}},
#else #else
{{0}, UPB_VALUETYPE_RAW}, {{0}, UPB_VALUETYPE_RAW},
#endif #endif
{NULL}, NULL, 0, 0, 0, NULL}; NULL, NULL, NULL, 0, 0, 0, NULL};
void upb_dispatcher_init(upb_dispatcher *d, upb_handlers *h) { void upb_dispatcher_init(upb_dispatcher *d, upb_handlers *h) {
d->handlers = h; d->handlers = h;
for (int i = 0; i < h->msgs_len; i++) for (int i = 0; i < h->msgs_len; i++) {
upb_inttable_compact(&h->msgs[i].fieldtab); upb_mhandlers *m = h->msgs[i];
upb_inttable_compact(&m->fieldtab);
}
d->stack[0].f = &toplevel_f; d->stack[0].f = &toplevel_f;
d->limit = &d->stack[UPB_MAX_NESTING]; d->limit = &d->stack[UPB_MAX_NESTING];
upb_status_init(&d->status); upb_status_init(&d->status);
} }
void upb_dispatcher_reset(upb_dispatcher *d, void *top_closure, uint32_t top_end_offset) { void upb_dispatcher_reset(upb_dispatcher *d, void *top_closure, uint32_t top_end_offset) {
d->msgent = &d->handlers->msgs[0]; d->msgent = d->handlers->msgs[0];
d->dispatch_table = &d->msgent->fieldtab; d->dispatch_table = &d->msgent->fieldtab;
d->current_depth = 0; d->current_depth = 0;
d->skip_depth = INT_MAX; d->skip_depth = INT_MAX;
@ -296,7 +236,7 @@ upb_flow_t upb_dispatch_startsubmsg(upb_dispatcher *d, upb_fhandlers *f,
size_t userval) { size_t userval) {
++d->current_depth; ++d->current_depth;
if (upb_dispatcher_skipping(d)) return UPB_SKIPSUBMSG; if (upb_dispatcher_skipping(d)) return UPB_SKIPSUBMSG;
upb_sflow_t sflow = f->cb.startsubmsg(d->top->closure, f->fval); upb_sflow_t sflow = f->startsubmsg(d->top->closure, f->fval);
if (sflow.flow != UPB_CONTINUE) { if (sflow.flow != UPB_CONTINUE) {
d->noframe_depth = d->current_depth; d->noframe_depth = d->current_depth;
d->skip_depth = (sflow.flow == UPB_BREAK) ? d->skip_depth = (sflow.flow == UPB_BREAK) ?
@ -315,7 +255,7 @@ upb_flow_t upb_dispatch_startsubmsg(upb_dispatcher *d, upb_fhandlers *f,
d->top->end_offset = userval; d->top->end_offset = userval;
d->top->closure = sflow.closure; d->top->closure = sflow.closure;
d->top->is_packed = false; d->top->is_packed = false;
d->msgent = upb_handlers_getmsgent(d->handlers, f); d->msgent = f->submsg;
d->dispatch_table = &d->msgent->fieldtab; d->dispatch_table = &d->msgent->fieldtab;
return upb_dispatch_startmsg(d); return upb_dispatch_startmsg(d);
} }
@ -329,7 +269,8 @@ upb_flow_t upb_dispatch_endsubmsg(upb_dispatcher *d) {
upb_fhandlers *old_f = d->top->f; upb_fhandlers *old_f = d->top->f;
d->msgent->endmsg(d->top->closure, &d->status); d->msgent->endmsg(d->top->closure, &d->status);
--d->top; --d->top;
d->msgent = upb_handlers_getmsgent(d->handlers, d->top->f); d->msgent = d->top->f->submsg;
if (!d->msgent) d->msgent = d->handlers->msgs[0];
d->dispatch_table = &d->msgent->fieldtab; d->dispatch_table = &d->msgent->fieldtab;
d->noframe_depth = INT_MAX; d->noframe_depth = INT_MAX;
if (!upb_dispatcher_skipping(d)) d->skip_depth = INT_MAX; if (!upb_dispatcher_skipping(d)) d->skip_depth = INT_MAX;

198
src/upb_handlers.h
Unescape View File

@ -108,6 +108,24 @@ upb_flow_t upb_value_nop(void *closure, upb_value fval, upb_value val);
upb_sflow_t upb_startsubmsg_nop(void *closure, upb_value fval); upb_sflow_t upb_startsubmsg_nop(void *closure, upb_value fval);
upb_flow_t upb_endsubmsg_nop(void *closure, upb_value fval); upb_flow_t upb_endsubmsg_nop(void *closure, upb_value fval);
// Structure definitions. Do not access any fields directly! Accessors are
// provided for the fields that may be get/set.
typedef struct _upb_mhandlers {
upb_startmsg_handler *startmsg;
upb_endmsg_handler *endmsg;
upb_inttable fieldtab; // Maps field number -> upb_fhandlers.
uint32_t jit_startmsg_pclabel;
uint32_t jit_endofbuf_pclabel;
uint32_t jit_endofmsg_pclabel;
uint32_t jit_unknownfield_pclabel;
bool is_group;
int32_t jit_parent_field_done_pclabel;
uint32_t max_field_number;
// Currently keyed on field number. Could also try keying it
// on encoded or decoded tag, or on encoded field number.
void **tablearray;
} upb_mhandlers;
struct _upb_decoder; struct _upb_decoder;
typedef struct _upb_fieldent { typedef struct _upb_fieldent {
bool junk; bool junk;
@ -115,14 +133,10 @@ typedef struct _upb_fieldent {
bool repeated; bool repeated;
bool is_repeated_primitive; bool is_repeated_primitive;
uint32_t number; uint32_t number;
// For upb_issubmsg(f) only, the index into the msgdef array of the submsg. upb_mhandlers *submsg; // Must be set iff upb_issubmsgtype(type) == true.
// -1 if unset (indicates that submsg should be skipped).
int32_t msgent_index;
upb_value fval; upb_value fval;
union {
upb_value_handler *value; upb_value_handler *value;
upb_startsubmsg_handler *startsubmsg; upb_startsubmsg_handler *startsubmsg;
} cb;
upb_endsubmsg_handler *endsubmsg; upb_endsubmsg_handler *endsubmsg;
uint32_t jit_pclabel; uint32_t jit_pclabel;
uint32_t jit_pclabel_notypecheck; uint32_t jit_pclabel_notypecheck;
@ -130,42 +144,15 @@ typedef struct _upb_fieldent {
void (*decode)(struct _upb_decoder *d, struct _upb_fieldent *f); void (*decode)(struct _upb_decoder *d, struct _upb_fieldent *f);
} upb_fhandlers; } upb_fhandlers;
typedef struct _upb_msgent {
upb_startmsg_handler *startmsg;
upb_endmsg_handler *endmsg;
// Maps field number -> upb_fhandlers.
upb_inttable fieldtab;
uint32_t jit_startmsg_pclabel;
uint32_t jit_endofbuf_pclabel;
uint32_t jit_endofmsg_pclabel;
uint32_t jit_unknownfield_pclabel;
bool is_group;
int32_t jit_parent_field_done_pclabel;
uint32_t max_field_number;
// Currently keyed on field number. Could also try keying it
// on encoded or decoded tag, or on encoded field number.
void **tablearray;
} upb_mhandlers;
typedef struct {
upb_msgdef *msgdef;
int msgent_index;
} upb_handlers_frame;
struct _upb_handlers { struct _upb_handlers {
// Array of msgdefs, [0]=toplevel. // Array of msgdefs, [0]=toplevel.
upb_mhandlers *msgs; upb_mhandlers **msgs;
int msgs_len, msgs_size; int msgs_len, msgs_size;
upb_msgdef *toplevel_msgdef; // We own a ref.
upb_mhandlers *msgent;
upb_handlers_frame stack[UPB_MAX_TYPE_DEPTH], *top, *limit;
bool should_jit; bool should_jit;
}; };
typedef struct _upb_handlers upb_handlers; typedef struct _upb_handlers upb_handlers;
// The handlers object takes a ref on md. md can be NULL iff the client calls void upb_handlers_init(upb_handlers *h);
// only upb_*_typed_*() (only upb_symtab should do this).
void upb_handlers_init(upb_handlers *h, upb_msgdef *md);
void upb_handlers_uninit(upb_handlers *h); void upb_handlers_uninit(upb_handlers *h);
// The startsubmsg handler needs to also pass a closure to the submsg. // The startsubmsg handler needs to also pass a closure to the submsg.
@ -180,75 +167,84 @@ INLINE upb_sflow_t UPB_SFLOW(upb_flow_t flow, void *closure) {
#define UPB_CONTINUE_WITH(c) UPB_SFLOW(UPB_CONTINUE, c) #define UPB_CONTINUE_WITH(c) UPB_SFLOW(UPB_CONTINUE, c)
#define UPB_S_BREAK UPB_SFLOW(UPB_BREAK, NULL) #define UPB_S_BREAK UPB_SFLOW(UPB_BREAK, NULL)
// Functions to register the above handlers. // Appends a new message to the graph of handlers and returns it. This message
void upb_register_startend(upb_handlers *h, upb_startmsg_handler *startmsg, // can be obtained later at index upb_handlers_msgcount()-1. All handlers will
upb_endmsg_handler *endmsg); // be initialized to no-op handlers.
void upb_register_value(upb_handlers *h, upb_fielddef *f, upb_mhandlers *upb_handlers_newmsg(upb_handlers *h);
upb_value_handler *value, upb_value fval); upb_mhandlers *upb_handlers_getmsg(upb_handlers *h, int index);
// To register handlers for a submessage, push the fielddef and pop it // Creates a new field with the given name and number. There must not be an
// when you're done. This can be used to delegate a submessage to a // existing field with either this name or number or abort() will be called.
// different processing component which does not need to be aware whether // TODO: this should take a name also.
// it is at the top level or not. upb_fhandlers *upb_mhandlers_newfield(upb_mhandlers *m, uint32_t n,
void upb_handlers_push(upb_handlers *h, upb_fielddef *f,
upb_startsubmsg_handler *start,
upb_endsubmsg_handler *end, upb_value fval,
bool delegate);
void upb_handlers_pop(upb_handlers *h, upb_fielddef *f);
// In the case where types are self-recursive or mutually recursive, you can
// use this function which will link a set of handlers to a set that is
// already on our stack. This allows us to handle a tree of arbitrary
// depth without having to register an arbitrary number of levels of handlers.
// Returns "true" if the given type is indeed on the stack already and was
// linked.
//
// If more than one message of this type is on the stack, it chooses the
// one that is deepest in the tree (if necessary, we could give the caller
// more control over this).
bool upb_handlers_link(upb_handlers *h, upb_fielddef *f);
// Convenience function for registering the given handler for the given
// field path. This will overwrite any startsubmsg handlers that were
// previously registered along the path. These can be overwritten again
// later if desired.
// TODO: upb_register_path_submsg()?
void upb_register_path_value(upb_handlers *h, const char *path,
upb_value_handler *value, upb_value fval);
// Convenience function for registering a single set of handlers on every
// message in our hierarchy. mvals are bound to upb_msgdef* and fvals are
// bound to upb_fielddef*. Any of the handlers can be NULL.
void upb_register_all(upb_handlers *h, upb_startmsg_handler *start,
upb_endmsg_handler *end,
upb_value_handler *value,
upb_startsubmsg_handler *startsubmsg,
upb_endsubmsg_handler *endsubmsg);
// TODO: for clients that want to increase efficiency by preventing bytesrcs
// from automatically being converted to strings in the value callback.
// INLINE void upb_handlers_use_bytesrcs(upb_handlers *h, bool use_bytesrcs);
// Low-level functions -- internal-only.
void upb_register_typed_value(upb_handlers *h, upb_field_number_t fieldnum,
upb_fieldtype_t type, bool repeated,
upb_value_handler *value, upb_value fval);
void upb_register_typed_submsg(upb_handlers *h, upb_field_number_t fieldnum,
upb_fieldtype_t type, bool repeated,
upb_startsubmsg_handler *start,
upb_endsubmsg_handler *end,
upb_value fval);
void upb_handlers_typed_link(upb_handlers *h, upb_field_number_t fieldnum,
upb_fieldtype_t type, bool repeated, int frames);
void upb_handlers_typed_push(upb_handlers *h, upb_field_number_t fieldnum,
upb_fieldtype_t type, bool repeated); upb_fieldtype_t type, bool repeated);
void upb_handlers_typed_pop(upb_handlers *h); // Like the previous but for MESSAGE or GROUP fields. For GROUP fields, the
// given submessage must not have any fields with this field number.
upb_fhandlers *upb_mhandlers_newsubmsgfield(upb_mhandlers *m, uint32_t n,
upb_fieldtype_t type, bool repeated,
upb_mhandlers *subm);
// upb_mhandlers accessors.
#define UPB_MHANDLERS_ACCESSORS(name, type) \
INLINE void upb_mhandlers_set ## name(upb_mhandlers *m, type v){m->name = v;} \
INLINE type upb_mhandlers_get ## name(upb_mhandlers *m) { return m->name; }
UPB_MHANDLERS_ACCESSORS(startmsg, upb_startmsg_handler*);
UPB_MHANDLERS_ACCESSORS(endmsg, upb_endmsg_handler*);
// upb_fhandlers accessors
#define UPB_FHANDLERS_ACCESSORS(name, type) \
INLINE void upb_fhandlers_set ## name(upb_fhandlers *f, type v){f->name = v;} \
INLINE type upb_fhandlers_get ## name(upb_fhandlers *f) { return f->name; }
UPB_FHANDLERS_ACCESSORS(fval, upb_value)
UPB_FHANDLERS_ACCESSORS(value, upb_value_handler*)
UPB_FHANDLERS_ACCESSORS(startsubmsg, upb_startsubmsg_handler*)
UPB_FHANDLERS_ACCESSORS(endsubmsg, upb_endsubmsg_handler*)
UPB_FHANDLERS_ACCESSORS(submsg, upb_mhandlers*)
// Convenience function for registering handlers for all messages and
// fields in a msgdef and all its children. For every registered message
// "msgreg_cb" will be called with the newly-created mhandlers, and likewise
// with "fieldreg_cb"
//
// See upb_handlers_reghandlerset() below for an example.
typedef void upb_onmsgreg(void *closure, upb_mhandlers *mh, upb_msgdef *m);
typedef void upb_onfieldreg(void *closure, upb_fhandlers *mh, upb_fielddef *m);
upb_mhandlers *upb_handlers_regmsgdef(upb_handlers *h, upb_msgdef *m,
upb_onmsgreg *msgreg_cb,
upb_onfieldreg *fieldreg_cb,
void *closure);
// Convenience function for registering a set of handlers for all messages and
// fields in a msgdef and its children, with the fval bound to the upb_fielddef.
// Any of the handlers may be NULL, in which case no callback will be set and
// the nop callback will be used.
typedef struct {
upb_startmsg_handler *startmsg;
upb_endmsg_handler *endmsg;
upb_value_handler *value;
upb_startsubmsg_handler *startsubmsg;
upb_endsubmsg_handler *endsubmsg;
} upb_handlerset;
INLINE upb_mhandlers *upb_handlers_getmsgent(upb_handlers *h, upb_fhandlers *f) { INLINE void upb_onmreg_hset(void *c, upb_mhandlers *mh, upb_msgdef *m) {
assert(f->msgent_index != -1); (void)m;
return &h->msgs[f->msgent_index]; upb_handlerset *hs = (upb_handlerset*)c;
if (hs->startmsg) upb_mhandlers_setstartmsg(mh, hs->startmsg);
if (hs->endmsg) upb_mhandlers_setendmsg(mh, hs->endmsg);
}
INLINE void upb_onfreg_hset(void *c, upb_fhandlers *fh, upb_fielddef *f) {
upb_handlerset *hs = (upb_handlerset*)c;
if (hs->value) upb_fhandlers_setvalue(fh, hs->value);
if (hs->startsubmsg) upb_fhandlers_setstartsubmsg(fh, hs->startsubmsg);
if (hs->endsubmsg) upb_fhandlers_setendsubmsg(fh, hs->endsubmsg);
upb_value val;
upb_value_setfielddef(&val, f);
upb_fhandlers_setfval(fh, val);
}
INLINE upb_mhandlers *upb_handlers_reghandlerset(upb_handlers *h, upb_msgdef *m,
upb_handlerset *hs) {
return upb_handlers_regmsgdef(h, m, &upb_onmreg_hset, &upb_onfreg_hset, hs);
} }
upb_fhandlers *upb_handlers_lookup(upb_inttable *dispatch_table, upb_field_number_t fieldnum);
/* upb_dispatcher *************************************************************/ /* upb_dispatcher *************************************************************/
@ -338,7 +334,7 @@ upb_flow_t upb_dispatch_endsubmsg(upb_dispatcher *d);
INLINE upb_flow_t upb_dispatch_value(upb_dispatcher *d, upb_fhandlers *f, INLINE upb_flow_t upb_dispatch_value(upb_dispatcher *d, upb_fhandlers *f,
upb_value val) { upb_value val) {
if (upb_dispatcher_skipping(d)) return UPB_SKIPSUBMSG; if (upb_dispatcher_skipping(d)) return UPB_SKIPSUBMSG;
upb_flow_t flow = f->cb.value(d->top->closure, f->fval, val); upb_flow_t flow = f->value(d->top->closure, f->fval, val);
if (flow != UPB_CONTINUE) { if (flow != UPB_CONTINUE) {
d->noframe_depth = d->current_depth + 1; d->noframe_depth = d->current_depth + 1;
d->skip_depth = (flow == UPB_BREAK) ? d->delegated_depth : d->current_depth; d->skip_depth = (flow == UPB_BREAK) ? d->delegated_depth : d->current_depth;

22
src/upb_msg.c
Unescape View File

@ -461,16 +461,8 @@ upb_sflow_t upb_msgsink_startsubmsg_r(void *_m, upb_value _fval) {
return UPB_CONTINUE_WITH(upb_msg_appendmsg(m, &f, &md)); return UPB_CONTINUE_WITH(upb_msg_appendmsg(m, &f, &md));
} }
void upb_msg_regdhandlers(upb_handlers *h) { INLINE void upb_msg_onfreg(void *c, upb_fhandlers *fh, upb_fielddef *f) {
upb_register_all(h, NULL, NULL, NULL, NULL, NULL); (void)c;
for (int i = 0; i < h->msgs_len; i++) {
upb_mhandlers *m = &h->msgs[i];
upb_inttable_iter iter = upb_inttable_begin(&m->fieldtab);
for(; !upb_inttable_done(iter);
iter = upb_inttable_next(&m->fieldtab, iter)) {
upb_fhandlers *fe = upb_inttable_iter_value(iter);
if (fe->type == UPB_TYPE_ENDGROUP) continue;
upb_fielddef *f = upb_value_getfielddef(fe->fval);
uint16_t msg_size = 0; uint16_t msg_size = 0;
uint8_t set_flags_bytes = 0; uint8_t set_flags_bytes = 0;
if (upb_issubmsg(f)) { if (upb_issubmsg(f)) {
@ -478,12 +470,12 @@ void upb_msg_regdhandlers(upb_handlers *h) {
msg_size = md->size; msg_size = md->size;
set_flags_bytes = md->set_flags_bytes; set_flags_bytes = md->set_flags_bytes;
} }
upb_value_setuint64(&fe->fval, upb_value_setuint64(&fh->fval,
upb_msgsink_packfval(f->set_bit_offset, f->set_bit_mask, upb_msgsink_packfval(f->set_bit_offset, f->set_bit_mask,
f->byte_offset, msg_size, set_flags_bytes)); f->byte_offset, msg_size, set_flags_bytes));
#define CASE(upb_type, type) \ #define CASE(upb_type, type) \
case UPB_TYPE(upb_type): \ case UPB_TYPE(upb_type): \
fe->cb.value = upb_isarray(f) ? \ fh->value = upb_isarray(f) ? \
upb_msgsink_ ## type ## value_r : upb_msgsink_ ## type ## value; \ upb_msgsink_ ## type ## value_r : upb_msgsink_ ## type ## value; \
break; break;
switch (f->type) { switch (f->type) {
@ -506,10 +498,12 @@ void upb_msg_regdhandlers(upb_handlers *h) {
#undef CASE #undef CASE
case UPB_TYPE(MESSAGE): case UPB_TYPE(MESSAGE):
case UPB_TYPE(GROUP): case UPB_TYPE(GROUP):
fe->cb.startsubmsg = fh->startsubmsg =
upb_isarray(f) ? upb_msgsink_startsubmsg_r : upb_msgsink_startsubmsg; upb_isarray(f) ? upb_msgsink_startsubmsg_r : upb_msgsink_startsubmsg;
break; break;
} }
} }
}
upb_mhandlers *upb_msg_reghandlers(upb_handlers *h, upb_msgdef *m) {
return upb_handlers_regmsgdef(h, m, NULL, &upb_msg_onfreg, NULL);
} }

6
src/upb_msg.h
Unescape View File

@ -277,11 +277,7 @@ INLINE void upb_msg_clear(upb_msg *msg, upb_msgdef *md) {
// Registers handlers for populating a msg for the given upb_msgdef. // Registers handlers for populating a msg for the given upb_msgdef.
// The upb_msg itself must be passed as the param to the src. // The upb_msg itself must be passed as the param to the src.
void upb_msg_reghandlers(upb_handlers *h, upb_msgdef *md); upb_mhandlers *upb_msg_reghandlers(upb_handlers *h, upb_msgdef *md);
// Registers handlers that are suitable for populating a msg of *any*
// upb_msgdef ("dynamic" handlers). May be slower than upb_msg_reghandlers().
void upb_msg_regdhandlers(upb_handlers *h);
void upb_msg_runhandlers(upb_msg *msg, upb_msgdef *md, upb_handlers *h, void upb_msg_runhandlers(upb_msg *msg, upb_msgdef *md, upb_handlers *h,
void *closure, upb_status *status); void *closure, upb_status *status);

7
src/upb_textprinter.c
Unescape View File

@ -185,12 +185,13 @@ void upb_textprinter_reset(upb_textprinter *p, upb_bytesink *sink,
p->indent_depth = 0; p->indent_depth = 0;
} }
void upb_textprinter_reghandlers(upb_handlers *h) { upb_mhandlers *upb_textprinter_reghandlers(upb_handlers *h, upb_msgdef *m) {
upb_register_all(h, upb_handlerset hset = {
NULL, // startmsg NULL, // startmsg
NULL, // endmsg NULL, // endmsg
upb_textprinter_value, upb_textprinter_value,
upb_textprinter_startsubmsg, upb_textprinter_startsubmsg,
upb_textprinter_endsubmsg upb_textprinter_endsubmsg
); };
return upb_handlers_reghandlerset(h, m, &hset);
} }

2
src/upb_textprinter.h
Unescape View File

@ -22,7 +22,7 @@ upb_textprinter *upb_textprinter_new();
void upb_textprinter_free(upb_textprinter *p); void upb_textprinter_free(upb_textprinter *p);
void upb_textprinter_reset(upb_textprinter *p, upb_bytesink *sink, void upb_textprinter_reset(upb_textprinter *p, upb_bytesink *sink,
bool single_line); bool single_line);
void upb_textprinter_reghandlers(upb_handlers *h); upb_mhandlers *upb_textprinter_reghandlers(upb_handlers *h, upb_msgdef *m);
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */

5
tests/tests.c
Unescape View File

@ -39,8 +39,9 @@ static void test_upb_jit() {
ASSERT(def); ASSERT(def);
upb_handlers h; upb_handlers h;
upb_handlers_init(&h, upb_downcast_msgdef(def)); upb_handlers_init(&h);
upb_register_all(&h, NULL, NULL, &upb_test_onvalue, NULL, NULL); upb_handlerset hset = {NULL, NULL, &upb_test_onvalue, NULL, NULL};
upb_handlers_reghandlerset(&h, upb_downcast_msgdef(def), &hset);
upb_decoder d; upb_decoder d;
upb_decoder_init(&d, &h); upb_decoder_init(&d, &h);
upb_decoder_uninit(&d); upb_decoder_uninit(&d);

Write Preview
Loading…
Cancel
Save