From d5566c6038845e505f7c16130b2368ef9bb3a373 Mon Sep 17 00:00:00 2001 From: Joshua Haberman Date: Fri, 15 Jan 2010 19:11:54 -0800 Subject: Remove struct keyword from all types, use typedef instead. --- src/upb_def.c | 250 +++++++++++++++++++++++++++------------------------------- 1 file changed, 118 insertions(+), 132 deletions(-) (limited to 'src/upb_def.c') diff --git a/src/upb_def.c b/src/upb_def.c index 2ab1d11..7c9777d 100644 --- a/src/upb_def.c +++ b/src/upb_def.c @@ -56,11 +56,11 @@ static int div_round_up(int numerator, int denominator) { // This algorithm is relatively cheap, since it only requires extra work when // the external refcount on a cyclic type transitions from 0->1 or 1->0. -static void msgdef_free(struct upb_msgdef *m); -static void enumdef_free(struct upb_enumdef *e); -static void unresolveddef_free(struct upb_unresolveddef *u); +static void msgdef_free(upb_msgdef *m); +static void enumdef_free(upb_enumdef *e); +static void unresolveddef_free(struct _upb_unresolveddef *u); -static void def_free(struct upb_def *def) +static void def_free(upb_def *def) { switch(def->type) { case UPB_DEF_MSG: @@ -91,9 +91,8 @@ static void def_free(struct upb_def *def) // search so we can stop the search if we detect a cycles that do not involve // cycle_base. We can't color the nodes as we go by writing to a member of the // def, because another thread could be performing the search concurrently. -static int cycle_ref_or_unref(struct upb_msgdef *m, - struct upb_msgdef *cycle_base, - struct upb_msgdef **open_defs, int num_open_defs, +static int cycle_ref_or_unref(upb_msgdef *m, upb_msgdef *cycle_base, + upb_msgdef **open_defs, int num_open_defs, bool ref) { bool found = false; for(int i = 0; i < num_open_defs; i++) { @@ -116,10 +115,10 @@ static int cycle_ref_or_unref(struct upb_msgdef *m, open_defs[num_open_defs++] = m; } for(int i = 0; i < m->num_fields; i++) { - struct upb_fielddef *f = &m->fields[i]; - struct upb_def *def = f->def; + upb_fielddef *f = &m->fields[i]; + upb_def *def = f->def; if(upb_issubmsg(f) && def->is_cyclic) { - struct upb_msgdef *sub_m = upb_downcast_msgdef(def); + upb_msgdef *sub_m = upb_downcast_msgdef(def); path_count += cycle_ref_or_unref(sub_m, cycle_base, open_defs, num_open_defs, ref); } @@ -134,22 +133,22 @@ static int cycle_ref_or_unref(struct upb_msgdef *m, } } -void _upb_def_reftozero(struct upb_def *def) { +void _upb_def_reftozero(upb_def *def) { if(def->is_cyclic) { - struct upb_msgdef *m = upb_downcast_msgdef(def); - struct upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN]; + upb_msgdef *m = upb_downcast_msgdef(def); + upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN]; cycle_ref_or_unref(m, NULL, open_defs, 0, false); } else { def_free(def); } } -void _upb_def_cyclic_ref(struct upb_def *def) { - struct upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN]; +void _upb_def_cyclic_ref(upb_def *def) { + upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN]; cycle_ref_or_unref(upb_downcast_msgdef(def), NULL, open_defs, 0, true); } -static void upb_def_init(struct upb_def *def, enum upb_def_type type, +static void upb_def_init(upb_def *def, enum upb_def_type type, upb_strptr fqname) { def->type = type; def->is_cyclic = 0; // We detect this later, after resolving refs. @@ -158,26 +157,26 @@ static void upb_def_init(struct upb_def *def, enum upb_def_type type, upb_atomic_refcount_init(&def->refcount, 1); } -static void upb_def_uninit(struct upb_def *def) { +static void upb_def_uninit(upb_def *def) { upb_string_unref(def->fqname); } /* upb_unresolveddef **********************************************************/ -struct upb_unresolveddef { - struct upb_def base; +typedef struct _upb_unresolveddef { + upb_def base; upb_strptr name; -}; +} upb_unresolveddef; -static struct upb_unresolveddef *upb_unresolveddef_new(upb_strptr str) { - struct upb_unresolveddef *def = malloc(sizeof(*def)); +static upb_unresolveddef *upb_unresolveddef_new(upb_strptr str) { + upb_unresolveddef *def = malloc(sizeof(*def)); upb_strptr name = upb_string_getref(str, UPB_REF_THREADUNSAFE_READONLY); upb_def_init(&def->base, UPB_DEF_UNRESOLVED, name); def->name = name; return def; } -static void unresolveddef_free(struct upb_unresolveddef *def) { +static void unresolveddef_free(struct _upb_unresolveddef *def) { upb_string_unref(def->name); upb_def_uninit(&def->base); free(def); @@ -185,7 +184,7 @@ static void unresolveddef_free(struct upb_unresolveddef *def) { /* upb_fielddef ***************************************************************/ -static void fielddef_init(struct upb_fielddef *f, +static void fielddef_init(upb_fielddef *f, google_protobuf_FieldDescriptorProto *fd) { f->type = fd->type; @@ -201,14 +200,14 @@ static void fielddef_init(struct upb_fielddef *f, } } -static struct upb_fielddef *fielddef_new( - google_protobuf_FieldDescriptorProto *fd) { - struct upb_fielddef *f = malloc(sizeof(*f)); +static upb_fielddef *fielddef_new(google_protobuf_FieldDescriptorProto *fd) +{ + upb_fielddef *f = malloc(sizeof(*f)); fielddef_init(f, fd); return f; } -static void fielddef_uninit(struct upb_fielddef *f) +static void fielddef_uninit(upb_fielddef *f) { upb_string_unref(f->name); if(upb_hasdef(f) && f->owned) { @@ -216,12 +215,12 @@ static void fielddef_uninit(struct upb_fielddef *f) } } -static void fielddef_free(struct upb_fielddef *f) { +static void fielddef_free(upb_fielddef *f) { fielddef_uninit(f); free(f); } -static void fielddef_copy(struct upb_fielddef *dst, struct upb_fielddef *src) +static void fielddef_copy(upb_fielddef *dst, upb_fielddef *src) { *dst = *src; dst->name = upb_string_getref(src->name, UPB_REF_FROZEN); @@ -232,7 +231,7 @@ static void fielddef_copy(struct upb_fielddef *dst, struct upb_fielddef *src) } // Callback for sorting fields. -static int compare_fields(struct upb_fielddef *f1, struct upb_fielddef *f2) { +static int compare_fields(upb_fielddef *f1, upb_fielddef *f2) { // Required fields go before non-required. bool req1 = f1->label == GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_REQUIRED; bool req2 = f2->label == GOOGLE_PROTOBUF_FIELDDESCRIPTORPROTO_LABEL_REQUIRED; @@ -250,7 +249,7 @@ static int compare_fielddefs(const void *e1, const void *e2) { } static int compare_fds(const void *e1, const void *e2) { - struct upb_fielddef f1, f2; + upb_fielddef f1, f2; fielddef_init(&f1, *(void**)e1); fielddef_init(&f2, *(void**)e2); int ret = compare_fields(&f1, &f2); @@ -264,17 +263,15 @@ void upb_fielddef_sortfds(google_protobuf_FieldDescriptorProto **fds, size_t num qsort(fds, num, sizeof(*fds), compare_fds); } -static void fielddef_sort(struct upb_fielddef **defs, size_t num) +static void fielddef_sort(upb_fielddef **defs, size_t num) { qsort(defs, num, sizeof(*defs), compare_fielddefs); } /* upb_msgdef *****************************************************************/ -static struct upb_msgdef *msgdef_new(struct upb_fielddef **fields, - int num_fields, - upb_strptr fqname, - struct upb_status *status) +static upb_msgdef *msgdef_new(upb_fielddef **fields, int num_fields, + upb_strptr fqname, upb_status *status) { if(num_fields > UPB_MAX_FIELDS) { upb_seterr(status, UPB_STATUS_ERROR, @@ -282,23 +279,23 @@ static struct upb_msgdef *msgdef_new(struct upb_fielddef **fields, free(fields); return NULL; } - struct upb_msgdef *m = malloc(sizeof(*m)); + upb_msgdef *m = malloc(sizeof(*m)); upb_def_init(&m->base, UPB_DEF_MSG, fqname); upb_atomic_refcount_init(&m->cycle_refcount, 0); - upb_inttable_init(&m->itof, num_fields, sizeof(struct upb_itof_ent)); - upb_strtable_init(&m->ntof, num_fields, sizeof(struct upb_ntof_ent)); + upb_inttable_init(&m->itof, num_fields, sizeof(upb_itof_ent)); + upb_strtable_init(&m->ntof, num_fields, sizeof(upb_ntof_ent)); m->num_fields = num_fields; m->set_flags_bytes = div_round_up(m->num_fields, 8); // These are incremented in the loop. m->num_required_fields = 0; m->size = m->set_flags_bytes + 4; // 4 for the refcount. - m->fields = malloc(sizeof(struct upb_fielddef) * num_fields); + m->fields = malloc(sizeof(upb_fielddef) * num_fields); size_t max_align = 0; for(int i = 0; i < num_fields; i++) { - struct upb_fielddef *f = &m->fields[i]; - struct upb_type_info *type_info = &upb_type_info[fields[i]->type]; + upb_fielddef *f = &m->fields[i]; + upb_type_info *type_info = &upb_types[fields[i]->type]; fielddef_copy(f, fields[i]); // General alignment rules are: each member must be at an address that is a @@ -316,8 +313,8 @@ static struct upb_msgdef *msgdef_new(struct upb_fielddef **fields, } // Insert into the tables. - struct upb_itof_ent itof_ent = {{f->number, 0}, f}; - struct upb_ntof_ent ntof_ent = {{f->name, 0}, f}; + upb_itof_ent itof_ent = {{f->number, 0}, f}; + upb_ntof_ent ntof_ent = {{f->name, 0}, f}; upb_inttable_insert(&m->itof, &itof_ent.e); upb_strtable_insert(&m->ntof, &ntof_ent.e); } @@ -326,7 +323,7 @@ static struct upb_msgdef *msgdef_new(struct upb_fielddef **fields, return m; } -static void msgdef_free(struct upb_msgdef *m) +static void msgdef_free(upb_msgdef *m) { for (upb_field_count_t i = 0; i < m->num_fields; i++) fielddef_uninit(&m->fields[i]); @@ -337,8 +334,7 @@ static void msgdef_free(struct upb_msgdef *m) free(m); } -static void upb_msgdef_resolve(struct upb_msgdef *m, struct upb_fielddef *f, - struct upb_def *def) { +static void upb_msgdef_resolve(upb_msgdef *m, upb_fielddef *f, upb_def *def) { (void)m; if(f->owned) upb_def_unref(f->def); f->def = def; @@ -349,75 +345,75 @@ static void upb_msgdef_resolve(struct upb_msgdef *m, struct upb_fielddef *f, /* upb_enumdef ****************************************************************/ -struct ntoi_ent { - struct upb_strtable_entry e; +typedef struct { + upb_strtable_entry e; uint32_t value; -}; +} ntoi_ent; -struct iton_ent { - struct upb_inttable_entry e; +typedef struct { + upb_inttable_entry e; upb_strptr string; -}; +} iton_ent; -static struct upb_enumdef *enumdef_new(google_protobuf_EnumDescriptorProto *ed, - upb_strptr fqname) +static upb_enumdef *enumdef_new(google_protobuf_EnumDescriptorProto *ed, + upb_strptr fqname) { - struct upb_enumdef *e = malloc(sizeof(*e)); + upb_enumdef *e = malloc(sizeof(*e)); upb_def_init(&e->base, UPB_DEF_ENUM, fqname); int num_values = ed->set_flags.has.value ? google_protobuf_EnumValueDescriptorProto_array_len(ed->value) : 0; - upb_strtable_init(&e->ntoi, num_values, sizeof(struct ntoi_ent)); - upb_inttable_init(&e->iton, num_values, sizeof(struct iton_ent)); + upb_strtable_init(&e->ntoi, num_values, sizeof(ntoi_ent)); + upb_inttable_init(&e->iton, num_values, sizeof(iton_ent)); for(int i = 0; i < num_values; i++) { google_protobuf_EnumValueDescriptorProto *value = google_protobuf_EnumValueDescriptorProto_array_get(ed->value, i); - struct ntoi_ent ntoi_ent = {{value->name, 0}, value->number}; - struct iton_ent iton_ent = {{value->number, 0}, value->name}; + ntoi_ent ntoi_ent = {{value->name, 0}, value->number}; + iton_ent iton_ent = {{value->number, 0}, value->name}; upb_strtable_insert(&e->ntoi, &ntoi_ent.e); upb_inttable_insert(&e->iton, &iton_ent.e); } return e; } -static void enumdef_free(struct upb_enumdef *e) { +static void enumdef_free(upb_enumdef *e) { upb_strtable_free(&e->ntoi); upb_inttable_free(&e->iton); upb_def_uninit(&e->base); free(e); } -static void fill_iter(struct upb_enum_iter *iter, struct ntoi_ent *ent) { +static void fill_iter(upb_enum_iter *iter, ntoi_ent *ent) { iter->state = ent; iter->name = ent->e.key; iter->val = ent->value; } -void upb_enum_begin(struct upb_enum_iter *iter, struct upb_enumdef *e) { +void upb_enum_begin(upb_enum_iter *iter, upb_enumdef *e) { // We could iterate over either table here; the choice is arbitrary. - struct ntoi_ent *ent = upb_strtable_begin(&e->ntoi); + ntoi_ent *ent = upb_strtable_begin(&e->ntoi); iter->e = e; fill_iter(iter, ent); } -void upb_enum_next(struct upb_enum_iter *iter) { - struct ntoi_ent *ent = iter->state; +void upb_enum_next(upb_enum_iter *iter) { + ntoi_ent *ent = iter->state; assert(ent); ent = upb_strtable_next(&iter->e->ntoi, &ent->e); iter->state = ent; if(ent) fill_iter(iter, ent); } -bool upb_enum_done(struct upb_enum_iter *iter) { +bool upb_enum_done(upb_enum_iter *iter) { return iter->state == NULL; } /* symtab internal ***********************************************************/ -struct symtab_ent { - struct upb_strtable_entry e; - struct upb_def *def; -}; +typedef struct { + upb_strtable_entry e; + upb_def *def; +} symtab_ent; /* Search for a character in a string, in reverse. */ static int my_memrchr(char *data, char c, size_t len) @@ -429,9 +425,7 @@ static int my_memrchr(char *data, char c, size_t len) /* Given a symbol and the base symbol inside which it is defined, find the * symbol's definition in t. */ -static struct symtab_ent *resolve(struct upb_strtable *t, - upb_strptr base, - upb_strptr symbol) +static symtab_ent *resolve(upb_strtable *t, upb_strptr base, upb_strptr symbol) { if(upb_strlen(base) + upb_strlen(symbol) + 1 >= UPB_SYMBOL_MAXLEN || upb_strlen(symbol) == 0) return NULL; @@ -440,7 +434,7 @@ static struct symtab_ent *resolve(struct upb_strtable *t, // Symbols starting with '.' are absolute, so we do a single lookup. // Slice to omit the leading '.' upb_strptr sym_str = upb_strslice(symbol, 1, INT_MAX); - struct symtab_ent *e = upb_strtable_lookup(t, sym_str); + symtab_ent *e = upb_strtable_lookup(t, sym_str); upb_string_unref(sym_str); return e; } else { @@ -455,7 +449,7 @@ static struct symtab_ent *resolve(struct upb_strtable *t, buf[baselen] = UPB_SYMBOL_SEPARATOR; memcpy(buf + baselen + 1, upb_string_getrobuf(symbol), upb_strlen(symbol)); - struct symtab_ent *e = upb_strtable_lookup(t, sym_str); + symtab_ent *e = upb_strtable_lookup(t, sym_str); if (e) return e; else if(baselen == 0) return NULL; /* No more scopes to try. */ @@ -478,8 +472,8 @@ static upb_strptr join(upb_strptr base, upb_strptr name) { return joined; } -static upb_strptr try_define(struct upb_strtable *t, upb_strptr base, - upb_strptr name, struct upb_status *status) +static upb_strptr try_define(upb_strtable *t, upb_strptr base, + upb_strptr name, upb_status *status) { if(upb_string_isnull(name)) { upb_seterr(status, UPB_STATUS_ERROR, @@ -498,26 +492,23 @@ static upb_strptr try_define(struct upb_strtable *t, upb_strptr base, return fqname; } -static void insert_enum(struct upb_strtable *t, +static void insert_enum(upb_strtable *t, google_protobuf_EnumDescriptorProto *ed, - upb_strptr base, - struct upb_status *status) + upb_strptr base, upb_status *status) { upb_strptr name = ed->set_flags.has.name ? ed->name : UPB_STRING_NULL; upb_strptr fqname = try_define(t, base, name, status); if(upb_string_isnull(fqname)) return; - struct symtab_ent e; + symtab_ent e; e.e.key = fqname; e.def = UPB_UPCAST(enumdef_new(ed, fqname)); upb_strtable_insert(t, &e.e); upb_string_unref(fqname); } -static void insert_message(struct upb_strtable *t, - google_protobuf_DescriptorProto *d, - upb_strptr base, bool sort, - struct upb_status *status) +static void insert_message(upb_strtable *t, google_protobuf_DescriptorProto *d, + upb_strptr base, bool sort, upb_status *status) { upb_strptr name = d->set_flags.has.name ? d->name : UPB_STRING_NULL; upb_strptr fqname = try_define(t, base, name, status); @@ -525,11 +516,11 @@ static void insert_message(struct upb_strtable *t, int num_fields = d->set_flags.has.field ? google_protobuf_FieldDescriptorProto_array_len(d->field) : 0; - struct symtab_ent e; + symtab_ent e; e.e.key = fqname; // Gather our list of fields, sorting if necessary. - struct upb_fielddef **fielddefs = malloc(sizeof(*fielddefs) * num_fields); + upb_fielddef **fielddefs = malloc(sizeof(*fielddefs) * num_fields); for (int i = 0; i < num_fields; i++) { google_protobuf_FieldDescriptorProto *fd = google_protobuf_FieldDescriptorProto_array_get(d->field, i); @@ -562,8 +553,7 @@ error: upb_string_unref(fqname); } -static bool find_cycles(struct upb_msgdef *m, int search_depth, - struct upb_status *status) +static bool find_cycles(upb_msgdef *m, int search_depth, upb_status *status) { if(search_depth > UPB_MAX_TYPE_DEPTH) { // There are many situations in upb where we recurse over the type tree @@ -592,10 +582,10 @@ static bool find_cycles(struct upb_msgdef *m, int search_depth, UPB_UPCAST(m)->search_depth = ++search_depth; bool cycle_found = false; for(upb_field_count_t i = 0; i < m->num_fields; i++) { - struct upb_fielddef *f = &m->fields[i]; + upb_fielddef *f = &m->fields[i]; if(!upb_issubmsg(f)) continue; - struct upb_def *sub_def = f->def; - struct upb_msgdef *sub_m = upb_downcast_msgdef(sub_def); + upb_def *sub_def = f->def; + upb_msgdef *sub_m = upb_downcast_msgdef(sub_def); if(find_cycles(sub_m, search_depth, status)) { cycle_found = true; UPB_UPCAST(m)->is_cyclic = true; @@ -610,9 +600,9 @@ static bool find_cycles(struct upb_msgdef *m, int search_depth, } } -static void addfd(struct upb_strtable *addto, struct upb_strtable *existingdefs, +static void addfd(upb_strtable *addto, upb_strtable *existingdefs, google_protobuf_FileDescriptorProto *fd, bool sort, - struct upb_status *status) + upb_status *status) { upb_strptr pkg; if(fd->set_flags.has.package) { @@ -639,16 +629,16 @@ static void addfd(struct upb_strtable *addto, struct upb_strtable *existingdefs, /* TODO: handle extensions and services. */ // Attempt to resolve all references. - struct symtab_ent *e; + symtab_ent *e; for(e = upb_strtable_begin(addto); e; e = upb_strtable_next(addto, &e->e)) { - struct upb_msgdef *m = upb_dyncast_msgdef(e->def); + upb_msgdef *m = upb_dyncast_msgdef(e->def); if(!m) continue; upb_strptr base = e->e.key; for(upb_field_count_t i = 0; i < m->num_fields; i++) { - struct upb_fielddef *f = &m->fields[i]; + upb_fielddef *f = &m->fields[i]; if(!upb_hasdef(f)) continue; // No resolving necessary. upb_strptr name = upb_downcast_unresolveddef(f->def)->name; - struct symtab_ent *found = resolve(existingdefs, base, name); + symtab_ent *found = resolve(existingdefs, base, name); if(!found) found = resolve(addto, base, name); upb_field_type_t expected = upb_issubmsg(f) ? UPB_DEF_MSG : UPB_DEF_ENUM; if(!found) { @@ -667,33 +657,33 @@ static void addfd(struct upb_strtable *addto, struct upb_strtable *existingdefs, // Deal with type cycles. for(e = upb_strtable_begin(addto); e; e = upb_strtable_next(addto, &e->e)) { - struct upb_msgdef *m = upb_dyncast_msgdef(e->def); + upb_msgdef *m = upb_dyncast_msgdef(e->def); if(!m) continue; // Do an initial pass over the graph to check that there are no cycles // longer than the maximum length. We also mark all cyclic defs as such, // and decrement refs on cyclic defs. find_cycles(m, 0, status); - struct upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN]; + upb_msgdef *open_defs[UPB_MAX_TYPE_CYCLE_LEN]; cycle_ref_or_unref(m, NULL, open_defs, 0, true); } } /* upb_symtab *****************************************************************/ -struct upb_symtab *upb_symtab_new() +upb_symtab *upb_symtab_new() { - struct upb_symtab *s = malloc(sizeof(*s)); + upb_symtab *s = malloc(sizeof(*s)); upb_atomic_refcount_init(&s->refcount, 1); upb_rwlock_init(&s->lock); - upb_strtable_init(&s->symtab, 16, sizeof(struct symtab_ent)); - upb_strtable_init(&s->psymtab, 16, sizeof(struct symtab_ent)); + upb_strtable_init(&s->symtab, 16, sizeof(symtab_ent)); + upb_strtable_init(&s->psymtab, 16, sizeof(symtab_ent)); // Add descriptor.proto types to private symtable so we can parse descriptors. // We know there is only 1. google_protobuf_FileDescriptorProto *fd = google_protobuf_FileDescriptorProto_array_get(upb_file_descriptor_set->file, 0); - struct upb_status status = UPB_STATUS_INIT; + upb_status status = UPB_STATUS_INIT; addfd(&s->psymtab, &s->symtab, fd, false, &status); if(!upb_ok(&status)) { fprintf(stderr, "Failed to initialize upb: %s.\n", status.msg); @@ -703,21 +693,21 @@ struct upb_symtab *upb_symtab_new() upb_static_string name = UPB_STATIC_STRING_INIT("google.protobuf.FileDescriptorSet"); upb_strptr nameptr = UPB_STATIC_STRING_PTR_INIT(name); - struct symtab_ent *e = upb_strtable_lookup(&s->psymtab, nameptr); + symtab_ent *e = upb_strtable_lookup(&s->psymtab, nameptr); assert(e); s->fds_msgdef = upb_downcast_msgdef(e->def); return s; } -static void free_symtab(struct upb_strtable *t) +static void free_symtab(upb_strtable *t) { - struct symtab_ent *e = upb_strtable_begin(t); - for(; e; e = upb_strtable_next(t, &e->e)) + symtab_ent *e; + for(e = upb_strtable_begin(t); e; e = upb_strtable_next(t, &e->e)) upb_def_unref(e->def); upb_strtable_free(t); } -void _upb_symtab_free(struct upb_symtab *s) +void _upb_symtab_free(upb_symtab *s) { free_symtab(&s->symtab); free_symtab(&s->psymtab); @@ -725,18 +715,17 @@ void _upb_symtab_free(struct upb_symtab *s) free(s); } -struct upb_def **upb_symtab_getdefs(struct upb_symtab *s, int *count, - upb_def_type_t type) +upb_def **upb_symtab_getdefs(upb_symtab *s, int *count, upb_def_type_t type) { upb_rwlock_rdlock(&s->lock); int total = upb_strtable_count(&s->symtab); // We may only use part of this, depending on how many symbols are of the // correct type. - struct upb_def **defs = malloc(sizeof(*defs) * total); - struct symtab_ent *e = upb_strtable_begin(&s->symtab); + upb_def **defs = malloc(sizeof(*defs) * total); + symtab_ent *e = upb_strtable_begin(&s->symtab); int i = 0; for(; e; e = upb_strtable_next(&s->symtab, &e->e)) { - struct upb_def *def = e->def; + upb_def *def = e->def; assert(def); if(type == UPB_DEF_ANY || def->type == type) defs[i++] = def; @@ -748,11 +737,11 @@ struct upb_def **upb_symtab_getdefs(struct upb_symtab *s, int *count, return defs; } -struct upb_def *upb_symtab_lookup(struct upb_symtab *s, upb_strptr sym) +upb_def *upb_symtab_lookup(upb_symtab *s, upb_strptr sym) { upb_rwlock_rdlock(&s->lock); - struct symtab_ent *e = upb_strtable_lookup(&s->symtab, sym); - struct upb_def *ret = NULL; + symtab_ent *e = upb_strtable_lookup(&s->symtab, sym); + upb_def *ret = NULL; if(e) { ret = e->def; upb_def_ref(ret); @@ -762,11 +751,10 @@ struct upb_def *upb_symtab_lookup(struct upb_symtab *s, upb_strptr sym) } -struct upb_def *upb_symtab_resolve(struct upb_symtab *s, upb_strptr base, - upb_strptr symbol) { +upb_def *upb_symtab_resolve(upb_symtab *s, upb_strptr base, upb_strptr symbol) { upb_rwlock_rdlock(&s->lock); - struct symtab_ent *e = resolve(&s->symtab, base, symbol); - struct upb_def *ret = NULL; + symtab_ent *e = resolve(&s->symtab, base, symbol); + upb_def *ret = NULL; if(e) { ret = e->def; upb_def_ref(ret); @@ -775,15 +763,14 @@ struct upb_def *upb_symtab_resolve(struct upb_symtab *s, upb_strptr base, return ret; } -void upb_symtab_addfds(struct upb_symtab *s, - google_protobuf_FileDescriptorSet *fds, - struct upb_status *status) +void upb_symtab_addfds(upb_symtab *s, google_protobuf_FileDescriptorSet *fds, + upb_status *status) { if(fds->set_flags.has.file) { // Insert new symbols into a temporary table until we have verified that // the descriptor is valid. - struct upb_strtable tmp; - upb_strtable_init(&tmp, 0, sizeof(struct symtab_ent)); + upb_strtable tmp; + upb_strtable_init(&tmp, 0, sizeof(symtab_ent)); { // Read lock scope upb_rwlock_rdlock(&s->lock); @@ -801,7 +788,7 @@ void upb_symtab_addfds(struct upb_symtab *s, // Everything was successfully added, copy from the tmp symtable. { // Write lock scope upb_rwlock_wrlock(&s->lock); - struct symtab_ent *e; + symtab_ent *e; for(e = upb_strtable_begin(&tmp); e; e = upb_strtable_next(&tmp, &e->e)) { // We checked for duplicates when we had only the read lock, but it is // theoretically possible that a duplicate symbol when we dropped the @@ -825,8 +812,7 @@ void upb_symtab_addfds(struct upb_symtab *s, return; } -void upb_symtab_add_desc(struct upb_symtab *s, upb_strptr desc, - struct upb_status *status) +void upb_symtab_add_desc(upb_symtab *s, upb_strptr desc, upb_status *status) { upb_msg *fds = upb_msg_new(s->fds_msgdef); upb_msg_decodestr(fds, s->fds_msgdef, desc, status); -- cgit v1.2.3