bool upb_fielddef_resolvedefault(upb_fielddef *f) { if (!upb_fielddef_default_is_symbolic(f)) return true; upb_byteregion *bytes = upb_value_getbyteregion(f->defaultval); const upb_enumdef *e = upb_downcast_enumdef(upb_fielddef_subdef(f)); assert(bytes); // Points to either a real default or the empty string. assert(e); if (upb_byteregion_len(bytes) == 0) { // The "default default" for an enum is the first defined value. upb_value_setint32(&f->defaultval, e->defaultval); } else { size_t len; int32_t val = 0; // ptr is guaranteed to be NULL-terminated because the byteregion was // created with upb_byteregion_newl(). const char *ptr = upb_byteregion_getptr( bytes, upb_byteregion_startofs(bytes), &len); assert(len == upb_byteregion_len(bytes)); // Should all be in one chunk if (!upb_enumdef_ntoi(e, ptr, &val)) { return false; } upb_value_setint32(&f->defaultval, val); } f->default_is_string = false; upb_byteregion_free(bytes); return true; }
static bool upb_fielddef_resolve(upb_fielddef *f, upb_def *def, upb_status *s) { assert(upb_dyncast_unresolveddef(f->def)); upb_def_unref(f->def); f->def = def; if (f->type == UPB_TYPE(ENUM) && f->default_is_symbolic) { // Resolve the enum's default from a string to an integer. upb_byteregion *bytes = upb_value_getbyteregion(f->defaultval); assert(bytes); // Points to either a real default or the empty string. upb_enumdef *e = upb_downcast_enumdef(f->def); int32_t val = 0; // Could do a sanity check that the default value does not have embedded // NULLs. if (upb_byteregion_len(bytes) == 0) { upb_value_setint32(&f->defaultval, e->defaultval); } else { size_t len; // ptr is guaranteed to be NULL-terminated because the byteregion was // created with upb_byteregion_newl(). const char *ptr = upb_byteregion_getptr(bytes, 0, &len); assert(len == upb_byteregion_len(bytes)); // Should all be in one chunk. bool success = upb_enumdef_ntoi(e, ptr, &val); if (!success) { upb_status_seterrf( s, "Default enum value (%s) is not a member of the enum", ptr); return false; } upb_value_setint32(&f->defaultval, val); } upb_byteregion_free(bytes); } return true; }
void upb_fielddef_setdefaultstr(upb_fielddef *f, const void *str, size_t len) { assert(upb_isstring(f) || f->type == UPB_TYPE(ENUM)); upb_byteregion *bytes = upb_value_getbyteregion(f->defaultval); assert(bytes); upb_byteregion_free(bytes); upb_value_setbyteregion(&f->defaultval, upb_byteregion_newl(str, len)); f->default_is_symbolic = true; }
void upb_fielddef_setdefault(upb_fielddef *f, upb_value value) { assert(!upb_fielddef_isfrozen(f)); assert(!upb_fielddef_isstring(f) && !upb_fielddef_issubmsg(f)); if (f->default_is_string) { upb_byteregion *bytes = upb_value_getbyteregion(f->defaultval); assert(bytes); upb_byteregion_free(bytes); } f->defaultval = value; f->default_is_string = false; }
static void _upb_stdmsg_setstr(void *_dst, upb_value src) { upb_stdarray **dstp = _dst; upb_stdarray *dst = *dstp; if (!dst) { dst = malloc(sizeof(*dst)); dst->size = 0; dst->ptr = NULL; *dstp = dst; } dst->len = 0; const upb_byteregion *bytes = upb_value_getbyteregion(src); uint32_t len = upb_byteregion_len(bytes); if (len > dst->size) { dst->size = len; dst->ptr = realloc(dst->ptr, dst->size); } dst->len = len; upb_byteregion_copyall(bytes, dst->ptr); }
bool upb_fielddef_setdefaultstr(upb_fielddef *f, const void *str, size_t len) { assert(upb_fielddef_isstring(f) || f->type_ == UPB_TYPE(ENUM)); if (f->type_ == UPB_TYPE(ENUM) && !upb_isident(str, len, false)) return false; if (f->default_is_string) { upb_byteregion *bytes = upb_value_getbyteregion(f->defaultval); assert(bytes); upb_byteregion_free(bytes); } else { assert(f->type_ == UPB_TYPE(ENUM)); } upb_byteregion *r = upb_byteregion_newl(str, len); upb_value_setbyteregion(&f->defaultval, r); upb_bytesuccess_t ret = upb_byteregion_fetch(r); UPB_ASSERT_VAR(ret, ret == (len == 0 ? UPB_BYTE_EOF : UPB_BYTE_OK)); assert(upb_byteregion_available(r, 0) == upb_byteregion_len(r)); f->default_is_string = true; return true; }
upb_fielddef *upb_fielddef_dup(const upb_fielddef *f, const void *owner) { upb_fielddef *newf = upb_fielddef_new(owner); if (!newf) return NULL; upb_fielddef_settype(newf, upb_fielddef_type(f)); upb_fielddef_setlabel(newf, upb_fielddef_label(f)); upb_fielddef_setnumber(newf, upb_fielddef_number(f)); upb_fielddef_setname(newf, upb_fielddef_name(f)); if (f->default_is_string) { upb_byteregion *r = upb_value_getbyteregion(upb_fielddef_default(f)); size_t len; const char *ptr = upb_byteregion_getptr(r, 0, &len); assert(len == upb_byteregion_len(r)); upb_fielddef_setdefaultstr(newf, ptr, len); } else { upb_fielddef_setdefault(newf, upb_fielddef_default(f)); } const char *srcname; if (f->subdef_is_symbolic) { srcname = f->sub.name; // Might be NULL. } else { srcname = f->sub.def ? upb_def_fullname(f->sub.def) : NULL; } if (srcname) { char *newname = malloc(strlen(f->sub.def->fullname) + 2); if (!newname) { upb_fielddef_unref(newf, owner); return NULL; } strcpy(newname, "."); strcat(newname, f->sub.def->fullname); upb_fielddef_setsubdefname(newf, newname); free(newname); } return newf; }
static void upb_fielddef_uninit_default(upb_fielddef *f) { if (upb_isstring(f) || f->default_is_symbolic) { upb_byteregion_free(upb_value_getbyteregion(f->defaultval)); } }
static void upb_fielddef_uninit_default(upb_fielddef *f) { if (f->default_is_string) upb_byteregion_free(upb_value_getbyteregion(f->defaultval)); }