void upb_symtab_freeze(upb_symtab *s) {
upb_refcounted *r;
bool ok;
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_VAR(ok, ok);
}
bool upb_def_freeze(upb_def *const* defs, int n, upb_status *s) {
// First perform validation, in two passes so we can check that we have a
// transitive closure without needing to search.
for (int i = 0; i < n; i++) {
upb_def *def = defs[i];
if (upb_def_isfrozen(def)) {
// Could relax this requirement if it's annoying.
upb_status_seterrliteral(s, "def is already frozen");
goto err;
} else if (def->type == UPB_DEF_FIELD) {
upb_status_seterrliteral(s, "standalone fielddefs can not be frozen");
goto err;
} else {
// Set now to detect transitive closure in the second pass.
def->came_from_user = true;
}
}
for (int i = 0; i < n; i++) {
upb_msgdef *m = upb_dyncast_msgdef_mutable(defs[i]);
upb_enumdef *e = upb_dyncast_enumdef_mutable(defs[i]);
if (m) {
upb_inttable_compact(&m->itof);
upb_msg_iter j;
uint32_t selector = UPB_STATIC_SELECTOR_COUNT;
for(upb_msg_begin(&j, m); !upb_msg_done(&j); upb_msg_next(&j)) {
upb_fielddef *f = upb_msg_iter_field(&j);
assert(f->msgdef == m);
if (!upb_validate_field(f, s)) goto err;
f->selector_base = selector + upb_handlers_selectorbaseoffset(f);
selector += upb_handlers_selectorcount(f);
}
m->selector_count = selector;
} else if (e) {
upb_inttable_compact(&e->iton);
}
}
// Validation all passed; freeze the defs.
return upb_refcounted_freeze((upb_refcounted*const*)defs, n, s);
err:
for (int i = 0; i < n; i++) {
defs[i]->came_from_user = false;
}
assert(!upb_ok(s));
return false;
}
bool upb_def_freeze(upb_def *const* defs, int n, upb_status *s) {
// First perform validation, in two passes so we can check that we have a
// transitive closure without needing to search.
for (int i = 0; i < n; i++) {
upb_def *def = defs[i];
if (upb_def_isfrozen(def)) {
// Could relax this requirement if it's annoying.
upb_status_seterrmsg(s, "def is already frozen");
goto err;
} else if (def->type == UPB_DEF_FIELD) {
upb_status_seterrmsg(s, "standalone fielddefs can not be frozen");
goto err;
} else {
// Set now to detect transitive closure in the second pass.
def->came_from_user = true;
}
}
// Second pass of validation. Also assign selector bases and indexes, and
// compact tables.
for (int i = 0; i < n; i++) {
upb_msgdef *m = upb_dyncast_msgdef_mutable(defs[i]);
upb_enumdef *e = upb_dyncast_enumdef_mutable(defs[i]);
if (m) {
upb_inttable_compact(&m->itof);
assign_msg_indices(m, s);
} else if (e) {
upb_inttable_compact(&e->iton);
}
}
// Def graph contains FieldDefs between each MessageDef, so double the limit.
int maxdepth = UPB_MAX_MESSAGE_DEPTH * 2;
// Validation all passed; freeze the defs.
return upb_refcounted_freeze((upb_refcounted * const *)defs, n, s, maxdepth);
err:
for (int i = 0; i < n; i++) {
defs[i]->came_from_user = false;
}
assert(!upb_ok(s));
return false;
}
const upb_handlers *upb_handlers_newfrozen(const upb_msgdef *m,
const void *owner,
upb_handlers_callback *callback,
void *closure) {
dfs_state state;
state.callback = callback;
state.closure = closure;
if (!upb_inttable_init(&state.tab, UPB_CTYPE_PTR)) return NULL;
upb_handlers *ret = newformsg(m, owner, &state);
upb_inttable_uninit(&state.tab);
if (!ret) return NULL;
upb_refcounted *r = UPB_UPCAST(ret);
bool ok = upb_refcounted_freeze(&r, 1, NULL, UPB_MAX_HANDLER_DEPTH);
UPB_ASSERT_VAR(ok, ok);
return ret;
}
bool upb_handlers_freeze(upb_handlers *const*handlers, int n, upb_status *s) {
// TODO: verify we have a transitive closure.
for (int i = 0; i < n; i++) {
upb_handlers *h = handlers[i];
if (!upb_ok(&h->status_)) {
upb_status_seterrf(s, "handlers for message %s had error status: %s",
upb_msgdef_fullname(upb_handlers_msgdef(h)),
upb_status_errmsg(&h->status_));
return false;
}
// Check that there are no closure mismatches due to missing Start* handlers
// or subhandlers with different type-level types.
upb_msg_iter j;
for(upb_msg_begin(&j, h->msg); !upb_msg_done(&j); upb_msg_next(&j)) {
const upb_fielddef *f = upb_msg_iter_field(&j);
if (upb_fielddef_isseq(f)) {
if (!checkstart(h, f, UPB_HANDLER_STARTSEQ, s))
return false;
}
if (upb_fielddef_isstring(f)) {
if (!checkstart(h, f, UPB_HANDLER_STARTSTR, s))
return false;
}
if (upb_fielddef_issubmsg(f)) {
bool hashandler = false;
if (upb_handlers_gethandler(h, getsel(h, f, UPB_HANDLER_STARTSUBMSG)) ||
upb_handlers_gethandler(h, getsel(h, f, UPB_HANDLER_ENDSUBMSG))) {
hashandler = true;
}
if (upb_fielddef_isseq(f) &&
(upb_handlers_gethandler(h, getsel(h, f, UPB_HANDLER_STARTSEQ)) ||
upb_handlers_gethandler(h, getsel(h, f, UPB_HANDLER_ENDSEQ)))) {
hashandler = true;
}
if (hashandler && !upb_handlers_getsubhandlers(h, f)) {
// For now we add an empty subhandlers in this case. It makes the
// decoder code generator simpler, because it only has to handle two
// cases (submessage has handlers or not) as opposed to three
// (submessage has handlers in enclosing message but no subhandlers).
//
// This makes parsing less efficient in the case that we want to
// notice a submessage but skip its contents (like if we're testing
// for submessage presence or counting the number of repeated
// submessages). In this case we will end up parsing the submessage
// field by field and throwing away the results for each, instead of
// skipping the whole delimited thing at once. If this is an issue we
// can revisit it, but do remember that this only arises when you have
// handlers (startseq/startsubmsg/endsubmsg/endseq) set for the
// submessage but no subhandlers. The uses cases for this are
// limited.
upb_handlers *sub = upb_handlers_new(upb_fielddef_msgsubdef(f), &sub);
upb_handlers_setsubhandlers(h, f, sub);
upb_handlers_unref(sub, &sub);
}
// TODO(haberman): check type of submessage.
// This is slightly tricky; also consider whether we should check that
// they match at setsubhandlers time.
}
}
}
if (!upb_refcounted_freeze((upb_refcounted*const*)handlers, n, s,
UPB_MAX_HANDLER_DEPTH)) {
return false;
}
return true;
}
