From 621c0cdcb5efc4f7c2382031becded018ef0b62b Mon Sep 17 00:00:00 2001 From: Joshua Haberman Date: Sun, 4 Sep 2011 19:29:36 -0700 Subject: Const invasion: large parts of upb made const-correct. --- upb/def.c | 71 ++++++++++++++++++++++++++++++++++++++------------------------- 1 file changed, 43 insertions(+), 28 deletions(-) (limited to 'upb/def.c') diff --git a/upb/def.c b/upb/def.c index ee793a9..555d763 100644 --- a/upb/def.c +++ b/upb/def.c @@ -38,7 +38,7 @@ static void upb_msgdef_free(upb_msgdef *m); static void upb_enumdef_free(upb_enumdef *e); static void upb_unresolveddef_free(struct _upb_unresolveddef *u); -bool upb_def_ismutable(upb_def *def) { return def->symtab == NULL; } +bool upb_def_ismutable(const upb_def *def) { return def->symtab == NULL; } bool upb_def_setfqname(upb_def *def, const char *fqname) { assert(upb_def_ismutable(def)); @@ -58,10 +58,12 @@ static void upb_def_free(upb_def *def) { } } -upb_def *upb_def_dup(upb_def *def) { +upb_def *upb_def_dup(const upb_def *def) { switch (def->type) { - case UPB_DEF_MSG: return UPB_UPCAST(upb_msgdef_dup(upb_downcast_msgdef(def))); - case UPB_DEF_ENUM: return UPB_UPCAST(upb_enumdef_dup(upb_downcast_enumdef(def))); + case UPB_DEF_MSG: + return UPB_UPCAST(upb_msgdef_dup(upb_downcast_msgdef_const(def))); + case UPB_DEF_ENUM: + return UPB_UPCAST(upb_enumdef_dup(upb_downcast_enumdef_const(def))); default: assert(false); return NULL; } } @@ -70,7 +72,8 @@ upb_def *upb_def_dup(upb_def *def) { // def itself. If the refcount falls to zero, the def is deleted. Once the // def belongs to a symtab, the def is owned by the symtab and its refcount // determines whether the def owns a ref on the symtab or not. -void upb_def_ref(upb_def *def) { +void upb_def_ref(const upb_def *_def) { + upb_def *def = (upb_def*)_def; // Need to modify refcount. if (upb_atomic_ref(&def->refcount) && def->symtab) upb_symtab_ref(def->symtab); } @@ -83,7 +86,8 @@ static void upb_def_movetosymtab(upb_def *d, upb_symtab *s) { if (m) upb_inttable_compact(&m->itof); } -void upb_def_unref(upb_def *def) { +void upb_def_unref(const upb_def *_def) { + upb_def *def = (upb_def*)_def; // Need to modify refcount. if (!def) return; if (upb_atomic_unref(&def->refcount)) { if (def->symtab) { @@ -152,7 +156,7 @@ static void upb_enumdef_free(upb_enumdef *e) { free(e); } -upb_enumdef *upb_enumdef_dup(upb_enumdef *e) { +upb_enumdef *upb_enumdef_dup(const upb_enumdef *e) { upb_enumdef *new_e = upb_enumdef_new(); upb_enum_iter i; for(i = upb_enum_begin(e); !upb_enum_done(i); i = upb_enum_next(e, i)) { @@ -176,12 +180,12 @@ void upb_enumdef_setdefault(upb_enumdef *e, int32_t val) { e->defaultval = val; } -upb_enum_iter upb_enum_begin(upb_enumdef *e) { +upb_enum_iter upb_enum_begin(const upb_enumdef *e) { // We could iterate over either table here; the choice is arbitrary. return upb_inttable_begin(&e->iton); } -upb_enum_iter upb_enum_next(upb_enumdef *e, upb_enum_iter iter) { +upb_enum_iter upb_enum_next(const upb_enumdef *e, upb_enum_iter iter) { return upb_inttable_next(&e->iton, iter); } @@ -267,11 +271,11 @@ upb_fielddef *upb_fielddef_dup(upb_fielddef *f) { return f; } -bool upb_fielddef_ismutable(upb_fielddef *f) { +bool upb_fielddef_ismutable(const upb_fielddef *f) { return !f->msgdef || upb_def_ismutable(UPB_UPCAST(f->msgdef)); } -upb_def *upb_fielddef_subdef(upb_fielddef *f) { +upb_def *upb_fielddef_subdef(const upb_fielddef *f) { if (upb_hassubdef(f) && !upb_fielddef_ismutable(f)) return f->def; else @@ -403,7 +407,7 @@ static void upb_msgdef_free(upb_msgdef *m) { free(m); } -upb_msgdef *upb_msgdef_dup(upb_msgdef *m) { +upb_msgdef *upb_msgdef_dup(const upb_msgdef *m) { upb_msgdef *newm = upb_msgdef_new(); newm->size = m->size; newm->hasbit_bytes = m->hasbit_bytes; @@ -512,31 +516,24 @@ void upb_msgdef_layout(upb_msgdef *m) { free(sorted_fields); } -upb_msg_iter upb_msg_begin(upb_msgdef *m) { +upb_msg_iter upb_msg_begin(const upb_msgdef *m) { return upb_inttable_begin(&m->itof); } -upb_msg_iter upb_msg_next(upb_msgdef *m, upb_msg_iter iter) { +upb_msg_iter upb_msg_next(const upb_msgdef *m, upb_msg_iter iter) { return upb_inttable_next(&m->itof, iter); } /* upb_symtab *****************************************************************/ -struct _upb_symtab { - upb_atomic_t refcount; - upb_rwlock_t lock; // Protects all members except the refcount. - upb_strtable symtab; // The symbol table. - upb_deflist olddefs; -}; - typedef struct { upb_def *def; } upb_symtab_ent; // Given a symbol and the base symbol inside which it is defined, find the // symbol's definition in t. -static upb_symtab_ent *upb_resolve(upb_strtable *t, +static upb_symtab_ent *upb_resolve(const upb_strtable *t, const char *base, const char *sym) { if(strlen(sym) == 0) return NULL; if(sym[0] == UPB_SYMBOL_SEPARATOR) { @@ -575,9 +572,13 @@ static void upb_symtab_free(upb_symtab *s) { free(s); } -void upb_symtab_ref(upb_symtab *s) { upb_atomic_ref(&s->refcount); } +void upb_symtab_ref(const upb_symtab *_s) { + upb_symtab *s = (upb_symtab*)_s; + upb_atomic_ref(&s->refcount); +} -void upb_symtab_unref(upb_symtab *s) { +void upb_symtab_unref(const upb_symtab *_s) { + upb_symtab *s = (upb_symtab*)_s; if(s && upb_atomic_unref(&s->refcount)) { upb_symtab_free(s); } @@ -592,12 +593,13 @@ upb_symtab *upb_symtab_new() { return s; } -upb_def **upb_symtab_getdefs(upb_symtab *s, int *count, upb_deftype_t type) { +const upb_def **upb_symtab_getdefs(const upb_symtab *s, int *count, + upb_deftype_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. - upb_def **defs = malloc(sizeof(*defs) * total); + const upb_def **defs = malloc(sizeof(*defs) * total); upb_strtable_iter iter; upb_strtable_begin(&iter, &s->symtab); int i = 0; @@ -614,7 +616,7 @@ upb_def **upb_symtab_getdefs(upb_symtab *s, int *count, upb_deftype_t type) { return defs; } -upb_def *upb_symtab_lookup(upb_symtab *s, const char *sym) { +const upb_def *upb_symtab_lookup(const upb_symtab *s, const char *sym) { upb_rwlock_rdlock(&s->lock); upb_symtab_ent *e = upb_strtable_lookup(&s->symtab, sym); upb_def *ret = NULL; @@ -626,7 +628,20 @@ upb_def *upb_symtab_lookup(upb_symtab *s, const char *sym) { return ret; } -upb_def *upb_symtab_resolve(upb_symtab *s, const char *base, const char *sym) { +const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym) { + upb_rwlock_rdlock(&s->lock); + upb_symtab_ent *e = upb_strtable_lookup(&s->symtab, sym); + upb_msgdef *ret = NULL; + if(e && e->def->type == UPB_DEF_MSG) { + ret = upb_downcast_msgdef(e->def); + upb_def_ref(UPB_UPCAST(ret)); + } + upb_rwlock_unlock(&s->lock); + return ret; +} + +const upb_def *upb_symtab_resolve(const upb_symtab *s, const char *base, + const char *sym) { upb_rwlock_rdlock(&s->lock); upb_symtab_ent *e = upb_resolve(&s->symtab, base, sym); upb_def *ret = NULL; -- cgit v1.2.3