Joshua Haberman
8 years ago
committed by
GitHub
commit
9a9a1097a7
9 changed files with 664 additions and 695 deletions
@ -1,495 +0,0 @@ |
|||||||
|
|
||||||
#include "upb/structdefs.int.h" |
|
||||||
#include "upb/symtab.h" |
|
||||||
|
|
||||||
#include <string.h> |
|
||||||
|
|
||||||
static void upb_symtab_free(upb_refcounted *r) { |
|
||||||
upb_symtab *s = (upb_symtab*)r; |
|
||||||
upb_strtable_iter i; |
|
||||||
upb_strtable_begin(&i, &s->symtab); |
|
||||||
for (; !upb_strtable_done(&i); upb_strtable_next(&i)) { |
|
||||||
const upb_def *def = upb_value_getptr(upb_strtable_iter_value(&i)); |
|
||||||
upb_def_unref(def, s); |
|
||||||
} |
|
||||||
upb_strtable_uninit(&s->symtab); |
|
||||||
upb_gfree(s); |
|
||||||
} |
|
||||||
|
|
||||||
upb_symtab *upb_symtab_new(const void *owner) { |
|
||||||
static const struct upb_refcounted_vtbl vtbl = {NULL, &upb_symtab_free}; |
|
||||||
|
|
||||||
upb_symtab *s = upb_gmalloc(sizeof(*s)); |
|
||||||
if (!s) { |
|
||||||
return NULL; |
|
||||||
} |
|
||||||
|
|
||||||
upb_refcounted_init(upb_symtab_upcast_mutable(s), &vtbl, owner); |
|
||||||
upb_strtable_init(&s->symtab, UPB_CTYPE_PTR); |
|
||||||
return s; |
|
||||||
} |
|
||||||
|
|
||||||
void upb_symtab_freeze(upb_symtab *s) { |
|
||||||
upb_refcounted *r; |
|
||||||
bool ok; |
|
||||||
|
|
||||||
UPB_ASSERT(!upb_symtab_isfrozen(s)); |
|
||||||
r = upb_symtab_upcast_mutable(s); |
|
||||||
/* The symtab does not take ref2's (see refcounted.h) on the defs, because
|
|
||||||
* defs cannot refer back to the table and therefore cannot create cycles. So |
|
||||||
* 0 will suffice for maxdepth here. */ |
|
||||||
ok = upb_refcounted_freeze(&r, 1, NULL, 0); |
|
||||||
UPB_ASSERT(ok); |
|
||||||
} |
|
||||||
|
|
||||||
const upb_def *upb_symtab_lookup(const upb_symtab *s, const char *sym) { |
|
||||||
upb_value v; |
|
||||||
upb_def *ret = upb_strtable_lookup(&s->symtab, sym, &v) ? |
|
||||||
upb_value_getptr(v) : NULL; |
|
||||||
return ret; |
|
||||||
} |
|
||||||
|
|
||||||
const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym) { |
|
||||||
upb_value v; |
|
||||||
upb_def *def = upb_strtable_lookup(&s->symtab, sym, &v) ? |
|
||||||
upb_value_getptr(v) : NULL; |
|
||||||
return def ? upb_dyncast_msgdef(def) : NULL; |
|
||||||
} |
|
||||||
|
|
||||||
const upb_enumdef *upb_symtab_lookupenum(const upb_symtab *s, const char *sym) { |
|
||||||
upb_value v; |
|
||||||
upb_def *def = upb_strtable_lookup(&s->symtab, sym, &v) ? |
|
||||||
upb_value_getptr(v) : NULL; |
|
||||||
return def ? upb_dyncast_enumdef(def) : NULL; |
|
||||||
} |
|
||||||
|
|
||||||
/* Given a symbol and the base symbol inside which it is defined, find the
|
|
||||||
* symbol's definition in t. */ |
|
||||||
static upb_def *upb_resolvename(const upb_strtable *t, |
|
||||||
const char *base, const char *sym) { |
|
||||||
if(strlen(sym) == 0) return NULL; |
|
||||||
if(sym[0] == '.') { |
|
||||||
/* Symbols starting with '.' are absolute, so we do a single lookup.
|
|
||||||
* Slice to omit the leading '.' */ |
|
||||||
upb_value v; |
|
||||||
return upb_strtable_lookup(t, sym + 1, &v) ? upb_value_getptr(v) : NULL; |
|
||||||
} else { |
|
||||||
/* Remove components from base until we find an entry or run out.
|
|
||||||
* TODO: This branch is totally broken, but currently not used. */ |
|
||||||
(void)base; |
|
||||||
UPB_ASSERT(false); |
|
||||||
return NULL; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
const upb_def *upb_symtab_resolve(const upb_symtab *s, const char *base, |
|
||||||
const char *sym) { |
|
||||||
upb_def *ret = upb_resolvename(&s->symtab, base, sym); |
|
||||||
return ret; |
|
||||||
} |
|
||||||
|
|
||||||
/* Starts a depth-first traversal at "def", recursing into any subdefs
|
|
||||||
* (ie. submessage types). Adds duplicates of existing defs to addtab |
|
||||||
* wherever necessary, so that the resulting symtab will be consistent once |
|
||||||
* addtab is added. |
|
||||||
* |
|
||||||
* More specifically, if any def D is found in the DFS that: |
|
||||||
* |
|
||||||
* 1. can reach a def that is being replaced by something in addtab, AND |
|
||||||
* |
|
||||||
* 2. is not itself being replaced already (ie. this name doesn't already |
|
||||||
* exist in addtab) |
|
||||||
* |
|
||||||
* ...then a duplicate (new copy) of D will be added to addtab. |
|
||||||
* |
|
||||||
* Returns true if this happened for any def reachable from "def." |
|
||||||
* |
|
||||||
* It is slightly tricky to do this correctly in the presence of cycles. If we |
|
||||||
* detect that our DFS has hit a cycle, we might not yet know if any SCCs on |
|
||||||
* our stack can reach a def in addtab or not. Once we figure this out, that |
|
||||||
* answer needs to apply to *all* defs in these SCCs, even if we visited them |
|
||||||
* already. So a straight up one-pass cycle-detecting DFS won't work. |
|
||||||
* |
|
||||||
* To work around this problem, we traverse each SCC (which we already |
|
||||||
* computed, since these defs are frozen) as a single node. We first compute |
|
||||||
* whether the SCC as a whole can reach any def in addtab, then we dup (or not) |
|
||||||
* the entire SCC. This requires breaking the encapsulation of upb_refcounted, |
|
||||||
* since that is where we get the data about what SCC we are in. */ |
|
||||||
static bool upb_resolve_dfs(const upb_def *def, upb_strtable *addtab, |
|
||||||
const void *new_owner, upb_inttable *seen, |
|
||||||
upb_status *s) { |
|
||||||
upb_value v; |
|
||||||
bool need_dup; |
|
||||||
const upb_def *base; |
|
||||||
const void* memoize_key; |
|
||||||
|
|
||||||
/* Memoize results of this function for efficiency (since we're traversing a
|
|
||||||
* DAG this is not needed to limit the depth of the search). |
|
||||||
* |
|
||||||
* We memoize by SCC instead of by individual def. */ |
|
||||||
memoize_key = def->base.group; |
|
||||||
|
|
||||||
if (upb_inttable_lookupptr(seen, memoize_key, &v)) |
|
||||||
return upb_value_getbool(v); |
|
||||||
|
|
||||||
/* Visit submessages for all messages in the SCC. */ |
|
||||||
need_dup = false; |
|
||||||
base = def; |
|
||||||
do { |
|
||||||
upb_value v; |
|
||||||
const upb_msgdef *m; |
|
||||||
|
|
||||||
UPB_ASSERT(upb_def_isfrozen(def)); |
|
||||||
if (def->type == UPB_DEF_FIELD) continue; |
|
||||||
if (upb_strtable_lookup(addtab, upb_def_fullname(def), &v)) { |
|
||||||
need_dup = true; |
|
||||||
} |
|
||||||
|
|
||||||
/* For messages, continue the recursion by visiting all subdefs, but only
|
|
||||||
* ones in different SCCs. */ |
|
||||||
m = upb_dyncast_msgdef(def); |
|
||||||
if (m) { |
|
||||||
upb_msg_field_iter i; |
|
||||||
for(upb_msg_field_begin(&i, m); |
|
||||||
!upb_msg_field_done(&i); |
|
||||||
upb_msg_field_next(&i)) { |
|
||||||
upb_fielddef *f = upb_msg_iter_field(&i); |
|
||||||
const upb_def *subdef; |
|
||||||
|
|
||||||
if (!upb_fielddef_hassubdef(f)) continue; |
|
||||||
subdef = upb_fielddef_subdef(f); |
|
||||||
|
|
||||||
/* Skip subdefs in this SCC. */ |
|
||||||
if (def->base.group == subdef->base.group) continue; |
|
||||||
|
|
||||||
/* |= to avoid short-circuit; we need its side-effects. */ |
|
||||||
need_dup |= upb_resolve_dfs(subdef, addtab, new_owner, seen, s); |
|
||||||
if (!upb_ok(s)) return false; |
|
||||||
} |
|
||||||
} |
|
||||||
} while ((def = (upb_def*)def->base.next) != base); |
|
||||||
|
|
||||||
if (need_dup) { |
|
||||||
/* Dup all defs in this SCC that don't already have entries in addtab. */ |
|
||||||
def = base; |
|
||||||
do { |
|
||||||
const char *name; |
|
||||||
|
|
||||||
if (def->type == UPB_DEF_FIELD) continue; |
|
||||||
name = upb_def_fullname(def); |
|
||||||
if (!upb_strtable_lookup(addtab, name, NULL)) { |
|
||||||
upb_def *newdef = upb_def_dup(def, new_owner); |
|
||||||
if (!newdef) goto oom; |
|
||||||
newdef->came_from_user = false; |
|
||||||
if (!upb_strtable_insert(addtab, name, upb_value_ptr(newdef))) |
|
||||||
goto oom; |
|
||||||
} |
|
||||||
} while ((def = (upb_def*)def->base.next) != base); |
|
||||||
} |
|
||||||
|
|
||||||
upb_inttable_insertptr(seen, memoize_key, upb_value_bool(need_dup)); |
|
||||||
return need_dup; |
|
||||||
|
|
||||||
oom: |
|
||||||
upb_status_seterrmsg(s, "out of memory"); |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
/* TODO(haberman): we need a lot more testing of error conditions.
|
|
||||||
* The came_from_user stuff in particular is not tested. */ |
|
||||||
static bool symtab_add(upb_symtab *s, upb_def *const*defs, size_t n, |
|
||||||
void *ref_donor, upb_refcounted *freeze_also, |
|
||||||
upb_status *status) { |
|
||||||
size_t i; |
|
||||||
size_t add_n; |
|
||||||
size_t freeze_n; |
|
||||||
upb_strtable_iter iter; |
|
||||||
upb_refcounted **add_objs = NULL; |
|
||||||
upb_def **add_defs = NULL; |
|
||||||
size_t add_objs_size; |
|
||||||
upb_strtable addtab; |
|
||||||
upb_inttable seen; |
|
||||||
|
|
||||||
if (n == 0 && !freeze_also) { |
|
||||||
return true; |
|
||||||
} |
|
||||||
|
|
||||||
UPB_ASSERT(!upb_symtab_isfrozen(s)); |
|
||||||
if (!upb_strtable_init(&addtab, UPB_CTYPE_PTR)) { |
|
||||||
upb_status_seterrmsg(status, "out of memory"); |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
/* Add new defs to our "add" set. */ |
|
||||||
for (i = 0; i < n; i++) { |
|
||||||
upb_def *def = defs[i]; |
|
||||||
const char *fullname; |
|
||||||
upb_fielddef *f; |
|
||||||
|
|
||||||
if (upb_def_isfrozen(def)) { |
|
||||||
upb_status_seterrmsg(status, "added defs must be mutable"); |
|
||||||
goto err; |
|
||||||
} |
|
||||||
UPB_ASSERT(!upb_def_isfrozen(def)); |
|
||||||
fullname = upb_def_fullname(def); |
|
||||||
if (!fullname) { |
|
||||||
upb_status_seterrmsg( |
|
||||||
status, "Anonymous defs cannot be added to a symtab"); |
|
||||||
goto err; |
|
||||||
} |
|
||||||
|
|
||||||
f = upb_dyncast_fielddef_mutable(def); |
|
||||||
|
|
||||||
if (f) { |
|
||||||
if (!upb_fielddef_containingtypename(f)) { |
|
||||||
upb_status_seterrmsg(status, |
|
||||||
"Standalone fielddefs must have a containing type " |
|
||||||
"(extendee) name set"); |
|
||||||
goto err; |
|
||||||
} |
|
||||||
} else { |
|
||||||
if (upb_strtable_lookup(&addtab, fullname, NULL)) { |
|
||||||
upb_status_seterrf(status, "Conflicting defs named '%s'", fullname); |
|
||||||
goto err; |
|
||||||
} |
|
||||||
/* We need this to back out properly, because if there is a failure we
|
|
||||||
* need to donate the ref back to the caller. */ |
|
||||||
def->came_from_user = true; |
|
||||||
upb_def_donateref(def, ref_donor, s); |
|
||||||
if (!upb_strtable_insert(&addtab, fullname, upb_value_ptr(def))) |
|
||||||
goto oom_err; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/* Add standalone fielddefs (ie. extensions) to the appropriate messages.
|
|
||||||
* If the appropriate message only exists in the existing symtab, duplicate |
|
||||||
* it so we have a mutable copy we can add the fields to. */ |
|
||||||
for (i = 0; i < n; i++) { |
|
||||||
upb_def *def = defs[i]; |
|
||||||
upb_fielddef *f = upb_dyncast_fielddef_mutable(def); |
|
||||||
const char *msgname; |
|
||||||
upb_value v; |
|
||||||
upb_msgdef *m; |
|
||||||
|
|
||||||
if (!f) continue; |
|
||||||
msgname = upb_fielddef_containingtypename(f); |
|
||||||
/* We validated this earlier in this function. */ |
|
||||||
UPB_ASSERT(msgname); |
|
||||||
|
|
||||||
/* If the extendee name is absolutely qualified, move past the initial ".".
|
|
||||||
* TODO(haberman): it is not obvious what it would mean if this was not |
|
||||||
* absolutely qualified. */ |
|
||||||
if (msgname[0] == '.') { |
|
||||||
msgname++; |
|
||||||
} |
|
||||||
|
|
||||||
if (upb_strtable_lookup(&addtab, msgname, &v)) { |
|
||||||
/* Extendee is in the set of defs the user asked us to add. */ |
|
||||||
m = upb_value_getptr(v); |
|
||||||
} else { |
|
||||||
/* Need to find and dup the extendee from the existing symtab. */ |
|
||||||
const upb_msgdef *frozen_m = upb_symtab_lookupmsg(s, msgname); |
|
||||||
if (!frozen_m) { |
|
||||||
upb_status_seterrf(status, |
|
||||||
"Tried to extend message %s that does not exist " |
|
||||||
"in this SymbolTable.", |
|
||||||
msgname); |
|
||||||
goto err; |
|
||||||
} |
|
||||||
m = upb_msgdef_dup(frozen_m, s); |
|
||||||
if (!m) goto oom_err; |
|
||||||
if (!upb_strtable_insert(&addtab, msgname, upb_value_ptr(m))) { |
|
||||||
upb_msgdef_unref(m, s); |
|
||||||
goto oom_err; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if (!upb_msgdef_addfield(m, f, ref_donor, status)) { |
|
||||||
goto err; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/* Add dups of any existing def that can reach a def with the same name as
|
|
||||||
* anything in our "add" set. */ |
|
||||||
if (!upb_inttable_init(&seen, UPB_CTYPE_BOOL)) goto oom_err; |
|
||||||
upb_strtable_begin(&iter, &s->symtab); |
|
||||||
for (; !upb_strtable_done(&iter); upb_strtable_next(&iter)) { |
|
||||||
upb_def *def = upb_value_getptr(upb_strtable_iter_value(&iter)); |
|
||||||
upb_resolve_dfs(def, &addtab, s, &seen, status); |
|
||||||
if (!upb_ok(status)) goto err; |
|
||||||
} |
|
||||||
upb_inttable_uninit(&seen); |
|
||||||
|
|
||||||
/* Now using the table, resolve symbolic references for subdefs. */ |
|
||||||
upb_strtable_begin(&iter, &addtab); |
|
||||||
for (; !upb_strtable_done(&iter); upb_strtable_next(&iter)) { |
|
||||||
const char *base; |
|
||||||
upb_def *def = upb_value_getptr(upb_strtable_iter_value(&iter)); |
|
||||||
upb_msgdef *m = upb_dyncast_msgdef_mutable(def); |
|
||||||
upb_msg_field_iter j; |
|
||||||
|
|
||||||
if (!m) continue; |
|
||||||
/* Type names are resolved relative to the message in which they appear. */ |
|
||||||
base = upb_msgdef_fullname(m); |
|
||||||
|
|
||||||
for(upb_msg_field_begin(&j, m); |
|
||||||
!upb_msg_field_done(&j); |
|
||||||
upb_msg_field_next(&j)) { |
|
||||||
upb_fielddef *f = upb_msg_iter_field(&j); |
|
||||||
const char *name = upb_fielddef_subdefname(f); |
|
||||||
if (name && !upb_fielddef_subdef(f)) { |
|
||||||
/* Try the lookup in the current set of to-be-added defs first. If not
|
|
||||||
* there, try existing defs. */ |
|
||||||
upb_def *subdef = upb_resolvename(&addtab, base, name); |
|
||||||
if (subdef == NULL) { |
|
||||||
subdef = upb_resolvename(&s->symtab, base, name); |
|
||||||
} |
|
||||||
if (subdef == NULL) { |
|
||||||
upb_status_seterrf( |
|
||||||
status, "couldn't resolve name '%s' in message '%s'", name, base); |
|
||||||
goto err; |
|
||||||
} else if (!upb_fielddef_setsubdef(f, subdef, status)) { |
|
||||||
goto err; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/* We need an array of the defs in addtab, for passing to
|
|
||||||
* upb_refcounted_freeze(). */ |
|
||||||
add_objs_size = upb_strtable_count(&addtab); |
|
||||||
if (freeze_also) { |
|
||||||
add_objs_size++; |
|
||||||
} |
|
||||||
|
|
||||||
add_defs = upb_gmalloc(sizeof(void*) * add_objs_size); |
|
||||||
if (add_defs == NULL) goto oom_err; |
|
||||||
upb_strtable_begin(&iter, &addtab); |
|
||||||
for (add_n = 0; !upb_strtable_done(&iter); upb_strtable_next(&iter)) { |
|
||||||
add_defs[add_n++] = upb_value_getptr(upb_strtable_iter_value(&iter)); |
|
||||||
} |
|
||||||
|
|
||||||
/* Validate defs. */ |
|
||||||
if (!_upb_def_validate(add_defs, add_n, status)) { |
|
||||||
goto err; |
|
||||||
} |
|
||||||
|
|
||||||
/* Cheat a little and give the array a new type.
|
|
||||||
* This is probably undefined behavior, but this code will be deleted soon. */ |
|
||||||
add_objs = (upb_refcounted**)add_defs; |
|
||||||
|
|
||||||
freeze_n = add_n; |
|
||||||
if (freeze_also) { |
|
||||||
add_objs[freeze_n++] = freeze_also; |
|
||||||
} |
|
||||||
|
|
||||||
if (!upb_refcounted_freeze(add_objs, freeze_n, status, |
|
||||||
UPB_MAX_MESSAGE_DEPTH * 2)) { |
|
||||||
goto err; |
|
||||||
} |
|
||||||
|
|
||||||
/* This must be delayed until all errors have been detected, since error
|
|
||||||
* recovery code uses this table to cleanup defs. */ |
|
||||||
upb_strtable_uninit(&addtab); |
|
||||||
|
|
||||||
/* TODO(haberman) we don't properly handle errors after this point (like
|
|
||||||
* OOM in upb_strtable_insert() below). */ |
|
||||||
for (i = 0; i < add_n; i++) { |
|
||||||
upb_def *def = (upb_def*)add_objs[i]; |
|
||||||
const char *name = upb_def_fullname(def); |
|
||||||
upb_value v; |
|
||||||
bool success; |
|
||||||
|
|
||||||
if (upb_strtable_remove(&s->symtab, name, &v)) { |
|
||||||
const upb_def *def = upb_value_getptr(v); |
|
||||||
upb_def_unref(def, s); |
|
||||||
} |
|
||||||
success = upb_strtable_insert(&s->symtab, name, upb_value_ptr(def)); |
|
||||||
UPB_ASSERT(success == true); |
|
||||||
} |
|
||||||
upb_gfree(add_defs); |
|
||||||
return true; |
|
||||||
|
|
||||||
oom_err: |
|
||||||
upb_status_seterrmsg(status, "out of memory"); |
|
||||||
err: { |
|
||||||
/* For defs the user passed in, we need to donate the refs back. For defs
|
|
||||||
* we dup'd, we need to just unref them. */ |
|
||||||
upb_strtable_begin(&iter, &addtab); |
|
||||||
for (; !upb_strtable_done(&iter); upb_strtable_next(&iter)) { |
|
||||||
upb_def *def = upb_value_getptr(upb_strtable_iter_value(&iter)); |
|
||||||
bool came_from_user = def->came_from_user; |
|
||||||
def->came_from_user = false; |
|
||||||
if (came_from_user) { |
|
||||||
upb_def_donateref(def, s, ref_donor); |
|
||||||
} else { |
|
||||||
upb_def_unref(def, s); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
upb_strtable_uninit(&addtab); |
|
||||||
upb_gfree(add_defs); |
|
||||||
UPB_ASSERT(!upb_ok(status)); |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
bool upb_symtab_add(upb_symtab *s, upb_def *const*defs, size_t n, |
|
||||||
void *ref_donor, upb_status *status) { |
|
||||||
return symtab_add(s, defs, n, ref_donor, NULL, status); |
|
||||||
} |
|
||||||
|
|
||||||
bool upb_symtab_addfile(upb_symtab *s, upb_filedef *file, upb_status *status) { |
|
||||||
size_t n; |
|
||||||
size_t i; |
|
||||||
upb_def **defs; |
|
||||||
bool ret; |
|
||||||
|
|
||||||
n = upb_filedef_defcount(file); |
|
||||||
defs = upb_gmalloc(sizeof(*defs) * n); |
|
||||||
|
|
||||||
if (defs == NULL) { |
|
||||||
upb_status_seterrmsg(status, "Out of memory"); |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
for (i = 0; i < n; i++) { |
|
||||||
defs[i] = upb_filedef_mutabledef(file, i); |
|
||||||
} |
|
||||||
|
|
||||||
ret = symtab_add(s, defs, n, NULL, upb_filedef_upcast_mutable(file), status); |
|
||||||
|
|
||||||
upb_gfree(defs); |
|
||||||
return ret; |
|
||||||
} |
|
||||||
|
|
||||||
/* Iteration. */ |
|
||||||
|
|
||||||
static void advance_to_matching(upb_symtab_iter *iter) { |
|
||||||
if (iter->type == UPB_DEF_ANY) |
|
||||||
return; |
|
||||||
|
|
||||||
while (!upb_strtable_done(&iter->iter) && |
|
||||||
iter->type != upb_symtab_iter_def(iter)->type) { |
|
||||||
upb_strtable_next(&iter->iter); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
void upb_symtab_begin(upb_symtab_iter *iter, const upb_symtab *s, |
|
||||||
upb_deftype_t type) { |
|
||||||
upb_strtable_begin(&iter->iter, &s->symtab); |
|
||||||
iter->type = type; |
|
||||||
advance_to_matching(iter); |
|
||||||
} |
|
||||||
|
|
||||||
void upb_symtab_next(upb_symtab_iter *iter) { |
|
||||||
upb_strtable_next(&iter->iter); |
|
||||||
advance_to_matching(iter); |
|
||||||
} |
|
||||||
|
|
||||||
bool upb_symtab_done(const upb_symtab_iter *iter) { |
|
||||||
return upb_strtable_done(&iter->iter); |
|
||||||
} |
|
||||||
|
|
||||||
const upb_def *upb_symtab_iter_def(const upb_symtab_iter *iter) { |
|
||||||
return upb_value_getptr(upb_strtable_iter_value(&iter->iter)); |
|
||||||
} |
|
||||||
@ -1,195 +0,0 @@ |
|||||||
/*
|
|
||||||
** upb::SymbolTable (upb_symtab) |
|
||||||
** |
|
||||||
** A symtab (symbol table) stores a name->def map of upb_defs. Clients could |
|
||||||
** always create such tables themselves, but upb_symtab has logic for resolving |
|
||||||
** symbolic references, and in particular, for keeping a whole set of consistent |
|
||||||
** defs when replacing some subset of those defs. This logic is nontrivial. |
|
||||||
** |
|
||||||
** This is a mixed C/C++ interface that offers a full API to both languages. |
|
||||||
** See the top-level README for more information. |
|
||||||
*/ |
|
||||||
|
|
||||||
#ifndef UPB_SYMTAB_H_ |
|
||||||
#define UPB_SYMTAB_H_ |
|
||||||
|
|
||||||
#include "upb/def.h" |
|
||||||
|
|
||||||
#ifdef __cplusplus |
|
||||||
#include <vector> |
|
||||||
namespace upb { class SymbolTable; } |
|
||||||
#endif |
|
||||||
|
|
||||||
UPB_DECLARE_DERIVED_TYPE(upb::SymbolTable, upb::RefCounted, |
|
||||||
upb_symtab, upb_refcounted) |
|
||||||
|
|
||||||
typedef struct { |
|
||||||
UPB_PRIVATE_FOR_CPP |
|
||||||
upb_strtable_iter iter; |
|
||||||
upb_deftype_t type; |
|
||||||
} upb_symtab_iter; |
|
||||||
|
|
||||||
#ifdef __cplusplus |
|
||||||
|
|
||||||
/* Non-const methods in upb::SymbolTable are NOT thread-safe. */ |
|
||||||
class upb::SymbolTable { |
|
||||||
public: |
|
||||||
/* Returns a new symbol table with a single ref owned by "owner."
|
|
||||||
* Returns NULL if memory allocation failed. */ |
|
||||||
static reffed_ptr<SymbolTable> New(); |
|
||||||
|
|
||||||
/* Include RefCounted base methods. */ |
|
||||||
UPB_REFCOUNTED_CPPMETHODS |
|
||||||
|
|
||||||
/* For all lookup functions, the returned pointer is not owned by the
|
|
||||||
* caller; it may be invalidated by any non-const call or unref of the |
|
||||||
* SymbolTable! To protect against this, take a ref if desired. */ |
|
||||||
|
|
||||||
/* Freezes the symbol table: prevents further modification of it.
|
|
||||||
* After the Freeze() operation is successful, the SymbolTable must only be |
|
||||||
* accessed via a const pointer. |
|
||||||
* |
|
||||||
* Unlike with upb::MessageDef/upb::EnumDef/etc, freezing a SymbolTable is not |
|
||||||
* a necessary step in using a SymbolTable. If you have no need for it to be |
|
||||||
* immutable, there is no need to freeze it ever. However sometimes it is |
|
||||||
* useful, and SymbolTables that are statically compiled into the binary are |
|
||||||
* always frozen by nature. */ |
|
||||||
void Freeze(); |
|
||||||
|
|
||||||
/* Resolves the given symbol using the rules described in descriptor.proto,
|
|
||||||
* namely: |
|
||||||
* |
|
||||||
* If the name starts with a '.', it is fully-qualified. Otherwise, |
|
||||||
* C++-like scoping rules are used to find the type (i.e. first the nested |
|
||||||
* types within this message are searched, then within the parent, on up |
|
||||||
* to the root namespace). |
|
||||||
* |
|
||||||
* If not found, returns NULL. */ |
|
||||||
const Def* Resolve(const char* base, const char* sym) const; |
|
||||||
|
|
||||||
/* Finds an entry in the symbol table with this exact name. If not found,
|
|
||||||
* returns NULL. */ |
|
||||||
const Def* Lookup(const char *sym) const; |
|
||||||
const MessageDef* LookupMessage(const char *sym) const; |
|
||||||
const EnumDef* LookupEnum(const char *sym) const; |
|
||||||
|
|
||||||
/* TODO: introduce a C++ iterator, but make it nice and templated so that if
|
|
||||||
* you ask for an iterator of MessageDef the iterated elements are strongly |
|
||||||
* typed as MessageDef*. */ |
|
||||||
|
|
||||||
/* Adds the given mutable defs to the symtab, resolving all symbols
|
|
||||||
* (including enum default values) and finalizing the defs. Only one def per |
|
||||||
* name may be in the list, but defs can replace existing defs in the symtab. |
|
||||||
* All defs must have a name -- anonymous defs are not allowed. Anonymous |
|
||||||
* defs can still be frozen by calling upb_def_freeze() directly. |
|
||||||
* |
|
||||||
* Any existing defs that can reach defs that are being replaced will |
|
||||||
* themselves be replaced also, so that the resulting set of defs is fully |
|
||||||
* consistent. |
|
||||||
* |
|
||||||
* This logic implemented in this method is a convenience; ultimately it |
|
||||||
* calls some combination of upb_fielddef_setsubdef(), upb_def_dup(), and |
|
||||||
* upb_freeze(), any of which the client could call themself. However, since |
|
||||||
* the logic for doing so is nontrivial, we provide it here. |
|
||||||
* |
|
||||||
* The entire operation either succeeds or fails. If the operation fails, |
|
||||||
* the symtab is unchanged, false is returned, and status indicates the |
|
||||||
* error. The caller passes a ref on all defs to the symtab (even if the |
|
||||||
* operation fails). |
|
||||||
* |
|
||||||
* TODO(haberman): currently failure will leave the symtab unchanged, but may |
|
||||||
* leave the defs themselves partially resolved. Does this matter? If so we |
|
||||||
* could do a prepass that ensures that all symbols are resolvable and bail |
|
||||||
* if not, so we don't mutate anything until we know the operation will |
|
||||||
* succeed. |
|
||||||
* |
|
||||||
* TODO(haberman): since the defs must be mutable, refining a frozen def |
|
||||||
* requires making mutable copies of the entire tree. This is wasteful if |
|
||||||
* only a few messages are changing. We may want to add a way of adding a |
|
||||||
* tree of frozen defs to the symtab (perhaps an alternate constructor where |
|
||||||
* you pass the root of the tree?) */ |
|
||||||
bool Add(Def*const* defs, size_t n, void* ref_donor, Status* status); |
|
||||||
|
|
||||||
bool Add(const std::vector<Def*>& defs, void *owner, Status* status) { |
|
||||||
return Add((Def*const*)&defs[0], defs.size(), owner, status); |
|
||||||
} |
|
||||||
|
|
||||||
/* Resolves all subdefs for messages in this file and attempts to freeze the
|
|
||||||
* file. If this succeeds, adds all the symbols to this SymbolTable |
|
||||||
* (replacing any existing ones with the same names). */ |
|
||||||
bool AddFile(FileDef* file, Status* s); |
|
||||||
|
|
||||||
private: |
|
||||||
UPB_DISALLOW_POD_OPS(SymbolTable, upb::SymbolTable) |
|
||||||
}; |
|
||||||
|
|
||||||
#endif /* __cplusplus */ |
|
||||||
|
|
||||||
UPB_BEGIN_EXTERN_C |
|
||||||
|
|
||||||
/* Native C API. */ |
|
||||||
|
|
||||||
/* Include refcounted methods like upb_symtab_ref(). */ |
|
||||||
UPB_REFCOUNTED_CMETHODS(upb_symtab, upb_symtab_upcast) |
|
||||||
|
|
||||||
upb_symtab *upb_symtab_new(const void *owner); |
|
||||||
void upb_symtab_freeze(upb_symtab *s); |
|
||||||
const upb_def *upb_symtab_resolve(const upb_symtab *s, const char *base, |
|
||||||
const char *sym); |
|
||||||
const upb_def *upb_symtab_lookup(const upb_symtab *s, const char *sym); |
|
||||||
const upb_msgdef *upb_symtab_lookupmsg(const upb_symtab *s, const char *sym); |
|
||||||
const upb_enumdef *upb_symtab_lookupenum(const upb_symtab *s, const char *sym); |
|
||||||
bool upb_symtab_add(upb_symtab *s, upb_def *const*defs, size_t n, |
|
||||||
void *ref_donor, upb_status *status); |
|
||||||
bool upb_symtab_addfile(upb_symtab *s, upb_filedef *file, upb_status* status); |
|
||||||
|
|
||||||
/* upb_symtab_iter i;
|
|
||||||
* for(upb_symtab_begin(&i, s, type); !upb_symtab_done(&i); |
|
||||||
* upb_symtab_next(&i)) { |
|
||||||
* const upb_def *def = upb_symtab_iter_def(&i); |
|
||||||
* // ...
|
|
||||||
* } |
|
||||||
* |
|
||||||
* For C we don't have separate iterators for const and non-const. |
|
||||||
* It is the caller's responsibility to cast the upb_fielddef* to |
|
||||||
* const if the upb_msgdef* is const. */ |
|
||||||
void upb_symtab_begin(upb_symtab_iter *iter, const upb_symtab *s, |
|
||||||
upb_deftype_t type); |
|
||||||
void upb_symtab_next(upb_symtab_iter *iter); |
|
||||||
bool upb_symtab_done(const upb_symtab_iter *iter); |
|
||||||
const upb_def *upb_symtab_iter_def(const upb_symtab_iter *iter); |
|
||||||
|
|
||||||
UPB_END_EXTERN_C |
|
||||||
|
|
||||||
#ifdef __cplusplus |
|
||||||
/* C++ inline wrappers. */ |
|
||||||
namespace upb { |
|
||||||
inline reffed_ptr<SymbolTable> SymbolTable::New() { |
|
||||||
upb_symtab *s = upb_symtab_new(&s); |
|
||||||
return reffed_ptr<SymbolTable>(s, &s); |
|
||||||
} |
|
||||||
|
|
||||||
inline void SymbolTable::Freeze() { |
|
||||||
return upb_symtab_freeze(this); |
|
||||||
} |
|
||||||
inline const Def *SymbolTable::Resolve(const char *base, |
|
||||||
const char *sym) const { |
|
||||||
return upb_symtab_resolve(this, base, sym); |
|
||||||
} |
|
||||||
inline const Def* SymbolTable::Lookup(const char *sym) const { |
|
||||||
return upb_symtab_lookup(this, sym); |
|
||||||
} |
|
||||||
inline const MessageDef *SymbolTable::LookupMessage(const char *sym) const { |
|
||||||
return upb_symtab_lookupmsg(this, sym); |
|
||||||
} |
|
||||||
inline bool SymbolTable::Add( |
|
||||||
Def*const* defs, size_t n, void* ref_donor, Status* status) { |
|
||||||
return upb_symtab_add(this, (upb_def*const*)defs, n, ref_donor, status); |
|
||||||
} |
|
||||||
inline bool SymbolTable::AddFile(FileDef* file, Status* s) { |
|
||||||
return upb_symtab_addfile(this, file, s); |
|
||||||
} |
|
||||||
} /* namespace upb */ |
|
||||||
#endif |
|
||||||
|
|
||||||
#endif /* UPB_SYMTAB_H_ */ |
|
||||||
Loading…
Reference in new issue